SOFA API  6dc60b15
Open source framework for multi-physics simuation
sofa::helper Namespace Reference

Namespaces

 console
 
 gl
 
 io
 
 lifecycle
 
 logging
 
 messaging
 
 pairwise
 
 polygon_cube_intersection
 
 system
 
 testing
 
 types
 

Classes

class  AdvancedTimer
 
class  ArgumentParser
 
class  BackTrace
 
class  BaseCreator
 
class  BaseCreator< sofa::gui::BaseViewer, sofa::gui::BaseViewerArgument & >
 
class  BasicDispatcher
 
struct  CleanupCheck
 
class  ColorMap
 
struct  CompareIndirect
 
class  CPUMemoryManager
 CPU MemoryManager. More...
 
class  Creator
 
class  CreatorFn
 
class  Decompose
 
class  DistancePointTri
 
class  DistanceSegTri
 
class  DistanceTriTri
 
class  DualQuatCoord3
 
class  Factory
 
class  fixed_array
 
class  FnDispatcher
 
struct  GenerateRigidInfo
 storing rigid infos needed for RigidMass More...
 
class  HasDeprecatedClassName
 
class  HasDeprecatedShortName
 
class  HasDeprecatedTemplateName
 
class  HasGetCustomClassName
 
class  HasGetCustomTemplateName
 
class  HasGetDefaultTemplateName
 
class  HasName
 
struct  IndexOpenMP
 
class  integer_id
 
struct  IsEqual
 
struct  IsEqual< true >
 
struct  IsNull
 
struct  IsNull< true >
 
class  kdTree
 
class  LCP
 
class  LCPSolver
 
class  LocalBlock33
 
class  map_ptr_stable_compare
 A map container that order pointers in a stable way, i.e. in the order pointers are presented. More...
 
class  MarchingCubeUtility
 
class  MemoryManager
 
class  Monomial_LD
 A generic monomial with N variables of type Real. A monomial is one term of a polynomial. More...
 
class  NameDecoder
 
class  NoArgument
 Allow us to use BaseCreator and Factory without using any Arguments. More...
 
class  OptionsGroup
 OptionsGroup is a kind of data for a radio button. It has a list of text representing a list of choices, and a interger number indicating the choice selected. More...
 
class  OwnershipSPtr
 
class  Polynomial_LD
 A generic polynomial with N variables of type Real. A polynomial is a list composed of several monomials. More...
 
class  ptr_stable_compare
 A comparison object that order pointers in a stable way, i.e. in the order pointers are presented. More...
 
class  ptr_stable_compare< std::pair< T *, T * > >
 
class  ptr_stable_compare< T * >
 
class  ptr_stable_id
 
class  Quater
 
class  RandomGenerator
 
class  ReadAccessor
 
class  ReadAccessor< core::objectmodel::Data< T > >
 
class  ReadAccessor< helper::vector< T, Alloc > >
 
class  ReadAccessor< std::vector< T, Alloc > >
 
class  ReadAccessor< vector_id< T, TIndex, CheckIndices, MemoryManager > >
 
class  ReadAccessorVector
 ReadAccessor implementation class for vector types. More...
 
class  ReadAccessorVectorId
 ReadAccessor implementation class for vector_id types. More...
 
class  Record
 
struct  ScopedAdvancedTimer
 Scoped (RAII) AdvancedTimer to simplify a basic usage. More...
 
class  SingletonFnDispatcher
 
class  SofaViewerCreator
 
class  SofaViewerFactory
 
class  StateMask
 Utility class to handle the mechanism of masks. More...
 
class  StepData
 
class  SVector
 Same as helper::vector, + delimitors on serialization. More...
 
class  TagFactory
 
class  TimerData
 
class  TSimpleTimer
 
class  TypeInfo
 
class  UnitTest
 
class  Utils
 Contains possibly useful functions, that don't fit anywhere else. More...
 
class  vector
 
class  vector< T, CPUMemoryManager< T > >
 
class  vector_id
 
class  vectorData
 
class  VectorLinks
 
class  WriteAccessor
 
class  WriteAccessor< core::objectmodel::Data< T > >
 
class  WriteAccessor< helper::vector< T, Alloc > >
 
class  WriteAccessor< std::vector< T, Alloc > >
 
class  WriteAccessor< vector_id< T, TIndex, CheckIndices, MemoryManager > >
 
class  WriteAccessorVector
 WriteAccessor implementation class for vector types. More...
 
class  WriteAccessorVectorId
 WriteAccessor implementation class for vector_id types. More...
 
class  WriteOnlyAccessor
 
class  WriteOnlyAccessor< core::objectmodel::Data< T > >
 The WriteOnlyAccessor provides an access to the Data without triggering an engine update. This should be the prefered writeAccessor for most of the cases as it avoids uncessary Data updates. More...
 

Typedefs

typedef sofa::helper::system::thread::ctime_t ctime_t
 
typedef sofa::helper::system::thread::CTime CTime
 
typedef DualQuatCoord3< doubleDualQuatCoordd
 alias More...
 
typedef DualQuatCoord3< floatDualQuatCoordf
 alias More...
 
typedef const char *(* integer_id_name) ()
 
typedef double FemClipsReal
 
typedef TSimpleTimer SimpleTimer
 
template<class T , class A = std::allocator<T>>
using stable_vector = boost::container::stable_vector< T, A >
 

Enumerations

enum  { NDefaultColorMapSchemes = 20 }
 
enum  DataEngineDataType { DataEngineNothing, DataEngineInput, DataEngineOutput }
 

Functions

template<class T >
WriteAccessor< core::objectmodel::Data< T > > write (core::objectmodel::Data< T > &data)
 Easy syntax for getting read/write access to a Data using operator ->. Example: write(someFlagData)->setFlagValue(true);. More...
 
template<class T >
WriteAccessor< core::objectmodel::Data< T > > write (core::objectmodel::Data< T > &data, const core::ExecParams *)
 
template<class T >
ReadAccessor< core::objectmodel::Data< T > > read (const core::objectmodel::Data< T > &data)
 
template<class T >
ReadAccessor< core::objectmodel::Data< T > > read (const core::objectmodel::Data< T > &data, const core::ExecParams *)
 
template<class T >
WriteOnlyAccessor< core::objectmodel::Data< T > > writeOnly (core::objectmodel::Data< T > &data)
 Easy syntax for getting write only access to a Data using operator ->. Example: writeOnly(someFlagData)->setFlagValue(true);. More...
 
template<class D >
sofa::helper::ReadAccessor< D > getReadAccessor (D &c)
 
template<class D >
sofa::helper::WriteAccessor< D > getWriteAccessor (D &c)
 
template<class D >
sofa::helper::WriteOnlyAccessor< D > getWriteOnlyAccessor (D &c)
 
 SOFA_THREAD_SPECIFIC_PTR (std::stack< AdvancedTimer::IdTimer >, curTimerThread)
 
 SOFA_THREAD_SPECIFIC_PTR (helper::vector< Record >, curRecordsThread)
 
std::stack< AdvancedTimer::IdTimer > & getCurTimer ()
 
helper::vector< Record > * getCurRecords ()
 
void setCurRecords (helper::vector< Record > *ptr)
 
void printVal (std::ostream &out, double v)
 
void printNoVal (std::ostream &out)
 
void printVal (std::ostream &out, double v, int niter)
 
void printTime (std::ostream &out, ctime_t t, int niter=1)
 
std::string getVal (double v)
 
std::string getNoVal ()
 
std::string getVal (double v, int niter)
 
std::string getTime (ctime_t t, int niter=1)
 
double strToDouble (std::string const &stringToConvert, std::size_t const precision)
 
template<class Real >
int dsyevc3 (const defaulttype::Mat< 3, 3, Real > &A, defaulttype::Vec< 3, Real > &w)
 
template<class Real >
void dsytrd3 (const defaulttype::Mat< 3, 3, Real > &A, defaulttype::Mat< 3, 3, Real > &Q, defaulttype::Vec< 3, Real > &d, defaulttype::Vec< 3, Real > &e)
 
template<class Real >
int dsyevq3 (const defaulttype::Mat< 3, 3, Real > &A, defaulttype::Mat< 3, 3, Real > &Q, defaulttype::Vec< 3, Real > &w)
 
template<class Real >
void dsyev2 (Real A, Real B, Real C, Real &rt1, Real &rt2, Real &cs, Real &sn)
 
std::string SOFA_HELPER_API gettypename (const std::type_info &t)
 Decode the type's name to a more readable form if possible. More...
 
void SOFA_HELPER_API logFactoryRegister (std::string baseclass, std::string classname, std::string key, bool multi)
 Log classes registered in the factory. More...
 
void SOFA_HELPER_API printFactoryLog (std::ostream &out)
 Print factory log. More...
 
template<class T >
fixed_array< T, 2 > make_array (const T &v0, const T &v1)
 
template<class T >
fixed_array< T, 3 > make_array (const T &v0, const T &v1, const T &v2)
 
template<class T >
fixed_array< T, 4 > make_array (const T &v0, const T &v1, const T &v2, const T &v3)
 
template<class T >
fixed_array< T, 5 > make_array (const T &v0, const T &v1, const T &v2, const T &v3, const T &v4)
 
template<class T >
fixed_array< T, 6 > make_array (const T &v0, const T &v1, const T &v2, const T &v3, const T &v4, const T &v5)
 
template<class T >
fixed_array< T, 7 > make_array (const T &v0, const T &v1, const T &v2, const T &v3, const T &v4, const T &v5, const T &v6)
 
template<class T >
fixed_array< T, 8 > make_array (const T &v0, const T &v1, const T &v2, const T &v3, const T &v4, const T &v5, const T &v6, const T &v7)
 
template<class T >
fixed_array< T, 9 > make_array (const T &v0, const T &v1, const T &v2, const T &v3, const T &v4, const T &v5, const T &v6, const T &v7, const T &v8)
 
template<class T >
fixed_array< T, 10 > make_array (const T &v0, const T &v1, const T &v2, const T &v3, const T &v4, const T &v5, const T &v6, const T &v7, const T &v8, const T &v9)
 
void generateRigid (Rigid3Mass &mass, Vector3 &center, const sofa::helper::io::Mesh *mesh)
 
void generateRigid (defaulttype::Rigid3Mass &mass, defaulttype::Vector3 &center, io::Mesh *mesh, SReal density, const defaulttype::Vector3 &scale=defaulttype::Vector3(1, 1, 1), const defaulttype::Vector3 &rotation=defaulttype::Vector3(0, 0, 0))
 user friendly function to compute center of mass, mass and inertia tensor from a mesh, a density, a scale and a rotation More...
 
bool generateRigid (Rigid3Mass &mass, Vector3 &center, const std::string &meshFilename, SReal density, const Vector3 &scale, const Vector3 &rotation)
 
bool generateRigid (GenerateRigidInfo &res, const std::string &meshFilename, SReal density, const defaulttype::Vector3 &scale, const Vector3 &rotation)
 
void generateRigid (GenerateRigidInfo &res, io::Mesh *mesh, std::string const &meshName, SReal density, const defaulttype::Vector3 &scale, const Vector3 &rotation)
 
void SOFA_HELPER_API generateRigid (defaulttype::Rigid3Mass &mass, defaulttype::Vector3 &center, const helper::io::Mesh *mesh)
 base function to compute center of mass, mass and inertia tensor from a mesh More...
 
bool SOFA_HELPER_API generateRigid (defaulttype::Rigid3Mass &mass, defaulttype::Vector3 &center, const std::string &meshFilename, SReal density, const defaulttype::Vector3 &scale=defaulttype::Vector3(1, 1, 1), const defaulttype::Vector3 &rotation=defaulttype::Vector3(0, 0, 0))
 user friendly function to compute center of mass, mass and inertia tensor from a mesh file, a density, a scale and a rotation More...
 
void SOFA_HELPER_API generateRigid (GenerateRigidInfo &res, io::Mesh *mesh, std::string const &meshName, SReal density, const defaulttype::Vector3 &scale=defaulttype::Vector3(1, 1, 1), const defaulttype::Vector3 &rotation=defaulttype::Vector3(0, 0, 0))
 user friendly function to compute rigid info from a mesh, a density, a scale More...
 
bool SOFA_HELPER_API generateRigid (GenerateRigidInfo &res, const std::string &meshFilename, SReal density, const defaulttype::Vector3 &scale=defaulttype::Vector3(1, 1, 1), const defaulttype::Vector3 &rotation=defaulttype::Vector3(0, 0, 0))
 user friendly function to compute rigid info from a mesh file, a density, a scale More...
 
SOFA_HELPER_API void init ()
 Initialize the SofaHelper library. More...
 
SOFA_HELPER_API bool isInitialized ()
 Return true if and only if the SofaHelper library has been initialized. More...
 
SOFA_HELPER_API void cleanup ()
 Clean up the resources used by the SofaHelper library. More...
 
SOFA_HELPER_API bool isCleanedUp ()
 Return true if and only if the SofaHelper library has been cleaned up. More...
 
SOFA_HELPER_API void printUninitializedLibraryWarning (const std::string &library, const std::string &initFunction)
 Print a warning about a library not being initialized (meant for internal use). More...
 
SOFA_HELPER_API void printLibraryNotCleanedUpWarning (const std::string &library, const std::string &cleanupFunction)
 Print a warning about a library not being cleaned up (meant for internal use). More...
 
void SOFA_HELPER_API vector_access_failure (const void *vec, unsigned size, unsigned i, const std::type_info &type, const char *tindex)
 
int resoudreLCP (int dim, double *q, double **M, double *res)
 
void afficheSyst (double *q, double **M, int *base, double **mat, int dim)
 
void afficheLCP (double *q, double **M, int dim)
 
void afficheLCP (double *q, double **M, double *f, int dim)
 
void resultToString (ostream &s, double *f, int dim)
 
void projection (LCP &fineLevel, LCP &coarseLevel, int nbContactsCoarse, const std::vector< int > &projectionTable, const std::vector< int > &projectionConstraints, std::vector< double > &projectionValues, std::vector< bool > &contact_is_projected, bool verbose)
 
void prolongation (LCP &fineLevel, LCP &coarseLevel, const std::vector< int > &projectionTable, const std::vector< int > &projectionConstraints, std::vector< double > &projectionValues, std::vector< bool > &contact_is_projected, bool verbose)
 
int nlcp_multiGrid_2levels (int dim, double *dfree, double **W, double *f, double mu, double tol, int numItMax, bool useInitialF, std::vector< int > &contact_group, unsigned int num_group, std::vector< int > &constraint_group, std::vector< double > &constraint_group_fact, bool verbose, std::vector< double > *residuals1, std::vector< double > *residuals2)
 new multigrid resolution of a problem with projection & prolongation More...
 
int nlcp_multiGrid_Nlevels (int dim, double *dfree, double **W, double *f, double mu, double tol, int numItMax, bool useInitialF, std::vector< std::vector< int > > &contact_group_hierarchy, std::vector< unsigned int > Tab_num_group, std::vector< std::vector< int > > &constraint_group_hierarchy, std::vector< std::vector< double > > &constraint_group_fact_hierarchy, bool verbose, std::vector< double > *residualsN, std::vector< double > *residualLevels, std::vector< double > *violations)
 
int nlcp_multiGrid (int dim, double *dfree, double **W, double *f, double mu, double tol, int numItMax, bool useInitialF, double **W_coarse, std::vector< int > &contact_group, unsigned int num_group, bool verbose)
 
int nlcp_gaussseidel (int dim, double *dfree, double **W, double *f, double mu, double tol, int numItMax, bool useInitialF, bool verbose, double minW, double maxF, std::vector< double > *residuals, std::vector< double > *violations)
 
int nlcp_gaussseidelTimed (int dim, double *dfree, double **W, double *f, double mu, double tol, int numItMax, bool useInitialF, double timeout, bool verbose)
 
void gaussSeidelLCP1 (int dim, FemClipsReal *q, FemClipsReal **M, FemClipsReal *res, double tol, int numItMax, double minW, double maxF, std::vector< double > *residuals)
 
SOFA_HELPER_API void set3Dof (double *vector, int index, double vx, double vy, double vz)
 
SOFA_HELPER_API void add3Dof (double *vector, int index, double vx, double vy, double vz)
 
SOFA_HELPER_API double normError (double f1x, double f1y, double f1z, double f2x, double f2y, double f2z)
 
SOFA_HELPER_API double absError (double f1x, double f1y, double f1z, double f2x, double f2y, double f2z)
 
SOFA_HELPER_API void resultToString (std::ostream &s, double *f, int dim)
 
template<std::size_t NumRows, std::size_t NumCols, class Real >
Eigen::Matrix< Real, NumRows, NumCols > eigenMat (const defaulttype::Mat< NumRows, NumCols, Real > &mat)
 
template<std::size_t NumRows, std::size_t NumCols, class Real >
defaulttype::Mat< NumRows, NumCols, RealsofaMat (const Eigen::Matrix< Real, NumRows, NumCols > &emat)
 
template<std::size_t NumRows, class Real >
defaulttype::Vec< NumRows, RealsofaVec (const Eigen::Matrix< Real, NumRows, 1 > &evec)
 
template<std::size_t NumRows, class Real >
Eigen::Matrix< Real, NumRows, 1 > eigenVec (const defaulttype::Vec< NumRows, Real > &vec)
 
template<typename T >
std::string GetSofaTypeTemplateName (const std::string prefix="")
 
template<typename T1 , typename T2 , typename... Ts>
std::string GetSofaTypeTemplateName (const std::string prefix="")
 
std::ostream & operator<< (std::ostream &on, const OptionsGroup &m_trick)
 
std::istream & operator>> (std::istream &in, OptionsGroup &m_trick)
 
template<typename FReal , unsigned int FN>
std::ostream & operator<< (std::ostream &out, const Monomial_LD< FReal, FN > &m_monomial)
 
template<typename FReal , unsigned int FN>
std::istream & operator>> (std::istream &in, Monomial_LD< FReal, FN > &m_monomial)
 
template<typename FReal , unsigned int FN>
std::ostream & operator<< (std::ostream &stream, const Polynomial_LD< FReal, FN > &m_polynomial)
 
template<typename FReal , unsigned int FN>
std::istream & operator>> (std::istream &stream, Polynomial_LD< FReal, FN > &m_polynomial)
 
template<typename FReal , unsigned int FN>
Monomial_LD< FReal, FN > & operator* (const FReal &alpha, Monomial_LD< FReal, FN > &r)
 
template<typename FReal , unsigned int FN>
Polynomial_LD< FReal, FN > & operator* (const FReal &alpha, Polynomial_LD< FReal, FN > &r)
 
template<typename FReal , unsigned int FN>
Polynomial_LD< FReal, FN > & operator* (const Monomial_LD< FReal, FN > &a, Polynomial_LD< FReal, FN > &r)
 
void srand (unsigned seed)
 
int irand ()
 
double drand ()
 
double drandpos (double max)
 
double drand (double max)
 
double drand (double min, double max)
 
template<class real >
int rfloor (real r)
 
template<class real >
int rnear (real r)
 
int rceil (double r)
 
template<class real >
real rabs (real r)
 
template<class real >
real rmin (real r, real s)
 
template<class real >
real rmax (real r, real s)
 
template<class T >
rlerp (const T &a, const T &b, float f)
 
template<class T >
rsqrt (const T &a)
 
double rsqrt (const double &a)
 
long double rsqrt (const long double &a)
 
template<class T >
const T SQR (const T &a)
 
template<class T >
const T SIGN (const T &a, const T &b)
 
template<class T >
void SWAP (T &a, T &b)
 
void shft3 (double &a, double &b, double &c, const double d)
 
template<class T >
round (const T &x)
 
template<class T >
factorial (T Number)
 
template<class T >
rclamp (const T &value, const T &low, const T &high)
 
template<class T >
bool isClamped (const T &value, const T &low, const T &high)
 
template<class T >
sign (const T &v)
 
template<class T >
sign0 (const T &v)
 
template<class T >
bool isEqual (T x, T y, T threshold=(std::numeric_limits< T >::epsilon)())
 
template<class T >
bool isNull (T x, T threshold=(std::numeric_limits< T >::epsilon)())
 
double rcos (double x)
 
float rcos (float x)
 
double rsin (double x)
 
float rsin (float x)
 
template<class T >
rcos (const T &a)
 
template<class T >
rsin (const T &a)
 
template<class Container >
helper::vector< unsigned > sortedPermutation (const Container &values)
 Return a sorted permutation of the container, i.e. a list of indices corresponding to increasing entries. More...
 
std::vector< std::string > split (const std::string &s, char delimiter)
 Taken from https://www.fluentcpp.com/2017/04/21/how-to-split-a-string-in-c/. More...
 
char * getAStringCopy (const char *c)
 returns a copy of the string given in argument. More...
 
void replaceAll (std::string &str, const std::string &search, const std::string &replace)
 replace all occurence of "search" by the "replace" string. More...
 
bool ends_with (const std::string &suffix, const std::string &full)
 returns true if the suffix if located at the end of the "full" string. More...
 
bool starts_with (const std::string &prefix, const std::string &full)
 returns true if the prefix if located at the beginning of the "full" string. More...
 
std::string safeCharToString (const char *c)
 converts a char* string into a c++ string. The special case with nullptr is coerced to an empty string. More...
 
template<class S , class T >
std::string join (std::vector< T > &elems, S &delim)
 Join a std::vector into a single string, separated by the provided delimiter. More...
 
void SOFA_HELPER_API vector_access_failure (const void *vec, unsigned size, unsigned i, const std::type_info &type)
 
int SOFA_HELPER_API getInteger (const std::string &s, std::stringstream &msg, unsigned int &numErrors)
 
unsigned int SOFA_HELPER_API getUnsignedInteger (const std::string &s, std::stringstream &msg, unsigned int &numErrors)
 
vector class-related methods
template<class T1 , class T2 >
void remove (T1 &v, const T2 &elem)
 
template<class T1 , class T2 >
void removeValue (T1 &v, const T2 &elem)
 
template<class T , class TT >
void removeIndex (std::vector< T, TT > &v, size_t index)
 Remove value at given index, replace it by the value at the last index, other values are not changed. More...
 
linear algebra on standard vectors
template<class V1 , class V2 >
SReal dot (const V1 &vector1, const V2 &vector2)
 Dot product of two vectors. More...
 
template<class V >
SReal norm (const V &v)
 Norm of a vector. More...
 
template<class V1 , class Scalar , class V2 , class V3 >
void axpy (V1 &result, Scalar a, const V2 &x, const V3 &y)
 Vector operation: result = ax + y. More...
 

Variables

std::map< AdvancedTimer::IdTimer, TimerDatatimers
 
std::atomic< intactiveTimers
 
AdvancedTimer::SyncCallBack syncCallBack = nullptr
 
void * syncCallBackData = nullptr
 
template class SOFA_HELPER_API Decompose< double >
 
template class SOFA_HELPER_API Decompose< float >
 
template class SOFA_HELPER_API DualQuatCoord3< double >
 
template class SOFA_HELPER_API DualQuatCoord3< float >
 
template class SOFA_HELPER_API fixed_array< float, 2 >
 
template class SOFA_HELPER_API fixed_array< double, 2 >
 
template class SOFA_HELPER_API fixed_array< float, 3 >
 
template class SOFA_HELPER_API fixed_array< double, 3 >
 
template class SOFA_HELPER_API fixed_array< float, 4 >
 
template class SOFA_HELPER_API fixed_array< double, 4 >
 
template class SOFA_HELPER_API fixed_array< float, 5 >
 
template class SOFA_HELPER_API fixed_array< double, 5 >
 
template class SOFA_HELPER_API fixed_array< float, 6 >
 
template class SOFA_HELPER_API fixed_array< double, 6 >
 
template class SOFA_HELPER_API fixed_array< float, 7 >
 
template class SOFA_HELPER_API fixed_array< double, 7 >
 
const int MarchingCubeEdgeTable [256]
 
const int MarchingCubeFaceTable [256]
 
const int MarchingCubeTriTable [256][16]
 
template class SOFA_HELPER_API Monomial_LD< double, 1 >
 
template class SOFA_HELPER_API Monomial_LD< double, 2 >
 
template class SOFA_HELPER_API Monomial_LD< double, 3 >
 
template class SOFA_HELPER_API Monomial_LD< double, 4 >
 
template class SOFA_HELPER_API Monomial_LD< double, 5 >
 
template class SOFA_HELPER_API Polynomial_LD< double, 1 >
 
template class SOFA_HELPER_API Polynomial_LD< double, 2 >
 
template class SOFA_HELPER_API Polynomial_LD< double, 3 >
 
template class SOFA_HELPER_API Polynomial_LD< double, 4 >
 
template class SOFA_HELPER_API Polynomial_LD< double, 5 >
 
template class SOFA_HELPER_API Quater< double >
 
template class SOFA_HELPER_API Quater< float >
 

Typedef Documentation

typedef const char*(* sofa::helper::integer_id_name) ()
template<class T , class A = std::allocator<T>>
using sofa::helper::stable_vector = typedef boost::container::stable_vector<T,A>

Enumeration Type Documentation

anonymous enum
Enumerator
NDefaultColorMapSchemes 
Enumerator
DataEngineNothing 
DataEngineInput 
DataEngineOutput 

Function Documentation

SOFA_HELPER_API double sofa::helper::absError ( double  f1x,
double  f1y,
double  f1z,
double  f2x,
double  f2y,
double  f2z 
)
inline
SOFA_HELPER_API void sofa::helper::add3Dof ( double vector,
int  index,
double  vx,
double  vy,
double  vz 
)
inline
SOFA_HELPER_API void sofa::helper::afficheLCP ( double q,
double **  M,
int  dim 
)
SOFA_HELPER_API void sofa::helper::afficheLCP ( double q,
double **  M,
double f,
int  dim 
)
SOFA_HELPER_API void sofa::helper::afficheSyst ( double q,
double **  M,
int base,
double **  mat,
int  dim 
)
template<class V1 , class Scalar , class V2 , class V3 >
void sofa::helper::axpy ( V1 &  result,
Scalar  a,
const V2 &  x,
const V3 &  y 
)

Vector operation: result = ax + y.

SOFA_HELPER_API void sofa::helper::cleanup ( )

Clean up the resources used by the SofaHelper library.

template<class V1 , class V2 >
SReal sofa::helper::dot ( const V1 &  vector1,
const V2 &  vector2 
)

Dot product of two vectors.

double sofa::helper::drand ( )
inline
double sofa::helper::drand ( double  max)
inline
double sofa::helper::drand ( double  min,
double  max 
)
inline
double sofa::helper::drandpos ( double  max)
inline
template<class Real >
void sofa::helper::dsyev2 ( Real  A,
Real  B,
Real  C,
Real rt1,
Real rt2,
Real cs,
Real sn 
)
inline
template<class Real >
int sofa::helper::dsyevc3 ( const defaulttype::Mat< 3, 3, Real > &  A,
defaulttype::Vec< 3, Real > &  w 
)
template<class Real >
int sofa::helper::dsyevq3 ( const defaulttype::Mat< 3, 3, Real > &  A,
defaulttype::Mat< 3, 3, Real > &  Q,
defaulttype::Vec< 3, Real > &  w 
)
template<class Real >
void sofa::helper::dsytrd3 ( const defaulttype::Mat< 3, 3, Real > &  A,
defaulttype::Mat< 3, 3, Real > &  Q,
defaulttype::Vec< 3, Real > &  d,
defaulttype::Vec< 3, Real > &  e 
)
inline
template<std::size_t NumRows, std::size_t NumCols, class Real >
Eigen::Matrix<Real, NumRows, NumCols> sofa::helper::eigenMat ( const defaulttype::Mat< NumRows, NumCols, Real > &  mat)
template<std::size_t NumRows, class Real >
Eigen::Matrix<Real, NumRows, 1> sofa::helper::eigenVec ( const defaulttype::Vec< NumRows, Real > &  vec)
SOFA_HELPER_API bool sofa::helper::ends_with ( const std::string &  suffix,
const std::string &  full 
)

returns true if the suffix if located at the end of the "full" string.

template<class T >
T sofa::helper::factorial ( Number)
inline
SOFA_HELPER_API void sofa::helper::gaussSeidelLCP1 ( int  dim,
FemClipsReal q,
FemClipsReal **  M,
FemClipsReal res,
double  tol,
int  numItMax,
double  minW,
double  maxF,
std::vector< double > *  residuals 
)
void sofa::helper::generateRigid ( Rigid3Mass mass,
Vector3 &  center,
const sofa::helper::io::Mesh mesh 
)
void SOFA_HELPER_API sofa::helper::generateRigid ( defaulttype::Rigid3Mass mass,
defaulttype::Vector3 &  center,
const helper::io::Mesh mesh 
)

base function to compute center of mass, mass and inertia tensor from a mesh

bool SOFA_HELPER_API sofa::helper::generateRigid ( defaulttype::Rigid3Mass mass,
defaulttype::Vector3 &  center,
const std::string &  meshFilename,
SReal  density,
const defaulttype::Vector3 &  scale = defaulttype::Vector3(1, 1, 1),
const defaulttype::Vector3 &  rotation = defaulttype::Vector3(0, 0, 0) 
)

user friendly function to compute center of mass, mass and inertia tensor from a mesh file, a density, a scale and a rotation

void SOFA_HELPER_API sofa::helper::generateRigid ( GenerateRigidInfo res,
io::Mesh mesh,
std::string const &  meshName,
SReal  density,
const defaulttype::Vector3 &  scale = defaulttype::Vector3(1, 1, 1),
const defaulttype::Vector3 &  rotation = defaulttype::Vector3(0, 0, 0) 
)

user friendly function to compute rigid info from a mesh, a density, a scale

bool SOFA_HELPER_API sofa::helper::generateRigid ( GenerateRigidInfo res,
const std::string &  meshFilename,
SReal  density,
const defaulttype::Vector3 &  scale = defaulttype::Vector3(1, 1, 1),
const defaulttype::Vector3 &  rotation = defaulttype::Vector3(0, 0, 0) 
)

user friendly function to compute rigid info from a mesh file, a density, a scale

void sofa::helper::generateRigid ( defaulttype::Rigid3Mass mass,
defaulttype::Vector3 &  center,
helper::io::Mesh mesh,
SReal  density,
const defaulttype::Vector3 &  scale,
const defaulttype::Vector3 &  rotation 
)

user friendly function to compute center of mass, mass and inertia tensor from a mesh, a density, a scale and a rotation

bool sofa::helper::generateRigid ( Rigid3Mass mass,
Vector3 &  center,
const std::string &  meshFilename,
SReal  density,
const Vector3 &  scale,
const Vector3 &  rotation 
)
bool sofa::helper::generateRigid ( GenerateRigidInfo res,
const std::string &  meshFilename,
SReal  density,
const defaulttype::Vector3 &  scale,
const Vector3 &  rotation 
)
void sofa::helper::generateRigid ( GenerateRigidInfo res,
io::Mesh mesh,
std::string const &  meshName,
SReal  density,
const defaulttype::Vector3 &  scale,
const Vector3 &  rotation 
)
SOFA_HELPER_API char * sofa::helper::getAStringCopy ( const char *  c)

returns a copy of the string given in argument.

helper::vector<Record>* sofa::helper::getCurRecords ( )
std::stack<AdvancedTimer::IdTimer>& sofa::helper::getCurTimer ( )
int SOFA_HELPER_API sofa::helper::getInteger ( const std::string &  s,
std::stringstream &  msg,
unsigned int numErrors 
)

Convert the string 's' into an unsigned int. The error are reported in msg & numErrors is incremented.

std::string sofa::helper::getNoVal ( )
template<class D >
sofa::helper::ReadAccessor<D> sofa::helper::getReadAccessor ( D &  c)

Returns a read accessor from the provided Data<> Example of use: auto points = getReadAccessor(d_points)

template<typename T >
std::string sofa::helper::GetSofaTypeTemplateName ( const std::string  prefix = "")
template<typename T1 , typename T2 , typename... Ts>
std::string sofa::helper::GetSofaTypeTemplateName ( const std::string  prefix = "")
std::string sofa::helper::getTime ( ctime_t  t,
int  niter = 1 
)
std::string SOFA_HELPER_API sofa::helper::gettypename ( const std::type_info &  t)

Decode the type's name to a more readable form if possible.

unsigned int SOFA_HELPER_API sofa::helper::getUnsignedInteger ( const std::string &  s,
std::stringstream &  msg,
unsigned int numErrors 
)

Convert the string 's' into an unsigned int. The error are reported in msg & numErrors is incremented.

std::string sofa::helper::getVal ( double  v)
std::string sofa::helper::getVal ( double  v,
int  niter 
)
template<class D >
sofa::helper::WriteAccessor<D> sofa::helper::getWriteAccessor ( D &  c)

Returns a write only accessor from the provided Data<> Example of use: auto points = getWriteOnlyAccessor(d_points)

template<class D >
sofa::helper::WriteOnlyAccessor<D> sofa::helper::getWriteOnlyAccessor ( D &  c)

Returns a write only accessor from the provided Data<> WriteOnly accessors are faster than WriteAccessor because as the data is only read this means there is no need to pull the data from the parents Example of use: auto points = getWriteOnlyAccessor(d_points)

SOFA_HELPER_API void sofa::helper::init ( )

Initialize the SofaHelper library.

int sofa::helper::irand ( )
inline
template<class T >
bool sofa::helper::isClamped ( const T &  value,
const T &  low,
const T &  high 
)
inline
SOFA_HELPER_API bool sofa::helper::isCleanedUp ( )

Return true if and only if the SofaHelper library has been cleaned up.

template<class T >
bool sofa::helper::isEqual ( x,
y,
threshold = (std::numeric_limits<T>::epsilon)() 
)
inline

number comparison rough floating point comparison (threshold) exact integer comparison

SOFA_HELPER_API bool sofa::helper::isInitialized ( )

Return true if and only if the SofaHelper library has been initialized.

template<class T >
bool sofa::helper::isNull ( x,
threshold = (std::numeric_limits<T>::epsilon)() 
)
inline

number null test rough floating point test ( <= threshold) exact integer test

template<class S , class T >
std::string sofa::helper::join ( std::vector< T > &  elems,
S &  delim 
)

Join a std::vector into a single string, separated by the provided delimiter.

Taken from https://github.com/ekg/split/blob/master/join.h (I don't know what is the licence but thank for the author.

void SOFA_HELPER_API sofa::helper::logFactoryRegister ( std::string  baseclass,
std::string  classname,
std::string  key,
bool  multi 
)

Log classes registered in the factory.

template<class T >
fixed_array<T, 2> sofa::helper::make_array ( const T &  v0,
const T &  v1 
)
inline
template<class T >
fixed_array<T, 3> sofa::helper::make_array ( const T &  v0,
const T &  v1,
const T &  v2 
)
inline
template<class T >
fixed_array<T, 4> sofa::helper::make_array ( const T &  v0,
const T &  v1,
const T &  v2,
const T &  v3 
)
inline
template<class T >
fixed_array<T, 5> sofa::helper::make_array ( const T &  v0,
const T &  v1,
const T &  v2,
const T &  v3,
const T &  v4 
)
inline
template<class T >
fixed_array<T, 6> sofa::helper::make_array ( const T &  v0,
const T &  v1,
const T &  v2,
const T &  v3,
const T &  v4,
const T &  v5 
)
inline
template<class T >
fixed_array<T, 7> sofa::helper::make_array ( const T &  v0,
const T &  v1,
const T &  v2,
const T &  v3,
const T &  v4,
const T &  v5,
const T &  v6 
)
inline
template<class T >
fixed_array<T, 8> sofa::helper::make_array ( const T &  v0,
const T &  v1,
const T &  v2,
const T &  v3,
const T &  v4,
const T &  v5,
const T &  v6,
const T &  v7 
)
inline
template<class T >
fixed_array<T, 9> sofa::helper::make_array ( const T &  v0,
const T &  v1,
const T &  v2,
const T &  v3,
const T &  v4,
const T &  v5,
const T &  v6,
const T &  v7,
const T &  v8 
)
inline
template<class T >
fixed_array<T, 10> sofa::helper::make_array ( const T &  v0,
const T &  v1,
const T &  v2,
const T &  v3,
const T &  v4,
const T &  v5,
const T &  v6,
const T &  v7,
const T &  v8,
const T &  v9 
)
inline
SOFA_HELPER_API int sofa::helper::nlcp_gaussseidel ( int  dim,
double dfree,
double **  W,
double f,
double  mu,
double  tol,
int  numItMax,
bool  useInitialF,
bool  verbose,
double  minW,
double  maxF,
std::vector< double > *  residuals,
std::vector< double > *  violations 
)
SOFA_HELPER_API int sofa::helper::nlcp_gaussseidelTimed ( int  dim,
double dfree,
double **  W,
double f,
double  mu,
double  tol,
int  numItMax,
bool  useInitialF,
double  timeout,
bool  verbose 
)
SOFA_HELPER_API int sofa::helper::nlcp_multiGrid ( int  dim,
double dfree,
double **  W,
double f,
double  mu,
double  tol,
int  numItMax,
bool  useInitialF,
double **  W_coarse,
std::vector< int > &  contact_group,
unsigned int  num_group,
bool  verbose 
)
SOFA_HELPER_API int sofa::helper::nlcp_multiGrid_2levels ( int  dim,
double dfree,
double **  W,
double f,
double  mu,
double  tol,
int  numItMax,
bool  useInitialF,
std::vector< int > &  contact_group,
unsigned int  num_group,
std::vector< int > &  constraint_group,
std::vector< double > &  constraint_group_fact,
bool  verbose,
std::vector< double > *  residuals1,
std::vector< double > *  residuals2 
)

new multigrid resolution of a problem with projection & prolongation

SOFA_HELPER_API int sofa::helper::nlcp_multiGrid_Nlevels ( int  dim,
double dfree,
double **  W,
double f,
double  mu,
double  tol,
int  numItMax,
bool  useInitialF,
std::vector< std::vector< int > > &  contact_group_hierarchy,
std::vector< unsigned int Tab_num_group,
std::vector< std::vector< int > > &  constraint_group_hierarchy,
std::vector< std::vector< double > > &  constraint_group_fact_hierarchy,
bool  verbose,
std::vector< double > *  residualsN,
std::vector< double > *  residualLevels,
std::vector< double > *  violations 
)
template<class V >
SReal sofa::helper::norm ( const V &  v)

Norm of a vector.

SOFA_HELPER_API double sofa::helper::normError ( double  f1x,
double  f1y,
double  f1z,
double  f2x,
double  f2y,
double  f2z 
)
inline
template<typename FReal , unsigned int FN>
Monomial_LD< FReal, FN >& sofa::helper::operator* ( const FReal &  alpha,
Monomial_LD< FReal, FN > &  r 
)
template<typename FReal , unsigned int FN>
Polynomial_LD< FReal, FN >& sofa::helper::operator* ( const FReal &  alpha,
Polynomial_LD< FReal, FN > &  r 
)

Comutativity of operator*(Real): Allowing to write p1=r*p2; or p1=p2*r; Polynomial_LD = Polynomial_LD*Real || Real*Polynomial_LD.

template<typename FReal , unsigned int FN>
Polynomial_LD< FReal, FN >& sofa::helper::operator* ( const Monomial_LD< FReal, FN > &  a,
Polynomial_LD< FReal, FN > &  r 
)
std::ostream& sofa::helper::operator<< ( std::ostream &  on,
const OptionsGroup m_trick 
)
inline
template<typename FReal , unsigned int FN>
std::ostream& sofa::helper::operator<< ( std::ostream &  out,
const Monomial_LD< FReal, FN > &  m_monomial 
)
inline
template<typename FReal , unsigned int FN>
std::ostream& sofa::helper::operator<< ( std::ostream &  stream,
const Polynomial_LD< FReal, FN > &  m_polynomial 
)
inline
std::istream& sofa::helper::operator>> ( std::istream &  in,
OptionsGroup m_trick 
)
inline
template<typename FReal , unsigned int FN>
std::istream& sofa::helper::operator>> ( std::istream &  in,
Monomial_LD< FReal, FN > &  m_monomial 
)
inline
template<typename FReal , unsigned int FN>
std::istream& sofa::helper::operator>> ( std::istream &  stream,
Polynomial_LD< FReal, FN > &  m_polynomial 
)
inline
void SOFA_HELPER_API sofa::helper::printFactoryLog ( std::ostream &  out)

Print factory log.

SOFA_HELPER_API void sofa::helper::printLibraryNotCleanedUpWarning ( const std::string &  library,
const std::string &  cleanupFunction 
)

Print a warning about a library not being cleaned up (meant for internal use).

void sofa::helper::printNoVal ( std::ostream &  out)
void sofa::helper::printTime ( std::ostream &  out,
ctime_t  t,
int  niter = 1 
)
SOFA_HELPER_API void sofa::helper::printUninitializedLibraryWarning ( const std::string &  library,
const std::string &  initFunction 
)

Print a warning about a library not being initialized (meant for internal use).

void sofa::helper::printVal ( std::ostream &  out,
double  v 
)
void sofa::helper::printVal ( std::ostream &  out,
double  v,
int  niter 
)
void sofa::helper::projection ( LCP fineLevel,
LCP coarseLevel,
int  nbContactsCoarse,
const std::vector< int > &  projectionTable,
const std::vector< int > &  projectionConstraints,
std::vector< double > &  projectionValues,
std::vector< bool > &  contact_is_projected,
bool  verbose 
)

projection function input values: LCP &fineLevel => LCP at the fine level nbContactsCoarse => number of contacts wanted at the coarse level projectionTable => Table (size = fine level) => for each contact at the fine level, provide the coarse contact verbose => output values: LCP &coarseLevel contact_is_projected => (size= fine level) => for each contact at the fine level, tell if the contact is projected or not

void sofa::helper::prolongation ( LCP fineLevel,
LCP coarseLevel,
const std::vector< int > &  projectionTable,
const std::vector< int > &  projectionConstraints,
std::vector< double > &  projectionValues,
std::vector< bool > &  contact_is_projected,
bool  verbose 
)

prolongation function all parameters as input output=> change value of F in fineLevel

template<class real >
real sofa::helper::rabs ( real  r)
inline
int sofa::helper::rceil ( double  r)
inline
template<class T >
T sofa::helper::rclamp ( const T &  value,
const T &  low,
const T &  high 
)
inline
double sofa::helper::rcos ( double  x)
inline
float sofa::helper::rcos ( float  x)
inline
template<class T >
T sofa::helper::rcos ( const T &  a)
inline
template<class T >
ReadAccessor<core::objectmodel::Data<T> > sofa::helper::read ( const core::objectmodel::Data< T > &  data)
inline
template<class T >
ReadAccessor<core::objectmodel::Data<T> > sofa::helper::read ( const core::objectmodel::Data< T > &  data,
const core::ExecParams  
)
inline
template<class T1 , class T2 >
void sofa::helper::remove ( T1 &  v,
const T2 &  elem 
)

Remove the first occurence of a given value.

The remaining values are shifted.

template<class T , class TT >
void sofa::helper::removeIndex ( std::vector< T, TT > &  v,
size_t  index 
)

Remove value at given index, replace it by the value at the last index, other values are not changed.

template<class T1 , class T2 >
void sofa::helper::removeValue ( T1 &  v,
const T2 &  elem 
)

Remove the first occurence of a given value.

The last value is moved to where the value was found, and the other values are not shifted.

SOFA_HELPER_API void sofa::helper::replaceAll ( std::string &  str,
const std::string &  search,
const std::string &  replace 
)

replace all occurence of "search" by the "replace" string.

SOFA_HELPER_API int sofa::helper::resoudreLCP ( int  dim,
double q,
double **  M,
double res 
)
SOFA_HELPER_API void sofa::helper::resultToString ( std::ostream &  s,
double f,
int  dim 
)
void sofa::helper::resultToString ( ostream &  s,
double f,
int  dim 
)
template<class real >
int sofa::helper::rfloor ( real  r)
inline
template<class T >
T sofa::helper::rlerp ( const T &  a,
const T &  b,
float  f 
)
inline
template<class real >
real sofa::helper::rmax ( real  r,
real  s 
)
inline
template<class real >
real sofa::helper::rmin ( real  r,
real  s 
)
inline
template<class real >
int sofa::helper::rnear ( real  r)
inline
template<class T >
T sofa::helper::round ( const T &  x)
inline
double sofa::helper::rsin ( double  x)
inline
float sofa::helper::rsin ( float  x)
inline
template<class T >
T sofa::helper::rsin ( const T &  a)
inline
template<class T >
T sofa::helper::rsqrt ( const T &  a)
inline
double sofa::helper::rsqrt ( const double a)
inline
long double sofa::helper::rsqrt ( const long double a)
inline
SOFA_HELPER_API std::string sofa::helper::safeCharToString ( const char *  c)

converts a char* string into a c++ string. The special case with nullptr is coerced to an empty string.

SOFA_HELPER_API void sofa::helper::set3Dof ( double vector,
int  index,
double  vx,
double  vy,
double  vz 
)
inline
void sofa::helper::setCurRecords ( helper::vector< Record > *  ptr)
void sofa::helper::shft3 ( double a,
double b,
double c,
const double  d 
)
inline
template<class T >
const T sofa::helper::SIGN ( const T &  a,
const T &  b 
)
inline
template<class T >
T sofa::helper::sign ( const T &  v)
inline
template<class T >
T sofa::helper::sign0 ( const T &  v)
inline
sofa::helper::SOFA_THREAD_SPECIFIC_PTR ( std::stack< AdvancedTimer::IdTimer ,
curTimerThread   
)
sofa::helper::SOFA_THREAD_SPECIFIC_PTR ( helper::vector< Record ,
curRecordsThread   
)
template<std::size_t NumRows, std::size_t NumCols, class Real >
defaulttype::Mat<NumRows, NumCols, Real> sofa::helper::sofaMat ( const Eigen::Matrix< Real, NumRows, NumCols > &  emat)
template<std::size_t NumRows, class Real >
defaulttype::Vec<NumRows, Real> sofa::helper::sofaVec ( const Eigen::Matrix< Real, NumRows, 1 > &  evec)
template<class Container >
helper::vector<unsigned> sofa::helper::sortedPermutation ( const Container &  values)

Return a sorted permutation of the container, i.e. a list of indices corresponding to increasing entries.

std::vector< std::string > SOFA_HELPER_API sofa::helper::split ( const std::string &  s,
char  delimiter 
)

Taken from https://www.fluentcpp.com/2017/04/21/how-to-split-a-string-in-c/.

Split one string by a given delimiter and returns that into a std::vector.

template<class T >
const T sofa::helper::SQR ( const T &  a)
inline
void sofa::helper::srand ( unsigned  seed)
inline

Define random methods srand and rand for double and int used only for the tests now.

SOFA_HELPER_API bool sofa::helper::starts_with ( const std::string &  prefix,
const std::string &  full 
)

returns true if the prefix if located at the beginning of the "full" string.

double sofa::helper::strToDouble ( std::string const &  stringToConvert,
std::size_t const  precision 
)
template<class T >
void sofa::helper::SWAP ( T &  a,
T &  b 
)
inline
void SOFA_HELPER_API sofa::helper::vector_access_failure ( const void *  vec,
unsigned  size,
unsigned  i,
const std::type_info &  type 
)
void SOFA_HELPER_API sofa::helper::vector_access_failure ( const void *  vec,
unsigned  size,
unsigned  i,
const std::type_info &  type,
const char *  tindex 
)
template<class T >
WriteAccessor<core::objectmodel::Data<T> > sofa::helper::write ( core::objectmodel::Data< T > &  data)
inline

Easy syntax for getting read/write access to a Data using operator ->. Example: write(someFlagData)->setFlagValue(true);.

template<class T >
WriteAccessor<core::objectmodel::Data<T> > sofa::helper::write ( core::objectmodel::Data< T > &  data,
const core::ExecParams  
)
inline
template<class T >
WriteOnlyAccessor<core::objectmodel::Data<T> > sofa::helper::writeOnly ( core::objectmodel::Data< T > &  data)
inline

Easy syntax for getting write only access to a Data using operator ->. Example: writeOnly(someFlagData)->setFlagValue(true);.

Variable Documentation

std::atomic<int> sofa::helper::activeTimers
template class SOFA_HELPER_API sofa::helper::Decompose< double >
template class SOFA_HELPER_API sofa::helper::Decompose< float >
template class SOFA_HELPER_API sofa::helper::DualQuatCoord3< double >
template class SOFA_HELPER_API sofa::helper::DualQuatCoord3< float >
template class SOFA_HELPER_API sofa::helper::fixed_array< double, 2 >
template class SOFA_HELPER_API sofa::helper::fixed_array< double, 3 >
template class SOFA_HELPER_API sofa::helper::fixed_array< double, 4 >
template class SOFA_HELPER_API sofa::helper::fixed_array< double, 5 >
template class SOFA_HELPER_API sofa::helper::fixed_array< double, 6 >
template class SOFA_HELPER_API sofa::helper::fixed_array< double, 7 >
template class SOFA_HELPER_API sofa::helper::fixed_array< float, 2 >
template class SOFA_HELPER_API sofa::helper::fixed_array< float, 3 >
template class SOFA_HELPER_API sofa::helper::fixed_array< float, 4 >
template class SOFA_HELPER_API sofa::helper::fixed_array< float, 5 >
template class SOFA_HELPER_API sofa::helper::fixed_array< float, 6 >
template class SOFA_HELPER_API sofa::helper::fixed_array< float, 7 >
SOFA_HELPER_API const int sofa::helper::MarchingCubeEdgeTable
SOFA_HELPER_API const int sofa::helper::MarchingCubeFaceTable
Initial value:
=
{
0x0 , 0x19, 0x15, 0x1d, 0x25, 0x3d, 0x35, 0x3d, 0x29, 0x39,
0x3d, 0x3d, 0x2d, 0x3d, 0x3d, 0x3c, 0x1a, 0x1b, 0x1f, 0x1f,
0x3f, 0x3f, 0x3f, 0x3f, 0x3b, 0x3b, 0x3f, 0x3f, 0x3f, 0x3f,
0x3f, 0x3e, 0x16, 0x1f, 0x17, 0x1f, 0x37, 0x3f, 0x37, 0x3f,
0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3e, 0x1e, 0x1f,
0x1f, 0xf , 0x3f, 0x3f, 0x3f, 0x2f, 0x3f, 0x3f, 0x3f, 0x2f,
0x3f, 0x3f, 0x3f, 0x2e, 0x26, 0x3f, 0x37, 0x3f, 0x27, 0x3f,
0x37, 0x3f, 0x2f, 0x3f, 0x3f, 0x3f, 0x2f, 0x3f, 0x3f, 0x3e,
0x3e, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f,
0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3e, 0x36, 0x3f, 0x37, 0x3f,
0x37, 0x3f, 0x33, 0x3b, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f,
0x3b, 0x3a, 0x3e, 0x3f, 0x3f, 0x2f, 0x3f, 0x3f, 0x3b, 0x2b,
0x3f, 0x3f, 0x3f, 0x2f, 0x3f, 0x3f, 0x3b, 0x2a, 0x2a, 0x3b,
0x3f, 0x3f, 0x2f, 0x3f, 0x3f, 0x3f, 0x2b, 0x3b, 0x3f, 0x3f,
0x2f, 0x3f, 0x3f, 0x3e, 0x3a, 0x3b, 0x3f, 0x3f, 0x3f, 0x3f,
0x3f, 0x3f, 0x3b, 0x33, 0x3f, 0x37, 0x3f, 0x37, 0x3f, 0x36,
0x3e, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f,
0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3e, 0x3e, 0x3f, 0x3f, 0x2f,
0x3f, 0x3f, 0x3f, 0x2f, 0x3f, 0x37, 0x3f, 0x27, 0x3f, 0x37,
0x3f, 0x26, 0x2e, 0x3f, 0x3f, 0x3f, 0x2f, 0x3f, 0x3f, 0x3f,
0x2f, 0x3f, 0x3f, 0x3f, 0xf , 0x1f, 0x1f, 0x1e, 0x3e, 0x3f,
0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f, 0x37, 0x3f, 0x37,
0x1f, 0x17, 0x1f, 0x16, 0x3e, 0x3f, 0x3f, 0x3f, 0x3f, 0x3f,
0x3b, 0x3b, 0x3f, 0x3f, 0x3f, 0x3f, 0x1f, 0x1f, 0x1b, 0x1a,
0x3c, 0x3d, 0x3d, 0x2d, 0x3d, 0x3d, 0x39, 0x29, 0x3d, 0x35,
0x3d, 0x25, 0x1d, 0x15, 0x19, 0x0
}
SOFA_HELPER_API const int sofa::helper::MarchingCubeTriTable
template class SOFA_HELPER_API sofa::helper::Monomial_LD< double, 1 >
template class SOFA_HELPER_API sofa::helper::Monomial_LD< double, 2 >
template class SOFA_HELPER_API sofa::helper::Monomial_LD< double, 3 >
template class SOFA_HELPER_API sofa::helper::Monomial_LD< double, 4 >
template class SOFA_HELPER_API sofa::helper::Monomial_LD< double, 5 >
template class SOFA_HELPER_API sofa::helper::Polynomial_LD< double, 1 >
template class SOFA_HELPER_API sofa::helper::Polynomial_LD< double, 2 >
template class SOFA_HELPER_API sofa::helper::Polynomial_LD< double, 3 >
template class SOFA_HELPER_API sofa::helper::Polynomial_LD< double, 4 >
template class SOFA_HELPER_API sofa::helper::Polynomial_LD< double, 5 >
template class SOFA_HELPER_API sofa::helper::Quater< double >
template class SOFA_HELPER_API sofa::helper::Quater< float >
AdvancedTimer::SyncCallBack sofa::helper::syncCallBack = nullptr
void* sofa::helper::syncCallBackData = nullptr
std::map< AdvancedTimer::IdTimer, TimerData > sofa::helper::timers