IMeshData

Template defining a class derived from the specified base class and Standard_Transient, and supporting OCCT RTTI.
This provides possibility to use Handes for types not initially intended to be dynamically allocated.
Current limitation is that only copy and constructors with 1-3 arguments are defined, calling those of the argument class (default constructor must be available). It can be improved when perfect forwarding of template arguments is supported by all compilers used for OCCT.
The intent is similar to std::make_shared<> in STL, except that this implementation defines a separate type.

Template defining a class derived from the specified base class and Standard_Transient, and supporting OCCT RTTI.
This provides possibility to use Handes for types not initially intended to be dynamically allocated.
Current limitation is that only copy and constructors with 1-3 arguments are defined, calling those of the argument class (default constructor must be available). It can be improved when perfect forwarding of template arguments is supported by all compilers used for OCCT.
The intent is similar to std::make_shared<> in STL, except that this implementation defines a separate type.

Template defining a class derived from the specified base class and Standard_Transient, and supporting OCCT RTTI.
This provides possibility to use Handes for types not initially intended to be dynamically allocated.
Current limitation is that only copy and constructors with 1-3 arguments are defined, calling those of the argument class (default constructor must be available). It can be improved when perfect forwarding of template arguments is supported by all compilers used for OCCT.
The intent is similar to std::make_shared<> in STL, except that this implementation defines a separate type.

This class is used to fill an UBTree in a random order. The quality of a tree is much better (from the point of view of the search time) if objects are added to it in a random order to avoid adding a chain of neerby objects one following each other.
This class collects objects to be added, and then add them to the tree in a random order.

A data structure for sorting geometric objects (called targets) in n-dimensional space into cells, with associated algorithm for fast checking of coincidence (overlapping, intersection, etc.) with other objects (called here bullets).
Description
The algorithm is based on hash map, thus it has linear time of initialization (O(N) where N is number of cells covered by added targets) and constant-time search for one bullet (more precisely, O(M) where M is number of cells covered by the bullet).
The idea behind the algorithm is to separate each coordinate of the space into equal-size cells. Note that this works well when cell size is approximately equal to the characteristic size of the involved objects (targets and bullets; including tolerance eventually used for coincidence check).
Usage
The target objects to be searched are added to the tool by methods Add(); each target is classified as belonging to some cell(s). The data on cells (list of targets found in each one) are stored in the hash map with key being cumulative index of the cell by all coordinates. Thus the time needed to find targets in some cell is O(1) * O(number of targets in the cell).
As soon as all the targets are added, the algorithm is ready to check for coincidence. To find the targets coincident with any given bullet, it checks all the candidate targets in the cell(s) covered by the bullet object (methods Inspect()).
The methods Add() and Inspect() have two flavours each: one accepts single point identifying one cell, another accept two points specifying the range of cells. It should be noted that normally at least one of these methods is called as for range of cells: either due to objects having non- zero size, or in order to account for the tolerance when objects are points.
The set of targets can be modified during the process: new targets can be added by Add(), existing targets can be removed by Remove().
Implementation
The algorithm is implemented as template class, thus it is capable to work with objects of any type. The only argument of the template should be the specific class providing all necessary features required by the algorithm:

• typedef "Target" defining type of target objects. This type must have copy constructor
• typedef "Point" defining type of geometrical points used
• static constexpr int Dimension whose value must be dimension of the point
• method Coord() returning value of the i-th coordinate of the point: static double Coord (int i, const Point& thePnt); Note that index i is from 0 to Dimension-1.
• method IsEqual() used by Remove() to identify objects to be removed: bool IsEqual (const Target& theT1, const Target& theT2);
• method Inspect() performing necessary actions on the candidate target object (usually comparison with the currently checked bullet object): NCollection_CellFilter_Action Inspect (const Target& theObject); The returned value can be used to command CellFilter to remove the inspected item from the current cell; this allows to exclude the items that has been processed and are not needed any more in further search (for better performance). Note that method Inspect() can be const and/or virtual.

Interface class representing discrete 3d curve of edge. Indexation of points starts from zero.

Template defining a class derived from the specified base class and Standard_Transient, and supporting OCCT RTTI.
This provides possibility to use Handes for types not initially intended to be dynamically allocated.
Current limitation is that only copy and constructors with 1-3 arguments are defined, calling those of the argument class (default constructor must be available). It can be improved when perfect forwarding of template arguments is supported by all compilers used for OCCT.
The intent is similar to std::make_shared<> in STL, except that this implementation defines a separate type.

Template defining a class derived from the specified base class and Standard_Transient, and supporting OCCT RTTI.
This provides possibility to use Handes for types not initially intended to be dynamically allocated.
Current limitation is that only copy and constructors with 1-3 arguments are defined, calling those of the argument class (default constructor must be available). It can be improved when perfect forwarding of template arguments is supported by all compilers used for OCCT.
The intent is similar to std::make_shared<> in STL, except that this implementation defines a separate type.

Template defining a class derived from the specified base class and Standard_Transient, and supporting OCCT RTTI.
This provides possibility to use Handes for types not initially intended to be dynamically allocated.
Current limitation is that only copy and constructors with 1-3 arguments are defined, calling those of the argument class (default constructor must be available). It can be improved when perfect forwarding of template arguments is supported by all compilers used for OCCT.
The intent is similar to std::make_shared<> in STL, except that this implementation defines a separate type.

Template defining a class derived from the specified base class and Standard_Transient, and supporting OCCT RTTI.
This provides possibility to use Handes for types not initially intended to be dynamically allocated.
Current limitation is that only copy and constructors with 1-3 arguments are defined, calling those of the argument class (default constructor must be available). It can be improved when perfect forwarding of template arguments is supported by all compilers used for OCCT.
The intent is similar to std::make_shared<> in STL, except that this implementation defines a separate type.

Template defining a class derived from the specified base class and Standard_Transient, and supporting OCCT RTTI.
This provides possibility to use Handes for types not initially intended to be dynamically allocated.
Current limitation is that only copy and constructors with 1-3 arguments are defined, calling those of the argument class (default constructor must be available). It can be improved when perfect forwarding of template arguments is supported by all compilers used for OCCT.
The intent is similar to std::make_shared<> in STL, except that this implementation defines a separate type.

Template defining a class derived from the specified base class and Standard_Transient, and supporting OCCT RTTI.
This provides possibility to use Handes for types not initially intended to be dynamically allocated.
Current limitation is that only copy and constructors with 1-3 arguments are defined, calling those of the argument class (default constructor must be available). It can be improved when perfect forwarding of template arguments is supported by all compilers used for OCCT.
The intent is similar to std::make_shared<> in STL, except that this implementation defines a separate type.

Template defining a class derived from the specified base class and Standard_Transient, and supporting OCCT RTTI.
This provides possibility to use Handes for types not initially intended to be dynamically allocated.
Current limitation is that only copy and constructors with 1-3 arguments are defined, calling those of the argument class (default constructor must be available). It can be improved when perfect forwarding of template arguments is supported by all compilers used for OCCT.
The intent is similar to std::make_shared<> in STL, except that this implementation defines a separate type.

Template defining a class derived from the specified base class and Standard_Transient, and supporting OCCT RTTI.
This provides possibility to use Handes for types not initially intended to be dynamically allocated.
Current limitation is that only copy and constructors with 1-3 arguments are defined, calling those of the argument class (default constructor must be available). It can be improved when perfect forwarding of template arguments is supported by all compilers used for OCCT.
The intent is similar to std::make_shared<> in STL, except that this implementation defines a separate type.

Template defining a class derived from the specified base class and Standard_Transient, and supporting OCCT RTTI.
This provides possibility to use Handes for types not initially intended to be dynamically allocated.
Current limitation is that only copy and constructors with 1-3 arguments are defined, calling those of the argument class (default constructor must be available). It can be improved when perfect forwarding of template arguments is supported by all compilers used for OCCT.
The intent is similar to std::make_shared<> in STL, except that this implementation defines a separate type.

Template defining a class derived from the specified base class and Standard_Transient, and supporting OCCT RTTI.
This provides possibility to use Handes for types not initially intended to be dynamically allocated.
Current limitation is that only copy and constructors with 1-3 arguments are defined, calling those of the argument class (default constructor must be available). It can be improved when perfect forwarding of template arguments is supported by all compilers used for OCCT.
The intent is similar to std::make_shared<> in STL, except that this implementation defines a separate type.

Template defining a class derived from the specified base class and Standard_Transient, and supporting OCCT RTTI.
This provides possibility to use Handes for types not initially intended to be dynamically allocated.
Current limitation is that only copy and constructors with 1-3 arguments are defined, calling those of the argument class (default constructor must be available). It can be improved when perfect forwarding of template arguments is supported by all compilers used for OCCT.
The intent is similar to std::make_shared<> in STL, except that this implementation defines a separate type.

Template defining a class derived from the specified base class and Standard_Transient, and supporting OCCT RTTI.
This provides possibility to use Handes for types not initially intended to be dynamically allocated.
Current limitation is that only copy and constructors with 1-3 arguments are defined, calling those of the argument class (default constructor must be available). It can be improved when perfect forwarding of template arguments is supported by all compilers used for OCCT.
The intent is similar to std::make_shared<> in STL, except that this implementation defines a separate type.

Template defining a class derived from the specified base class and Standard_Transient, and supporting OCCT RTTI.
This provides possibility to use Handes for types not initially intended to be dynamically allocated.
Current limitation is that only copy and constructors with 1-3 arguments are defined, calling those of the argument class (default constructor must be available). It can be improved when perfect forwarding of template arguments is supported by all compilers used for OCCT.
The intent is similar to std::make_shared<> in STL, except that this implementation defines a separate type.

Template defining a class derived from the specified base class and Standard_Transient, and supporting OCCT RTTI.
This provides possibility to use Handes for types not initially intended to be dynamically allocated.
Current limitation is that only copy and constructors with 1-3 arguments are defined, calling those of the argument class (default constructor must be available). It can be improved when perfect forwarding of template arguments is supported by all compilers used for OCCT.
The intent is similar to std::make_shared<> in STL, except that this implementation defines a separate type.

Template defining a class derived from the specified base class and Standard_Transient, and supporting OCCT RTTI.
This provides possibility to use Handes for types not initially intended to be dynamically allocated.
Current limitation is that only copy and constructors with 1-3 arguments are defined, calling those of the argument class (default constructor must be available). It can be improved when perfect forwarding of template arguments is supported by all compilers used for OCCT.
The intent is similar to std::make_shared<> in STL, except that this implementation defines a separate type.

Template defining a class derived from the specified base class and Standard_Transient, and supporting OCCT RTTI.
This provides possibility to use Handes for types not initially intended to be dynamically allocated.
Current limitation is that only copy and constructors with 1-3 arguments are defined, calling those of the argument class (default constructor must be available). It can be improved when perfect forwarding of template arguments is supported by all compilers used for OCCT.
The intent is similar to std::make_shared<> in STL, except that this implementation defines a separate type.

Interface class representing discrete model of a shape.

Interface class representing list of parameters on curve.

Interface class representing pcurve of edge associated with discrete face. Indexation of points starts from zero.

Template defining a class derived from the specified base class and Standard_Transient, and supporting OCCT RTTI.
This provides possibility to use Handes for types not initially intended to be dynamically allocated.
Current limitation is that only copy and constructors with 1-3 arguments are defined, calling those of the argument class (default constructor must be available). It can be improved when perfect forwarding of template arguments is supported by all compilers used for OCCT.
The intent is similar to std::make_shared<> in STL, except that this implementation defines a separate type.

Template defining a class derived from the specified base class and Standard_Transient, and supporting OCCT RTTI.
This provides possibility to use Handes for types not initially intended to be dynamically allocated.
Current limitation is that only copy and constructors with 1-3 arguments are defined, calling those of the argument class (default constructor must be available). It can be improved when perfect forwarding of template arguments is supported by all compilers used for OCCT.
The intent is similar to std::make_shared<> in STL, except that this implementation defines a separate type.

Template defining a class derived from the specified base class and Standard_Transient, and supporting OCCT RTTI.
This provides possibility to use Handes for types not initially intended to be dynamically allocated.
Current limitation is that only copy and constructors with 1-3 arguments are defined, calling those of the argument class (default constructor must be available). It can be improved when perfect forwarding of template arguments is supported by all compilers used for OCCT.
The intent is similar to std::make_shared<> in STL, except that this implementation defines a separate type.

Interface class representing model with associated TopoDS_Shape. Intended for inheritance by structures and algorithms keeping reference TopoDS_Shape.

Extension interface class providing status functionality.

Interface class representing shaped model with deflection.

Template defining a class derived from the specified base class and Standard_Transient, and supporting OCCT RTTI.
This provides possibility to use Handes for types not initially intended to be dynamically allocated.
Current limitation is that only copy and constructors with 1-3 arguments are defined, calling those of the argument class (default constructor must be available). It can be improved when perfect forwarding of template arguments is supported by all compilers used for OCCT.
The intent is similar to std::make_shared<> in STL, except that this implementation defines a separate type.

Template defining a class derived from the specified base class and Standard_Transient, and supporting OCCT RTTI.
This provides possibility to use Handes for types not initially intended to be dynamically allocated.
Current limitation is that only copy and constructors with 1-3 arguments are defined, calling those of the argument class (default constructor must be available). It can be improved when perfect forwarding of template arguments is supported by all compilers used for OCCT.
The intent is similar to std::make_shared<> in STL, except that this implementation defines a separate type.

Template defining a class derived from the specified base class and Standard_Transient, and supporting OCCT RTTI.
This provides possibility to use Handes for types not initially intended to be dynamically allocated.
Current limitation is that only copy and constructors with 1-3 arguments are defined, calling those of the argument class (default constructor must be available). It can be improved when perfect forwarding of template arguments is supported by all compilers used for OCCT.
The intent is similar to std::make_shared<> in STL, except that this implementation defines a separate type.

Template defining a class derived from the specified base class and Standard_Transient, and supporting OCCT RTTI.
This provides possibility to use Handes for types not initially intended to be dynamically allocated.
Current limitation is that only copy and constructors with 1-3 arguments are defined, calling those of the argument class (default constructor must be available). It can be improved when perfect forwarding of template arguments is supported by all compilers used for OCCT.
The intent is similar to std::make_shared<> in STL, except that this implementation defines a separate type.

Template defining a class derived from the specified base class and Standard_Transient, and supporting OCCT RTTI.
This provides possibility to use Handes for types not initially intended to be dynamically allocated.
Current limitation is that only copy and constructors with 1-3 arguments are defined, calling those of the argument class (default constructor must be available). It can be improved when perfect forwarding of template arguments is supported by all compilers used for OCCT.
The intent is similar to std::make_shared<> in STL, except that this implementation defines a separate type.

Template defining a class derived from the specified base class and Standard_Transient, and supporting OCCT RTTI.
This provides possibility to use Handes for types not initially intended to be dynamically allocated.
Current limitation is that only copy and constructors with 1-3 arguments are defined, calling those of the argument class (default constructor must be available). It can be improved when perfect forwarding of template arguments is supported by all compilers used for OCCT.
The intent is similar to std::make_shared<> in STL, except that this implementation defines a separate type.

Template defining a class derived from the specified base class and Standard_Transient, and supporting OCCT RTTI.
This provides possibility to use Handes for types not initially intended to be dynamically allocated.
Current limitation is that only copy and constructors with 1-3 arguments are defined, calling those of the argument class (default constructor must be available). It can be improved when perfect forwarding of template arguments is supported by all compilers used for OCCT.
The intent is similar to std::make_shared<> in STL, except that this implementation defines a separate type.

Template defining a class derived from the specified base class and Standard_Transient, and supporting OCCT RTTI.
This provides possibility to use Handes for types not initially intended to be dynamically allocated.
Current limitation is that only copy and constructors with 1-3 arguments are defined, calling those of the argument class (default constructor must be available). It can be improved when perfect forwarding of template arguments is supported by all compilers used for OCCT.
The intent is similar to std::make_shared<> in STL, except that this implementation defines a separate type.

Template defining a class derived from the specified base class and Standard_Transient, and supporting OCCT RTTI.
This provides possibility to use Handes for types not initially intended to be dynamically allocated.
Current limitation is that only copy and constructors with 1-3 arguments are defined, calling those of the argument class (default constructor must be available). It can be improved when perfect forwarding of template arguments is supported by all compilers used for OCCT.
The intent is similar to std::make_shared<> in STL, except that this implementation defines a separate type.

Template defining a class derived from the specified base class and Standard_Transient, and supporting OCCT RTTI.
This provides possibility to use Handes for types not initially intended to be dynamically allocated.
Current limitation is that only copy and constructors with 1-3 arguments are defined, calling those of the argument class (default constructor must be available). It can be improved when perfect forwarding of template arguments is supported by all compilers used for OCCT.
The intent is similar to std::make_shared<> in STL, except that this implementation defines a separate type.

Template defining a class derived from the specified base class and Standard_Transient, and supporting OCCT RTTI.
This provides possibility to use Handes for types not initially intended to be dynamically allocated.
Current limitation is that only copy and constructors with 1-3 arguments are defined, calling those of the argument class (default constructor must be available). It can be improved when perfect forwarding of template arguments is supported by all compilers used for OCCT.
The intent is similar to std::make_shared<> in STL, except that this implementation defines a separate type.

A data structure for sorting geometric objects (called targets) in n-dimensional space into cells, with associated algorithm for fast checking of coincidence (overlapping, intersection, etc.) with other objects (called here bullets).
Description
The algorithm is based on hash map, thus it has linear time of initialization (O(N) where N is number of cells covered by added targets) and constant-time search for one bullet (more precisely, O(M) where M is number of cells covered by the bullet).
The idea behind the algorithm is to separate each coordinate of the space into equal-size cells. Note that this works well when cell size is approximately equal to the characteristic size of the involved objects (targets and bullets; including tolerance eventually used for coincidence check).
Usage
The target objects to be searched are added to the tool by methods Add(); each target is classified as belonging to some cell(s). The data on cells (list of targets found in each one) are stored in the hash map with key being cumulative index of the cell by all coordinates. Thus the time needed to find targets in some cell is O(1) * O(number of targets in the cell).
As soon as all the targets are added, the algorithm is ready to check for coincidence. To find the targets coincident with any given bullet, it checks all the candidate targets in the cell(s) covered by the bullet object (methods Inspect()).
The methods Add() and Inspect() have two flavours each: one accepts single point identifying one cell, another accept two points specifying the range of cells. It should be noted that normally at least one of these methods is called as for range of cells: either due to objects having non- zero size, or in order to account for the tolerance when objects are points.
The set of targets can be modified during the process: new targets can be added by Add(), existing targets can be removed by Remove().
Implementation
The algorithm is implemented as template class, thus it is capable to work with objects of any type. The only argument of the template should be the specific class providing all necessary features required by the algorithm:

• typedef "Target" defining type of target objects. This type must have copy constructor
• typedef "Point" defining type of geometrical points used
• static constexpr int Dimension whose value must be dimension of the point
• method Coord() returning value of the i-th coordinate of the point: static double Coord (int i, const Point& thePnt); Note that index i is from 0 to Dimension-1.
• method IsEqual() used by Remove() to identify objects to be removed: bool IsEqual (const Target& theT1, const Target& theT2);
• method Inspect() performing necessary actions on the candidate target object (usually comparison with the currently checked bullet object): NCollection_CellFilter_Action Inspect (const Target& theObject); The returned value can be used to command CellFilter to remove the inspected item from the current cell; this allows to exclude the items that has been processed and are not needed any more in further search (for better performance). Note that method Inspect() can be const and/or virtual.