SOFA API  27534f6d
Open source framework for multi-physics simuation
sofa::component::topology Namespace Reference

Classes

class  BasicArrayInterface
 A class used as an interface with an array : Useful to compute geometric information on each edge in an efficient way. More...
 
class  CenterPointTopologicalMapping
 
class  CubeTopology
 
class  CylinderGridTopology
 Define a cylinder grid topology Paramenters are its. More...
 
class  DynamicSparseGridGeometryAlgorithms
 
class  DynamicSparseGridTopologyAlgorithms
 
class  DynamicSparseGridTopologyContainer
 
class  DynamicSparseGridTopologyModifier
 
class  Edge2QuadTopologicalMapping
 
class  EdgeData
 
class  EdgeSetGeometryAlgorithms
 forward declaration to avoid adding includes in .h More...
 
class  EdgeSetTopologyAlgorithms
 
class  EdgeSetTopologyContainer
 
class  EdgeSetTopologyModifier
 
class  EdgeSparseData
 
class  EdgeSubsetData
 
class  GridTopology
 Define a regular grid topology, with no spatial information. More...
 
class  Hexa2QuadTopologicalMapping
 
class  Hexa2TetraTopologicalMapping
 
class  HexahedronData
 
class  HexahedronSetGeometryAlgorithms
 
class  HexahedronSetTopologyAlgorithms
 
class  HexahedronSetTopologyContainer
 
class  HexahedronSetTopologyModifier
 
class  HexahedronSparseData
 
class  HexahedronSubsetData
 
class  IdentityTopologicalMapping
 
class  Mesh2PointTopologicalMapping
 
class  MeshTopology
 
class  MultilevelHexahedronSetTopologyContainer
 
class  MultilevelModification
 
class  NumericalIntegrationDescriptor
 Cross product for 3-elements vectors. More...
 
class  PointData
 
class  PointSetGeometryAlgorithms
 
class  PointSetTopologyAlgorithms
 
class  PointSetTopologyContainer
 
class  PointSetTopologyModifier
 
class  PointSparseData
 
class  PointSubsetData
 
class  Quad2TriangleTopologicalMapping
 
class  QuadData
 
class  QuadSetGeometryAlgorithms
 
class  QuadSetTopologyAlgorithms
 
class  QuadSetTopologyContainer
 
class  QuadSetTopologyModifier
 
class  QuadSparseData
 
class  QuadSubsetData
 
class  RegularGridTopology
 
class  SimpleTesselatedHexaTopologicalMapping
 
class  SimpleTesselatedTetraTopologicalMapping
 
class  SparseGridMultipleTopology
 
class  SparseGridRamificationTopology
 a SparseGridTopology where each resulting cube contains only one independant connexe component (nodes can be multiplied by using virtual nodes) More...
 
class  SparseGridTopology
 
class  SphereGridTopology
 Define a sphere grid topology Paramenters are its. More...
 
class  SphereQuadTopology
 
class  SubsetTopologicalMapping
 
class  Tetra2TriangleTopologicalMapping
 
class  TetrahedronData
 
class  TetrahedronSetGeometryAlgorithms
 
class  TetrahedronSetTopologyAlgorithms
 
class  TetrahedronSetTopologyContainer
 
class  TetrahedronSetTopologyModifier
 
class  TetrahedronSparseData
 
class  TetrahedronSubsetData
 
class  TopologyDataHandler
 A class for storing topology related data. Automatically manages topology changes. More...
 
class  TopologyDataImpl
 A class for storing topology related data. Automatically manages topology changes. More...
 
class  TopologyEngineImpl
 
class  TopologySparseDataHandler
 A class for storing Edge related data. Automatically manages topology changes. More...
 
class  TopologySparseDataImpl
 
class  TopologySubsetDataHandler
 A class for storing Edge related data. Automatically manages topology changes. More...
 
class  TopologySubsetDataImpl
 A class for storing element related data. Automatically manages topology changes. More...
 
class  Triangle2EdgeTopologicalMapping
 
class  TriangleData
 
class  TriangleSetGeometryAlgorithms
 
class  TriangleSetTopologyAlgorithms
 
class  TriangleSetTopologyContainer
 : Object that stores a set of triangles and provides access to each triangle and its edges and vertices More...
 
class  TriangleSetTopologyModifier
 
class  TriangleSparseData
 
class  TriangleSubsetData
 

Typedefs

typedef core::topology::BaseMeshTopology::Triangle Triangle
 
typedef BaseMeshTopology In
 Input Topology. More...
 
typedef BaseMeshTopology Out
 Output Topology. More...
 

Enumerations

enum  Grid_dimension { Grid_dimension::GRID_nullptr = 0, Grid_dimension::GRID_1D, Grid_dimension::GRID_2D, Grid_dimension::GRID_3D }
 

Functions

template<class T >
make_unique (const T &v)
 
template<class T , class M >
apply_map (const T &v, const M &m)
 
template<class Real >
Real areaProduct (const sofa::defaulttype::Vec< 3, Real > &a, const sofa::defaulttype::Vec< 3, Real > &b)
 Cross product for 3-elements Vectors. More...
 
template<class Real >
Real areaProduct (const defaulttype::Vec< 2, Real > &a, const defaulttype::Vec< 2, Real > &b)
 area for 2-elements sofa::helper::vectors. More...
 
template<class Real >
Real areaProduct (const defaulttype::Vec< 1, Real > &, const defaulttype::Vec< 1, Real > &)
 area invalid for 1-elements sofa::helper::vectors. More...
 
template<class Real >
defaulttype::Vec< 2, Realortho (const defaulttype::Vec< 2, Real > &in)
 orthogonal of a 2D vector More...
 
template<class Real >
defaulttype::Vec< 2, Realcross (const defaulttype::Vec< 2, Real > &, const defaulttype::Vec< 2, Real > &)
 cross product for 2-elements sofa::helper::vectors. More...
 
template<class Real >
defaulttype::Vec< 1, Realcross (const defaulttype::Vec< 1, Real > &, const defaulttype::Vec< 1, Real > &)
 cross product for 1-elements sofa::helper::vectors. More...
 
template<typename real >
real tripleProduct (const sofa::defaulttype::Vec< 3, real > &a, const sofa::defaulttype::Vec< 3, real > &b, const sofa::defaulttype::Vec< 3, real > &c)
 Volume (triple product) for 3-elements sofa::helper::vectors. More...
 
template<typename real >
real tripleProduct (const sofa::defaulttype::Vec< 2, real > &, const sofa::defaulttype::Vec< 2, real > &, const sofa::defaulttype::Vec< 2, real > &)
 Volume invalid for 2-elements sofa::helper::vectors. More...
 
template<typename real >
real tripleProduct (const sofa::defaulttype::Vec< 1, real > &, const sofa::defaulttype::Vec< 1, real > &, const sofa::defaulttype::Vec< 1, real > &)
 Volume invalid for 1-elements sofa::helper::vectors. More...
 
size_t lfactorial (size_t n)
 this function is only valid for small value of n which should be sufficient for a regular use. More...
 
template<class Real >
Real binomial (const size_t p, const size_t q)
 
template<class Real >
Real multinomial (const size_t n, helper::vector< unsigned char > valArray)
 
template<size_t N, class Real >
Real multinomial (const size_t n, const sofa::defaulttype::Vec< N, unsigned char > tbi)
 
template<size_t N, class Real >
Real multinomialVector (const sofa::helper::vector< sofa::defaulttype::Vec< N, unsigned char > > tbiArray)
 
template<size_t N, class Real >
Real binomialVector (const sofa::defaulttype::Vec< N, unsigned char > tbi1, const sofa::defaulttype::Vec< N, unsigned char > tbi2)
 
template<class Vec >
bool is_point_on_edge (const Vec &p, const Vec &a, const Vec &b)
 
template<class Coord >
bool is_point_in_quad (const Coord &p, const Coord &a, const Coord &b, const Coord &c, const Coord &d)
 
void snapping_test_quad (double epsilon, double alpha0, double alpha1, double alpha2, double alpha3, bool &is_snap_0, bool &is_snap_1, bool &is_snap_2, bool &is_snap_3)
 
template<class Real >
Real areaProduct (const defaulttype::Vec< 3, Real > &a, const defaulttype::Vec< 3, Real > &b)
 
void SOFA_BASE_TOPOLOGY_API snapping_test_triangle (double epsilon, double alpha0, double alpha1, double alpha2, bool &is_snap_0, bool &is_snap_1, bool &is_snap_2)
 
void SOFA_BASE_TOPOLOGY_API snapping_test_edge (double epsilon, double alpha0, double alpha1, bool &is_snap_0, bool &is_snap_1)
 
template<class Real >
bool is_point_in_triangle (const sofa::defaulttype::Vec< 3, Real > &p, const sofa::defaulttype::Vec< 3, Real > &a, const sofa::defaulttype::Vec< 3, Real > &b, const sofa::defaulttype::Vec< 3, Real > &c)
 
template<class Real >
bool is_point_in_halfplane (const sofa::defaulttype::Vec< 3, Real > &p, unsigned int e0, unsigned int e1, const sofa::defaulttype::Vec< 3, Real > &a, const sofa::defaulttype::Vec< 3, Real > &b, const sofa::defaulttype::Vec< 3, Real > &c, unsigned int ind_p0, unsigned int ind_p1, unsigned int ind_p2)
 Test if a point p is in the right halfplane. More...
 

Variables

int CubeTopologyClass
 
int CylinderGridTopologyClass
 
int SphereGridTopologyClass
 
int SphereQuadTopologyClass
 
int DynamicSparseGridGeometryAlgorithmsClass
 
template class SOFA_SOFANONUNIFORMFEM_API DynamicSparseGridGeometryAlgorithms< Vec3Types >
 
template class SOFA_SOFANONUNIFORMFEM_API DynamicSparseGridGeometryAlgorithms< Vec2Types >
 
template class SOFA_SOFANONUNIFORMFEM_API DynamicSparseGridGeometryAlgorithms< Vec1Types >
 
int DynamicSparseGridTopologyAlgorithmsClass
 
int DynamicSparseGridTopologyContainerClass
 
int DynamicSparseGridTopologyModifierClass
 
int MultilevelHexahedronSetTopologyContainerClass
 
int SparseGridMultipleTopologyClass
 
int SparseGridRamificationTopologyClass
 
int CenterPointTopologicalMappingClass
 
int Edge2QuadTopologicalMappingClass
 
int Hexa2QuadTopologicalMappingClass
 
int Hexa2TetraTopologicalMappingClass
 
int IdentityTopologicalMappingClass
 
int Mesh2PointTopologicalMappingClass
 
int Quad2TriangleTopologicalMappingClass
 
int SimpleTesselatedHexaTopologicalMappingClass
 
int SimpleTesselatedTetraTopologicalMappingClass
 
int SubsetTopologicalMappingClass
 
int Tetra2TriangleTopologicalMappingClass
 
int Triangle2EdgeTopologicalMappingClass
 
int EdgeSetGeometryAlgorithmsClass
 
template class SOFA_BASE_TOPOLOGY_API EdgeSetGeometryAlgorithms< Vec3Types >
 
template class SOFA_BASE_TOPOLOGY_API EdgeSetGeometryAlgorithms< Vec2Types >
 
template class SOFA_BASE_TOPOLOGY_API EdgeSetGeometryAlgorithms< Vec1Types >
 
template class SOFA_BASE_TOPOLOGY_API EdgeSetGeometryAlgorithms< Rigid3Types >
 
template class SOFA_BASE_TOPOLOGY_API EdgeSetGeometryAlgorithms< Rigid2Types >
 
int EdgeSetTopologyAlgorithmsClass
 
template class SOFA_BASE_TOPOLOGY_API EdgeSetTopologyAlgorithms< Vec3Types >
 
template class SOFA_BASE_TOPOLOGY_API EdgeSetTopologyAlgorithms< Vec2Types >
 
template class SOFA_BASE_TOPOLOGY_API EdgeSetTopologyAlgorithms< Vec1Types >
 
template class SOFA_BASE_TOPOLOGY_API EdgeSetTopologyAlgorithms< Rigid3Types >
 
template class SOFA_BASE_TOPOLOGY_API EdgeSetTopologyAlgorithms< Rigid2Types >
 
int EdgeSetTopologyContainerClass
 
int EdgeSetTopologyModifierClass
 
int GridTopologyClass
 
int HexahedronSetGeometryAlgorithmsClass
 
template class SOFA_BASE_TOPOLOGY_API HexahedronSetGeometryAlgorithms< Vec3Types >
 
template class SOFA_BASE_TOPOLOGY_API HexahedronSetGeometryAlgorithms< Vec2Types >
 
template class SOFA_BASE_TOPOLOGY_API HexahedronSetGeometryAlgorithms< Vec1Types >
 
const unsigned int verticesInHexahedronArray [2][2][2] = {{{0,4},{3,7}},{{1,5},{2,6}}}
 
int HexahedronSetTopologyAlgorithmsClass
 
template class SOFA_BASE_TOPOLOGY_API HexahedronSetTopologyAlgorithms< Vec3Types >
 
template class SOFA_BASE_TOPOLOGY_API HexahedronSetTopologyAlgorithms< Vec2Types >
 
template class SOFA_BASE_TOPOLOGY_API HexahedronSetTopologyAlgorithms< Vec1Types >
 
int HexahedronSetTopologyContainerClass
 
const unsigned int edgesInHexahedronArray [12][2] = {{0,1},{0,3},{0,4},{1,2},{1,5},{2,3},{2,6},{3,7},{4,5},{4,7},{5,6},{6,7}}
 
const unsigned int quadsInHexahedronArray [6][4] = {{0,1,2,3}, {4,7,6,5}, {1,0,4,5},{1,5,6,2}, {2,6,7,3}, {0,3,7,4}}
 convention quads in hexa (orientation interior) More...
 
int HexahedronSetTopologyModifierClass
 
int MeshTopologyClass
 
template class SOFA_BASE_TOPOLOGY_API NumericalIntegrationDescriptor< double, 4 >
 
template class SOFA_BASE_TOPOLOGY_API NumericalIntegrationDescriptor< double, 3 >
 
template class SOFA_BASE_TOPOLOGY_API NumericalIntegrationDescriptor< double, 1 >
 
int PointSetGeometryAlgorithmsClass
 
template class SOFA_BASE_TOPOLOGY_API PointSetGeometryAlgorithms< Vec3Types >
 
template class SOFA_BASE_TOPOLOGY_API PointSetGeometryAlgorithms< Vec2Types >
 
template class SOFA_BASE_TOPOLOGY_API PointSetGeometryAlgorithms< Vec1Types >
 
template class SOFA_BASE_TOPOLOGY_API PointSetGeometryAlgorithms< Rigid3Types >
 
template class SOFA_BASE_TOPOLOGY_API PointSetGeometryAlgorithms< Rigid2Types >
 
int PointSetTopologyAlgorithmsClass
 
template class SOFA_BASE_TOPOLOGY_API PointSetTopologyAlgorithms< Vec3Types >
 
template class SOFA_BASE_TOPOLOGY_API PointSetTopologyAlgorithms< Vec2Types >
 
template class SOFA_BASE_TOPOLOGY_API PointSetTopologyAlgorithms< Vec1Types >
 
template class SOFA_BASE_TOPOLOGY_API PointSetTopologyAlgorithms< Rigid3Types >
 
template class SOFA_BASE_TOPOLOGY_API PointSetTopologyAlgorithms< Rigid2Types >
 
int PointSetTopologyContainerClass
 
int PointSetTopologyModifierClass
 
int QuadSetGeometryAlgorithmsClass
 
template class SOFA_BASE_TOPOLOGY_API QuadSetGeometryAlgorithms< Vec3Types >
 
template class SOFA_BASE_TOPOLOGY_API QuadSetGeometryAlgorithms< Vec2Types >
 
template class SOFA_BASE_TOPOLOGY_API QuadSetGeometryAlgorithms< Vec1Types >
 
int QuadSetTopologyAlgorithmsClass
 
template class SOFA_BASE_TOPOLOGY_API QuadSetTopologyAlgorithms< Vec3Types >
 
template class SOFA_BASE_TOPOLOGY_API QuadSetTopologyAlgorithms< Vec2Types >
 
template class SOFA_BASE_TOPOLOGY_API QuadSetTopologyAlgorithms< Vec1Types >
 
int QuadSetTopologyContainerClass
 
int QuadSetTopologyModifierClass
 
int RegularGridTopologyClass
 
int SparseGridTopologyClass
 
int TetrahedronSetGeometryAlgorithmsClass
 
template class SOFA_BASE_TOPOLOGY_API TetrahedronSetGeometryAlgorithms< Vec3Types >
 
template class SOFA_BASE_TOPOLOGY_API TetrahedronSetGeometryAlgorithms< Vec2Types >
 
template class SOFA_BASE_TOPOLOGY_API TetrahedronSetGeometryAlgorithms< Vec1Types >
 
const unsigned int edgesInTetrahedronArray [6][2] = {{0,1}, {0,2}, {0,3}, {1,2}, {1,3}, {2,3}}
 
int TetrahedronSetTopologyAlgorithmsClass
 
template class SOFA_BASE_TOPOLOGY_API TetrahedronSetTopologyAlgorithms< Vec3Types >
 
template class SOFA_BASE_TOPOLOGY_API TetrahedronSetTopologyAlgorithms< Vec2Types >
 
template class SOFA_BASE_TOPOLOGY_API TetrahedronSetTopologyAlgorithms< Vec1Types >
 
int TetrahedronSetTopologyContainerClass
 
int TetrahedronSetTopologyModifierClass
 
int TriangleSetGeometryAlgorithmsClass
 
template class SOFA_BASE_TOPOLOGY_API TriangleSetGeometryAlgorithms< Vec3Types >
 
template class SOFA_BASE_TOPOLOGY_API TriangleSetGeometryAlgorithms< Vec2Types >
 
template class SOFA_BASE_TOPOLOGY_API TriangleSetGeometryAlgorithms< Vec1Types >
 
const size_t permutation3 [6][3] ={{0,1,2},{0,2,1},{1,0,2},{1,2,0},{2,0,1},{2,1,0}}
 
int TriangleSetTopologyAlgorithmsClass
 
template class SOFA_BASE_TOPOLOGY_API TriangleSetTopologyAlgorithms< Vec3Types >
 
template class SOFA_BASE_TOPOLOGY_API TriangleSetTopologyAlgorithms< Vec2Types >
 
template class SOFA_BASE_TOPOLOGY_API TriangleSetTopologyAlgorithms< Vec1Types >
 
int TriangleSetTopologyContainerClass
 
int TriangleSetTopologyModifierClass
 

Typedef Documentation

typedef core::topology::BaseMeshTopology::Triangle sofa::component::topology::Triangle

Enumeration Type Documentation

Enumerator
GRID_nullptr 
GRID_1D 
GRID_2D 
GRID_3D 

Function Documentation

template<class T , class M >
T sofa::component::topology::apply_map ( const T &  v,
const M &  m 
)
template<class Real >
Real sofa::component::topology::areaProduct ( const sofa::defaulttype::Vec< 3, Real > &  a,
const sofa::defaulttype::Vec< 3, Real > &  b 
)
inline

Cross product for 3-elements Vectors.

template<class Real >
Real sofa::component::topology::areaProduct ( const defaulttype::Vec< 2, Real > &  a,
const defaulttype::Vec< 2, Real > &  b 
)
inline

area for 2-elements sofa::helper::vectors.

template<class Real >
Real sofa::component::topology::areaProduct ( const defaulttype::Vec< 1, Real > &  ,
const defaulttype::Vec< 1, Real > &   
)
inline

area invalid for 1-elements sofa::helper::vectors.

template<class Real >
Real sofa::component::topology::areaProduct ( const defaulttype::Vec< 3, Real > &  a,
const defaulttype::Vec< 3, Real > &  b 
)
inline
template<class Real >
Real sofa::component::topology::binomial ( const size_t  p,
const size_t  q 
)
template<size_t N, class Real >
Real sofa::component::topology::binomialVector ( const sofa::defaulttype::Vec< N, unsigned char >  tbi1,
const sofa::defaulttype::Vec< N, unsigned char >  tbi2 
)
template<class Real >
defaulttype::Vec<2,Real> sofa::component::topology::cross ( const defaulttype::Vec< 2, Real > &  ,
const defaulttype::Vec< 2, Real > &   
)

cross product for 2-elements sofa::helper::vectors.

template<class Real >
defaulttype::Vec<1,Real> sofa::component::topology::cross ( const defaulttype::Vec< 1, Real > &  ,
const defaulttype::Vec< 1, Real > &   
)

cross product for 1-elements sofa::helper::vectors.

template<class Real >
bool sofa::component::topology::is_point_in_halfplane ( const sofa::defaulttype::Vec< 3, Real > &  p,
unsigned int  e0,
unsigned int  e1,
const sofa::defaulttype::Vec< 3, Real > &  a,
const sofa::defaulttype::Vec< 3, Real > &  b,
const sofa::defaulttype::Vec< 3, Real > &  c,
unsigned int  ind_p0,
unsigned int  ind_p1,
unsigned int  ind_p2 
)

Test if a point p is in the right halfplane.

template<class Coord >
bool sofa::component::topology::is_point_in_quad ( const Coord &  p,
const Coord &  a,
const Coord &  b,
const Coord &  c,
const Coord &  d 
)
template<class Real >
bool sofa::component::topology::is_point_in_triangle ( const sofa::defaulttype::Vec< 3, Real > &  p,
const sofa::defaulttype::Vec< 3, Real > &  a,
const sofa::defaulttype::Vec< 3, Real > &  b,
const sofa::defaulttype::Vec< 3, Real > &  c 
)
template<class Vec >
bool sofa::component::topology::is_point_on_edge ( const Vec &  p,
const Vec &  a,
const Vec &  b 
)
size_t sofa::component::topology::lfactorial ( size_t  n)
inline

this function is only valid for small value of n which should be sufficient for a regular use.

template<class T >
T sofa::component::topology::make_unique ( const T &  v)
template<class Real >
Real sofa::component::topology::multinomial ( const size_t  n,
helper::vector< unsigned char >  valArray 
)
template<size_t N, class Real >
Real sofa::component::topology::multinomial ( const size_t  n,
const sofa::defaulttype::Vec< N, unsigned char >  tbi 
)
template<size_t N, class Real >
Real sofa::component::topology::multinomialVector ( const sofa::helper::vector< sofa::defaulttype::Vec< N, unsigned char > >  tbiArray)
template<class Real >
defaulttype::Vec<2,Real> sofa::component::topology::ortho ( const defaulttype::Vec< 2, Real > &  in)

orthogonal of a 2D vector

void SOFA_BASE_TOPOLOGY_API sofa::component::topology::snapping_test_edge ( double  epsilon,
double  alpha0,
double  alpha1,
bool is_snap_0,
bool is_snap_1 
)
void sofa::component::topology::snapping_test_quad ( double  epsilon,
double  alpha0,
double  alpha1,
double  alpha2,
double  alpha3,
bool is_snap_0,
bool is_snap_1,
bool is_snap_2,
bool is_snap_3 
)
void SOFA_BASE_TOPOLOGY_API sofa::component::topology::snapping_test_triangle ( double  epsilon,
double  alpha0,
double  alpha1,
double  alpha2,
bool is_snap_0,
bool is_snap_1,
bool is_snap_2 
)
template<typename real >
real sofa::component::topology::tripleProduct ( const sofa::defaulttype::Vec< 3, real > &  a,
const sofa::defaulttype::Vec< 3, real > &  b,
const sofa::defaulttype::Vec< 3, real > &  c 
)
inline

Volume (triple product) for 3-elements sofa::helper::vectors.

template<typename real >
real sofa::component::topology::tripleProduct ( const sofa::defaulttype::Vec< 2, real > &  ,
const sofa::defaulttype::Vec< 2, real > &  ,
const sofa::defaulttype::Vec< 2, real > &   
)
inline

Volume invalid for 2-elements sofa::helper::vectors.

template<typename real >
real sofa::component::topology::tripleProduct ( const sofa::defaulttype::Vec< 1, real > &  ,
const sofa::defaulttype::Vec< 1, real > &  ,
const sofa::defaulttype::Vec< 1, real > &   
)
inline

Volume invalid for 1-elements sofa::helper::vectors.

Variable Documentation

int sofa::component::topology::CenterPointTopologicalMappingClass
Initial value:
= core::RegisterObject ( "" )
.add< CenterPointTopologicalMapping >()
int sofa::component::topology::CubeTopologyClass
Initial value:
= core::RegisterObject("Surface of a cube in 3D")
.add< CubeTopology >()
int sofa::component::topology::CylinderGridTopologyClass
Initial value:
= core::RegisterObject("Cylinder grid in 3D")
.addAlias("CylinderGrid")
.add< CylinderGridTopology >()
template class SOFA_SOFANONUNIFORMFEM_API sofa::component::topology::DynamicSparseGridGeometryAlgorithms< Vec1Types >
template class SOFA_SOFANONUNIFORMFEM_API sofa::component::topology::DynamicSparseGridGeometryAlgorithms< Vec2Types >
template class SOFA_SOFANONUNIFORMFEM_API sofa::component::topology::DynamicSparseGridGeometryAlgorithms< Vec3Types >
int sofa::component::topology::DynamicSparseGridGeometryAlgorithmsClass
Initial value:
= core::RegisterObject ( "Hexahedron set geometry algorithms" )
.add< DynamicSparseGridGeometryAlgorithms<Vec3Types> > ( true )
.add< DynamicSparseGridGeometryAlgorithms<Vec2Types> >()
.add< DynamicSparseGridGeometryAlgorithms<Vec1Types> >()
int sofa::component::topology::DynamicSparseGridTopologyAlgorithmsClass
Initial value:
= core::RegisterObject("Hexahedron set topology algorithms")
.add< DynamicSparseGridTopologyAlgorithms<Vec3Types> >(true)
.add< DynamicSparseGridTopologyAlgorithms<Vec2Types> >()
.add< DynamicSparseGridTopologyAlgorithms<Vec1Types> >()
int sofa::component::topology::DynamicSparseGridTopologyContainerClass
Initial value:
= core::RegisterObject ( "Hexahedron set topology container" )
.add< DynamicSparseGridTopologyContainer >()
int sofa::component::topology::DynamicSparseGridTopologyModifierClass
Initial value:
= core::RegisterObject ( "Hexahedron set topology modifier" )
.add< DynamicSparseGridTopologyModifier >()
int sofa::component::topology::Edge2QuadTopologicalMappingClass
Initial value:
= core::RegisterObject("Special case of mapping where EdgeSetTopology is converted to QuadSetTopology")
.add< Edge2QuadTopologicalMapping >()
template class SOFA_BASE_TOPOLOGY_API sofa::component::topology::EdgeSetGeometryAlgorithms< Rigid2Types >
template class SOFA_BASE_TOPOLOGY_API sofa::component::topology::EdgeSetGeometryAlgorithms< Rigid3Types >
template class SOFA_BASE_TOPOLOGY_API sofa::component::topology::EdgeSetGeometryAlgorithms< Vec1Types >
template class SOFA_BASE_TOPOLOGY_API sofa::component::topology::EdgeSetGeometryAlgorithms< Vec2Types >
template class SOFA_BASE_TOPOLOGY_API sofa::component::topology::EdgeSetGeometryAlgorithms< Vec3Types >
int sofa::component::topology::EdgeSetGeometryAlgorithmsClass
Initial value:
= core::RegisterObject("Edge set geometry algorithms")
.add< EdgeSetGeometryAlgorithms<Vec3Types> >(true)
.add< EdgeSetGeometryAlgorithms<Vec2Types> >()
.add< EdgeSetGeometryAlgorithms<Vec1Types> >()
.add< EdgeSetGeometryAlgorithms<Rigid3Types> >()
.add< EdgeSetGeometryAlgorithms<Rigid2Types> >()
template class SOFA_BASE_TOPOLOGY_API sofa::component::topology::EdgeSetTopologyAlgorithms< Rigid2Types >
template class SOFA_BASE_TOPOLOGY_API sofa::component::topology::EdgeSetTopologyAlgorithms< Rigid3Types >
template class SOFA_BASE_TOPOLOGY_API sofa::component::topology::EdgeSetTopologyAlgorithms< Vec1Types >
template class SOFA_BASE_TOPOLOGY_API sofa::component::topology::EdgeSetTopologyAlgorithms< Vec2Types >
template class SOFA_BASE_TOPOLOGY_API sofa::component::topology::EdgeSetTopologyAlgorithms< Vec3Types >
int sofa::component::topology::EdgeSetTopologyAlgorithmsClass
Initial value:
= core::RegisterObject("Edge set topology algorithms")
.add< EdgeSetTopologyAlgorithms<Vec3Types> >(true)
.add< EdgeSetTopologyAlgorithms<Vec2Types> >()
.add< EdgeSetTopologyAlgorithms<Vec1Types> >()
.add< EdgeSetTopologyAlgorithms<Rigid3Types> >()
.add< EdgeSetTopologyAlgorithms<Rigid2Types> >()
int sofa::component::topology::EdgeSetTopologyContainerClass
Initial value:
= core::RegisterObject("Edge set topology container")
.add< EdgeSetTopologyContainer >()
int sofa::component::topology::EdgeSetTopologyModifierClass
Initial value:
= core::RegisterObject("Edge set topology modifier")
.add< EdgeSetTopologyModifier >()
const unsigned int sofa::component::topology::edgesInHexahedronArray = {{0,1},{0,3},{0,4},{1,2},{1,5},{2,3},{2,6},{3,7},{4,5},{4,7},{5,6},{6,7}}
const unsigned int sofa::component::topology::edgesInTetrahedronArray = {{0,1}, {0,2}, {0,3}, {1,2}, {1,3}, {2,3}}
int sofa::component::topology::GridTopologyClass
Initial value:
= core::RegisterObject("Base class fo a regular grid in 3D")
.addAlias("Grid")
.add< GridTopology >()
int sofa::component::topology::Hexa2QuadTopologicalMappingClass
Initial value:
= core::RegisterObject("Special case of mapping where HexahedronSetTopology is converted to QuadSetTopology")
.add< Hexa2QuadTopologicalMapping >()
int sofa::component::topology::Hexa2TetraTopologicalMappingClass
Initial value:
= core::RegisterObject("Special case of mapping where HexahedronSetTopology is converted to TetrahedronSetTopology")
.add< Hexa2TetraTopologicalMapping >()
int sofa::component::topology::HexahedronSetGeometryAlgorithmsClass
Initial value:
= core::RegisterObject("Hexahedron set geometry algorithms")
.add< HexahedronSetGeometryAlgorithms<Vec3Types> >(true)
.add< HexahedronSetGeometryAlgorithms<Vec2Types> >()
.add< HexahedronSetGeometryAlgorithms<Vec1Types> >()
int sofa::component::topology::HexahedronSetTopologyAlgorithmsClass
Initial value:
= core::RegisterObject("Hexahedron set topology algorithms")
.add< HexahedronSetTopologyAlgorithms<Vec3Types> >(true)
.add< HexahedronSetTopologyAlgorithms<Vec2Types> >()
.add< HexahedronSetTopologyAlgorithms<Vec1Types> >()
int sofa::component::topology::HexahedronSetTopologyContainerClass
Initial value:
= core::RegisterObject("Hexahedron set topology container")
.add< HexahedronSetTopologyContainer >()
int sofa::component::topology::HexahedronSetTopologyModifierClass
Initial value:
= core::RegisterObject("Hexahedron set topology modifier")
.add< HexahedronSetTopologyModifier >()
int sofa::component::topology::IdentityTopologicalMappingClass
Initial value:
= core::RegisterObject("This class is a specific implementation of TopologicalMapping where the destination topology should be kept identical to the source topology. The implementation currently assumes that both topology have been initialized identically.")
.add< IdentityTopologicalMapping >()
int sofa::component::topology::Mesh2PointTopologicalMappingClass
Initial value:
= core::RegisterObject ( "This class maps any mesh primitive (point, edge, triangle...) into a point using a relative position from the primitive" )
.add< Mesh2PointTopologicalMapping >()
int sofa::component::topology::MeshTopologyClass
Initial value:
= core::RegisterObject("Generic mesh topology")
.addAlias("Mesh")
.add< MeshTopology >()
int sofa::component::topology::MultilevelHexahedronSetTopologyContainerClass
Initial value:
= core::RegisterObject("Hexahedron set topology container")
.add< MultilevelHexahedronSetTopologyContainer >()
template class SOFA_BASE_TOPOLOGY_API sofa::component::topology::NumericalIntegrationDescriptor< double, 1 >
template class SOFA_BASE_TOPOLOGY_API sofa::component::topology::NumericalIntegrationDescriptor< double, 3 >
template class SOFA_BASE_TOPOLOGY_API sofa::component::topology::NumericalIntegrationDescriptor< double, 4 >
const size_t sofa::component::topology::permutation3[6][3] ={{0,1,2},{0,2,1},{1,0,2},{1,2,0},{2,0,1},{2,1,0}}
template class SOFA_BASE_TOPOLOGY_API sofa::component::topology::PointSetGeometryAlgorithms< Rigid2Types >
template class SOFA_BASE_TOPOLOGY_API sofa::component::topology::PointSetGeometryAlgorithms< Rigid3Types >
template class SOFA_BASE_TOPOLOGY_API sofa::component::topology::PointSetGeometryAlgorithms< Vec1Types >
template class SOFA_BASE_TOPOLOGY_API sofa::component::topology::PointSetGeometryAlgorithms< Vec2Types >
template class SOFA_BASE_TOPOLOGY_API sofa::component::topology::PointSetGeometryAlgorithms< Vec3Types >
int sofa::component::topology::PointSetGeometryAlgorithmsClass
Initial value:
= core::RegisterObject("Point set geometry algorithms")
.add< PointSetGeometryAlgorithms<Vec3Types> >(true)
.add< PointSetGeometryAlgorithms<Vec2Types> >()
.add< PointSetGeometryAlgorithms<Vec1Types> >()
template class SOFA_BASE_TOPOLOGY_API sofa::component::topology::PointSetTopologyAlgorithms< Rigid2Types >
template class SOFA_BASE_TOPOLOGY_API sofa::component::topology::PointSetTopologyAlgorithms< Rigid3Types >
template class SOFA_BASE_TOPOLOGY_API sofa::component::topology::PointSetTopologyAlgorithms< Vec1Types >
template class SOFA_BASE_TOPOLOGY_API sofa::component::topology::PointSetTopologyAlgorithms< Vec2Types >
template class SOFA_BASE_TOPOLOGY_API sofa::component::topology::PointSetTopologyAlgorithms< Vec3Types >
int sofa::component::topology::PointSetTopologyAlgorithmsClass
Initial value:
= core::RegisterObject("Point set topology algorithms")
.add< PointSetTopologyAlgorithms<Vec3Types> >(true)
.add< PointSetTopologyAlgorithms<Vec2Types> >()
.add< PointSetTopologyAlgorithms<Vec1Types> >()
int sofa::component::topology::PointSetTopologyContainerClass
Initial value:
= core::RegisterObject("Point set topology container")
.add< PointSetTopologyContainer >()
int sofa::component::topology::PointSetTopologyModifierClass
Initial value:
= core::RegisterObject("Point set topology modifier")
.add< PointSetTopologyModifier >()
int sofa::component::topology::Quad2TriangleTopologicalMappingClass
Initial value:
= core::RegisterObject("Special case of mapping where QuadSetTopology is converted to TriangleSetTopology")
.add< Quad2TriangleTopologicalMapping >()
template class SOFA_BASE_TOPOLOGY_API sofa::component::topology::QuadSetGeometryAlgorithms< Vec1Types >
template class SOFA_BASE_TOPOLOGY_API sofa::component::topology::QuadSetGeometryAlgorithms< Vec2Types >
template class SOFA_BASE_TOPOLOGY_API sofa::component::topology::QuadSetGeometryAlgorithms< Vec3Types >
int sofa::component::topology::QuadSetGeometryAlgorithmsClass
Initial value:
= core::RegisterObject("Quad set geometry algorithms")
.add< QuadSetGeometryAlgorithms<Vec3Types> >(true)
.add< QuadSetGeometryAlgorithms<Vec2Types> >()
.add< QuadSetGeometryAlgorithms<Vec1Types> >()
template class SOFA_BASE_TOPOLOGY_API sofa::component::topology::QuadSetTopologyAlgorithms< Vec1Types >
template class SOFA_BASE_TOPOLOGY_API sofa::component::topology::QuadSetTopologyAlgorithms< Vec2Types >
template class SOFA_BASE_TOPOLOGY_API sofa::component::topology::QuadSetTopologyAlgorithms< Vec3Types >
int sofa::component::topology::QuadSetTopologyAlgorithmsClass
Initial value:
= core::RegisterObject("Quad set topology algorithms")
.add< QuadSetTopologyAlgorithms<Vec3dTypes> >(true)
.add< QuadSetTopologyAlgorithms<Vec2Types> >()
.add< QuadSetTopologyAlgorithms<Vec1Types> >()
int sofa::component::topology::QuadSetTopologyContainerClass
Initial value:
= core::RegisterObject("Quad set topology container")
.add< QuadSetTopologyContainer >()
int sofa::component::topology::QuadSetTopologyModifierClass
Initial value:
= core::RegisterObject("Quad set topology modifier")
.add< QuadSetTopologyModifier >()
const unsigned int sofa::component::topology::quadsInHexahedronArray[6][4] = {{0,1,2,3}, {4,7,6,5}, {1,0,4,5},{1,5,6,2}, {2,6,7,3}, {0,3,7,4}}

convention quads in hexa (orientation interior)

int sofa::component::topology::RegularGridTopologyClass
Initial value:
= core::RegisterObject("Regular grid in 3D")
.addAlias("RegularGrid")
.add< RegularGridTopology >()
int sofa::component::topology::SimpleTesselatedHexaTopologicalMappingClass
Initial value:
= core::RegisterObject ( "Special case of mapping where HexahedronSetTopology is converted into a finer HexahedronSetTopology" )
.add< SimpleTesselatedHexaTopologicalMapping >()
int sofa::component::topology::SimpleTesselatedTetraTopologicalMappingClass
Initial value:
= core::RegisterObject ( "Special case of mapping where TetrahedronSetTopology is converted into a finer TetrahedronSetTopology" )
.add< SimpleTesselatedTetraTopologicalMapping >()
int sofa::component::topology::SparseGridMultipleTopologyClass
Initial value:
= core::RegisterObject("Sparse grid in 3D")
.addAlias("SparseGridMultiple")
.add< SparseGridMultipleTopology >()
int sofa::component::topology::SparseGridRamificationTopologyClass
Initial value:
= core::RegisterObject("Sparse grid in 3D (modified)")
.addAlias("SparseGridRamification")
.add< SparseGridRamificationTopology >()
int sofa::component::topology::SparseGridTopologyClass
Initial value:
= core::RegisterObject("Sparse grid in 3D")
.addAlias("SparseGrid")
.add< SparseGridTopology >()
int sofa::component::topology::SphereGridTopologyClass
Initial value:
= core::RegisterObject("Sphere grid in 3D")
.addAlias("SphereGrid")
.add< SphereGridTopology >()
int sofa::component::topology::SphereQuadTopologyClass
Initial value:
= core::RegisterObject("Sphere topology constructed with deformed quads")
.addAlias("SphereQuad")
.add< SphereQuadTopology >()
int sofa::component::topology::SubsetTopologicalMappingClass
Initial value:
= core::RegisterObject("This class is a specific implementation of TopologicalMapping where the destination topology is a subset of the source topology. The implementation currently assumes that both topologies have been initialized correctly.")
.add< SubsetTopologicalMapping >()
int sofa::component::topology::Tetra2TriangleTopologicalMappingClass
Initial value:
= core::RegisterObject("Special case of mapping where TetrahedronSetTopology is converted to TriangleSetTopology")
.add< Tetra2TriangleTopologicalMapping >()
int sofa::component::topology::TetrahedronSetGeometryAlgorithmsClass
Initial value:
= core::RegisterObject("Tetrahedron set geometry algorithms")
.add< TetrahedronSetGeometryAlgorithms<Vec3dTypes> >(true)
.add< TetrahedronSetGeometryAlgorithms<Vec2Types> >()
.add< TetrahedronSetGeometryAlgorithms<Vec1Types> >()
int sofa::component::topology::TetrahedronSetTopologyAlgorithmsClass
Initial value:
= core::RegisterObject("Tetrahedron set topology algorithms")
.add< TetrahedronSetTopologyAlgorithms<Vec3Types> >(true)
.add< TetrahedronSetTopologyAlgorithms<Vec2Types> >()
.add< TetrahedronSetTopologyAlgorithms<Vec1Types> >()
int sofa::component::topology::TetrahedronSetTopologyContainerClass
Initial value:
= core::RegisterObject("Tetrahedron set topology container")
.add< TetrahedronSetTopologyContainer >()
int sofa::component::topology::TetrahedronSetTopologyModifierClass
Initial value:
= core::RegisterObject("Tetrahedron set topology modifier")
.add< TetrahedronSetTopologyModifier >()
int sofa::component::topology::Triangle2EdgeTopologicalMappingClass
Initial value:
= core::RegisterObject("Special case of mapping where TriangleSetTopology is converted to EdgeSetTopology")
.add< Triangle2EdgeTopologicalMapping >()
template class SOFA_BASE_TOPOLOGY_API sofa::component::topology::TriangleSetGeometryAlgorithms< Vec1Types >
template class SOFA_BASE_TOPOLOGY_API sofa::component::topology::TriangleSetGeometryAlgorithms< Vec2Types >
template class SOFA_BASE_TOPOLOGY_API sofa::component::topology::TriangleSetGeometryAlgorithms< Vec3Types >
int sofa::component::topology::TriangleSetGeometryAlgorithmsClass
Initial value:
= core::RegisterObject("Triangle set geometry algorithms")
.add< TriangleSetGeometryAlgorithms<Vec3dTypes> >(true)
.add< TriangleSetGeometryAlgorithms<Vec2Types> >()
.add< TriangleSetGeometryAlgorithms<Vec1Types> >()
template class SOFA_BASE_TOPOLOGY_API sofa::component::topology::TriangleSetTopologyAlgorithms< Vec1Types >
template class SOFA_BASE_TOPOLOGY_API sofa::component::topology::TriangleSetTopologyAlgorithms< Vec2Types >
template class SOFA_BASE_TOPOLOGY_API sofa::component::topology::TriangleSetTopologyAlgorithms< Vec3Types >
int sofa::component::topology::TriangleSetTopologyAlgorithmsClass
Initial value:
= core::RegisterObject("Triangle set topology algorithms")
.add< TriangleSetTopologyAlgorithms<Vec3Types> >(true)
.add< TriangleSetTopologyAlgorithms<Vec2Types> >()
.add< TriangleSetTopologyAlgorithms<Vec1Types> >()
int sofa::component::topology::TriangleSetTopologyContainerClass
Initial value:
= core::RegisterObject("Triangle set topology container")
.add< TriangleSetTopologyContainer >()
int sofa::component::topology::TriangleSetTopologyModifierClass
Initial value:
= core::RegisterObject("Triangle set topology modifier")
.add< TriangleSetTopologyModifier >()
const unsigned int sofa::component::topology::verticesInHexahedronArray = {{{0,4},{3,7}},{{1,5},{2,6}}}