|
| void | addTriangle (triangle *S, int num) |
| | Adds triangles to the internal list of triangles.
|
| void | binRead (std::ifstream &is) |
| | Reads object from binary file represented by istream is.
|
| void | binWrite (std::ofstream &os) |
| | Writes object to binary file represented by ostream os.
|
| maths::Vector< double > | calcCoM () |
| | calculates center of mass (needed by setCenter2CoM () )
|
| void | clearS () |
| | clears the internal list of triangles
|
| maths::Matrix< double > | computeInertia () |
| | Calculates the inertia of the object.
|
| int | createsurface () |
| | Creates a list of triangles, which describes the surface, from standard input.
|
| int | createsurface (std::string FName) |
| | reads the triangle list from a file (proprietary file format, SRF)
|
| void | exportSRF (std::string FName) |
| | export triangle list to proprietary file format SRF
|
| int | getCurrentIndex () |
| | Returns the index of the triangle that was last hit.
|
| std::string | getFilename () |
| | returns the current file name
|
| void | getMinMax (double &min, double &max) |
| | calculates center of mass
|
| triangle & | getTriangle (int i) |
| | Returns the i-th triangle in the internal triangle list.
|
| int | importBinSTL (std::string FName) |
| | import triangle list from binary STL-file
|
| void | initBounds (maths::Vector< double > &pul, maths::Vector< double > &por) |
| | Calculates the bounding box (=circumferent cuboid) but without rotation. The cuboid is represented by the upper right corner (por) and the lower left corner (pul).
|
| void | initQuad () |
| | Boundaries of the circumferent cuboid is calculated. The cuboid is represented by the upper right corner (por) and the lower left corner (pul). Used only for inelastic scattering.
|
| bool | isInside (const maths::Vector< double > &p) |
| | checks if point P is inside the object
|
| bool | next (const maths::Vector< double > &r, const maths::Vector< double > &k, maths::Vector< double > &p) |
| | Calculates the intersection point between a straight line and the surface object. The straight line is represented by a point on the line and its direction.
|
| maths::Vector< double > | norm (const maths::Vector< double > &P) |
| | Surface normal at point P (There is no check, if P is on the surface. This function is used for internal purposes)
|
| surface | nosurface () |
| | returns copy of the object without triangles
|
| surface & | operator= (const surface &) |
| void | scale (double sf) |
| | scale the lengths of all triangles
|
| void | setCenter (maths::Vector< double > P) |
| void | setCenter2CoM () |
| | Sets the Position to the center of mass (CoM)
|
| void | setFilename (std::string FName) |
| void | setPos (double x, double y, double z) |
| | Set position of the object to a position vector represented by its components x,y and z.
|
| void | setPos (maths::Vector< double > r) |
| | Set position of the object to r.
|
| void | setr0 (double r0) |
| | sets the radius of the calculation sphere (necessary only if this class is used outside Scene)
|
| | surface () |
| | surface (const maths::Vector< double > &P, std::complex< double > n, const maths::Matrix< std::complex< double > > alpha=maths::CUNITY, const maths::Vector< double > Ex=GOAT::maths::ex, const maths::Vector< double > Ey=GOAT::maths::ey, const maths::Vector< double > Ez=GOAT::maths::ez) |
| | surface (const maths::Vector< double > &P, std::complex< double > n, int num, triangle *list, const maths::Matrix< std::complex< double > > alpha=maths::CUNITY, const maths::Vector< double > Ex=maths::ex, const maths::Vector< double > Ey=maths::ey, const maths::Vector< double > Ez=maths::ez) |
| | surface (const surface &Su) |
| | surface (maths::Vector< double > Oh) |
| | Empty surface object with position Oh.
|
| double | volume () |
| | Calculates the volume of the object.
|
| std::complex< double > | getn () |
| | returns refractive index for inelastic (RRT) calculation
|
| std::complex< double > | getninel () |
| | returns refractive index
|
| bool | getVisible () |
| | show the visiblity state (used in GOATvis)
|
| bool | isActive () |
| | returns true if the object should be considered for inelastic calculation
|
| bool | isOutsideWorld () |
| | Test if bounding box is (partly) outside the calculation space.
|
| | ObjectShape () |
| | ObjectShape (const maths::Vector< double > &P, std::complex< double > n, GOAT::maths::Matrix< std::complex< double > > alpha, const maths::Vector< double > &Ex=maths::ex, const maths::Vector< double > &Ey=maths::ey, const maths::Vector< double > &Ez=maths::ez, const int type=-1) |
| | Constructor, as template for all derived classes.
|
| | ObjectShape (const ObjectShape &F) |
| void | rotate (maths::Vector< double > A, double phi) |
| | sets the matrix for the transformation between object's coordinate system and outer coordinate system, A: rotation axis, phi: angle for rotation around A
|
| void | scale (double sf) |
| | sets scaling of the shape by the factor sf
|
| void | setActive (bool active) |
| | sets flag if the object is inelastic active, i.e. it will be considered for inelastic calculation
|
| void | setAlpha (double Alpha) |
| | sets rotation angle around x-axis
|
| void | setBeta (double Beta) |
| | sets rotation angle around y-axis
|
| void | setCenter (maths::Vector< double > P) |
| | sets Center to P (check, if function is necessary)
|
| void | setCenter2CoM () |
| | Calculates the center of mass (CoM) and sets the object's reference point to the CoM.
|
| void | setGamma (double Gamma) |
| | sets rotation angle around z-axis
|
| void | setMatrix (double alpha, double beta, double gamma) |
| | sets the matrix for the transformation between object's coordinate system and outer coordinate system, alpha, beta, gamma: angles (rotation around x-, y- and z-axis) to calculate transformation matrix
|
| void | setMatrix (maths::Matrix< double > H) |
| | sets the matrix for the transformation between object's coordinate system and outer coordinate system, H: transformation matrix
|
| void | setn (std::complex< double > n) |
| | sets refractive index
|
| void | setninel (std::complex< double > ninel) |
| | sets refractive index for inelastic (RRT) calculation
|
| void | setPolMatrix (maths::Matrix< std::complex< double > >alpha) |
| | sets polarisability matrix
|
| void | setVisible (bool visible) |
| | set visiblity (used in GOATvis)
|
| int | Type () |
| | returns the object's type
|
|
| int | currentIndex |
| | Index of the triangle that was last hit.
|
| maths::Vector< double > | currentnorm |
| | Normal vector of the triangle that was last hit.
|
| int | filetype =OBJECTSHAPE_SURFACE_FILETYPE_NONE |
| | type of the file connected with this surface object
|
| std::string | FName |
| | File name (used to save the internal triangle list)
|
| int | numTriangles = 0 |
| | number of triangles
|
| triangle * | S |
| | list of all triangles
|
| bool | Active |
| | should the object be considered for inelastic (RRT) calculations?
|
| maths::Matrix< std::complex< double > > | alpha |
| | polarisability matrix
|
| maths::Vector< double > | e [3] |
| | unity vectors, describing the directions of the local coordinate system
|
| double | Ealpha |
| double | Ebeta |
| double | Egamma |
| | angles through which the object was rotated (around the x- (Ealpha), then the y- (Ebeta) and finally the z-axis (Egamma))
|
| maths::Matrix< double > | H |
| std::complex< double > | n |
| | refractive index of the object
|
| std::function< std::complex< double >(double)> | nfunc |
| NFUNCTYPE | nfuncType =NFUNCTYPE::vacuum |
| std::complex< double > | ninel |
| | refractive index of the object, used for inelastic (RRT) calculation
|
| maths::Vector< double > | P |
| | position of the object
|
| maths::Vector< double > | por |
| | corners of the circumferent cuboid (lower left corner and upper right corner)
|
| maths::Vector< double > | pul |
| maths::Matrix< double > | R |
| | matrices for the transformation in the local coordinate system (H) and back to the calculation system (R)
|
| double | r0 |
| | radius of the calculation sphere
|
| double | rho |
| | mass density in \( kg/m^3 \)
|
| double | sf =1 |
| | scaling factor, it is used to scale the shape of the object
|
| int | type |
| | type of the object
|
| bool | visible =true |
This class represents objects those surface is described by triangles.
The surface class represents a volume object, whose surface is described by triangles. This method is often used by CAD programs, therefore a function is provided to import binary stl files. The surface class has also a simple proprietary file format: The first entry is the number of triangles in the file. Than, the information about the triangles follows. Each triangle is described by the components of the corner vectors. Therefore the file looks like: \(\newline
\begin{array}{ccccccccc}
\text{<number of triangles>} & & & & & & & & \\
\text{<number of triangles>} & & & & & & & & \\
x_{00} & y_{00} & z_{00} & x_{01} & y_{01} & z_{01} & x_{02} & y_{02} & z_{02} \\
x_{10} & y_{10} & z_{10} & x_{11} & y_{11} & z_{11} & x_{12} & y_{12} & z_{12} \\
\vdots & \vdots & & & & & & &
\end{array}
\) The intersection points are calculated with help of an octree procedure to enhance the calculation speed for the intersection point finding.
Definition at line 55 of file surface.h.
