| NBRepGraph_DefsIterator | Single-level typed iterators over active child definitions |
| CBaseTraits | |
| CShellOfSolidTraits | Traits for iterating over shell children of a solid |
| CFaceOfShellTraits | Traits for iterating over face children of a shell |
| CWireOfFaceTraits | Traits for iterating over wire children of a face |
| CCoEdgeOfWireTraits | Traits for iterating over coedge children of a wire (direct, no ref indirection) |
| CEdgeOfWireTraits | Traits for iterating over edge children of a wire (via coedge indirection) |
| CSolidOfCompSolidTraits | Traits for iterating over solid children of a compsolid |
| CChildOfCompoundTraits | Traits for iterating over child nodes of a compound |
| COccurrenceOfProductTraits | Traits for iterating over occurrence children of a product |
| CDefsOfParent | |
| CDefsVertexOfEdge | Direct active boundary vertex children of an edge |
| NBRepGraph_IteratorDetail | Type-safe, allocation-free iterator over BRepGraph definition nodes |
| CNodeTraits | Compile-time traits mapping from definition type to typed NodeId, count accessor, and definition accessor |
| CNodeTraits< BRepGraphInc::SolidDef > | |
| CNodeTraits< BRepGraphInc::ShellDef > | |
| CNodeTraits< BRepGraphInc::FaceDef > | |
| CNodeTraits< BRepGraphInc::WireDef > | |
| CNodeTraits< BRepGraphInc::EdgeDef > | |
| CNodeTraits< BRepGraphInc::VertexDef > | |
| CNodeTraits< BRepGraphInc::ProductDef > | |
| CNodeTraits< BRepGraphInc::OccurrenceDef > | |
| CNodeTraits< BRepGraphInc::CoEdgeDef > | |
| CNodeTraits< BRepGraphInc::CompoundDef > | |
| CNodeTraits< BRepGraphInc::CompSolidDef > | |
| NBRepGraph_RefsIterator | Single-level typed iterators over active child reference ids |
| NDetail | |
| CRefTraits | |
| CRefTraits< BRepGraphInc::ShellRef > | |
| CRefTraits< BRepGraphInc::FaceRef > | |
| CRefTraits< BRepGraphInc::WireRef > | |
| CRefTraits< BRepGraphInc::VertexRef > | |
| CRefTraits< BRepGraphInc::SolidRef > | |
| CRefTraits< BRepGraphInc::ChildRef > | |
| CRefTraits< BRepGraphInc::OccurrenceRef > | |
| CRefIterator | |
| CBaseTraits | |
| CShellOfSolidTraits | |
| CFaceOfShellTraits | |
| CWireOfFaceTraits | |
| CCoEdgeOfWireTraits | |
| CSolidOfCompSolidTraits | |
| CChildOfCompoundTraits | |
| COccurrenceOfProductTraits | |
| CRefsOfParent | |
| CRefsVertexOfEdge | Direct active boundary vertex reference ids of an edge |
| NBRepGraph_ReverseIterator | Single-level typed iterators over parent definitions via relation lists |
| CDefTraits | Compile-time traits mapping typed ID to its definition type and accessor |
| CDefTraits< BRepGraph_SolidId > | |
| CDefTraits< BRepGraph_ShellId > | |
| CDefTraits< BRepGraph_FaceId > | |
| CDefTraits< BRepGraph_WireId > | |
| CDefTraits< BRepGraph_EdgeId > | |
| CDefTraits< BRepGraph_VertexId > | |
| CDefTraits< BRepGraph_CoEdgeId > | |
| CDefTraits< BRepGraph_CompoundId > | |
| CDefTraits< BRepGraph_CompSolidId > | |
| CDefTraits< BRepGraph_ProductId > | |
| CDefTraits< BRepGraph_OccurrenceId > | |
| CParentsOf | Typed iterator over a relation vector of parent IDs. Skips removed parent definitions automatically in sequential iteration. Also provides indexed access (Length/Value) for callers that need random access into the underlying vector (e.g. BRepGraph_ParentExplorer) |
| CEdgeParentsOf | |
| CParentRef | Result pair returned by parent-ref iterators: parent definition ID + the RefId in that parent which references the child |
| CLookupParentRefsOf | Typed iterator over parent ID relation lists that also resolves the specific RefId linking each parent to the child by lookup in the parent definition. Used only where the reverse relation stores parent IDs but no ref IDs |
| CIdsOfRefs | |
| CWireOfCoEdgeUsageTraits | |
| CWireFromEdgeCoEdgeTraits | |
| CFaceFromEdgeCoEdgeTraits | |
| CEdgeOfVertexRefTraits | |
| CFaceFromWireRefTraits | |
| CShellFromFaceRefTraits | |
| CSolidFromShellRefTraits | |
| CCompSolidFromSolidRefTraits | |
| CCompoundFromChildRefTraits | |
| COccurrenceFromOccurrenceRefTraits | |
| CProductFromOccurrenceRefTraits | |
| NBRepGraphInc | Definition structs for the incidence-table topology model |
| CBaseDef | Fields shared by every entity |
| CBaseRef | Fields shared by every reference entry |
| CChildRef | Child reference storage entry |
| CCoEdgeCurve2DRep | 2D parametric curve (PCurve) use for coedges. Owned by a single coedge |
| CCoEdgeDef | CoEdge entity: use of an edge on a specific face, owns PCurve data |
| CCoEdgePolygon2DRep | 2D polygon-on-surface use for coedges. Owned by a single coedge |
| CCoEdgePolygonOnTriRep | Polygon-on-triangulation use for coedges. Owned by a single coedge |
| CCompoundDef | Compound entity |
| CCompoundRelations | Topology relations for compound definitions |
| CCompSolidDef | Comp-solid entity |
| CCompSolidRelations | Topology relations for compsolid definitions |
| CEdgeCurve3DRep | 3D curve use for edges. Owned by a single edge |
| CEdgeDef | Edge entity: parameter range, boundary vertices. Geometry (curve, polygon) accessed via owned use records. Degeneracy, closure, SameRange, and SameParameter are derived from current topology and geometry via BRepGraph_CacheDerivedState |
| CEdgePolygon3DRep | 3D polygon use for edges. Owned by a single edge |
| CEdgeRelations | Topology relations for edge definitions |
| CFaceDef | Face entity: surface, triangulations, wires |
| CFaceRef | Face reference storage entry |
| CFaceRelations | Topology relations for face definitions |
| CFaceSurfaceRep | Surface geometry use for faces. Owned by a single face |
| CFaceTriangulationRep | Triangulation mesh use for faces. Owned by a single face |
| CInstance | Unified instance container template |
| COccurrenceDef | Occurrence entity: reference to a child node (topology root or product). Parent products are determined from ProductRelations owner arrays. Placement lives on OccurrenceRef::LocalLocation (definitions never carry location). Path-based traversal (BRepGraph_UsagePath) resolves DAG paths without stored parent-occurrence pointers |
| COccurrenceRef | Occurrence reference storage entry. Like ChildRef but without Orientation - placement is a reference property. Structurally parallel to other ref types: definitions carry no location |
| COccurrenceRelations | Topology relations for occurrence definitions |
| CParityOrientation | Persisted core-topology orientation stored as forward/reversed parity only |
| CProductDef | Product entity: reusable shape definition (part or assembly). Children are managed uniformly via ProductRelations::OccurrenceRefIds: |
| CProductRelations | Topology relations for product definitions |
| CShellDef | Shell entity. Shell closure is derived from face-boundary edge incidence via BRepGraph_CacheDerivedState |
| CShellRef | Shell reference storage entry |
| CShellRelations | Topology relations for shell definitions |
| CSolidDef | Solid entity |
| CSolidRef | Solid reference storage entry |
| CSolidRelations | Topology relations for solid definitions |
| CVertexDef | Vertex definition: 3D point + tolerance |
| CVertexRef | Vertex reference storage entry |
| CVertexRelations | Topology relations for vertex definitions |
| CWireDef | Wire entity: ordered coedge sequence. Wire closure is derived from the ordered coedge chain via BRepGraph_CacheDerivedState |
| CWireRef | Wire reference storage entry |
| CWireRelations | Topology relations for wire definitions |
| NBRepGraphInc_Load | Internal storage-side types for fixed-size indexed load preparation |
| CCounts | Final section counts needed to prepare BRepGraphInc_Storage for indexed load |
| NBVH | |
| CArray | Tool class providing typical operations on the array |
| CArrayType | Tool class for selecting type of array of vectors |
| CBitComparator | STL compare tool used in binary search algorithm |
| CBitPredicate | |
| CBoundData | |
| CBoxMinMax | Tool class for computing component-wise vector minimum and maximum |
| CBVH_AxisSelector | |
| CBVH_AxisSelector< T, 2 > | |
| CCenterAxis | Tool class for calculating box center along the given axis |
| CMatrixOp | |
| CMatrixOp< T, 4 > | |
| CMatrixType | Tool class for selecting appropriate matrix type (Eigen or NCollection) |
| CMatrixType< T, 4 > | |
| CRadixSorter | Tool object for sorting link array using radix sort algorithm |
| CSurfaceCalculator | Tool class for calculating surface area of the box. For N=1, computes length (degenerate case). For N=2, computes area (or perimeter for degenerate boxes). For N>=3, computes 3D surface area using X, Y, Z components only. The W component (4th dimension) is intentionally ignored as BVH surface area heuristic (SAH) operates in 3D geometric space regardless of additional dimensions |
| CUnitVector | |
| CUnitVector< T, 2 > | |
| CUnitVector< T, 3 > | |
| CUnitVector< T, 4 > | |
| CUpdateBoundTask | Task for parallel bounds updating |
| CVecComp | Tool class for accessing specific vector component (by index) |
| CVecComp< T, 2 > | |
| CVecComp< T, 3 > | |
| CVecComp< T, 4 > | |
| CVectorType | Tool class for selecting appropriate vector type (Eigen or NCollection) |
| CVectorType< T, 1 > | |
| CVectorType< T, 2 > | |
| CVectorType< T, 3 > | |
| CVectorType< T, 4 > | |
| NExtremaPC | |
| CExtremumResult | Result of a single extremum computation |
| CResult | Result of extrema computation containing all found extrema. Non-copyable to enforce use of const reference from Perform() |
| CConfig | Configuration for extrema computation |
| NGeom2dEval_RepCurveDesc | |
| CMap1d | 1D affine parameter map: uRep = Scale * u + Offset |
| CDomain1d | 1D parameter domain interval |
| CBase | Abstract base descriptor for 2D curve evaluation representation. Holds the representation handle and a Kind tag for switch-based dispatch |
| CFull | Fully equivalent descriptor: no derivative limit, no domain, no map. Fastest evaluation path - direct delegation to Representation |
| CDerivBounded | Derivative-bounded descriptor: full domain, identity map, limited to MaxDerivOrder |
| CMapped | Mapped descriptor for 2D curve evaluation representation. Adds optional bounded domain and affine parameter map |
| NGeom2dGridEval | Namespace containing result structures for 2D curve grid evaluators |
| CCurveD1 | Result structure for curve D1 evaluation (point and first derivative) |
| CCurveD2 | Result structure for curve D2 evaluation (point and first two derivatives) |
| CCurveD3 | Result structure for curve D3 evaluation (point and first three derivatives) |
| NGeomEval_RepCurveDesc | |
| CMap1d | 1D affine parameter map: uRep = Scale * u + Offset |
| CDomain1d | 1D parameter domain interval |
| CBase | Abstract base descriptor for curve evaluation representation. Holds the representation handle and a Kind tag for switch-based dispatch |
| CFull | Fully equivalent descriptor: no derivative limit, no domain, no map. Fastest evaluation path - direct delegation to Representation |
| CDerivBounded | Derivative-bounded descriptor: full domain, identity map, limited to MaxDerivOrder |
| CMapped | Mapped descriptor for curve evaluation representation. Adds optional bounded domain and affine parameter map. Evaluation requires: domain check -> map parameter -> evaluate -> scale derivatives |
| NGeomEval_RepSurfaceDesc | |
| CMap2d | 2D diagonal affine parameter map with optional UV swap. Without swap: uRep = ScaleU*u + OffsetU, vRep = ScaleV*v + OffsetV. With swap: uRep = ScaleU*v + OffsetU, vRep = ScaleV*u + OffsetV |
| CDomain2d | 2D parameter domain |
| CBase | Abstract base descriptor for surface evaluation representation. Holds the representation handle and a Kind tag for switch-based dispatch |
| CFull | Fully equivalent descriptor: no derivative limit, no domain, no map. Fastest evaluation path - direct delegation to Representation |
| CDerivBounded | Derivative-bounded descriptor: full domain, identity map, limited to MaxDerivOrder |
| CMapped | Mapped descriptor for surface evaluation representation. Adds optional bounded domain and diagonal affine parameter map with optional UV swap. Evaluation requires: domain check -> map parameters -> evaluate -> scale derivatives. Future subclasses can support multi-region descriptors with per-patch UV domains and maps |
| NGraphic3d_TransformUtils | Helper class that implements transformation matrix functionality |
| CMatrixType | |
| CMatrixType< double > | |
| CMatrixType< float > | |
| CVectorType | |
| CVectorType< double > | |
| CVectorType< float > | |
| NLProp_CurveUtils | Template utility functions for CLProps curve local property computation. Provides access policies (DirectAccess, ToolAccess) and shared algorithms for evaluating derivatives, tangents, curvature, normals, and centres of curvature |
| CDirectAccess | Direct access policy: calls D0/D1/D2/D3 methods on the curve object. Works with occ::handle<T> and by-value curve types |
| CToolAccess | Tool-based access policy: delegates to static Tool methods. Used for HLRBRep types where Tool class provides the interface |
| NLProp_SurfaceUtils | Template utility functions for SLProps surface local property computation. Provides access policies (DirectAccess, ToolAccess), surface bounds helpers, and shared algorithms for evaluating derivatives, tangents, normals, and curvatures |
| CDirectAccess | Direct access policy: calls D0/D1/D2 methods on the surface object. Works with occ::handle<T> and by-value surface types |
| CToolAccess | Tool-based access policy: delegates to static Tool methods. Used for HLRBRep types where Tool class provides the interface |
| NMathInteg | Numerical integration algorithms |
| CDoubleExpConfig | Configuration for double exponential integration |
| CKronrodConfig | Configuration for Gauss-Kronrod integration |
| CMultipleConfig | Configuration for multi-dimensional Gauss integration |
| CSetResult | Result for vector function integration |
| NMathLin | |
| CCroutResult | Result for Crout LDL^T decomposition. Specialized for symmetric matrices |
| CEigenResult | Result for eigenvalue decomposition of tridiagonal matrix |
| CLeastSquaresResult | Result for least squares problems |
| CLUResult | Result for LU decomposition |
| CQRResult | Result for QR decomposition using Householder reflections |
| CSVDResult | Result for SVD decomposition |
| NMathOpt | Optimization algorithms for scalar and vector functions |
| CFRPRConfig | Configuration for FRPR conjugate gradient method |
| CGlobalConfig | Configuration for global optimization |
| CNewtonConfig | Configuration for Newton minimization with Hessian |
| CPSOConfig | Configuration for Particle Swarm Optimization |
| CPSOSeedParticle | Seed particle for PSO initialization |
| CPSOStats | Statistics collected during PSO execution |
| CUzawaConfig | Configuration for Uzawa algorithm |
| CUzawaResult | Result for Uzawa constrained optimization |
| NMathPoly | Polynomial root finding algorithms |
| CGeneralPolyResult | Result for general polynomial solver |
| NMathRoot | Root finding algorithms for scalar functions |
| CAllRootsResult | Result for all roots finder including null intervals |
| CMultipleBrentValueWrapper | Brent wrapper that adapts a Value-only function for offset root finding |
| CMultipleConfig | Configuration for multiple root finding |
| CMultipleDerivativeValueWrapper | Wrapper exposing a function derivative through the Value() contract required by Brent |
| CMultipleGetRootValueFn | Evaluates original (non-offset) function value at a root point via Value interface |
| CMultipleGetValueFn | Returns the sampled value at a given index from a math_Vector |
| CMultipleNoExtraHandler | No-op interval handler for functions without derivative |
| CMultipleResult | Result for multiple root finding. Contains all found roots sorted in ascending order |
| CMultipleSampleValueFn | Samples a Value-only function and stores f(x)-offset into a math_Vector |
| CNullInterval | Represents an interval where the function is null (within tolerance) |
| CTrigResult | Result for trigonometric equation solver |
| NMathSys | Shared types for specialized small-dimension Newton solvers |
| CLMConfig | Configuration for Levenberg-Marquardt algorithm. Extends base Config with damping parameter settings |
| CNewtonBoundsN | Box bounds for N-dimensional solver |
| CNewtonOptions | Solver options for small-dimension Newton methods |
| CNewtonResultN | Result of N-dimensional Newton solver |
| NMathUtils | Modern math solver types and result structures |
| CAckley | Ackley function functor (for testing global optimization). f(x) = -a*exp(-b*sqrt(sum(x[i]^2)/n)) - exp(sum(cos(c*x[i]))/n) + a + e Default: a = 20, b = 0.2, c = 2*pi Global minimum at origin with f = 0 |
| CBeale | Beale function functor (for testing optimization). f(x,y) = (1.5 - x + xy)^2 + (2.25 - x + xy^2)^2 + (2.625 - x + xy^3)^2 Global minimum at (3, 0.5) with f = 0 |
| CBooth | Booth function functor (for testing optimization). f(x,y) = (x + 2y - 7)^2 + (2x + y - 5)^2 Global minimum at (1, 3) with f = 0 |
| CBoundedConfig | Configuration for bounded 1D optimization and root finding. Extends Config with interval bounds |
| CBracketResult | Result of root bracketing operation |
| CComposite | Composite functor: f(g(x)). Evaluates the outer function at the result of the inner function |
| CConfig | Configuration for iterative solvers. Provides common settings for convergence criteria and iteration limits |
| CConstant | Constant function functor: f(x) = c |
| CCosine | Cosine function functor: f(x) = a * cos(b*x + c) + d |
| CDecompResult | Result for matrix decomposition (LU, SVD, QR). Structure depends on decomposition type |
| CDifference | Difference of functions functor: f(x) - g(x) |
| CDomain1D | 1D parameter domain for curves |
| CDomain2D | 2D parameter domain for surfaces |
| CEigenResult | Result for eigenvalue/eigenvector computation. Contains eigenvalues and optionally eigenvectors |
| CExponential | Exponential function functor: f(x) = a * exp(b*x) + c |
| CGaussian | Gaussian function functor: f(x) = a * exp(-((x-mu)^2)/(2*sigma^2)) |
| CHimmelblau | Himmelblau function functor (for testing optimization). f(x,y) = (x^2 + y - 11)^2 + (x + y^2 - 7)^2 Has four local minima, all with f = 0: (3.0, 2.0), (-2.805118, 3.131312), (-3.779310, -3.283186), (3.584428, -1.848126) |
| CIntegConfig | Configuration for numerical integration. Provides settings for quadrature order and adaptive refinement |
| CIntegResult | Result for numerical integration. Contains integral value and error estimates |
| CInverseResult | Result for matrix inverse computation. Contains the inverse matrix if computation succeeded |
| CLinConfig | Configuration for linear algebra solvers. Provides settings for singularity detection and pivoting |
| CLinear | Linear function functor: f(x) = a*x + b |
| CLinearMultipleResult | Result for multiple linear systems solving (AX = B with matrix RHS). Contains the full solution matrix and determinant if computed |
| CLinearResidual | Linear system residual functor: f(x) = ||Ax - b||^2. Useful for solving overdetermined linear systems via optimization |
| CLinearResult | Result for linear system solving (Ax = b). Contains the solution vector and matrix determinant if computed |
| CLineSearchResult | Result of line search operation |
| CMinBracketOptions | Options for minimum bracketing |
| CMinBracketResult | Result of minimum bracketing operation |
| CNDimConfig | Configuration for N-dimensional optimization with optional bounds. Bounds are passed separately as math_Vector for flexibility |
| CNegated | Negated function functor: -f(x) |
| CPolynomial | Polynomial functor: f(x) = sum(a[i] * x^i). Coefficients are stored in order: a[0] + a[1]*x + a[2]*x^2 + .. |
| CPolyResult | Result for polynomial root finding. Supports up to 4 real roots (for quartic equations) |
| CPower | Power function functor: f(x) = a * x^n + b |
| CProduct | Product of functions functor: f(x) * g(x) |
| CQuadraticForm | Quadratic form functor: f(x) = x^T A x + b^T x + c. Commonly used for testing optimization algorithms |
| CQuotient | Quotient of functions functor: f(x) / g(x) |
| CRandomGenerator | High-quality pseudo-random number generator based on xoshiro256** |
| CRastrigin | Rastrigin function functor (for testing global optimization). f(x) = A*n + sum(x[i]^2 - A*cos(2*pi*x[i])) for all i Default: A = 10 Global minimum at origin with f = 0. Highly multimodal - challenging for local optimizers |
| CRational | Rational function functor: f(x) = P(x) / Q(x). Both numerator P and denominator Q are polynomials |
| CRosenbrock | Rosenbrock function functor (for testing optimization). f(x,y) = (a - x)^2 + b*(y - x^2)^2 Default: a = 1, b = 100 Global minimum at (a, a^2) = (1, 1) with f = 0 |
| CScalarLambda | Lambda wrapper for scalar functions with value only. Wraps a lambda/callable into a functor with Value() method |
| CScalarLambdaWithDerivative | Lambda wrapper for scalar functions with value and derivative. Wraps a lambda/callable into a functor with Values() method |
| CScalarResult | Result for scalar (1D) root finding and minimization. Contains the found root/minimum location and diagnostic information |
| CScaled | Scaled function functor: c * f(x) |
| CShifted | Shifted function functor: f(x) + c |
| CSine | Sine function functor: f(x) = a * sin(b*x + c) + d |
| CSphere | Sphere function functor (for testing optimization). f(x) = sum(x[i]^2) for all i. Global minimum at origin with f = 0 |
| CSum | Sum of functions functor: f(x) + g(x) |
| CSystemLambda | Nonlinear system functor: F(x) = [f1(x), f2(x), ..., fn(x)]. Lambda wrapper for systems of nonlinear equations |
| CVectorLambda | Lambda wrapper for N-D objective functions (value only). Wraps a lambda/callable into a functor with Value() method |
| CVectorLambdaWithGradient | Lambda wrapper for N-D objective functions with gradient. Wraps a lambda/callable into a functor with Value() and Gradient() methods |
| CVectorResult | Result for N-dimensional optimization and system solving. Contains the solution vector and optional gradient/Jacobian information |
| NNCollection_ForwardRangeDetail | |
| CHasValue | SFINAE: detect .Value() const |
| CHasValue< T, std::void_t< decltype(std::declval< const T & >().Value())> > | |
| CHasCurrent | SFINAE: detect .Current() const |
| CHasCurrent< T, std::void_t< decltype(std::declval< const T & >().Current())> > | |
| CHasCurrentId | SFINAE: detect .CurrentId() const |
| CHasCurrentId< T, std::void_t< decltype(std::declval< const T & >().CurrentId())> > | |
| CAccessorTraits | Accessor dispatch trait: resolves to the correct value accessor and its return type. Uses std::enable_if_t for mutually-exclusive priority selection |
| CAccessorTraits< T, std::enable_if_t< HasValue< T >::value > > | Priority 1: has Value() |
| CAccessorTraits< T, std::enable_if_t<!HasValue< T >::value &&HasCurrent< T >::value > > | Priority 2: has Current() but not Value() |
| CAccessorTraits< T, std::enable_if_t<!HasValue< T >::value &&!HasCurrent< T >::value &&HasCurrentId< T >::value > > | Priority 3: has CurrentId() but not Value() or Current() |
| CArrowProxy | Proxy for operator-> when the accessor returns a value (not a reference) |
| NNCollection_ItemsView | |
| CKeyValueRef | Key-value pair reference for structured binding support. Enables: for (auto [key, value] : map.Items()) |
| CKeyValueIndexRef | Key-value-index tuple reference for structured binding support. Enables: for (auto [key, value, index] : map.IndexedItems()) |
| CKeyIndexRef | Key-index pair reference for structured binding support (key-only indexed maps). Enables: for (auto [key, index] : map.IndexedItems()) |
| CIterator | Generic forward iterator for View classes |
| CView | Generic view class for Items() iteration |
| Nopencascade | Namespace opencascade is intended for low-level template classes and functions |
| Cdisable_deduction | The auxiliary template that is used for template argument deduction in function templates. A function argument which type is a template type parameter and it is not needed to be deducted must be declared using this class template based on the type of some other template type parameter of a function template |
| Chandle | Intrusive smart pointer for use with Standard_Transient class and its descendants |
| Cis_base_but_not_same | Trait yielding true if class T1 is base of T2 but not the same |
| Cis_base_but_not_same< T1, T2, typename opencascade::std::enable_if< opencascade::std::is_same< T1, T2 >::value >::type > | Explicit specialization of is_base_of trait to workaround the requirement of type to be complete when T1 and T2 are the same |
| Cis_integer | The type trait that checks if the passed type is integer (it must be integral and not boolean) |
| NOpenGl | |
| CVectorType | Tool class for selecting appropriate vector type |
| CVectorType< double > | |
| CVectorType< float > | |
| CMatrixType | Tool class for selecting appropriate matrix type |
| CMatrixType< double > | |
| CMatrixType< float > | |
| NOpenGl_HashMapInitializer | |
| CMapListOfType | |
| Nstd | STL namespace |
| Cequal_to< gp_Pnt > | |
| Cequal_to< occ::handle< Image_Texture > > | |
| Cequal_to< occ::handle< TCollection_HExtendedString > > | |
| Cequal_to< occ::handle< VrmlData_Node > > | |
| Cequal_to< Poly_MakeLoops::Link > | |
| Chash< BOPDS_Pair > | |
| Chash< BOPDS_Pave > | |
| Chash< BOPTools_Set > | |
| Chash< BRepGraph_ItemId > | Std::hash specialization for BRepGraph_ItemId |
| Chash< BRepGraph_ItemUID > | Std::hash specialization for NCollection_DefaultHasher support |
| Chash< BRepGraph_NodeId > | Std::hash specialization for BRepGraph_NodeId |
| Chash< BRepGraph_NodeId::Typed< TheKind > > | Std::hash specialization for BRepGraph_NodeId::Typed |
| Chash< BRepGraph_RefId > | |
| Chash< BRepGraph_RefId::Typed< TheKind > > | |
| Chash< BRepGraph_RefUID > | |
| Chash< BRepGraph_RepId > | |
| Chash< BRepGraph_RepId::Typed< TheKind > > | |
| Chash< BRepGraph_UID > | Std::hash specialization for NCollection_DefaultHasher support |
| Chash< BRepGraph_UsagePath > | Std::hash specialization for BRepGraph_UsagePath |
| Chash< BRepGraph_VersionStamp > | Std::hash specialization for NCollection_DefaultHasher support |
| Chash< BRepGraphInc::Instance< TypedIdT > > | Std::hash specialization for BRepGraphInc::Instance<T> |
| Chash< BRepMesh_Edge > | |
| Chash< BRepMesh_OrientedEdge > | |
| Chash< BRepMesh_Triangle > | |
| Chash< BRepMesh_Vertex > | |
| Chash< gp_Pnt > | |
| Chash< Handle< TheTransientType > > | |
| Chash< IntPolyh_Couple > | |
| Chash< IntTools_CurveRangeSample > | |
| Chash< MAT2d_BiInt > | |
| Chash< MeshVS_TwoColors > | |
| Chash< MeshVS_TwoNodes > | |
| Chash< occ::handle< Font_SystemFont > > | |
| Chash< occ::handle< Image_Texture > > | |
| Chash< occ::handle< TCollection_HExtendedString > > | |
| Chash< occ::handle< VrmlData_Node > > | |
| Chash< Poly_MakeLoops::Link > | |
| Chash< Quantity_Color > | |
| Chash< Quantity_ColorRGBA > | |
| Chash< Standard_GUID > | |
| Chash< StepToTopoDS_PointPair > | |
| Chash< TCollection_ExtendedString > | |
| Chash< TopoDS_Compound > | |
| Chash< TopoDS_CompSolid > | |
| Chash< TopoDS_Edge > | |
| Chash< TopoDS_Face > | |
| Chash< TopoDS_Shape > | |
| Chash< TopoDS_Shell > | |
| Chash< TopoDS_Solid > | |
| Chash< TopoDS_Vertex > | |
| Chash< TopoDS_Wire > | |
| Chash< XCAFDoc_AssemblyItemId > | |
| Chash< XCAFPrs_DocumentNode > | |
| Chash< XCAFPrs_Style > | |
| Ctuple_element< 0, NCollection_ItemsView::KeyIndexRef< TheKeyType > > | |
| Ctuple_element< 0, NCollection_ItemsView::KeyValueIndexRef< TheKeyType, TheValueType, IsConst > > | |
| Ctuple_element< 0, NCollection_ItemsView::KeyValueRef< TheKeyType, TheValueType, IsConst > > | |
| Ctuple_element< 1, NCollection_ItemsView::KeyIndexRef< TheKeyType > > | |
| Ctuple_element< 1, NCollection_ItemsView::KeyValueIndexRef< TheKeyType, TheValueType, IsConst > > | |
| Ctuple_element< 1, NCollection_ItemsView::KeyValueRef< TheKeyType, TheValueType, IsConst > > | |
| Ctuple_element< 2, NCollection_ItemsView::KeyValueIndexRef< TheKeyType, TheValueType, IsConst > > | |
| Ctuple_size< NCollection_ItemsView::KeyIndexRef< TheKeyType > > | |
| Ctuple_size< NCollection_ItemsView::KeyValueIndexRef< TheKeyType, TheValueType, IsConst > > | |
| Ctuple_size< NCollection_ItemsView::KeyValueRef< TheKeyType, TheValueType, IsConst > > | |
| Nstep | |
| Cparser | A Bison parser |
| Csyntax_error | Syntax errors thrown from user actions |
| Ctoken | Token kinds |
| Csymbol_kind | Symbol kinds |
| Cbasic_symbol | A complete symbol |
| Cby_kind | Type access provider for token (enum) based symbols |
| Csymbol_type | "External" symbols: returned by the scanner |
| Ccontext | |
| Cscanner | |
| C_file_ace | |
| CAdaptor2d_Curve2d | Root class for 2D curves on which geometric algorithms work. An adapted curve is an interface between the services provided by a curve, and those required of the curve by algorithms, which use it. A derived concrete class is provided: Geom2dAdaptor_Curve for a curve from the Geom2d package |
| CAdaptor2d_Line2d | Use by the TopolTool to trim a surface |
| CAdaptor2d_OffsetCurve | Defines an Offset curve (algorithmic 2d curve) |
| CAdaptor3d_Curve | Root class for 3D curves on which geometric algorithms work. An adapted curve is an interface between the services provided by a curve and those required of the curve by algorithms which use it. Two derived concrete classes are provided: |
| CAdaptor3d_CurveOnSurface | An interface between the services provided by a curve lying on a surface from the package Geom and those required of the curve by algorithms which use it. The curve is defined as a 2D curve from the Geom2d package, in the parametric space of the surface |
| CAdaptor3d_HSurfaceTool | |
| CAdaptor3d_HVertex | |
| CAdaptor3d_InterFunc | Used to find the points U(t) = U0 or V(t) = V0 in order to determine the Cn discontinuities of an Adpator_CurveOnSurface relatively to the discontinuities of the surface. Used to find the roots of the functions |
| CAdaptor3d_IsoCurve | Defines an isoparametric curve on a surface. The type of isoparametric curve (U or V) is defined with the enumeration IsoType from GeomAbs if NoneIso is given an error is raised |
| CAdaptor3d_Surface | Root class for surfaces on which geometric algorithms work. An adapted surface is an interface between the services provided by a surface and those required of the surface by algorithms which use it. A derived concrete class is provided: GeomAdaptor_Surface for a surface from the Geom package. The Surface class describes the standard behaviour of a surface for generic algorithms |
| CAdaptor3d_TopolTool | This class provides a default topological tool, based on the Umin,Vmin,Umax,Vmax of an HSurface from Adaptor3d. All methods and fields may be redefined when inheriting from this class. This class is used to instantiate algorithms as Intersection, outlines,.. |
| CAdvApp2Var_ApproxAFunc2Var | Perform the approximation of <Func> F(U,V) Arguments are : Num1DSS, Num2DSS, Num3DSS :The numbers of 1,2,3 dimensional subspaces OneDTol, TwoDTol, ThreeDTol: The tolerance of approximation in each subspaces OneDTolFr, TwoDTolFr, ThreeDTolFr: The tolerance of approximation on the boundaries in each subspaces [FirstInU, LastInU]: The Bounds in U of the Approximation [FirstInV, LastInV]: The Bounds in V of the Approximation FavorIso : Give preference to extract u-iso or v-iso on F(U,V) This can be useful to optimize the <Func> method ContInU, ContInV : Continuity waiting in u and v PrecisCode : Precision on approximation's error measurement 1 : Fast computation and average precision 2 : Average computation and good precision 3 : Slow computation and very good precision MaxDegInU : Maximum u-degree waiting in U MaxDegInV : Maximum u-degree waiting in V Warning: MaxDegInU (resp. MaxDegInV) must be >= 2*iu (resp. iv) + 1, where iu (resp. iv) = 0 if ContInU (resp. ContInV) = GeomAbs_C0, = 1 if = GeomAbs_C1, = 2 if = GeomAbs_C2. MaxPatch : Maximum number of Patch waiting number of Patch is number of u span * number of v span Func : The external method to evaluate F(U,V) Crit : To (re)defined condition of convergence UChoice, VChoice : To define the way in U (or V) Knot insertion Warning: for the moment, the result is a 3D Surface so Num1DSS and Num2DSS must be equals to 0 and Num3DSS must be equal to 1. Warning: the Function of type EvaluatorFunc2Var from Approx must be a subclass of AdvApp2Var_EvaluatorFunc2Var |
| CAdvApp2Var_ApproxF2var | |
| CAdvApp2Var_Context | All the parameters for approximation (tolerancy, computing option, ...) |
| CAdvApp2Var_Criterion | This class contains a given criterion to be satisfied |
| CAdvApp2Var_EvaluatorFunc2Var | |
| CAdvApp2Var_Framework | |
| CAdvApp2Var_Iso | Used to store constraints on a line U = Ui or V = Vj |
| CAdvApp2Var_MathBase | |
| CAdvApp2Var_Network | |
| CAdvApp2Var_Node | Used to store constraints on a (Ui,Vj) point |
| CAdvApp2Var_Patch | Used to store results on a domain [Ui,Ui+1]x[Vj,Vj+1] |
| CAdvApp2Var_SysBase | |
| CAdvApprox_ApproxAFunction | This approximate a given function |
| CAdvApprox_Cutting | To choose the way of cutting in approximation |
| CAdvApprox_DichoCutting | If Cutting is necessary in [a,b], we cut at (a+b) / 2 |
| CAdvApprox_EvaluatorFunction | Interface for a class implementing a function to be approximated by AdvApprox_ApproxAFunction |
| CAdvApprox_PrefAndRec | Inherits class Cutting; contains a list of preferential points (pi)i and a list of Recommended points used in cutting management. if Cutting is necessary in [a,b], we cut at the di nearest from (a+b)/2 |
| CAdvApprox_PrefCutting | Inherits class Cutting; contains a list of preferential points (di)i if Cutting is necessary in [a,b], we cut at the di nearest from (a+b)/2 |
| CAdvApprox_SimpleApprox | Approximate a function on an interval [First,Last] The result is a simple polynomial whose degree is as low as possible to satisfy the required tolerance and the maximum degree. The maximum error and the average error resulting from approximating the function by the polynomial are computed |
| CAIS | Application Interactive Services provide the means to create links between an application GUI viewer and the packages which are used to manage selection and presentation. The tools AIS defined in order to do this include different sorts of entities: both the selectable viewable objects themselves and the context and attribute managers to define their selection and display. To orient the user as he works in a modeling environment, views and selections must be comprehensible. There must be several different sorts of selectable and viewable object defined. These must also be interactive, that is, connecting graphic representation and the underlying reference geometry. These entities are called Interactive Objects, and are divided into four types: |
| CAIS_Animation | Class represents a basic animation class. AIS_Animation can be used as: |
| CAIS_AnimationAxisRotation | Animation defining object transformation |
| CAIS_AnimationCamera | Camera animation |
| CAIS_AnimationObject | Animation defining object transformation |
| CAIS_AnimationProgress | Structure defining current animation progress |
| CAIS_AttributeFilter | Selects Interactive Objects, which have the desired width or color. The filter questions each Interactive Object in local context to determine whether it has an non-null owner, and if so, whether it has the required color and width attributes. If the object returns true in each case, it is kept. If not, it is rejected. This filter is used only in an open local context. In the Collector viewer, you can only locate Interactive Objects, which answer positively to the filters, which are in position when a local context is open |
| CAIS_Axis | Locates the x, y and z axes in an Interactive Object. These are used to orient it correctly in presentations from different viewpoints, or to construct a revolved shape, for example, from one of the axes. Conversely, an axis can be created to build a revolved shape and then situated relative to one of the axes of the view |
| CAIS_BadEdgeFilter | A Class |
| CAIS_BaseAnimationObject | Animation defining object transformation |
| CAIS_C0RegularityFilter | |
| CAIS_CameraFrustum | Presentation for drawing camera frustum. Default configuration is built with filling and some transparency |
| CAIS_Circle | Constructs circle datums to be used in construction of composite shapes |
| CAIS_ColoredDrawer | Customizable properties |
| CAIS_ColoredShape | Presentation of the shape with customizable sub-shapes properties |
| CAIS_ColorScale | Class for drawing a custom color scale |
| CAIS_ConnectedInteractive | Creates an arbitrary located instance of another Interactive Object, which serves as a reference. This allows you to use the Connected Interactive Object without having to recalculate presentation, selection or graphic structure. These are deduced from your reference object. The relation between the connected interactive object and its source is generally one of geometric transformation. AIS_ConnectedInteractive class supports selection mode 0 for any InteractiveObject and all standard modes if its reference based on AIS_Shape. Descendants may redefine ComputeSelection() though. Also ConnectedInteractive will handle HLR if its reference based on AIS_Shape |
| CAIS_ExclusionFilter | A framework to reject or to accept only objects of given types and/or signatures. Objects are stored, and the stored objects - along with the flag settings - are used to define the filter. Objects to be filtered are compared with the stored objects added to the filter, and are accepted or rejected according to the exclusion flag setting |
| CAIS_GlobalStatus | Stores information about objects in graphic context: |
| CAIS_GraphicTool | |
| CAIS_InteractiveContext | The Interactive Context allows you to manage graphic behavior and selection of Interactive Objects in one or more viewers. Class methods make this highly transparent. It is essential to remember that an Interactive Object which is already known by the Interactive Context must be modified using Context methods. You can only directly call the methods available for an Interactive Object if it has not been loaded into an Interactive Context |
| CAIS_InteractiveObject | Defines a class of objects with display and selection services. Entities which are visualized and selected are Interactive Objects. Specific attributes of entities such as arrow aspect for dimensions must be loaded in a Prs3d_Drawer |
| CAIS_LightSource | Interactive object for a light source. Each type of light source has it's own presentation: |
| CAIS_LightSourceOwner | Owner of AIS_LightSource presentation |
| CAIS_Line | Constructs line datums to be used in construction of composite shapes |
| CAIS_Manipulator | Interactive object class to manipulate local transformation of another interactive object or a group of objects via mouse. It manages three types of manipulations in 3D space: |
| COptionsForAttach | Behavior settings to be applied when performing transformation: |
| CBehaviorOnTransform | Behavior settings to be applied when performing transformation: |
| CQuadric | |
| CDisk | |
| CSphere | |
| CCube | |
| CSector | |
| CAxis | The class describes on axis sub-object. It includes sub-objects itself: -rotator -translator -scaler |
| CAIS_ManipulatorOwner | Entity owner for selection management of AIS_Manipulator object |
| CAIS_MediaPlayer | Presentation for video playback |
| CAIS_MultipleConnectedInteractive | Defines an Interactive Object by gathering together several object presentations. This is done through a list of interactive objects. These can also be Connected objects. That way memory-costly calculations of presentation are avoided |
| CAIS_Plane | Constructs plane datums to be used in construction of composite shapes |
| CAIS_PlaneTrihedron | To construct a selectable 2d axis system in a 3d drawing. This can be placed anywhere in the 3d system, and provides a coordinate system for drawing curves and shapes in a plane. There are 3 selection modes: |
| CAIS_Point | Constructs point datums to be used in construction of composite shapes. The datum is displayed as the plus marker + |
| CAIS_PointCloud | Interactive object for set of points. The presentation supports two display modes: |
| CAIS_PointCloudOwner | Custom owner for highlighting selected points |
| CAIS_RubberBand | Presentation for drawing rubber band selection. It supports rectangle and polygonal selection. It is constructed in 2d overlay. Default configuration is built without filling. For rectangle selection use SetRectangle() method. For polygonal selection use AddPoint() and GetPoints() methods |
| CAIS_Selection | Class holding the list of selected owners |
| CAIS_Shape | A framework to manage presentation and selection of shapes. AIS_Shape is the interactive object which is used the most by applications. There are standard functions available which allow you to prepare selection operations on the constituent elements of shapes - vertices, edges, faces etc - in an open local context. The selection modes specific to "Shape" type objects are referred to as Standard Activation Mode. These modes are only taken into account in open local context and only act on Interactive Objects which have redefined the virtual method AcceptShapeDecomposition so that it returns true. Several advanced functions are also available. These include functions to manage deviation angle and deviation coefficient - both HLR and non-HLR - of an inheriting shape class. These services allow you to select one type of shape interactive object for higher precision drawing. When you do this, the Prs3d_Drawer::IsOwn... functions corresponding to the above deviation angle and coefficient functions return true indicating that there is a local setting available for the specific object |
| CAIS_SignatureFilter | Selects Interactive Objects through their signatures and types. The signature provides an additional characterization of an object's type, and takes the form of an index. The filter questions each Interactive Object in local context to determine whether it has an non-null owner, and if so, whether it has the desired signature. If the object returns true in each case, it is kept. If not, it is rejected. By default, the interactive object has a None type and a signature of 0. If you want to give a particular type and signature to your Interactive Object, you must redefine two virtual methods: Type and Signature. This filter is only used in an open local contexts. In the Collector viewer, you can only locate Interactive Objects which answer positively to the positioned filters when a local context is open. Warning Some signatures have already been used by standard objects delivered in AIS. These include: |
| CAIS_TextLabel | Presentation of the text |
| CAIS_TexturedShape | This class allows to map textures on shapes. Presentations modes AIS_WireFrame (0) and AIS_Shaded (1) behave in the same manner as in AIS_Shape, whilst new modes 2 (bounding box) and 3 (texture mapping) extends it functionality |
| CAIS_Triangulation | Interactive object that draws data from Poly_Triangulation, optionally with colors associated with each triangulation vertex. For maximum efficiency colors are represented as 32-bit integers instead of classic Quantity_Color values. Interactive selection of triangles and vertices is not yet implemented |
| CAIS_Trihedron | Create a selectable trihedron The trihedron includes 1 origin, 3 axes and 3 labels. Default text of labels are "X", "Y", "Z". Color of origin and any axis, color of arrows and labels may be changed. Visual presentation might be shown in two, shaded and wireframe modes, wireframe by default). There are 4 modes of selection: |
| CAIS_TrihedronOwner | Entity owner for selection management of AIS_Trihedron object |
| CAIS_TypeFilter | Selects Interactive Objects through their types. The filter questions each Interactive Object in local context to determine whether it has an non-null owner, and if so, whether it is of the desired type. If the object returns true in each case, it is kept. If not, it is rejected. By default, the interactive object has a None type and a signature of 0. A filter for type specifies a choice of type out of a range at any level enumerated for type or kind. The choice could be for kind of interactive object, of dimension, of unit, or type of axis, plane or attribute. If you want to give a particular type and signature to your Interactive Object, you must redefine two virtual methods: Type and Signature. This filter is used in both Neutral Point and open local contexts. In the Collector viewer, you can only locate Interactive Objects which answer positively to the positioned filters when a local context is open. Warning When you close a local context, all temporary interactive objects are deleted, all selection modes concerning the context are cancelled, and all content filters are emptied |
| CAIS_ViewController | Auxiliary structure for handling viewer events between GUI and Rendering threads |
| CAIS_ViewCube | Interactive object for displaying the view manipulation cube |
| CAIS_ViewCubeOwner | Redefined entity owner that is highlighted when owner is detected, even if Interactive Context highlighted on last detection procedure |
| CAIS_ViewCubeSensitive | Simple sensitive element for picking by point only |
| CAIS_ViewInputBuffer | Auxiliary structure defining viewer events |
| C_orientation | |
| C_highlighting | |
| C_selection | |
| C_panningParams | |
| C_draggingParams | |
| C_orbitRotation | |
| C_viewRotation | |
| C_zrotateParams | |
| CAIS_WalkDelta | Walking values |
| CAIS_WalkPart | Walking value |
| CAIS_XRTrackedDevice | Auxiliary textured mesh presentation of tracked XR device |
| CAPIHeaderSection_EditHeader | |
| CAPIHeaderSection_MakeHeader | This class allows to consult and prepare/edit data stored in a Step Model Header |
| CAppBlend_Approx | Bspline approximation of a surface |
| CAppCont_Function | Class describing a continuous 3d and/or function f(u). This class must be provided by the user to use the approximation algorithm FittingCurve |
| CAppCont_LeastSquare | |
| CAppDef_BSpGradient_BFGSOfMyBSplGradientOfBSplineCompute | |
| CAppDef_BSplineCompute | |
| CAppDef_BSpParFunctionOfMyBSplGradientOfBSplineCompute | |
| CAppDef_BSpParLeastSquareOfMyBSplGradientOfBSplineCompute | |
| CAppDef_Compute | |
| CAppDef_Gradient_BFGSOfMyGradientbisOfBSplineCompute | |
| CAppDef_Gradient_BFGSOfMyGradientOfCompute | |
| CAppDef_Gradient_BFGSOfTheGradient | |
| CAppDef_LinearCriteria | Defined an Linear Criteria to used in variational Smoothing of points |
| CAppDef_MultiLine | This class describes the organized set of points used in the approximations. A MultiLine is composed of n MultiPointConstraints. The approximation of the MultiLine will be done in the order of the given n MultiPointConstraints |
| CAppDef_MultiPointConstraint | Describes a MultiPointConstraint used in a Multiline. MultiPointConstraints are composed of several two or three-dimensional points. The purpose is to define the corresponding points that share a common constraint in order to compute the approximation of several lines in parallel. Notes: |
| CAppDef_MyBSplGradientOfBSplineCompute | |
| CAppDef_MyGradientbisOfBSplineCompute | |
| CAppDef_MyGradientOfCompute | |
| CAppDef_MyLineTool | Example of MultiLine tool corresponding to the tools of the packages AppParCurves and Approx. For Approx, the tool will not add points if the algorithms want some |
| CAppDef_ParFunctionOfMyGradientbisOfBSplineCompute | |
| CAppDef_ParFunctionOfMyGradientOfCompute | |
| CAppDef_ParFunctionOfTheGradient | |
| CAppDef_ParLeastSquareOfMyGradientbisOfBSplineCompute | |
| CAppDef_ParLeastSquareOfMyGradientOfCompute | |
| CAppDef_ParLeastSquareOfTheGradient | |
| CAppDef_ResConstraintOfMyGradientbisOfBSplineCompute | |
| CAppDef_ResConstraintOfMyGradientOfCompute | |
| CAppDef_ResConstraintOfTheGradient | |
| CAppDef_SmoothCriterion | Defined criterion to smooth points in curve |
| CAppDef_TheFunction | |
| CAppDef_TheGradient | |
| CAppDef_TheLeastSquares | |
| CAppDef_TheResol | |
| CAppDef_Variational | This class is used to smooth N points with constraints by minimization of quadratic criterium but also variational criterium in order to obtain " fair Curve " Computes the approximation of a Multiline by Variational optimization |
| CAppParCurves | Parallel Approximation in n curves. This package gives all the algorithms used to approximate a MultiLine described by the tool MLineTool. The result of the approximation will be a MultiCurve |
| CAppParCurves_ConstraintCouple | Associates an index and a constraint for an object. This couple is used by AppDef_TheVariational when performing approximations |
| CAppParCurves_MultiBSpCurve | This class describes a MultiBSpCurve approximating a Multiline. Just as a Multiline is a set of a given number of lines, a MultiBSpCurve is a set of a specified number of bsplines defined by: |
| CAppParCurves_MultiCurve | This class describes a MultiCurve approximating a Multiline. As a Multiline is a set of n lines, a MultiCurve is a set of n curves. These curves are Bezier curves. A MultiCurve is composed of m MultiPoint. The approximating degree of these n curves is the same for each one |
| CAppParCurves_MultiPoint | This class describes Points composing a MultiPoint. These points can be 2D or 3D. The user must first give the 3D Points and then the 2D Points. They are Poles of a Bezier Curve. This class is used either to define data input or results when performing the approximation of several lines in parallel |
| CApprox_Curve2d | Makes an approximation for HCurve2d from Adaptor3d |
| CApprox_Curve3d | |
| CApprox_CurveOnSurface | Approximation of curve on surface |
| CApprox_CurvilinearParameter | Approximation of a Curve to make its parameter be its curvilinear abscissa. If the curve is a curve on a surface S, C2D is the corresponding Pcurve, we consider the curve is given by its representation |
| CApprox_CurvlinFunc | Defines an abstract curve with curvilinear parametrization |
| CApprox_FitAndDivide | |
| CApprox_FitAndDivide2d | |
| CApprox_MCurvesToBSpCurve | |
| CApprox_SameParameter | Approximation of a PCurve on a surface to make its parameter be the same that the parameter of a given 3d reference curve |
| CApprox_SweepApproximation | Approximation of an Surface S(u,v) (and eventually associate 2d Curves) defined by section's law |
| CApprox_SweepFunction | Defined the function used by SweepApproximation to perform sweeping application |
| CApproxInt_KnotTools | This class intended to build knots sequence on discrete set of points for further approximation into bspline curve |
| CApproxInt_SvSurfaces | This class is root class for classes dedicated to calculate 2d and 3d points and tangents of intersection lines of two surfaces of different types for given u, v parameters of intersection point on two surfaces |
| CAppStd_Application | Legacy class defining resources name for standard OCAF documents |
| CAppStdL_Application | Legacy class defining resources name for lite OCAF documents |
| CAspect_Background | This class allows the definition of a window background |
| CAspect_CircularGrid | |
| CAspect_DisplayConnection | This class creates and provides connection with X server. Raises exception if can not connect to X server. On Windows and Mac OS X (in case when Cocoa used) platforms this class does nothing. WARNING: Do not close display connection manually! |
| CAspect_FrustumLRBT | Structure defining frustum boundaries |
| CAspect_GenId | This class permits the creation and control of integer identifiers |
| CAspect_GradientBackground | This class allows the definition of a window gradient background |
| CAspect_Grid | |
| CAspect_GridParams | Grid appearance for V3d_View::GridDisplay: color, scale, bounds, arc, draw mode, background and adaptive flags |
| CAspect_NeutralWindow | Defines a platform-neutral window. This class is intended to be used in context when window management (including OpenGL context creation) is performed on application side (e.g. using external framework) |
| CAspect_OpenVRSession | OpenVR wrapper implementing Aspect_XRSession interface |
| CAspect_RectangularGrid | |
| CAspect_ScrollDelta | Parameters for mouse scroll action |
| CAspect_SkydomeBackground | This class allows the definition of a window skydome background |
| CAspect_Touch | Structure holding touch position - original and current location |
| CAspect_TrackedDevicePose | Describes a single pose for a tracked object (for XR) |
| CAspect_VKeySet | Structure defining key state |
| CAspect_Window | Defines a window |
| CAspect_WindowInputListener | Defines a listener for window input events |
| CAspect_XRAction | XR action definition |
| CAspect_XRActionSet | XR action set |
| CAspect_XRAnalogActionData | Analog input XR action data |
| CAspect_XRDigitalActionData | Digital input XR action data |
| CAspect_XRHapticActionData | Haptic output XR action data |
| CAspect_XRPoseActionData | Pose input XR action data |
| CAspect_XRSession | Extended Reality (XR) Session interface |
| CBinDrivers | |
| CBinDrivers_DocumentRetrievalDriver | |
| CBinDrivers_DocumentStorageDriver | Persistent implementation of storage a document in a binary file |
| CBinLDrivers | |
| CBinLDrivers_DocumentRetrievalDriver | |
| CBinLDrivers_DocumentSection | More or less independent part of the saved/restored document that is distinct from OCAF data themselves but may be referred by them |
| CBinLDrivers_DocumentStorageDriver | Persistent implementation of storage a document in a binary file |
| CBinMDataStd | Storage and Retrieval drivers for modelling attributes |
| CBinMDataStd_AsciiStringDriver | TDataStd_AsciiString attribute Driver |
| CBinMDataStd_BooleanArrayDriver | |
| CBinMDataStd_BooleanListDriver | |
| CBinMDataStd_ByteArrayDriver | |
| CBinMDataStd_ExpressionDriver | Attribute Driver |
| CBinMDataStd_ExtStringArrayDriver | Array of extended string attribute Driver |
| CBinMDataStd_ExtStringListDriver | |
| CBinMDataStd_GenericEmptyDriver | GenericEmpty attribute driver |
| CBinMDataStd_GenericExtStringDriver | TDataStd_Name attribute Driver |
| CBinMDataStd_IntegerArrayDriver | Array of Integer attribute Driver |
| CBinMDataStd_IntegerDriver | Integer attribute Driver |
| CBinMDataStd_IntegerListDriver | |
| CBinMDataStd_IntPackedMapDriver | TDataStd_IntPackedMap attribute Driver |
| CBinMDataStd_NamedDataDriver | |
| CBinMDataStd_RealArrayDriver | Array of Real attribute Driver |
| CBinMDataStd_RealDriver | Real attribute Driver |
| CBinMDataStd_RealListDriver | |
| CBinMDataStd_ReferenceArrayDriver | |
| CBinMDataStd_ReferenceListDriver | |
| CBinMDataStd_TreeNodeDriver | Attribute Driver |
| CBinMDataStd_UAttributeDriver | Attribute Driver |
| CBinMDataStd_VariableDriver | Attribute Driver |
| CBinMDataXtd | Storage and Retrieval drivers for modelling attributes |
| CBinMDataXtd_ConstraintDriver | Attribute Driver |
| CBinMDataXtd_GeometryDriver | Attribute Driver |
| CBinMDataXtd_PatternStdDriver | Attribute Driver |
| CBinMDataXtd_PositionDriver | Position Attribute Driver |
| CBinMDataXtd_PresentationDriver | Presentation Attribute Driver |
| CBinMDataXtd_TriangulationDriver | TDataXtd_Triangulation attribute bin Driver |
| CBinMDF | This package provides classes and methods to translate a transient DF into a persistent one and vice versa |
| CBinMDF_ADriver | Attribute Storage/Retrieval Driver |
| CBinMDF_ADriverTable | A driver table is an object building links between object types and object drivers. In the translation process, a driver table is asked to give a translation driver for each current object to be translated |
| CBinMDF_DerivedDriver | A universal driver for the attribute that inherits another attribute with ready to used persistence mechanism implemented (already has a driver to store/retrieve) |
| CBinMDF_ReferenceDriver | Reference attribute Driver |
| CBinMDF_TagSourceDriver | TDF_TagSource Driver |
| CBinMDocStd | Storage and Retrieval drivers for TDocStd modelling attributes |
| CBinMDocStd_XLinkDriver | XLink attribute Driver |
| CBinMFunction | Storage and Retrieval drivers for TFunction modelling attributes |
| CBinMFunction_FunctionDriver | Function attribute Driver |
| CBinMFunction_GraphNodeDriver | GraphNode attribute Driver |
| CBinMFunction_ScopeDriver | Scope attribute Driver |
| CBinMNaming | Storage/Retrieval drivers for TNaming attributes |
| CBinMNaming_NamedShapeDriver | NamedShape Attribute Driver |
| CBinMNaming_NamingDriver | Naming Attribute Driver |
| CBinMXCAFDoc | |
| CBinMXCAFDoc_AssemblyItemRefDriver | |
| CBinMXCAFDoc_CentroidDriver | |
| CBinMXCAFDoc_ColorDriver | |
| CBinMXCAFDoc_DatumDriver | |
| CBinMXCAFDoc_DimTolDriver | |
| CBinMXCAFDoc_GraphNodeDriver | |
| CBinMXCAFDoc_LengthUnitDriver | Attribute Driver |
| CBinMXCAFDoc_LocationDriver | |
| CBinMXCAFDoc_MaterialDriver | |
| CBinMXCAFDoc_NoteBinDataDriver | |
| CBinMXCAFDoc_NoteCommentDriver | |
| CBinMXCAFDoc_NoteDriver | |
| CBinMXCAFDoc_VisMaterialDriver | Binary persistence driver for XCAFDoc_VisMaterial attribute |
| CBinMXCAFDoc_VisMaterialToolDriver | Binary persistence driver for XCAFDoc_VisMaterialTool attribute |
| CBinObjMgt_Persistent | Binary persistent representation of an object. Really it is used as a buffer for read/write an object |
| CBinObjMgt_Position | Stores and manipulates position in the stream |
| CBinObjMgt_RRelocationTable | Retrieval relocation table is modeled as a child class of NCollection_DataMap<int, occ::handle<Standard_Transient>> that stores a handle to the file header section. With that attribute drivers have access to the file header section |
| CBinTObjDrivers | Class for registering storage/retrieval drivers for TObj Bin persistence |
| CBinTObjDrivers_DocumentRetrievalDriver | |
| CBinTObjDrivers_DocumentStorageDriver | |
| CBinTObjDrivers_IntSparseArrayDriver | |
| CBinTObjDrivers_ModelDriver | |
| CBinTObjDrivers_ObjectDriver | |
| CBinTObjDrivers_ReferenceDriver | |
| CBinTObjDrivers_XYZDriver | |
| CBinTools | Tool to keep shapes in binary format |
| CBinTools_Curve2dSet | Stores a set of Curves from Geom2d in binary format |
| CBinTools_CurveSet | Stores a set of Curves from Geom in binary format |
| CBinTools_IStream | Substitution of IStream for shape reader for fast management of position in the file (get and go) and operation on all reading types |
| CBinTools_LocationSet | The class LocationSet stores a set of location in a relocatable state |
| CBinTools_OStream | Substitution of OStream for shape writer for fast management of position in the file and operation on all writing types |
| CBinTools_ShapeReader | Reads topology from IStream in binary format without grouping of objects by types and using relative positions in a file as references |
| CBinTools_ShapeSet | Writes topology in OStream in binary format |
| CBinTools_ShapeSetBase | A base class for all readers/writers of TopoDS_Shape into/from stream |
| CBinTools_ShapeWriter | Writes topology in OStream in binary format without grouping of objects by types and using relative positions in a file as references |
| CBinTools_SurfaceSet | Stores a set of Surfaces from Geom in binary format |
| CBinXCAFDrivers | |
| CBinXCAFDrivers_DocumentRetrievalDriver | |
| CBinXCAFDrivers_DocumentStorageDriver | |
| CBisector | This package provides the bisecting line between two geometric elements |
| CBisector_Bisec | Bisec provides the bisecting line between two elements This line is trimmed by a point |
| CBisector_BisecAna | This class provides the bisecting line between two geometric elements.The elements are Circles,Lines or Points |
| CBisector_BisecCC | Construct the bisector between two curves. The curves can intersect only in their extremities |
| CBisector_BisecPC | Provides the bisector between a point and a curve. the curvature on the curve has to be monoton. the point can't be on the curve except at the extremities |
| CBisector_Curve | |
| CBisector_FunctionH | H(v) = (T1.P2(v) - P1) * ||T(v)|| - 2 2 (T(v).P2(v) - P1) * ||T1|| |
| CBisector_FunctionInter | 2 2 F(u) = (PC(u) - PBis1(u)) + (PC(u) - PBis2(u)) |
| CBisector_Inter | Intersection between two <Bisec> from Bisector |
| CBisector_PointOnBis | |
| CBisector_PolyBis | Polygon of PointOnBis |
| CBiTgte_Blend | Root class |
| CBiTgte_CurveOnEdge | Private class used to create a filler rolling on an edge |
| CBiTgte_CurveOnVertex | Private class used to create a filler rolling on an edge |
| CBlend_AppFunction | Deferred class for a function used to compute a blending surface between two surfaces, using a guide line. The vector <X> used in Value, Values and Derivatives methods has to be the vector of the parametric coordinates U1,V1, U2,V2, of the extremities of a section on the first and second surface |
| CBlend_CSFunction | Deferred class for a function used to compute a blending surface between a surface and a curve, using a guide line. The vector <X> used in Value, Values and Derivatives methods may be the vector of the parametric coordinates U,V, W of the extremities of a section on the surface and the curve |
| CBlend_CurvPointFuncInv | Deferred class for a function used to compute a blending surface between a surface and a curve, using a guide line. This function is used to find a solution on a done point of the curve. The vector <X> used in Value, Values and Derivatives methods has to be the vector of the parametric coordinates w, U, V where w is the parameter on the guide line, U,V are the parametric coordinates of a point on the partner surface |
| CBlend_FuncInv | Deferred class for a function used to compute a blending surface between two surfaces, using a guide line. This function is used to find a solution on a restriction of one of the surface. The vector <X> used in Value, Values and Derivatives methods has to be the vector of the parametric coordinates t,w,U,V where t is the parameter on the curve on surface, w is the parameter on the guide line, U,V are the parametric coordinates of a point on the partner surface |
| CBlend_Function | Deferred class for a function used to compute a blending surface between two surfaces, using a guide line. The vector <X> used in Value, Values and Derivatives methods has to be the vector of the parametric coordinates U1,V1, U2,V2, of the extremities of a section on the first and second surface |
| CBlend_Point | |
| CBlend_RstRstFunction | Deferred class for a function used to compute a blending surface between a surface and a pcurve on an other Surface, using a guide line. The vector <X> used in Value, Values and Derivatives methods may be the vector of the parametric coordinates U,V, W of the extremities of a section on the surface and the curve |
| CBlend_SurfCurvFuncInv | Deferred class for a function used to compute a blending surface between a surface and a curve, using a guide line. This function is used to find a solution on a done restriction of the surface |
| CBlend_SurfPointFuncInv | Deferred class for a function used to compute a blending surface between a surface and a curve, using a guide line. This function is used to find a solution on a done point of the curve |
| CBlend_SurfRstFunction | Deferred class for a function used to compute a blending surface between a surface and a pcurve on an other Surface, using a guide line. The vector <X> used in Value, Values and Derivatives methods may be the vector of the parametric coordinates U,V, W of the extremities of a section on the surface and the curve |
| CBlendFunc | This package provides a set of generic functions, that can instantiated to compute blendings between two surfaces (Constant radius, Evolutive radius, Ruled surface) |
| CBlendFunc_Chamfer | Class for a function used to compute a "ordinary" chamfer: when distances from spine to surfaces are constant |
| CBlendFunc_ChamfInv | Class for a function used to compute a chamfer with two constant distances on a surface's boundary |
| CBlendFunc_ChAsym | |
| CBlendFunc_ChAsymInv | |
| CBlendFunc_ConstRad | |
| CBlendFunc_ConstRadInv | |
| CBlendFunc_ConstThroat | Class for a function used to compute a symmetric chamfer with constant throat that is the height of isosceles triangle in section |
| CBlendFunc_ConstThroatInv | Class for a function used to compute a ConstThroat chamfer on a surface's boundary |
| CBlendFunc_ConstThroatWithPenetration | Class for a function used to compute a chamfer with constant throat: the section of chamfer is right-angled triangle, the first of two surfaces (where is the top of the chamfer) is virtually moved inside the solid by offset operation, the apex of the section is on the intersection curve between moved surface and second surface, right angle is at the top of the chamfer, the length of the leg from apex to top is constant - it is throat |
| CBlendFunc_ConstThroatWithPenetrationInv | Class for a function used to compute a ConstThroatWithPenetration chamfer on a surface's boundary |
| CBlendFunc_Corde | This function calculates point (pts) on the curve of intersection between the normal to a curve (guide) in a chosen parameter and a surface (surf), so that pts was at a given distance from the guide. X(1),X(2) are the parameters U,V of pts on surf |
| CBlendFunc_CSCircular | |
| CBlendFunc_CSConstRad | |
| CBlendFunc_EvolRad | |
| CBlendFunc_EvolRadInv | |
| CBlendFunc_GenChamfer | Deferred class for a function used to compute a general chamfer |
| CBlendFunc_GenChamfInv | Deferred class for a function used to compute a general chamfer on a surface's boundary |
| CBlendFunc_Ruled | |
| CBlendFunc_RuledInv | |
| CBlendFunc_Tensor | Used to store the "gradient of gradient" |
| CBnd_B2 | Template class for 2D bounding box. This is a base template that is instantiated for double and float |
| CBnd_B3 | Template class for 3D bounding box. This is a base template that is instantiated for double and float |
| CBnd_BoundSortBox | A tool to compare a bounding box or a plane with a set of bounding boxes. It sorts the set of bounding boxes to give the list of boxes which intersect the element being compared. The boxes being sorted generally bound a set of shapes, while the box being compared bounds a shape to be compared. The resulting list of intersecting boxes therefore gives the list of items which potentially intersect the shape to be compared. How to use this class: |
| CBnd_Box | Describes a bounding box in 3D space. A bounding box is parallel to the axes of the coordinates system. If it is finite, it is defined by the three intervals: |
| CLimits | Structure containing the box limits (Xmin, Xmax, Ymin, Ymax, Zmin, Zmax). The values include the gap and account for open directions |
| CBnd_Box2d | Describes a bounding box in 2D space. A bounding box is parallel to the axes of the coordinates system. If it is finite, it is defined by the two intervals: |
| CLimits | Structure containing the 2D box limits (Xmin, Xmax, Ymin, Ymax). The values include the gap and account for open directions |
| CBnd_OBB | The class describes the Oriented Bounding Box (OBB), much tighter enclosing volume for the shape than the Axis Aligned Bounding Box (AABB). The OBB is defined by a center of the box, the axes and the halves of its three dimensions. The OBB can be used more effectively than AABB as a rejection mechanism for non-interfering objects |
| CHalfSizes | Structure containing the OBB half-size dimensions. Can be used with C++17 structured bindings: |
| CBnd_Range | This class describes a range in 1D space restricted by two real values. A range can be void indicating there is no point included in the range |
| CBounds | Structure containing the range bounds (Min, Max). Can be used with C++17 structured bindings: |
| CBnd_Sphere | This class represents a bounding sphere of a geometric entity (triangle, segment of line or whatever else) |
| CBnd_Tools | Defines a set of static methods operating with bounding boxes |
| CBndLib | The BndLib package provides functions to add a geometric primitive to a bounding box. Note: these functions work with gp objects, optionally limited by parameter values. If the curves and surfaces provided by the gp package are not explicitly parameterized, they still have an implicit parameterization, similar to that which they infer for the equivalent Geom or Geom2d objects. Add : Package to compute the bounding boxes for elementary objects from gp in 2d and 3d |
| CBndLib_Add2dCurve | Computes the bounding box for a curve in 2d . Functions to add a 2D curve to a bounding box. The 2D curve is defined from a Geom2d curve |
| CBndLib_Add3dCurve | Computes the bounding box for a curve in 3d. Functions to add a 3D curve to a bounding box. The 3D curve is defined from a Geom curve |
| CBndLib_AddSurface | Computes the box from a surface Functions to add a surface to a bounding box. The surface is defined from a Geom surface |
| CBOPAlgo_Algo | The class provides the root interface for the algorithms in Boolean Component |
| CBOPAlgo_ArgumentAnalyzer | Check the validity of argument(s) for Boolean Operations |
| CBOPAlgo_BOP | The class represents the Building part of the Boolean Operations algorithm. The arguments of the algorithms are divided in two groups - Objects and Tools. The algorithm builds the splits of the given arguments using the intersection results and combines the result of Boolean Operation of given type: |
| CBOPAlgo_Builder | The class is a General Fuse algorithm - base algorithm for the algorithms in the Boolean Component. Its main purpose is to build the split parts of the argument shapes from which the result of the operations is combined. The result of the General Fuse algorithm itself is a compound containing all split parts of the arguments |
| CNbShapes | Auxiliary structure to get information about number of shapes of each type participated in operation |
| CBOPAlgo_BuilderArea | The root class for algorithms to build faces/solids from set of edges/faces |
| CBOPAlgo_BuilderFace | The algorithm to build new faces from the given faces and set of edges lying on this face |
| CBOPAlgo_BuilderShape | Root class for algorithms that has shape as result |
| CBOPAlgo_BuilderSolid | Solid Builder is the algorithm for building solids from set of faces. The given faces should be non-intersecting, i.e. all coinciding parts of the faces should be shared among them |
| CBOPAlgo_CellsBuilder | The algorithm is based on the General Fuse algorithm (GFA). The result of GFA is all split parts of the Arguments |
| CBOPAlgo_CheckerSI | Checks the shape on self-interference |
| CBOPAlgo_CheckResult | Information about faulty shapes and faulty types can't be processed by Boolean Operations |
| CBOPAlgo_MakeConnected | BOPAlgo_MakeConnected is the algorithm for making the touching shapes connected or glued, i.e. for making the coinciding geometries be topologically shared among the shapes |
| CBOPAlgo_MakePeriodic | BOPAlgo_MakePeriodic is the tool for making an arbitrary shape periodic in 3D space in specified directions |
| CPeriodicityParams | |
| CBOPAlgo_MakerVolume | The algorithm is to build solids from set of shapes. It uses the BOPAlgo_Builder algorithm to intersect the given shapes and build the images of faces (if needed) and BOPAlgo_BuilderSolid algorithm to build the solids |
| CBOPAlgo_Options | The class provides the following options for the algorithms in Boolean Component: |
| CBOPAlgo_ParallelAlgo | Additional root class to provide interface to be launched from parallel vector. It already has the range as a field, and has to be used with caution to create scope from the range only once |
| CBOPAlgo_PaveFiller | The class represents the Intersection phase of the Boolean Operations algorithm. It performs the pairwise intersection of the sub-shapes of the arguments in the following order: |
| CEdgeRangeDistance | Auxiliary structure to hold the edge distance to the face |
| CBOPAlgo_PISteps | Class for representing the relative contribution of each step of the operation to the whole progress |
| CBOPAlgo_RemoveFeatures | The RemoveFeatures algorithm is intended for reconstruction of the shape by removal of the unwanted parts from it. These parts can be holes, protrusions, spikes, fillets etc. The shape itself is not modified, the new shape is built in the result |
| CBOPAlgo_Section | The algorithm to build a Section between the arguments. The Section consists of vertices and edges. The Section contains: |
| CBOPAlgo_SectionAttribute | Class is a container of the flags used by intersection algorithm |
| CBOPAlgo_ShellSplitter | The class provides the splitting of the set of connected faces on separate loops |
| CBOPAlgo_Splitter | The Splitter algorithm is the algorithm for splitting a group of arbitrary shapes by the other group of arbitrary shapes. The arguments of the operation are divided on two groups: Objects - shapes that will be split; Tools - shapes by which the Objects will be split. The result of the operation contains only the split parts of the shapes from the group of Objects. The split parts of the shapes from the group of Tools are excluded from the result. The shapes can be split by the other shapes from the same group (in case these shapes are interfering) |
| CBOPAlgo_Tools | Provides tools used in the intersection part of Boolean operations |
| CBOPAlgo_ToolsProvider | Auxiliary class providing API to operate tool arguments |
| CBOPAlgo_WireEdgeSet | |
| CBOPAlgo_WireSplitter | The class is to build loops from the given set of edges |
| CBOPDS_CommonBlock | The class BOPDS_CommonBlock is to store the information about pave blocks that have geometrical coincidence (in terms of a tolerance) with: a) other pave block(s); b) face(s). First pave block in the common block (real pave block) is always a pave block with the minimal index of the original edge |
| CBOPDS_CoupleOfPaveBlocks | Stores information about two pave blocks and satellite data |
| CBOPDS_Curve | The class BOPDS_Curve is to store the information about intersection curve |
| CBOPDS_DS | The class BOPDS_DS provides the control of data structure for the algorithms in the Boolean Component such as General Fuse, Boolean operations, Section, Maker Volume, Splitter and Cells Builder |
| CBOPDS_FaceInfo | The class BOPDS_FaceInfo is to store handy information about state of face |
| CBOPDS_IndexRange | The class BOPDS_IndexRange is to store the information about range of two indices |
| CBOPDS_Interf | |
| CBOPDS_InterfEE | |
| CBOPDS_InterfEF | |
| CBOPDS_InterfEZ | |
| CBOPDS_InterfFF | |
| CBOPDS_InterfFZ | |
| CBOPDS_InterfVE | |
| CBOPDS_InterfVF | |
| CBOPDS_InterfVV | |
| CBOPDS_InterfVZ | |
| CBOPDS_InterfZZ | |
| CBOPDS_Iterator | The class BOPDS_Iterator is 1.to compute intersections between BRep sub-shapes of arguments of an operation (see the class BOPDS_DS) in terms of theirs bounding boxes 2.provides interface to iterate the pairs of intersected sub-shapes of given type |
| CBOPDS_IteratorSI | The class BOPDS_IteratorSI is 1.to compute self-intersections between BRep sub-shapes of each argument of an operation (see the class BOPDS_DS) in terms of theirs bounding boxes 2.provides interface to iterare the pairs of intersected sub-shapes of given type |
| CBOPDS_Pair | The class is to provide the pair of indices of interfering shapes |
| CBOPDS_Pave | The class BOPDS_Pave is to store information about vertex on an edge |
| CBOPDS_PaveBlock | The class BOPDS_PaveBlock is to store the information about pave block on an edge. Two adjacent paves on edge make up pave block |
| CBOPDS_Point | The class BOPDS_Point is to store the information about intersection point |
| CBOPDS_ShapeInfo | The class BOPDS_ShapeInfo is to store handy information about shape |
| CBOPDS_SubIterator | The class BOPDS_SubIterator is used to compute intersections between bounding boxes of two sub-sets of BRep sub-shapes of arguments of an operation (see the class BOPDS_DS). The class provides interface to iterate the pairs of intersected sub-shapes |
| CBOPDS_Tools | The class BOPDS_Tools contains a set auxiliary static functions of the package BOPDS |
| CBOPTest | |
| CBOPTest_DrawableShape | |
| CBOPTest_Objects | |
| CBOPTools_AlgoTools | Provides tools used in Boolean Operations algorithm: |
| CBOPTools_AlgoTools2D | The class contains handy static functions dealing with the topology This is the copy of the BOPTools_AlgoTools2D.cdl |
| CBOPTools_AlgoTools3D | The class contains handy static functions dealing with the topology This is the copy of BOPTools_AlgoTools3D.cdl file |
| CBOPTools_BoxSelector | Template Selector for elements selection from BVH tree |
| CBOPTools_BoxSet | Redefines BoxSet to use the Linear builder by default |
| CBOPTools_ConnexityBlock | |
| CBOPTools_CoupleOfShape | |
| CBOPTools_PairSelector | Template Selector for selection of the elements from two BVH trees |
| CPairIDs | |
| CBOPTools_Parallel | Implementation of Functors/Starters |
| CBOPTools_Set | |
| CBRep_Builder | A framework providing advanced tolerance control. It is used to build Shapes. If tolerance control is required, you are advised to: |
| CBRep_Curve3D | Representation of a curve by a 3D curve |
| CBRep_CurveOn2Surfaces | Defines a continuity between two surfaces |
| CBRep_CurveOnClosedSurface | Representation of a curve by two pcurves on a closed surface |
| CBRep_CurveOnSurface | Representation of a curve by a curve in the parametric space of a surface |
| CBRep_CurveRepresentation | Root class for the curve representations. Contains a location |
| CBRep_GCurve | Root class for the geometric curves representation. Contains a range. Contains a first and a last parameter |
| CBRep_PointOnCurve | Representation by a parameter on a 3D curve |
| CBRep_PointOnCurveOnSurface | Representation by a parameter on a curve on a surface |
| CBRep_PointOnSurface | Representation by two parameters on a surface |
| CBRep_PointRepresentation | Root class for the points representations. Contains a location and a parameter |
| CBRep_PointsOnSurface | Root for points on surface |
| CBRep_Polygon3D | Representation by a 3D polygon |
| CBRep_PolygonOnClosedSurface | Representation by two 2d polygons in the parametric space of a surface |
| CBRep_PolygonOnClosedTriangulation | A representation by two arrays of nodes on a triangulation |
| CBRep_PolygonOnSurface | Representation of a 2D polygon in the parametric space of a surface |
| CBRep_PolygonOnTriangulation | A representation by an array of nodes on a triangulation |
| CBRep_TEdge | The TEdge from BRep is inherited from the TEdge from TopoDS. It contains the geometric data |
| CBRep_TFace | The Tface from BRep is based on the TFace from TopoDS. The TFace contains: |
| CBRep_Tool | Provides class methods to access to the geometry of BRep shapes |
| CBRep_TVertex | The TVertex from BRep inherits from the TVertex from TopoDS. It contains the geometric data |
| CBRepAdaptor_CompCurve | The Curve from BRepAdaptor allows to use a Wire of the BRep topology like a 3D curve. Warning: With this class of curve, C0 and C1 continuities are not assumed. So be careful with some algorithm! Please note that BRepAdaptor_CompCurve cannot be periodic curve at all (even if it contains single periodic edge) |
| CBRepAdaptor_Curve | The Curve from BRepAdaptor allows to use an Edge of the BRep topology like a 3D curve |
| CBRepAdaptor_Curve2d | The Curve2d from BRepAdaptor allows to use an Edge on a Face like a 2d curve (curve in the parametric space) |
| CBRepAdaptor_Surface | The Surface from BRepAdaptor allows to use a Face of the BRep topology look like a 3D surface |
| CBRepAlgo | Following tools for: |
| CBRepAlgo_AsDes | SD to store descendants and ascendants of Shapes |
| CBRepAlgo_FaceRestrictor | Builds all the faces limited with a set of non jointing and planars wires. if <ControlOrientation> is false The Wires must have correct orientations. Sinon orientation des wires de telle sorte que les faces ne soient pas infinies et qu'elles soient disjointes |
| CBRepAlgo_Image | Stores link between a shape and a shape <NewS> obtained from . <NewS> is an image of |
| CBRepAlgo_Loop | Builds the loops from a set of edges on a face |
| CBRepAlgo_NormalProjection | This class makes the projection of a wire on a shape |
| CBRepAlgoAPI_Algo | Provides the root interface for the API algorithms |
| CBRepAlgoAPI_BooleanOperation | The root API class for performing Boolean Operations on arbitrary shapes |
| CBRepAlgoAPI_BuilderAlgo | The class contains API level of the General Fuse algorithm |
| CBRepAlgoAPI_Check | The class Check provides a diagnostic tool for checking the validity of the single shape or couple of shapes. The shapes are checked on: |
| CBRepAlgoAPI_Common | The class provides Boolean common operation between arguments and tools (Boolean Intersection) |
| CBRepAlgoAPI_Cut | The class Cut provides Boolean cut operation between arguments and tools (Boolean Subtraction) |
| CBRepAlgoAPI_Defeaturing | The BRepAlgoAPI_Defeaturing algorithm is the API algorithm intended for removal of the unwanted parts from the shape. The unwanted parts (or features) can be holes, protrusions, gaps, chamfers, fillets etc. The shape itself is not modified, the new shape is built as the result |
| CBRepAlgoAPI_Fuse | The class provides Boolean fusion operation between arguments and tools (Boolean Union) |
| CBRepAlgoAPI_Section | The algorithm is to build a Section operation between arguments and tools. The result of Section operation consists of vertices and edges. The result of Section operation contains: |
| CBRepAlgoAPI_Splitter | The class contains API level of the Splitter algorithm, which allows splitting a group of arbitrary shapes by the other group of arbitrary shapes. The arguments of the operation are divided on two groups: Objects - shapes that will be split; Tools - shapes by which the Objects will be split. The result of the operation contains only the split parts of the shapes from the group of Objects. The split parts of the shapes from the group of Tools are excluded from the result. The shapes can be split by the other shapes from the same group (in case these shapes are interfering) |
| CBRepApprox_Approx | |
| CBRepApprox_ApproxLine | |
| CBRepApprox_BSpGradient_BFGSOfMyBSplGradientOfTheComputeLineOfApprox | |
| CBRepApprox_BSpParFunctionOfMyBSplGradientOfTheComputeLineOfApprox | |
| CBRepApprox_BSpParLeastSquareOfMyBSplGradientOfTheComputeLineOfApprox | |
| CBRepApprox_Gradient_BFGSOfMyGradientbisOfTheComputeLineOfApprox | |
| CBRepApprox_Gradient_BFGSOfMyGradientOfTheComputeLineBezierOfApprox | |
| CBRepApprox_MyBSplGradientOfTheComputeLineOfApprox | |
| CBRepApprox_MyGradientbisOfTheComputeLineOfApprox | |
| CBRepApprox_MyGradientOfTheComputeLineBezierOfApprox | |
| CBRepApprox_ParFunctionOfMyGradientbisOfTheComputeLineOfApprox | |
| CBRepApprox_ParFunctionOfMyGradientOfTheComputeLineBezierOfApprox | |
| CBRepApprox_ParLeastSquareOfMyGradientbisOfTheComputeLineOfApprox | |
| CBRepApprox_ParLeastSquareOfMyGradientOfTheComputeLineBezierOfApprox | |
| CBRepApprox_ResConstraintOfMyGradientbisOfTheComputeLineOfApprox | |
| CBRepApprox_ResConstraintOfMyGradientOfTheComputeLineBezierOfApprox | |
| CBRepApprox_SurfaceTool | |
| CBRepApprox_TheComputeLineBezierOfApprox | |
| CBRepApprox_TheComputeLineOfApprox | |
| CBRepApprox_TheFunctionOfTheInt2SOfThePrmPrmSvSurfacesOfApprox | |
| CBRepApprox_TheImpPrmSvSurfacesOfApprox | |
| CBRepApprox_TheInt2SOfThePrmPrmSvSurfacesOfApprox | |
| CBRepApprox_TheMultiLineOfApprox | |
| CBRepApprox_TheMultiLineToolOfApprox | |
| CBRepApprox_ThePrmPrmSvSurfacesOfApprox | |
| CBRepApprox_TheZerImpFuncOfTheImpPrmSvSurfacesOfApprox | |
| CBRepBlend_AppFunc | Function to approximate by AppSurface for Surface/Surface contact |
| CBRepBlend_AppFuncRoot | Function to approximate by AppSurface |
| CBRepBlend_AppFuncRst | Function to approximate by AppSurface for Curve/Surface contact |
| CBRepBlend_AppFuncRstRst | Function to approximate by AppSurface for Edge/Face (Curve/Curve contact) |
| CBRepBlend_AppSurf | |
| CBRepBlend_AppSurface | Used to Approximate the blending surfaces |
| CBRepBlend_BlendTool | |
| CBRepBlend_CSWalking | |
| CBRepBlend_CurvPointRadInv | Function of reframing between a point and a curve. valid in cases of constant and progressive radius. This function is used to find a solution on a done point of the curve 1 when using RstRstConsRad or CSConstRad... The vector <X> used in Value, Values and Derivatives methods has to be the vector of the parametric coordinates w, U where w is the parameter on the guide line, U are the parametric coordinates of a point on the partner curve 2 |
| CBRepBlend_Extremity | |
| CBRepBlend_HCurve2dTool | |
| CBRepBlend_HCurveTool | |
| CBRepBlend_Line | |
| CBRepBlend_PointOnRst | Definition of an intersection point between a line and a restriction on a surface. Such a point is contains geometrical information (see the Value method) and logical information |
| CBRepBlend_RstRstConstRad | Copy of CSConstRad with a pcurve on surface as support |
| CBRepBlend_RstRstEvolRad | Function to approximate by AppSurface for Edge/Edge and evolutif radius |
| CBRepBlend_RstRstLineBuilder | This class processes the data resulting from Blend_CSWalking but it takes in consideration the Surface supporting the curve to detect the breakpoint |
| CBRepBlend_SurfCurvConstRadInv | Function of reframing between a restriction surface of the surface and a curve. Class used to compute a solution of the surfRstConstRad problem on a done restriction of the surface. The vector <X> used in Value, Values and Derivatives methods has to be the vector of the parametric coordinates wguide, wcurv, wrst where wguide is the parameter on the guide line, wcurv is the parameter on the curve, wrst is the parameter on the restriction on the surface |
| CBRepBlend_SurfCurvEvolRadInv | Function of reframing between a surface restriction of the surface and a curve. Class used to compute a solution of the surfRstConstRad problem on a done restriction of the surface. The vector <X> used in Value, Values and Derivatives methods has to be the vector of the parametric coordinates wguide, wcurv, wrst where wguide is the parameter on the guide line, wcurv is the parameter on the curve, wrst is the parameter on the restriction on the surface |
| CBRepBlend_SurfPointConstRadInv | Function of reframing between a point and a surface. This function is used to find a solution on a done point of the curve when using SurfRstConsRad or CSConstRad... The vector <X> used in Value, Values and Derivatives methods has to be the vector of the parametric coordinates w, U, V where w is the parameter on the guide line, U,V are the parametric coordinates of a point on the partner surface |
| CBRepBlend_SurfPointEvolRadInv | Function of reframing between a point and a surface. This function is used to find a solution on a done point of the curve when using SurfRstConsRad or CSConstRad... The vector <X> used in Value, Values and Derivatives methods has to be the vector of the parametric coordinates w, U, V where w is the parameter on the guide line, U,V are the parametric coordinates of a point on the partner surface |
| CBRepBlend_SurfRstConstRad | Copy of CSConstRad with pcurve on surface as support |
| CBRepBlend_SurfRstEvolRad | Function to approximate by AppSurface for Edge/Face and evolutif radius |
| CBRepBlend_SurfRstLineBuilder | This class processes data resulting from Blend_CSWalking taking in consideration the Surface supporting the curve to detect the breakpoint |
| CBRepBlend_Walking | |
| CBRepBndLib | This package provides the bounding boxes for curves and surfaces from BRepAdaptor. Functions to add a topological shape to a bounding box |
| CBRepBuilderAPI | The BRepBuilderAPI package provides an Application Programming Interface for the BRep topology data structure |
| CBRepBuilderAPI_BndBoxTreeSelector | Class BRepBuilderAPI_BndBoxTreeSelector derived from UBTree::Selector This class is used to select overlapping boxes, stored in NCollection::UBTree; contains methods to maintain the selection condition and to retrieve selected objects after search |
| CBRepBuilderAPI_Collect | |
| CBRepBuilderAPI_Command | Root class for all commands in BRepBuilderAPI |
| CBRepBuilderAPI_Copy | Duplication of a shape. A Copy object provides a framework for: |
| CBRepBuilderAPI_FastSewing | Created on: 2015-04-24 Created by: NIKOLAI BUKHALOV Copyright (c) 2015 OPEN CASCADE SAS |
| CFS_Vertex | The struct corresponding to a vertex |
| CFS_Face | The struct corresponding to an face |
| CFS_Edge | The struct corresponding to a edge |
| CNodeInspector | This inspector will find a node nearest to the given point not far than on the given tolerance |
| CBRepBuilderAPI_FindPlane | Describes functions to find the plane in which the edges of a given shape are located. A FindPlane object provides a framework for: |
| CBRepBuilderAPI_GTransform | Geometric transformation on a shape. The transformation to be applied is defined as a gp_GTrsf transformation. It may be: |
| CBRepBuilderAPI_MakeEdge | Provides methods to build edges |
| CBRepBuilderAPI_MakeEdge2d | Provides methods to build edges |
| CBRepBuilderAPI_MakeFace | Provides methods to build faces |
| CBRepBuilderAPI_MakePolygon | Describes functions to build polygonal wires. A polygonal wire can be built from any number of points or vertices, and consists of a sequence of connected rectilinear edges. When a point or vertex is added to the polygon if it is identic to the previous point no edge is built. The method added can be used to test it. Construction of a Polygonal Wire You can construct: |
| CBRepBuilderAPI_MakeShape | This is the root class for all shape constructions. It stores the result |
| CBRepBuilderAPI_MakeShapeOnMesh | Builds shape on per-facet basis on the input mesh. Resulting shape has shared edges by construction, but no maximization (unify same domain) is applied. No generation history is provided |
| CBRepBuilderAPI_MakeShell | Describes functions to build a shape corresponding to the skin of a surface. Note that the term shell in the class name has the same definition as that of a shell in STEP, in other words the skin of a shape, and not a solid model defined by surface and thickness. If you want to build the second sort of shell, you must use BRepOffsetAPI_MakeOffsetShape. A shell is made of a series of faces connected by their common edges. If the underlying surface of a face is not C2 continuous and the flag Segment is True, MakeShell breaks the surface down into several faces which are all C2 continuous and which are connected along the non-regular curves on the surface. The resulting shell contains all these faces. Construction of a Shell from a non-C2 continuous Surface A MakeShell object provides a framework for: |
| CBRepBuilderAPI_MakeSolid | Describes functions to build a solid from shells. A solid is made of one shell, or a series of shells, which do not intersect each other. One of these shells constitutes the outside skin of the solid. It may be closed (a finite solid) or open (an infinite solid). Other shells form hollows (cavities) in these previous ones. Each must bound a closed volume. A MakeSolid object provides a framework for: |
| CBRepBuilderAPI_MakeVertex | Describes functions to build BRepBuilder vertices directly from 3D geometric points. A vertex built using a MakeVertex object is only composed of a 3D point and a default precision value (Precision::Confusion()). Later on, 2D representations can be added, for example, when inserting a vertex in an edge. A MakeVertex object provides a framework for: |
| CBRepBuilderAPI_MakeWire | Describes functions to build wires from edges. A wire can be built from any number of edges. To build a wire you first initialize the construction, then add edges in sequence. An unlimited number of edges can be added. The initialization of construction is done with: |
| CBRepBuilderAPI_ModifyShape | Implements the methods of MakeShape for the constant topology modifications. The methods are implemented when the modification uses a Modifier from BRepTools. Some of them have to be redefined if the modification is implemented with another tool (see Transform from BRepBuilderAPI for example). The BRepBuilderAPI package provides the following frameworks to perform modifications of this sort: |
| CBRepBuilderAPI_NurbsConvert | Conversion of the complete geometry of a shape (all 3D analytical representation of surfaces and curves) into NURBS geometry (except for Planes). For example, all curves supporting edges of the basis shape are converted into BSpline curves, and all surfaces supporting its faces are converted into BSpline surfaces |
| CBRepBuilderAPI_Sewing | Provides methods to |
| CBRepBuilderAPI_Transform | Geometric transformation on a shape. The transformation to be applied is defined as a gp_Trsf transformation, i.e. a transformation which does not modify the underlying geometry of shapes. The transformation is applied to: |
| CBRepBuilderAPI_VertexInspector | Inspector for CellFilter algorithm working with gp_XYZ points in 3d space. Used in search of coincidence points with a certain tolerance |
| CBRepCheck | This package provides tools to check the validity of the BRep |
| CBRepCheck_Analyzer | A framework to check the overall validity of a shape. For a shape to be valid in Open CASCADE, it - or its component subshapes - must respect certain criteria. These criteria are checked by the function IsValid. Once you have determined whether a shape is valid or not, you can diagnose its specific anomalies and correct them using the services of the ShapeAnalysis, ShapeUpgrade, and ShapeFix packages |
| CBRepCheck_Edge | |
| CBRepCheck_Face | |
| CBRepCheck_Result | |
| CBRepCheck_Shell | |
| CBRepCheck_Solid | The class is to check a solid |
| CBRepCheck_Vertex | |
| CBRepCheck_Wire | |
| CBRepClass3d | |
| CBRepClass3d_BndBoxTreeSelectorLine | |
| CEdgeParam | |
| CVertParam | |
| CBRepClass3d_BndBoxTreeSelectorPoint | |
| CBRepClass3d_Intersector3d | |
| CBRepClass3d_SClassifier | Provides an algorithm to classify a point in a solid |
| CBRepClass3d_SolidClassifier | Provides an algorithm to classify a point in a solid |
| CBRepClass3d_SolidExplorer | Provide an exploration of a BRep Shape for the classification. Provide access to the special UB tree to obtain fast search |
| CBRepClass3d_SolidPassiveClassifier | |
| CBRepClass_Edge | This class is used to send the description of an Edge to the classifier. It contains an Edge and a Face. So the PCurve of the Edge can be found |
| CBRepClass_FaceClassifier | Provides Constructors with a Face |
| CBRepClass_FaceExplorer | Provide an exploration of a BRep Face for the classification. Return UV edges |
| CBRepClass_FacePassiveClassifier | |
| CBRepClass_FClass2dOfFClassifier | |
| CBRepClass_FClassifier | |
| CBRepClass_Intersector | Intersect an Edge with a segment. Implement the Intersector2d required by the classifier |
| CBRepExtrema_DistanceSS | This class allows to compute minimum distance between two brep shapes (face edge vertex) and is used in DistShapeShape class |
| CBRepExtrema_DistShapeShape | This class provides tools to compute minimum distance between two Shapes (Compound,CompSolid, Solid, Shell, Face, Wire, Edge, Vertex) |
| CBRepExtrema_ElementFilter | Filtering tool used to detect if two given mesh elements should be tested for overlapping/intersection or not |
| CBRepExtrema_ExtCC | |
| CBRepExtrema_ExtCF | |
| CBRepExtrema_ExtFF | |
| CBRepExtrema_ExtPC | |
| CBRepExtrema_ExtPF | |
| CBRepExtrema_OverlapTool | Enables storing of individual overlapped triangles (useful for debug) |
| CBRepExtrema_Poly | |
| CBRepExtrema_ProximityDistTool | Tool class for computation the proximity distance from first primitive set to second one that is the maximal from minimum perpendicular distances. If no perpendicular distance is found, the minimum distance will be returned. This tool is not intended to be used independently, and is integrated in other classes, implementing algorithms based on shape tessellation (BRepExtrema_ProximityValueTool) |
| CPrjState | Struct with information about projection point state from 2nd BVH, providing proximity point of 2nd shape |
| CBRepExtrema_ProximityValueTool | Tool class for computation of the proximity value from one BVH primitive set to another, solving max(min) problem. Handles only edge/edge or face/face cases. This tool is not intended to be used independently, and is integrated in other classes, implementing algorithms based on shape tessellation (BRepExtrema_ShapeProximity and BRepExtrema_SelfIntersection) |
| CBRepExtrema_SelfIntersection | Tool class for detection of self-sections in the given shape. This class is based on BRepExtrema_OverlapTool and thus uses shape tessellation to detect incorrect mesh fragments (pairs of overlapped triangles belonging to different faces). Thus, a result depends critically on the quality of mesh generator (e.g., BREP mesh is not always a good choice, because it can contain gaps between adjacent face triangulations, which may not share vertices on common edge; thus false overlap can be detected). As a result, this tool can be used for relatively fast approximated test which provides sub-set of potentially overlapped faces |
| CBRepExtrema_ShapeProximity | Tool class for shape proximity detection |
| CBRepExtrema_SolutionElem | This class is used to store information relative to the minimum distance between two shapes |
| CBRepExtrema_TriangleSet | List of shapes and their IDs for collision detection |
| CBRepExtrema_VertexInspector | Inspector for CellFilter algorithm working with gp_XYZ points in 3d space. Used in search of coincidence points with a certain tolerance |
| CBRepFeat | BRepFeat is necessary for the creation and manipulation of both form and mechanical features in a Boundary Representation framework. Form features can be depressions or protrusions and include the following types: |
| CBRepFeat_Builder | Provides a basic tool to implement features topological operations. The main goal of the algorithm is to perform the result of the operation according to the kept parts of the tool. Input data: a) DS; b) The kept parts of the tool; If the map of the kept parts of the tool is not filled boolean operation of the given type will be performed; c) Operation required. Steps: a) Fill myShapes, myRemoved maps; b) Rebuild edges and faces; c) Build images of the object; d) Build the result of the operation. Result: Result shape of the operation required |
| CBRepFeat_Form | Provides general functions to build form features. Form features can be depressions or protrusions and include the following types: |
| CBRepFeat_Gluer | One of the most significant aspects of BRepFeat functionality is the use of local operations as opposed to global ones. In a global operation, you would first construct a form of the type you wanted in your final feature, and then remove matter so that it could fit into your initial basis object. In a local operation, however, you specify the domain of the feature construction with aspects of the shape on which the feature is being created. These semantics are expressed in terms of a member shape of the basis shape from which - or up to which - matter will be added or removed. As a result, local operations make calculations simpler and faster than global operations. Glueing uses wires or edges of a face in the basis shape. These are to become a part of the feature. They are first cut out and then projected to a plane outside or inside the basis shape. By rebuilding the initial shape incorporating the edges and the faces of the tool, protrusion features can be constructed |
| CBRepFeat_MakeCylindricalHole | Provides a tool to make cylindrical holes on a shape |
| CBRepFeat_MakeDPrism | Describes functions to build draft prism topologies from basis shape surfaces. These can be depressions or protrusions. The semantics of draft prism feature creation is based on the construction of shapes: |
| CBRepFeat_MakeLinearForm | Builds a rib or a groove along a developable, planar surface. The semantics of mechanical features is built around giving thickness to a contour. This thickness can either be symmetrical - on one side of the contour - or dissymmetrical - on both sides. As in the semantics of form features, the thickness is defined by construction of shapes in specific contexts. The development contexts differ, however, in case of mechanical features. Here they include extrusion: |
| CBRepFeat_MakePipe | Constructs compound shapes with pipe features. These can be depressions or protrusions. The semantics of pipe feature creation is based on the construction of shapes: |
| CBRepFeat_MakePrism | Describes functions to build prism features. These can be depressions or protrusions. The semantics of prism feature creation is based on the construction of shapes: |
| CBRepFeat_MakeRevol | Describes functions to build revolved shells from basis shapes |
| CBRepFeat_MakeRevolutionForm | MakeRevolutionForm Generates a surface of revolution in the feature as it slides along a revolved face in the basis shape. The semantics of mechanical features is built around giving thickness to a contour. This thickness can either be unilateral - on one side of the contour - or bilateral - on both sides. As in the semantics of form features, the thickness is defined by construction of shapes in specific contexts. The development contexts differ, however,in case of mechanical features. Here they include extrusion: |
| CBRepFeat_RibSlot | Provides functions to build mechanical features. Mechanical features include ribs - protrusions and grooves (or slots) - depressions along planar (linear) surfaces or revolution surfaces. The semantics of mechanical features is built around giving thickness to a contour. This thickness can either be unilateral - on one side of the contour - or bilateral - on both sides. As in the semantics of form features, the thickness is defined by construction of shapes in specific contexts. The development contexts differ, however,in case of mechanical features. Here they include extrusion: |
| CBRepFeat_SplitShape | One of the most significant aspects of BRepFeat functionality is the use of local operations as opposed to global ones. In a global operation, you would first construct a form of the type you wanted in your final feature, and then remove matter so that it could fit into your initial basis object. In a local operation, however, you specify the domain of the feature construction with aspects of the shape on which the feature is being created. These semantics are expressed in terms of a member shape of the basis shape from which - or up to which - matter will be added or removed. As a result, local operations make calculations simpler and faster than global operations. In BRepFeat, the semantics of local operations define features constructed from a contour or a part of the basis shape referred to as the tool. In a SplitShape object, wires or edges of a face in the basis shape to be used as a part of the feature are cut out and projected to a plane outside or inside the basis shape. By rebuilding the initial shape incorporating the edges and the faces of the tool, protrusion or depression features can be constructed |
| CBRepFill | |
| CBRepFill_ACRLaw | Build Location Law, with a Wire. In the case of guided contour and trihedron by reduced curvilinear abscissa |
| CBRepFill_AdvancedEvolved | Constructs an evolved volume from a spine (wire or face) and a profile (wire) |
| CBRepFill_ApproxSeewing | Evaluate the 3dCurve and the PCurves described in a MultiLine from BRepFill. The parametrization of those curves is not imposed by the Bissectrice. The parametrization is given approximately by the abscissa of the curve3d |
| CBRepFill_CompatibleWires | Constructs a sequence of Wires (with good orientation and origin) agreed each other so that the surface passing through these sections is not twisted |
| CBRepFill_ComputeCLine | |
| CBRepFill_CurveConstraint | Same as CurveConstraint from GeomPlate with BRepAdaptor_Surface instead of GeomAdaptor_Surface |
| CBRepFill_Draft | |
| CBRepFill_DraftLaw | Build Location Law, with a Wire |
| CBRepFill_Edge3DLaw | Build Location Law, with a Wire |
| CBRepFill_EdgeFaceAndOrder | |
| CBRepFill_EdgeOnSurfLaw | Build Location Law, with a Wire and a Surface |
| CBRepFill_Evolved | Constructs an evolved volume from a spine (wire or face) and a profile ( wire) |
| CBRepFill_FaceAndOrder | A structure containing Face and Order of constraint |
| CBRepFill_Filling | N-Side Filling This algorithm avoids to build a face from: |
| CBRepFill_Generator | Compute a topological surface (a shell) using generating wires. The face of the shell will be ruled surfaces passing by the wires. The wires must have the same number of edges |
| CBRepFill_LocationLaw | Location Law on a Wire |
| CBRepFill_MultiLine | Class used to compute the 3d curve and the two 2d curves resulting from the intersection of a surface of linear extrusion( Bissec, Dz) and the 2 faces. These 3 curves will have the same parametrization as the Bissectrice. This class is to be sent to an approximation routine |
| CBRepFill_NSections | Build Section Law, with N Sections |
| CBRepFill_OffsetAncestors | This class is used to find the generating shapes of an OffsetWire |
| CBRepFill_OffsetWire | Constructs a Offset Wire to a spine (wire or face). Offset direction will be to outer region in case of positive offset value and to inner region in case of negative offset value. Inner/Outer region for open wire is defined by the following rule: when we go along the wire (taking into account of edges orientation) then outer region will be on the right side, inner region will be on the left side. In case of closed wire, inner region will always be inside the wire (at that, edges orientation is not taken into account). The Wire or the Face must be planar and oriented correctly |
| CBRepFill_Pipe | Create a shape by sweeping a shape (the profile) along a wire (the spine) |
| CBRepFill_PipeShell | Computes a topological shell using some wires (spines and profiles) and displacement option Perform general sweeping construction |
| CBRepFill_Section | To store section definition |
| CBRepFill_SectionLaw | Build Section Law, with an Vertex, or an Wire |
| CBRepFill_SectionPlacement | Place a shape in a local axis coordinate |
| CBRepFill_ShapeLaw | Build Section Law, with an Vertex, or an Wire |
| CBRepFill_Sweep | Topological Sweep Algorithm Computes an Sweep shell using a generating wire, an SectionLaw and an LocationLaw |
| CBRepFill_TrimEdgeTool | Geometric Tool using to construct Offset Wires |
| CBRepFill_TrimShellCorner | Trims sets of faces in the corner to make proper parts of pipe |
| CBRepFill_TrimSurfaceTool | Compute the Pcurves and the 3d curves resulting of the trimming of a face by an extruded surface |
| CBRepFilletAPI_LocalOperation | Construction of fillets on the edges of a Shell |
| CBRepFilletAPI_MakeChamfer | Describes functions to build chamfers on edges of a shell or solid. Chamfered Edge of a Shell or Solid A MakeChamfer object provides a framework for: |
| CBRepFilletAPI_MakeFillet | Describes functions to build fillets on the broken edges of a shell or solid. A MakeFillet object provides a framework for: |
| CBRepFilletAPI_MakeFillet2d | Describes functions to build fillets and chamfers on the vertices of a planar face. Fillets and Chamfers on the Vertices of a Planar Face A MakeFillet2d object provides a framework for: |
| CBRepGProp | Provides global functions to compute a shape's global properties for lines, surfaces or volumes, and bring them together with the global properties already computed for a geometric system. The global properties computed for a system are : |
| CBRepGProp_Cinert | Computes the global properties of bounded curves in 3D space. The curve must have at least a continuity C1. It can be a curve as defined in the template CurveTool from package GProp. This template gives the minimum of methods required to evaluate the global properties of a curve 3D with the algorithms of GProp |
| CBRepGProp_Domain | Arc iterator. Returns only Forward and Reversed edges from the face in an undigested order |
| CBRepGProp_EdgeTool | Provides the required methods to instantiate CGProps from GProp with a Curve from BRepAdaptor |
| CBRepGProp_Face | |
| CBRepGProp_Gauss | Class performs computing of the global inertia properties of geometric object in 3D space by adaptive and non-adaptive 2D Gauss integration algorithms |
| CBRepGProp_MeshCinert | Computes the global properties of of polylines represented by set of points. This class is used for computation of global properties of edge, which has no exact geometry (3d or 2d curve), but has any of allowed polygons |
| CBRepGProp_MeshProps | Computes the global properties of a surface mesh. The mesh can be interpreted as just a surface or as a piece of volume limited by this surface |
| CBRepGProp_Sinert | Computes the global properties of a face in 3D space. The face 's requirements to evaluate the global properties are defined in the template FaceTool from package GProp |
| CBRepGProp_TFunction | This class represents the integrand function for the outer integral computation. The returned value represents the integral of UFunction. It depends on the value type and the flag IsByPoint |
| CBRepGProp_UFunction | This class represents the integrand function for computation of an inner integral. The returned value depends on the value type and the flag IsByPoint |
| CBRepGProp_Vinert | Computes the global properties of a geometric solid (3D closed region of space) delimited with : . a surface . a point and a surface . a plane and a surface |
| CBRepGProp_VinertGK | Computes the global properties of a geometric solid (3D closed region of space) delimited with : |
| CBRepGraph | Topology-geometry graph over TopoDS / BRep |
| CEditorView | Non-const view for programmatic graph construction and structural editing |
| CVertexOps | Vertex creation operations |
| CEdgeOps | Edge creation and editing operations |
| CCoEdgeOps | CoEdge and PCurve operations |
| CWireOps | Wire creation and editing operations |
| CFaceOps | Face creation and editing operations |
| CShellOps | Shell creation and editing operations |
| CSolidOps | Solid creation and editing operations |
| CCompoundOps | Compound creation and editing operations |
| CCompSolidOps | CompSolid creation and editing operations |
| CProductOps | Product and assembly low-level reconstruction primitives. Wire two existing entities together; for shape ingestion use BRepGraph::ShapesView::Add() |
| COccurrenceOps | Occurrence mutation operations |
| CGenOps | Generic node, reference, and representation removal operations |
| CBoundaryIssue | A single boundary invariant issue detected by ValidateMutationBoundary() |
| CTopoView | Unified read-only view over topology definitions, adjacency, and representations |
| CFaceOps | Face-oriented topology queries |
| CEdgeOps | Edge-oriented topology queries |
| CVertexOps | Vertex-oriented topology queries |
| CWireOps | Wire-oriented topology queries |
| CShellOps | Shell-oriented topology queries |
| CSolidOps | Solid-oriented topology queries |
| CCoEdgeOps | Coedge-oriented topology and representation queries |
| CCompoundOps | Compound-oriented topology queries |
| CCompSolidOps | Comp-solid oriented topology queries |
| CProductOps | Product-oriented raw assembly queries |
| COccurrenceOps | Occurrence-oriented raw assembly queries |
| CGenOps | Generic topology and assembly count / meta queries |
| CGeometryOps | Analytic geometry representation queries |
| CMeshView | Read/write view over mesh data |
| CCacheView | Cache reads. Each accessor returns data only if a fresh cache entry exists for the given entity (matched against its current OwnGen) |
| CFaceOps | |
| CEdgeOps | |
| CCoEdgeOps | |
| CPersistentView | Persistent reads. Resolves data through the rep id stored on the entity's definition (FaceDef / EdgeDef / CoEdgeDef). Independent of the cache |
| CFaceOps | |
| CEdgeOps | |
| CCoEdgeOps | |
| CEffectiveView | Resolves mesh data by checking the cache first and the persistent (def-resident) source second. Callers that do not care which source supplies the data go through this view; callers that do care use Cache() or Persistent() directly |
| CFaceOps | |
| CEdgeOps | |
| CCoEdgeOps | |
| CEditorView | Cache mutation surface. Mutates the BRepGraphMesh cache only - does not touch persistent definition data. Persistent rep creation/edit lives on BRepGraph::Editor().Edges(), BRepGraph::Editor().CoEdges(), BRepGraph::Editor().Faces() |
| CFaceOps | |
| CEdgeOps | |
| CCoEdgeOps | |
| CPolyOps | Polygonal and triangulation count queries |
| CRefsView | Read-only view for RefId/RefUID-based reference storage |
| CShellOps | Shell reference queries |
| CFaceOps | Face reference queries |
| CWireOps | Wire reference queries |
| CVertexOps | Vertex reference queries |
| CSolidOps | Solid reference queries |
| CChildOps | Generic child reference queries |
| COccurrenceOps | Occurrence reference queries |
| CGenOps | Generic reference id queries |
| CShapesView | View for TopoDS_Shape ingestion, reconstruction and lookup |
| COptions | Shape-ingestion options |
| CResult | Outcome of a single Add() call |
| CUIDsView | Read-only view for persistent node and reference identifiers |
| CBRepGraph_Cache | Lightweight owner-bound base for transient graph cache services |
| CNodeEntry | Value base for node-derived cache entries |
| CRefEntry | Value base for reference-derived cache entries |
| CItemEntry | Value base for item-derived cache entries |
| CBRepGraph_CacheDerivedState | Cache for derived edge, wire, and shell properties |
| CBRepGraph_CacheIterator | Iterator over registered cache families in a BRepGraph_CacheRegistry |
| CBRepGraph_CacheMesh | Registry-owned runtime mesh cache for BRepGraph |
| CEntryStamp | Entry stamp against the slot recipe and cache-local generation |
| CFaceMeshEntry | Cached mesh entry for a face: single triangulation |
| CCoEdgeMeshEntry | Cached mesh entry for a coedge: polygon-in-parametric-space and polygon-on-triangulation |
| CEdgeMeshEntry | Cached mesh entry for an edge: polygon-3D |
| CDirtySet | Dirty topology set requested from a cache driver |
| CSlotState | Runtime state of a cache slot |
| CDriver | Mesh recomputation driver registered by a meshing toolkit |
| CBRepGraph_CacheRegistry | GUID-keyed runtime registry of graph cache services |
| CBRepGraph_ChildExplorer | Stack-based lazy downward hierarchy walker for BRepGraph with inline location/orientation accumulation |
| CConfig | Consolidated configuration for the explorer |
| CBRepGraph_Compact | Graph compaction algorithm that reclaims removed node slots |
| COptions | Configuration for compaction |
| CResult | Result counters for diagnostics |
| CBRepGraph_Copy | Graph-to-graph deep copy |
| CBRepGraph_CopyRemap | Immutable context passed to layer copy callbacks |
| CBRepGraph_Data | Internal storage for BRepGraph (PIMPL) |
| CBRepGraph_Deduplicate | Deep geometry deduplication algorithm over an existing BRepGraph |
| COptions | Configuration for graph deduplication run |
| CResult | Result counters for diagnostics and tests |
| CBRepGraph_DeferredScope | RAII guard for batch mutation scopes with deferred invalidation |
| CBRepGraph_FacesOfEdge | |
| CBRepGraph_ItemId | Generic BRepGraph item identifier covering definitions and references. Use-records are NOT included - they are session-local, not graph identity |
| CBRepGraph_ItemUID | Durable BRepGraph item identity covering definition nodes and reference entries |
| CBRepGraph_Iterator | Type-safe, allocation-free iterator over BRepGraph definition nodes |
| CBRepGraph_Layer | Abstract base class for named attribute layers |
| CBRepGraph_LayerDeferred | Base layer for postponed graph item loading |
| CRepresentation | One postponed representation attached to a graph item |
| CEntry | Deferred ownership entry for one graph item |
| CRepresentationStorage | Small fixed representation list. Deferred graph items have a bounded number of persisted representations, so avoid one heap allocation per item |
| CBRepGraph_LayerHistory | History layer for BRepGraph |
| CEvent | One atomic modification event recorded in the graph's history log |
| CBRepGraph_LayerIterator | Iterator over registered layers in a BRepGraph_LayerRegistry |
| CBRepGraph_LayerLock | Owner metadata layer for owned BRepGraph items |
| CScopedOwnerEdit | Scoped permission for an owner layer to edit one item it owns |
| CBRepGraph_LayerParametric | Base layer for graph-owned parametric generators |
| CAddResult | Result of adding a new parametric instance to a graph |
| CBRepGraph_LayerRegistry | Dense GUID-keyed runtime registry of graph layers |
| CBRepGraph_LayerTopoSupplement | Runtime-only storage for supplemental TopoDS topology fragments |
| CEntry | Stored runtime attachment record |
| CBRepGraph_MutGuard | RAII scope token batching mutation notifications for a single entity |
| CBRepGraph_NodeId | Lightweight typed index into a per-kind node vector inside BRepGraph |
| CTyped | Compile-time typed wrapper around BRepGraph_NodeId |
| CBRepGraph_ParallelPolicy | Lightweight workload-aware policy for deciding whether an internal phase should actually launch parallel work when parallel mode is allowed |
| CWorkload | Simple workload estimate for an execution phase |
| CBRepGraph_ParentExplorer | Upward occurrence-aware parent traversal for BRepGraph |
| CConfig | Consolidated configuration for the explorer |
| CBRepGraph_RefId | Lightweight typed index into a per-kind reference vector inside BRepGraph |
| CTyped | Compile-time typed wrapper around BRepGraph_RefId |
| CBRepGraph_RefUID | Unique reference-entry identifier within a BRepGraph |
| CBRepGraph_RelatedIterator | Single-level iterator over semantically related topology nodes |
| CBRepGraph_RepId | Lightweight typed index into a per-kind use-record vector inside BRepGraph |
| CTyped | Compile-time typed wrapper around BRepGraph_RepId |
| CBRepGraph_RootProductIterator | Allocation-free iterator over root product identifiers |
| CBRepGraph_SupplementEditor | Lightweight mutation facade for runtime supplement attachments |
| CBRepGraph_SupplementIterator | Iterator over supplemental TopoDS attachments owned by one core node |
| CBRepGraph_Tool | Centralized geometry access for BRepGraph - analogue of BRep_Tool |
| CVertex | Vertex geometry accessors |
| CEdge | Edge geometry, curve, and continuity accessors |
| CCoEdge | CoEdge (half-edge) parametric curve accessors |
| CFace | Face surface and property accessors |
| CWire | Wire property accessors |
| CShell | Shell property accessors |
| CBRepGraph_Transform | Graph-to-graph transformation |
| CBRepGraph_UID | Unique definition-node identifier within a BRepGraph |
| CBRepGraph_UsagePath | Explicit identity of a concrete usage from traversal root to selected node |
| CStep | One concrete traversal step in a usage path |
| CBRepGraph_Validate | Structural invariant checker for BRepGraph |
| CIssue | A single structural issue found in the graph |
| CResult | Aggregated validation result |
| COptions | Validation options |
| CBRepGraph_VersionStamp | Snapshot of a graph item identity and its freshness generation |
| CBRepGraph_WiresOfEdge | |
| CBRepGraphInc_BitFlags | Contiguous bit-vector for per-entity boolean flags |
| CBRepGraphInc_Populate | Backend topology/geometry population for BRepGraph |
| COptions | Options controlling population |
| CBRepGraphInc_Reconstruct | Backend reconstruction helpers over incidence-table storage |
| CCache | Per-Kind dense vector cache for O(1) shape lookup by entity index. Replaces NCollection_DataMap to eliminate hash/equality overhead |
| CTempScope | |
| CBRepGraphInc_Storage | Central backend storage container for the incidence-table topology model |
| CCachedShape | Gen-validated shape cache entry |
| CBRepIntCurveSurface_Inter | Computes the intersection between a face and a curve. To intersect one curve with shape method Init(Shape, curve, tTol) should be used. To intersect a few curves with specified shape it is necessary to load shape one time using method Load(shape, tol) and find intersection points for each curve using method Init(curve). For iteration by intersection points method More() and Next() should be used |
| CBRepLib | The BRepLib package provides general utilities for BRep |
| CBRepLib_CheckCurveOnSurface | Computes the max distance between edge and its 2d representation on the face. This class is not intended to process non-sameparameter edges |
| CBRepLib_Command | Root class for all commands in BRepLib |
| CBRepLib_FindSurface | Provides an algorithm to find a Surface through a set of edges |
| CBRepLib_FuseEdges | This class can detect vertices in a face that can be considered useless and then perform the fuse of the edges and remove the useless vertices. By useles vertices, we mean: |
| CBRepLib_MakeEdge | Provides methods to build edges |
| CBRepLib_MakeEdge2d | Provides methods to build edges |
| CBRepLib_MakeFace | Provides methods to build faces |
| CBRepLib_MakePolygon | Class to build polygonal wires |
| CBRepLib_MakeShape | This is the root class for all shape constructions. It stores the result |
| CBRepLib_MakeShell | Provides methods to build shells |
| CBRepLib_MakeSolid | Makes a solid from compsolid or shells |
| CBRepLib_MakeVertex | Provides methods to build vertices |
| CBRepLib_MakeWire | Provides methods to build wires |
| CBRepLib_PointCloudShape | This tool is intended to get points from shape with specified distance from shape along normal. Can be used to simulation of points obtained in result of laser scan of shape. There are 2 ways for generation points by shape: |
| CBRepLib_ToolTriangulatedShape | Provides methods for calculating normals to Poly_Triangulation of TopoDS_Face |
| CBRepLib_ValidateEdge | Computes the max distance between 3D-curve and curve on surface. This class uses 2 methods: approximate using finite number of points (default) and exact |
| CBRepLProp | These global functions compute the degree of continuity of a curve built by concatenation of two edges at their junction point |
| CBRepLProp_SurfaceTool | |
| CBRepMAT2d_BisectingLocus | BisectingLocus generates and contains the Bisecting_Locus of a set of lines from Geom2d, defined by <ExploSet> |
| CBRepMAT2d_Explorer | Construct an explorer from wires, face, set of curves from Geom2d to compute the bisecting Locus |
| CBRepMAT2d_LinkTopoBilo | Constructs links between the Wire or the Face of the explorer and the BasicElts contained in the bisecting locus |
| CBRepMesh_BaseMeshAlgo | Class provides base functionality for algorithms building face triangulation. Performs initialization of BRepMesh_DataStructureOfDelaun and nodes map structures |
| CBRepMesh_BoundaryParamsRangeSplitter | Auxiliary class extending UV range splitter in order to generate internal nodes for NURBS surface |
| CBRepMesh_Circle | Describes a 2d circle with a size of only 3 double numbers instead of gp who needs 7 double numbers |
| CBRepMesh_CircleInspector | Auxiliary class to find circles shot by the given point |
| CBRepMesh_CircleTool | Create sort and destroy the circles used in triangulation |
| CBRepMesh_Classifier | Auxiliary class intended for classification of points regarding internals of discrete face |
| CBRepMesh_ConeRangeSplitter | Auxiliary class extending default range splitter in order to generate internal nodes for conical surface |
| CBRepMesh_ConstrainedBaseMeshAlgo | Class provides base functionality to build face triangulation using Dealunay approach. Performs generation of mesh using raw data from model |
| CBRepMesh_Context | Class implementing default context of BRepMesh algorithm. Initializes context by default algorithms |
| CBRepMesh_CurveTessellator | Auxiliary class performing tessellation of passed edge according to specified parameters |
| CBRepMesh_CustomBaseMeshAlgo | Class provides base functionality to build face triangulation using custom triangulation algorithm. Performs generation of mesh using raw data from model |
| CBRepMesh_CustomDelaunayBaseMeshAlgo | Class provides base functionality to build face triangulation using custom triangulation algorithm with possibility to modify final mesh. Performs generation of mesh using raw data from model |
| CBRepMesh_CylinderRangeSplitter | Auxiliary class extending default range splitter in order to generate internal nodes for cylindrical surface |
| CBRepMesh_DataStructureOfDelaun | Describes the data structure necessary for the mesh algorithms in two dimensions plane or on surface by meshing in UV space |
| CBRepMesh_DefaultRangeSplitter | Default tool to define range of discrete face model and obtain grid points distributed within this range |
| CBRepMesh_Deflection | Auxiliary tool encompassing methods to compute deflection of shapes |
| CBRepMesh_DelabellaBaseMeshAlgo | Class provides base functionality to build face triangulation using Delabella project. Performs generation of mesh using raw data from model |
| CBRepMesh_DelabellaMeshAlgoFactory | Implementation of IMeshTools_MeshAlgoFactory providing Delabella-based algorithms of different complexity depending on type of target surface |
| CBRepMesh_Delaun | Compute the Delaunay's triangulation with the algorithm of Watson |
| CBRepMesh_DelaunayBaseMeshAlgo | Class provides base functionality to build face triangulation using Dealunay approach. Performs generation of mesh using raw data from model |
| CBRepMesh_DelaunayDeflectionControlMeshAlgo | Extends node insertion Delaunay meshing algo in order to control deflection of generated triangles. Splits triangles failing the check |
| CBRepMesh_DelaunayNodeInsertionMeshAlgo | Extends base Delaunay meshing algo in order to enable possibility of addition of free vertices and internal nodes into the mesh |
| CBRepMesh_DiscretAlgoFactory | Abstract factory for creating meshing algorithms. This class provides a registry-based factory pattern that allows multiple meshing algorithms to coexist without symbol collisions. It follows the pattern established by Graphic3d_GraphicDriverFactory |
| CBRepMesh_DiscretFactory | Factory for retrieving triangulation algorithms. Use BRepMesh_DiscretFactory::Get() static method to retrieve global Factory instance. Use BRepMesh_DiscretFactory::Discret() method to retrieve meshing tool |
| CBRepMesh_DiscretRoot | This is a common interface for meshing algorithms instantiated by Mesh Factory and implemented by plugins |
| CBRepMesh_Edge | Light weighted structure representing link of the mesh |
| CBRepMesh_EdgeDiscret | Class implements functionality of edge discret tool. Performs check of the edges for existing Poly_PolygonOnTriangulation. In case if it fits specified deflection, restores data structure using it, else clears edges from outdated data |
| CBRepMesh_EdgeParameterProvider | Auxiliary class provides correct parameters on curve regarding SameParameter flag |
| CBRepMesh_EdgeTessellationExtractor | Auxiliary class implements functionality retrieving tessellated representation of an edge stored in polygon |
| CBRepMesh_ExtrusionRangeSplitter | Auxiliary class analysing extrusion surface in order to generate internal nodes |
| CBRepMesh_FaceChecker | Auxiliary class checking wires of target face for self-intersections. Explodes wires of discrete face on sets of segments using tessellation data stored in model. Each segment is then checked for intersection with other ones. All collisions are registered and returned as result of check |
| CSegment | |
| CBRepMesh_FaceDiscret | Class implements functionality starting triangulation of model's faces. Each face is processed separately and can be executed in parallel mode. Uses mesh algo factory passed as initializer to create instance of triangulation algorithm according to type of surface of target face |
| CBRepMesh_FastDiscret | |
| CBRepMesh_GeomTool | Tool class accumulating common geometrical functions as well as functionality using shape geometry to produce data necessary for tessellation. General aim is to calculate discretization points for the given curve or iso curve of surface according to the specified parameters |
| CBRepMesh_IncrementalMesh | Builds the mesh of a shape with respect of their correctly triangulated parts |
| CBRepMesh_IncrementalMeshFactory | Factory for creating BRepMesh_IncrementalMesh instances. This factory is registered under the name "FastDiscret" and provides the default built-in meshing algorithm |
| CBRepMesh_MeshAlgoFactory | Default implementation of IMeshTools_MeshAlgoFactory providing algorithms of different complexity depending on type of target surface |
| CBRepMesh_MeshTool | Auxiliary tool providing API for manipulation with BRepMesh_DataStructureOfDelaun |
| CNodeClassifier | Helper functor intended to separate points to left and right from the constraint |
| CBRepMesh_ModelBuilder | Class implements interface representing tool for discrete model building |
| CBRepMesh_ModelHealer | Class implements functionality of model healer tool. Iterates over model's faces and checks consistency of their wires, i.e.whether wires are closed and do not contain self - intersections. In case if wire contains disconnected parts, ends of adjacent edges forming the gaps are connected in parametric space forcibly. The notion of this operation is to create correct discrete model defined relatively parametric space of target face taking into account connectivity and tolerances of 3D space only. This means that there are no specific computations are made for the sake of determination of U and V tolerance. Registers intersections on edges forming the face's shape and tries to amplify discrete representation by decreasing of deflection for the target edge. Checks can be performed in parallel mode |
| CBRepMesh_ModelPostProcessor | Class implements functionality of model post-processing tool. Stores polygons on triangulations to TopoDS_Edge |
| CBRepMesh_ModelPreProcessor | Class implements functionality of model pre-processing tool. Nullifies existing polygonal data in case if model elements have IMeshData_Outdated status |
| CBRepMesh_NodeInsertionMeshAlgo | Extends base meshing algo in order to enable possibility of addition of free vertices into the mesh |
| CBRepMesh_NURBSRangeSplitter | Auxiliary class extending UV range splitter in order to generate internal nodes for NURBS surface |
| CBRepMesh_OrientedEdge | Light weighted structure representing simple link |
| CBRepMesh_PairOfIndex | This class represents a pair of integer indices to store element indices connected to link. It is restricted to store more than two indices in it |
| CBRepMesh_SelectorOfDataStructureOfDelaun | Describes a selector and an iterator on a selector of components of a mesh |
| CBRepMesh_ShapeTool | Auxiliary class providing functionality to compute, retrieve and store data to TopoDS and model shape |
| CBRepMesh_ShapeVisitor | Builds discrete model of a shape by adding faces and free edges. Computes deflection for corresponded shape and checks whether it fits existing polygonal representation. If not, cleans shape from outdated info |
| CBRepMesh_SphereRangeSplitter | Auxiliary class extending default range splitter in order to generate internal nodes for spherical surface |
| CBRepMesh_TorusRangeSplitter | Auxiliary class extending UV range splitter in order to generate internal nodes for NURBS surface |
| CBRepMesh_Triangle | Light weighted structure representing triangle of mesh consisting of oriented links |
| CBRepMesh_Triangulator | Auxiliary tool to generate triangulation |
| CBRepMesh_UndefinedRangeSplitter | Auxiliary class provides safe value for surfaces that looks like NURBS but has no poles or other characteristics |
| CBRepMesh_UVParamRangeSplitter | Intended to generate internal mesh nodes using UV parameters of boundary discrete points |
| CBRepMesh_Vertex | Light weighted structure representing vertex of the mesh in parametric space. Vertex could be associated with 3d point stored in external map |
| CBRepMesh_VertexInspector | Class intended for fast searching of the coincidence points |
| CBRepMesh_VertexTool | Describes data structure intended to keep mesh nodes defined in UV space and implements functionality providing their uniqueness regarding their position |
| CBRepMeshData_Curve | Default implementation of curve data model entity |
| CBRepMeshData_Edge | Default implementation of edge data model entity |
| CBRepMeshData_Face | Default implementation of face data model entity |
| CBRepMeshData_Model | Default implementation of model entity |
| CBRepMeshData_PCurve | Default implementation of pcurve data model entity |
| CBRepMeshData_Wire | Default implementation of wire data model entity |
| CBRepOffset | Auxiliary tools for offset algorithms |
| CBRepOffset_Analyse | Analyses the shape to find the parts of edges connecting the convex, concave or tangent faces |
| CBRepOffset_Inter2d | Computes the intersections between edges on a face stores result is SD as AsDes from BRepOffset |
| CBRepOffset_Inter3d | Computes the connection of the offset and not offset faces according to the connection type required. Store the result in AsDes tool |
| CBRepOffset_Interval | |
| CBRepOffset_MakeLoops | |
| CBRepOffset_MakeOffset | |
| CBRepOffset_MakeSimpleOffset | This class represents simple offset algorithm itself. It builds simple offset without intersection. Solid can be created using SetBuildSolidFlag method (set flag to true). By default shell will be constructed |
| CBRepOffset_Offset | This class compute elemenary offset surface. Evaluate the offset generated : 1 - from a face. 2 - from an edge. 3 - from a vertex |
| CBRepOffset_SimpleOffset | This class represents mechanism of simple offset algorithm i.e. topology-preserve offset construction without intersection |
| CBRepOffset_Tool | |
| CBRepOffsetAPI_DraftAngle | Taper-adding transformations on a shape. The resulting shape is constructed by defining one face to be tapered after another one, as well as the geometric properties of their tapered transformation. Each tapered transformation is propagated along the series of faces which are tangential to one another and which contains the face to be tapered. This algorithm is useful in the construction of molds or dies. It facilitates the removal of the article being produced. A DraftAngle object provides a framework for: |
| CBRepOffsetAPI_FindContigousEdges | Provides methods to identify contiguous boundaries for continuity control (C0, C1, ...) |
| CBRepOffsetAPI_MakeDraft | Build a draft surface along a wire |
| CBRepOffsetAPI_MakeEvolved | Describes functions to build evolved shapes. An evolved shape is built from a planar spine (face or wire) and a profile (wire). The evolved shape is the unlooped sweep (pipe) of the profile along the spine. Self-intersections are removed. A MakeEvolved object provides a framework for: |
| CBRepOffsetAPI_MakeFilling | N-Side Filling This algorithm avoids to build a face from: |
| CBRepOffsetAPI_MakeOffset | Describes algorithms for offsetting wires from a set of wires contained in a planar face. A MakeOffset object provides a framework for: |
| CBRepOffsetAPI_MakeOffsetShape | Describes functions to build a shell out of a shape. The result is an unlooped shape parallel to the source shape. A MakeOffsetShape object provides a framework for: |
| CBRepOffsetAPI_MakePipe | Describes functions to build pipes. A pipe is built a basis shape (called the profile) along a wire (called the spine) by sweeping. The profile must not contain solids. A MakePipe object provides a framework for: |
| CBRepOffsetAPI_MakePipeShell | This class provides for a framework to construct a shell or a solid along a spine consisting in a wire. To produce a solid, the initial wire must be closed. Two approaches are used: |
| CBRepOffsetAPI_MakeThickSolid | Describes functions to build hollowed solids. A hollowed solid is built from an initial solid and a set of faces on this solid, which are to be removed. The remaining faces of the solid become the walls of the hollowed solid, their thickness defined at the time of construction. the solid is built from an initial solid and a set of faces {Fi} from , builds a solid composed by two shells closed by the {Fi}. First shell <SS> is composed by all the faces of expected {Fi}. Second shell is the offset shell of <SS>. A MakeThickSolid object provides a framework for: |
| CBRepOffsetAPI_MiddlePath | Describes functions to build a middle path of a pipe-like shape |
| CBRepOffsetAPI_NormalProjection | A framework to define projection onto a shape according to the normal from each point to be projected. The target shape is a face, and the source shape is an edge or a wire |
| CBRepOffsetAPI_ThruSections | Describes functions to build a loft. This is a shell or a solid passing through a set of sections in a given sequence. Usually sections are wires, but the first and the last sections may be vertices (punctual sections) |
| CBRepPreviewAPI_MakeBox | Builds a valid box, if points fulfill the conditions of a valid box. And allows to build a preview, otherwise. There are 4 cases: 1 - preview can be a vertex if thin box in all directions is a point; 2 - preview can be an edge if thin box in two directions is a point; 3 - preview can be a rectangular face if thin box in only one direction is a point; 4 - preview can be a valid box if point values fulfill the conditions of a valid box |
| CBRepPrim_Builder | Implements the abstract Builder with the BRep Builder |
| CBRepPrim_Cone | Implement the cone primitive |
| CBRepPrim_Cylinder | Cylinder primitive |
| CBRepPrim_FaceBuilder | The FaceBuilder is an algorithm to build a BRep Face from a Geom Surface |
| CBRepPrim_GWedge | A wedge is defined by: |
| CBRepPrim_OneAxis | Algorithm to build primitives with one axis of revolution |
| CBRepPrim_Revolution | Implement the OneAxis algorithm for a revolution surface |
| CBRepPrim_Sphere | Implements the sphere primitive |
| CBRepPrim_Torus | Implements the torus primitive |
| CBRepPrim_Wedge | Provides constructors without Builders |
| CBRepPrimAPI_MakeBox | Describes functions to build parallelepiped boxes. A MakeBox object provides a framework for: |
| CBRepPrimAPI_MakeCone | Describes functions to build cones or portions of cones. A MakeCone object provides a framework for: |
| CBRepPrimAPI_MakeCylinder | Describes functions to build cylinders or portions of cylinders. A MakeCylinder object provides a framework for: |
| CBRepPrimAPI_MakeHalfSpace | Describes functions to build half-spaces. A half-space is an infinite solid, limited by a surface. It is built from a face or a shell, which bounds it, and with a reference point, which specifies the side of the surface where the matter of the half-space is located. A half-space is a tool commonly used in topological operations to cut another shape. A MakeHalfSpace object provides a framework for: |
| CBRepPrimAPI_MakeOneAxis | The abstract class MakeOneAxis is the root class of algorithms used to construct rotational primitives |
| CBRepPrimAPI_MakePrism | Describes functions to build linear swept topologies, called prisms. A prism is defined by: |
| CBRepPrimAPI_MakeRevol | Class to make revolved sweep topologies |
| CBRepPrimAPI_MakeRevolution | Describes functions to build revolved shapes. A MakeRevolution object provides a framework for: |
| CBRepPrimAPI_MakeSphere | Describes functions to build spheres or portions of spheres. A MakeSphere object provides a framework for: |
| CBRepPrimAPI_MakeSweep | The abstract class MakeSweep is the root class of swept primitives. Sweeps are objects you obtain by sweeping a profile along a path. The profile can be any topology and the path is usually a curve or a wire. The profile generates objects according to the following rules: |
| CBRepPrimAPI_MakeTorus | Describes functions to build tori or portions of tori. A MakeTorus object provides a framework for: |
| CBRepPrimAPI_MakeWedge | Describes functions to build wedges, i.e. boxes with inclined faces. A MakeWedge object provides a framework for: |
| CBRepProj_Projection | The Projection class provides conical and cylindrical projections of Edge or Wire on a Shape from TopoDS. The result will be a Edge or Wire from TopoDS |
| CBRepSweep_Builder | Implements the abstract Builder with the BRep Builder |
| CBRepSweep_Iterator | This class provides iteration services required by the Generating Line (TopoDS Shape) of a BRepSweep. This tool is used to iterate on the direct sub-shapes of a Shape |
| CBRepSweep_NumLinearRegularSweep | This a generic class is used to build Sweept primitives with a generating "shape" and a directing "line" |
| CBRepSweep_Prism | Provides natural constructors to build BRepSweep translated swept Primitives |
| CBRepSweep_Revol | Provides natural constructors to build BRepSweep rotated swept Primitives |
| CBRepSweep_Rotation | Provides an algorithm to build object by Rotation sweep |
| CBRepSweep_Tool | Provides the indexation and type analysis services required by the TopoDS generating Shape of BRepSweep |
| CBRepSweep_Translation | Provides an algorithm to build object by translation sweep |
| CBRepSweep_Trsf | This class is inherited from NumLinearRegularSweep to implement the simple swept primitives built moving a Shape with a Trsf. It often is possible to build the constructed subshapes by a simple move of the generating subshapes (shared topology and geometry). So two ways of construction are proposed: |
| CBRepTest | Provides commands to test BRep |
| CBRepTest_DrawableHistory | Drawable History object. Allows keeping histories of the algorithms in Draw |
| CBRepTest_Objects | Provides the access to the useful tools common for the algorithms |
| CBRepToIGES_BREntity | Methods to transfer BRep entity from CASCADE to IGES |
| CBRepToIGES_BRShell | This class implements the transfer of Shape Entities from Geom To IGES. These can be: . Vertex . Edge . Wire |
| CBRepToIGES_BRSolid | This class implements the transfer of Shape Entities from Geom To IGES. These can be: . Vertex . Edge . Wire |
| CBRepToIGES_BRWire | This class implements the transfer of Shape Entities from Geom To IGES. These can be: . Vertex . Edge . Wire |
| CBRepToIGESBRep_Entity | Methods to transfer BRep entity from CASCADE to IGESBRep |
| CBRepTools | The BRepTools package provides utilities for BRep data structures |
| CBRepTools_CopyModification | Tool class implementing necessary functionality for copying geometry and triangulation |
| CBRepTools_GTrsfModification | Defines a modification of the geometry by a GTrsf from gp. All methods return True and transform the geometry |
| CBRepTools_History | The history keeps the following relations between the input shapes (S1, ..., Sm) and output shapes (T1, ..., Tn): 1) an output shape Tj is generated from an input shape Si: Tj <= G(Si); 2) a output shape Tj is modified from an input shape Si: Tj <= M(Si); 3) an input shape (Si) is removed: R(Si) == 1 |
| CBRepTools_Modification | Defines geometric modifications to a shape, i.e. changes to faces, edges and vertices |
| CBRepTools_Modifier | Performs geometric modifications on a shape |
| CBRepTools_NurbsConvertModification | Defines a modification of the geometry by a Trsf from gp. All methods return True and transform the geometry |
| CBRepTools_PurgeLocations | Removes location datums, which satisfy conditions: aTrsf.IsNegative() || (std::abs(std::abs(aTrsf.ScaleFactor()) - 1.) > TopLoc_Location::ScalePrec()) from all locations of shape and its subshapes |
| CBRepTools_Quilt | A Tool to glue faces at common edges and reconstruct shells |
| CBRepTools_ReShape | Rebuilds a Shape by making pre-defined substitutions on some of its components |
| CBRepTools_ShapeSet | Contains a Shape and all its subshapes, locations and geometries |
| CBRepTools_Substitution | A tool to substitute subshapes by other shapes |
| CBRepTools_TrsfModification | Describes a modification that uses a gp_Trsf to change the geometry of a shape. All functions return true and transform the geometry of the shape |
| CBRepTools_WireExplorer | The WireExplorer is a tool to explore the edges of a wire in a connection order |
| CBRepTopAdaptor_FClass2d | |
| CBRepTopAdaptor_HVertex | |
| CBRepTopAdaptor_Tool | |
| CBRepTopAdaptor_TopolTool | |
| CBSplCLib | BSplCLib B-spline curve Library |
| CBSplCLib_Cache | A cache class for Bezier and B-spline curves |
| CBSplCLib_CacheParams | Simple structure containing parameters describing parameterization of a B-spline curve or a surface in one direction (U or V), and data of the current span for its caching |
| CBSplCLib_EvaluatorFunction | |
| CBSplSLib | BSplSLib B-spline surface Library This package provides an implementation of geometric functions for rational and non rational, periodic and non periodic B-spline surface computation |
| CBSplSLib_Cache | A cache class for Bezier and B-spline surfaces |
| CBSplSLib_EvaluatorFunction | |
| CBVH_BaseBox | Base class for BVH_Box (CRTP idiom is used) |
| CBVH_BaseBox< T, 3, BVH_Box > | Partial template specialization for BVH_Box when N = 3 |
| CBVH_BaseTraverse | The classes implement the traverse of the BVH tree |
| CBVH_Bin | Stores parameters of single bin (slice of AABB) |
| CBVH_BinaryTree | Type corresponding to binary BVH |
| CBVH_BinnedBuilder | Performs construction of BVH tree using binned SAH algorithm. Number of bins controls BVH quality in cost of construction time (greater - better). For optimal results, use 32 - 48 bins. However, reasonable performance is provided even for 4 - 8 bins (it is only 10-20% lower in comparison with optimal settings). Note that multiple threads can be used only with thread safe BVH primitive sets |
| CBVH_SplitPlane | Describes split plane candidate |
| CBVH_Box | Defines axis aligned bounding box (AABB) based on BVH vectors |
| CBVH_BoxSet | Implements easy to use interfaces for adding the elements into BVH tree and its following construction. To make it more effective it is better to set the number of elements that are going to be added into BVH tree. For better efficiency on heavy data types it is recommended to use either BHV_IndexedBoxSet which uses indirect indexing for accessing the elements and their boxes or set the element to be an index of the real element in the application's internal data structures |
| CBVH_Builder | Performs construction of BVH tree using bounding boxes (AABBs) of abstract objects |
| CBVH_BuilderTransient | A non-template class for using as base for BVH_Builder (just to have a named base class) |
| CBVH_BuildQueue | Command-queue for parallel building of BVH nodes |
| CBVH_BuildThread | Wrapper for BVH build thread |
| CBVH_BuildTool | Tool object to call BVH builder subroutines |
| CBVH_Distance | Abstract class for computation of the min distance between some Object and elements of BVH tree. To use this class it is required to define two methods: |
| CBVH_DistanceField | Tool object for building 3D distance field from the set of BVH triangulations. Distance field is a scalar field that measures the distance from a given point to some object, including optional information about the inside and outside of the structure. Distance fields are used as alternative surface representations (like polygons or NURBS) |
| CBVH_Geometry | BVH geometry as a set of abstract geometric objects organized with bounding volume hierarchy (BVH) |
| CBVH_IndexedBoxSet | Implements easy to use interfaces for adding the elements into BVH tree and its following construction. To make it more effective it is better to set the number of elements that are going to be added into BVH tree. It uses the indirect indexing for accessing the elements and their boxes which allows using heavy data types as elements with better efficiency during BVH construction and just a bit slower selection time. Due to better BVH tree construction time the class will be more efficient than BVH_BoxSet on the operations where just a few selections from the tree required |
| CBVH_LinearBuilder | Performs fast BVH construction using LBVH building approach. Algorithm uses spatial Morton codes to reduce the BVH construction problem to a sorting problem (radix sort – O(N) complexity). This Linear Bounding Volume Hierarchy (LBVH) builder produces BVH trees of lower quality compared to SAH-based BVH builders but it is over an order of magnitude faster (up to 3M triangles per second) |
| CBVH_Object | Abstract geometric object bounded by BVH box |
| CBVH_ObjectSet | Array of abstract entities (bounded by BVH boxes) to built BVH |
| CBVH_ObjectTransient | A non-template class for using as base for BVH_Object (just to have a named base class) |
| CBVH_PairDistance | Abstract class for computation of the min distance between elements of two BVH trees. To use this class it is required to define only the method Accept to compute the distance between elements of the trees |
| CBVH_PairTraverse | Abstract class implementing the parallel traverse of two binary trees. Selection of the data from the trees is performed by the rules defined in the Accept/Reject methods. See description of the required methods in the comments above |
| CBVH_PairNodesInStack | |
| CBVH_ParallelDistanceFieldBuilder | |
| CBVH_PrimitiveSet | Set of abstract geometric primitives organized with bounding volume hierarchy (BVH). Unlike an object set, this collection is designed for storing structural elements of a single object (such as triangles in the object triangulation). Because there may be a large number of such elements, the implementations of this interface should be sufficiently optimized |
| CBVH_Properties | Abstract properties of geometric object |
| CBVH_QuadTree | Type corresponding to quad BVH |
| CBVH_QueueBuilder | Abstract BVH builder based on the concept of work queue. Queue based BVH builders support parallelization with a fixed number of threads (maximum efficiency is achieved by setting the number of threads equal to the number of CPU cores plus one). Note that to support parallel mode, a corresponding BVH primitive set should provide thread safe implementations of interface functions (e.g., Swap, Box, Center). Otherwise, the results will be undefined |
| CBVH_PrimitiveRange | Stores range of primitives belonging to a BVH node |
| CBVH_ChildNodes | Stores parameters of constructed child nodes |
| CBVH_TypedBuildTool | Wrapper for BVH build data |
| CBVH_QuickSorter | Performs centroid-based sorting of abstract set along the given axis (X - 0, Y - 1, Z - 2) using std::sort. Uses introsort algorithm which guarantees O(n log n) complexity |
| CBVH_RadixSorter | Performs radix sort of a BVH primitive set using 10-bit Morton codes (or 1024 x 1024 x 1024 grid) |
| CBVH_Ray | Describes a ray based on BVH vectors |
| CBVH_Set | Set of abstract entities (bounded by BVH boxes). This is the minimal geometry interface needed to construct BVH |
| CBVH_Sorter | Tool object to sort abstract primitive set |
| CBVH_SpatialMedianBuilder | Performs building of BVH tree using spatial median split algorithm |
| CBVH_SweepPlaneBuilder | Performs building of BVH tree using sweep plane SAH algorithm |
| CBVH_Tools | Defines a set of static methods operating with points and bounding boxes |
| CBVH_Transform | Stores transform properties of geometric object |
| CBVH_Traverse | Abstract class implementing the traverse of the single binary tree. Selection of the data from the tree is performed by the rules defined in the Accept/Reject methods. See description of the required methods in the comments above |
| CBVH_NodeInStack | |
| CBVH_Tree | BVH tree with given arity (2 or 4) |
| CBVH_Tree< T, N, BVH_BinaryTree > | Specialization of binary BVH tree |
| CBVH_Tree< T, N, BVH_QuadTree > | Specialization of quad BVH (QBVH) tree |
| CBVH_TreeBase | Stores parameters of bounding volume hierarchy (BVH). Bounding volume hierarchy (BVH) organizes geometric objects in the tree based on spatial relationships. Each node in the tree contains an axis-aligned bounding box of all the objects below it. Bounding volume hierarchies are used in many algorithms to support efficient operations on the sets of geometric objects, such as collision detection, ray-tracing, searching of nearest objects, and view frustum culling |
| CBVH_TreeBaseTransient | A non-template class for using as base for BVH_TreeBase (just to have a named base class) |
| CBVH_Triangulation | Triangulation as an example of BVH primitive set |
| CCDF_Application | |
| CCDF_Directory | A directory is a collection of documents. There is only one instance of a given document in a directory. put |
| CCDF_DirectoryIterator | |
| CCDF_FWOSDriver | |
| CCDF_MetaDataDriver | This class list the method that must be available for a specific DBMS |
| CCDF_MetaDataDriverFactory | |
| CCDF_Store | |
| CCDF_StoreList | |
| CCDM_Application | |
| CCDM_Document | An applicative document is an instance of a class inheriting CDM_Document. These documents have the following properties: |
| CCDM_MetaData | |
| CCDM_Reference | |
| CCDM_ReferenceIterator | |
| CChFi2d | This package contains the algorithms used to build fillets or chamfers on planar wire |
| CChFi2d_AnaFilletAlgo | An analytical algorithm for calculation of the fillets. It is implemented for segments and arcs of circle only |
| CChFi2d_Builder | This class contains the algorithm used to build fillet on planar wire |
| CChFi2d_ChamferAPI | A class making a chamfer between two linear edges |
| CChFi2d_FilletAlgo | Algorithm that creates fillet edge: arc tangent to two edges in the start and in the end vertices. Initial edges must be located on the plane and must be connected by the end or start points (shared vertices are not obligatory). Created fillet arc is created with the given radius, that is useful in sketcher applications |
| CChFi2d_FilletAPI | An interface class for 2D fillets. Open CASCADE provides two algorithms for 2D fillets: ChFi2d_Builder - it constructs a fillet or chamfer for linear and circular edges of a face. ChFi2d_FilletAPI - it encapsulates two algorithms: ChFi2d_AnaFilletAlgo - analytical constructor of the fillet. It works only for linear and circular edges, having a common point. ChFi2d_FilletAlgo - iteration recursive method constructing the fillet edge for any type of edges including ellipses and b-splines. The edges may even have no common point |
| CChFi3d | Creation of spatial fillets on a solid |
| CChFi3d_Builder | Root class for calculation of surfaces (fillets, chamfers) destined to smooth edges of a gap on a Shape and the reconstruction of the Shape |
| CChFi3d_ChBuilder | Construction tool for 3D chamfers on edges (on a solid) |
| CChFi3d_FilBuilder | Tool of construction of fillets 3d on edges (on a solid) |
| CChFi3d_SearchSing | Searches singularities on fillet. F(t) = (C1(t) - C2(t)).(C1'(t) - C2'(t)); |
| CChFiDS_ChamfSpine | Provides data specific to chamfers distances on each of faces |
| CChFiDS_CircSection | A Section of fillet |
| CChFiDS_CommonPoint | Point start/end of fillet common to 2 adjacent filets and to an edge on one of 2 faces participating in the construction of the fillet |
| CChFiDS_ElSpine | Elementary Spine for cheminements and approximations |
| CChFiDS_FaceInterference | Interference face/fillet |
| CChFiDS_FilSpine | Provides data specific to the fillets - vector or rule of evolution (C2) |
| CChFiDS_Map | Encapsulation of IndexedDataMapOfShapeListOfShape |
| CChFiDS_Regul | Storage of a curve and its 2 faces or surfaces of support |
| CChFiDS_Spine | Contains information necessary for construction of a 3D fillet or chamfer: |
| CChFiDS_Stripe | Data characterising a band of fillet |
| CChFiDS_StripeMap | Encapsulation of IndexedDataMapOfVertexListOfStripe |
| CChFiDS_SurfData | Data structure for all information related to the fillet and to 2 faces vis a vis |
| CChFiKPart_ComputeData | Methodes de classe permettant de remplir une SurfData dans les cas particuliers de conges suivants: |
| CCocoa_LocalPool | Auxiliary class to create local pool |
| CCocoa_Window | This class defines Cocoa window |
| CContap_ArcFunction | |
| CContap_ContAna | This class provides the computation of the contours for quadric surfaces |
| CContap_Contour | |
| CContap_HContTool | Tool for the intersection between 2 surfaces. Regroupe pour l instant les methodes hors Adaptor3d.. |
| CContap_HCurve2dTool | |
| CContap_Line | |
| CContap_Point | Definition of a vertex on the contour line. Most of the time, such a point is an intersection between the contour and a restriction of the surface. When it is not the method IsOnArc return False. Such a point is contains geometrical information (see the Value method) and logical information |
| CContap_SurfFunction | This class describes the function on a parametric surface. the form of the function is F(u,v) = 0 where u and v are the parametric coordinates of a point on the surface, to compute the contours of the surface |
| CContap_SurfProps | Internal tool used to compute the normal and its derivatives |
| CContap_TheIWalking | |
| CContap_TheIWLineOfTheIWalking | |
| CContap_ThePathPointOfTheSearch | |
| CContap_TheSearch | |
| CContap_TheSearchInside | |
| CContap_TheSegmentOfTheSearch | |
| CConvert_CircleToBSplineCurve | This algorithm converts a circle into a rational B-spline curve. The circle is a Circ2d from package gp and its parametrization is : P (U) = Loc + R * (std::cos(U) * Xdir + std::sin(U) * YDir) where Loc is the center of the circle Xdir and Ydir are the normalized directions of the local cartesian coordinate system of the circle. The parametrization range for the circle is U [0, 2Pi] |
| CConvert_CompBezierCurves2dToBSplineCurve2d | Converts a list of connecting Bezier Curves 2d to a BSplineCurve 2d. if possible, the continuity of the BSpline will be increased to more than C0 |
| CConvert_CompBezierCurvesToBSplineCurve | An algorithm to convert a sequence of adjacent non-rational Bezier curves into a BSpline curve. A CompBezierCurvesToBSplineCurve object provides a framework for: |
| CConvert_CompBezierCurvesToBSplineCurveBase | Template base class for converting a sequence of adjacent non-rational Bezier curves into a BSpline curve. PointType is gp_Pnt or gp_Pnt2d; VecType is gp_Vec or gp_Vec2d |
| CConvert_CompPolynomialToPoles | Convert a serie of Polynomial N-Dimensional Curves that are have continuity CM to an N-Dimensional Bspline Curve that has continuity CM. (to convert an function (curve) polynomial by span in a BSpline) This class uses the following arguments : NumCurves : the number of Polynomial Curves Continuity: the requested continuity for the n-dimensional Spline Dimension : the dimension of the Spline MaxDegree : maximum allowed degree for each composite polynomial segment. NumCoeffPerCurve : the number of coefficient per segments = degree - 1 Coefficients : the coefficients organized in the following way [1..<myNumPolynomials>][1..myMaxDegree +1][1..myDimension] that is : index [n,d,i] is at slot (n-1) * (myMaxDegree + 1) * myDimension + (d-1) * myDimension + i PolynomialIntervals : nth polynomial represents a polynomial between myPolynomialIntervals->Value(n,0) and myPolynomialIntervals->Value(n,1) TrueIntervals : the nth polynomial has to be mapped linearly to be defined on the following interval : myTrueIntervals->Value(n) and myTrueIntervals->Value(n+1) so that it adequately represents the function with the required continuity |
| CConvert_ConeToBSplineSurface | This algorithm converts a bounded Cone into a rational B-spline surface. The cone a Cone from package gp. Its parametrization is: P (U, V) = Loc + V * Zdir + (R + V*Tan(Ang)) * (std::cos(U)*Xdir + std::sin(U)*Ydir) where Loc is the location point of the cone, Xdir, Ydir and Zdir are the normalized directions of the local cartesian coordinate system of the cone (Zdir is the direction of the Cone's axis), Ang is the cone semi-angle. The U parametrization range is [0, 2PI]. KeyWords : Convert, Cone, BSplineSurface |
| CConvert_ConicToBSplineCurve | Root class for algorithms which convert a conic curve into a BSpline curve (CircleToBSplineCurve, EllipseToBSplineCurve, HyperbolaToBSplineCurve, ParabolaToBSplineCurve). These algorithms all work on 2D curves from the gp package and compute all the data needed to construct a BSpline curve equivalent to the conic curve. This data consists of: |
| CConvert_CylinderToBSplineSurface | This algorithm converts a bounded cylinder into a rational B-spline surface. The cylinder is a Cylinder from package gp. The parametrization of the cylinder is: P (U, V) = Loc + V * Zdir + Radius * (Xdir*std::cos(U) + Ydir*Sin(U)) where Loc is the location point of the cylinder, Xdir, Ydir and Zdir are the normalized directions of the local cartesian coordinate system of the cylinder (Zdir is the direction of the cylinder's axis). The U parametrization range is U [0, 2PI]. KeyWords : Convert, Cylinder, BSplineSurface |
| CConvert_ElementarySurfaceToBSplineSurface | Root class for algorithms which convert an elementary surface (cylinder, cone, sphere or torus) into a BSpline surface. These algorithms all work on elementary surfaces from the gp package and compute all the data needed to construct a BSpline surface equivalent to the cylinder, cone, sphere or torus |
| CConvert_EllipseToBSplineCurve | This algorithm converts a ellipse into a rational B-spline curve. The ellipse is represented an Elips2d from package gp with the parametrization : P (U) = Loc + (MajorRadius * std::cos(U) * Xdir + MinorRadius * std::sin(U) * Ydir) where Loc is the center of the ellipse, Xdir and Ydir are the normalized directions of the local cartesian coordinate system of the ellipse. The parametrization range is U [0, 2PI]. KeyWords : Convert, Ellipse, BSplineCurve, 2D |
| CConvert_GridPolynomialToPoles | Convert a grid of Polynomial Surfaces that are have continuity CM to an Bspline Surface that has continuity CM |
| CConvert_HyperbolaToBSplineCurve | This algorithm converts a hyperbola into a rational B-spline curve. The hyperbola is an Hypr2d from package gp with the parametrization : P (U) = Loc + (MajorRadius * std::cosh(U) * Xdir + MinorRadius * std::sinh(U) * Ydir) where Loc is the location point of the hyperbola, Xdir and Ydir are the normalized directions of the local cartesian coordinate system of the hyperbola. KeyWords : Convert, Hyperbola, BSplineCurve, 2D |
| CConvert_ParabolaToBSplineCurve | This algorithm converts a parabola into a non rational B-spline curve. The parabola is a Parab2d from package gp with the parametrization P (U) = Loc + F * (U*U * Xdir + 2 * U * Ydir) where Loc is the apex of the parabola, Xdir is the normalized direction of the symmetry axis of the parabola, Ydir is the normalized direction of the directrix and F is the focal length. KeyWords : Convert, Parabola, BSplineCurve, 2D |
| CConvert_SphereToBSplineSurface | This algorithm converts a bounded Sphere into a rational B-spline surface. The sphere is a Sphere from package gp. The parametrization of the sphere is: P (U, V) = Loc + Radius * std::sin(V) * Zdir + Radius * std::cos(V) * (std::cos(U)*Xdir + std::sin(U)*Ydir) where Loc is the center of the sphere Xdir, Ydir and Zdir are the normalized directions of the local cartesian coordinate system of the sphere. The parametrization range is U [0, 2PI] and V [-PI/2, PI/2]. KeyWords : Convert, Sphere, BSplineSurface |
| CConvert_TorusToBSplineSurface | This algorithm converts a bounded Torus into a rational B-spline surface. The torus is a Torus from package gp. The parametrization of the torus is : P (U, V) = Loc + MinorRadius * std::sin(V) * Zdir + (MajorRadius+MinorRadius*std::cos(V)) * (std::cos(U)*Xdir + std::sin(U)*Ydir) where Loc is the center of the torus, Xdir, Ydir and Zdir are the normalized directions of the local cartesian coordinate system of the Torus. The parametrization range is U [0, 2PI], V [0, 2PI]. KeyWords : Convert, Torus, BSplineSurface |
| CCPnts_AbscissaPoint | Algorithm computes a point on a curve at a given distance from another point on the curve |
| CCPnts_MyGaussFunction | For implementation, compute values for Gauss |
| CCPnts_MyRootFunction | Implements a function for the Newton algorithm to find the solution of Integral(F) = L (compute Length and Derivative of the curve for Newton) |
| CCPnts_UniformDeflection | This class defines an algorithm to create a set of points (with a given chordal deviation) at the positions of constant deflection of a given parametrized curve or a trimmed circle. The continuity of the curve must be at least C2 |
| CCSLib | Provides functions for basic geometric computation on curves and surfaces |
| CCSLib_Class2d | Low-level algorithm for 2D point-in-polygon classification |
| CCSLib_NormalPolyDef | Polynomial definition for surface normal computation at singular points |
| CD3DHost_FrameBuffer | Implements bridge FBO for direct rendering to Direct3D surfaces |
| CD3DHost_GraphicDriver | This class defines D3D host for an OpenGl graphic driver |
| CD3DHost_GraphicDriverFactory | This class for creation of D3DHost_GraphicDriver |
| CD3DHost_View | The D3D host view implementation that overrides rendering methods |
| CD3DHostTest | This package defines a set of Draw commands for testing of TKD3DHost library |
| CDBRep | Used to display BRep objects using the DrawTrSurf package. The DrawableShape is a Display object build from a Shape. Provides methods to manage a directory of named shapes. Provides a set of Draw commands for Shapes |
| CDBRep_DrawableShape | Drawable structure to display a shape. Contains a list of edges and a list of faces |
| CDBRep_Edge | Display of an edge. Edge + color |
| CDBRep_Face | Display of a face. Face + Array of iso + color |
| CDBRep_HideData | This class stores all the information concerning hidden lines on a view |
| CDBRep_IsoBuilder | Creation of isoparametric curves |
| CDBRep_Params | DBRep parameters |
| CDDataStd | |
| CDDataStd_DrawDriver | Root class of drivers to build draw variables from TDF_Label. Priority rule to display standard attributes is : |
| CDDataStd_DrawPresentation | Draw presentation of a label of a document |
| CDDataStd_TreeBrowser | |
| CDDF | Provides facilities to manipulate data framework in a Draw-Commands environment |
| CDDF_AttributeBrowser | |
| CDDF_Browser | Browses a data framework from TDF |
| CDDF_Data | Encapsulates a data framework from TDF in a drawable object |
| CDDF_Transaction | This class encapsulates TDF_Transaction |
| CDDocStd | This package provides Draw services to test CAF standard documents (see TDocStd package) |
| CDDocStd_DrawDocument | |
| CDE_ConfigurationContext | Provides convenient interface to resource file Allows loading of the resource file and getting attributes' values starting from some scope, for example if scope is defined as "ToV4" and requested parameter is "exec.op", value of "ToV4.exec.op" parameter from the resource file will be returned |
| CDE_ConfigurationNode | Base class to work with CAD transfer properties. Stores the necessary settings for a single Provider type. Configures and creates special provider to transfer CAD files |
| CDE_SectionGlobal | < Internal parameters for transfer process |
| CDE_MultiPluginHolder | Helper class for variadic plugin registration. Allows registration of multiple configuration node types simultaneously |
| CDE_PluginHolder | Base class to work with DE_Wrapper global registration of components. Control life-time of current configuration node. In creating stage load into global configuration. On destroying stage unload from global configuration. Operation to load/unload are thread safety |
| CDE_Provider | Base class to make transfer process. Reads or Writes specialized CAD files into/from OCCT. Each operation needs the Configuration Node |
| CWriteStreamNode | Node to store write stream information Contains relative path and reference to output stream |
| CReadStreamNode | Node to store read stream information Contains relative path and reference to input stream |
| CDE_ShapeFixConfigurationNode | Base class to work with shape healing parameters for child classes |
| CDE_ShapeFixParameters | Struct for shape healing parameters storage |
| CDE_ValidationUtils | Utility class providing static methods for common validation operations used across DataExchange providers. Includes validation for configuration nodes, file paths, streams, and other common scenarios with optional verbose error reporting |
| CDE_Wrapper | The main class for working with CAD file exchange. Loads and Saves special CAD transfer property. Consolidates all supported Formats and Vendors. Automatically recognizes CAD format and uses the preferred existed Vendor. Note: If Vendor's format is not binded, the configuration loading doesn't affect on its property |
| CDEBREP_ConfigurationNode | The purpose of this class is to configure the transfer process for BRep format Stores the necessary settings for DEBREP_Provider. Configures and creates special provider to transfer BRep files |
| CDEBRep_InternalSection | |
| CDEBREP_Provider | The class to transfer BRep files. Reads and Writes any BRep files into/from OCCT. Each operation needs configuration node |
| CDEGLTF_ConfigurationNode | The purpose of this class is to configure the transfer process for glTF format Stores the necessary settings for DEGLTF_Provider. Configures and creates special provider to transfer glTF files |
| CRWGltf_InternalSection | |
| CDEGLTF_Provider | The class to transfer glTF files. Reads and Writes any glTF files into/from OCCT. Each operation needs configuration node |
| CDEIGES_ConfigurationNode | The purpose of this class is to configure the transfer process for IGES format Stores the necessary settings for DEIGES_Provider. Configures and creates special provider to transfer IGES files |
| CDEIGES_Parameters | |
| CDEIGES_Provider | The class to transfer IGES files. Reads and Writes any IGES files into/from OCCT. Each operation needs configuration node |
| CDEOBJ_ConfigurationNode | The purpose of this class is to configure the transfer process for OBJ format Stores the necessary settings for DEOBJ_Provider. Configures and creates special provider to transfer OBJ files |
| CRWObj_InternalSection | |
| CDEOBJ_Provider | The class to transfer OBJ files. Reads and Writes any OBJ files into/from OCCT. Each operation needs configuration node |
| CDEPLY_ConfigurationNode | The purpose of this class is to configure the transfer process for PLY format Stores the necessary settings for DEPLY_Provider. Configures and creates special provider to transfer PLY files |
| CRWPly_InternalSection | |
| CDEPLY_Provider | The class to transfer PLY files. Writes any PLY files from OCCT. Each operation needs configuration node |
| CDESTEP_ConfigurationNode | The purpose of this class is to configure the transfer process for STEP format Stores the necessary settings for DESTEP_Provider. Configures and creates special provider to transfer STEP files |
| CDESTEP_Parameters | |
| CDESTEP_Provider | The class to transfer STEP files. Reads and Writes any STEP files into/from OCCT. Each operation needs configuration node |
| CDESTL_ConfigurationNode | The purpose of this class is to configure the transfer process for STL format Stores the necessary settings for DESTL_Provider. Configures and creates special provider to transfer STL files |
| CRWStl_InternalSection | |
| CDESTL_Provider | The class to transfer STL files. Reads and Writes any STL files into/from OCCT. Each operation needs configuration node |
| CDEVRML_ConfigurationNode | The purpose of this class is to configure the transfer process for VRML format Stores the necessary settings for DEVRML_Provider. Configures and creates special provider to transfer VRML files |
| CVrml_InternalSection | |
| CDEVRML_Provider | The class to transfer VRML files. Reads and Writes any VRML files into/from OCCT. Each operation needs configuration node |
| CDEXCAF_ConfigurationNode | The purpose of this class is to configure the transfer process for XDE Documents Stores the necessary settings for DEXCAF_Provider. Configures and creates special provider to transfer XDE Documents |
| CXCAFDoc_InternalSection | |
| CDEXCAF_Provider | The class to transfer XCAF Documents. Reads and Writes any XDE Document files into/from OCCT. Each operation needs configuration node |
| Cdirpart | |
| CDNaming | |
| CDNaming_BooleanOperationDriver | Driver for Fuse, Cut, Common |
| CDNaming_BoxDriver | |
| CDNaming_CylinderDriver | Computes Cylinder function |
| CDNaming_FilletDriver | |
| CDNaming_Line3DDriver | Computes Line 3D function |
| CDNaming_PointDriver | Driver for PointXYZ and RelativePoint |
| CDNaming_PrismDriver | |
| CDNaming_RevolutionDriver | |
| CDNaming_SelectionDriver | |
| CDNaming_SphereDriver | |
| CDNaming_TransformationDriver | |
| CDPrsStd | |
| CDraft | |
| CDraft_EdgeInfo | |
| CDraft_FaceInfo | |
| CDraft_Modification | |
| CDraft_VertexInfo | |
| CDraw | MAQUETTE DESSIN MODELISATION |
| CDraw_Axis2D | |
| CDraw_Axis3D | |
| CDraw_Box | 3d box |
| CDraw_Chronometer | Class to store chronometer variables |
| CDraw_Circle2D | |
| CDraw_Circle3D | |
| CDraw_Color | |
| CDraw_Display | Use to draw in a 3d or a 2d view |
| CDraw_Drawable2D | |
| CDraw_Drawable3D | |
| CDraw_Grid | |
| CDraw_Interpretor | Provides an encapsulation of the TCL interpreter to define Draw commands |
| CCallBackData | Callback for TCL (interface) |
| CCallBackDataFunc | Callback implementation for global function definition |
| CCallBackDataMethod | Callback implementation for class's method definition |
| CDraw_Marker2D | |
| CDraw_Marker3D | |
| CDraw_Number | To store numbers in variables |
| CDraw_Printer | Implementation of Printer class with output (Message_Messenge) directed to Draw_Interpretor |
| CDraw_ProgressIndicator | Implements ProgressIndicator (interface provided by Message) for DRAW, with possibility to output to TCL window and/or trace file |
| CDraw_Segment2D | |
| CDraw_Segment3D | |
| CDraw_Text2D | |
| CDraw_Text3D | |
| CDraw_View | |
| CDraw_Viewer | |
| CDraw_Window | Draw window |
| CDraw_XSegment | Segment definition |
| CDrawDim | This package provides Drawable Dimensions |
| CDrawDim_Angle | |
| CDrawDim_Dimension | Dimension between planes and cylinder |
| CDrawDim_Distance | |
| CDrawDim_PlanarAngle | |
| CDrawDim_PlanarDiameter | |
| CDrawDim_PlanarDimension | Dimensions between point, line and circle ON a plane |
| CDrawDim_PlanarDistance | PlanarDistance point/point PlanarDistance point/line PlanarDistance line/line |
| CDrawDim_PlanarRadius | |
| CDrawDim_Radius | |
| CDrawFairCurve_Batten | Interactive Draw object of type "Batten" |
| CDrawFairCurve_MinimalVariation | Interactive Draw object of type "MVC" |
| CDrawTrSurf | This package supports the display of parametric curves and surfaces |
| CDrawTrSurf_BezierCurve | |
| CDrawTrSurf_BezierCurve2d | |
| CDrawTrSurf_BezierSurface | |
| CDrawTrSurf_BSplineCurve | |
| CDrawTrSurf_BSplineCurve2d | |
| CDrawTrSurf_BSplineSurface | This class defines a drawable BSplineSurface. With this class you can draw the control points and the knots of the surface. You can use the general class Surface from DrawTrSurf too, if you just want to sea boundaries and isoparametric curves |
| CDrawTrSurf_Curve | This class defines a drawable curve in 3d space |
| CDrawTrSurf_Curve2d | This class defines a drawable curve in 2d space. The curve is drawn in the plane XOY |
| CDrawTrSurf_Drawable | This class adds to the Drawable3D methods to display Curves and Curves on Surface |
| CDrawTrSurf_Params | DrawTrSurf parameters |
| CDrawTrSurf_Point | A drawable point |
| CDrawTrSurf_Polygon2D | Used to display a 2d polygon. Optional display of nodes |
| CDrawTrSurf_Polygon3D | Used to display a 3d polygon. Optional display of nodes |
| CDrawTrSurf_Surface | This class defines a drawable surface. With this class you can draw a general surface from package Geom |
| CDrawTrSurf_Triangulation | Used to display a triangulation |
| CDrawTrSurf_Triangulation2D | Used to display a 2d triangulation |
| CDsgPrs | Describes Standard Presentations for DsgIHM objects |
| CDsgPrs_AnglePresentation | A framework for displaying angles |
| CDsgPrs_Chamf2dPresentation | Framework for display of 2D chamfers |
| CDsgPrs_ConcentricPresentation | A framework to define display of relations of concentricity |
| CDsgPrs_DatumPrs | A framework for displaying an XYZ trihedron |
| CDsgPrs_DiameterPresentation | A framework for displaying diameters in shapes |
| CDsgPrs_EllipseRadiusPresentation | |
| CDsgPrs_EqualDistancePresentation | A framework to display equal distances between shapes and a given plane. The distance is the length of a projection from the shape to the plane. These distances are used to compare two shapes by this vector alone |
| CDsgPrs_EqualRadiusPresentation | A framework to define display of equality in radii |
| CDsgPrs_FilletRadiusPresentation | A framework for displaying radii of fillets |
| CDsgPrs_FixPresentation | Class which draws the presentation of Fixed objects |
| CDsgPrs_IdenticPresentation | |
| CDsgPrs_LengthPresentation | Framework for displaying lengths. The length displayed is indicated by line segments and text alone or by a combination of line segment, text and arrows at either or both of its ends |
| CDsgPrs_MidPointPresentation | |
| CDsgPrs_OffsetPresentation | A framework to define display of offsets |
| CDsgPrs_ParalPresentation | A framework to define display of relations of parallelism between shapes |
| CDsgPrs_PerpenPresentation | A framework to define display of perpendicular constraints between shapes |
| CDsgPrs_RadiusPresentation | A framework to define display of radii |
| CDsgPrs_ShadedPlanePresentation | A framework to define display of shaded planes |
| CDsgPrs_ShapeDirPresentation | A framework to define display of the normal to the surface of a shape |
| CDsgPrs_SymbPresentation | A framework to define display of symbols |
| CDsgPrs_SymmetricPresentation | A framework to define display of symmetry between shapes |
| CDsgPrs_TangentPresentation | A framework to define display of tangents |
| CDsgPrs_XYZAxisPresentation | A framework for displaying the axes of an XYZ trihedron |
| CDsgPrs_XYZPlanePresentation | A framework for displaying the planes of an XYZ trihedron |
| CElCLib | Provides functions for basic geometric computations on elementary curves such as conics and lines in 2D and 3D space. This includes: |
| CElSLib | Provides functions for basic geometric computation on elementary surfaces. This includes: |
| CExpr | This package describes the data structure of any expression, relation or function used in mathematics. It also describes the assignment of variables. Standard mathematical functions are implemented such as trigonometrics, hyperbolics, and log functions |
| CExpr_Absolute | |
| CExpr_ArcCosine | |
| CExpr_ArcSine | |
| CExpr_ArcTangent | |
| CExpr_ArgCosh | |
| CExpr_ArgSinh | |
| CExpr_ArgTanh | |
| CExpr_BinaryExpression | Defines all binary expressions. The order of the two operands is significant |
| CExpr_BinaryFunction | Defines the use of a binary function in an expression with given arguments |
| CExpr_Cosh | |
| CExpr_Cosine | |
| CExpr_Difference | |
| CExpr_Different | |
| CExpr_Division | |
| CExpr_Equal | |
| CExpr_Exponential | |
| CExpr_Exponentiate | |
| CExpr_FunctionDerivative | |
| CExpr_GeneralExpression | Defines the general purposes of any expression |
| CExpr_GeneralFunction | Defines the general purposes of any function |
| CExpr_GeneralRelation | Defines the general purposes of any relation between expressions |
| CExpr_GreaterThan | |
| CExpr_GreaterThanOrEqual | |
| CExpr_LessThan | |
| CExpr_LessThanOrEqual | |
| CExpr_LogOf10 | |
| CExpr_LogOfe | |
| CExpr_NamedConstant | Describes any numeric constant known by a special name (as PI, e,...) |
| CExpr_NamedExpression | Describe an expression used by its name (as constants or variables). A single reference is made to a NamedExpression in every Expression (i.e. a NamedExpression is shared) |
| CExpr_NamedFunction | |
| CExpr_NamedUnknown | This class describes any variable of an expression. Assignment is treated directly in this class |
| CExpr_NumericValue | This class describes any reel value defined in an expression |
| CExpr_PolyExpression | |
| CExpr_PolyFunction | Defines the use of an n-ary function in an expression with given arguments |
| CExpr_Product | |
| CExpr_RelationIterator | Iterates on every basic relation contained in a GeneralRelation |
| CExpr_RUIterator | Iterates on NamedUnknowns in a GeneralRelation |
| CExpr_Sign | |
| CExpr_Sine | |
| CExpr_SingleRelation | |
| CExpr_Sinh | |
| CExpr_Square | |
| CExpr_SquareRoot | |
| CExpr_Sum | |
| CExpr_SystemRelation | |
| CExpr_Tangent | |
| CExpr_Tanh | |
| CExpr_UnaryExpression | |
| CExpr_UnaryFunction | Defines the use of an unary function in an expression with a given argument |
| CExpr_UnaryMinus | |
| CExpr_UnknownIterator | Describes an iterator on NamedUnknowns contained in any GeneralExpression |
| CExprIntrp | Describes an interpreter for GeneralExpressions, GeneralFunctions, and GeneralRelations defined in package Expr |
| CExprIntrp_Analysis | |
| CExprIntrp_Generator | Implements general services for interpretation of expressions |
| CExprIntrp_GenExp | This class permits, from a string, to create any kind of expression of package Expr by using built-in functions such as Sin,Cos, etc, and by creating variables |
| CExprIntrp_GenFct | Implements an interpreter for defining functions. All its functionalities can be found in class GenExp |
| CExprIntrp_GenRel | Implements an interpreter for equations or system of equations made of expressions of package Expr |
| CExtrema_Curve2dTool | |
| CExtrema_CurveTool | |
| CExtrema_ExtCC | It calculates all the distance between two curves. These distances can be maximum or minimum |
| CExtrema_ExtCC2d | It calculates all the distance between two curves. These distances can be maximum or minimum |
| CExtrema_ExtCS | It calculates all the extremum distances between a curve and a surface. These distances can be minimum or maximum |
| CExtrema_ExtElC | It calculates all the distance between two elementary curves. These distances can be maximum or minimum |
| CExtrema_ExtElC2d | It calculates all the distance between two elementary curves. These distances can be maximum or minimum |
| CExtrema_ExtElCS | It calculates all the distances between a curve and a surface. These distances can be maximum or minimum |
| CExtrema_ExtElSS | It calculates all the distances between 2 elementary surfaces. These distances can be maximum or minimum |
| CExtrema_ExtPElC | It calculates all the distances between a point and an elementary curve. These distances can be minimum or maximum |
| CExtrema_ExtPElC2d | It calculates all the distances between a point and an elementary curve. These distances can be minimum or maximum |
| CExtrema_ExtPElS | It calculates all the extremum distances between a point and a surface. These distances can be minimum or maximum |
| CExtrema_ExtPExtS | It calculates all the extremum (minimum and maximum) distances between a point and a linear extrusion surface |
| CExtrema_ExtPRevS | It calculates all the extremum (minimum and maximum) distances between a point and a surface of revolution |
| CExtrema_ExtPS | It calculates all the extremum distances between a point and a surface. These distances can be minimum or maximum |
| CExtrema_ExtSS | It calculates all the extremum distances between two surfaces. These distances can be minimum or maximum |
| CExtrema_FuncExtCS | Function to find extrema of the distance between a curve and a surface |
| CExtrema_FuncExtSS | Function to find extrema of the distance between two surfaces |
| CExtrema_FuncPSDist | Functional for search of extremum of the square Euclidean distance between point P and surface S, starting from approximate solution (u0, v0) |
| CExtrema_FuncPSNorm | Functional for search of extremum of the distance between point P and surface S, starting from approximate solution (u0, v0) |
| CExtrema_GCurveLocator | Template class for locating the closest point on a curve to a given point. Among a set of sampled points on the curve, finds the one closest to the target |
| CExtrema_GenExtCS | It calculates all the extremum distances between acurve and a surface. These distances can be minimum or maximum |
| CExtrema_GenExtPS | It calculates all the extremum distances between a point and a surface. These distances can be minimum or maximum |
| CExtrema_GenExtSS | It calculates all the extremum distances between two surfaces. These distances can be minimum or maximum |
| CExtrema_GenLocateExtCC | Template class for locating local extremum of distance between two curves. Searches for a pair of parameter values (U,V) such that dist(C1(u),C2(v)) passes through an extremum, and (U,V) is the solution closest to (U0,V0) |
| CExtrema_GenLocateExtCS | With two close points it calculates the distance between two surfaces. This distance can be a minimum or a maximum |
| CExtrema_GenLocateExtPC | Template class for local extremum search between a point and a curve. Searches for a local extremum of distance between a point and a curve near an initial parameter value |
| CExtrema_GenLocateExtPS | With a close point, it calculates the distance between a point and a surface. Criteria type is defined in "Perform" method |
| CExtrema_GenLocateExtSS | With two close points it calculates the distance between two surfaces. This distance can be a minimum or a maximum |
| CExtrema_GFuncExtCC | Template class for function used to find extremal distance between two curves. This class inherits from math_FunctionSetWithDerivatives and is used by the algorithm math_FunctionSetRoot |
| CExtrema_GFuncExtPC | Template class for computing extremal distance function between a point and a curve. Searches for a parameter value u such that dist(P, C(u)) passes through an extremum. Inherits from math_FunctionWithDerivative and is used by math_FunctionRoot and math_FunctionRoots algorithms |
| CExtrema_GGenExtCC | Template class for computing extremal distances between two curves. The function F(u,v)=distance(C1(u),C2(v)) has an extremum when gradient(f)=0. The algorithm uses Evtushenko's global optimization solver |
| CExtrema_GGenExtPC | Generic class for finding extremal distances between a point and a curve |
| CExtrema_GGExtPC | Generic class for computing extremal distances between a point and a curve |
| CExtrema_GlobOptFuncCCC0 | This class implements function which calculate Eucluidean distance between point on curve and point on other curve in case of C1 and C2 continuity is C0 |
| CExtrema_GlobOptFuncCCC1 | This class implements function which calculate Eucluidean distance between point on curve and point on other curve in case of C1 and C2 continuity is C1 |
| CExtrema_GlobOptFuncCCC2 | This class implements function which calculate Eucluidean distance between point on curve and point on other curve in case of C1 and C2 continuity is C2 |
| CExtrema_GlobOptFuncConicS | This class implements function which calculate square Eucluidean distance between point on surface and nearest point on Conic |
| CExtrema_GlobOptFuncCQuadric | This class implements function which calculate square Eucluidean distance between point on surface and nearest point on Conic |
| CExtrema_GlobOptFuncCS | This class implements function which calculate square Eucluidean distance between point on curve and point on surface in case of continuity is C2 |
| CExtrema_GLocateExtPC | Template class for locating extremum of distance between a point and a curve. Calculates the distance with a close point. The close point is defined by the parameter value U0. The function F(u)=distance(P,C(u)) has an extremum when g(u)=dF/du=0. The algorithm searches a zero near the close point |
| CExtrema_LocateExtCC | It calculates the distance between two curves with a close point; these distances can be maximum or minimum |
| CExtrema_LocateExtCC2d | It calculates the distance between two curves with a close point; these distances can be maximum or minimum |
| CExtrema_POnCurv | Definition of a point on curve |
| CExtrema_POnCurv2d | Definition of a point on 2D curve |
| CExtrema_POnSurf | Definition of a point on surface |
| CExtrema_POnSurfParams | Data container for point on surface parameters. These parameters are required to compute an initial approximation for extrema computation |
| CExtremaPC_BezierCurve | Point-BezierCurve extrema computation using grid-based approach |
| CExtremaPC_BSplineCurve | Point-BSplineCurve extrema computation using grid-based approach |
| CExtremaPC_Circle | Point-Circle extrema computation |
| CExtremaPC_Curve | Main aggregator for Point-Curve extrema computation |
| CExtremaPC_DistanceFunction | Distance function for point-curve extrema computation |
| CExtremaPC_Ellipse | Point-Ellipse extrema computation |
| CExtremaPC_GridEvaluator | Grid-based point-curve extrema computation class |
| CGridPoint | Cached grid point with pre-computed data |
| CCandidate | Candidate interval for Newton refinement |
| CExtremaPC_Hyperbola | Point-Hyperbola extrema computation |
| CExtremaPC_Line | Point-Line extrema computation |
| CExtremaPC_OffsetCurve | Point-OffsetCurve extrema computation using grid-based approach |
| CExtremaPC_OtherCurve | Point-Curve extrema computation for general curves using grid-based approach |
| CExtremaPC_Parabola | Point-Parabola extrema computation |
| CFairCurve_Batten | Constructs curves with a constant or linearly increasing section to be used in the design of wooden or plastic battens. These curves are two-dimensional, and simulate physical splines or battens |
| CFairCurve_BattenLaw | This class compute the Heigth of an batten |
| CFairCurve_DistributionOfEnergy | Abstract class to use the Energy of an FairCurve |
| CFairCurve_DistributionOfJerk | Compute the "Jerk" distribution |
| CFairCurve_DistributionOfSagging | Compute the Sagging Distribution |
| CFairCurve_DistributionOfTension | Compute the Tension Distribution |
| CFairCurve_Energy | Necessary methodes to compute the energy of an FairCurve |
| CFairCurve_EnergyOfBatten | Energy Criterium to minimize in Batten |
| CFairCurve_EnergyOfMVC | Energy Criterium to minimize in MinimalVariationCurve |
| CFairCurve_MinimalVariation | Computes a 2D curve using an algorithm which minimizes tension, sagging, and jerk energy. As in FairCurve_Batten, two reference points are used. Unlike that class, FairCurve_MinimalVariation requires curvature settings at the first and second reference points. These are defined by the rays of curvature desired at each point |
| CFairCurve_Newton | Algorithm of Optimization used to make "FairCurve" |
| CFEmTool_Assembly | Assemble and solve system from (one dimensional) Finite Elements |
| CFEmTool_Curve | Curve defined by Polynomial Elements |
| CFEmTool_ElementaryCriterion | Defined J Criteria to used in minimisation |
| CFEmTool_ElementsOfRefMatrix | This class describes the functions needed for calculating matrix elements of RefMatrix for linear criteriums (Tension, Flexion and Jerk) by Gauss integration. Each function from set gives value Pi(u)'*Pj(u)' or Pi(u)''*Pj(u)'' or Pi(u)'''*Pj(u)''' for each i and j, where Pi(u) is i-th basis function of expansion and (') means derivative |
| CFEmTool_LinearFlexion | Criterium of LinearFlexion To Hermit-Jacobi elements |
| CFEmTool_LinearJerk | Criterion of LinearJerk To Hermit-Jacobi elements |
| CFEmTool_LinearTension | Criterium of LinearTension To Hermit-Jacobi elements |
| CFEmTool_ProfileMatrix | Symmetric Sparse ProfileMatrix useful for 1D Finite Element methods |
| CFEmTool_SparseMatrix | Sparse Matrix definition |
| CFilletPoint | Private class. Corresponds to the point on the first curve, computed fillet function and derivative on it |
| CFilletSurf_Builder | API giving the following geometric information about fillets list of corresponding NUBS surfaces for each surface: the 2 support faces on each face: the 3d curve and the corresponding 2d curve the 2d curves on the fillet status of start and end section of the fillet first and last parameter on edge of the fillet |
| CFilletSurf_InternalBuilder | This class is private. It is used by the class Builder from FilletSurf. It computes geometric information about fillets |
| CFlexLexer | |
| CFont_FontMgr | Collects and provides information about available fonts in system |
| CFont_FTFont | Wrapper over FreeType font. Notice that this class uses internal buffers for loaded glyphs and it is absolutely UNSAFE to load/read glyph from concurrent threads! |
| CFont_FTFontParams | Font initialization parameters |
| CFont_FTLibrary | Wrapper over FT_Library. Provides access to FreeType library |
| CFont_Rect | Auxiliary POD structure - 2D rectangle definition |
| CFont_SystemFont | This class stores information about the font, which is merely a file path and cached metadata about the font |
| CFont_TextFormatter | This class is intended to prepare formatted text by using: |
| CIterator | Iterator through formatted symbols. It's possible to filter returned symbols to have only significant ones |
| CFSD_Base64 | Tool for encoding/decoding base64 stream |
| CFSD_BinaryFile | |
| CFSD_CmpFile | |
| CFSD_File | A general driver which defines as a file, the physical container for data to be stored or retrieved |
| CFSD_FileHeader | |
| CGC_MakeArcOfCircle | Implements construction algorithms for an arc of circle in 3D space. The result is a Geom_TrimmedCurve curve. A MakeArcOfCircle object provides a framework for: |
| CGC_MakeArcOfCircle2d | This class implements construction algorithms for arcs of circles in the plane. The result is a Geom2d_TrimmedCurve. A GC_MakeArcOfCircle2d object provides a framework for: |
| CGC_MakeArcOfEllipse | Implements construction algorithms for ellipse arcs in 3D space. The result is a Geom_TrimmedCurve. A MakeArcOfEllipse object provides a framework for: |
| CGC_MakeArcOfEllipse2d | This class implements construction algorithms for arcs of ellipses in the plane. The result is a Geom2d_TrimmedCurve. A GC_MakeArcOfEllipse2d object provides a framework for: |
| CGC_MakeArcOfHyperbola | Implements construction algorithms for hyperbola arcs in 3D space. The result is a Geom_TrimmedCurve. A MakeArcOfHyperbola object provides a framework for: |
| CGC_MakeArcOfHyperbola2d | This class implements construction algorithms for arcs of hyperbolas in the plane. The result is a Geom2d_TrimmedCurve. A GC_MakeArcOfHyperbola2d object provides a framework for: |
| CGC_MakeArcOfParabola | Implements construction algorithms for parabola arcs in 3D space. The result is a Geom_TrimmedCurve. A MakeArcOfParabola object provides a framework for: |
| CGC_MakeArcOfParabola2d | This class implements construction algorithms for arcs of parabolas in the plane. The result is a Geom2d_TrimmedCurve. A GC_MakeArcOfParabola2d object provides a framework for: |
| CGC_MakeCircle | Implements construction algorithms for circles in 3D space |
| CGC_MakeCircle2d | This class implements construction algorithms for circles in the plane. The result is a Geom2d_Circle. A GC_MakeCircle2d object provides a framework for: |
| CGC_MakeConicalSurface | Implements construction algorithms for conical surfaces. Supported constructions include: |
| CGC_MakeCylindricalSurface | Implements construction algorithms for cylindrical surfaces. Supported constructions include: |
| CGC_MakeEllipse | Implements construction algorithms for ellipses in 3D space. The result is a Geom_Ellipse. A MakeEllipse object provides a framework for: |
| CGC_MakeEllipse2d | This class implements construction algorithms for ellipses in the plane. The result is a Geom2d_Ellipse. A GC_MakeEllipse2d object provides a framework for: |
| CGC_MakeHyperbola | Implements construction algorithms for hyperbolas in 3D space. The result is a Geom_Hyperbola. A MakeHyperbola object provides a framework for: |
| CGC_MakeHyperbola2d | This class implements construction algorithms for hyperbolas in the plane. The result is a Geom2d_Hyperbola (main branch). A GC_MakeHyperbola2d object provides a framework for: |
| CGC_MakeLine | This class implements the following algorithms used to create a Line from Geom |
| CGC_MakeLine2d | This class implements construction algorithms for lines in the plane. The result is a Geom2d_Line. A GC_MakeLine2d object provides a framework for: |
| CGC_MakeMirror | This class implements elementary construction algorithms for a symmetrical transformation in 3D space about a point, axis or plane. The result is a Geom_Transformation transformation. A MakeMirror object provides a framework for: |
| CGC_MakeMirror2d | This class implements elementary construction algorithms for symmetric transformations in 2D space about a point, axis, or line. The result is a Geom2d_Transformation. A GC_MakeMirror2d object provides a framework for: |
| CGC_MakeParabola2d | This class implements construction algorithms for parabolas in the plane. The result is a Geom2d_Parabola. A GC_MakeParabola2d object provides a framework for: |
| CGC_MakePlane | Implements construction algorithms for planes in 3D space. Supported constructions include: |
| CGC_MakeRotation | This class implements elementary construction algorithms for a rotation in 3D space. The result is a Geom_Transformation transformation. A MakeRotation object provides a framework for: |
| CGC_MakeRotation2d | This class implements elementary construction algorithms for rotations in 2D space. The result is a Geom2d_Transformation. A GC_MakeRotation2d object provides a framework for: |
| CGC_MakeScale | Implements construction of a scaling transformation in 3D space. The result is a Geom_Transformation centered at Point with scale factor Scale. A MakeScale object provides a framework for: |
| CGC_MakeScale2d | This class implements elementary construction algorithms for scaling transformations in 2D space. The result is a Geom2d_Transformation. A GC_MakeScale2d object provides a framework for: |
| CGC_MakeSegment | Implements construction algorithms for line segments in 3D space. The result is a Geom_TrimmedCurve. A GC_MakeSegment object provides a framework for: |
| CGC_MakeSegment2d | This class implements construction algorithms for line segments in the plane. The result is a Geom2d_TrimmedCurve. A GC_MakeSegment2d object provides a framework for: |
| CGC_MakeTranslation | This class implements elementary construction algorithms for a translation in 3D space. The result is a Geom_Transformation transformation. A MakeTranslation object provides a framework for: |
| CGC_MakeTranslation2d | This class implements elementary construction algorithms for translations in 2D space. The result is a Geom2d_Transformation. A GC_MakeTranslation2d object provides a framework for: |
| CGC_MakeTrimmedCone | Implements construction algorithms for trimmed cones. The result is a Geom_RectangularTrimmedSurface. A MakeTrimmedCone provides a framework for: |
| CGC_MakeTrimmedCylinder | Implements construction algorithms for trimmed cylinders. The result is a Geom_RectangularTrimmedSurface. A MakeTrimmedCylinder provides a framework for: |
| CGC_Root | Provides common status services for GC builders reporting construction errors |
| CGccAna_Circ2d2TanOn | Describes functions for building a 2D circle |
| CGccAna_Circ2d2TanRad | This class implements the algorithms used to create 2d circles tangent to 2 points/lines/circles and with a given radius. For each construction methods arguments are: |
| CGccAna_Circ2d3Tan | This class implements the algorithms used to create 2d circles tangent to 3 points/lines/circles. The arguments of all construction methods are : |
| CGccAna_Circ2dBisec | This class describes functions for building bisecting curves between two 2D circles. A bisecting curve between two circles is a curve such that each of its points is at the same distance from the two circles. It can be an ellipse, hyperbola, circle or line, depending on the relative position of the two circles. The algorithm computes all the elementary curves which are solutions. There is no solution if the two circles are coincident. A Circ2dBisec object provides a framework for: |
| CGccAna_Circ2dTanCen | This class implements the algorithms used to create 2d circles tangent to an entity and centered on a point. The arguments of all construction methods are : |
| CGccAna_Circ2dTanOnRad | This class implements the algorithms used to create a 2d circle tangent to a 2d entity, centered on a curv and with a given radius. The arguments of all construction methods are : |
| CGccAna_CircLin2dBisec | Describes functions for building bisecting curves between a 2D line and a 2D circle. A bisecting curve between a circle and a line is a curve such that each of its points is at the same distance from the circle and the line. It can be a parabola or a line, depending of the relative position of the line and the circle. The algorithm computes all the elementary curves which are solutions. A CircLin2dBisec object provides a framework for: |
| CGccAna_CircPnt2dBisec | Describes functions for building a bisecting curve between a 2D circle and a point. A bisecting curve between a circle and a point is such a curve that each of its points is at the same distance from the circle and the point. It can be an ellipse, hyperbola, circle or line, depending on the relative position of the point and the circle. The algorithm computes all the elementary curves which are solutions. A CircPnt2dBisec object provides a framework for: |
| CGccAna_Lin2d2Tan | This class implements the algorithms used to create 2d lines tangent to 2 other elements which can be circles or points. Describes functions for building a 2D line: |
| CGccAna_Lin2dBisec | Describes functions for building bisecting lines between two 2D lines. A bisecting line between two lines is such that each of its points is at the same distance from the two lines. If the two lines are secant, there are two orthogonal bisecting lines which share the angles made by the two straight lines in two equal parts. If D1 and D2 are the unit vectors of the two straight lines, those of the two bisecting lines are collinear with the following vectors: |
| CGccAna_Lin2dTanObl | This class implements the algorithms used to create 2d line tangent to a circle or a point and making an angle with a line. The angle is in radians. The origin of the solution is the tangency point with the first argument. Its direction is making an angle Angle with the second argument |
| CGccAna_Lin2dTanPar | This class implements the algorithms used to create 2d line tangent to a circle or a point and parallel to another line. The solution has the same orientation as the second argument. Describes functions for building a 2D line parallel to a line and: |
| CGccAna_Lin2dTanPer | This class implements the algorithms used to create 2d lines tangent to a circle or a point and perpendicular to a line or a circle. Describes functions for building a 2D line perpendicular to a line and: |
| CGccAna_LinPnt2dBisec | Describes functions for building bisecting curves between a 2D line and a point. A bisecting curve between a line and a point is such a curve that each of its points is at the same distance from the circle and the point. It can be a parabola or a line, depending on the relative position of the line and the circle. There is always one unique solution. A LinPnt2dBisec object provides a framework for: |
| CGccAna_Pnt2dBisec | This class implements the algorithms used to create the bisecting line between two 2d points Describes functions for building a bisecting line between two 2D points. The bisecting line between two points is the bisector of the segment which joins the two points, if these are not coincident. The algorithm does not find a solution if the two points are coincident. A Pnt2dBisec object provides a framework for: |
| CGccEnt | This package provides an implementation of the qualified entities useful to create 2d entities with geometric constraints. The qualifier explains which subfamily of solutions we want to obtain. It uses the following law: the matter/the interior side is at the left of the line, if we go from the beginning to the end. The qualifiers are: Enclosing : the solution(s) must enclose the argument. Enclosed : the solution(s) must be enclosed in the argument. Outside : both the solution(s) and the argument must be outside to each other. Unqualified : the position is undefined, so give all the solutions. The use of a qualifier is always required if such subfamilies exist. For example, it is not used for a point. Note: the interior of a curve is defined as the left-hand side of the curve in relation to its orientation |
| CGccEnt_QualifiedCirc | Creates a qualified 2d Circle. A qualified 2D circle is a circle (gp_Circ2d circle) with a qualifier which specifies whether the solution of a construction algorithm using the qualified circle (as an argument): |
| CGccEnt_QualifiedLin | Describes a qualified 2D line. A qualified 2D line is a line (gp_Lin2d line) with a qualifier which specifies whether the solution of a construction algorithm using the qualified line (as an argument): |
| CGccInt_BCirc | Describes a circle as a bisecting curve between two 2D geometric objects (such as circles or points) |
| CGccInt_BElips | Describes an ellipse as a bisecting curve between two 2D geometric objects (such as circles or points) |
| CGccInt_BHyper | Describes a hyperbola as a bisecting curve between two 2D geometric objects (such as circles or points) |
| CGccInt_Bisec | The deferred class GccInt_Bisec is the root class for elementary bisecting loci between two simple geometric objects (i.e. circles, lines or points). Bisecting loci between two geometric objects are such that each of their points is at the same distance from the two geometric objects. It is typically a curve, such as a line, circle or conic. Generally there is more than one elementary object which is the solution to a bisecting loci problem: each solution is described with one elementary bisecting locus. For example, the bisectors of two secant straight lines are two perpendicular straight lines. The GccInt package provides concrete implementations of the following elementary derived bisecting loci: |
| CGccInt_BLine | Describes a line as a bisecting curve between two 2D geometric objects (such as lines, circles or points) |
| CGccInt_BParab | Describes a parabola as a bisecting curve between two 2D geometric objects (such as lines, circles or points) |
| CGccInt_BPoint | Describes a point as a bisecting object between two 2D geometric objects |
| Cgce_MakeCirc | This class implements construction algorithms for gp_Circ. Supported constructions include: |
| Cgce_MakeCirc2d | This class implements construction algorithms for gp_Circ2d. Supported constructions include: |
| Cgce_MakeCone | This class implements construction algorithms for gp_Cone. Supported constructions include: |
| Cgce_MakeCylinder | This class implements construction algorithms for gp_Cylinder. Supported constructions include: |
| Cgce_MakeDir | This class implements construction algorithms for gp_Dir. Supported constructions include: |
| Cgce_MakeDir2d | This class implements construction algorithms for gp_Dir2d. Supported constructions include: |
| Cgce_MakeElips | This class implements construction algorithms for gp_Elips. Supported constructions include: |
| Cgce_MakeElips2d | This class implements construction algorithms for gp_Elips2d. Supported constructions include: |
| Cgce_MakeHypr | This class implements construction algorithms for gp_Hypr. Supported constructions include: |
| Cgce_MakeHypr2d | This class implements construction algorithms for gp_Hypr2d. Supported constructions include: |
| Cgce_MakeLin | This class implements construction algorithms for gp_Lin. Supported constructions include: |
| Cgce_MakeLin2d | This class implements construction algorithms for gp_Lin2d. Supported constructions include: |
| Cgce_MakeMirror | This class implements elementary construction algorithms for a symmetrical transformation in 3D space about a point, axis or plane. The result is a gp_Trsf transformation. A MakeMirror object provides a framework for: |
| Cgce_MakeMirror2d | This class implements elementary construction algorithms for a symmetrical transformation in 2D space about a point or axis. The result is a gp_Trsf2d transformation. A MakeMirror2d object provides a framework for: |
| Cgce_MakeParab | Implements construction algorithms for gp_Parab. The parabola is infinite in the parameter range ]-infinite, +infinite[. The vertex is the Location point of the local coordinate system |
| Cgce_MakeParab2d | Implements construction algorithms for gp_Parab2d. The parabola is infinite and represented in a local 2D coordinate system. The XAxis is the symmetry axis directed from vertex to focus, and the YAxis is parallel to the directrix. The equation in local coordinates is: Y**2 = (2*P) * X, where P is the distance between focus and directrix. The focal length F = P / 2 is the distance from vertex to focus |
| Cgce_MakePln | This class implements construction algorithms for gp_Pln. Supported constructions include: |
| Cgce_MakeRotation | This class implements elementary construction algorithms for a rotation in 3D space. The result is a gp_Trsf transformation. A MakeRotation object provides a framework for: |
| Cgce_MakeRotation2d | Implements an elementary construction algorithm for a rotation in 2D space. The result is a gp_Trsf2d transformation. A MakeRotation2d object provides a framework for: |
| Cgce_MakeScale | Implements an elementary construction algorithm for a scaling transformation in 3D space. The result is a gp_Trsf transformation. A MakeScale object provides a framework for: |
| Cgce_MakeScale2d | This class implements an elementary construction algorithm for a scaling transformation in 2D space. The result is a gp_Trsf2d transformation. A MakeScale2d object provides a framework for: |
| Cgce_MakeTranslation | This class implements elementary construction algorithms for a translation in 3D space. The result is a gp_Trsf transformation. A MakeTranslation object provides a framework for: |
| Cgce_MakeTranslation2d | This class implements elementary construction algorithms for a translation in 2D space. The result is a gp_Trsf2d transformation. A MakeTranslation2d object provides a framework for: |
| Cgce_Root | Provides common status services for all gce construction classes |
| CGCPnts_AbscissaPoint | Provides an algorithm to compute a point on a curve situated at a given distance from another point on the curve, the distance being measured along the curve (curvilinear abscissa on the curve). This algorithm is also used to compute the length of a curve. An AbscissaPoint object provides a framework for: |
| CGCPnts_DistFunction | Class to define function, which calculates square distance between point on curve C(u), U1 <= u <= U2 and line passing through points C(U1) and C(U2) This function is used in any minimization algorithm to define maximal deviation between curve and line, which required one variable function without derivative (for ex. math_BrentMinimum) |
| CGCPnts_DistFunction2d | Class to define function, which calculates square distance between point on curve C(u), U1 <= u <= U2 and line passing through points C(U1) and C(U2) This function is used in any minimisation algorithm to define maximal deviation between curve and line, which required one variable function without derivative (for ex. math_BrentMinimum) |
| CGCPnts_DistFunction2dMV | The same as class GCPnts_DistFunction2d, but it can be used in minimization algorithms that requires multi variable function |
| CGCPnts_DistFunctionMV | The same as class GCPnts_DistFunction, but it can be used in minimization algorithms that requires multi variable function |
| CGCPnts_QuasiUniformAbscissa | This class provides an algorithm to compute a uniform abscissa distribution of points on a curve, i.e. a sequence of equidistant points. The distance between two consecutive points is measured along the curve |
| CGCPnts_QuasiUniformDeflection | This class computes a distribution of points on a curve. The points may respect the deflection. The algorithm is not based on the classical prediction (with second derivative of curve), but either on the evaluation of the distance between the mid point and the point of mid parameter of the two points, or the distance between the mid point and the point at parameter 0.5 on the cubic interpolation of the two points and their tangents |
| CGCPnts_TangentialDeflection | Computes a set of points on a curve from package Adaptor3d such as between two successive points P1(u1)and P2(u2) : |
| CGCPnts_TCurveTypes | Auxiliary tool to resolve 2D/3D curve classes |
| CGCPnts_TCurveTypes< Adaptor2d_Curve2d > | Auxiliary tool to resolve 2D curve classes |
| CGCPnts_TCurveTypes< Adaptor3d_Curve > | Auxiliary tool to resolve 3D curve classes |
| CGCPnts_UniformAbscissa | This class allows to compute a uniform distribution of points on a curve (i.e. the points will all be equally distant) |
| CGCPnts_UniformDeflection | Provides an algorithm to compute a distribution of points on a 'C2' continuous curve. The algorithm respects a criterion of maximum deflection between the curve and the polygon that results from the computed points. Note: This algorithm is relatively time consuming. A GCPnts_QuasiUniformDeflection algorithm is quicker; it can also work with non-'C2' continuous curves, but it generates more points in the distribution |
| CGeom2d_AxisPlacement | Describes an axis in 2D space. An axis is defined by: |
| CGeom2d_BezierCurve | Describes a rational or non-rational Bezier curve |
| CGeom2d_BoundedCurve | The abstract class BoundedCurve describes the common behavior of bounded curves in 2D space. A bounded curve is limited by two finite values of the parameter, termed respectively "first parameter" and "last parameter". The "first parameter" gives the "start
point" of the bounded curve, and the "last parameter" gives the "end point" of the bounded curve. The length of a bounded curve is finite. The Geom2d package provides three concrete classes of bounded curves: |
| CGeom2d_BSplineCurve | Describes a BSpline curve. A BSpline curve can be: |
| CGeom2d_CartesianPoint | Describes a point in 2D space. A Geom2d_CartesianPoint is defined by a gp_Pnt2d point, with its two Cartesian coordinates X and Y |
| CGeom2d_Circle | Describes a circle in the plane (2D space). A circle is defined by its radius and, as with any conic curve, is positioned in the plane with a coordinate system (gp_Ax22d object) where the origin is the center of the circle. The coordinate system is the local coordinate system of the circle. The orientation (direct or indirect) of the local coordinate system gives an explicit orientation to the circle, determining the direction in which the parameter increases along the circle. The Geom2d_Circle circle is parameterized by an angle: P(U) = O + R*std::cos(U)*XDir + R*Sin(U)*YDir where: |
| CGeom2d_Conic | The abstract class Conic describes the common behavior of conic curves in 2D space and, in particular, their general characteristics. The Geom2d package provides four specific classes of conics: Geom2d_Circle, Geom2d_Ellipse, Geom2d_Hyperbola and Geom2d_Parabola. A conic is positioned in the plane with a coordinate system (gp_Ax22d object), where the origin is the center of the conic (or the apex in case of a parabola). This coordinate system is the local coordinate system of the conic. It gives the conic an explicit orientation, determining the direction in which the parameter increases along the conic. The "X Axis" of the local coordinate system also defines the origin of the parameter of the conic |
| CGeom2d_Curve | The abstract class Curve describes the common behavior of curves in 2D space. The Geom2d package provides numerous concrete classes of derived curves, including lines, circles, conics, Bezier or BSpline curves, etc. The main characteristic of these curves is that they are parameterized. The Geom2d_Curve class shows: |
| CResD1 | Result of D1 evaluation: point and first derivative |
| CResD2 | Result of D2 evaluation: point and first two derivatives |
| CResD3 | Result of D3 evaluation: point and first three derivatives |
| CGeom2d_Direction | The class Direction specifies a vector that is never null. It is a unit vector |
| CGeom2d_Ellipse | Describes an ellipse in the plane (2D space). An ellipse is defined by its major and minor radii and, as with any conic curve, is positioned in the plane with a coordinate system (gp_Ax22d object) where: |
| CGeom2d_Geometry | The general abstract class Geometry in 2D space describes the common behaviour of all the geometric entities |
| CGeom2d_Hyperbola | Describes a branch of a hyperbola in the plane (2D space). A hyperbola is defined by its major and minor radii and, as with any conic curve, is positioned in the plane with a coordinate system (gp_Ax22d object) where: |
| CGeom2d_Line | Describes an infinite line in the plane (2D space). A line is defined and positioned in the plane with an axis (gp_Ax2d object) which gives it an origin and a unit vector. The Geom2d_Line line is parameterized as follows: P (U) = O + U*Dir where: |
| CGeom2d_OffsetCurve | This class implements the basis services for the creation, edition, modification and evaluation of planar offset curve. The offset curve is obtained by offsetting by distance along the normal to a basis curve defined in 2D space. The offset curve in this package can be a self intersecting curve even if the basis curve does not self-intersect. The self intersecting portions are not deleted at the construction time. An offset curve is a curve at constant distance (Offset) from a basis curve and the offset curve takes its parametrization from the basis curve. The Offset curve is in the direction of the normal to the basis curve N. The distance offset may be positive or negative to indicate the preferred side of the curve : . distance offset >0 => the curve is in the direction of N . distance offset >0 => the curve is in the direction of - N On the Offset curve : Value(u) = BasisCurve.Value(U) + (Offset * (T ^ Z)) / ||T ^ Z|| where T is the tangent vector to the basis curve and Z the direction of the normal vector to the plane of the curve, N = T ^ Z defines the offset direction and should not have null length |
| CGeom2d_Parabola | Describes a parabola in the plane (2D space). A parabola is defined by its focal length (i.e. the distance between its focus and its apex) and is positioned in the plane with a coordinate system (gp_Ax22d object) where: |
| CGeom2d_Point | The abstract class Point describes the common behavior of geometric points in 2D space. The Geom2d package also provides the concrete class Geom2d_CartesianPoint |
| CGeom2d_Transformation | The class Transformation allows to create Translation, Rotation, Symmetry, Scaling and complex transformations obtained by combination of the previous elementary transformations. The Transformation class can also be used to construct complex transformations by combining these elementary transformations. However, these transformations can never change the type of an object. For example, the projection transformation can change a circle into an ellipse, and therefore change the real type of the object. Such a transformation is forbidden in this environment and cannot be a Geom2d_Transformation. The transformation can be represented as follows: |
| CGeom2d_TrimmedCurve | Defines a portion of a curve limited by two values of parameters inside the parametric domain of the curve. The trimmed curve is defined by: |
| CGeom2d_Vector | The abstract class Vector describes the common behavior of vectors in 2D space. The Geom2d package provides two concrete classes of vectors: Geom2d_Direction (unit vector) and Geom2d_VectorWithMagnitude |
| CGeom2d_VectorWithMagnitude | Defines a vector with magnitude. A vector with magnitude can have a zero length |
| CGeom2dAdaptor | This package contains the geometric definition of 2d curves compatible with the Adaptor package templates |
| CGeom2dAdaptor_Curve | An interface between the services provided by any curve from the package Geom2d and those required of the curve by algorithms which use it |
| COffsetData | Internal structure for 2D offset curve evaluation data |
| CBezierData | Internal structure for Bezier curve evaluation data |
| CBSplineData | Internal structure for BSpline curve evaluation data |
| CGeom2dAPI_ExtremaCurveCurve | Describes functions for computing all the extrema between two 2D curves. An ExtremaCurveCurve algorithm minimizes or maximizes the distance between a point on the first curve and a point on the second curve. Thus, it computes the start point and end point of perpendiculars common to the two curves (an intersection point is not an extremum except where the two curves are tangential at this point). Solutions consist of pairs of points, and an extremum is considered to be a segment joining the two points of a solution. An ExtremaCurveCurve object provides a framework for: |
| CGeom2dAPI_InterCurveCurve | This class implements methods for computing |
| CGeom2dAPI_Interpolate | This class is used to interpolate a BsplineCurve passing through an array of points, with a C2 Continuity if tangency is not requested at the point. If tangency is requested at the point the continuity will be C1. If Perodicity is requested the curve will be closed and the junction will be the first point given. The curve will than be only C1 The curve is defined by a table of points through which it passes, and if required by a parallel table of reals which gives the value of the parameter of each point through which the resulting BSpline curve passes, and by vectors tangential to these points. An Interpolate object provides a framework for: defining the constraints of the BSpline curve, |
| CGeom2dAPI_PointsToBSpline | This class is used to approximate a BsplineCurve passing through an array of points, with a given Continuity. Describes functions for building a 2D BSpline curve which approximates a set of points. A PointsToBSpline object provides a framework for: |
| CGeom2dAPI_ProjectPointOnCurve | This class implements methods for computing all the orthogonal projections of a 2D point onto a 2D curve |
| CGeom2dConvert | This package provides an implementation of algorithms to do the conversion between equivalent geometric entities from package Geom2d. It gives the possibility : . to obtain the B-spline representation of bounded curves. . to split a B-spline curve into several B-spline curves with some constraints of continuity, . to convert a B-spline curve into several Bezier curves or surfaces. All the geometric entities used in this package are bounded. References : . Generating the Bezier Points of B-spline curves and surfaces (Wolfgang Bohm) CAGD volume 13 number 6 november 1981 . On NURBS: A Survey (Leslie Piegl) IEEE Computer Graphics and Application January 1991 . Curve and surface construction using rational B-splines (Leslie Piegl and Wayne Tiller) CAD Volume 19 number 9 november 1987 . A survey of curve and surface methods in CAGD (Wolfgang BOHM) CAGD 1 1984 |
| CGeom2dConvert_ApproxArcsSegments | Approximation of a free-form curve by a sequence of arcs+segments |
| CGeom2dConvert_ApproxCurve | A framework to convert a 2D curve to a BSpline. This is done by approximation within a given tolerance |
| CGeom2dConvert_BSplineCurveKnotSplitting | An algorithm to determine points at which a BSpline curve should be split in order to obtain arcs of the same continuity. If you require curves with a minimum continuity for your computation, it is useful to know the points between which an arc has a continuity of a given order. The continuity order is given at the construction time. For a BSpline curve, the discontinuities are localized at the knot values. Between two knot values the BSpline is infinitely and continuously differentiable. At a given knot, the continuity is equal to: Degree - Mult, where Degree is the degree of the BSpline curve and Mult is the multiplicity of the knot. It is possible to compute the arcs which correspond to this splitting using the global function SplitBSplineCurve provided by the package Geom2dConvert. A BSplineCurveKnotSplitting object provides a framework for: |
| CGeom2dConvert_BSplineCurveToBezierCurve | An algorithm to convert a BSpline curve into a series of adjacent Bezier curves. A BSplineCurveToBezierCurve object provides a framework for: |
| CGeom2dConvert_CompCurveToBSplineCurve | This algorithm converts and concat several curve in an BSplineCurve |
| CGeom2dConvert_PPoint | Class representing a point on curve, with 2D coordinate and the tangent |
| CGeom2dEval_AHTBezierCurve | 2D Algebraic-Hyperbolic-Trigonometric Bezier curve. Uses a mixed basis: {1, t, ..., t^k, sinh(alpha*t), cosh(alpha*t), sin(beta*t), cos(beta*t)}. The number of basis functions = algDegree + 1 + 2*(alpha>0) + 2*(beta>0) must equal NbPoles. Parameter range: [0, 1] |
| CGeom2dEval_ArchimedeanSpiralCurve | Describes a 2D Archimedean spiral curve. The polar equation is r = a + b*t, where a is the initial radius and b is the growth rate per radian |
| CGeom2dEval_CircleInvoluteCurve | Describes a 2D involute of a circle. Critical for gear tooth profiles |
| CGeom2dEval_LogarithmicSpiralCurve | Describes a 2D logarithmic (equiangular) spiral curve. The polar equation is r = a*exp(b*t) |
| CGeom2dEval_SineWaveCurve | Describes a 2D sine wave curve |
| CGeom2dEval_TBezierCurve | 2D Trigonometric Bezier curve. Uses a trigonometric Bernstein-like basis over the space {1, sin(alpha*t), cos(alpha*t), ..., sin(n*alpha*t), cos(n*alpha*t)} |
| CGeom2dGcc | The Geom2dGcc package describes qualified 2D curves used in the construction of constrained geometric objects by an algorithm provided by the Geom2dGcc package. A qualified 2D curve is a curve with a qualifier which specifies whether the solution of a construction algorithm using the qualified curve (as an argument): |
| CGeom2dGcc_Circ2d2TanOn | This class implements the algorithms used to create 2d circles TANgent to 2 entities and having the center ON a curve. The order of the tangency argument is always QualifiedCirc, QualifiedLin, QualifiedCurv, Pnt2d. the arguments are : |
| CGeom2dGcc_Circ2d2TanOnGeo | This class implements the algorithms used to create 2d circles TANgent to 2 entities and having the center ON a curve. The order of the tangency argument is always QualifiedCirc, QualifiedLin, QualifiedCurv, Pnt2d. the arguments are : |
| CGeom2dGcc_Circ2d2TanOnIter | This class implements the algorithms used to create 2d circles TANgent to 2 entities and having the center ON a curv. The order of the tangency argument is always QualifiedCirc, QualifiedLin, QualifiedCurv, Pnt2d. the arguments are : |
| CGeom2dGcc_Circ2d2TanRad | This class implements the algorithms used to create 2d circles tangent to one curve and a point/line/circle/curv and with a given radius. For each construction methods arguments are: |
| CGeom2dGcc_Circ2d2TanRadGeo | This class implements the algorithms used to create 2d circles tangent to one curve and a point/line/circle/curv and with a given radius. For each construction methods arguments are: |
| CGeom2dGcc_Circ2d3Tan | This class implements the algorithms used to create 2d circles tangent to 3 points/lines/circles/ curves with one curve or more. The arguments of all construction methods are : |
| CGeom2dGcc_Circ2d3TanIter | This class implements the algorithms used to create 2d circles tangent to 3 points/lines/circles/ curves with one curve or more. The arguments of all construction methods are : |
| CGeom2dGcc_Circ2dTanCen | This class implements the algorithms used to create 2d circles tangent to a curve and centered on a point. The arguments of all construction methods are : |
| CGeom2dGcc_Circ2dTanCenGeo | This class implements the algorithms used to create 2d circles tangent to a curve and centered on a point. The arguments of all construction methods are : |
| CGeom2dGcc_Circ2dTanOnRad | This class implements the algorithms used to create a 2d circle tangent to a 2d entity, centered on a 2d entity and with a given radius. More than one argument must be a curve. The arguments of all construction methods are : |
| CGeom2dGcc_Circ2dTanOnRadGeo | This class implements the algorithms used to create a 2d circle tangent to a 2d entity, centered on a 2d entity and with a given radius. More than one argument must be a curve. The arguments of all construction methods are : |
| CGeom2dGcc_CurveTool | |
| CGeom2dGcc_FunctionTanCirCu | This abstract class describes a Function of 1 Variable used to find a line tangent to a curve and a circle |
| CGeom2dGcc_FunctionTanCuCu | This abstract class describes a Function of 1 Variable used to find a line tangent to two curves |
| CGeom2dGcc_FunctionTanCuCuCu | This abstract class describes a set on N Functions of M independent variables |
| CGeom2dGcc_FunctionTanCuCuOnCu | This abstract class describes a set on N Functions of M independent variables |
| CGeom2dGcc_FunctionTanCuPnt | This abstract class describes a Function of 1 Variable used to find a line tangent to a curve and passing through a point |
| CGeom2dGcc_FunctionTanObl | This class describe a function of a single variable |
| CGeom2dGcc_Lin2d2Tan | This class implements the algorithms used to create 2d lines tangent to 2 other elements which can be circles, curves or points. More than one argument must be a curve. Describes functions for building a 2D line: |
| CGeom2dGcc_Lin2d2TanIter | This class implements the algorithms used to create 2d lines tangent to 2 other elements which can be circles, curves or points. More than one argument must be a curve |
| CGeom2dGcc_Lin2dTanObl | This class implements the algorithms used to create 2d line tangent to a curve QualifiedCurv and doing an angle Angle with a line TheLin. The angle must be in Radian. Describes functions for building a 2D line making a given angle with a line and tangential to a curve. A Lin2dTanObl object provides a framework for: |
| CGeom2dGcc_Lin2dTanOblIter | This class implements the algorithms used to create 2d line tangent to a curve QualifiedCurv and doing an angle Angle with a line TheLin. The angle must be in Radian |
| CGeom2dGcc_QCurve | Creates a qualified 2d line |
| CGeom2dGcc_QualifiedCurve | Describes functions for building a qualified 2D curve. A qualified 2D curve is a curve with a qualifier which specifies whether the solution of a construction algorithm using the qualified curve (as an argument): |
| CGeom2dGridEval_BezierCurve | Efficient batch evaluator for 2D Bezier curve grid points |
| CGeom2dGridEval_BSplineCurve | Efficient batch evaluator for 2D B-spline curve grid points |
| CGeom2dGridEval_Circle | Efficient batch evaluator for 2D circle grid points |
| CGeom2dGridEval_Curve | Unified grid evaluator for any 2D curve |
| CGeom2dGridEval_Ellipse | Efficient batch evaluator for 2D ellipse grid points |
| CGeom2dGridEval_Hyperbola | Efficient batch evaluator for 2D hyperbola grid points |
| CGeom2dGridEval_Line | Efficient batch evaluator for 2D line grid points |
| CGeom2dGridEval_OffsetCurve | Batch evaluator for 2D offset curve grid points |
| CGeom2dGridEval_OtherCurve | Fallback evaluator for unknown 2D curve types |
| CGeom2dGridEval_Parabola | Efficient batch evaluator for 2D parabola grid points |
| CGeom2dHash_CurveHasher | Polymorphic hasher for Geom2d_Curve using RTTI dispatch. Used for geometry deduplication |
| CGeom2dHatch_Classifier | |
| CGeom2dHatch_Element | |
| CGeom2dHatch_Elements | |
| CGeom2dHatch_FClass2dOfClassifier | |
| CGeom2dHatch_Hatcher | |
| CGeom2dHatch_Hatching | |
| CGeom2dHatch_Intersector | |
| CGeom2dInt_ExactIntersectionPointOfTheIntPCurvePCurveOfGInter | |
| CGeom2dInt_Geom2dCurveTool | This class provides a Geom2dCurveTool as < Geom2dCurveTool from IntCurve > from a Tool as < Geom2dCurveTool from Adaptor3d > |
| CGeom2dInt_GInter | |
| CGeom2dInt_IntConicCurveOfGInter | |
| CGeom2dInt_MyImpParToolOfTheIntersectorOfTheIntConicCurveOfGInter | |
| CGeom2dInt_TheDistBetweenPCurvesOfTheIntPCurvePCurveOfGInter | |
| CGeom2dInt_TheIntConicCurveOfGInter | |
| CGeom2dInt_TheIntersectorOfTheIntConicCurveOfGInter | |
| CGeom2dInt_TheIntPCurvePCurveOfGInter | |
| CGeom2dInt_ThePolygon2dOfTheIntPCurvePCurveOfGInter | |
| CGeom2dInt_TheProjPCurOfGInter | |
| CGeom2dToIGES_Geom2dCurve | This class implements the transfer of the Curve Entity from Geom2d To IGES. These can be: Curve . BoundedCurve |
| CGeom2dToIGES_Geom2dEntity | Methods to transfer Geom2d entity from CASCADE to IGES |
| CGeom2dToIGES_Geom2dPoint | This class implements the transfer of the Point Entity from Geom2d to IGES. These are: . 2dPoint |
| CGeom2dToIGES_Geom2dVector | This class implements the transfer of the Vector from Geom2d to IGES. These can be: . Vector |
| CGeom_Axis1Placement | Describes an axis in 3D space. An axis is defined by: |
| CGeom_Axis2Placement | Describes a right-handed coordinate system in 3D space. A coordinate system is defined by: |
| CGeom_AxisPlacement | The abstract class AxisPlacement describes the common behavior of positioning systems in 3D space, such as axis or coordinate systems. The Geom package provides two implementations of 3D positioning systems: |
| CGeom_BezierCurve | Describes a rational or non-rational Bezier curve |
| CGeom_BezierSurface | Describes a rational or non-rational Bezier surface |
| CGeom_BoundedCurve | The abstract class BoundedCurve describes the common behavior of bounded curves in 3D space. A bounded curve is limited by two finite values of the parameter, termed respectively "first parameter" and "last parameter". The "first parameter" gives the "start
point" of the bounded curve, and the "last parameter" gives the "end point" of the bounded curve. The length of a bounded curve is finite. The Geom package provides three concrete classes of bounded curves: |
| CGeom_BoundedSurface | The root class for bounded surfaces in 3D space. A bounded surface is defined by a rectangle in its 2D parametric space, i.e |
| CGeom_BSplineCurve | Definition of the B_spline curve. A B-spline curve can be Uniform or non-uniform Rational or non-rational Periodic or non-periodic |
| CGeom_BSplineSurface | Describes a BSpline surface. In each parametric direction, a BSpline surface can be: |
| CGeom_CartesianPoint | Describes a point in 3D space. A Geom_CartesianPoint is defined by a gp_Pnt point, with its three Cartesian coordinates X, Y and Z |
| CGeom_Circle | Describes a circle in 3D space. A circle is defined by its radius and, as with any conic curve, is positioned in space with a right-handed coordinate system (gp_Ax2 object) where: |
| CGeom_Conic | The abstract class Conic describes the common behavior of conic curves in 3D space and, in particular, their general characteristics. The Geom package provides four concrete classes of conics: Geom_Circle, Geom_Ellipse, Geom_Hyperbola and Geom_Parabola. A conic is positioned in space with a right-handed coordinate system (gp_Ax2 object), where: |
| CGeom_ConicalSurface | Describes a cone. A cone is defined by the half-angle (can be negative) at its apex, and is positioned in space by a coordinate system (a gp_Ax3 object) and a reference radius as follows: |
| CGeom_Curve | The abstract class Curve describes the common behavior of curves in 3D space. The Geom package provides numerous concrete classes of derived curves, including lines, circles, conics, Bezier or BSpline curves, etc. The main characteristic of these curves is that they are parameterized. The Geom_Curve class shows: |
| CResD1 | Result of D1 evaluation: point and first derivative |
| CResD2 | Result of D2 evaluation: point and first two derivatives |
| CResD3 | Result of D3 evaluation: point and first three derivatives |
| CGeom_CylindricalSurface | This class defines the infinite cylindrical surface |
| CGeom_Direction | The class Direction specifies a vector that is never null. It is a unit vector |
| CGeom_ElementarySurface | Describes the common behavior of surfaces which have a simple parametric equation in a local coordinate system. The Geom package provides several implementations of concrete elementary surfaces: |
| CGeom_Ellipse | Describes an ellipse in 3D space. An ellipse is defined by its major and minor radii and, as with any conic curve, is positioned in space with a right-handed coordinate system (gp_Ax2 object) where: |
| CGeom_Geometry | The abstract class Geometry for 3D space is the root class of all geometric objects from the Geom package. It describes the common behavior of these objects when: |
| CGeom_Hyperbola | Describes a branch of a hyperbola in 3D space. A hyperbola is defined by its major and minor radii and, as with any conic curve, is positioned in space with a right-handed coordinate system (gp_Ax2 object) where: |
| CGeom_Line | Describes an infinite line. A line is defined and positioned in space with an axis (gp_Ax1 object) which gives it an origin and a unit vector. The Geom_Line line is parameterized: P (U) = O + U*Dir, where: |
| CGeom_OffsetCurve | This class implements the basis services for an offset curve in 3D space. The Offset curve in this package can be a self intersecting curve even if the basis curve does not self-intersect. The self intersecting portions are not deleted at the construction time. An offset curve is a curve at constant distance (Offset) from a basis curve in a reference direction V. The offset curve takes its parametrization from the basis curve. The Offset curve is in the direction of the normal N defined with the cross product T^V, where the vector T is given by the first derivative on the basis curve with non zero length. The distance offset may be positive or negative to indicate the preferred side of the curve : . distance offset >0 => the curve is in the direction of N . distance offset <0 => the curve is in the direction of - N |
| CGeom_OffsetSurface | Describes an offset surface in 3D space. An offset surface is defined by: |
| CGeom_Parabola | Describes a parabola in 3D space. A parabola is defined by its focal length (i.e. the distance between its focus and its apex) and is positioned in space with a coordinate system (gp_Ax2 object) where: |
| CGeom_Plane | Describes a plane in 3D space. A plane is positioned in space by a coordinate system (a gp_Ax3 object) such that the plane is defined by the origin, "X Direction" and "Y Direction" of this coordinate system. This coordinate system is the "local coordinate
system" of the plane. The following apply: |
| CGeom_Point | The abstract class Point describes the common behavior of geometric points in 3D space. The Geom package also provides the concrete class Geom_CartesianPoint |
| CGeom_RectangularTrimmedSurface | Describes a portion of a surface (a patch) limited by two values of the u parameter in the u parametric direction, and two values of the v parameter in the v parametric direction. The domain of the trimmed surface must be within the domain of the surface being trimmed. The trimmed surface is defined by: |
| CGeom_SphericalSurface | Describes a sphere. A sphere is defined by its radius, and is positioned in space by a coordinate system (a gp_Ax3 object), the origin of which is the center of the sphere. This coordinate system is the "local coordinate
system" of the sphere. The following apply: |
| CGeom_Surface | Describes the common behavior of surfaces in 3D space. The Geom package provides many implementations of concrete derived surfaces, such as planes, cylinders, cones, spheres and tori, surfaces of linear extrusion, surfaces of revolution, Bezier and BSpline surfaces, and so on. The key characteristic of these surfaces is that they are parameterized. Geom_Surface demonstrates: |
| CResD1 | Result of D1 evaluation: point and partial first derivatives |
| CResD2 | Result of D2 evaluation: point and partial derivatives up to 2nd order |
| CResD3 | Result of D3 evaluation: point and partial derivatives up to 3rd order |
| CGeom_SurfaceOfLinearExtrusion | Describes a surface of linear extrusion ("extruded
surface"), e.g. a generalized cylinder. Such a surface is obtained by sweeping a curve (called the "extruded
curve" or "basis") in a given direction (referred to as the "direction of extrusion" and defined by a unit vector). The u parameter is along the extruded curve. The v parameter is along the direction of extrusion. The parameter range for the u parameter is defined by the reference curve. The parameter range for the v parameter is ] - infinity, + infinity [. The position of the curve gives the origin of the v parameter. The surface is "CN" in the v parametric direction. The form of a surface of linear extrusion is generally a ruled surface (GeomAbs_RuledForm). It can be: |
| CGeom_SurfaceOfRevolution | Describes a surface of revolution (revolved surface). Such a surface is obtained by rotating a curve (called the "meridian") through a complete revolution about an axis (referred to as the "axis of revolution"). The curve and the axis must be in the same plane (the "reference plane" of the surface). Rotation around the axis of revolution in the trigonometric sense defines the u parametric direction. So the u parameter is an angle, and its origin is given by the position of the meridian on the surface. The parametric range for the u parameter is: [ 0, 2.*Pi ] The v parameter is that of the meridian. Note: A surface of revolution is built from a copy of the original meridian. As a result the original meridian is not modified when the surface is modified. The form of a surface of revolution is typically a general revolution surface (GeomAbs_RevolutionForm). It can be: |
| CGeom_SweptSurface | Describes the common behavior for surfaces constructed by sweeping a curve with another curve. The Geom package provides two concrete derived surfaces: surface of revolution (a revolved surface), and surface of linear extrusion (an extruded surface) |
| CGeom_ToroidalSurface | Describes a torus. A torus is defined by its major and minor radii, and positioned in space with a coordinate system (a gp_Ax3 object) as follows: |
| CGeom_Transformation | Describes how to construct the following elementary transformations |
| CGeom_TrimmedCurve | Describes a portion of a curve (termed the "basis
curve") limited by two parameter values inside the parametric domain of the basis curve. The trimmed curve is defined by: |
| CGeom_Vector | The abstract class Vector describes the common behavior of vectors in 3D space. The Geom package provides two concrete classes of vectors: Geom_Direction (unit vector) and Geom_VectorWithMagnitude |
| CGeom_VectorWithMagnitude | Defines a vector with magnitude. A vector with magnitude can have a zero length |
| CGeomAdaptor | This package contains the geometric definition of curve and surface necessary to use algorithms |
| CGeomAdaptor_Curve | This class provides an interface between the services provided by any curve from the package Geom and those required of the curve by algorithms which use it. Creation of the loaded curve the curve is C1 by piece |
| COffsetData | Internal structure for offset curve evaluation data |
| CBezierData | Internal structure for Bezier curve cache data |
| CBSplineData | Internal structure for BSpline curve cache data |
| CGeomAdaptor_Surface | An interface between the services provided by any surface from the package Geom and those required of the surface by algorithms which use it. Creation of the loaded surface the surface is C1 by piece |
| CExtrusionData | Internal structure for extrusion surface evaluation data |
| CRevolutionData | Internal structure for revolution surface evaluation data |
| COffsetData | Internal structure for offset surface evaluation data |
| CBezierData | Internal structure for Bezier surface cache data |
| CBSplineData | Internal structure for BSpline surface cache data |
| CGeomAdaptor_SurfaceOfLinearExtrusion | Generalised cylinder. This surface is obtained by sweeping a curve in a given direction. The parametrization range for the parameter U is defined with referenced the curve. The parametrization range for the parameter V is ]-infinite,+infinite[ The position of the curve gives the origin for the parameter V. The continuity of the surface is CN in the V direction |
| CGeomAdaptor_SurfaceOfRevolution | This class defines a complete surface of revolution. The surface is obtained by rotating a curve a complete revolution about an axis. The curve and the axis must be in the same plane. If the curve and the axis are not in the same plane it is always possible to be in the previous case after a cylindrical projection of the curve in a referenced plane. For a complete surface of revolution the parametric range is 0 <= U <= 2*PI The parametric range for V is defined with the revolved curve. The origin of the U parametrization is given by the position of the revolved curve (reference). The direction of the revolution axis defines the positive sense of rotation (trigonometric sense) corresponding to the increasing of the parametric value U. The derivatives are always defined for the u direction. For the v direction the definition of the derivatives depends on the degree of continuity of the referenced curve |
| CGeomAdaptor_TransformedCurve | An adaptor for curves with an applied transformation |
| CGeomAdaptor_TransformedSurface | An adaptor for surfaces with an applied transformation |
| CGeomAPI | The GeomAPI package provides an Application Programming Interface for the Geometry |
| CGeomAPI_ExtremaCurveCurve | Describes functions for computing all the extrema between two 3D curves. An ExtremaCurveCurve algorithm minimizes or maximizes the distance between a point on the first curve and a point on the second curve. Thus, it computes start and end points of perpendiculars common to the two curves (an intersection point is not an extremum unless the two curves are tangential at this point). Solutions consist of pairs of points, and an extremum is considered to be a segment joining the two points of a solution. An ExtremaCurveCurve object provides a framework for: |
| CGeomAPI_ExtremaCurveSurface | Describes functions for computing all the extrema between a curve and a surface. An ExtremaCurveSurface algorithm minimizes or maximizes the distance between a point on the curve and a point on the surface. Thus, it computes start and end points of perpendiculars common to the curve and the surface (an intersection point is not an extremum except where the curve and the surface are tangential at this point). Solutions consist of pairs of points, and an extremum is considered to be a segment joining the two points of a solution. An ExtremaCurveSurface object provides a framework for: |
| CGeomAPI_ExtremaSurfaceSurface | Describes functions for computing all the extrema between two surfaces. An ExtremaSurfaceSurface algorithm minimizes or maximizes the distance between a point on the first surface and a point on the second surface. Results are start and end points of perpendiculars common to the two surfaces. Solutions consist of pairs of points, and an extremum is considered to be a segment joining the two points of a solution. An ExtremaSurfaceSurface object provides a framework for: |
| CGeomAPI_IntCS | This class implements methods for computing intersection points and segments between a |
| CGeomAPI_Interpolate | This class is used to interpolate a BsplineCurve passing through an array of points, with a C2 Continuity if tangency is not requested at the point. If tangency is requested at the point the continuity will be C1. If Perodicity is requested the curve will be closed and the junction will be the first point given. The curve will than be only C1 Describes functions for building a constrained 3D BSpline curve. The curve is defined by a table of points through which it passes, and if required: |
| CGeomAPI_IntSS | This class implements methods for computing the intersection curves between two surfaces. The result is curves from Geom. The "domain" used for a surface is the natural parametric domain unless the surface is a RectangularTrimmedSurface from Geom |
| CGeomAPI_PointsToBSpline | This class is used to approximate a BsplineCurve passing through an array of points, with a given Continuity. Describes functions for building a 3D BSpline curve which approximates a set of points. A PointsToBSpline object provides a framework for: |
| CGeomAPI_PointsToBSplineSurface | This class is used to approximate or interpolate a BSplineSurface passing through an Array2 of points, with a given continuity. Describes functions for building a BSpline surface which approximates or interpolates a set of points. A PointsToBSplineSurface object provides a framework for: |
| CGeomAPI_ProjectPointOnCurve | This class implements methods for computing all the orthogonal projections of a 3D point onto a 3D curve |
| CGeomAPI_ProjectPointOnSurf | This class implements methods for computing all the orthogonal projections of a point onto a surface |
| CGeomBndLib_BezierCurve | Computes bounding box for a 3D Bezier curve (Geom_BezierCurve). Uses poles convex hull + sampling for deflection estimation |
| CGeomBndLib_BezierCurve2d | Computes bounding box for a 2D Bezier curve (Geom2d_BezierCurve). Uses poles convex hull + sampling for deflection estimation |
| CGeomBndLib_BezierSurface | Computes bounding box for a Bezier surface (Geom_BezierSurface). Uses poles convex hull for full surface, grid sampling for trimmed patches |
| CGeomBndLib_BSplineCurve | Computes bounding box for a 3D BSpline curve (Geom_BSplineCurve). Uses poles convex hull with knot-based index selection + sampling |
| CGeomBndLib_BSplineCurve2d | Computes bounding box for a 2D BSpline curve (Geom2d_BSplineCurve). Uses poles convex hull with knot-based index selection + sampling |
| CGeomBndLib_BSplineSurface | Computes bounding box for a BSpline surface (Geom_BSplineSurface). Uses poles convex hull with knot-based index selection via ComputePolesIndexes |
| CGeomBndLib_Circle | Computes bounding box for a 3D circle (Geom_Circle). Uses analytical per-coordinate extrema computation |
| CGeomBndLib_Circle2d | Computes bounding box for a 2D circle (Geom2d_Circle). Uses analytical per-coordinate extrema computation |
| CGeomBndLib_Cone | Computes bounding box for a conical surface (Geom_ConicalSurface). Uses ElSLib iso-curves and GeomBndLib_ConicHelpers for circle arc bounding |
| CGeomBndLib_Curve | Variant-based dispatcher for 3D curve bounding box computation. Auto-detects the curve type and delegates to the appropriate specialized class |
| CGeomBndLib_Curve2d | Variant-based dispatcher for 2D curve bounding box computation. Auto-detects the curve type and delegates to the appropriate specialized class |
| CGeomBndLib_Cylinder | Computes bounding box for a cylindrical surface (Geom_CylindricalSurface). Uses ElSLib iso-curves and GeomBndLib_ConicHelpers for circle arc bounding |
| CGeomBndLib_Ellipse | Computes bounding box for a 3D ellipse (Geom_Ellipse). Uses analytical per-coordinate extrema computation |
| CGeomBndLib_Ellipse2d | Computes bounding box for a 2D ellipse (Geom2d_Ellipse). Uses analytical per-coordinate extrema computation |
| CGeomBndLib_Hyperbola | Computes bounding box for a 3D hyperbola (Geom_Hyperbola). Handles infinite parameters by opening the box in appropriate directions |
| CGeomBndLib_Hyperbola2d | Computes bounding box for a 2D hyperbola (Geom2d_Hyperbola). Handles infinite parameters by opening the box in appropriate directions |
| CGeomBndLib_Line | Computes bounding box for a 3D line (Geom_Line). Handles infinite parameters by opening the box in appropriate directions |
| CGeomBndLib_Line2d | Computes bounding box for a 2D line (Geom2d_Line). Handles infinite parameters by opening the box in appropriate directions |
| CGeomBndLib_OffsetCurve | Computes bounding box for a 3D offset curve (Geom_OffsetCurve). Computes the bounding box of the basis curve and enlarges it by |offset| |
| CGeomBndLib_OffsetCurve2d | Computes bounding box for a 2D offset curve (Geom2d_OffsetCurve). Computes the bounding box of the basis curve and enlarges it by |offset| |
| CGeomBndLib_OffsetSurface | Computes bounding box for an offset surface (Geom_OffsetSurface). Computes the bounding box of the basis surface and enlarges it by |offset| |
| CGeomBndLib_OtherCurve | Computes bounding box for a general 3D curve via adaptor. Uses sampling + PSO/Brent numerical optimization for BoxOptimal |
| CGeomBndLib_OtherCurve2d | Computes bounding box for a general 2D curve via adaptor. Uses sampling + PSO/Brent numerical optimization for BoxOptimal |
| CGeomBndLib_OtherSurface | Computes bounding box for a general surface via adaptor. Uses grid sampling for Box and PSO/Powell numerical optimization for BoxOptimal |
| CGeomBndLib_Parabola | Computes bounding box for a 3D parabola (Geom_Parabola). Handles infinite parameters by opening the box in appropriate directions |
| CGeomBndLib_Parabola2d | Computes bounding box for a 2D parabola (Geom2d_Parabola). Handles infinite parameters by opening the box in appropriate directions |
| CGeomBndLib_Plane | Computes bounding box for a 3D plane (Geom_Plane). Handles infinite parameters by opening box sides based on the plane normal direction |
| CGeomBndLib_Sphere | Computes bounding box for a spherical surface (Geom_SphericalSurface). Uses direct extremal-point computation and ElSLib iso-curves with GeomBndLib_ConicHelpers for circle arc bounding |
| CGeomBndLib_Surface | Variant-based dispatcher for 3D surface bounding box computation. Auto-detects the surface type and delegates to the appropriate specialized class |
| CGeomBndLib_SurfaceOfExtrusion | Computes bounding box for a surface of linear extrusion (Geom_SurfaceOfLinearExtrusion). Uses pure analytical approach: P(U, V) = BasisCurve(U) + V * Direction, so the box is computed from the basis curve box extended along the direction |
| CGeomBndLib_SurfaceOfRevolution | Computes bounding box for a surface of revolution (Geom_SurfaceOfRevolution). Uses analytical approach: samples the basis curve at multiple V values, constructs the revolution circle for each sample point, and bounds each circle arc using GeomBndLib_Circle |
| CGeomBndLib_Torus | Computes bounding box for a toroidal surface (Geom_ToroidalSurface). Uses 8-point polygon approximation via GeomBndLib_ConicHelpers and extremal-point computation for degenerate torus (Ra < Ri) |
| CGeomConvert | The GeomConvert package provides some global functions as follows |
| CGeomConvert_ApproxCurve | A framework to convert a 3D curve to a 3D BSpline. This is done by approximation to a BSpline curve within a given tolerance |
| CGeomConvert_ApproxSurface | A framework to convert a surface to a BSpline surface. This is done by approximation to a BSpline surface within a given tolerance |
| CGeomConvert_BSplineCurveKnotSplitting | An algorithm to determine points at which a BSpline curve should be split in order to obtain arcs of the same continuity. If you require curves with a minimum continuity for your computation, it is useful to know the points between which an arc has a continuity of a given order. The continuity order is given at the construction time. For a BSpline curve, the discontinuities are localized at the knot values. Between two knot values the BSpline is infinitely and continuously differentiable. At a given knot, the continuity is equal to: Degree - Mult, where Degree is the degree of the BSpline curve and Mult is the multiplicity of the knot. It is possible to compute the arcs which correspond to this splitting using the global function SplitBSplineCurve provided by the package GeomConvert. A BSplineCurveKnotSplitting object provides a framework for: |
| CGeomConvert_BSplineCurveToBezierCurve | An algorithm to convert a BSpline curve into a series of adjacent Bezier curves. A BSplineCurveToBezierCurve object provides a framework for: |
| CGeomConvert_BSplineSurfaceKnotSplitting | An algorithm to determine isoparametric curves along which a BSpline surface should be split in order to obtain patches of the same continuity. The continuity order is given at the construction time. It is possible to compute the surface patches corresponding to the splitting with the method of package SplitBSplineSurface. For a B-spline surface the discontinuities are localised at the knot values. Between two knots values the B-spline is infinitely continuously differentiable. For each parametric direction at a knot of range index the continuity in this direction is equal to: Degree - Mult (Index) where Degree is the degree of the basis B-spline functions and Mult the multiplicity of the knot of range Index in the given direction. If for your computation you need to have B-spline surface with a minima of continuity it can be interesting to know between which knot values, a B-spline patch, has a continuity of given order. This algorithm computes the indexes of the knots where you should split the surface, to obtain patches with a constant continuity given at the construction time. If you just want to compute the local derivatives on the surface you don't need to create the BSpline patches, you can use the functions LocalD1, LocalD2, LocalD3, LocalDN of the class BSplineSurface from package Geom |
| CGeomConvert_BSplineSurfaceToBezierSurface | This algorithm converts a B-spline surface into several Bezier surfaces. It uses an algorithm of knot insertion. A BSplineSurfaceToBezierSurface object provides a framework for: |
| CGeomConvert_CompBezierSurfacesToBSplineSurface | An algorithm to convert a grid of adjacent non-rational Bezier surfaces (with continuity CM) into a BSpline surface (with continuity CM). A CompBezierSurfacesToBSplineSurface object provides a framework for: |
| CGeomConvert_CompCurveToBSplineCurve | Algorithm converts and concat several curve in an BSplineCurve |
| CGeomConvert_CurveToAnaCurve | |
| CGeomConvert_FuncConeLSDist | Function for search of Cone canonic parameters: coordinates of center local coordinate system, direction of axis, radius and semi-angle from set of points by least square method |
| CGeomConvert_FuncCylinderLSDist | Function for search of cylinder canonic parameters: coordinates of center local coordinate system, direction of axis and radius from set of points by least square method |
| CGeomConvert_FuncSphereLSDist | Function for search of sphere canonic parameters: coordinates of center and radius from set of moints by least square method. //! The class inherits math_MultipleVarFunctionWithGradient and thus is intended for use in math_BFGS algorithm |
| CGeomConvert_SurfToAnaSurf | Converts a surface to the analytical form with given precision. Conversion is done only the surface is bspline of bezier and this can be approximated by some analytical surface with that precision |
| CGeomConvert_Units | Class contains conversion methods for 2d geom objects |
| CGeometryTest | This package provides commands for curves and surface |
| CGeometryTest_DrawableQualifiedCurve2d | Create geom curve drawable presentation with the position of a solution of a construction algorithm |
| CGeomEval_AHTBezierCurve | 3D Algebraic-Hyperbolic-Trigonometric Bezier curve. Uses a mixed basis: {1, t, ..., t^k, sinh(alpha*t), cosh(alpha*t), sin(beta*t), cos(beta*t)}. The number of basis functions = algDegree + 1 + 2*(alpha>0) + 2*(beta>0) must equal NbPoles. Parameter range: [0, 1] |
| CGeomEval_AHTBezierSurface | Tensor-product Algebraic-Hyperbolic-Trigonometric Bezier surface. Uses a mixed basis in each parametric direction: {1, t, ..., t^k, sinh(alpha*t), cosh(alpha*t), sin(beta*t), cos(beta*t)} |
| CGeomEval_CircularHelicoidSurface | Describes a circular helicoid surface. A ruled surface generated by a line segment rotating uniformly about an axis while translating along it. Named "circular" because the generating line sweeps circular helices at constant radius |
| CGeomEval_CircularHelixCurve | Describes a circular helix in 3D space. A circular helix is an unbounded curve defined by a radius R, a pitch P (axial advance per full 2*Pi turn), and a coordinate system |
| CGeomEval_EllipsoidSurface | Describes a triaxial ellipsoid surface. An ellipsoid is defined by three semi-axes A, B, C (all > 0) and is positioned in space by a coordinate system (a gp_Ax3 object), the origin of which is the center of the ellipsoid |
| CGeomEval_HyperboloidSurface | Describes a hyperboloid of revolution surface (one-sheet or two-sheet) |
| CGeomEval_HypParaboloidSurface | Describes a hyperbolic paraboloid (saddle surface) |
| CGeomEval_ParaboloidSurface | Describes a circular paraboloid surface of revolution. A paraboloid is defined by its focal distance and is positioned in space by a coordinate system (a gp_Ax3 object), the origin of which is the vertex of the paraboloid |
| CGeomEval_SineWaveCurve | Describes a 3D sine wave curve. The curve lies in the plane defined by the local coordinate system, oscillating along YDir with propagation along XDir |
| CGeomEval_TBezierCurve | 3D Trigonometric Bezier curve. Uses a trigonometric Bernstein-like basis over the space {1, sin(alpha*t), cos(alpha*t), ..., sin(n*alpha*t), cos(n*alpha*t)} |
| CGeomEval_TBezierSurface | Tensor-product Trigonometric Bezier surface. Uses trigonometric Bernstein-like bases in both U and V directions over the space {1, sin(alpha*t), cos(alpha*t), ..., sin(n*alpha*t), cos(n*alpha*t)} |
| CGeomFill | Tools and Data to filling Surface and Sweep Surfaces |
| CGeomFill_AppSurf | Approximate a BSplineSurface passing by all the curves described in the SectionGenerator |
| CGeomFill_AppSweep | Approximate a sweep surface passing by all the curves described in the SweepSectionGenerator |
| CGeomFill_BezierCurves | This class provides an algorithm for constructing a Bezier surface filled from contiguous Bezier curves which form its boundaries. The algorithm accepts two, three or four Bezier curves as the boundaries of the target surface. A range of filling styles - more or less rounded, more or less flat - is available. A BezierCurves object provides a framework for: |
| CGeomFill_Boundary | Root class to define a boundary which will form part of a contour around a gap requiring filling. Any new type of constrained boundary must inherit this class. The GeomFill package provides two classes to define constrained boundaries: |
| CGeomFill_BoundWithSurf | Defines a 3d curve as a boundary for a GeomFill_ConstrainedFilling algorithm. This curve is attached to an existing surface. Defines a constrained boundary for filling the computations are done with a CurveOnSurf and a normals field defined by the normalized normal to the surface along the PCurve. Contains fields to allow a reparametrization of curve and normals field |
| CGeomFill_BSplineCurves | An algorithm for constructing a BSpline surface filled from contiguous BSpline curves which form its boundaries. The algorithm accepts two, three or four BSpline curves as the boundaries of the target surface. A range of filling styles - more or less rounded, more or less flat - is available. A BSplineCurves object provides a framework for: |
| CGeomFill_CircularBlendFunc | Circular Blend Function to approximate by SweepApproximation from Approx |
| CGeomFill_ConstantBiNormal | Defined a Trihedron Law where the BiNormal, is fixed |
| CGeomFill_ConstrainedFilling | An algorithm for constructing a BSpline surface filled from a series of boundaries which serve as path constraints and optionally, as tangency constraints. The algorithm accepts three or four curves as the boundaries of the target surface. The only FillingStyle used is Coons. A ConstrainedFilling object provides a framework for: |
| CGeomFill_Coons | |
| CGeomFill_CoonsAlgPatch | Provides evaluation methods on an algorithmic patch (based on 4 Curves) defined by its boundaries and blending functions |
| CGeomFill_CornerState | Class (should be a structure) storing the information about continuity, normals parallelism, coons conditions and bounds tangents angle on the corner of contour to be filled |
| CGeomFill_CorrectedFrenet | Defined an Corrected Frenet Trihedron Law It is like Frenet with an Torsion's minimization |
| CGeomFill_CurveAndTrihedron | Define location law with an TrihedronLaw and an curve Definition Location is: transformed section coordinates in (Curve(v)), (Normal(v), BiNormal(v), Tangente(v))) systems are the same like section shape coordinates in (O,(OX, OY, OZ)) system |
| CGeomFill_Curved | |
| CGeomFill_Darboux | Defines Darboux case of Frenet Trihedron Law |
| CGeomFill_DegeneratedBound | Description of a degenerated boundary (a point). Class defining a degenerated boundary for a constrained filling with a point and no other constraint. Only used to simulate an ordinary bound, may not be useful and desapear soon |
| CGeomFill_DiscreteTrihedron | Defined Discrete Trihedron Law. The requirement for path curve is only G1. The result is C0-continuous surface that can be later approximated to C1 |
| CGeomFill_DraftTrihedron | |
| CGeomFill_EvolvedSection | Define an Constant Section Law |
| CGeomFill_Filling | Root class for Filling; |
| CGeomFill_Fixed | Defined an constant TrihedronLaw |
| CGeomFill_Frenet | Defined Frenet Trihedron Law |
| CGeomFill_FunctionDraft | |
| CGeomFill_FunctionGuide | |
| CGeomFill_Generator | Create a surface using generating lines. Inherits profiler. The surface will be a BSplineSurface passing by all the curves described in the generator. The VDegree of the resulting surface is 1 |
| CGeomFill_Gordon | High-level Gordon surface construction from arbitrary curve networks |
| CBuildReport | Diagnostics for the last Perform() call |
| CGeomFill_GuideTrihedronAC | Trihedron in the case of a sweeping along a guide curve. defined by curviline absciss |
| CGeomFill_GuideTrihedronPlan | Trihedron in the case of sweeping along a guide curve defined by the orthogonal plan on the trajectory |
| CGeomFill_Line | Class for instantiation of AppBlend |
| CGeomFill_LocationDraft | |
| CGeomFill_LocationGuide | |
| CGeomFill_LocationLaw | To define location law in Sweeping location is defined by an Matrix M and an Vector V, and transform an point P in MP+V |
| CGeomFill_LocFunction | |
| CGeomFill_NetworkSurface | Low-level Gordon surface construction from a compatible B-spline curve network |
| CGeomFill_NSections | Define a Section Law by N Sections |
| CGeomFill_Pipe | Describes functions to construct pipes. A pipe is built by sweeping a curve (the section) along another curve (the path). The Pipe class provides the following types of construction: |
| CGeomFill_PlanFunc | |
| CGeomFill_PolynomialConvertor | To convert circular section in polynome |
| CGeomFill_Profiler | Evaluation of the common BSplineProfile of a group of curves from Geom. All the curves will have the same degree, the same knot-vector, so the same number of poles |
| CGeomFill_QuasiAngularConvertor | To convert circular section in QuasiAngular Bezier form |
| CGeomFill_SectionGenerator | Gives the functions needed for instantiation from AppSurf in AppBlend. Allow to evaluate a surface passing by all the curves if the Profiler |
| CGeomFill_SectionLaw | To define section law in sweeping |
| CGeomFill_SectionPlacement | To place section in sweep Function |
| CGeomFill_SimpleBound | Defines a 3d curve as a boundary for a GeomFill_ConstrainedFilling algorithm. This curve is unattached to an existing surface.D Contains fields to allow a reparametrization of curve |
| CGeomFill_SnglrFunc | To represent function C'(t)^C''(t) |
| CGeomFill_Stretch | |
| CGeomFill_Sweep | Geometrical Sweep Algorithm |
| CGeomFill_SweepFunction | Function to approximate by SweepApproximation from Approx. To build general sweep Surface |
| CGeomFill_SweepSectionGenerator | Class for instantiation of AppBlend. evaluate the sections of a sweep surface |
| CGeomFill_Tensor | Used to store the "gradient of gradient" |
| CGeomFill_TgtField | Root class defining the methods we need to make an algorithmic tangents field |
| CGeomFill_TgtOnCoons | Defines an algorithmic tangents field on a boundary of a CoonsAlgPatch |
| CGeomFill_TrihedronLaw | To define Trihedron along one Curve |
| CGeomFill_TrihedronWithGuide | To define Trihedron along one Curve with a guide |
| CGeomFill_UniformSection | Define an Constant Section Law |
| CGeomGridEval_BezierCurve | Efficient batch evaluator for Bezier curve grid points |
| CGeomGridEval_BezierSurface | Efficient batch evaluator for Bezier surface grid points |
| CGeomGridEval_BSplineCurve | Efficient batch evaluator for B-spline curve grid points |
| CGeomGridEval_BSplineSurface | Efficient batch evaluator for B-spline surface points |
| CGeomGridEval_Circle | Efficient batch evaluator for circle grid points |
| CGeomGridEval_Cone | Efficient batch evaluator for cone grid points |
| CGeomGridEval_Curve | Unified grid evaluator for any 3D curve |
| CGeomGridEval_Cylinder | Efficient batch evaluator for cylinder grid points |
| CGeomGridEval_Ellipse | Efficient batch evaluator for ellipse grid points |
| CGeomGridEval_Hyperbola | Efficient batch evaluator for hyperbola grid points |
| CGeomGridEval_Line | Efficient batch evaluator for line grid points |
| CGeomGridEval_OffsetCurve | Batch evaluator for offset curve grid points |
| CGeomGridEval_OffsetSurface | Batch evaluator for offset surface grid points |
| CGeomGridEval_OtherCurve | Fallback evaluator for unknown curve types |
| CGeomGridEval_OtherSurface | Fallback evaluator for any surface type |
| CGeomGridEval_Parabola | Efficient batch evaluator for parabola grid points |
| CGeomGridEval_Plane | Efficient batch evaluator for plane grid points |
| CGeomGridEval_Sphere | Efficient batch evaluator for sphere grid points |
| CGeomGridEval_Surface | Unified grid evaluator for any 3D surface |
| CGeomGridEval_SurfaceOfExtrusion | Optimized batch evaluator for linear extrusion surface grid points |
| CGeomGridEval_SurfaceOfRevolution | Optimized batch evaluator for revolution surface grid points |
| CGeomGridEval_Torus | Efficient batch evaluator for torus grid points |
| CGeomHash_CurveHasher | Polymorphic hasher for Geom_Curve using RTTI dispatch. Used for geometry deduplication |
| CGeomHash_Polygon2DHasher | |
| CGeomHash_Polygon3DHasher | |
| CGeomHash_PolygonOnTriHasher | |
| CGeomHash_SurfaceHasher | Polymorphic hasher for Geom_Surface using RTTI dispatch. Used for geometry deduplication |
| CGeomHash_TriangulationHasher | |
| CGeomInt | Provides intersections on between two surfaces of Geom. The result are curves from Geom |
| CGeomInt_BSpGradient_BFGSOfMyBSplGradientOfTheComputeLineOfWLApprox | |
| CGeomInt_BSpParFunctionOfMyBSplGradientOfTheComputeLineOfWLApprox | |
| CGeomInt_BSpParLeastSquareOfMyBSplGradientOfTheComputeLineOfWLApprox | |
| CGeomInt_Gradient_BFGSOfMyGradientbisOfTheComputeLineOfWLApprox | |
| CGeomInt_Gradient_BFGSOfMyGradientOfTheComputeLineBezierOfWLApprox | |
| CGeomInt_IntSS | |
| CGeomInt_LineConstructor | Splits given Line |
| CGeomInt_LineTool | |
| CGeomInt_MyBSplGradientOfTheComputeLineOfWLApprox | |
| CGeomInt_MyGradientbisOfTheComputeLineOfWLApprox | |
| CGeomInt_MyGradientOfTheComputeLineBezierOfWLApprox | |
| CGeomInt_ParameterAndOrientation | |
| CGeomInt_ParFunctionOfMyGradientbisOfTheComputeLineOfWLApprox | |
| CGeomInt_ParFunctionOfMyGradientOfTheComputeLineBezierOfWLApprox | |
| CGeomInt_ParLeastSquareOfMyGradientbisOfTheComputeLineOfWLApprox | |
| CGeomInt_ParLeastSquareOfMyGradientOfTheComputeLineBezierOfWLApprox | |
| CGeomInt_ResConstraintOfMyGradientbisOfTheComputeLineOfWLApprox | |
| CGeomInt_ResConstraintOfMyGradientOfTheComputeLineBezierOfWLApprox | |
| CGeomInt_TheComputeLineBezierOfWLApprox | |
| CGeomInt_TheComputeLineOfWLApprox | |
| CGeomInt_TheFunctionOfTheInt2SOfThePrmPrmSvSurfacesOfWLApprox | |
| CGeomInt_TheImpPrmSvSurfacesOfWLApprox | |
| CGeomInt_TheInt2SOfThePrmPrmSvSurfacesOfWLApprox | |
| CGeomInt_TheMultiLineOfWLApprox | |
| CGeomInt_TheMultiLineToolOfWLApprox | |
| CGeomInt_ThePrmPrmSvSurfacesOfWLApprox | |
| CGeomInt_TheZerImpFuncOfTheImpPrmSvSurfacesOfWLApprox | |
| CGeomInt_WLApprox | |
| CGeomLib | Geom Library. This package provides an implementation of functions for basic computation on geometric entity from packages Geom and Geom2d |
| CGeomLib_Check2dBSplineCurve | Checks for the end tangents : whether or not those are reversed |
| CGeomLib_CheckBSplineCurve | Checks for the end tangents : whether or not those are reversed regarding the third or n-3rd control |
| CGeomLib_CheckCurveOnSurface | Computes the max distance between 3D-curve and 2D-curve in some surface |
| CGeomLib_DenominatorMultiplier | This defines an evaluator for a function of 2 variables that will be used by CancelDenominatorDerivative in one direction |
| CGeomLib_Interpolate | This class is used to construct a BSpline curve by interpolation of points at given parameters. The continuity of the curve is degree - 1 and the method used when boundary conditions are not given is to use odd degrees and null the derivatives on both sides from degree -1 down to (degree+1) / 2 When even degree is given the returned curve is of degree - 1 so that the degree of the curve is odd |
| CGeomLib_IsPlanarSurface | Find if a surface is a planar surface |
| CGeomLib_LogSample | |
| CGeomLib_MakeCurvefromApprox | This class is used to construct the BSpline curve from an Approximation (ApproxAFunction from AdvApprox) |
| CGeomLib_PolyFunc | Polynomial Function |
| CGeomLib_Tool | Provides various methods with Geom2d and Geom curves and surfaces. The methods of this class compute the parameter(s) of a given point on a curve or a surface. To get the valid result the point must be located rather close to the curve (surface) or at least to allow getting unambiguous result (do not put point at center of circle...), but choice of "trust" distance between curve/surface and point is responsibility of user (parameter MaxDist). Return FALSE if the point is beyond the MaxDist limit or if computation fails |
| CGeomliteTest | This package provides elementary commands for curves and surface |
| CGeomLProp | These global functions compute the degree of continuity of a 3D curve built by concatenation of two other curves (or portions of curves) at their junction point |
| CGeomLProp_CLPropsBase | Implementation class for computing local properties of a curve: point, derivatives up to order 3, tangent, curvature, normal, and centre of curvature. Parameterized by geometric types (Pnt/Vec/Dir) and curve type |
| CGeomLProp_CurAndInf2d | An algorithm for computing local properties of a curve. These properties include: |
| CGeomLProp_SLPropsBase | Template class for computing local properties of a 3D surface: point, first and second derivatives, tangent directions, normal, and curvature analysis (max, min, mean, Gaussian) |
| CGeomPlate_Aij | A structure containing indexes of two normals and its cross product |
| CGeomPlate_BuildAveragePlane | This class computes an average inertial plane with an array of points. Computes the initial surface (average plane) in the cases when the initial surface is not given |
| CGeomPlate_BuildPlateSurface | This class provides an algorithm for constructing such a plate surface that it conforms to given curve and/or point constraints. The algorithm accepts or constructs an initial surface and looks for a deformation of it satisfying the constraints and minimizing energy input. A BuildPlateSurface object provides a framework for: |
| CGeomPlate_CurveConstraint | Defines curves as constraints to be used to deform a surface |
| CGeomPlate_MakeApprox | Allows you to convert a GeomPlate surface into a BSpline |
| CGeomPlate_PlateG0Criterion | This class contains a specific G0 criterion for GeomPlate_MakeApprox |
| CGeomPlate_PlateG1Criterion | This class contains a specific G1 criterion for GeomPlate_MakeApprox |
| CGeomPlate_PointConstraint | Defines points as constraints to be used to deform a surface |
| CGeomPlate_Surface | Describes the characteristics of plate surface objects returned by BuildPlateSurface::Surface. These can be used to verify the quality of the resulting surface before approximating it to a Geom_BSpline surface generated by MakeApprox. This proves necessary in cases where you want to use the resulting surface as the support for a shape. The algorithmically generated surface cannot fill this function as is, and as a result must be converted first |
| CGeomProjLib | Projection of a curve on a surface |
| CGeomToIGES_GeomCurve | This class implements the transfer of the Curve Entity from Geom To IGES. These can be: Curve . BoundedCurve |
| CGeomToIGES_GeomEntity | Methods to transfer Geom entity from CASCADE to IGES |
| CGeomToIGES_GeomPoint | This class implements the transfer of the Point Entity from Geom to IGES. These are: . Point |
| CGeomToIGES_GeomSurface | This class implements the transfer of the Surface Entity from Geom To IGES. These can be: . BoundedSurface |
| CGeomToIGES_GeomVector | This class implements the transfer of the Vector from Geom to IGES. These can be: . Vector |
| CGeomTools | The GeomTools package provides utilities for Geometry |
| CGeomTools_Curve2dSet | Stores a set of Curves from Geom2d |
| CGeomTools_CurveSet | Stores a set of Curves from Geom |
| CGeomTools_SurfaceSet | Stores a set of Surfaces from Geom |
| CGeomTools_UndefinedTypeHandler | |
| CGeomToStep_MakeAxis1Placement | This class implements the mapping between classes Axis1Placement from Geom and Ax1 from gp, and the class Axis1Placement from StepGeom which describes an Axis1Placement from Prostep |
| CGeomToStep_MakeAxis2Placement2d | This class implements the mapping between classes Axis2Placement from Geom and Ax2, Ax22d from gp, and the class Axis2Placement2d from StepGeom which describes an axis2_placement_2d from Prostep |
| CGeomToStep_MakeAxis2Placement3d | This class implements the mapping between classes Axis2Placement from Geom and Ax2, Ax3 from gp, and the class Axis2Placement3d from StepGeom which describes an axis2_placement_3d from Prostep |
| CGeomToStep_MakeBoundedCurve | This class implements the mapping between classes BoundedCurve from Geom, Geom2d and the class BoundedCurve from StepGeom which describes a BoundedCurve from prostep. As BoundedCurve is an abstract BoundedCurve this class is an access to the sub-class required |
| CGeomToStep_MakeBoundedSurface | This class implements the mapping between classes BoundedSurface from Geom and the class BoundedSurface from StepGeom which describes a BoundedSurface from prostep. As BoundedSurface is an abstract BoundedSurface this class is an access to the sub-class required |
| CGeomToStep_MakeBSplineCurveWithKnots | This class implements the mapping between classes BSplineCurve from Geom, Geom2d and the class BSplineCurveWithKnots from StepGeom which describes a bspline_curve_with_knots from Prostep |
| CGeomToStep_MakeBSplineCurveWithKnotsAndRationalBSplineCurve | This class implements the mapping between classes BSplineCurve from Geom, Geom2d and the class BSplineCurveWithKnotsAndRationalBSplineCurve from StepGeom which describes a rational_bspline_curve_with_knots from Prostep |
| CGeomToStep_MakeBSplineSurfaceWithKnots | This class implements the mapping between class BSplineSurface from Geom and the class BSplineSurfaceWithKnots from StepGeom which describes a bspline_Surface_with_knots from Prostep |
| CGeomToStep_MakeBSplineSurfaceWithKnotsAndRationalBSplineSurface | This class implements the mapping between class BSplineSurface from Geom and the class BSplineSurfaceWithKnotsAndRationalBSplineSurface from StepGeom which describes a rational_bspline_Surface_with_knots from Prostep |
| CGeomToStep_MakeCartesianPoint | This class implements the mapping between classes CartesianPoint from Geom and Pnt from gp, and the class CartesianPoint from StepGeom which describes a point from Prostep |
| CGeomToStep_MakeCartesianTransformationOperator | This class creates a cartesian_transformation_operator from gp_Trsf. This entity is used in OCCT to implement a transformation with scaling. In case of other inputs without scaling use Axis2Placement3d |
| CGeomToStep_MakeCircle | This class implements the mapping between classes Circle from Geom, and Circ from gp, and the class Circle from StepGeom which describes a circle from Prostep |
| CGeomToStep_MakeConic | This class implements the mapping between classes Conic from Geom and the class Conic from StepGeom which describes a Conic from prostep. As Conic is an abstract Conic this class is an access to the sub-class required |
| CGeomToStep_MakeConicalSurface | This class implements the mapping between class ConicalSurface from Geom and the class ConicalSurface from StepGeom which describes a conical_surface from Prostep |
| CGeomToStep_MakeCurve | This class implements the mapping between classes Curve from Geom and the class Curve from StepGeom which describes a Curve from prostep. As Curve is an abstract curve this class an access to the sub-class required |
| CGeomToStep_MakeCylindricalSurface | This class implements the mapping between class CylindricalSurface from Geom and the class CylindricalSurface from StepGeom which describes a cylindrical_surface from Prostep |
| CGeomToStep_MakeDirection | This class implements the mapping between classes Direction from Geom, Geom2d and Dir, Dir2d from gp, and the class Direction from StepGeom which describes a direction from Prostep |
| CGeomToStep_MakeElementarySurface | This class implements the mapping between classes ElementarySurface from Geom and the class ElementarySurface from StepGeom which describes a ElementarySurface from prostep. As ElementarySurface is an abstract Surface this class is an access to the sub-class required |
| CGeomToStep_MakeEllipse | This class implements the mapping between classes Ellipse from Geom, and Circ from gp, and the class Ellipse from StepGeom which describes a Ellipse from Prostep |
| CGeomToStep_MakeHyperbola | This class implements the mapping between the class Hyperbola from Geom and the class Hyperbola from StepGeom which describes a Hyperbola from ProSTEP |
| CGeomToStep_MakeLine | This class implements the mapping between classes Line from Geom and Lin from gp, and the class Line from StepGeom which describes a line from Prostep |
| CGeomToStep_MakeParabola | This class implements the mapping between the class Parabola from Geom and the class Parabola from StepGeom which describes a Parabola from ProSTEP |
| CGeomToStep_MakePlane | This class implements the mapping between classes Plane from Geom and Pln from gp, and the class Plane from StepGeom which describes a plane from Prostep |
| CGeomToStep_MakePolyline | This class implements the mapping between an Array1 of points from gp and a Polyline from StepGeom |
| CGeomToStep_MakeRectangularTrimmedSurface | This class implements the mapping between class RectangularTrimmedSurface from Geom and the class RectangularTrimmedSurface from StepGeom which describes a rectangular_trimmed_surface from ISO-IS 10303-42 |
| CGeomToStep_MakeSphericalSurface | This class implements the mapping between class SphericalSurface from Geom and the class SphericalSurface from StepGeom which describes a spherical_surface from Prostep |
| CGeomToStep_MakeSurface | This class implements the mapping between classes Surface from Geom and the class Surface from StepGeom which describes a Surface from prostep. As Surface is an abstract Surface this class is an access to the sub-class required |
| CGeomToStep_MakeSurfaceOfLinearExtrusion | This class implements the mapping between class SurfaceOfLinearExtrusion from Geom and the class SurfaceOfLinearExtrusion from StepGeom which describes a surface_of_linear_extrusion from Prostep |
| CGeomToStep_MakeSurfaceOfRevolution | This class implements the mapping between class SurfaceOfRevolution from Geom and the class SurfaceOfRevolution from StepGeom which describes a surface_of_revolution from Prostep |
| CGeomToStep_MakeSweptSurface | This class implements the mapping between classes SweptSurface from Geom and the class SweptSurface from StepGeom which describes a SweptSurface from prostep. As SweptSurface is an abstract SweptSurface this class is an access to the sub-class required |
| CGeomToStep_MakeToroidalSurface | This class implements the mapping between class ToroidalSurface from Geom and the class ToroidalSurface from StepGeom which describes a toroidal_surface from Prostep |
| CGeomToStep_MakeVector | This class implements the mapping between classes Vector from Geom, Geom2d and Vec, Vec2d from gp, and the class Vector from StepGeom which describes a Vector from Prostep |
| CGeomToStep_Root | This class implements the common services for all classes of GeomToStep which report error |
| Cgp | The geometric processor package, called gp, provides an implementation of entities used: . for algebraic calculation such as "XYZ" coordinates, "Mat" matrix . for basis analytic geometry such as Transformations, point, vector, line, plane, axis placement, conics, and elementary surfaces. These entities are defined in 2d and 3d space. All the classes of this package are non-persistent. This is a utility class that cannot be instantiated |
| Cgp_Ax1 | Describes an axis in 3D space. An axis is defined by: |
| Cgp_Ax2 | Describes a right-handed coordinate system in 3D space. A coordinate system is defined by: |
| Cgp_Ax22d | Describes a coordinate system in a plane (2D space). A coordinate system is defined by: |
| Cgp_Ax2d | Describes an axis in the plane (2D space). An axis is defined by: |
| Cgp_Ax3 | Describes a coordinate system in 3D space. Unlike a gp_Ax2 coordinate system, a gp_Ax3 can be right-handed ("direct sense") or left-handed ("indirect sense"). A coordinate system is defined by: |
| Cgp_Circ | Describes a circle in 3D space. A circle is defined by its radius and positioned in space with a coordinate system (a gp_Ax2 object) as follows: |
| Cgp_Circ2d | Describes a circle in the plane (2D space). A circle is defined by its radius and positioned in the plane with a coordinate system (a gp_Ax22d object) as follows: |
| Cgp_Cone | Defines an infinite conical surface. A cone is defined by its half-angle (can be negative) at the apex and positioned in space with a coordinate system (a gp_Ax3 object) and a "reference radius" where: |
| Cgp_Cylinder | Describes an infinite cylindrical surface. A cylinder is defined by its radius and positioned in space with a coordinate system (a gp_Ax3 object), the "main
Axis" of which is the axis of the cylinder. This coordinate system is the "local coordinate system" of the cylinder. Note: when a gp_Cylinder cylinder is converted into a Geom_CylindricalSurface cylinder, some implicit properties of its local coordinate system are used explicitly: |
| Cgp_Dir | Describes a unit vector in 3D space. This unit vector is also called "Direction". See Also gce_MakeDir which provides functions for more complex unit vector constructions Geom_Direction which provides additional functions for constructing unit vectors and works, in particular, with the parametric equations of unit vectors |
| Cgp_Dir2d | Describes a unit vector in the plane (2D space). This unit vector is also called "Direction". See Also gce_MakeDir2d which provides functions for more complex unit vector constructions Geom2d_Direction which provides additional functions for constructing unit vectors and works, in particular, with the parametric equations of unit vectors |
| Cgp_Elips | Describes an ellipse in 3D space. An ellipse is defined by its major and minor radii and positioned in space with a coordinate system (a gp_Ax2 object) as follows: |
| Cgp_Elips2d | Describes an ellipse in the plane (2D space). An ellipse is defined by its major and minor radii and positioned in the plane with a coordinate system (a gp_Ax22d object) as follows: |
| Cgp_GTrsf | Defines a non-persistent transformation in 3D space. This transformation is a general transformation. It can be a gp_Trsf, an affinity, or you can define your own transformation giving the matrix of transformation |
| Cgp_GTrsf2d | Defines a non persistent transformation in 2D space. This transformation is a general transformation. It can be a gp_Trsf2d, an affinity, or you can define your own transformation giving the corresponding matrix of transformation |
| Cgp_Hypr | Describes a branch of a hyperbola in 3D space. A hyperbola is defined by its major and minor radii and positioned in space with a coordinate system (a gp_Ax2 object) of which: |
| Cgp_Hypr2d | Describes a branch of a hyperbola in the plane (2D space). A hyperbola is defined by its major and minor radii, and positioned in the plane with a coordinate system (a gp_Ax22d object) of which: |
| Cgp_Lin | Describes a line in 3D space. A line is positioned in space with an axis (a gp_Ax1 object) which gives it an origin and a unit vector. A line and an axis are similar objects, thus, we can convert one into the other. A line provides direct access to the majority of the edit and query functions available on its positioning axis. In addition, however, a line has specific functions for computing distances and positions. See Also gce_MakeLin which provides functions for more complex line constructions Geom_Line which provides additional functions for constructing lines and works, in particular, with the parametric equations of lines |
| Cgp_Lin2d | Describes a line in 2D space. A line is positioned in the plane with an axis (a gp_Ax2d object) which gives the line its origin and unit vector. A line and an axis are similar objects, thus, we can convert one into the other. A line provides direct access to the majority of the edit and query functions available on its positioning axis. In addition, however, a line has specific functions for computing distances and positions. See Also GccAna and Geom2dGcc packages which provide functions for constructing lines defined by geometric constraints gce_MakeLin2d which provides functions for more complex line constructions Geom2d_Line which provides additional functions for constructing lines and works, in particular, with the parametric equations of lines |
| Cgp_Mat | Describes a three column, three row matrix. This sort of object is used in various vectorial or matrix computations |
| Cgp_Mat2d | Describes a two column, two row matrix. This sort of object is used in various vectorial or matrix computations |
| Cgp_Parab | Describes a parabola in 3D space. A parabola is defined by its focal length (that is, the distance between its focus and apex) and positioned in space with a coordinate system (a gp_Ax2 object) where: |
| Cgp_Parab2d | Describes a parabola in the plane (2D space). A parabola is defined by its focal length (that is, the distance between its focus and apex) and positioned in the plane with a coordinate system (a gp_Ax22d object) where: |
| Cgp_Pln | Describes a plane. A plane is positioned in space with a coordinate system (a gp_Ax3 object), such that the plane is defined by the origin, "X Direction" and "Y Direction" of this coordinate system, which is the "local coordinate system" of the plane. The "main Direction" of the coordinate system is a vector normal to the plane. It gives the plane an implicit orientation such that the plane is said to be "direct", if the coordinate system is right-handed, or "indirect" in the other case. Note: when a gp_Pln plane is converted into a Geom_Plane plane, some implicit properties of its local coordinate system are used explicitly: |
| Cgp_Pnt | Defines a 3D cartesian point |
| Cgp_Pnt2d | Defines a non-persistent 2D cartesian point |
| Cgp_Quaternion | Represents operation of rotation in 3d space as quaternion and implements operations with rotations basing on quaternion mathematics |
| Cgp_QuaternionNLerp | Class perform linear interpolation (approximate rotation interpolation), result quaternion nonunit, its length lay between. sqrt(2)/2 and 1.0 |
| Cgp_QuaternionSLerp | Perform Spherical Linear Interpolation of the quaternions, return unit length quaternion |
| Cgp_Sphere | Describes a sphere. A sphere is defined by its radius and positioned in space with a coordinate system (a gp_Ax3 object). The origin of the coordinate system is the center of the sphere. This coordinate system is the "local coordinate system" of the sphere. Note: when a gp_Sphere sphere is converted into a Geom_SphericalSurface sphere, some implicit properties of its local coordinate system are used explicitly: |
| Cgp_Torus | Describes a torus. A torus is defined by its major and minor radii and positioned in space with a coordinate system (a gp_Ax3 object) as follows: |
| Cgp_Trsf | Defines a non-persistent transformation in 3D space. The following transformations are implemented : . Translation, Rotation, Scale . Symmetry with respect to a point, a line, a plane. Complex transformations can be obtained by combining the previous elementary transformations using the method Multiply. The transformations can be represented as follow : |
| Cgp_Trsf2d | Defines a non-persistent transformation in 2D space. The following transformations are implemented : |
| Cgp_Vec | Defines a non-persistent vector in 3D space |
| Cgp_Vec2d | Defines a non-persistent vector in 2D space |
| Cgp_XY | This class describes a cartesian coordinate entity in 2D space {X,Y}. This class is non persistent. This entity used for algebraic calculation. An XY can be transformed with a Trsf2d or a GTrsf2d from package gp. It is used in vectorial computations or for holding this type of information in data structures |
| Cgp_XYZ | This class describes a cartesian coordinate entity in 3D space {X,Y,Z}. This entity is used for algebraic calculation. This entity can be transformed with a "Trsf" or a "GTrsf" from package "gp". It is used in vectorial computations or for holding this type of information in data structures |
| CGProp | This package defines algorithms to compute the global properties of a set of points, a curve, a surface, a solid (non infinite region of space delimited with geometric entities), a compound geometric system (heterogeneous composition of the previous entities) |
| CGProp_CelGProps | Computes the global properties of bounded curves in 3D space. Supports elementary curves from the gp package: Lin, Circ, Elips, Parab |
| CGProp_GProps | Implements a general mechanism to compute the global properties of a "compound geometric system" in 3D space by composition of the global properties of elementary geometric entities such as a curve, surface, solid, or set of points. It is also possible to compose the properties of several "compound geometric systems" |
| CGProp_PEquation | Analyzes a collection of 3D points to decide whether they are coincident, collinear, coplanar, or span 3D space, within a given tolerance |
| CGProp_PGProps | Computes global properties (mass, barycentre, inertia matrix) of a weighted set of 3D points |
| CGProp_PrincipalProps | A framework to present the principal properties of inertia of a system of which global properties are computed by a GProp_GProps object. There is always a set of axes for which the products of inertia of a geometric system are equal to 0; i.e. the matrix of inertia of the system is diagonal. These axes are the principal axes of inertia. Their origin is coincident with the center of mass of the system. The associated moments are called the principal moments of inertia. This sort of presentation object is created, filled and returned by the function PrincipalProperties for any GProp_GProps object, and can be queried to access the result. Note: The system whose principal properties of inertia are returned by this framework is referred to as the current system. The current system, however, is retained neither by this presentation framework nor by the GProp_GProps object which activates it |
| CGProp_SelGProps | Computes the global properties of a bounded elementary surface in 3D (surfaces from the gp package: Cylinder, Cone, Sphere, Torus) |
| CGProp_VelGProps | Computes the global properties and the volume of a geometric solid (3D closed region of space). Supports elementary solids from the gp package: Cylinder, Cone, Sphere, Torus |
| CGraphic3d_ArrayOfPoints | Contains points array definition |
| CGraphic3d_ArrayOfPolygons | Contains polygons array definition. WARNING! Polygon primitives might be unsupported by graphics library. Triangulation should be used instead of quads for better compatibility |
| CGraphic3d_ArrayOfPolylines | Contains polylines array definition |
| CGraphic3d_ArrayOfPrimitives | This class furnish services to defined and fill an array of primitives which can be passed directly to graphics rendering API |
| CGraphic3d_ArrayOfQuadrangles | Contains quadrangles array definition. WARNING! Quadrangle primitives might be unsupported by graphics library. Triangulation should be used instead of quads for better compatibility |
| CGraphic3d_ArrayOfQuadrangleStrips | Contains quadrangles strip array definition. WARNING! Quadrangle primitives might be unsupported by graphics library. Triangulation should be used instead of quads for better compatibility |
| CGraphic3d_ArrayOfSegments | Contains segments array definition |
| CGraphic3d_ArrayOfTriangleFans | Contains triangles fan array definition |
| CGraphic3d_ArrayOfTriangles | Contains triangles array definition |
| CGraphic3d_ArrayOfTriangleStrips | Contains triangles strip array definition |
| CGraphic3d_AspectFillArea3d | This class defines graphic attributes for opaque 3d primitives (polygons, triangles, quadrilaterals) |
| CGraphic3d_AspectLine3d | Creates and updates a group of attributes for 3d line primitives. This group contains the color, the type of line, and its thickness |
| CGraphic3d_AspectMarker3d | Creates and updates an attribute group for marker type primitives. This group contains the type of marker, its color, and its scale factor |
| CGraphic3d_Aspects | This class defines graphic attributes |
| CGraphic3d_AspectText3d | Creates and updates a group of attributes for text primitives |
| CGraphic3d_AttribBuffer | Buffer of vertex attributes. This class is intended for advanced usage allowing invalidation of entire buffer content or its sub-part |
| CGraphic3d_Attribute | Vertex attribute definition |
| CGraphic3d_BoundBuffer | Bounds buffer |
| CGraphic3d_BSDF | Describes material's BSDF (Bidirectional Scattering Distribution Function) used for physically-based rendering (in path tracing engine). BSDF is represented as weighted mixture of basic BRDFs/BTDFs (Bidirectional Reflectance (Transmittance) Distribution Functions) |
| CGraphic3d_Buffer | Buffer of vertex attributes |
| CGraphic3d_BufferRange | Range of values defined as Start + Length pair |
| CGraphic3d_BvhCStructureSet | Set of OpenGl_Structures for building BVH tree |
| CGraphic3d_BvhCStructureSetTrsfPers | Set of transformation persistent OpenGl_Structure for building BVH tree. Provides built-in mechanism to invalidate tree when world view projection state changes. Due to frequent invalidation of BVH tree the choice of BVH tree builder is made in favor of BVH linear builder (quick rebuild) |
| CGraphic3d_Camera | Forward declaration |
| CGraphic3d_CameraTile | Class defines the area (Tile) inside a view |
| CGraphic3d_CLight | Generic light source definition. This class defines arbitrary light source - see Graphic3d_TypeOfLightSource enumeration. Some parameters are applicable only to particular light type; calling methods unrelated to current type will throw an exception |
| CGraphic3d_ClipPlane | Container for properties describing either a Clipping halfspace (single Clipping Plane), or a chain of Clipping Planes defining logical AND (conjunction) operation. The plane equation is specified in "world" coordinate system |
| CGraphic3d_CStructure | Low-level graphic structure interface |
| CSubclassStructIterator | Auxiliary wrapper to iterate through structure list |
| CSubclassGroupIterator | Auxiliary wrapper to iterate through group sequence |
| CGraphic3d_CubeMap | Base class for cubemaps. It is iterator over cubemap sides |
| CGraphic3d_CubeMapOrder | Graphic3d_CubeMapOrder maps sides of cubemap on tiles in packed cubemap image to support different tiles order in such images. Also it can be considered as permutation of numbers from 0 to 5. It stores permutation in one integer as convolution |
| CGraphic3d_CubeMapPacked | Class is intended to process cubemap packed into single image plane |
| CGraphic3d_CubeMapSeparate | Class to manage cubemap located in six different images |
| CGraphic3d_CullingTool | Graphic3d_CullingTool class provides a possibility to store parameters of view volume, such as its vertices and equations, and contains methods detecting if given AABB overlaps view volume |
| CCullingContext | Auxiliary structure holding non-persistent culling options |
| CPlane | Auxiliary structure representing 3D plane |
| CGraphic3d_CView | Base class of a graphical view that carries out rendering process for a concrete implementation of graphical driver. Provides virtual interfaces for redrawing its contents, management of displayed structures and render settings. The source code of the class itself implements functionality related to management of computed (HLR or "view-dependent") structures |
| CGraphic3d_DataStructureManager | This class allows the definition of a manager to which the graphic objects are associated. It allows them to be globally manipulated. It defines the global attributes |
| CGraphic3d_Flipper | CPU-side analogue of OpenGl_Flipper used by the selection pipeline. Describes a reference coordinate system used at draw time to mirror group contents so that they remain upright relative to the camera. The same logic is used here to compute the flipping matrix applied to bounding boxes and sensitive frustums, so that selection matches the rendered geometry |
| CGraphic3d_FrameStats | Class storing the frame statistics |
| CGraphic3d_FrameStatsData | Data frame definition |
| CGraphic3d_FrameStatsDataTmp | Temporary data frame definition |
| CGraphic3d_Fresnel | Describes Fresnel reflectance parameters |
| CGraphic3d_GraduatedTrihedron | Defines the class of a graduated trihedron. It contains main style parameters for implementation of graduated trihedron |
| CAxisAspect | Class that stores style for one graduated trihedron axis such as colors, lengths and customization flags. It is used in Graphic3d_GraduatedTrihedron |
| CGraphic3d_GraphicDriver | This class allows the definition of a graphic driver for 3d interface (currently only OpenGl driver is used) |
| CGraphic3d_GraphicDriverFactory | This class for creation of Graphic3d_GraphicDriver |
| CGraphic3d_Group | This class allows the definition of groups of primitives inside of graphic objects (presentations). A group contains the primitives and attributes for which the range is limited to this group. The primitives of a group can be globally suppressed |
| CGraphic3d_HatchStyle | A class that provides an API to use standard OCCT hatch styles defined in Aspect_HatchStyle enum or to create custom styles from a user-defined bitmap |
| CGraphic3d_IndexBuffer | Index buffer |
| CGraphic3d_Layer | Presentations list sorted within priorities |
| CGraphic3d_LightSet | Class defining the set of light sources |
| CIterator | Iterator through light sources |
| CGraphic3d_MarkerImage | This class is used to store bitmaps and images for markers rendering. It can convert bitmap texture stored in NCollection_HArray1<uint8_t> to Image_PixMap and vice versa |
| CGraphic3d_MaterialAspect | This class allows the definition of the type of a surface. Aspect attributes of a 3d face. Keywords: Material, FillArea, Shininess, Ambient, Color, Diffuse, Specular, Transparency, Emissive, ReflectionMode, BackFace, FrontFace, Reflection, Absorption |
| CGraphic3d_MediaTexture | Texture adapter for Media_Frame |
| CGraphic3d_MediaTextureSet | Texture adapter for Media_Frame |
| CGraphic3d_MutableIndexBuffer | Mutable index buffer |
| CGraphic3d_PBRMaterial | Class implementing Metallic-Roughness physically based material definition |
| CGraphic3d_PolygonOffset | Polygon offset parameters |
| CGraphic3d_PresentationAttributes | Class defines presentation properties |
| CGraphic3d_RenderingParams | Helper class to store rendering parameters |
| CGraphic3d_SequenceOfHClipPlane | Class defines a Clipping Volume as a logical OR (disjunction) operation between Graphic3d_ClipPlane in sequence. Each Graphic3d_ClipPlane represents either a single Plane clipping a halfspace (direction is specified by normal), or a sub-chain of planes defining a logical AND (conjunction) operation. Therefore, this collection allows defining a Clipping Volume through the limited set of Boolean operations between clipping Planes |
| CIterator | Iterator through clipping planes |
| CGraphic3d_ShaderAttribute | Describes custom vertex shader attribute |
| CGraphic3d_ShaderManager | This class is responsible for generation of shader programs |
| CGraphic3d_ShaderObject | Forward declaration |
| CShaderVariable | Structure defining shader uniform or in/out variable |
| CGraphic3d_ShaderProgram | List of shader objects |
| CGraphic3d_ShaderVariable | Describes custom uniform shader variable |
| CGraphic3d_Structure | This class allows the definition a graphic object. This graphic structure can be displayed, erased, or highlighted. This graphic structure can be connected with another graphic structure |
| CGraphic3d_StructureManager | This class allows the definition of a manager to which the graphic objects are associated. It allows them to be globally manipulated. It defines the global attributes. Keywords: Structure, Structure Manager, Update Mode, Destroy, Highlight, Visible |
| CGraphic3d_Text | This class allows the definition of a text object for display. The text might be defined in one of ways, using: |
| CGraphic3d_Texture1D | This is an abstract class for managing 1D textures |
| CGraphic3d_Texture1Dmanual | This class provides the implementation of a manual 1D texture. you MUST provide texture coordinates on your facets if you want to see your texture |
| CGraphic3d_Texture1Dsegment | This class provides the implementation of a 1D texture applicable along a segment. You might use the SetSegment() method to set the way the texture is "stretched" on facets |
| CGraphic3d_Texture2D | This abstract class for managing 2D textures |
| CGraphic3d_Texture2Dplane | This class allows the management of a 2D texture defined from a plane equation Use the SetXXX() methods for positioning the texture as you want |
| CGraphic3d_Texture3D | This abstract class for managing 3D textures |
| CGraphic3d_TextureEnv | This class provides environment texture |
| CGraphic3d_TextureMap | This is an abstract class for managing texture applicable on polygons |
| CGraphic3d_TextureParams | This class describes texture parameters |
| CGraphic3d_TextureRoot | This is the texture root class enable the dialog with the GraphicDriver allows the loading of texture |
| CGraphic3d_TextureSet | Class holding array of textures to be mapped as a set. Textures should be defined in ascending order of texture units within the set |
| CIterator | Class for iterating texture set |
| CGraphic3d_TransformPers | Transformation Persistence definition |
| CGraphic3d_TransformPersScaledAbove | Transformation Zoom persistence with the above boundary of scale. This persistence works only when the camera scale value is below the scale value of this persistence. Otherwise, no persistence is applied |
| CGraphic3d_UniformValue | Describes specific value of custom uniform variable |
| CGraphic3d_UniformValueTypeID | Generates unique type identifier for variable value |
| CGraphic3d_UniformValueTypeID< float > | |
| CGraphic3d_UniformValueTypeID< int > | |
| CGraphic3d_UniformValueTypeID< NCollection_Mat3< float > > | |
| CGraphic3d_UniformValueTypeID< NCollection_Mat4< float > > | |
| CGraphic3d_UniformValueTypeID< NCollection_Vec2< float > > | |
| CGraphic3d_UniformValueTypeID< NCollection_Vec2< int > > | |
| CGraphic3d_UniformValueTypeID< NCollection_Vec3< float > > | |
| CGraphic3d_UniformValueTypeID< NCollection_Vec3< int > > | |
| CGraphic3d_UniformValueTypeID< NCollection_Vec4< float > > | |
| CGraphic3d_UniformValueTypeID< NCollection_Vec4< int > > | |
| CGraphic3d_ValidatedCubeMapOrder | Graphic3d_ValidatedCubeMapOrder contains completely valid order object. The only way to create this class except copy constructor is 'Validated' method of Graphic3d_CubeMapOrder. This class can initialize Graphic3d_CubeMapOrder. It is supposed to be used in case of necessity of completely valid order (in function argument as example). It helps to automate order's valid checks |
| CGraphic3d_ValueInterface | Interface for generic variable value |
| CGraphic3d_Vertex | This class represents a graphical 3D point |
| CGraphic3d_ViewAffinity | Structure display state |
| CGraphic3d_WorldViewProjState | Helper class for keeping reference on world-view-projection state. Helpful for synchronizing state of WVP dependent data structures |
| CGraphic3d_ZLayerSettings | Structure defines list of ZLayer properties |
| CHatch_Hatcher | The Hatcher is an algorithm to compute cross hatchings in a 2d plane. It is mainly dedicated to display purpose |
| CHatch_Line | Stores a Line in the Hatcher. Represented by: |
| CHatch_Parameter | Stores an intersection on a line represented by : |
| CHatchGen_Domain | |
| CHatchGen_IntersectionPoint | |
| CHatchGen_PointOnElement | |
| CHatchGen_PointOnHatching | |
| CHeaderSection | |
| CHeaderSection_FileDescription | |
| CHeaderSection_FileName | |
| CHeaderSection_FileSchema | |
| CHeaderSection_Protocol | Protocol for HeaderSection Entities It requires HeaderSection as a Resource |
| CHelixBRep_BuilderHelix | Implementation of building helix wire Values of Error Status returned by algo: 0 - OK 1 - object is just initialized, it means that no input parameters were set 2 - approximation fails |
| CHelixGeom_BuilderApproxCurve | Base class for helix curve approximation algorithms |
| CHelixGeom_BuilderHelix | Upper level class for geometrical algorithm of building helix curves using arbitrary axis |
| CHelixGeom_BuilderHelixCoil | Implementation of algorithm for building helix coil with axis OZ |
| CHelixGeom_BuilderHelixGen | Base class for helix curve building algorithms with parameter management |
| CHelixGeom_HelixCurve | Adaptor class for calculation of helix curves with analytical expressions |
| CHelixGeom_Tools | Static utility class providing approximation algorithms for helix curves |
| CHermit | This is used to reparameterize Rational BSpline Curves so that we can concatenate them later to build C1 Curves It builds and 1D-reparameterizing function starting from an Hermite interpolation and adding knots and modifying poles of the 1D BSpline obtained that way. The goal is to build a(u) so that if we consider a BSpline curve N(u) f(u) = --— D(u) |
| CHLRAlgo | In order to have the precision required in industrial design, drawings need to offer the possibility of removing lines, which are hidden in a given projection. To do this, the Hidden Line Removal component provides two algorithms: HLRBRep_Algo and HLRBRep_PolyAlgo. These algorithms remove or indicate lines hidden by surfaces. For a given projection, they calculate a set of lines characteristic of the object being represented. They are also used in conjunction with extraction utilities, which reconstruct a new, simplified shape from a selection of calculation results. This new shape is made up of edges, which represent the lines of the visualized shape in a plane. This plane is the projection plane. HLRBRep_Algo takes into account the shape itself. HLRBRep_PolyAlgo works with a polyhedral simplification of the shape. When you use HLRBRep_Algo, you obtain an exact result, whereas, when you use HLRBRep_PolyAlgo, you reduce computation time but obtain polygonal segments |
| CHLRAlgo_BiPoint | |
| CIndicesT | |
| CPointsT | |
| CHLRAlgo_Coincidence | The Coincidence class is used in an Interference to store information on the "hiding" edge |
| CHLRAlgo_EdgeIterator | |
| CHLRAlgo_EdgesBlock | An EdgesBlock is a set of Edges. It is used by the DataStructure to structure the Edges |
| CMinMaxIndices | |
| CHLRAlgo_EdgeStatus | This class describes the Hidden Line status of an Edge. It contains: |
| CHLRAlgo_Interference | |
| CHLRAlgo_Intersection | Describes an intersection on an edge to hide. Contains a parameter and a state (ON = on the face, OUT = above the face, IN = under the Face) |
| CHLRAlgo_PolyAlgo | To remove Hidden lines on Triangulations |
| CHLRAlgo_PolyData | Data structure of a set of Triangles |
| CFaceIndices | |
| CTriangle | |
| CHLRAlgo_PolyHidingData | Data structure of a set of Hiding Triangles |
| CTriangleIndices | |
| CPlaneT | |
| CHLRAlgo_PolyInternalData | To Update OutLines |
| CHLRAlgo_PolyInternalNode | To Update OutLines |
| CNodeIndices | |
| CNodeData | |
| CHLRAlgo_PolyInternalSegment | To Update OutLines |
| CHLRAlgo_PolyShellData | All the PolyData of a Shell |
| CShellIndices | |
| CHLRAlgo_Projector | Implements a projector object. To transform and project Points and Planes. This object is designed to be used in the removal of hidden lines and is returned by the Prs3d_Projector::Projector function. You define the projection of the selected shape by calling one of the following functions: |
| CHLRAlgo_TriangleData | Data structure of a triangle |
| CHLRAlgo_WiresBlock | A WiresBlock is a set of Blocks. It is used by the DataStructure to structure the Edges |
| CHLRAppli_ReflectLines | This class builds reflect lines on a shape according to the axes of view defined by user. Reflect lines are represented by edges in 3d |
| CHLRBRep | Hidden Lines Removal algorithms on the BRep DataStructure |
| CHLRBRep_Algo | Inherited from InternalAlgo to provide methods with Shape from TopoDS. A framework to compute a shape as seen in a projection plane. This is done by calculating the visible and the hidden parts of the shape. HLRBRep_Algo works with three types of entity: |
| CHLRBRep_AreaLimit | The private nested class AreaLimit represents a vertex on the Edge with the state on the left and the right |
| CHLRBRep_BCurveTool | |
| CHLRBRep_BiPnt2D | Contains the colors of a shape |
| CHLRBRep_BiPoint | Contains the colors of a shape |
| CHLRBRep_BSurfaceTool | |
| CHLRBRep_CInter | |
| CHLRBRep_CLPropsATool | |
| CHLRBRep_Curve | Defines a 2d curve by projection of a 3D curve on a plane with an optional perspective transformation |
| CHLRBRep_CurveTool | |
| CHLRBRep_Data | |
| CHLRBRep_EdgeBuilder | |
| CHLRBRep_EdgeData | |
| CHLRBRep_EdgeFaceTool | The EdgeFaceTool computes the UV coordinates at a given parameter on a Curve and a Surface. It also compute the signed curvature value in a direction at a given u,v point on a surface |
| CHLRBRep_EdgeIList | |
| CHLRBRep_EdgeInterferenceTool | Implements the methods required to instantiates the EdgeInterferenceList from HLRAlgo |
| CHLRBRep_ExactIntersectionPointOfTheIntPCurvePCurveOfCInter | |
| CHLRBRep_FaceData | |
| CHLRBRep_FaceIterator | |
| CHLRBRep_Hider | |
| CHLRBRep_HLRToShape | A framework for filtering the computation results of an HLRBRep_Algo algorithm by extraction. From the results calculated by the algorithm on a shape, a filter returns the type of edge you want to identify. You can choose any of the following types of output: |
| CHLRBRep_IntConicCurveOfCInter | |
| CHLRBRep_InterCSurf | |
| CHLRBRep_InternalAlgo | |
| CHLRBRep_Intersector | The Intersector computes 2D intersections of the projections of 3D curves. It can also computes the intersection of a 3D line and a surface |
| CHLRBRep_LineTool | The LineTool class provides class methods to access the methodes of the Line |
| CHLRBRep_MyImpParToolOfTheIntersectorOfTheIntConicCurveOfCInter | |
| CHLRBRep_PolyAlgo | To remove Hidden lines on Shapes with Triangulations. A framework to compute the shape as seen in a projection plane. This is done by calculating the visible and the hidden parts of the shape. HLRBRep_PolyAlgo works with three types of entity: |
| CHLRBRep_PolyHLRToShape | A framework for filtering the computation results of an HLRBRep_Algo algorithm by extraction. From the results calculated by the algorithm on a shape, a filter returns the type of edge you want to identify. You can choose any of the following types of output: |
| CHLRBRep_ShapeBounds | Contains a Shape and the bounds of its vertices, edges and faces in the DataStructure |
| CHLRBRep_ShapeToHLR | Compute the OutLinedShape of a Shape with an OutLiner, a Projector and create the Data Structure of a Shape |
| CHLRBRep_SLPropsATool | |
| CHLRBRep_Surface | |
| CHLRBRep_SurfaceTool | |
| CHLRBRep_TheCSFunctionOfInterCSurf | |
| CHLRBRep_TheDistBetweenPCurvesOfTheIntPCurvePCurveOfCInter | |
| CHLRBRep_TheExactInterCSurf | |
| CHLRBRep_TheIntConicCurveOfCInter | |
| CHLRBRep_TheInterferenceOfInterCSurf | |
| CHLRBRep_TheIntersectorOfTheIntConicCurveOfCInter | |
| CHLRBRep_TheIntPCurvePCurveOfCInter | |
| CHLRBRep_ThePolygon2dOfTheIntPCurvePCurveOfCInter | |
| CHLRBRep_ThePolygonOfInterCSurf | |
| CHLRBRep_ThePolygonToolOfInterCSurf | |
| CHLRBRep_ThePolyhedronOfInterCSurf | |
| CHLRBRep_ThePolyhedronToolOfInterCSurf | |
| CHLRBRep_TheProjPCurOfCInter | |
| CHLRBRep_TheQuadCurvExactInterCSurf | |
| CHLRBRep_TheQuadCurvFuncOfTheQuadCurvExactInterCSurf | |
| CHLRBRep_VertexList | |
| CHLRTest | This package is a test of the Hidden Lines algorithms instantiated on the BRep Data Structure and using the Draw package to display the results |
| CHLRTest_DrawableEdgeTool | Used to display the results |
| CHLRTest_DrawablePolyEdgeTool | Used to display the results |
| CHLRTest_OutLiner | |
| CHLRTest_Projector | Draw Variable Projector to test |
| CHLRTest_ShapeData | Contains the colors of a shape |
| CHLRTopoBRep_Data | Stores the results of the OutLine and IsoLine processes |
| CHLRTopoBRep_DSFiller | Provides methods to fill a HLRTopoBRep_Data |
| CHLRTopoBRep_FaceData | Contains the 3 ListOfShape of a Face (Internal OutLines, OutLines on restriction and IsoLines) |
| CHLRTopoBRep_FaceIsoLiner | |
| CHLRTopoBRep_OutLiner | |
| CHLRTopoBRep_VData | |
| CIFGraph_AllConnected | This class gives content of the CONNECTED COMPONENT(S) which include specific Entity(ies) |
| CIFGraph_AllShared | This class determines all Entities shared by some specific ones, at any level (those which will be lead in a Transfer for instance) |
| CIFGraph_Articulations | This class gives entities which are Articulation points in a whole Model or in a sub-part An Articulation Point divides the graph in two (or more) disconnected sub-graphs Identifying Articulation Points allows improving efficiency of splitting a set of Entities into sub-sets |
| CIFGraph_Compare | This class evaluates effect of two compared sub-parts : cumulation (union), common part (intersection-overlapping) part specific to first sub-part or to the second one Results are kept in a Graph, several question can be set Basic Iteration gives Cumulation (union) |
| CIFGraph_ConnectedComponants | Determines Connected Components in a Graph. They define disjoined sets of Entities |
| CIFGraph_Cumulate | This class evaluates effect of cumulated sub-parts : overlapping, forgotten entities Results are kept in a Graph, several question can be set Basic Iteration gives entities which are part of Cumulation |
| CIFGraph_Cycles | Determines strong components in a graph which are Cycles |
| CIFGraph_ExternalSources | This class gives entities which are Source of entities of a sub-part, but are not contained by this sub-part |
| CIFGraph_SCRoots | Determines strong components in a graph which are Roots |
| CIFGraph_StrongComponants | Determines strong components of a graph, that is isolated entities (single components) or loops |
| CIFGraph_SubPartsIterator | Defines general form for graph classes of which result is not a single iteration on Entities, but a nested one : External iteration works on sub-parts, identified by each class (according to its algorithm) Internal Iteration concerns Entities of a sub-part Sub-Parts are assumed to be disjoined; if they are not, the first one has priority |
| CIFSelect | Gives tools to manage Selecting a group of Entities processed by an Interface, for instance to divide up an original Model (from a File) to several smaller ones They use description of an Interface Model as a graph |
| CIFSelect_Act | Act gives a simple way to define and add functions to be ran from a SessionPilot, as follows : |
| CIFSelect_Activator | Defines the general frame for working with a SessionPilot. Each Activator treats a set of Commands. Commands are given as alphanumeric strings. They can be of two main forms : |
| CIFSelect_AppliedModifiers | This class allows to memorize and access to the modifiers which are to be applied to a file. To each modifier, is bound a list of integers (optional) : if this list is absent, the modifier applies to all the file. Else, it applies to the entities designated by these numbers in the produced file |
| CIFSelect_BasicDumper | BasicDumper takes into account, for SessionFile, all the classes defined in the package IFSelect : Selections, Dispatches (there is no Modifier) |
| CIFSelect_CheckCounter | A CheckCounter allows to see a CheckList (i.e. CheckIterator) not per entity, its messages, but per message, the entities attached (count and list). Because many messages can be repeated if they are due to systematic errors |
| CIFSelect_ContextModif | This class gathers various information used by Model Modifiers apart from the target model itself, and the CopyTool which must be passed directly |
| CIFSelect_ContextWrite | This class gathers various information used by File Modifiers apart from the writer object, which is specific of the norm and of the physical format |
| CIFSelect_Dispatch | This class allows to describe how a set of Entities has to be dispatched into resulting Packets : a Packet is a sub-set of the initial set of entities |
| CIFSelect_DispGlobal | A DispGlobal gathers all the input Entities into only one global Packet |
| CIFSelect_DispPerCount | A DispPerCount gathers all the input Entities into one or several Packets, each containing a defined count of Entity This count is a Parameter of the DispPerCount, given as an IntParam, thus allowing external control of its Value |
| CIFSelect_DispPerFiles | A DispPerFiles produces a determined count of Packets from the input Entities. It divides, as equally as possible, the input list into a count of files. This count is the parameter of the DispPerFiles. If the input list has less than this count, of course there will be one packet per input entity. This count is a Parameter of the DispPerFiles, given as an IntParam, thus allowing external control of its Value |
| CIFSelect_DispPerOne | A DispPerOne gathers all the input Entities into as many Packets as there Root Entities from the Final Selection, that is, one Packet per Entity |
| CIFSelect_DispPerSignature | A DispPerSignature sorts input Entities according to a Signature : it works with a SignCounter to do this |
| CIFSelect_EditForm | An EditForm is the way to apply an Editor on an Entity or on the Model It gives read-only or read-write access, with or without undo |
| CIFSelect_Editor | An Editor defines a set of values and a way to edit them, on an entity or on the model (e.g. on its header) |
| CIFSelect_Functions | Functions gives access to all the actions which can be commanded with the resources provided by IFSelect : especially WorkSession and various types of Selections and Dispatches |
| CIFSelect_GeneralModifier | This class gives a frame for Actions which modify the effect of a Dispatch, i.e. : By Selections and Dispatches, an original Model can be split into one or more "target" Models : these Models contain Entities copied from the original one (that is, a part of it). Basically, these dispatched Entities are copied as identical to their original counterparts. Also the copied Models reproduce the Header of the original one |
| CIFSelect_GraphCounter | A GraphCounter computes values to be sorted with the help of a Graph. I.E. not from a Signature |
| CIFSelect_IntParam | This class simply allows to access an Integer value through a Handle, as a String can be (by using HString). Hence, this value can be accessed : read and modified, without passing through the specific object which detains it. Thus, parameters of a Selection or a Dispatch (according its type) can be controlled directly from the ShareOut which contains them |
| CIFSelect_ListEditor | A ListEditor is an auxiliary operator for Editor/EditForm I.E. it works on parameter values expressed as strings |
| CIFSelect_ModelCopier | This class performs the Copy operations involved by the description of a ShareOut (evaluated by a ShareOutResult) plus, if there are, the Modifications on the results, with the help of Modifiers. Each Modifier can work on one or more resulting packets, according to its criteria : it operates on a Model once copied and filled with the content of the packet |
| CIFSelect_ModifEditForm | This modifier applies an EditForm on the entities selected |
| CIFSelect_Modifier | This class gives a frame for Actions which can work globally on a File once completely defined (i.e. afterwards) |
| CIFSelect_ModifReorder | This modifier reorders a whole model from its roots, i.e. according to <rootlast> status, it considers each of its roots, then it orders all its shared entities at any level, the result begins by the lower level entities ... ends by the roots |
| CIFSelect_PacketList | This class gives a simple way to return then consult a list of packets, determined from the content of a Model, by various criteria |
| CIFSelect_ParamEditor | A ParamEditor gives access for edition to a list of TypedValue (i.e. of Static too) Its definition is made of the TypedValue to edit themselves, and can add some constants, which can then be displayed but not changed (for instance, system name, processor version ...) |
| CIFSelect_SelectAnyList | A SelectAnyList kind Selection selects a List of an Entity, as well as this Entity contains some. A List contains sub-entities as one per Item, or several (for instance if an Entity binds couples of sub-entities, each item is one of these couples). Remark that only Entities are taken into account (neither Reals, nor Strings, etc...) |
| CIFSelect_SelectAnyType | A SelectAnyType sorts the Entities of which the Type is Kind of a given Type : this Type for Match is specific of each class of SelectAnyType |
| CIFSelect_SelectBase | SelectBase works directly from an InterfaceModel : it is the first base for other Selections |
| CIFSelect_SelectCombine | A SelectCombine type Selection defines algebraic operations between results of several Selections It is a deferred class : sub-classes will have to define precise what operator is to be applied |
| CIFSelect_SelectControl | A SelectControl kind Selection works with two input Selections in a dissymmetric way : the Main Input which gives an input list of Entities, to be processed, and the Second Input which gives another list, to be used to filter the main input |
| CIFSelect_SelectDeduct | A SelectDeduct determines a list of Entities from an Input Selection, by a computation : Output list is not obliged to be a sub-list of Input list (for more specific, see SelectExtract for filtered sub-lists, and SelectExplore for recurcive exploration) |
| CIFSelect_SelectDiff | A SelectDiff keeps the entities from a Selection, the Main Input, which are not listed by the Second Input |
| CIFSelect_SelectEntityNumber | A SelectEntityNumber gets in an InterfaceModel (through a Graph), the Entity which has a specified Number (its rank of adding into the Model) : there can be zero (if none) or one. The Number is not directly defined as an Integer, but as a Parameter, which can be externally controlled |
| CIFSelect_SelectErrorEntities | A SelectErrorEntities sorts the Entities which are qualified as "Error" (their Type has not been recognized) during reading a File. This does not concern Entities which are syntactically correct, but with incorrect data (for integrity constraints) |
| CIFSelect_SelectExplore | A SelectExplore determines from an input list of Entities, a list obtained by a way of exploration. This implies the possibility of recursive exploration : the output list is itself reused as input, etc... Examples : Shared Entities, can be considered at one level (immediate shared) or more, or max level |
| CIFSelect_SelectExtract | A SelectExtract determines a list of Entities from an Input Selection, as a sub-list of the Input Result It works by applying a sort criterium on each Entity of the Input. This criterium can be applied Direct to Pick Items (default case) or Reverse to Remove Item |
| CIFSelect_SelectFlag | A SelectFlag queries a flag noted in the bitmap of the Graph. The Flag is designated by its Name. Flag Names are defined by Work Session and, as necessary, other functional objects |
| CIFSelect_SelectIncorrectEntities | A SelectIncorrectEntities sorts the Entities which have been noted as Incorrect in the Graph of the Session (flag "Incorrect") It can find a result only if ComputeCheck has formerly been called on the WorkSession. Else, its result will be empty |
| CIFSelect_SelectInList | A SelectInList kind Selection selects a List of an Entity, which is composed of single Entities To know the list on which to work, SelectInList has two deferred methods : NbItems (inherited from SelectAnyList) and ListedEntity (which gives an item as an Entity) which must be defined to get a List in an Entity of the required Type (and consider that list is empty if Entity has not required Type) |
| CIFSelect_SelectIntersection | A SelectIntersection filters the Entities issued from several other Selections as Intersection of results : "AND" operator |
| CIFSelect_Selection | A Selection allows to define a set of Interface Entities. Entities to be put on an output file should be identified in a way as independent from such or such execution as possible. This permits to handle comprehensive criteria, and to replay them when a new variant of an input file has to be processed |
| CIFSelect_SelectionIterator | Defines an Iterator on a list of Selections |
| CIFSelect_SelectModelEntities | A SelectModelEntities gets all the Entities of an InterfaceModel |
| CIFSelect_SelectModelRoots | A SelectModelRoots gets all the Root Entities of an InterfaceModel. Remember that a "Root Entity" is defined as having no Sharing Entity (if there is a Loop between Entities, none of them can be a "Root") |
| CIFSelect_SelectPointed | This type of Selection is intended to describe a direct selection without an explicit criterium, for instance the result of picking viewed entities on a graphic screen |
| CIFSelect_SelectRange | A SelectRange keeps or rejects a sub-set of the input set, that is the Entities of which rank in the iteration list is in a given range (for instance form 2nd to 6th, etc...) |
| CIFSelect_SelectRootComps | A SelectRootComps sorts the Entities which are part of Strong Components, local roots of a set of Entities : they can be Single Components (containing one Entity) or Cycles This class gives a more secure result than SelectRoots (which considers only Single Components) but is longer to work : it can be used when there can be or there are cycles in a Model For each cycle, one Entity is given arbitrarily Reject works as for SelectRoots : Strong Components defined in the input list which are not local roots are given |
| CIFSelect_SelectRoots | A SelectRoots sorts the Entities which are local roots of a set of Entities (not shared by other Entities inside this set, even if they are shared by other Entities outside it) |
| CIFSelect_SelectSent | This class returns entities according sending to a file Once a model has been loaded, further sendings are recorded as status in the graph (for each value, a count of sendings) |
| CIFSelect_SelectShared | A SelectShared selects Entities which are directly Shared by the Entities of the Input list |
| CIFSelect_SelectSharing | A SelectSharing selects Entities which directly Share (Level One) the Entities of the Input list Remark : if an Entity of the Input List directly shares another one, it is of course present in the Result List |
| CIFSelect_SelectSignature | A SelectSignature sorts the Entities on a Signature Matching. The signature to match is given at creation time. Also, the required match is given at creation time : exact (IsEqual) or contains (the Type's Name must contain the criterium Text) |
| CIFSelect_SelectSignedShared | In the graph, explore the Shareds of the input entities, until it encounters some which match a given Signature (for a limited level, filters the returned list) By default, fitted for any level |
| CIFSelect_SelectSignedSharing | In the graph, explore the sharings of the input entities, until it encounters some which match a given Signature (for a limited level, filters the returned list) By default, fitted for any level |
| CIFSelect_SelectSuite | A SelectSuite can describe a suite of SelectDeduct as a unique one : in other words, it can be seen as a "macro selection" |
| CIFSelect_SelectType | A SelectType keeps or rejects Entities of which the Type is Kind of a given Cdl Type |
| CIFSelect_SelectUnion | A SelectUnion cumulates the Entities issued from several other Selections (union of results : "OR" operator) |
| CIFSelect_SelectUnknownEntities | A SelectUnknownEntities sorts the Entities which are qualified as "Unknown" (their Type has not been recognized) |
| CIFSelect_SessionDumper | A SessionDumper is called by SessionFile. It takes into account a set of classes (such as Selections, Dispatches ...). SessionFile writes the Type (as defined by cdl) of each Item and its general Parameters. It manages the names of the Items |
| CIFSelect_SessionFile | A SessionFile is intended to manage access between a WorkSession and an Ascii Form, to be considered as a Dump. It allows to write the File from the WorkSession, and later read the File to the WorkSession, by keeping required descriptions (such as dependences) |
| CIFSelect_SessionPilot | A SessionPilot is intended to make easier the use of a WorkSession. It receives commands, under alphanumeric form, then calls a library of Activators to interpret and run them |
| CIFSelect_ShareOut | This class gathers the information required to produce one or several file(s) from the content of an InterfaceModel (passing through the creation of intermediate Models) |
| CIFSelect_ShareOutResult | This class gives results computed from a ShareOut : simulation before transfer, helps to list entities ... Transfer itself will later be performed, either by a TransferCopy to simply divide up a file, or a TransferDispatch which can be parametred with more details |
| CIFSelect_SignAncestor | |
| CIFSelect_Signature | Signature provides the basic service used by the classes SelectSignature and Counter (i.e. Name, Value), which is : |
| CIFSelect_SignatureList | A SignatureList is given as result from a Counter (any kind) It gives access to a list of signatures, with counts, and optionally with list of corresponding entities |
| CIFSelect_SignCategory | This Signature returns the Category of an entity, as recorded in the model |
| CIFSelect_SignCounter | SignCounter gives the frame to count signatures associated with entities, deducted from them. Ex.: their Dynamic Type |
| CIFSelect_SignMultiple | Multiple Signature : ordered list of other Signatures It concatenates on a same line the result of its sub-items separated by sets of 3 blanks It is possible to define tabulations between sub-items Moreover, match rules are specific |
| CIFSelect_SignType | This Signature returns the cdl Type of an entity, under two forms : |
| CIFSelect_SignValidity | This Signature returns the Validity Status of an entity, as deducted from data in the model : it can be "OK" "Unknown" "Unloaded" "Syntactic Fail"(but loaded) "Syntactic Warning" "Semantic Fail" "Semantic Warning" |
| CIFSelect_Transformer | A Transformer defines the way an InterfaceModel is transformed (without sending it to a file). In order to work, each type of Transformer defines it method Perform, it can be parametred as needed |
| CIFSelect_TransformStandard | This class runs transformations made by Modifiers, as the ModelCopier does when it produces files (the same set of Modifiers can then be used, as to transform the starting Model, as at file sending time) |
| CIFSelect_WorkLibrary | This class defines the (empty) frame which can be used to enrich a XSTEP set with new capabilities In particular, a specific WorkLibrary must give the way for Reading a File into a Model, and Writing a Model to a File Thus, it is possible to define several Work Libraries for each norm, but recommended to define one general class for each one : this general class will define the Read and Write methods |
| CIFSelect_WorkSession | This class can be used to simply manage a process such as splitting a file, extracting a set of Entities ... It allows to manage different types of Variables : Integer or Text Parameters, Selections, Dispatches, in addition to a ShareOut. To each of these variables, a unique Integer Identifier is attached. A Name can be attached too as desired |
| CIGESAppli | This package represents collection of miscellaneous entities from IGES |
| CIGESAppli_DrilledHole | Defines DrilledHole, Type <406> Form <6> in package IGESAppli Identifies an entity representing a drilled hole through a printed circuit board |
| CIGESAppli_ElementResults | Defines ElementResults, Type <148> in package IGESAppli Used to find the results of FEM analysis |
| CIGESAppli_FiniteElement | Defines FiniteElement, Type <136> Form <0> in package IGESAppli Used to define a finite element with the help of an element topology |
| CIGESAppli_Flow | Defines Flow, Type <402> Form <18> in package IGESAppli Represents a single signal or a single fluid flow path starting from a starting Connect Point Entity and including additional intermediate connect points |
| CIGESAppli_FlowLineSpec | Defines FlowLineSpec, Type <406> Form <14> in package IGESAppli Attaches one or more text strings to entities being used to represent a flow line |
| CIGESAppli_GeneralModule | Definition of General Services for IGESAppli (specific part) This Services comprise : Shared & Implied Lists, Copy, Check |
| CIGESAppli_LevelFunction | Defines LevelFunction, Type <406> Form <3> in package IGESAppli Used to transfer the meaning or intended use of a level in the sending system |
| CIGESAppli_LevelToPWBLayerMap | Defines LevelToPWBLayerMap, Type <406> Form <24> in package IGESAppli Used to correlate an exchange file level number with its corresponding native level identifier, physical PWB layer number and predefined functional level identification |
| CIGESAppli_LineWidening | Defines LineWidening, Type <406> Form <5> in package IGESAppli Defines the characteristics of entities when they are used to define locations of items |
| CIGESAppli_NodalConstraint | Defines NodalConstraint, Type <418> Form <0> in package IGESAppli Relates loads and/or constraints to specific nodes in the Finite Element Model by creating a relation between Node entities and Tabular Data Property that contains the load or constraint data |
| CIGESAppli_NodalDisplAndRot | Defines NodalDisplAndRot, Type <138> Form <0> in package IGESAppli Used to communicate finite element post processing data |
| CIGESAppli_NodalResults | Defines NodalResults, Type <146> in package IGESAppli Used to store the Analysis Data results per FEM Node |
| CIGESAppli_Node | Defines Node, Type <134> Form <0> in package IGESAppli Geometric point used in the definition of a finite element |
| CIGESAppli_PartNumber | Defines PartNumber, Type <406> Form <9> in package IGESAppli Attaches a set of text strings that define the common part numbers to an entity being used to represent a physical component |
| CIGESAppli_PinNumber | Defines PinNumber, Type <406> Form <8> in package IGESAppli Used to attach a text string representing a component pin number to an entity being used to represent an electrical component's pin |
| CIGESAppli_PipingFlow | Defines PipingFlow, Type <402> Form <20> in package IGESAppli Represents a single fluid flow path |
| CIGESAppli_Protocol | Description of Protocol for IGESAppli |
| CIGESAppli_PWBArtworkStackup | Defines PWBArtworkStackup, Type <406> Form <25> in package IGESAppli Used to communicate which exchange file levels are to be combined in order to create the artwork for a printed wire board (PWB). This property should be attached to the entity defining the printed wire assembly (PWA) or if no such entity exists, then the property should stand alone in the file |
| CIGESAppli_PWBDrilledHole | Defines PWBDrilledHole, Type <406> Form <26> in package IGESAppli Used to identify an entity that locates a drilled hole and to specify the characteristics of the drilled hole |
| CIGESAppli_ReadWriteModule | Defines basic File Access Module for IGESAppli (specific parts) Specific actions concern : Read and Write Own Parameters of an IGESEntity |
| CIGESAppli_ReferenceDesignator | Defines ReferenceDesignator, Type <406> Form <7> in package IGESAppli Used to attach a text string containing the value of a component reference designator to an entity being used to represent a component |
| CIGESAppli_RegionRestriction | Defines RegionRestriction, Type <406> Form <2> in package IGESAppli Defines regions to set an application's restriction over a region |
| CIGESAppli_SpecificModule | Defines Services attached to IGES Entities : Dump & OwnCorrect, for IGESAppli |
| CIGESAppli_ToolDrilledHole | Tool to work on a DrilledHole. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule) |
| CIGESAppli_ToolElementResults | Tool to work on a ElementResults. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule) |
| CIGESAppli_ToolFiniteElement | Tool to work on a FiniteElement. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule) |
| CIGESAppli_ToolFlow | Tool to work on a Flow. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule) |
| CIGESAppli_ToolFlowLineSpec | Tool to work on a FlowLineSpec. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule) |
| CIGESAppli_ToolLevelFunction | Tool to work on a LevelFunction. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule) |
| CIGESAppli_ToolLevelToPWBLayerMap | Tool to work on a LevelToPWBLayerMap. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule) |
| CIGESAppli_ToolLineWidening | Tool to work on a LineWidening. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule) |
| CIGESAppli_ToolNodalConstraint | Tool to work on a NodalConstraint. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule) |
| CIGESAppli_ToolNodalDisplAndRot | Tool to work on a NodalDisplAndRot. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule) |
| CIGESAppli_ToolNodalResults | Tool to work on a NodalResults. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule) |
| CIGESAppli_ToolNode | Tool to work on a Node. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule) |
| CIGESAppli_ToolPartNumber | Tool to work on a PartNumber. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule) |
| CIGESAppli_ToolPinNumber | Tool to work on a PinNumber. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule) |
| CIGESAppli_ToolPipingFlow | Tool to work on a PipingFlow. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule) |
| CIGESAppli_ToolPWBArtworkStackup | Tool to work on a PWBArtworkStackup. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule) |
| CIGESAppli_ToolPWBDrilledHole | Tool to work on a PWBDrilledHole. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule) |
| CIGESAppli_ToolReferenceDesignator | Tool to work on a ReferenceDesignator. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule) |
| CIGESAppli_ToolRegionRestriction | Tool to work on a RegionRestriction. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule) |
| CIGESBasic | This package represents basic entities from IGES |
| CIGESBasic_AssocGroupType | Defines AssocGroupType, Type <406> Form <23> in package IGESBasic Used to assign an unambiguous identification to a Group Associativity |
| CIGESBasic_ExternalReferenceFile | Defines ExternalReferenceFile, Type <406> Form <12> in package IGESBasic References definitions residing in another file |
| CIGESBasic_ExternalRefFile | Defines ExternalRefFile, Type <416> Form <1> in package IGESBasic Used when entire reference file is to be instanced |
| CIGESBasic_ExternalRefFileIndex | Defines ExternalRefFileIndex, Type <402> Form <12> in package IGESBasic Contains a list of the symbolic names used by the referencing files and the DE pointers to the corresponding definitions within the referenced file |
| CIGESBasic_ExternalRefFileName | Defines ExternalRefFileName, Type <416> Form <0-2> in package IGESBasic Used when single definition from the reference file is required or for external logical references where an entity in one file relates to an entity in another file |
| CIGESBasic_ExternalRefLibName | Defines ExternalRefLibName, Type <416> Form <4> in package IGESBasic Used when it is assumed that a copy of the subfigure exists in native form in a library on the receiving system |
| CIGESBasic_ExternalRefName | Defines ExternalRefName, Type <416> Form <3> in package IGESBasic Used when it is assumed that a copy of the subfigure exists in native form on the receiving system |
| CIGESBasic_GeneralModule | Definition of General Services for IGESBasic (specific part) This Services comprise : Shared & Implied Lists, Copy, Check |
| CIGESBasic_Group | Defines Group, Type <402> Form <1> in package IGESBasic The Group Associativity allows a collection of a set of entities to be maintained as a single, logical entity |
| CIGESBasic_GroupWithoutBackP | Defines GroupWithoutBackP, Type <402> Form <7> in package IGESBasic this class defines a Group without back pointers |
| CIGESBasic_HArray1OfHArray1OfIGESEntity | |
| CIGESBasic_HArray1OfHArray1OfInteger | |
| CIGESBasic_HArray1OfHArray1OfReal | |
| CIGESBasic_HArray1OfHArray1OfXY | |
| CIGESBasic_HArray1OfHArray1OfXYZ | |
| CIGESBasic_Hierarchy | Defines Hierarchy, Type <406> Form <10> in package IGESBasic Provides ability to control the hierarchy of each directory entry attribute |
| CIGESBasic_Name | Defines Name, Type <406> Form <15> in package IGESBasic Used to specify a user defined name |
| CIGESBasic_OrderedGroup | Defines OrderedGroup, Type <402> Form <14> in package IGESBasic this class defines an Ordered Group with back pointers Allows a collection of a set of entities to be maintained as a single entity, but the group is ordered. It inherits from Group |
| CIGESBasic_OrderedGroupWithoutBackP | Defines OrderedGroupWithoutBackP, Type <402> Form <15> in package IGESBasic Allows a collection of a set of entities to be maintained as a single entity, but the group is ordered and there are no back pointers. It inherits from Group |
| CIGESBasic_Protocol | Description of Protocol for IGESBasic |
| CIGESBasic_ReadWriteModule | Defines basic File Access Module for IGESBasic (specific parts) Specific actions concern : Read and Write Own Parameters of an IGESEntity |
| CIGESBasic_SingleParent | Defines SingleParent, Type <402> Form <9> in package IGESBasic It defines a logical structure of one independent (parent) entity and one or more subordinate (children) entities |
| CIGESBasic_SingularSubfigure | Defines SingularSubfigure, Type <408> Form <0> in package IGESBasic Defines the occurrence of a single instance of the defined Subfigure |
| CIGESBasic_SpecificModule | Defines Services attached to IGES Entities : Dump & OwnCorrect, for IGESBasic |
| CIGESBasic_SubfigureDef | Defines SubfigureDef, Type <308> Form <0> in package IGESBasic This Entity permits a single definition of a detail to be utilized in multiple instances in the creation of the whole picture |
| CIGESBasic_ToolAssocGroupType | Tool to work on a AssocGroupType. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule) |
| CIGESBasic_ToolExternalReferenceFile | Tool to work on a ExternalReferenceFile. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule) |
| CIGESBasic_ToolExternalRefFile | Tool to work on a ExternalRefFile. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule) |
| CIGESBasic_ToolExternalRefFileIndex | Tool to work on a ExternalRefFileIndex. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule) |
| CIGESBasic_ToolExternalRefFileName | Tool to work on a ExternalRefFileName. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule) |
| CIGESBasic_ToolExternalRefLibName | Tool to work on a ExternalRefLibName. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule) |
| CIGESBasic_ToolExternalRefName | Tool to work on a ExternalRefName. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule) |
| CIGESBasic_ToolGroup | Tool to work on a Group. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule) |
| CIGESBasic_ToolGroupWithoutBackP | Tool to work on a GroupWithoutBackP. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule) |
| CIGESBasic_ToolHierarchy | Tool to work on a Hierarchy. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule) |
| CIGESBasic_ToolName | Tool to work on a Name. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule) |
| CIGESBasic_ToolOrderedGroup | Tool to work on a OrderedGroup. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule) |
| CIGESBasic_ToolOrderedGroupWithoutBackP | Tool to work on a OrderedGroupWithoutBackP. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule) |
| CIGESBasic_ToolSingleParent | Tool to work on a SingleParent. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule) |
| CIGESBasic_ToolSingularSubfigure | Tool to work on a SingularSubfigure. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule) |
| CIGESBasic_ToolSubfigureDef | Tool to work on a SubfigureDef. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule) |
| CIGESCAFControl | Provides high-level API to translate IGES file to and from DECAF document |
| CIGESCAFControl_Reader | Provides a tool to read IGES file and put it into DECAF document. Besides transfer of shapes (including assemblies) provided by IGESControl, supports also colors and part names IGESCAFControl_Reader reader; Methods for translation of an IGES file: reader.ReadFile("filename"); reader.Transfer(Document); or reader.Perform("filename",doc); Methods for managing reading attributes. Colors reader.SetColorMode(colormode); bool colormode = reader.GetColorMode(); Layers reader.SetLayerMode(layermode); bool layermode = reader.GetLayerMode(); Names reader.SetNameMode(namemode); bool namemode = reader.GetNameMode(); |
| CIGESCAFControl_Writer | Provides a tool to write DECAF document to the IGES file. Besides transfer of shapes (including assemblies) provided by IGESControl, supports also colors and part names IGESCAFControl_Writer writer(); Methods for writing IGES file: writer.Transfer (Document); writer.Write("filename") or writer.Write(OStream) or writer.Perform(Document,"filename"); Methods for managing the writing of attributes. Colors writer.SetColorMode(colormode); bool colormode = writer.GetColorMode(); Layers writer.SetLayerMode(layermode); bool layermode = writer.GetLayerMode(); Names writer.SetNameMode(namemode); bool namemode = writer.GetNameMode(); |
| CIGESControl_ActorWrite | Actor to write Shape to IGES |
| CIGESControl_AlgoContainer | |
| CIGESControl_Controller | Controller for IGES-5.1 |
| CIGESControl_IGESBoundary | Translates IGES boundary entity (types 141, 142 and 508) in Advanced Data Exchange. Redefines translation and treatment methods from inherited open class IGESToBRep_IGESBoundary |
| CIGESControl_Reader | Reads IGES files, checks them and translates their contents into Open CASCADE models. The IGES data can be that of a whole model or that of a specific list of entities in the model. As in XSControl_Reader, you specify the list using a selection. For translation of iges files it is possible to use the following sequence: To change parameters of translation class Interface_Static should be used before the beginning of translation (see IGES Parameters and General Parameters) Creation of reader IGESControl_Reader reader; To load a file in a model use method: reader.ReadFile("filename.igs") To check a loading file use method Check: reader.Check(failsonly); where failsonly is equal to true or false; To print the results of load: reader.PrintCheckLoad(failsonly,mode) where mode is equal to the value of enumeration IFSelect_PrintCount To transfer entities from a model the following methods can be used: for the whole model reader.TransferRoots(onlyvisible); where onlyvisible is equal to true or false; To transfer a list of entities: reader.TransferList(list); To transfer one entity reader.TransferEntity(ent) or reader.Transfer(num); To obtain a result the following method can be used: reader.IsDone() reader.NbShapes() and reader.Shape(num); or reader.OneShape(); To print the results of transfer use method: reader.PrintTransferInfo(failwarn,mode); where printfail is equal to the value of enumeration IFSelect_PrintFail, mode see above. Gets correspondence between an IGES entity and a result shape obtained therefrom. reader.TransientProcess(); TopoDS_Shape shape = TransferBRep::ShapeResult(reader.TransientProcess(),ent); |
| CIGESControl_ToolContainer | |
| CIGESControl_Writer | This class creates and writes IGES files from CAS.CADE models. An IGES file can be written to an existing IGES file or to a new one. The translation can be performed in one or several operations. Each translation operation outputs a distinct root entity in the IGES file. To write an IGES file it is possible to use the following sequence: To modify the IGES file header or to change translation parameters it is necessary to use class Interface_Static (see IGESParameters and GeneralParameters) |
| CIGESConvGeom | This package is intended to gather geometric conversion which are not immediate but can be used for several purposes : mainly, standard conversion to and from CasCade geometric and topologic data, and adaptations of IGES files as required (as replacing Spline entities to BSpline equivalents) |
| CIGESConvGeom_GeomBuilder | This class provides some useful basic tools to build IGESGeom curves, especially : define a curve in a plane in 3D space (ex. Circular or Conic arc, or Copious Data defined in 2D) make a CopiousData from a list of points/vectors |
| CIGESData | Basic description of an IGES Interface |
| CIGESData_BasicEditor | This class provides various functions of basic edition, such as : |
| CIGESData_ColorEntity | Defines required type for Color in directory part an effective Color entity must inherits it |
| CIGESData_DefaultGeneral | Processes the specific case of UndefinedEntity from IGESData (Case Number 1) |
| CIGESData_DefaultSpecific | Specific IGES Services for UndefinedEntity, FreeFormatEntity |
| CIGESData_DefSwitch | Description of a directory component which can be either undefined (let Void), defined as a Reference to an entity, or as a Rank, integer value addressing a builtin table The entity reference is not included here, only reference status is kept (because entity type must be adapted) |
| CIGESData_DirChecker | This class centralizes general Checks upon an IGES Entity's Directory Part. That is : such field Ignored or Required, or Required with a given Value (for an Integer field) More precise checks can be performed as necessary, by each Entity (method OwnCheck) |
| CIGESData_DirPart | Literal/numeric description of an entity's directory section, taken from file |
| CIGESData_FileProtocol | This class allows to define complex protocols, in order to treat various sub-sets (or the complete set) of the IGES Norm, such as Solid + Draw (which are normally independent), etc... While it inherits Protocol from IGESData, it admits UndefinedEntity too |
| CIGESData_FileRecognizer | |
| CIGESData_FreeFormatEntity | This class allows to create IGES Entities in a literal form : their definition is free, but they are not recognized as instances of specific classes |
| CIGESData_GeneralModule | Definition of General Services adapted to IGES. This Services comprise : Shared & Implied Lists, Copy, Check They are adapted according to the organisation of IGES Entities : Directory Part, Lists of Associativities and Properties are specifically processed |
| CIGESData_GlobalNodeOfSpecificLib | |
| CIGESData_GlobalNodeOfWriterLib | |
| CIGESData_GlobalSection | Description of a global section (corresponds to file header) used as well in IGESModel, IGESReader and IGESWriter Warning : From IGES-5.1, a parameter is added : LastChangeDate (concerns transferred set of data, not the file itself) Of course, it can be absent if read from earlier versions (a default is then to be set to current date) From 5.3, one more : ApplicationProtocol (optional) |
| CIGESData_IGESDumper | Provides a way to obtain a clear Dump of an IGESEntity (distinct from normalized output). It works with tools attached to Entities, as for normalized Reade and Write |
| CIGESData_IGESEntity | Defines root of IGES Entity definition, including Directory Part, lists of (optional) Properties and Associativities |
| CIGESData_IGESModel | Defines the file header and entities for IGES files. These headers and entities result from a complete data translation using the IGES data exchange processor. Each entity is contained in a single model only and has a unique identifier. You can access this identifier using the method Number. Gives an access to the general data in the Start and the Global sections of an IGES file. The IGES file includes the following sections: -Start, -Global, -Directory Entry, -Parameter Data, -Terminate |
| CIGESData_IGESReaderData | Specific FileReaderData for IGES contains header as GlobalSection, and for each Entity, its directory part as DirPart, list of Parameters as ParamSet Each Item has a DirPart, plus classically a ParamSet and the correspondent recognized Entity (inherited from FileReaderData) Parameters are accessed through specific objects, ParamReaders |
| CIGESData_IGESReaderTool | Specific FileReaderTool for IGES Parameters are accessed through specific objects, ParamReaders |
| CIGESData_IGESType | Taken from directory part of an entity (from file or model), gives "type" and "form" data, used to recognize entity's type |
| CIGESData_IGESWriter | Manages atomic file writing, under control of IGESModel : prepare text to be sent then sends it takes into account distinction between successive Sections |
| CIGESData_LabelDisplayEntity | Defines required type for LabelDisplay in directory part an effective LabelDisplay entity must inherits it |
| CIGESData_LevelListEntity | Defines required type for LevelList in directory part an effective LevelList entity must inherits it |
| CIGESData_LineFontEntity | Defines required type for LineFont in directory part an effective LineFont entity must inherits it |
| CIGESData_NameEntity | NameEntity is a kind of IGESEntity which can provide a Name under alphanumeric (String) form, from Properties list an effective Name entity must inherit it |
| CIGESData_NodeOfSpecificLib | |
| CIGESData_NodeOfWriterLib | |
| CIGESData_ParamCursor | Auxiliary class for ParamReader. It stores commands for a ParamReader to manage the current parameter number. Used by methods Read... from ParamReader. It allows to define the following commands : |
| CIGESData_ParamReader | Access to a list of parameters, with management of read stage (owned parameters, properties, associativities) and current parameter number, read errors (which feed a Check), plus convenient facilities to read parameters, in particular : |
| CIGESData_Protocol | Description of basic Protocol for IGES This comprises treatment of IGESModel and Recognition of Undefined-FreeFormat-Entity |
| CIGESData_ReadWriteModule | Defines basic File Access Module, under the control of IGESReaderTool for Reading and IGESWriter for Writing : Specific actions concern : Read and Write Own Parameters of an IGESEntity. The common parts (Directory Entry, Lists of Associativities and Properties) are processed by IGESReaderTool & IGESWriter |
| CIGESData_SingleParentEntity | SingleParentEntity is a kind of IGESEntity which can refer to a (Single) Parent, from Associativities list of an Entity a effective SingleParent definition entity must inherit it |
| CIGESData_SpecificLib | |
| CIGESData_SpecificModule | This class defines some Services which are specifically attached to IGES Entities : Dump |
| CIGESData_ToolLocation | This Tool determines and gives access to effective Locations of IGES Entities as defined by the IGES Norm. These Locations can be for each Entity : |
| CIGESData_TransfEntity | Defines required type for Transf in directory part an effective Transf entity must inherits it |
| CIGESData_UndefinedEntity | Undefined (unknown or error) entity specific of IGES DirPart can be correct or not : if it is not, a flag indicates it, and each corrupted field has an associated error flag |
| CIGESData_ViewKindEntity | Defines required type for ViewKind in directory part that is, Single view or Multiple view An effective ViewKind entity must inherit it and define IsSingle (True for Single, False for List of Views), NbViews and ViewItem (especially for a List) |
| CIGESData_WriterLib | |
| CIGESDefs | To embody general definitions of Entities (Parameters, Tables ...) |
| CIGESDefs_AssociativityDef | Defines IGES Associativity Definition Entity, Type <302> Form <5001 - 9999> in package IGESDefs. This class permits the preprocessor to define an associativity schema. i.e., by using it preprocessor defines the type of relationship |
| CIGESDefs_AttributeDef | Defines IGES Attribute Table Definition Entity, Type <322> Form [0, 1, 2] in package IGESDefs. This is class is used to support the concept of well defined collection of attributes, whether it is a table or a single row of attributes |
| CIGESDefs_AttributeTable | Defines IGES Attribute Table, Type <422> Form <0, 1> in package IGESDefs This class is used to represent an occurrence of Attribute Table. This Class may be independent or dependent or pointed at by other Entities |
| CIGESDefs_GeneralModule | Definition of General Services for IGESDefs (specific part) This Services comprise : Shared & Implied Lists, Copy, Check |
| CIGESDefs_GenericData | Defines IGES Generic Data, Type <406> Form <27> in package IGESDefs Used to communicate information defined by the system operator while creating the model. The information is system specific and does not map into one of the predefined properties or associativities. Properties and property values can be defined by multiple instances of this property |
| CIGESDefs_HArray1OfHArray1OfTextDisplayTemplate | |
| CIGESDefs_MacroDef | Defines IGES Macro Definition Entity, Type <306> Form <0> in package IGESDefs This Class specifies the action of a specific MACRO. After specification MACRO can be used as necessary by means of MACRO class instance entity |
| CIGESDefs_Protocol | Description of Protocol for IGESDefs |
| CIGESDefs_ReadWriteModule | Defines Defs File Access Module for IGESDefs (specific parts) Specific actions concern : Read and Write Own Parameters of an IGESEntity |
| CIGESDefs_SpecificModule | Defines Services attached to IGES Entities : Dump, for IGESDefs |
| CIGESDefs_TabularData | Defines IGES Tabular Data, Type <406> Form <11>, in package IGESDefs This Class is used to provide a Structure to accommodate point form data |
| CIGESDefs_ToolAssociativityDef | Tool to work on a AssociativityDef. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule) |
| CIGESDefs_ToolAttributeDef | Tool to work on a AttributeDef. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule) |
| CIGESDefs_ToolAttributeTable | Tool to work on a AttributeTable. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule) |
| CIGESDefs_ToolGenericData | Tool to work on a GenericData. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule) |
| CIGESDefs_ToolMacroDef | Tool to work on a MacroDef. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule) |
| CIGESDefs_ToolTabularData | Tool to work on a TabularData. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule) |
| CIGESDefs_ToolUnitsData | Tool to work on a UnitsData. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule) |
| CIGESDefs_UnitsData | Defines IGES UnitsData Entity, Type <316> Form <0> in package IGESDefs This class stores data about a model's fundamental units |
| CIGESDimen | This package represents Entities applied to Dimensions ie. Annotation Entities and attached Properties and Associativities |
| CIGESDimen_AngularDimension | Defines AngularDimension, Type <202> Form <0> in package IGESDimen Used to dimension angles |
| CIGESDimen_BasicDimension | Defines IGES Basic Dimension, Type 406, Form 31, in package IGESDimen The basic Dimension Property indicates that the referencing dimension entity is to be displayed with a box around text |
| CIGESDimen_CenterLine | Defines CenterLine, Type <106> Form <20-21> in package IGESDimen Is an entity appearing as crosshairs or as a construction between 2 positions |
| CIGESDimen_CurveDimension | Defines CurveDimension, Type <204> Form <0> in package IGESDimen Used to dimension curves Consists of one tail segment of nonzero length beginning with an arrowhead and which serves to define the orientation |
| CIGESDimen_DiameterDimension | Defines DiameterDimension, Type <206> Form <0> in package IGESDimen Used for dimensioning diameters |
| CIGESDimen_DimensionDisplayData | Defines IGES Dimension Display Data, Type <406> Form <30>, in package IGESDimen The Dimensional Display Data Property is optional but when present must be referenced by a dimension entity. The information it contains could be extracted from the text, leader and witness line data with difficulty |
| CIGESDimen_DimensionedGeometry | Defines IGES Dimensioned Geometry, Type <402> Form <13>, in package IGESDimen This entity has been replaced by the new form of Dimensioned Geometry Associativity Entity (Type 402, Form 21) and should no longer be used by preprocessors |
| CIGESDimen_DimensionTolerance | Defines Dimension Tolerance, Type <406>, Form <29> in package IGESDimen Provides tolerance information for a dimension which can be used by the receiving system to regenerate the dimension |
| CIGESDimen_DimensionUnits | Defines Dimension Units, Type <406>, Form <28> in package IGESDimen Describes the units and formatting details of the nominal value of a dimension |
| CIGESDimen_FlagNote | Defines FlagNote, Type <208> Form <0> in package IGESDimen Is label information formatted in different ways |
| CIGESDimen_GeneralLabel | Defines GeneralLabel, Type <210> Form <0> in package IGESDimen Used for general labeling with leaders |
| CIGESDimen_GeneralModule | Definition of General Services for IGESDimen (specific part) This Services comprise : Shared & Implied Lists, Copy, Check |
| CIGESDimen_GeneralNote | Defines GeneralNote, Type <212> Form <0-8, 100-200, 105> in package IGESDimen Used for formatting boxed text in different ways |
| CIGESDimen_GeneralSymbol | Defines General Symbol, Type <228>, Form <0-3,5001-9999> in package IGESDimen Consists of zero or one (Form 0) or one (all other forms), one or more geometry entities which define a symbol, and zero, one or more associated leaders |
| CIGESDimen_LeaderArrow | Defines LeaderArrow, Type <214> Form <1-12> in package IGESDimen Consists of one or more line segments except when leader is part of an angular dimension, with links to presumed text item |
| CIGESDimen_LinearDimension | Defines LinearDimension, Type <216> Form <0> in package IGESDimen Used for linear dimensioning |
| CIGESDimen_NewDimensionedGeometry | Defines New Dimensioned Geometry, Type <402>, Form <21> in package IGESDimen Links a dimension entity with the geometry entities it is dimensioning, so that later, in the receiving database, the dimension can be automatically recalculated and redrawn should the geometry be changed |
| CIGESDimen_NewGeneralNote | Defines NewGeneralNote, Type <213> Form <0> in package IGESDimen Further attributes for formatting text strings |
| CIGESDimen_OrdinateDimension | Defines IGES Ordinate Dimension, Type <218> Form <0, 1>, in package IGESDimen Note: The ordinate dimension entity is used to indicate dimensions from a common base line. Dimensioning is only permitted along the XT or YT axis |
| CIGESDimen_PointDimension | Defines IGES Point Dimension, Type <220> Form <0>, in package IGESDimen A Point Dimension Entity consists of a leader, text, and an optional circle or hexagon enclosing the text IGES specs for this entity mention SimpleClosedPlanarCurve Entity(106/63)which is not listed in LIST.Text In the sequel we have ignored this & considered only the other two entity for representing the hexagon or circle enclosing the text |
| CIGESDimen_Protocol | Description of Protocol for IGESDimen |
| CIGESDimen_RadiusDimension | Defines IGES Radius Dimension, type <222> Form <0, 1>, in package IGESDimen. A Radius Dimension Entity consists of a General Note, a leader, and an arc center point. A second form of this entity accounts for the occasional need to have two leader entities referenced |
| CIGESDimen_ReadWriteModule | Defines Dimen File Access Module for IGESDimen (specific parts) Specific actions concern : Read and Write Own Parameters of an IGESEntity |
| CIGESDimen_Section | Defines Section, Type <106> Form <31-38> in package IGESDimen Contains information to display sectioned sides |
| CIGESDimen_SectionedArea | Defines IGES Sectioned Area, Type <230> Form <0>, in package IGESDimen A sectioned area is a portion of a design which is to be filled with a pattern of lines. Ordinarily, this entity is used to reveal or expose shape or material characteri- stics defined by other entities. It consists of a pointer to an exterior definition curve, a specification of the pattern of lines, the coordinates of a point on a pattern line, the distance between the pattern lines, the angle between the pattern lines and the X-axis of definition space, and the specification of any enclosed definition curves (commonly known as islands) |
| CIGESDimen_SpecificModule | Defines Services attached to IGES Entities : Dump & OwnCorrect, for IGESDimen |
| CIGESDimen_ToolAngularDimension | Tool to work on a AngularDimension. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule) |
| CIGESDimen_ToolBasicDimension | Tool to work on a BasicDimension. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule) |
| CIGESDimen_ToolCenterLine | Tool to work on a CenterLine. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule) |
| CIGESDimen_ToolCurveDimension | Tool to work on a CurveDimension. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule) |
| CIGESDimen_ToolDiameterDimension | Tool to work on a DiameterDimension. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule) |
| CIGESDimen_ToolDimensionDisplayData | Tool to work on a DimensionDisplayData. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule) |
| CIGESDimen_ToolDimensionedGeometry | Tool to work on a DimensionedGeometry. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule) |
| CIGESDimen_ToolDimensionTolerance | Tool to work on a DimensionTolerance. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule) |
| CIGESDimen_ToolDimensionUnits | Tool to work on a DimensionUnits. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule) |
| CIGESDimen_ToolFlagNote | Tool to work on a FlagNote. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule) |
| CIGESDimen_ToolGeneralLabel | Tool to work on a GeneralLabel. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule) |
| CIGESDimen_ToolGeneralNote | Tool to work on a GeneralNote. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule) |
| CIGESDimen_ToolGeneralSymbol | Tool to work on a GeneralSymbol. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule) |
| CIGESDimen_ToolLeaderArrow | Tool to work on a LeaderArrow. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule) |
| CIGESDimen_ToolLinearDimension | Tool to work on a LinearDimension. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule) |
| CIGESDimen_ToolNewDimensionedGeometry | Tool to work on a NewDimensionedGeometry. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule) |
| CIGESDimen_ToolNewGeneralNote | Tool to work on a NewGeneralNote. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule) |
| CIGESDimen_ToolOrdinateDimension | Tool to work on a OrdinateDimension. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule) |
| CIGESDimen_ToolPointDimension | Tool to work on a PointDimension. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule) |
| CIGESDimen_ToolRadiusDimension | Tool to work on a RadiusDimension. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule) |
| CIGESDimen_ToolSection | Tool to work on a Section. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule) |
| CIGESDimen_ToolSectionedArea | Tool to work on a SectionedArea. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule) |
| CIGESDimen_ToolWitnessLine | Tool to work on a WitnessLine. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule) |
| CIGESDimen_WitnessLine | Defines WitnessLine, Type <106> Form <40> in package IGESDimen Contains one or more straight line segments associated with drafting entities of various types |
| CIGESDraw | This package contains the group of classes necessary for Structure Entities implied in Drawings and Structured Graphics (Sets for drawing, Drawings and Views) |
| CIGESDraw_CircArraySubfigure | Defines IGES Circular Array Subfigure Instance Entity, Type <414> Form Number <0> in package IGESDraw |
| CIGESDraw_ConnectPoint | Defines IGESConnectPoint, Type <132> Form Number <0> in package IGESDraw |
| CIGESDraw_Drawing | Defines IGESDrawing, Type <404> Form <0> in package IGESDraw |
| CIGESDraw_DrawingWithRotation | Defines IGESDrawingWithRotation, Type <404> Form <1> in package IGESDraw |
| CIGESDraw_GeneralModule | Definition of General Services for IGESDraw (specific part) This Services comprise : Shared & Implied Lists, Copy, Check |
| CIGESDraw_LabelDisplay | Defines IGESLabelDisplay, Type <402> Form <5> in package IGESDraw |
| CIGESDraw_NetworkSubfigure | Defines IGES Network Subfigure Instance Entity, Type <420> Form Number <0> in package IGESDraw |
| CIGESDraw_NetworkSubfigureDef | Defines IGESNetworkSubfigureDef, Type <320> Form Number <0> in package IGESDraw |
| CIGESDraw_PerspectiveView | Defines IGESPerspectiveView, Type <410> Form <1> in package IGESDraw |
| CIGESDraw_Planar | Defines IGESPlanar, Type <402> Form <16> in package IGESDraw |
| CIGESDraw_Protocol | Description of Protocol for IGESDraw |
| CIGESDraw_ReadWriteModule | Defines Draw File Access Module for IGESDraw (specific parts) Specific actions concern : Read and Write Own Parameters of an IGESEntity |
| CIGESDraw_RectArraySubfigure | Defines IGES Rectangular Array Subfigure Instance Entity, Type <412> Form Number <0> in package IGESDraw Used to produce copies of object called the base entity, arranging them in equally spaced rows and columns |
| CIGESDraw_SegmentedViewsVisible | Defines IGESSegmentedViewsVisible, Type <402> Form <19> in package IGESDraw |
| CIGESDraw_SpecificModule | Defines Services attached to IGES Entities : Dump & OwnCorrect, for IGESDraw |
| CIGESDraw_ToolCircArraySubfigure | Tool to work on a CircArraySubfigure. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule) |
| CIGESDraw_ToolConnectPoint | Tool to work on a ConnectPoint. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule) |
| CIGESDraw_ToolDrawing | Tool to work on a Drawing. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule) |
| CIGESDraw_ToolDrawingWithRotation | Tool to work on a DrawingWithRotation. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule) |
| CIGESDraw_ToolLabelDisplay | Tool to work on a LabelDisplay. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule) |
| CIGESDraw_ToolNetworkSubfigure | Tool to work on a NetworkSubfigure. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule) |
| CIGESDraw_ToolNetworkSubfigureDef | Tool to work on a NetworkSubfigureDef. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule) |
| CIGESDraw_ToolPerspectiveView | Tool to work on a PerspectiveView. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule) |
| CIGESDraw_ToolPlanar | Tool to work on a Planar. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule) |
| CIGESDraw_ToolRectArraySubfigure | Tool to work on a RectArraySubfigure. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule) |
| CIGESDraw_ToolSegmentedViewsVisible | Tool to work on a SegmentedViewsVisible. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule) |
| CIGESDraw_ToolView | Tool to work on a View. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule) |
| CIGESDraw_ToolViewsVisible | Tool to work on a ViewsVisible. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule) |
| CIGESDraw_ToolViewsVisibleWithAttr | Tool to work on a ViewsVisibleWithAttr. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule) |
| CIGESDraw_View | Defines IGES View Entity, Type <410> Form <0> in package IGESDraw |
| CIGESDraw_ViewsVisible | Defines IGESViewsVisible, Type <402>, Form <3> in package IGESDraw |
| CIGESDraw_ViewsVisibleWithAttr | Defines IGESViewsVisibleWithAttr, Type <402>, Form <4> in package IGESDraw |
| CIGESGeom | This package consists of B-Rep and CSG Solid entities |
| CIGESGeom_Boundary | Defines IGESBoundary, Type <141> Form <0> in package IGESGeom A boundary entity identifies a surface boundary consisting of a set of curves lying on the surface |
| CIGESGeom_BoundedSurface | Defines BoundedSurface, Type <143> Form <0> in package IGESGeom A bounded surface is used to communicate trimmed surfaces. The surface and trimming curves are assumed to be represented parametrically |
| CIGESGeom_BSplineCurve | Defines IGESBSplineCurve, Type <126> Form <0-5> in package IGESGeom A parametric equation obtained by dividing two summations involving weights (which are real numbers), the control points, and B-Spline basis functions |
| CIGESGeom_BSplineSurface | Defines IGESBSplineSurface, Type <128> Form <0-9> in package IGESGeom A parametric equation obtained by dividing two summations involving weights (which are real numbers), the control points, and B-Spline basis functions |
| CIGESGeom_CircularArc | Defines IGESCircularArc, Type <100> Form <0> in package IGESGeom A circular arc is a connected portion of a parent circle which consists of more than one point. The definition space coordinate system is always chosen so that the circular arc remains in a plane either coincident with or parallel to the XT, YT plane |
| CIGESGeom_CompositeCurve | Defines IGESCompositeCurve, Type <102> Form <0> in package IGESGeom A composite curve is defined as an ordered list of entities consisting of a point, connect point and parametrised curve entities (excluding the CompositeCurve entity) |
| CIGESGeom_ConicArc | Defines IGESConicArc, Type <104> Form <0-3> in package IGESGeom A conic arc is a bounded connected portion of a parent conic curve which consists of more than one point. The parent conic curve is either an ellipse, a parabola, or a hyperbola. The definition space coordinate system is always chosen so that the conic arc lies in a plane either coincident with or parallel to XT, YT plane. Within such a plane a conic is defined by the six coefficients in the following equation. A*XT^2 + B*XT*YT + C*YT^2 + D*XT + E*YT + F = 0 |
| CIGESGeom_CopiousData | Defines IGESCopiousData, Type <106> Form <1-3,11-13,63> in package IGESGeom This entity stores data points in the form of pairs, triples, or sextuples. An interpretation flag value signifies which of these forms is being used |
| CIGESGeom_CurveOnSurface | Defines IGESCurveOnSurface, Type <142> Form <0> in package IGESGeom A curve on a parametric surface entity associates a given curve with a surface and identifies the curve as lying on the surface |
| CIGESGeom_Direction | Defines IGESDirection, Type <123> Form <0> in package IGESGeom A direction entity is a non-zero vector in Euclidean 3-space that is defined by its three components (direction ratios) with respect to the coordinate axes. If x, y, z are the direction ratios then (x^2 + y^2 + z^2) > 0 |
| CIGESGeom_Flash | Defines IGESFlash, Type <125> Form <0 - 4> in package IGESGeom A flash entity is a point in the ZT=0 plane that locates a particular closed area. That closed area can be defined in one of two ways. First, it can be an arbitrary closed area defined by any entity capable of defining a closed area. The points of this entity must all lie in the ZT=0 plane. Second, it can be a member of a predefined set of flash shapes |
| CIGESGeom_GeneralModule | Definition of General Services for IGESGeom (specific part) This Services comprise : Shared & Implied Lists, Copy, Check |
| CIGESGeom_Line | Defines IGESLine, Type <110> Form <0> in package IGESGeom A line is a bounded, connected portion of a parent straight line which consists of more than one point. A line is defined by its end points |
| CIGESGeom_OffsetCurve | Defines IGESOffsetCurve, Type <130> Form <0> in package IGESGeom An OffsetCurve entity contains the data necessary to determine the offset of a given curve C. This entity points to the base curve to be offset and contains offset distance and other pertinent information |
| CIGESGeom_OffsetSurface | Defines IGESOffsetSurface, Type <140> Form <0> in package IGESGeom An offset surface is a surface defined in terms of an already existing surface.If S(u, v) is a parametrised regular surface and N(u, v) is a differential field of unit normal vectors defined on the whole surface, and "d" a fixed non zero real number, then offset surface to S is a parametrised surface S(u, v) given by O(u, v) = S(u, v) + d * N(u, v); u1 <= u <= u2; v1 <= v <= v2; |
| CIGESGeom_Plane | Defines IGESPlane, Type <108> Form <-1,0,1> in package IGESGeom A plane entity can be used to represent unbounded plane, as well as bounded portion of a plane. In either of the above cases the plane is defined within definition space by means of coefficients A, B, C, D where at least one of A, B, C is non-zero and A * XT + B * YT + C * ZT = D |
| CIGESGeom_Point | Defines IGESPoint, Type <116> Form <0> in package IGESGeom |
| CIGESGeom_Protocol | Description of Protocol for IGESGeom |
| CIGESGeom_ReadWriteModule | Defines Geom File Access Module for IGESGeom (specific parts) Specific actions concern : Read and Write Own Parameters of an IGESEntity |
| CIGESGeom_RuledSurface | Defines IGESRuledSurface, Type <118> Form <0-1> in package IGESGeom A ruled surface is formed by moving a line connecting points of equal relative arc length or equal relative parametric value on two parametric curves from a start point to a terminate point on the curves. The parametric curves may be points, lines, circles, conics, rational B-splines, parametric splines or any parametric curve defined in the IGES specification |
| CIGESGeom_SpecificModule | Defines Services attached to IGES Entities : Dump & OwnCorrect, for IGESGeom |
| CIGESGeom_SplineCurve | Defines IGESSplineCurve, Type <112> Form <0> in package IGESGeom The parametric spline is a sequence of parametric polynomial segments. The curve could be of the type Linear, Quadratic, Cubic, Wilson-Fowler, Modified Wilson-Fowler, B-Spline. The N polynomial segments are delimited by the break points: T(1), T(2), T(3), ..., T(N+1) |
| CIGESGeom_SplineSurface | Defines IGESSplineSurface, Type <114> Form <0> in package IGESGeom A parametric spline surface is a grid of polynomial patches. Patch could be of the type Linear, Quadratic, Cubic, Wilson-Fowler, Modified Wilson-Fowler, B-Spline The M * N grid of patches is defined by the 'u' break points TU(1), TU(2), ..., TU(M+1) and the 'v' break points TV(1), TV(2), TV(3) ..., TV(N+1) |
| CIGESGeom_SurfaceOfRevolution | Defines IGESSurfaceOfRevolution, Type <120> Form <0> in package IGESGeom A surface of revolution is defined by an axis of rotation a generatrix, and start and terminate rotation angles. The surface is created by rotating the generatrix about the axis of rotation through the start and terminate rotation angles |
| CIGESGeom_TabulatedCylinder | Defines IGESTabulatedCylinder, Type <122> Form <0> in package IGESGeom A tabulated cylinder is a surface formed by moving a line segment called generatrix parallel to itself along a curve called directrix. The curve may be a line, circular arc, conic arc, parametric spline curve, rational B-spline curve or composite curve |
| CIGESGeom_ToolBoundary | Tool to work on a Boundary. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule) |
| CIGESGeom_ToolBoundedSurface | Tool to work on a BoundedSurface. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule) |
| CIGESGeom_ToolBSplineCurve | Tool to work on a BSplineCurve. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule) |
| CIGESGeom_ToolBSplineSurface | Tool to work on a BSplineSurface. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule) |
| CIGESGeom_ToolCircularArc | Tool to work on a CircularArc. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule) |
| CIGESGeom_ToolCompositeCurve | Tool to work on a CompositeCurve. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule) |
| CIGESGeom_ToolConicArc | Tool to work on a ConicArc. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule) |
| CIGESGeom_ToolCopiousData | Tool to work on a CopiousData. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule) |
| CIGESGeom_ToolCurveOnSurface | Tool to work on a CurveOnSurface. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule) |
| CIGESGeom_ToolDirection | Tool to work on a Direction. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule) |
| CIGESGeom_ToolFlash | Tool to work on a Flash. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule) |
| CIGESGeom_ToolLine | Tool to work on a Line. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule) |
| CIGESGeom_ToolOffsetCurve | Tool to work on a OffsetCurve. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule) |
| CIGESGeom_ToolOffsetSurface | Tool to work on a OffsetSurface. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule) |
| CIGESGeom_ToolPlane | Tool to work on a Plane. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule) |
| CIGESGeom_ToolPoint | Tool to work on a Point. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule) |
| CIGESGeom_ToolRuledSurface | Tool to work on a RuledSurface. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule) |
| CIGESGeom_ToolSplineCurve | Tool to work on a SplineCurve. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule) |
| CIGESGeom_ToolSplineSurface | Tool to work on a SplineSurface. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule) |
| CIGESGeom_ToolSurfaceOfRevolution | Tool to work on a SurfaceOfRevolution. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule) |
| CIGESGeom_ToolTabulatedCylinder | Tool to work on a TabulatedCylinder. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule) |
| CIGESGeom_ToolTransformationMatrix | Tool to work on a TransformationMatrix. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule) |
| CIGESGeom_ToolTrimmedSurface | Tool to work on a TrimmedSurface. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule) |
| CIGESGeom_TransformationMatrix | Defines IGESTransformationMatrix, Type <124> Form <0> in package IGESGeom The transformation matrix entity transforms three-row column vectors by means of matrix multiplication and then a vector addition. This entity can be considered as an "operator" entity in that it starts with the input vector, operates on it as described above, and produces the output vector |
| CIGESGeom_TrimmedSurface | Defines IGESTrimmedSurface, Type <144> Form <0> in package IGESGeom A simple closed curve in Euclidean plane divides the plane in to two disjoint, open connected components; one bounded, one unbounded. The bounded one is called the interior region to the curve. Unbounded component is called exterior region to the curve. The domain of the trimmed surface is defined as the interior of the outer boundaries and exterior of the inner boundaries and includes the boundary curves |
| CIGESGraph | This package contains the group of classes necessary to define Graphic data among Structure Entities. (e.g., Fonts, Colors, Screen management ...) |
| CIGESGraph_Color | Defines IGESColor, Type <314> Form <0> in package IGESGraph |
| CIGESGraph_DefinitionLevel | Defines IGESDefinitionLevel, Type <406> Form <1> in package IGESGraph |
| CIGESGraph_DrawingSize | Defines IGESDrawingSize, Type <406> Form <16> in package IGESGraph |
| CIGESGraph_DrawingUnits | Defines IGESDrawingUnits, Type <406> Form <17> in package IGESGraph |
| CIGESGraph_GeneralModule | Definition of General Services for IGESGraph (specific part) This Services comprise : Shared & Implied Lists, Copy, Check |
| CIGESGraph_HighLight | Defines IGESHighLight, Type <406> Form <20> in package IGESGraph |
| CIGESGraph_IntercharacterSpacing | Defines IGESIntercharacterSpacing, Type <406> Form <18> in package IGESGraph |
| CIGESGraph_LineFontDefPattern | Defines IGESLineFontDefPattern, Type <304> Form <2> in package IGESGraph |
| CIGESGraph_LineFontDefTemplate | Defines IGESLineFontDefTemplate, Type <304> Form <1> in package IGESGraph |
| CIGESGraph_LineFontPredefined | Defines IGESLineFontPredefined, Type <406> Form <19> in package IGESGraph |
| CIGESGraph_NominalSize | Defines IGESNominalSize, Type <406> Form <13> in package IGESGraph |
| CIGESGraph_Pick | Defines IGESPick, Type <406> Form <21> in package IGESGraph |
| CIGESGraph_Protocol | Description of Protocol for IGESGraph |
| CIGESGraph_ReadWriteModule | Defines Graph File Access Module for IGESGraph (specific parts) Specific actions concern : Read and Write Own Parameters of an IGESEntity |
| CIGESGraph_SpecificModule | Defines Services attached to IGES Entities : Dump & OwnCorrect, for IGESGraph |
| CIGESGraph_TextDisplayTemplate | Defines IGES TextDisplayTemplate Entity, Type <312>, form <0, 1> in package IGESGraph |
| CIGESGraph_TextFontDef | Defines IGES Text Font Definition Entity, Type <310> in package IGESGraph |
| CIGESGraph_ToolColor | Tool to work on a Color. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule) |
| CIGESGraph_ToolDefinitionLevel | Tool to work on a DefinitionLevel. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule) |
| CIGESGraph_ToolDrawingSize | Tool to work on a DrawingSize. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule) |
| CIGESGraph_ToolDrawingUnits | Tool to work on a DrawingUnits. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule) |
| CIGESGraph_ToolHighLight | Tool to work on a HighLight. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule) |
| CIGESGraph_ToolIntercharacterSpacing | Tool to work on a IntercharacterSpacing. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule) |
| CIGESGraph_ToolLineFontDefPattern | Tool to work on a LineFontDefPattern. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule) |
| CIGESGraph_ToolLineFontDefTemplate | Tool to work on a LineFontDefTemplate. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule) |
| CIGESGraph_ToolLineFontPredefined | Tool to work on a LineFontPredefined. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule) |
| CIGESGraph_ToolNominalSize | Tool to work on a NominalSize. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule) |
| CIGESGraph_ToolPick | Tool to work on a Pick. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule) |
| CIGESGraph_ToolTextDisplayTemplate | Tool to work on a TextDisplayTemplate. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule) |
| CIGESGraph_ToolTextFontDef | Tool to work on a TextFontDef. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule) |
| CIGESGraph_ToolUniformRectGrid | Tool to work on a UniformRectGrid. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule) |
| CIGESGraph_UniformRectGrid | Defines IGESUniformRectGrid, Type <406> Form <22> in package IGESGraph |
| CIGESSelect | This package defines the library of the most used tools for IGES Files : Selections & Modifiers specific to the IGES norm, and the most needed converters |
| CIGESSelect_Activator | Performs Actions specific to IGESSelect, i.e. creation of IGES Selections and Dispatches, plus dumping specific to IGES |
| CIGESSelect_AddFileComment | This class allows to add comment lines on writing an IGES File These lines are added to Start Section, instead of the only one blank line written by default |
| CIGESSelect_AddGroup | Adds a Group to contain the entities designated by the Selection. If no Selection is given, nothing is done |
| CIGESSelect_AutoCorrect | Does the absolutely effective corrections on IGES Entity. That is to say : regarding the norm in details, some values have mandatory values, or set of values with constraints. When such values/constraints are univoque, they can be forced. Also nullifies items of Directory Part, Associativities, and Properties, which are not (or not longer) in <target> Model |
| CIGESSelect_ChangeLevelList | Changes Level List (in directory part) to a new single value Only entities attached to a LevelListEntity are considered If OldNumber is defined, only entities whose LevelList contains its Value are processed. Else all LevelLists are |
| CIGESSelect_ChangeLevelNumber | Changes Level Number (as null or single) to a new single value Entities attached to a LevelListEntity are ignored Entities considered can be, either all Entities but those attached to a LevelListEntity, or Entities attached to a specific Level Number (0 for not defined) |
| CIGESSelect_ComputeStatus | Computes Status of IGES Entities for a whole IGESModel. This concerns SubordinateStatus and UseFlag, which must have some definite values according the way they are referenced. (see definitions of Logical use, Physical use, etc...) |
| CIGESSelect_CounterOfLevelNumber | This class gives information about Level Number. It counts entities according level number, considering also the multiple level (see the class LevelList) for which an entity is attached to each of the listed levels |
| CIGESSelect_DispPerDrawing | This type of dispatch defines sets of entities attached to distinct drawings. This information is taken from attached views which appear in the Directory Part. Also Drawing Frames are considered when Drawings are part of input list |
| CIGESSelect_DispPerSingleView | This type of dispatch defines sets of entities attached to distinct single views. This information appears in the Directory Part. Drawings are taken into account too, because of their frames (proper lists of annotations) |
| CIGESSelect_Dumper | Dumper from IGESSelect takes into account, for SessionFile, the classes defined in the package IGESSelect : Selections, Dispatches, Modifiers |
| CIGESSelect_EditDirPart | This class is aimed to display and edit the Directory Part of an IGESEntity |
| CIGESSelect_EditHeader | This class is aimed to display and edit the Header of an IGES Model : Start Section and Global Section |
| CIGESSelect_FileModifier | |
| CIGESSelect_FloatFormat | This class gives control out format for floatting values : ZeroSuppress or no, Main Format, Format in Range (for values around 1.), as IGESWriter allows to manage it. Formats are given under C-printf form |
| CIGESSelect_IGESName | IGESName is a Signature specific to IGESNorm : it considers the Name of an IGESEntity as being its ShortLabel (some sending systems use name, not to identify entities, but ratjer to classify them) |
| CIGESSelect_IGESTypeForm | IGESTypeForm is a Signature specific to the IGES Norm : it gives the signature under two possible forms : |
| CIGESSelect_ModelModifier | |
| CIGESSelect_RebuildDrawings | Rebuilds Drawings which were bypassed to produce new models. If a set of entities, all put into a same IGESModel, were attached to a same Drawing in the starting Model, this Modifier rebuilds the original Drawing, but only with the transferred entities. This includes that all its views are kept too, but empty; and annotations are not kept. Drawing Name is renewed |
| CIGESSelect_RebuildGroups | Rebuilds Groups which were bypassed to produce new models. If a set of entities, all put into a same IGESModel, were part of a same Group in the starting Model, this Modifier rebuilds the original group, but only with the transferred entities. The distinctions (Ordered or not, "WithoutBackP" or not) are renewed, also the name of the group |
| CIGESSelect_RemoveCurves | Removes Curves UV or 3D (not both !) from Faces, those designated by the Selection. No Selection means all the file |
| CIGESSelect_SelectBasicGeom | This selection returns the basic geometric elements contained in an IGES Entity Intended to run a "quick" transfer. I.E. : |
| CIGESSelect_SelectBypassGroup | Selects a list built as follows : Groups are entities type 402, forms 1,7,14,15 (Group, Ordered or not, "WithoutBackPointer" or not) |
| CIGESSelect_SelectBypassSubfigure | Selects a list built as follows : Subfigures correspond to |
| CIGESSelect_SelectDrawingFrom | This selection gets the Drawings attached to its input IGES entities. They are read through the Single Views, referenced in Directory Parts of the entities |
| CIGESSelect_SelectFaces | This selection returns the faces contained in an IGES Entity or itself if it is a Face Face means : |
| CIGESSelect_SelectFromDrawing | This selection gets in all the model, the entities which are attached to the drawing(s) given as input. This includes : |
| CIGESSelect_SelectFromSingleView | This selection gets in all the model, the entities which are attached to the views given as input. Only Single Views are considered. This information is kept from Directory Part (View Item) |
| CIGESSelect_SelectLevelNumber | This selection looks at Level Number of IGES Entities : it considers items attached, either to a single level with a given value, or to a level list which contains this value |
| CIGESSelect_SelectName | Selects Entities which have a given name. Consider Property Name if present, else Short Label, but not the Subscript Number First version : keeps exact name Later : regular expression |
| CIGESSelect_SelectPCurves | This Selection returns the pcurves which lie on a face In two modes : global (i.e. a CompositeCurve is not explored) or basic (all the basic curves are listed) |
| CIGESSelect_SelectSingleViewFrom | This selection gets the Single Views attached to its input IGES entities. Single Views themselves or Drawings as passed as such (Drawings, for their Annotations) |
| CIGESSelect_SelectSubordinate | This selections uses Subordinate Status as sort criterium It is an integer number which can be : 0 Independent 1 Physically Dependent 2 Logically Dependent 3 Both (recorded) |
| CIGESSelect_SelectVisibleStatus | This selection looks at Blank Status of IGES Entities Direct selection keeps Visible Entities (Blank = 0), Reverse selection keeps Blanked Entities (Blank = 1) |
| CIGESSelect_SetGlobalParameter | Sets a Global (Header) Parameter to a new value, directly given Controls the form of the parameter (Integer, Real, String with such or such form), but not the consistence of the new value regarding the rest of the file |
| CIGESSelect_SetLabel | Sets/Clears Short Label of Entities, those designated by the Selection. No Selection means all the file |
| CIGESSelect_SetVersion5 | Sets IGES Version (coded in global parameter 23) to be at least IGES 5.1 . If it is older, it is set to IGES 5.1, and LastChangeDate (new Global n0 25) is added (current time) Else, it does nothing (i.e. changes neither IGES Version nor LastChangeDate) |
| CIGESSelect_SignColor | Gives Color attached to an entity Several forms are possible, according to <mode> 1 : number : "Dnn" for entity, "Snn" for standard, "(none)" for 0 2 : name : Of standard color, or of the color entity, or "(none)" (if the color entity has no name, its label is taken) 3 : RGB values, form R:nn,G:nn,B:nn 4 : RED value : an integer 5 : GREEN value : an integer 6 : BLUE value : an integer Other computable values can be added if needed : CMY values, Percentages for Hue, Lightness, Saturation |
| CIGESSelect_SignLevelNumber | Gives D.E. Level Number under two possible forms : |
| CIGESSelect_SignStatus | Gives D.E. Status under the form i,j,k,l (4 figures) i for BlankStatus j for SubordinateStatus k for UseFlag l for Hierarchy |
| CIGESSelect_SplineToBSpline | This type of Transformer allows to convert Spline Curves (IGES type 112) and Surfaces (IGES Type 126) to BSpline Curves (IGES type 114) and Surfac (IGES Type 128). All other entities are rebuilt as identical but on the basis of this conversion |
| CIGESSelect_UpdateCreationDate | Allows to Change the Creation Date indication in the Header (Global Section) of IGES File. It is taken from the operating system (time of application of the Modifier). The Selection of the Modifier is not used : it simply acts as a criterium to select IGES Files to touch up |
| CIGESSelect_UpdateFileName | Sets the File Name in Header to be the actual name of the file If new file name is unknown, the former one is kept Remark : this works well only when it is Applied and send time If it is run immediately, new file name is unknown and nothing is done The Selection of the Modifier is not used : it simply acts as a criterium to select IGES Files to touch up |
| CIGESSelect_UpdateLastChange | Allows to Change the Last Change Date indication in the Header (Global Section) of IGES File. It is taken from the operating system (time of application of the Modifier). The Selection of the Modifier is not used : it simply acts as a criterium to select IGES Files to touch up. Remark : IGES Models noted as version before IGES 5.1 are in addition changed to 5.1 |
| CIGESSelect_ViewSorter | Sorts IGES Entities on the views and drawings. In a first step, it splits a set of entities according the different views they are attached to. Then, packets according single views (+ drawing frames), or according drawings (which refer to the views) can be determined |
| CIGESSelect_WorkLibrary | Performs Read and Write an IGES File with an IGES Model |
| CIGESSolid | This package consists of B-Rep and CSG Solid entities |
| CIGESSolid_Block | Defines Block, Type <150> Form Number <0> in package IGESSolid The Block is a rectangular parallelopiped, defined with one vertex at (X1, Y1, Z1) and three edges lying along the local +X, +Y, +Z axes |
| CIGESSolid_BooleanTree | Defines BooleanTree, Type <180> Form Number <0> in package IGESSolid The Boolean tree describes a binary tree structure composed of regularized Boolean operations and operands, in post-order notation |
| CIGESSolid_ConeFrustum | Defines ConeFrustum, Type <156> Form Number <0> in package IGESSolid The Cone Frustum is defined by the center of the larger circular face of the frustum, its radius, a unit vector in the axis direction, a height in this direction and a second circular face with radius which is lesser than the first face |
| CIGESSolid_ConicalSurface | Defines ConicalSurface, Type <194> Form Number <0,1> in package IGESSolid The right circular conical surface is defined by a point on the axis on the cone, the direction of the axis of the cone, the radius of the cone at the axis point and the cone semi-angle |
| CIGESSolid_Cylinder | Defines Cylinder, Type <154> Form Number <0> in package IGESSolid This defines a solid cylinder |
| CIGESSolid_CylindricalSurface | Defines CylindricalSurface, Type <192> Form Number <0,1> in package IGESSolid |
| CIGESSolid_EdgeList | Defines EdgeList, Type <504> Form <1> in package IGESSolid EdgeList is defined as a segment joining two vertices It contains one or more edge tuples |
| CIGESSolid_Ellipsoid | Defines Ellipsoid, Type <168> Form Number <0> in package IGESSolid The ellipsoid is a solid bounded by the surface defined by: X^2 Y^2 Z^2 --— + --— + --— = 1 LX^2 LY^2 LZ^2 |
| CIGESSolid_Face | Defines Face, Type <510> Form Number <1> in package IGESSolid Face entity is a bound (partial) which has finite area |
| CIGESSolid_GeneralModule | Definition of General Services for IGESSolid (specific part) This Services comprise : Shared & Implied Lists, Copy, Check |
| CIGESSolid_Loop | Defines Loop, Type <508> Form Number <1> in package IGESSolid A Loop entity specifies a bound of a face. It represents a connected collection of face boundaries, seams, and poles of a single face |
| CIGESSolid_ManifoldSolid | Defines ManifoldSolid, Type <186> Form Number <0> in package IGESSolid A manifold solid is a bounded, closed, and finite volume in three dimensional Euclidean space |
| CIGESSolid_PlaneSurface | Defines PlaneSurface, Type <190> Form Number <0,1> in package IGESSolid A plane surface entity is defined by a point on the surface and a normal to it |
| CIGESSolid_Protocol | Description of Protocol for IGESSolid |
| CIGESSolid_ReadWriteModule | Defines Solid File Access Module for IGESSolid (specific parts) Specific actions concern : Read and Write Own Parameters of an IGESEntity |
| CIGESSolid_RightAngularWedge | Defines RightAngularWedge, Type <152> Form Number <0> in package IGESSolid A right angular wedge is a triangular/trapezoidal prism |
| CIGESSolid_SelectedComponent | Defines SelectedComponent, Type <182> Form Number <0> in package IGESSolid The Selected Component entity provides a means of selecting one component of a disjoint CSG solid |
| CIGESSolid_Shell | Defines Shell, Type <514> Form Number <1> in package IGESSolid Shell entity is a connected entity of dimensionality 2 which divides R3 into two arcwise connected open subsets, one of which is finite. Inside of the shell is defined to be the finite region. From IGES-5.3, Form can be <1> for Closed or <2> for Open |
| CIGESSolid_SolidAssembly | Defines SolidAssembly, Type <184> Form <0> in package IGESSolid Solid assembly is a collection of items which possess a shared fixed geometric relationship |
| CIGESSolid_SolidInstance | Defines SolidInstance, Type <430> Form Number <0> in package IGESSolid This provides a mechanism for replicating a solid representation |
| CIGESSolid_SolidOfLinearExtrusion | Defines SolidOfLinearExtrusion, Type <164> Form Number <0> in package IGESSolid Solid of linear extrusion is defined by translating an area determined by a planar curve |
| CIGESSolid_SolidOfRevolution | Defines SolidOfRevolution, Type <162> Form Number <0,1> in package IGESSolid This entity is defined by revolving the area determined by a planar curve about a specified axis through a given fraction of full rotation |
| CIGESSolid_SpecificModule | Defines Services attached to IGES Entities : Dump, for IGESSolid |
| CIGESSolid_Sphere | Defines Sphere, Type <158> Form Number <0> in package IGESSolid This defines a sphere with a center and radius |
| CIGESSolid_SphericalSurface | Defines SphericalSurface, Type <196> Form Number <0,1> in package IGESSolid Spherical surface is defined by a center and radius. In case of parametrised surface an axis and a reference direction is provided |
| CIGESSolid_ToolBlock | Tool to work on a Block. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule) |
| CIGESSolid_ToolBooleanTree | Tool to work on a BooleanTree. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule) |
| CIGESSolid_ToolConeFrustum | Tool to work on a ConeFrustum. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule) |
| CIGESSolid_ToolConicalSurface | Tool to work on a ConicalSurface. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule) |
| CIGESSolid_ToolCylinder | Tool to work on a Cylinder. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule) |
| CIGESSolid_ToolCylindricalSurface | Tool to work on a CylindricalSurface. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule) |
| CIGESSolid_ToolEdgeList | Tool to work on a EdgeList. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule) |
| CIGESSolid_ToolEllipsoid | Tool to work on a Ellipsoid. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule) |
| CIGESSolid_ToolFace | Tool to work on a Face. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule) |
| CIGESSolid_ToolLoop | Tool to work on a Loop. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule) |
| CIGESSolid_ToolManifoldSolid | Tool to work on a ManifoldSolid. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule) |
| CIGESSolid_ToolPlaneSurface | Tool to work on a PlaneSurface. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule) |
| CIGESSolid_ToolRightAngularWedge | Tool to work on a RightAngularWedge. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule) |
| CIGESSolid_ToolSelectedComponent | Tool to work on a SelectedComponent. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule) |
| CIGESSolid_ToolShell | Tool to work on a Shell. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule) |
| CIGESSolid_ToolSolidAssembly | Tool to work on a SolidAssembly. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule) |
| CIGESSolid_ToolSolidInstance | Tool to work on a SolidInstance. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule) |
| CIGESSolid_ToolSolidOfLinearExtrusion | Tool to work on a SolidOfLinearExtrusion. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule) |
| CIGESSolid_ToolSolidOfRevolution | Tool to work on a SolidOfRevolution. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule) |
| CIGESSolid_ToolSphere | Tool to work on a Sphere. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule) |
| CIGESSolid_ToolSphericalSurface | Tool to work on a SphericalSurface. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule) |
| CIGESSolid_ToolToroidalSurface | Tool to work on a ToroidalSurface. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule) |
| CIGESSolid_ToolTorus | Tool to work on a Torus. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule) |
| CIGESSolid_ToolVertexList | Tool to work on a VertexList. Called by various Modules (ReadWriteModule, GeneralModule, SpecificModule) |
| CIGESSolid_TopoBuilder | This class manages the creation of an IGES Topologic entity (BREP : ManifoldSolid, Shell, Face) This includes definiting of Vertex and Edge Lists, building of Edges and Loops |
| CIGESSolid_ToroidalSurface | Defines ToroidalSurface, Type <198> Form Number <0,1> in package IGESSolid This entity is defined by the center point, the axis direction and the major and minor radii. In case of parametrised surface a reference direction is provided |
| CIGESSolid_Torus | Defines Torus, Type <160> Form Number <0> in package IGESSolid A Torus is a solid formed by revolving a circular disc about a specified coplanar axis |
| CIGESSolid_VertexList | Defines VertexList, Type <502> Form Number <1> in package IGESSolid A vertex is a point in R3. A vertex is the bound of an edge and can participate in the bounds of a face. It contains one or more vertices |
| CIGESToBRep | Provides tools in order to transfer IGES entities to CAS.CADE |
| CIGESToBRep_Actor | This class performs the transfer of an Entity from IGESToBRep |
| CIGESToBRep_AlgoContainer | |
| CIGESToBRep_BasicCurve | Provides methods to transfer basic geometric curves entities from IGES to CASCADE. These can be: |
| CIGESToBRep_BasicSurface | Provides methods to transfer basic geometric surface entities from IGES to CASCADE. These can be: |
| CIGESToBRep_BRepEntity | Provides methods to transfer BRep entities ( VertexList 502, EdgeList 504, Loop 508, Face 510, Shell 514, ManifoldSolid 186) from IGES to CASCADE |
| CIGESToBRep_CurveAndSurface | Provides methods to transfer CurveAndSurface from IGES to CASCADE |
| CIGESToBRep_IGESBoundary | This class is intended to translate IGES boundary entity (142-CurveOnSurface, 141-Boundary or 508-Loop) into the wire. Methods Transfer are virtual and are redefined in Advanced Data Exchange to optimize the translation and take into account advanced parameters |
| CIGESToBRep_Reader | A simple way to read geometric IGES data. Encapsulates reading file and calling transfer tools |
| CIGESToBRep_ToolContainer | |
| CIGESToBRep_TopoCurve | Provides methods to transfer topologic curves entities from IGES to CASCADE |
| CIGESToBRep_TopoSurface | Provides methods to transfer topologic surfaces entities from IGES to CASCADE |
| CImage_AlienPixMap | Image class that support file reading/writing operations using auxiliary image library. Supported image formats: |
| CImage_ColorBGR | POD structure for packed BGR color value (3 bytes) |
| CImage_ColorBGR32 | POD structure for packed BGR color value (4 bytes with extra byte for alignment) |
| CImage_ColorBGRA | POD structure for packed BGRA color value (4 bytes) |
| CImage_ColorBGRAF | POD structure for packed float BGRA color value (4 floats) |
| CImage_ColorBGRF | POD structure for packed BGR float color value (3 floats) |
| CImage_ColorRGB | POD structure for packed RGB color value (3 bytes) |
| CImage_ColorRGB32 | POD structure for packed RGB color value (4 bytes with extra byte for alignment) |
| CImage_ColorRGBA | POD structure for packed RGBA color value (4 bytes) |
| CImage_ColorRGBAF | POD structure for packed RGBA color value (4 floats) |
| CImage_ColorRGBF | POD structure for packed float RGB color value (3 floats) |
| CImage_ColorRGF | POD structure for packed float RG color value (2 floats) |
| CImage_CompressedPixMap | Compressed pixmap data definition. It is defined independently from Image_PixMap, which defines only uncompressed formats |
| CImage_DDSParser | Auxiliary tool for parsing DDS file structure (without decoding) |
| CImage_Diff | This class compares two images pixel-by-pixel. It uses the following methods to ignore the difference between images: |
| CImage_PixMap | Class represents packed image plane |
| CImage_PixMapData | Structure to manage image buffer |
| CImage_PixMapTypedData | Structure to manage image buffer with predefined pixel type |
| CImage_SupportedFormats | Structure holding information about supported texture formats |
| CImage_Texture | Texture image definition. The image can be stored as path to image file, as file path with the given offset and as a data buffer of encoded image |
| CImage_VideoParams | Auxiliary structure defining video parameters. Please refer to FFmpeg documentation for defining text values |
| CImage_VideoRecorder | Video recording tool based on FFmpeg framework |
| CVideoRational | AVRational alias |
| CIMeshData_Curve | Interface class representing discrete 3d curve of edge. Indexation of points starts from zero |
| CIMeshData_Edge | Interface class representing discrete model of an edge |
| CIMeshData_Face | Interface class representing discrete model of a face. Face model contains one or several wires. First wire is always outer one |
| CIMeshData_Model | Interface class representing discrete model of a shape |
| CIMeshData_ParametersList | Interface class representing list of parameters on curve |
| CIMeshData_ParametersListArrayAdaptor | Auxiliary tool representing adaptor interface for child classes of IMeshData_ParametersList to be used in tools working on NCollection_Array structure |
| CIMeshData_PCurve | Interface class representing pcurve of edge associated with discrete face. Indexation of points starts from zero |
| CIMeshData_Shape | Interface class representing model with associated TopoDS_Shape. Intended for inheritance by structures and algorithms keeping reference TopoDS_Shape |
| CIMeshData_StatusOwner | Extension interface class providing status functionality |
| CIMeshData_TessellatedShape | Interface class representing shaped model with deflection |
| CIMeshData_Wire | Interface class representing discrete model of a wire. Wire should represent an ordered set of edges |
| CIMeshTools_Context | Interface class representing context of BRepMesh algorithm. Intended to cache discrete model and instances of tools for its processing |
| CIMeshTools_CurveTessellator | Interface class providing API for edge tessellation tools |
| CIMeshTools_MeshAlgo | Interface class providing API for algorithms intended to create mesh for discrete face |
| CIMeshTools_MeshAlgoFactory | Base interface for factories producing instances of triangulation algorithms taking into account type of surface of target face |
| CIMeshTools_MeshBuilder | Builds mesh for each face of shape without triangulation. In case if some faces of shape have already been triangulated checks deflection of existing polygonal model and re-uses it if deflection satisfies the specified parameter. Otherwise nullifies existing triangulation and build triangulation anew |
| CIMeshTools_ModelAlgo | Interface class providing API for algorithms intended to update or modify discrete model |
| CIMeshTools_ModelBuilder | Interface class represents API for tool building discrete model |
| CIMeshTools_Parameters | Structure storing meshing parameters |
| CIMeshTools_ShapeExplorer | Explores TopoDS_Shape for parts to be meshed - faces and free edges |
| CIMeshTools_ShapeVisitor | Interface class for shape visitor |
| CIntAna2d_AnaIntersection | Implementation of the analytical intersection between: |
| CIntAna2d_Conic | Definition of a conic by its implicit quadaratic equation: A.X**2 + B.Y**2 + 2.C.X*Y + 2.D.X + 2.E.Y + F = 0 |
| CIntAna2d_IntPoint | Geometrical intersection between two 2d elements |
| CIntAna_Curve | Definition of a parametric Curve which is the result of the intersection between two quadrics |
| CIntAna_Int3Pln | Intersection between 3 planes. The algorithm searches for an intersection point. If two of the planes are parallel or identical, IsEmpty returns TRUE |
| CIntAna_IntConicQuad | This class provides the analytic intersection between a conic defined as an element of gp (Lin,Circ,Elips, Parab,Hypr) and a quadric as defined in the class Quadric from IntAna. The intersection between a conic and a plane is treated as a special case |
| CIntAna_IntLinTorus | Intersection between a line and a torus |
| CIntAna_IntQuadQuad | This class provides the analytic intersection between a cylinder or a cone from gp and another quadric, as defined in the class Quadric from IntAna. This algorithm is used when the geometric intersection (class QuadQuadGeo from IntAna) returns no geometric solution. The result of the intersection may be |
| CIntAna_QuadQuadGeo | Geometric intersections between two natural quadrics (Sphere , Cylinder , Cone , Pln from gp). The possible intersections are : |
| CIntAna_Quadric | This class provides a description of Quadrics by their Coefficients in natural coordinate system |
| CIntCurve_IConicTool | Implementation of the ImpTool from IntImpParGen for conics of gp |
| CIntCurve_IntConicConic | Provides methods to intersect two conics. The exception ConstructionError is raised in constructors or in Perform methods when a domain (Domain from IntRes2d) is not correct, i-e when a Circle (Circ2d from gp) or an Ellipse (i-e Elips2d from gp) do not have a closed domain (use the SetEquivalentParameters method for a domain on a circle or an ellipse) |
| CIntCurve_IntImpConicParConic | |
| CIntCurve_MyImpParToolOfIntImpConicParConic | |
| CIntCurve_PConic | This class represents a conic from gp as a parametric curve ( in order to be used by the class PConicTool from IntCurve) |
| CIntCurve_PConicTool | Implementation of the ParTool from IntImpParGen for conics of gp, using the class PConic from IntCurve |
| CIntCurve_ProjectOnPConicTool | This class provides a tool which computes the parameter of a point near a parametric conic |
| CIntCurvesFace_Intersector | |
| CIntCurvesFace_ShapeIntersector | |
| CIntCurveSurface_HInter | |
| CIntCurveSurface_Intersection | |
| CIntCurveSurface_IntersectionPoint | Definition of an interserction point between a curve and a surface |
| CIntCurveSurface_IntersectionSegment | A IntersectionSegment describes a segment of curve (w1,w2) where distance(C(w),Surface) is less than a given tolerances |
| CIntCurveSurface_TheCSFunctionOfHInter | |
| CIntCurveSurface_TheExactHInter | |
| CIntCurveSurface_TheHCurveTool | |
| CIntCurveSurface_TheInterferenceOfHInter | |
| CIntCurveSurface_ThePolygonOfHInter | |
| CIntCurveSurface_ThePolygonToolOfHInter | |
| CIntCurveSurface_ThePolyhedronOfHInter | |
| CIntCurveSurface_ThePolyhedronToolOfHInter | |
| CIntCurveSurface_TheQuadCurvExactHInter | |
| CIntCurveSurface_TheQuadCurvFuncOfTheQuadCurvExactHInter | |
| CInterface_BitMap | A bit map simply allows to associate a boolean flag to each item of a list, such as a list of entities, etc... numbered between 1 and a positive count nbitems |
| CInterface_Category | This class manages categories A category is defined by a name and a number, and can be seen as a way of rough classification, i.e. less precise than a cdl type. Hence, it is possible to dispatch every entity in about a dozen of categories, twenty is a reasonable maximum |
| CInterface_Check | Defines a Check, as a list of Fail or Warning Messages under a literal form, which can be empty. A Check can also bring an Entity, which is the Entity to which the messages apply (this Entity may be any Transient Object) |
| CInterface_CheckIterator | Result of a Check operation (especially from InterfaceModel) |
| CInterface_CheckTool | Performs Checks on Entities, using General Service Library and Modules to work. Works on one Entity or on a complete Model |
| CInterface_CopyControl | This deferred class describes the services required by CopyTool to work. They are very simple and correspond basically to the management of an indexed map. But they can be provided by various classes which can control a Transfer. Each Starting Entity have at most one Result (Mapping one-one) |
| CInterface_CopyMap | Manages a Map for the need of single Transfers, such as Copies In such transfer, Starting Entities are read from a unique Starting Model, and each transferred Entity is bound to one and only one Result, which cannot be changed later |
| CInterface_CopyTool | Performs Deep Copies of sets of Entities Allows to perform Copy of Interface Entities from a Model to another one. Works by calling general services GetFromAnother and GetImplied. Uses a CopyMap to bind a unique Result to each Copied Entity |
| CInterface_EntityCluster | Auxiliary class for EntityList. An EntityList designates an EntityCluster, which brings itself an fixed maximum count of Entities. If it is full, it gives access to another cluster ("Next"). This class is intended to give a good compromise between access time (faster than a Sequence, good for little count) and memory use (better than a Sequence in any case, overall for little count, better than an Array for a very little count. It is designed for a light management. Remark that a new Item may not be Null, because this is the criterium used for "End of List" |
| CInterface_EntityIterator | Defines an Iterator on Entities. Allows considering of various criteria |
| CInterface_EntityList | This class defines a list of Entities (Transient Objects), it can be used as a field of other Transient classes, with these features : |
| CInterface_FileParameter | Auxiliary class to store a literal parameter in a file intermediate directory or in an UndefinedContent : a reference type Parameter detains an Integer which is used to address a record in the directory. FileParameter is intended to be stored in a ParamSet : hence memory management is performed by ParamSet, which calls Clear to work, while the Destructor (see Destroy) does nothing. Also a FileParameter can be read for consultation only, not to be read from a Structure to be included into another one |
| CInterface_FileReaderData | This class defines services which permit to access Data issued from a File, in a form which does not depend of physical format : thus, each Record has an attached ParamList (to be managed) and resulting Entity |
| CInterface_FileReaderTool | Defines services which are required to load an InterfaceModel from a File. Typically, it may firstly transform a system file into a FileReaderData object, then work on it, not longer considering file contents, to load an Interface Model. It may also work on a FileReaderData already loaded |
| CInterface_FloatWriter | This class converts a floating number (Real) to a string It can be used if the standard C-C++ output functions (Sprintf or std::cout<<) are not convenient. That is to say : |
| CInterface_GeneralLib | |
| CInterface_GeneralModule | This class defines general services, which must be provided for each type of Entity (i.e. of Transient Object processed by an Interface) : Shared List, Check, Copy, Delete, Category |
| CInterface_GlobalNodeOfGeneralLib | |
| CInterface_GlobalNodeOfReaderLib | |
| CInterface_Graph | Gives basic data structure for operating and storing graph results (usage is normally internal) Entities are Mapped according their Number in the Model |
| CInterface_GraphContent | Defines general form for classes of graph algorithms on Interfaces, this form is that of EntityIterator Each sub-class fills it according to its own algorithm This also allows to combine any graph result to others, all being given under one unique form |
| CInterface_GTool | GTool - General Tool for a Model Provides the functions performed by Protocol/GeneralModule for entities of a Model, and recorded in a GeneralLib Optimized : once an entity has been queried, the GeneralLib is not longer queried Shareable between several users : as a Handle |
| CInterface_HGraph | This class allows to store a redefinable Graph, via a Handle (useful for an Object which can work on several successive Models, with the same general conditions) |
| CInterface_InterfaceModel | Defines an (Indexed) Set of data corresponding to a complete Transfer by a File Interface, i.e. File Header and Transient Entities (Objects) contained in a File. Contained Entities are identified in the Model by unique and consecutive Numbers |
| CInterface_IntList | This class detains the data which describe a Graph. A Graph has two lists, one for shared refs, one for sharing refs (the reverses). Each list comprises, for each Entity of the Model of the Graph, a list of Entities (shared or sharing). In fact, entities are identified by their numbers in the Model or Graph : this gives better performances |
| CInterface_IntVal | An Integer through a Handle (i.e. managed as TShared) |
| CInterface_LineBuffer | Simple Management of a Line Buffer, to be used by Interface File Writers. While a String is suitable to do that, this class ensures an optimised Memory Management, because this is a hard point of File Writing |
| CInterface_MSG | This class gives a set of functions to manage and use a list of translated messages (messagery) |
| CInterface_NodeOfGeneralLib | |
| CInterface_NodeOfReaderLib | |
| CInterface_ParamList | |
| CInterface_ParamSet | Defines an ordered set of FileParameters, in a way to be efficient as in memory requirement or in speed |
| CInterface_Protocol | General description of Interface Protocols. A Protocol defines a set of Entity types. This class provides also the notion of Active Protocol, as a working context, defined once then exploited by various Tools and Libraries |
| CInterface_ReaderLib | |
| CInterface_ReaderModule | Defines unitary operations required to read an Entity from a File (see FileReaderData, FileReaderTool), under control of a FileReaderTool. The initial creation is performed by a GeneralModule (set in GeneralLib). Then, which remains is Loading data from the FileReaderData to the Entity |
| CInterface_ReportEntity | A ReportEntity is produced to acknowledge and memorize the binding between a Check and an Entity. The Check can bring Fails (+ Warnings if any), or only Warnings. If it is empty, the Report Entity is for an Unknown Entity |
| CInterface_ShareFlags | This class only says for each Entity of a Model, if it is Shared or not by one or more other(s) of this Model It uses the General Service "Shared" |
| CInterface_ShareTool | Builds the Graph of Dependencies, from the General Service "Shared" -> builds for each Entity of a Model, the Shared and Sharing Lists, and gives access to them. Allows to complete with Implied References (which are not regarded as Shared Entities, but are nevertheless Referenced), this can be useful for Reference Checking |
| CInterface_SignLabel | Signature to give the Label from the Model |
| CInterface_SignType | Provides the basic service to get a type name, according to a norm It can be used for other classes (general signatures ...) |
| CInterface_STAT | This class manages statistics to be queried asynchronously. Way of use : An operator describes a STAT form then fills it according to its progression. This produces a state of advancement of the process. This state can then be queried asynchronously : typically it is summarised as a percentage. There are also an identification of the current state, and information on processed volume |
| CInterface_Static | This class gives a way to manage meaningful static variables, used as "global" parameters in various procedures |
| CInterface_TypedValue | Now strictly equivalent to TypedValue from MoniTool, except for ParamType which remains for compatibility reasons |
| CInterface_UndefinedContent | Defines resources for an "Undefined Entity" : such an Entity is used to describe an Entity which complies with the Norm, but of an Unknown Type : hence it is kept under a literal form (avoiding to loose data). UndefinedContent offers a way to store a list of Parameters, as literals or references to other Entities |
| CInterval | |
| CIntf | Interference computation between polygons, lines and polyhedra with only triangular facets. These objects are polygonal representations of complex curves and triangulated representations of complex surfaces |
| CIntf_Interference | Describes the Interference computation result between polygon2d or polygon3d or polyhedron (as three sequences of points of intersection, polylines of intersection and zones de tangence) |
| CIntf_InterferencePolygon2d | Computes the interference between two polygons or the self intersection of a polygon in two dimensions |
| CIntf_Polygon2d | Describes the necessary polygon information to compute the interferences |
| CIntf_SectionLine | Describe a polyline of intersection between two polyhedra as a sequence of points of intersection |
| CIntf_SectionPoint | Describes an intersection point between polygons and polyedra |
| CIntf_TangentZone | Describes a zone of tangence between polygons or polyhedra as a sequence of points of intersection |
| CIntf_Tool | Provides services to create box for infinites lines in a given contexte |
| CIntImpParGen | Gives a generic algorithm to intersect Implicit Curves and Bounded Parametric Curves |
| CIntImpParGen_ImpTool | Template class for an implicit curve |
| CIntPatch_ALine | Implementation of an intersection line described by a parametrized curve |
| CIntPatch_ALineToWLine | |
| CIntPatch_ArcFunction | |
| CIntPatch_BVHTraversal | Performs BVH tree traversal of two polyhedra to find candidate triangle pairs for intersection testing. This class implements the BVH_PairTraverse interface to efficiently find potentially intersecting triangles using bounding box tests |
| CTrianglePair | Pair of triangle indices (both 1-based, original indices in polyhedra) |
| CIntPatch_CSFunction | This function is associated to the intersection between a curve on surface and a surface |
| CIntPatch_CurvIntSurf | |
| CIntPatch_GLine | Implementation of an intersection line represented by a conic |
| CIntPatch_HCurve2dTool | |
| CIntPatch_HInterTool | Tool for the intersection between 2 surfaces. Regroupe pour l instant les methodes hors Adaptor3d.. |
| CIntPatch_ImpImpIntersection | Implementation of the intersection between two quadric patches : Plane, Cone, Cylinder or Sphere |
| CIntPatch_ImpPrmIntersection | Implementation of the intersection between a natural quadric patch : Plane, Cone, Cylinder or Sphere and a bi-parametrised surface |
| CIntPatch_InterferencePolyhedron | Computes the interference between two polyhedra or the self interference of a polyhedron. Points of intersection, polylines of intersection and zones of tangence |
| CIntPatch_Intersection | This class provides a generic algorithm to intersect 2 surfaces |
| CIntPatch_Line | Definition of an intersection line between two surfaces. A line may be either geometric : line, circle, ellipse, parabola, hyperbola, as defined in the class GLine, or analytic, as defined in the class ALine, or defined by a set of points (coming from a walking algorithm) as defined in the class WLine |
| CIntPatch_LineConstructor | The intersections algorithms compute the intersection on two surfaces and return the intersections lines as IntPatch_Line |
| CIntPatch_Point | Definition of an intersection point between two surfaces. Such a point is contains geometrical information (see the Value method) and logical information |
| CIntPatch_PointLine | Definition of an intersection line between two surfaces. A line defined by a set of points (e.g. coming from a walking algorithm) as defined in the class WLine or RLine (Restriction line) |
| CIntPatch_PolyArc | |
| CIntPatch_Polygo | |
| CIntPatch_Polyhedron | This class provides a linear approximation of the PSurface. preview a constructor on a zone of a surface |
| CIntPatch_PolyhedronBVH | Wraps IntPatch_Polyhedron as a BVH_PrimitiveSet for efficient spatial queries. This class provides a BVH (Bounding Volume Hierarchy) representation of a polyhedron's triangles, enabling O(log n) spatial queries instead of linear search |
| CIntPatch_PolyhedronTool | Describe the signature of a polyhedral surface with only triangular facets and the necessary information to compute the interferences |
| CIntPatch_PolyLine | |
| CIntPatch_PrmPrmIntersection | Implementation of the Intersection between two bi-parametrised surfaces |
| CIntPatch_PrmPrmIntersection_T3Bits | |
| CIntPatch_RLine | Implementation of an intersection line described by a restriction line on one of the surfaces |
| CIntPatch_RstInt | Trouver les points d intersection entre la ligne de cheminement et les arcs de restriction |
| CIntPatch_SpecialPoints | |
| CIntPatch_TheIWalking | |
| CIntPatch_TheIWLineOfTheIWalking | |
| CIntPatch_ThePathPointOfTheSOnBounds | |
| CIntPatch_TheSearchInside | |
| CIntPatch_TheSegmentOfTheSOnBounds | |
| CIntPatch_TheSOnBounds | |
| CIntPatch_TheSurfFunction | |
| CIntPatch_WLine | Definition of set of points as a result of the intersection between 2 parametrised patches |
| CIntPatch_WLineTool | IntPatch_WLineTool provides set of static methods related to walking lines |
| CIntPolyh_Array | |
| CIntPolyh_Couple | The class represents the couple of indices with additional characteristics such as analyzed flag and an angle. In IntPolyh_MaillageAffinage algorithm the class is used as a couple of interfering triangles with the intersection angle |
| CIntPolyh_Edge | The class represents the edge built between the two IntPolyh points. It is linked to two IntPolyh triangles |
| CIntPolyh_Intersection | API algorithm for intersection of two surfaces by intersection of their triangulations |
| CIntPolyh_MaillageAffinage | Low-level algorithm to compute intersection of the surfaces by computing the intersection of their triangulations |
| CIntPolyh_Point | The class represents the point on the surface with both 3D and 2D points |
| CIntPolyh_PointNormal | Auxiliary structure to represent pair of point and normal vector in this point on the surface |
| CIntPolyh_SectionLine | |
| CIntPolyh_StartPoint | |
| CIntPolyh_Tools | The class provides tools for surface sampling |
| CIntPolyh_Triangle | The class represents the triangle built from three IntPolyh points and three IntPolyh edges |
| CIntRes2d_Domain | Definition of the domain of parameter on a 2d-curve. Most of the time, a domain is defined by two extremities. An extremity is made of : |
| CIntRes2d_Intersection | Defines the root class of all the Intersections between two 2D-Curves, and provides all the methods about the results of the Intersections Algorithms |
| CIntRes2d_IntersectionPoint | Definition of an intersection point between two 2D curves |
| CIntRes2d_IntersectionSegment | Definition of an intersection curve between two 2D curves |
| CIntRes2d_Transition | Definition of the type of transition near an intersection point between two curves. The transition is either a "true transition", which means that one of the curves goes inside or outside the area defined by the other curve near the intersection, or a "touch
transition" which means that the first curve does not cross the other one, or an "undecided" transition, which means that the curves are superposed |
| CIntrv_Interval | **--------—**** Other ***—* IsBefore ***-------—* IsJustBefore ***------------—* IsOverlappingAtStart ***---------------------—* IsJustEnclosingAtEnd ***--------------------------------—* IsEnclosing ***-—* IsJustOverlappingAtStart ***----------—* IsSimilar ***---------------------—* IsJustEnclosingAtStart ***-* IsInside ***---—* IsJustOverlappingAtEnd ***--------------—* IsOverlappingAtEnd ***-----—* IsJustAfter ***—* IsAfter |
| CIntrv_Intervals | The class Intervals is a sorted sequence of non overlapping Real Intervals |
| CIntStart_SITopolTool | Template class for a topological tool. This tool is linked with the surface on which the classification has to be made |
| CIntSurf | This package provides resources for all the packages concerning the intersection between surfaces |
| CIntSurf_Couple | Creation d 'un couple de 2 entiers |
| CIntSurf_InteriorPoint | Definition of a point solution of the intersection between an implicit an a parametrised surface. These points are passing points on the intersection lines, or starting points for the closed lines on the parametrised surface |
| CIntSurf_InteriorPointTool | This class provides a tool on the "interior point" that can be used to instantiates the Walking algorithms (see package IntWalk) |
| CIntSurf_LineOn2S | |
| CIntSurf_PathPoint | |
| CIntSurf_PathPointTool | |
| CIntSurf_PntOn2S | This class defines the geometric information for an intersection point between 2 surfaces : The coordinates ( Pnt from gp ), and two parametric coordinates |
| CIntSurf_Quadric | |
| CIntSurf_QuadricTool | This class provides a tool on a quadric that can be used to instantiates the Walking algorithms (see package IntWalk) with a Quadric from IntSurf as implicit surface |
| CIntSurf_Transition | Definition of the transition at the intersection between an intersection line and a restriction curve on a surface |
| CIntTools | Contains classes for intersection and classification purposes and accompanying classes |
| CIntTools_BaseRangeSample | Base class for range index management |
| CIntTools_BeanFaceIntersector | The class BeanFaceIntersector computes ranges of parameters on the curve of a bean(part of edge) that bound the parts of bean which are on the surface of a face according to edge and face tolerances. Warning: The real boundaries of the face are not taken into account, Most of the result parts of the bean lays only inside the region of the surface, which includes the inside of the face. And the parts which are out of this region can be excluded from the result |
| CIntTools_CommonPrt | The class is to describe a common part between two edges in 3D space |
| CIntTools_Context | The intersection Context contains geometrical and topological toolkit (classifiers, projectors, etc). The intersection Context is for caching the tools to increase the performance |
| CIntTools_Curve | The class is a container of one 3D curve, two 2D curves and two Tolerance values. It is used in the Face/Face intersection algorithm to store the results of intersection. In this context: the 3D curve is the intersection curve; the 2D curves are the PCurves of the 3D curve on the intersecting faces; the tolerance is the valid tolerance for 3D curve computed as maximal deviation between 3D curve and 2D curves (or surfaces in case there are no 2D curves); the tangential tolerance is the maximal distance from 3D curve to the end of the tangential zone between faces in terms of their tolerance values |
| CIntTools_CurveRangeLocalizeData | |
| CIntTools_CurveRangeSample | Class for range index management of curve |
| CIntTools_EdgeEdge | The class provides Edge/Edge intersection algorithm based on the intersection between edges bounding boxes |
| CIntTools_EdgeFace | The class provides Edge/Face intersection algorithm to determine common parts between edge and face in 3-d space. Common parts between Edge and Face can be: |
| CIntTools_FaceFace | This class provides the intersection of face's underlying surfaces |
| CIntTools_FClass2d | Class provides an algorithm to classify a 2d Point in 2d space of face using boundaries of the face |
| CIntTools_MarkedRangeSet | Class MarkedRangeSet provides continuous set of ranges marked with flags |
| CIntTools_PntOn2Faces | Contains two points PntOnFace from IntTools and a flag |
| CIntTools_PntOnFace | Contains a Face, a 3d point, corresponded UV parameters and a flag |
| CIntTools_Range | The class describes the 1-d range [myFirst, myLast] |
| CIntTools_Root | The class is to describe the root of function of one variable for Edge/Edge and Edge/Surface algorithms |
| CIntTools_ShrunkRange | The class provides the computation of a working (shrunk) range [t1, t2] for the 3D-curve of the edge |
| CIntTools_SurfaceRangeLocalizeData | |
| CIntTools_SurfaceRangeSample | Class for range index management of surface |
| CIntTools_Tools | The class contains handy static functions dealing with the geometry and topology |
| CIntTools_TopolTool | Class redefine methods of TopolTool from Adaptor3d concerning sample points |
| CIntTools_WLineTool | IntTools_WLineTool provides set of static methods related to walking lines |
| CIntWalk_PWalking | This class implements an algorithm to determine the intersection between 2 parametrized surfaces, marching from a starting point. The intersection line starts and ends on the natural surface's boundaries |
| CIntWalk_TheFunctionOfTheInt2S | |
| CIntWalk_TheInt2S | |
| CIntWalk_WalkingData | |
| CIVtk_Interface | Base interface for visualisation component |
| CIVtk_IShape | Interface for working with a shape and its sub-shapes ids |
| CIVtk_IShapeData | Interface for working with triangulated data |
| CIVtk_IShapeMesher | Interface for triangulator of 3D shapes |
| CIVtk_IShapePickerAlgo | Interface for 3D shapes picking algorithm |
| CIVtk_IView | Interface for obtaining view transformation parameters |
| CIVtkDraw | |
| CIVtkWinParams | VTK window creation parameters |
| CIVtkDraw_HighlightAndSelectionPipeline | |
| CIVtkDraw_Interactor | |
| CIVtkOCC_SelectableObject | Class with selection primitives used by OCCT selection algorithm |
| CIVtkOCC_Shape | OCC implementation of IShape interface |
| CIVtkOCC_ShapeMesher | OCC implementation of IMesher interface |
| CIVtkOCC_ShapePickerAlgo | OCC implementation of 3D shapes picking algorithm |
| CIVtkOCC_ViewerSelector | Class that implements OCCT selection algorithm |
| CIVtkTools_DisplayModeFilter | Cells filter according to the selected display mode by mesh parts types. This filter is used to get parts of a shape according to different display modes |
| CIVtkTools_ShapeDataSource | VTK data source for OCC shapes polygonal data |
| CIVtkTools_ShapeObject | VTK holder class for OCC shapes to pass them through pipelines |
| CIVtkTools_ShapePicker | VTK picker for OCC shapes with OCC selection algorithm |
| CIVtkTools_SubPolyDataFilter | Cells filter according to the given set of cells ids |
| CIVtkVTK_ShapeData | IShapeData implementation for VTK |
| CIVtkVTK_View | ICamera implementation for VTK |
| CLaw | Multiple services concerning 1d functions |
| CLaw_BSpFunc | Law Function based on a BSpline curve 1d. Package methods and classes are implemented in package Law to construct the basis curve with several constraints |
| CLaw_BSpline | Definition of the 1D B_spline curve |
| CLaw_BSplineKnotSplitting | For a B-spline curve the discontinuities are localised at the knot values and between two knots values the B-spline is infinitely continuously differentiable. At a knot of range index the continuity is equal to: Degree - Mult (Index) where Degree is the degree of the basis B-spline functions and Mult the multiplicity of the knot of range Index. If for your computation you need to have B-spline curves with a minima of continuity it can be interesting to know between which knot values, a B-spline curve arc, has a continuity of given order. This algorithm computes the indexes of the knots where you should split the curve, to obtain arcs with a constant continuity given at the construction time. The splitting values are in the range [FirstUKnotValue, LastUKnotValue] (See class B-spline curve from package Geom). If you just want to compute the local derivatives on the curve you don't need to create the B-spline curve arcs, you can use the functions LocalD1, LocalD2, LocalD3, LocalDN of the class BSplineCurve |
| CLaw_Composite | Loi composite constituee d une liste de lois de ranges consecutifs. Cette implementation un peu lourde permet de reunir en une seule loi des portions de loi construites de facon independantes (par exemple en interactif) et de lancer le walking d un coup a l echelle d une ElSpine. CET OBJET REPOND DONC A UN PROBLEME D IMPLEMENTATION SPECIFIQUE AUX CONGES!!! |
| CLaw_Constant | Loi constante |
| CLaw_Function | Root class for evolution laws |
| CLaw_Interpol | Provides an evolution law that interpolates a set of parameter and value pairs (wi, radi) |
| CLaw_Interpolate | This class is used to interpolate a BsplineCurve passing through an array of points, with a C2 Continuity if tangency is not requested at the point. If tangency is requested at the point the continuity will be C1. If Perodicity is requested the curve will be closed and the junction will be the first point given. The curve will than be only C1 |
| CLaw_Linear | Describes an linear evolution law |
| CLaw_S | Describes an "S" evolution law |
| CLDOM_Attr | |
| CLDOM_BasicAttribute | |
| CLDOM_BasicElement | |
| CLDOM_BasicNode | |
| CLDOM_BasicText | |
| CLDOM_CDATASection | |
| CLDOM_CharacterData | |
| CLDOM_CharReference | |
| CLDOM_Comment | |
| CLDOM_Document | |
| CLDOM_DocumentType | |
| CLDOM_Element | |
| CLDOM_LDOMImplementation | |
| CLDOM_MemManager | |
| CLDOM_Node | |
| CLDOM_NodeList | |
| CLDOM_OSStream | Subclass if std::ostream allowing to increase performance of outputting data into a string avoiding reallocation of buffer. Class LDOM_OSStream implements output into a sequence of strings and getting the result as a string. It inherits Standard_OStream (std::ostream). Beside methods of std::ostream, it also has additional useful methods: str(), Length() and Clear() |
| CLDOM_SBuffer | Class LDOM_SBuffer inherits std::streambuf and redefines some virtual methods of it (overflow() and xsputn()). This class contains pointers on first and current element of sequence, also it has methods for the sequence management |
| CLDOM_Text | |
| CLDOM_XmlReader | |
| CLDOM_XmlWriter | |
| CLDOMBasicString | |
| CLDOMParser | |
| CLDOMString | |
| CLocalAnalysis | This package gives tools to check the local continuity between two points situated on two curves or two surfaces |
| CLocalAnalysis_CurveContinuity | This class gives tools to check local continuity C0 C1 C2 G1 G2 between two points situated on two curves |
| CLocalAnalysis_SurfaceContinuity | This class gives tools to check local continuity C0 C1 C2 G1 G2 between two points situated on two surfaces |
| CLocOpe | Provides tools to implement local topological operations on a shape |
| CLocOpe_BuildShape | |
| CLocOpe_BuildWires | |
| CLocOpe_CSIntersector | This class provides the intersection between a set of axis or a circle and the faces of a shape. The intersection points are sorted in increasing parameter along each axis or circle |
| CLocOpe_CurveShapeIntersector | This class provides the intersection between an axis or a circle and the faces of a shape. The intersection points are sorted in increasing parameter along the axis |
| CLocOpe_DPrism | Defines a pipe (near from Pipe from BRepFill), with modifications provided for the Pipe feature |
| CLocOpe_FindEdges | |
| CLocOpe_FindEdgesInFace | |
| CLocOpe_GeneratedShape | |
| CLocOpe_Generator | |
| CLocOpe_GluedShape | |
| CLocOpe_Gluer | |
| CLocOpe_LinearForm | Defines a linear form (using Prism from BRepSweep) with modifications provided for the LinearForm feature |
| CLocOpe_Pipe | Defines a pipe (near from Pipe from BRepFill), with modifications provided for the Pipe feature |
| CLocOpe_PntFace | |
| CLocOpe_Prism | Defines a prism (using Prism from BRepSweep) with modifications provided for the Prism feature |
| CLocOpe_Revol | Defines a prism (using Prism from BRepSweep) with modifications provided for the Prism feature |
| CLocOpe_RevolutionForm | Defines a revolution form (using Revol from BRepSweep) with modifications provided for the RevolutionForm feature |
| CLocOpe_SplitDrafts | This class provides a tool to realize the following operations on a shape: |
| CLocOpe_Spliter | |
| CLocOpe_SplitShape | Provides a tool to cut: |
| CLocOpe_WiresOnShape | |
| CLProp_CurAndInf | Stores the parameters of a curve 2d or 3d corresponding to the curvature's extremas and the Inflection's Points |
| CMAT2d_BiInt | BiInt is a set of two integers |
| CMAT2d_Circuit | Constructs a circuit on a set of lines. EquiCircuit gives a Circuit passing by all the lines in a set and all the connexions of the minipath associated |
| CMAT2d_Connexion | A Connexion links two lines of items in a set of lines. It contains two points and their paramatric definitions on the lines. The items can be points or curves |
| CMAT2d_CutCurve | Cuts a curve at the extremas of curvature and at the inflections. Constructs a trimmed Curve for each interval |
| CMAT2d_Mat2d | This class contains the generic algorithm of computation of the bisecting locus |
| CMAT2d_MiniPath | MiniPath computes a path to link all the lines in a set of lines. The path is described as a set of connexions |
| CMAT2d_Tool2d | Set of the methods useful for the MAT's computation. Tool2d contains the geometry of the bisecting locus |
| CMAT_Arc | An Arc is associated to each Bisecting of the mat |
| CMAT_BasicElt | A BasicELt is associated to each elementary constituent of the figure |
| CMAT_Bisector | |
| CMAT_Edge | |
| CMAT_Graph | The Class Graph permits the exploration of the Bisector Locus |
| CMAT_ListOfBisector | |
| CMAT_ListOfEdge | |
| CMAT_Node | Node of Graph |
| CMAT_TListNodeOfListOfBisector | |
| CMAT_TListNodeOfListOfEdge | |
| CMAT_Zone | |
| Cmath | |
| Cmath_BFGS | This class implements the Broyden-Fletcher-Goldfarb-Shanno variant of Davidson-Fletcher-Powell minimization algorithm of a function of multiple variables.Knowledge of the function's gradient is required |
| Cmath_BissecNewton | This class implements a combination of Newton-Raphson and bissection methods to find the root of the function between two bounds. Knowledge of the derivative is required |
| Cmath_BracketedRoot | This class implements the Brent method to find the root of a function located within two bounds. No knowledge of the derivative is required |
| Cmath_BracketMinimum | Given two distinct initial points, BracketMinimum implements the computation of three points (a, b, c) which bracket the minimum of the function and verify A less than B, B less than C and F(B) less than F(A), F(B) less than F(C) |
| Cmath_BrentMinimum | This class implements the Brent's method to find the minimum of a function of a single variable. No knowledge of the derivative is required |
| Cmath_BullardGenerator | Fast random number generator (the algorithm proposed by Ian C. Bullard) |
| Cmath_ComputeGaussPointsAndWeights | |
| Cmath_ComputeKronrodPointsAndWeights | |
| Cmath_Crout | This class implements the Crout algorithm used to solve a system A*X = B where A is a symmetric matrix. It can be used to invert a symmetric matrix. This algorithm is similar to Gauss but is faster than Gauss. Only the inferior triangle of A and the diagonal can be given |
| Cmath_DirectPolynomialRoots | This class implements the calculation of all the real roots of a real polynomial of degree <= 4 using direct algebraic methods. The implementation uses Ferrari's method for quartics, Cardano's formula for cubics, and numerically stable algorithms for quadratics and linear equations |
| Cmath_DoubleTab | |
| Cmath_EigenValuesSearcher | This class finds eigenvalues and eigenvectors of real symmetric tridiagonal matrices |
| Cmath_FRPR | This class implements the Fletcher-Reeves-Polak_Ribiere minimization algorithm of a function of multiple variables. Knowledge of the function's gradient is required |
| Cmath_Function | This abstract class describes the virtual functions associated with a Function of a single variable |
| Cmath_FunctionAllRoots | This algorithm uses a sample of the function to find all intervals on which the function is null, and afterwards uses the FunctionRoots algorithm to find the points where the function is null outside the "null intervals". Knowledge of the derivative is required |
| Cmath_FunctionRoot | This class implements the computation of a root of a function of a single variable which is near an initial guess using a minimization algorithm.Knowledge of the derivative is required. The algorithm used is the same as in |
| Cmath_FunctionRoots | This class implements an algorithm which finds all the real roots of a function with derivative within a given range. Knowledge of the derivative is required |
| Cmath_FunctionSample | This class gives a default sample (constant difference of parameter) for a function defined between two bound A,B |
| Cmath_FunctionSet | This abstract class describes the virtual functions associated to a set on N Functions of M independent variables |
| Cmath_FunctionSetRoot | Calculates the root of a set of N functions of M variables (N<M, N=M or N>M). Knowing an initial guess of the solution and using a minimization algorithm, a search is made in the Newton direction and then in the Gradient direction if there is no success in the Newton direction. This algorithm can also be used for functions minimization. Knowledge of all the partial derivatives (the Jacobian) is required |
| Cmath_FunctionSetWithDerivatives | This abstract class describes the virtual functions associated with a set of N Functions each of M independent variables |
| Cmath_FunctionWithDerivative | This abstract class describes the virtual functions associated with a function of a single variable for which the first derivative is available |
| Cmath_Gauss | This class implements the Gauss LU decomposition (Crout algorithm) with partial pivoting (rows interchange) of a square matrix and the different possible derived calculation : |
| Cmath_GaussLeastSquare | This class implements the least square solution of a set of n linear equations of m unknowns (n >= m) using the gauss LU decomposition algorithm. This algorithm is more likely subject to numerical instability than math_SVD |
| Cmath_GaussMultipleIntegration | This class implements the integration of a function of multiple variables between the parameter bounds Lower[a..b] and Upper[a..b]. Warning: Each element of Order must be inferior or equal to 61 |
| Cmath_GaussSetIntegration | This class implements the integration of a set of N functions of M variables variables between the parameter bounds Lower[a..b] and Upper[a..b]. Warning: The case M>1 is not implemented |
| Cmath_GaussSingleIntegration | This class implements the integration of a function of a single variable between the parameter bounds Lower and Upper. Warning: Order must be inferior or equal to 61 |
| Cmath_GlobOptMin | This class represents Evtushenko's algorithm of global optimization based on non-uniform mesh. Article: Yu. Evtushenko. Numerical methods for finding global extreme (case of a non-uniform mesh). U.S.S.R. Comput. Maths. Math. Phys., Vol. 11, N 6, pp. 38-54 |
| Cmath_Householder | This class implements the least square solution of a set of linear equations of m unknowns (n >= m) using the Householder method. It solves A.X = B. This algorithm has more numerical stability than GaussLeastSquare but is longer. It must be used if the matrix is singular or nearly singular. It is about 16% longer than GaussLeastSquare if there is only one member B to solve. It is about 30% longer if there are twenty B members to solve |
| Cmath_Jacobi | This class implements the Jacobi method to find the eigenvalues and the eigenvectors of a real symmetric square matrix. A sort of eigenvalues is done |
| Cmath_KronrodSingleIntegration | This class implements the Gauss-Kronrod method of integral computation |
| Cmath_Matrix | This class implements the real matrix abstract data type. Matrixes can have an arbitrary range which must be defined at the declaration and cannot be changed after this declaration math_Matrix(-3,5,2,4); //a vector with range [-3..5, 2..4] Matrix values may be initialized and retrieved using indexes which must lie within the range of definition of the matrix. Matrix objects follow "value semantics", that is, they cannot be shared and are copied through assignment Matrices are copied through assignment: |
| Cmath_MultipleVarFunction | Describes the virtual functions associated with a multiple variable function |
| Cmath_MultipleVarFunctionWithGradient | The abstract class MultipleVarFunctionWithGradient describes the virtual functions associated with a multiple variable function |
| Cmath_MultipleVarFunctionWithHessian | |
| Cmath_NewtonFunctionRoot | This class implements the calculation of a root of a function of a single variable starting from an initial near guess using the Newton algorithm. Knowledge of the derivative is required |
| Cmath_NewtonFunctionSetRoot | This class computes the root of a set of N functions of N variables, knowing an initial guess at the solution and using the Newton Raphson algorithm. Knowledge of all the partial derivatives (Jacobian) is required |
| Cmath_NewtonMinimum | |
| Cmath_Powell | This class implements the Powell method to find the minimum of function of multiple variables (the gradient does not have to be known) |
| Cmath_PSO | In this class implemented variation of Particle Swarm Optimization (PSO) method. A. Ismael F. Vaz, L. N. Vicente "A particle swarm pattern search method for bound constrained global optimization" |
| Cmath_PSOParticlesPool | |
| Cmath_SVD | SVD implements the solution of a set of N linear equations of M unknowns without condition on N or M. The Singular Value Decomposition algorithm is used. For singular or nearly singular matrices SVD is a better choice than Gauss or GaussLeastSquare |
| Cmath_TrigonometricEquationFunction | This is function, which corresponds trigonometric equation a*std::cos(x)*std::cos(x) + 2*b*std::cos(x)*Sin(x) + c*std::cos(x) + d*Sin(x) + e = 0 See class math_TrigonometricFunctionRoots |
| Cmath_TrigonometricFunctionRoots | This class implements the solutions of the equation a*std::cos(x)*std::cos(x) + 2*b*std::cos(x)*Sin(x) + c*std::cos(x) + d*Sin(x) + e The degree of this equation can be 4, 3 or 2 |
| Cmath_Uzawa | This class implements a system resolution C*X = B with an approach solution X0. There are no conditions on the number of equations. The algorithm used is the Uzawa algorithm. It is possible to have equal or inequal (<) equations to solve. The resolution is done with a minimization of Norm(X-X0). If there are only equal equations, the resolution is directly done and is similar to Gauss resolution with an optimisation because the matrix is a symmetric matrix. (The resolution is done with Crout algorithm) |
| Cmath_ValueAndWeight | Simple container storing two reals: value and weight |
| Cmath_VectorBase | This class implements the real vector abstract data type. Vectors can have an arbitrary range which must be defined at the declaration and cannot be changed after this declaration |
| CMedia_BufferPool | AVBufferPool wrapper |
| CMedia_CodecContext | AVCodecContext wrapper - the coder/decoder holder |
| CMedia_FormatContext | AVFormatContext wrapper - the media input/output stream holder |
| CMedia_Frame | AVFrame wrapper - the frame (decoded image/audio sample data) holder |
| CMedia_IFrameQueue | Interface defining frame queuing |
| CMedia_Packet | AVPacket wrapper - the packet (data chunk for decoding/encoding) holder |
| CMedia_PlayerContext | Player context |
| CMedia_Scaler | SwsContext wrapper - tool performing image scaling and pixel format conversion |
| CMedia_Timer | Auxiliary class defining the animation timer |
| CMeshTest | Provides methods for testing the mesh algorithms |
| CMeshTest_CheckTopology | This class checks topology of the mesh presented by triangulations of faces |
| CMeshVS_Buffer | |
| CMeshVS_CommonSensitiveEntity | Sensitive entity covering entire mesh for global selection |
| CMeshVS_DataSource | The deferred class using for the following tasks: 1) Receiving geometry data about single element of node by its number; 2) Receiving type of element or node by its number; 3) Receiving topological information about links between element and nodes it consist of; 4) Receiving information about what element cover this node; 5) Receiving information about all nodes and elements the object consist of 6) Activation of advanced mesh selection. In the advanced mesh selection mode there is created: |
| CMeshVS_DataSource3D | |
| CMeshVS_DeformedDataSource | The class provides default class which helps to represent node displacements by deformed mesh This class has an internal handle to canonical non-deformed mesh data source and map of displacement vectors. The displacement can be magnified to useful size. All methods is implemented with calling the corresponding methods of non-deformed data source |
| CMeshVS_Drawer | This class provided the common interface to share between classes big set of constants affecting to object appearance. By default, this class can store integers, doubles, OCC colors, OCC materials. Each of OCC enum members can be stored as integers |
| CMeshVS_DummySensitiveEntity | This class allows to create owners to all elements or nodes, both hidden and shown, but these owners user cannot select "by hands" in viewer. They means for internal application tasks, for example, receiving all owners, both for hidden and shown entities |
| CMeshVS_ElementalColorPrsBuilder | This class provides methods to create presentation of elements with assigned colors. The class contains two color maps: map of same colors for front and back side of face and map of different ones, |
| CMeshVS_MeshEntityOwner | The custom owner. This class provides methods to store owner information: 1) An address of element or node data structure 2) Type of node or element owner assigned 3) ID of node or element owner assigned |
| CMeshVS_MeshOwner | The custom mesh owner used for advanced mesh selection. This class provides methods to store information: 1) IDs of hilighted mesh nodes and elements 2) IDs of mesh nodes and elements selected on the mesh |
| CMeshVS_MeshPrsBuilder | This class provides methods to compute base mesh presentation |
| CMeshVS_NodalColorPrsBuilder | This class provides methods to create presentation of nodes with assigned color. There are two ways of presentation building |
| CMeshVS_PrsBuilder | This class is parent for all builders using in MeshVS_Mesh. It provides base fields and methods all buildes need |
| CMeshVS_SensitiveFace | This class provides custom sensitive face, which will be selected if it center is in rectangle |
| CMeshVS_SensitiveMesh | This class provides custom mesh sensitive entity used in advanced mesh selection |
| CMeshVS_SensitivePolyhedron | This class is used to detect selection of a polyhedron. The main principle of detection algorithm is to search for overlap with each polyhedron's face separately, treating them as planar convex polygons |
| CMeshVS_SensitiveQuad | This class contains description of planar quadrangle and defines methods for its detection by OCCT BVH selection mechanism |
| CMeshVS_SensitiveSegment | This class provides custom sensitive face, which will be selected if it center is in rectangle |
| CMeshVS_SymmetricPairHasher | Provides symmetric hash methods pair of integers |
| CMeshVS_TextPrsBuilder | This class provides methods to create text data presentation. It store map of texts assigned with nodes or elements |
| CMeshVS_Tool | This class provides auxiliary methods to create different aspects |
| CMeshVS_TwoColors | |
| CMeshVS_TwoNodes | Structure containing two IDs (of nodes) for using as a key in a map (as representation of a mesh link) |
| CMeshVS_VectorPrsBuilder | This class provides methods to create vector data presentation. It store map of vectors assigned with nodes or elements. In simplified mode vectors draws with thickened ends instead of arrows |
| CMessage | Defines |
| CMessage_Alert | Base class of the hierarchy of classes describing various situations occurring during execution of some algorithm or procedure |
| CMessage_AlertExtended | Inherited class of Message_Alert with some additional information. It has Message_Attributes to provide the alert name, and other custom information It has a container of composite alerts, if the alert might provide sub-alerts collecting |
| CMessage_Algorithm | Class Message_Algorithm is intended to be the base class for classes implementing algorithms or any operations that need to provide extended information on its execution to the caller / user |
| CMessage_Attribute | Additional information of extended alert attribute To provide other custom attribute container, it might be redefined |
| CMessage_AttributeMeter | Alert object storing alert metrics values. Start and stop values for each metric |
| CMessage_AttributeObject | Alert object storing a transient object |
| CMessage_AttributeStream | Alert object storing stream value |
| CMessage_CompositeAlerts | Class providing container of alerts |
| CMessage_ExecStatus | |
| CMessage_LazyProgressScope | Progress scope with lazy updates and abort fetches |
| CMessage_Level | This class is an instance of Sentry to create a level in a message report Constructor of the class add new (active) level in the report, destructor removes it While the level is active in the report, new alerts are added below the level root alert |
| CMessage_Messenger | Messenger is API class providing general-purpose interface for libraries that may issue text messages without knowledge of how these messages will be further processed |
| CStreamBuffer | Auxiliary class wrapping std::stringstream thus allowing constructing message via stream interface, and putting result into its creator Message_Messenger within destructor |
| CMessage_Msg | This class provides a tool for constructing the parametrized message basing on resources loaded by Message_MsgFile tool |
| CMessage_MsgFile | A tool providing facility to load definitions of message strings from resource file(s) |
| CMessage_Printer | Abstract interface class defining printer as output context for text messages |
| CMessage_PrinterOStream | Implementation of a message printer associated with an std::ostream The std::ostream may be either externally defined one (e.g. std::cout), or file stream maintained internally (depending on constructor) |
| CMessage_PrinterSystemLog | Implementation of a message printer associated with system log. Implemented for the following systems: |
| CMessage_PrinterToReport | Implementation of a message printer associated with Message_Report Send will create a new alert of the report. If string is sent, an alert is created by Eol only. The alerts are sent into set report or default report of Message |
| CMessage_ProgressIndicator | Defines abstract interface from program to the user. This includes progress indication and user break mechanisms |
| CMessage_ProgressRange | Auxiliary class representing a part of the global progress scale allocated by a step of the progress scope, see Message_ProgressScope::Next() |
| CMessage_ProgressScope | Message_ProgressScope class provides convenient way to advance progress indicator in context of complex program organized in hierarchical way, where usually it is difficult (or even not possible) to consider process as linear with fixed step |
| CMessage_ProgressSentry | Functionality of this class (Message_ProgressSentry) has been superseded by Message_ProgressScope. This class is kept just to simplify transition of an old code and will be removed in future |
| CMessage_Report | Container for alert messages, sorted according to their gravity |
| CMoniTool_AttrList | AttrList allows to record a list of attributes as Transients which can be edited, changed ... Each one is identified by a name |
| CMoniTool_CaseData | This class is intended to record data attached to a case to be exploited. Cases can be : |
| CMoniTool_DataInfo | Gives information on an object Used as template to instantiate Elem, etc This class is for Transient |
| CMoniTool_Element | Element allows to map any kind of object as a Key for a Map. This works by defining, for a Hash Code, that of the real Key, not of the Element which acts only as an intermediate. When a Map asks for the HashCode of a Element, this one returns the code it has determined at creation time |
| CMoniTool_IntVal | An Integer through a Handle (i.e. managed as TShared) |
| CMoniTool_RealVal | A Real through a Handle (i.e. managed as TShared) |
| CMoniTool_SignShape | Signs HShape according to its real content (type of Shape) Context is not used |
| CMoniTool_SignText | Provides the basic service to get a text which identifies an object in a context It can be used for other classes (general signatures ...) It can also be used to build a message in which an object is to be identified |
| CMoniTool_Stat | This class manages Statistics to be queried asynchronously |
| CMoniTool_Timer | Provides convenient service on global timers accessed by string name, mostly aimed for debugging purposes |
| CMoniTool_TimerSentry | A tool to facilitate using MoniTool_Timer functionality by automatically ensuring consistency of start/stop actions |
| CMoniTool_TransientElem | TransientElem defines an Element for a specific input class its definition includes the value of the Key to be mapped, and the HashCoder associated to the class of the Key |
| CMoniTool_TypedValue | This class allows to dynamically manage .. typed values, i.e. values which have an alphanumeric expression, but with controls. Such as "must be an Integer" or "Enumerative Text" etc |
| CMyDirectPolynomialRoots | |
| CNCollection_AccAllocator | Class NCollection_AccAllocator - accumulating memory allocator. This class allocates memory on request returning the pointer to the allocated space. The allocation units are grouped in blocks requested from the system as required. This memory is returned to the system when all allocations in a block are freed |
| CAlignedSize | Size value aligned to a 4 byte boundary |
| CAlignedPtr | A pointer aligned to a 4 byte boundary |
| CKey | A key for the map of blocks |
| CHasher | Key hasher |
| CBlock | Descriptor of a block |
| CNCollection_AliasedArray | Defines an array of values of configurable size. For instance, this class allows defining an array of 32-bit or 64-bit integer values with bitness determined in runtime. The element size in bytes (stride) should be specified at construction time. Indexation starts from 0 index. As actual type of element varies at runtime, element accessors are defined as templates. Memory for array is allocated with the given alignment (template parameter) |
| CNCollection_AlignedAllocator | NCollection allocator with managed memory alignment capabilities |
| CNCollection_Allocator | Implements allocator requirements as defined in ISO C++ Standard 2003, section 20.1.5 |
| Crebind | |
| CNCollection_Array1 | The class NCollection_Array1 represents unidimensional arrays of fixed size known at run time. The range of the index is user defined. An array1 can be constructed with a "C array". This functionality is useful to call methods expecting an Array1. It allows to carry the bounds inside the arrays |
| CNCollection_Array2 | |
| CNCollection_BaseAllocator | |
| CNCollection_BaseList | |
| CIterator | Memory allocation |
| CNCollection_BaseMap | |
| CIterator | Memory allocation |
| CNCollection_BaseSequence | |
| CIterator | Memory allocation |
| CNCollection_Buffer | Low-level buffer object |
| CNCollection_CellFilter | |
| CListNode | |
| CCell | |
| CCellHasher | |
| CNCollection_DataMap | |
| CDataMapNode | |
| CIterator | |
| CNCollection_DefaultHasher | |
| CNCollection_DefaultHasher< TheKeyType * > | Explicit specialization for bool |
| CNCollection_DoubleMap | |
| CDoubleMapNode | |
| CIterator | |
| CNCollection_DynamicArray | Class NCollection_DynamicArray (dynamic array of objects) |
| CDynamicIterator | |
| CNCollection_EBTree | |
| CNCollection_FlatDataMap | High-performance hash map using open addressing with Robin Hood hashing |
| CIterator | Forward iterator for NCollection_FlatDataMap |
| CNCollection_FlatMap | High-performance hash set using open addressing with Robin Hood hashing |
| CIterator | Forward iterator for NCollection_FlatMap |
| CNCollection_ForwardRange | Standalone range wrapper for OCCT iterators |
| CNCollection_ForwardRangeIterator | STL input iterator that wraps an OCCT More()/Next() iterator |
| CPostfixProxy | Postfix increment: captures the current value, then advances. Returns a proxy holding the old value (safe for non-copyable hosts) |
| CNCollection_ForwardRangeSentinel | Empty sentinel type used as the end marker for range-for loops |
| CNCollection_Haft | Template CLI class providing the way to encapsulate instance of C++ class as a field in the C++/CLI (ref) class |
| CNCollection_Handle | Purpose: This template class is used to define Handle adaptor for allocated dynamically objects of arbitrary type |
| CNCollection_HArray1 | Template class for Handle-managed 1D arrays. Inherits from both NCollection_Array1<TheItemType> and Standard_Transient, providing reference-counted array functionality |
| CNCollection_HArray2 | Template class for Handle-managed 2D arrays. Inherits from both NCollection_Array2<TheItemType> and Standard_Transient, providing reference-counted 2D array functionality |
| CNCollection_HeapAllocator | |
| CNCollection_HSequence | Template class for Handle-managed sequences. Inherits from both NCollection_Sequence<TheItemType> and Standard_Transient, providing reference-counted sequence functionality |
| CNCollection_IncAllocator | |
| CIBlock | Forward list to keep multi-time allocated pointers. On Reset operation objects will be reused |
| CNCollection_IndexedDataMap | |
| CIterator | Implementation of the Iterator interface |
| CNCollection_IndexedIterator | Helper class that allows to use NCollection iterators as STL iterators. NCollection iterator can be extended to STL iterator of any category by adding necessary methods: STL forward iterator requires IsEqual method, STL bidirectional iterator requires Previous method, and STL random access iterator requires Offset and Differ methods. See NCollection_DynamicArray as example of declaring custom STL iterators |
| CNCollection_IndexedMap | |
| CIndexedMapNode | Adaptation of the TListNode to the INDEXEDmap |
| CIterator | |
| CNCollection_Iterator | Helper class that allows to use NCollection iterators as STL iterators. NCollection iterator can be extended to STL iterator of any category by adding necessary methods: STL forward iterator requires IsEqual method, STL bidirectional iterator requires Previous method, and STL random access iterator requires Offset and Differ methods. See NCollection_DynamicArray as example of declaring custom STL iterators |
| CNCollection_KDTree | Static KD-Tree for efficient point set queries |
| CNCollection_Lerp | Simple linear interpolation tool (also known as mix() in GLSL). The main purpose of this template class is making interpolation routines more readable |
| CNCollection_Lerp< gp_Trsf > | Linear interpolation tool for transformation defined by gp_Trsf |
| CNCollection_LinearVector | Contiguous dynamic array using a flat memory buffer |
| CNCollection_List | |
| CNCollection_ListNode | |
| CNCollection_LocalArray | Auxiliary class optimizing creation of array buffer (using stack allocation for small arrays) |
| CInlineStorageTrivial | Inline storage for trivial types: typed array with direct element access |
| CInlineStorageNonTrivial | Inline storage for non-trivial types: raw aligned bytes for placement new |
| CNCollection_Map | |
| CMapNode | Adaptation of the TListNode to the map notations |
| CIterator | Implementation of the Iterator interface |
| CNCollection_Mat3 | 3x3 Matrix class. Warning, empty constructor returns an identity matrix |
| CNCollection_Mat4 | Generic matrix of 4 x 4 elements. To be used in conjunction with NCollection_Vec4 entities. Originally introduced for 3D space projection and orientation operations. Warning, empty constructor returns an identity matrix |
| CNCollection_OccAllocator | Implements allocator requirements as defined in ISO C++ Standard 2003, section 20.1.5 |
| Crebind | |
| CNCollection_OrderedDataMap | Hash map that preserves insertion order |
| COrderedDataMapNode | Adaptation of the TListNode to the ordered data map notations. Extends the hash-chain node with insertion-order linked list pointers |
| CIterator | Implementation of the Iterator interface. Iterates in insertion order by walking the doubly-linked list |
| CNCollection_OrderedMap | Hash set that preserves insertion order |
| COrderedMapNode | Adaptation of the TListNode to the ordered map notations. Extends the hash-chain node with insertion-order linked list pointers |
| CIterator | Implementation of the Iterator interface. Iterates in insertion order by walking the doubly-linked list |
| CNCollection_PackedMap | Optimized Map for integer values of various integral types |
| CIterator | Iterator of class NCollection_PackedMap |
| CNCollection_SeqNode | |
| CNCollection_Sequence | |
| CNode | Class defining sequence node - for internal use by Sequence |
| CIterator | Implementation of the Iterator interface |
| CNCollection_Shared | Template defining a class derived from the specified base class and Standard_Transient, and supporting OCCT RTTI |
| CNCollection_SparseArray | |
| CConstIterator | |
| CIterator | |
| CNCollection_SparseArrayBase | |
| CIterator | |
| CNCollection_StlIterator | Helper class that allows to use NCollection iterators as STL iterators. NCollection iterator can be extended to STL iterator of any category by adding necessary methods: STL forward iterator requires IsEqual method, STL bidirectional iterator requires Previous method, and STL random access iterator requires Offset and Differ methods. See NCollection_DynamicArray as example of declaring custom STL iterators |
| CNCollection_TListIterator | |
| CNCollection_TListNode | |
| CNCollection_UBTree | |
| CSelector | Memory allocation |
| CTreeNode | |
| CNCollection_UBTreeFiller | |
| CObjBnd | Structure of pair (object, bnd box) |
| CNCollection_UtfIterator | Template class for Unicode strings support |
| CNCollection_UtfString | This template class represent constant UTF-* string. String stored in memory continuously, always NULL-terminated and can be used as standard C-string using ToCString() method |
| CNCollection_Vec2 | Defines the 2D-vector template. The main target for this class - to handle raw low-level arrays (from/to graphic driver etc.) |
| CNCollection_Vec3 | Generic 3-components vector. To be used as RGB color pixel or XYZ 3D-point. The main target for this class - to handle raw low-level arrays (from/to graphic driver etc.) |
| CNCollection_Vec4 | Generic 4-components vector. To be used as RGBA color vector or XYZW 3D-point with special W-component for operations with projection / model view matrices. Use this class for 3D-points carefully because declared W-component may results in incorrect results if used without matrices |
| CNCollection_WinHeapAllocator | This memory allocator creates dedicated heap for allocations. This technics available only on Windows platform (no alternative on Unix systems). It may be used to take control over memory fragmentation because on destruction ALL allocated memory will be released to the system |
| CNLPlate_HGPPConstraint | Define a PinPoint geometric Constraint used to load a Non Linear Plate |
| CNLPlate_HPG0Constraint | Define a PinPoint G0 Constraint used to load a Non Linear Plate |
| CNLPlate_HPG0G1Constraint | Define a PinPoint G0+G1 Constraint used to load a Non Linear Plate |
| CNLPlate_HPG0G2Constraint | Define a PinPoint G0+G2 Constraint used to load a Non Linear Plate |
| CNLPlate_HPG0G3Constraint | Define a PinPoint G0+G3 Constraint used to load a Non Linear Plate |
| CNLPlate_HPG1Constraint | Define a PinPoint (no G0) G1 Constraint used to load a Non Linear Plate |
| CNLPlate_HPG2Constraint | Define a PinPoint (no G0) G2 Constraint used to load a Non Linear Plate |
| CNLPlate_HPG3Constraint | Define a PinPoint (no G0) G3 Constraint used to load a Non Linear Plate |
| CNLPlate_NLPlate | |
| COpenGl_ArbDbg | Debug context routines |
| COpenGl_ArbFBO | FBO is available on OpenGL 2.0+ hardware |
| COpenGl_ArbFBOBlit | FBO blit is available in OpenGL 3.0+. Moved out from OpenGl_ArbFBO since it is unavailable in OpenGL ES 2.0 |
| COpenGl_ArbIns | Instancing is available on OpenGL 3.0+ hardware (in core since OpenGL 3.1 or GL_ARB_draw_instanced extension) |
| COpenGl_ArbSamplerObject | Provide Sampler Object functionality (texture parameters stored independently from texture itself). Available since OpenGL 3.3+ (GL_ARB_sampler_objects extension) and OpenGL ES 3.0+ |
| COpenGl_ArbTBO | TBO is available on OpenGL 3.0+ and OpenGL ES 3.2+ hardware |
| COpenGl_ArbTexBindless | Provides bindless textures. This extension allows OpenGL applications to access texture objects in shaders without first binding each texture to one of a limited number of texture image units |
| COpenGl_Aspects | The element holding Graphic3d_Aspects |
| COpenGl_AspectsProgram | OpenGl resources for custom shading program |
| COpenGl_AspectsSprite | OpenGl resources for custom point sprites |
| COpenGl_AspectsTextureSet | OpenGl resources for custom textures |
| COpenGl_BackgroundArray | Tool class for generating reusable data for gradient or texture background rendering |
| COpenGl_GradientParameters | |
| COpenGl_Buffer | Buffer Object - is a general storage object for arbitrary data (see sub-classes) |
| COpenGl_BufferCompatT | Compatibility layer for old OpenGL without VBO. Make sure to pass pointer from GetDataOffset() instead of NULL. Method GetDataOffset() returns pointer to real data in this class (while base class OpenGl_VertexBuffer always return NULL) |
| COpenGl_CappingAlgo | Capping surface rendering algorithm |
| COpenGl_CappingPlaneResource | Container of graphical resources for rendering capping plane associated to graphical clipping plane. This resource holds data necessary for OpenGl_CappingAlgo. This object is implemented as OpenGl resource for the following reasons: |
| COpenGl_Caps | Class to define graphic driver capabilities. Notice that these options will be ignored if particular functionality does not provided by GL driver |
| COpenGl_Clipping | This class contains logics related to tracking and modification of clipping plane state for particular OpenGl context. It contains information about enabled clipping planes and provides method to change clippings in context. The methods should be executed within OpenGl context associated with instance of this class |
| COpenGl_ClippingIterator | The iterator through clipping planes |
| COpenGl_ClippingState | Defines generic state of OCCT clipping state |
| COpenGl_Context | This class generalize access to the GL context and available extensions |
| COpenGl_DepthPeeling | Class provides FBOs for dual depth peeling |
| COpenGl_Element | Base interface for drawable elements |
| COpenGl_ElementNode | |
| COpenGl_ExtGS | Geometry shader as extension is available on OpenGL 2.0+ |
| COpenGl_Flipper | Being rendered, the elements modifies current model-view matrix such that the axes of the specified reference system (in model space) become oriented in the following way: |
| COpenGl_Font | Texture font |
| CTile | Simple structure stores tile rectangle |
| CRectI | |
| COpenGl_FrameBuffer | Short declaration of useful collection types |
| COpenGl_FrameStats | Class storing the frame statistics |
| COpenGl_FrameStatsPrs | Element rendering frame statistics |
| COpenGl_GlCore11 | OpenGL 1.1 core. Notice that all functions within this structure are actually exported by system GL library. The main purpose for these hint - to control visibility of functions per GL version (global functions should not be used directly to achieve this effect!) |
| COpenGl_GlCore11Fwd | OpenGL 1.1 core without deprecated Fixed Pipeline entry points. Notice that all functions within this structure are actually exported by system GL library. The main purpose for these hint - to control visibility of functions per GL version (global functions should not be used directly to achieve this effect!) |
| COpenGl_GlCore12 | OpenGL 1.2 core based on 1.1 version |
| COpenGl_GlCore13 | OpenGL 1.3 without deprecated entry points |
| COpenGl_GlCore14 | OpenGL 1.4 core based on 1.3 version |
| COpenGl_GlCore15 | OpenGL 1.5 core based on 1.4 version |
| COpenGl_GlCore20 | OpenGL 2.0 core based on 1.5 version |
| COpenGl_GlCore21 | OpenGL 2.1 core based on 2.0 version |
| COpenGl_GlCore30 | OpenGL 3.0 core. This is first version with deprecation model introduced |
| COpenGl_GlCore31 | OpenGL 3.1 definition |
| COpenGl_GlCore32 | OpenGL 3.2 definition |
| COpenGl_GlCore33 | OpenGL 3.3 definition |
| COpenGl_GlCore40 | OpenGL 4.0 definition |
| COpenGl_GlCore41 | OpenGL 4.1 definition |
| COpenGl_GlCore42 | OpenGL 4.2 definition |
| COpenGl_GlCore43 | OpenGL 4.3 definition |
| COpenGl_GlCore44 | OpenGL 4.4 definition |
| COpenGl_GlCore45 | OpenGL 4.5 definition |
| COpenGl_GlCore46 | OpenGL 4.6 definition |
| COpenGl_GlFunctions | Mega structure defines the complete list of OpenGL functions |
| COpenGl_GraduatedTrihedron | This class allows to render Graduated Trihedron, i.e. trihedron with grid. it is based on Graphic3d_GraduatedTrihedron parameters and support its customization on construction level only |
| COpenGl_GraphicDriver | This class defines an OpenGl graphic driver |
| COpenGl_GraphicDriverFactory | This class for creation of OpenGl_GraphicDriver |
| COpenGl_Group | Implementation of low-level graphic group |
| COpenGl_HaltonSampler | Compute points of the Halton sequence with digit-permutations for different bases |
| COpenGl_IndexBuffer | Index buffer is just a VBO with special target (GL_ELEMENT_ARRAY_BUFFER) |
| COpenGl_LayerList | Class defining the list of layers |
| COpenGl_LayerStack | Stack of references to existing layers of predefined maximum size |
| COpenGl_LightSourceState | Defines state of OCCT light sources |
| COpenGl_LineAttributes | Utility class to manage OpenGL resources of polygon hatching styles |
| COpenGl_Material | OpenGL material definition |
| COpenGl_MaterialCommon | OpenGL material definition |
| COpenGl_MaterialPBR | OpenGL material definition |
| COpenGl_MaterialState | Defines generic state of material properties |
| COpenGl_MatrixState | Software implementation for OpenGL matrix stack |
| COpenGl_ModelWorldState | Defines state of OCCT model-world transformation |
| COpenGl_NamedResource | Named resource object |
| COpenGl_OitState | Defines generic state of order-independent transparency rendering properties |
| COpenGl_PBREnvironment | This class contains specular and diffuse maps required for Image Base Lighting (IBL) in PBR shading model with it's generation methods |
| COpenGl_PointSprite | Point sprite resource. On modern hardware it will be texture with extra parameters. On ancient hardware sprites will be drawn using bitmaps |
| COpenGl_PrimitiveArray | Class for rendering of arbitrary primitive array |
| COpenGl_ProjectionState | Defines state of OCCT projection transformation |
| COpenGl_RaytraceGeometry | Stores geometry of ray-tracing scene |
| COpenGl_RaytraceLight | Stores properties of OpenGL light source |
| COpenGl_RaytraceMaterial | Stores properties of surface material |
| CPhysical | Physically-based material properties (used in path tracing engine) |
| COpenGl_Resource | Interface for OpenGl resource with following meaning: |
| COpenGl_Sampler | Class implements OpenGL sampler object resource that stores the sampling parameters for a texture access |
| COpenGl_SetOfPrograms | Alias to programs array of predefined length |
| COpenGl_SetOfShaderPrograms | Alias to 2D programs array of predefined length |
| COpenGl_SetterInterface | Interface for generic setter of user-defined uniform variables |
| COpenGl_ShaderGrid | State and geometry model of the OpenGl shader-rendered grid |
| COpenGl_ShaderManager | List of shader programs |
| COpenGl_ShaderLightParameters | Packed properties of light source |
| COpenGl_ShaderProgramFFP | Fake OpenGL program for tracking FFP state in the way consistent to programmable pipeline |
| COpenGl_ShaderObject | Wrapper for OpenGL shader object |
| COpenGl_ShaderProgram | Wrapper for OpenGL program object |
| COpenGl_ShaderUniformLocation | Simple class represents GLSL program variable location |
| COpenGl_ShadowMap | This class contains shadow mapping resources |
| COpenGl_ShadowMapArray | Array of shadow maps |
| COpenGl_StateCounter | Tool class to implement consistent state counter for objects inside the same driver instance |
| COpenGl_StateInterface | Defines interface for OpenGL state |
| COpenGl_StencilTest | |
| COpenGl_Structure | Implementation of low-level graphic structure |
| COpenGl_StructureShadow | Dummy structure which just redirects to groups of another structure |
| COpenGl_Text | Text rendering |
| COpenGl_TextBuilder | This class generates primitive array required for rendering textured text using OpenGl_Font instance |
| COpenGl_Texture | Texture resource |
| COpenGl_TextureBuffer | Texture Buffer Object. This is a special 1D texture that VBO-style initialized. The main differences from general 1D texture: |
| COpenGl_TextureFormat | Stores parameters of OpenGL texture format |
| COpenGl_TextureFormatSelector | Selects preferable texture format for specified parameters |
| COpenGl_TextureFormatSelector< GLbyte > | Specialization for signed byte |
| COpenGl_TextureFormatSelector< GLfloat > | Specialization for float |
| COpenGl_TextureFormatSelector< GLint > | Specialization for signed int |
| COpenGl_TextureFormatSelector< GLshort > | Specialization for signed short |
| COpenGl_TextureFormatSelector< GLubyte > | Specialization for unsigned byte |
| COpenGl_TextureFormatSelector< GLuint > | Specialization for unsigned int |
| COpenGl_TextureFormatSelector< GLushort > | Specialization for unsigned short |
| COpenGl_TextureSet | Class holding array of textures to be mapped as a set. Textures should be defined in ascending order of texture units within the set |
| CTextureSlot | Texture slot - combination of Texture and binding Unit |
| CIterator | Class for iterating texture set |
| COpenGl_TextureSetPairIterator | Class for iterating pair of texture sets through each defined texture slot. Note that iterator considers texture slots being in ascending order within OpenGl_TextureSet |
| COpenGl_TileSampler | Tool object used for sampling screen tiles according to estimated pixel variance (used in path tracing engine). To improve GPU thread coherency, rendering window is split into pixel blocks or tiles. The important feature of this approach is that it is possible to keep the same number of tiles for any screen resolution (e.g. 256 tiles can be used for both 512 x 512 window and 1920 x 1080 window). So, a smaller number of tiles allows to increase interactivity (FPS), but at the cost of higher per-frame variance ('noise'). On the contrary a larger number of tiles decrease interactivity, but leads to lower per-frame variance. Note that the total time needed to produce final final image is the same for both cases |
| COpenGl_TriangleSet | Triangulation of single OpenGL primitive array |
| COpenGl_UniformBuffer | Uniform buffer object |
| COpenGl_VariableSetter | |
| COpenGl_VariableSetterSelector | List of OpenGL shader objects |
| COpenGl_VertexBuffer | Vertex Buffer Object - is a general storage object for vertex attributes (position, normal, color). Notice that you should use OpenGl_IndexBuffer specialization for array of indices |
| COpenGl_VertexBufferEditor | Auxiliary class to iteratively modify data of existing VBO. It provides iteration interface with delayed CPU->GPU memory transfer to avoid slow per-element data transfer. User should explicitly call Flush() method to ensure that all data is transferred to VBO. Temporary buffer on CPU side can be initialized with lesser capacity than VBO to allow re-usage of shared buffer with fixed size between VBOs |
| COpenGl_View | Implementation of OpenGl view |
| CShaderSource | Tool class for management of shader sources |
| CRaytracingParams | Compile-time ray-tracing parameters |
| CStructState | Describes state of OpenGL structure |
| COpenGl_Window | This class represents low-level wrapper over window with GL context. The window itself should be provided to constructor |
| COpenGl_Workspace | Rendering workspace. Provides methods to render primitives and maintain GL state |
| COpenGl_WorldViewState | Defines state of OCCT world-view transformation |
| COpenGlTest | This package defines a set of Draw commands for testing of TKOpenGl library |
| COSD | Set of Operating System Dependent (OSD) tools |
| COSD_CachedFileSystem | File system keeping last stream created by linked file system (OSD_FileSystem::DefaultFileSystem() by default) to be reused for opening a stream with the same URL. Note that as file is kept in opened state, application will need destroying this object to ensure all files being closed. This interface could be handy in context of reading numerous objects pointing to the same file (at different offset). Make sure to create a dedicated OSD_CachedFileSystem for each working thread to avoid data races |
| COSD_CachedStream | |
| COSD_Chronometer | This class measures CPU time (both user and system) consumed by current process or thread. The chronometer can be started and stopped multiple times, and measures cumulative time |
| COSD_Directory | Management of directories (a set of directory oriented tools) |
| COSD_DirectoryIterator | Manages a breadth-only search for sub-directories in the specified Path. There is no specific order of results |
| COSD_Disk | Disk management (a set of disk oriented tools) |
| COSD_Environment | Management of system environment variables An environment variable is composed of a variable name and its value |
| COSD_Error | Accurate management of OSD specific errors |
| COSD_File | Basic tools to manage files Warning: 'ProgramError' is raised when somebody wants to use the methods Read, Write, Seek, Close when File is not open |
| COSD_FileIterator | Manages a breadth-only search for files in the specified Path. There is no specific order of results |
| COSD_FileNode | A class for 'File' and 'Directory' grouping common methods (file/directory manipulation tools). The "file oriented" name means files or directories which are in fact hard coded as files |
| COSD_FileSystem | Base interface for a file stream provider. It is intended to be implemented for specific file protocol |
| COSD_FileSystemSelector | File system implementation which tried to open stream using registered list of file systems |
| COSD_Host | Carries information about a Host System version ,host name, nodename .. |
| COSD_LocalFileSystem | A file system opening local files (or files from mount systems) |
| COSD_MemInfo | This class provide information about memory utilized by current process. This information includes: |
| COSD_Parallel | Simple tool for code parallelization |
| CUniversalIterator | Fixed-type iterator, implementing STL forward iterator interface, used for iteration over objects subject to parallel processing. It stores pointer to instance of polymorphic iterator inheriting from IteratorInterface, which contains actual type-specific iterator |
| CFunctorInterface | Interface class representing functor object. Intended to add polymorphic behaviour to For and ForEach functionality enabling execution of arbitrary function in parallel mode |
| COSD_Path | |
| COSD_PerfMeter | This class enables measuring the CPU time between two points of code execution, regardless of the scope of these points of code. A meter is identified by its name (string). So multiple objects in various places of user code may point to the same meter. The results will be printed on stdout upon finish of the program. For details see OSD_PerfMeter.h |
| COSD_Process | A set of system process tools |
| COSD_Protection | This class provides data to manage file protection Example:These rights are treated in a system dependent manner: On UNIX you have User,Group and Other rights On VMS you have Owner,Group,World and System rights An automatic conversion is done between OSD and UNIX/VMS |
| COSD_SharedLibrary | Interface to dynamic library loader. Provides tools to load a shared library and retrieve the address of an entry point |
| COSD_StreamBuffer | A file stream implementation initialized from std::shared_ptr<std::streambuf> |
| COSD_Thread | A simple platform-intependent interface to execute and control threads |
| COSD_ThreadPool | Class defining a thread pool for executing algorithms in multi-threaded mode. Thread pool allocates requested amount of threads and keep them alive (in sleep mode when unused) during thread pool lifetime. The same pool can be used by multiple consumers, including nested multi-threading algorithms and concurrent threads: |
| CJobInterface | Thread function interface |
| CEnumeratedThread | Thread with back reference to thread pool and thread index in it |
| CLauncher | Launcher object locking a subset of threads (or all threads) in a thread pool to perform parallel execution of the job |
| CJobRange | Auxiliary class which ensures exclusive access to iterators of processed data pool |
| CJob | Auxiliary wrapper class for thread function |
| COSD_Timer | Working on heterogeneous platforms we need to use the system call gettimeofday. This function is portable and it measures ELAPSED time and CPU time in seconds and microseconds. Example: OSD_Timer aTimer; aTimer.Start(); // Start the timers (t1). ..... // Do something. aTimer.Stop(); // Stop the timers (t2). aTimer.Show(); // Give the elapsed time between t1 and t2. // Give also the process CPU time between // t1 and t2 |
| Cparlist | |
| CPCDM | |
| CPCDM_Document | |
| CPCDM_DOMHeaderParser | |
| CPCDM_Reader | |
| CPCDM_ReaderFilter | Class represents a document reading filter |
| CPCDM_ReadWriter | |
| CPCDM_ReadWriter_1 | |
| CPCDM_Reference | |
| CPCDM_ReferenceIterator | |
| CPCDM_RetrievalDriver | |
| CPCDM_StorageDriver | Persistent implementation of storage |
| CPCDM_Writer | |
| CPeriodicInterval | |
| CPeriodicityInfo | |
| CPlate_D1 | Define an order 1 derivatives of a 3d valued function of a 2d variable |
| CPlate_D2 | Define an order 2 derivatives of a 3d valued function of a 2d variable |
| CPlate_D3 | Define an order 3 derivatives of a 3d valued function of a 2d variable |
| CPlate_FreeGtoCConstraint | Define a G1, G2 or G3 constraint on the Plate using weaker constraint than GtoCConstraint |
| CPlate_GlobalTranslationConstraint | Force a set of UV points to translate without deformation |
| CPlate_GtoCConstraint | Define a G1, G2 or G3 constraint on the Plate |
| CPlate_LinearScalarConstraint | Define on or several constraints as linear combination of the X,Y and Z components of a set of PinPointConstraint |
| CPlate_LinearXYZConstraint | Define on or several constraints as linear combination of PinPointConstraint unlike the LinearScalarConstraint, usage of this kind of constraint preserve the X,Y and Z uncoupling |
| CPlate_LineConstraint | Constraint a point to belong to a straight line |
| CPlate_PinpointConstraint | Define a constraint on the Plate |
| CPlate_PlaneConstraint | Constraint a point to belong to a Plane |
| CPlate_Plate | This class implement a variational spline algorithm able to define a two variable function satisfying some constraints and minimizing an energy like criterion |
| CPlate_SampledCurveConstraint | Define m PinPointConstraint driven by m unknown |
| CPLib | PLib means Polynomial functions library. This pk provides basic computation functions for polynomial functions. Note: weight arrays can be passed by pointer for some functions so that NULL pointer is valid. That means no weights passed |
| CPLib_HermitJacobi | This class provides method to work with Jacobi Polynomials relatively to an order of constraint q = myWorkDegree-2*(myNivConstr+1) Jk(t) for k=0,q compose the Jacobi Polynomial base relatively to the weight W(t) iorder is the integer value for the constraints: iorder = 0 <=> ConstraintOrder = GeomAbs_C0 iorder = 1 <=> ConstraintOrder = GeomAbs_C1 iorder = 2 <=> ConstraintOrder = GeomAbs_C2 P(t) = H(t) + W(t) * Q(t) Where W(t) = (1-t**2)**(2*iordre+2) the coefficients JacCoeff represents P(t) JacCoeff are stored as follow: |
| CPLib_JacobiPolynomial | This class provides method to work with Jacobi Polynomials relatively to an order of constraint q = myWorkDegree-2*(myNivConstr+1) Jk(t) for k=0,q compose the Jacobi Polynomial base relatively to the weight W(t) iorder is the integer value for the constraints: iorder = 0 <=> ConstraintOrder = GeomAbs_C0 iorder = 1 <=> ConstraintOrder = GeomAbs_C1 iorder = 2 <=> ConstraintOrder = GeomAbs_C2 P(t) = R(t) + W(t) * Q(t) Where W(t) = (1-t**2)**(2*iordre+2) the coefficients JacCoeff represents P(t) JacCoeff are stored as follow: |
| CPlugin | |
| CPoly | This package provides classes and services to handle: |
| CPoly_ArrayOfNodes | Defines an array of 3D nodes of single/double precision configurable at construction time |
| CPoly_ArrayOfUVNodes | Defines an array of 2D nodes of single/double precision configurable at construction time |
| CPoly_CoherentLink | |
| CPoly_CoherentNode | |
| CPoly_CoherentTriangle | |
| CPoly_CoherentTriangulation | Definition of HANDLE object using Standard_DefineHandle.hxx |
| CIteratorOfTriangle | |
| CIteratorOfNode | |
| CIteratorOfLink | |
| CTwoIntegers | Couple of integer indices (used in RemoveDegenerated()) |
| CPoly_CoherentTriPtr | |
| CIterator | |
| CPoly_Connect | Provides an algorithm to explore, inside a triangulation, the adjacency data for a node or a triangle. Adjacency data for a node consists of triangles which contain the node. Adjacency data for a triangle consists of: |
| CPoly_MakeLoops | |
| CLink | The Link structure |
| CHasher | |
| CHelper | The abstract helper class |
| CHeapOfInteger | This class implements a heap of integers. The most effective usage of it is first to add there all items, and then get top item and remove any items till it becomes empty |
| CPoly_MakeLoops2D | |
| CHelper | The abstract helper class |
| CPoly_MakeLoops3D | |
| CHelper | The abstract helper class |
| CPoly_MergeNodesTool | Auxiliary tool for merging triangulation nodes for visualization purposes. Tool tries to merge all nodes within input triangulation, but split the ones on sharp corners at specified angle |
| CPoly_Polygon2D | Provides a polygon in 2D space (for example, in the parametric space of a surface). It is generally an approximate representation of a curve. A Polygon2D is defined by a table of nodes. Each node is a 2D point. If the polygon is closed, the point of closure is repeated at the end of the table of nodes |
| CPoly_Polygon3D | This class Provides a polygon in 3D space. It is generally an approximate representation of a curve. A Polygon3D is defined by a table of nodes. Each node is a 3D point. If the polygon is closed, the point of closure is repeated at the end of the table of nodes. If the polygon is an approximate representation of a curve, you can associate with each of its nodes the value of the parameter of the corresponding point on the curve |
| CPoly_PolygonOnTriangulation | This class provides a polygon in 3D space, based on the triangulation of a surface. It may be the approximate representation of a curve on the surface, or more generally the shape. A PolygonOnTriangulation is defined by a table of nodes. Each node is an index in the table of nodes specific to a triangulation, and represents a point on the surface. If the polygon is closed, the index of the point of closure is repeated at the end of the table of nodes. If the polygon is an approximate representation of a curve on a surface, you can associate with each of its nodes the value of the parameter of the corresponding point on the curve.represents a 3d Polygon |
| CPoly_Triangle | Describes a component triangle of a triangulation (Poly_Triangulation object). A Triangle is defined by a triplet of nodes within [1, Poly_Triangulation::NbNodes()] range. Each node is an index in the table of nodes specific to an existing triangulation of a shape, and represents a point on the surface |
| CPoly_Triangulation | Provides a triangulation for a surface, a set of surfaces, or more generally a shape |
| CPoly_TriangulationParameters | Represents initial set of parameters triangulation is built for |
| CPolygonOnTriHashKey | |
| CPrecision | The Precision package offers a set of functions defining precision criteria for use in conventional situations when comparing two numbers. Generalities It is not advisable to use floating number equality. Instead, the difference between numbers must be compared with a given precision, i.e. : double x1, x2 ; x1 = ... x2 = ... If ( x1 == x2 ) ... should not be used and must be written as indicated below: double x1, x2 ; double Precision = ... x1 = ... x2 = ... If ( Abs ( x1 - x2 ) < Precision ) ... Likewise, when ordering floating numbers, you must take the following into account : double x1, x2 ; double Precision = ... x1 = ... ! a large number x2 = ... ! another large number If ( x1 < x2 - Precision ) ... is incorrect when x1 and x2 are large numbers ; it is better to write : double x1, x2 ; double Precision = ... x1 = ... ! a large number x2 = ... ! another large number If ( x2 - x1 > Precision ) ... Precision in Cas.Cade Generally speaking, the precision criterion is not implicit in Cas.Cade. Low-level geometric algorithms accept precision criteria as arguments. As a rule, they should not refer directly to the precision criteria provided by the Precision package. On the other hand, high-level modeling algorithms have to provide the low-level geometric algorithms that they call, with a precision criteria. One way of doing this is to use the above precision criteria. Alternatively, the high-level algorithms can have their own system for precision management. For example, the Topology Data Structure stores precision criteria for each elementary shape (as a vertex, an edge or a face). When a new topological object is constructed, the precision criteria are taken from those provided by the Precision package, and stored in the related data structure. Later, a topological algorithm which analyses these objects will work with the values stored in the data structure. Also, if this algorithm is to build a new topological object, from these precision criteria, it will compute a new precision criterion for the new topological object, and write it into the data structure of the new topological object. The different precision criteria offered by the Precision package, cover the most common requirements of geometric algorithms, such as intersections, approximations, and so on. The choice of precision depends on the algorithm and on the geometric space. The geometric space may be : |
| CProjLib | The ProjLib package first provides projection of curves on a plane along a given Direction. The result will be a 3D curve |
| CProjLib_CompProjectedCurve | |
| CProjLib_ComputeApprox | Approximate the projection of a 3d curve on an analytic surface and stores the result in Approx. The result is a 2d curve. For approximation some parameters are used, including required tolerance of approximation. Tolerance is maximal possible value of 3d deviation of 3d projection of projected curve from "exact" 3d projection. Since algorithm searches 2d curve on surface, required 2d tolerance is computed from 3d tolerance with help of U,V resolutions of surface. 3d and 2d tolerances have sense only for curves on surface, it defines precision of projecting and approximation and have nothing to do with distance between the projected curve and the surface |
| CProjLib_ComputeApproxOnPolarSurface | Approximate the projection of a 3d curve on an polar surface and stores the result in Approx. The result is a 2d curve. The evaluation of the current point of the 2d curve is done with the evaluation of the extrema P3d - Surface. For approximation some parameters are used, including required tolerance of approximation. Tolerance is maximal possible value of 3d deviation of 3d projection of projected curve from "exact" 3d projection. Since algorithm searches 2d curve on surface, required 2d tolerance is computed from 3d tolerance with help of U,V resolutions of surface. 3d and 2d tolerances have sense only for curves on surface, it defines precision of projecting and approximation and have nothing to do with distance between the projected curve and the surface |
| CProjLib_Cone | Projects elementary curves on a cone |
| CProjLib_Cylinder | Projects elementary curves on a cylinder |
| CProjLib_Plane | Projects elementary curves on a plane |
| CProjLib_PrjFunc | |
| CProjLib_PrjResolve | |
| CProjLib_ProjectedCurve | Compute the 2d-curve. Try to solve the particular case if possible. Otherwise, an approximation is done. For approximation some parameters are used, including required tolerance of approximation. Tolerance is maximal possible value of 3d deviation of 3d projection of projected curve from "exact" 3d projection. Since algorithm searches 2d curve on surface, required 2d tolerance is computed from 3d tolerance with help of U,V resolutions of surface. 3d and 2d tolerances have sense only for curves on surface, it defines precision of projecting and approximation and have nothing to do with distance between the projected curve and the surface |
| CProjLib_ProjectOnPlane | Class used to project a 3d curve on a plane. The result will be a 3d curve |
| CProjLib_ProjectOnSurface | Project a curve on a surface. The result (a 3D Curve) will be an approximation |
| CProjLib_Projector | Root class for projection algorithms, stores the result |
| CProjLib_Sphere | Projects elementary curves on a sphere |
| CProjLib_Torus | Projects elementary curves on a torus |
| CPrs3d | The Prs3d package provides the following services |
| CPrs3d_Arrow | Provides class methods to draw an arrow at a given location, along a given direction and using a given angle |
| CPrs3d_ArrowAspect | A framework for displaying arrows in representations of dimensions and relations |
| CPrs3d_BasicAspect | All basic Prs3d_xxxAspect must inherits from this class The aspect classes qualifies how to represent a given kind of object |
| CPrs3d_BndBox | Tool for computing bounding box presentation |
| CPrs3d_DatumAspect | A framework to define the display of datums |
| CPrs3d_DimensionAspect | Defines the attributes when drawing a Length Presentation |
| CPrs3d_DimensionUnits | This class provides units for two dimension groups: |
| CPrs3d_Drawer | A graphic attribute manager which governs how objects such as color, width, line thickness and deflection are displayed. A drawer includes an instance of the Aspect classes with particular default values |
| CPrs3d_IsoAspect | A framework to define the display attributes of isoparameters. This framework can be used to modify the default setting for isoparameters in Prs3d_Drawer |
| CPrs3d_LineAspect | A framework for defining how a line will be displayed in a presentation. Aspects of line display include width, color and type of line. The definition set by this class is then passed to the attribute manager Prs3d_Drawer. Any object which requires a value for line aspect as an argument may then be given the attribute manager as a substitute argument in the form of a field such as myDrawer for example |
| CPrs3d_PlaneAspect | A framework to define the display of planes |
| CPrs3d_Point | |
| CPrs3d_PointAspect | This class defines attributes for the points The points are drawn using markers, whose size does not depend on the zoom value of the views |
| CPrs3d_PresentationShadow | Defines a "shadow" of existing presentation object with custom aspects |
| CPrs3d_Root | A root class for the standard presentation algorithms of the StdPrs package |
| CPrs3d_ShadingAspect | A framework to define the display of shading. The attributes which make up this definition include: |
| CPrs3d_Text | A framework to define the display of texts |
| CPrs3d_TextAspect | Defines the attributes when displaying a text |
| CPrs3d_ToolCylinder | Standard presentation algorithm that outputs graphical primitives for cylindrical surface |
| CPrs3d_ToolDisk | Standard presentation algorithm that outputs graphical primitives for disk surface |
| CPrs3d_ToolQuadric | Base class to build 3D surfaces presentation of quadric surfaces |
| CPrs3d_ToolSector | Standard presentation algorithm that outputs graphical primitives for disk surface |
| CPrs3d_ToolSphere | Standard presentation algorithm that outputs graphical primitives for spherical surface |
| CPrs3d_ToolTorus | Standard presentation algorithm that outputs graphical primitives for torus surface |
| CPrsDim | Auxiliary methods for computing dimensions |
| CPrsDim_AngleDimension | Angle dimension. Can be constructed: |
| CPrsDim_Chamf2dDimension | A framework to define display of 2D chamfers. A chamfer is displayed with arrows and text. The text gives the length of the chamfer if it is a symmetrical chamfer, or the angle if it is not |
| CPrsDim_Chamf3dDimension | A framework to define display of 3D chamfers. A chamfer is displayed with arrows and text. The text gives the length of the chamfer if it is a symmetrical chamfer, or the angle if it is not |
| CPrsDim_ConcentricRelation | A framework to define a constraint by a relation of concentricity between two or more interactive datums. The display of this constraint is also defined. A plane is used to create an axis along which the relation of concentricity can be extended |
| CPrsDim_DiameterDimension | Diameter dimension. Can be constructed: |
| CPrsDim_Dimension | PrsDim_Dimension is a base class for 2D presentations of linear (length, diameter, radius) and angular dimensions |
| CSelectionGeometry | |
| CArrow | Arrows are represented by directed triangles |
| CPrsDim_DimensionOwner | The owner is the entity which makes it possible to link the sensitive primitives and the reference shapes that you want to detect. It stocks the various pieces of information which make it possible to find objects. An owner has a priority which you can modulate, so as to make one entity more selectable than another. You might want to make edges more selectable than faces, for example. In that case, you could attribute sa higher priority to the one compared to the other. An edge, could have priority 5, for example, and a face, priority 4. The default priority is 5 |
| CPrsDim_EllipseRadiusDimension | Computes geometry (basis curve and plane of dimension) for input shape aShape from TopoDS Root class for MinRadiusDimension and MaxRadiusDimension |
| CPrsDim_EqualDistanceRelation | A framework to display equivalent distances between shapes and a given plane. The distance is the length of a projection from the shape to the plane. These distances are used to compare shapes by this vector alone |
| CPrsDim_EqualRadiusRelation | |
| CPrsDim_FixRelation | Constructs and manages a constraint by a fixed relation between two or more interactive datums. This constraint is represented by a wire from a shape - point, vertex, or edge - in the first datum and a corresponding shape in the second. Warning: This relation is not bound with any kind of parametric constraint : it represents the "status" of an parametric object |
| CPrsDim_IdenticRelation | Constructs a constraint by a relation of identity between two or more datums figuring in shape Interactive Objects |
| CPrsDim_LengthDimension | Length dimension. Can be constructed: |
| CPrsDim_MaxRadiusDimension | Ellipse Max radius dimension of a Shape which can be Edge or Face (planar or cylindrical(surface of extrusion or
surface of offset)) |
| CPrsDim_MidPointRelation | Presentation of equal distance to point myMidPoint |
| CPrsDim_MinRadiusDimension | Ellipse Min radius dimension of a Shape which can be Edge or Face (planar or cylindrical(surface of
extrusion or surface of offset)) |
| CPrsDim_OffsetDimension | A framework to display dimensions of offsets. The relation between the offset and the basis shape is indicated. This relation is displayed with arrows and text. The text gives the dsitance between the offset and the basis shape |
| CPrsDim_ParallelRelation | A framework to display constraints of parallelism between two or more Interactive Objects. These entities can be faces or edges |
| CPrsDim_PerpendicularRelation | A framework to display constraints of perpendicularity between two or more interactive datums. These datums can be edges or faces |
| CPrsDim_RadiusDimension | Radius dimension. Can be constructed: |
| CPrsDim_Relation | One of the four types of interactive object in AIS,comprising dimensions and constraints. Serves as the abstract class for the seven relation classes as well as the seven dimension classes. The statuses available for relations between shapes are as follows: |
| CPrsDim_SymmetricRelation | A framework to display constraints of symmetricity between two or more datum Interactive Objects. A plane serves as the axis of symmetry between the shapes of which the datums are parts |
| CPrsDim_TangentRelation | A framework to display tangency constraints between two or more Interactive Objects of the datum type. The datums are normally faces or edges |
| CPrsMgr_PresentableObject | A framework to supply the Graphic3d structure of the object to be presented. On the first display request, this structure is created by calling the appropriate algorithm and retaining this framework for further display. This abstract framework is inherited in Application Interactive Services (AIS), notably by AIS_InteractiveObject. Consequently, 3D presentation should be handled by the relevant daughter classes and their member functions in AIS. This is particularly true in the creation of new interactive objects |
| CPrsMgr_Presentation | |
| CPrsMgr_PresentationManager | A framework to manage 3D displays, graphic entities and their updates. Used in the AIS package (Application Interactive Services), to enable the advanced user to define the default display mode of a new interactive object which extends the list of signatures and types. Definition of new display types is handled by calling the presentation algorithms provided by the StdPrs package |
| CPSO_Particle | Describes particle pool for using in PSO algorithm. Indexes: 0 <= aDimidx <= myDimensionCount - 1 |
| CQABugs | |
| CQADNaming | |
| CQADraw | Draw Harness plugin defining non-general commands specific to test cases |
| CQuantity_Color | This class allows the definition of an RGB color as triplet of 3 normalized floating point values (red, green, blue) |
| CQuantity_ColorRGBA | The pair of Quantity_Color and Alpha component (1.0 opaque, 0.0 transparent) |
| CQuantity_Date | This class provides services to manage date information. A date represents the following time intervals: year, month, day, hour, minute, second, millisecond and microsecond. Current time is expressed in elapsed seconds and microseconds beginning from 00:00 GMT, January 1, 1979 (zero hour). The valid date can only be later than this one. Note: a Period object gives the interval between two dates |
| CQuantity_Period | Manages date intervals. For example, a Period object gives the interval between two dates. A period is expressed in seconds and microseconds |
| CResource_LexicalCompare | |
| CResource_Manager | Defines a resource structure and its management methods |
| CResource_Unicode | This class provides functions used to convert a non-ASCII C string given in ANSI, EUC, GB or SJIS format, to a Unicode string of extended characters, and vice versa |
| CRWGltf_CafReader | The glTF (GL Transmission Format) mesh reader into XDE document |
| CRWGltf_CafWriter | GlTF writer context from XCAF document |
| CMesh | Mesh |
| CRWGltf_StyledShape | Shape + Style pair |
| CHasher | |
| CRWGltf_DracoParameters | Draco compression parameters |
| CRWGltf_GltfAccessor | Low-level glTF data structure defining Accessor |
| CRWGltf_GltfBufferView | Low-level glTF data structure defining BufferView |
| CRWGltf_GltfFace | Low-level glTF data structure holding single Face (one primitive array) definition |
| CRWGltf_GltfJsonParser | INTERNAL tool for parsing glTF document (JSON structure) |
| CRWGltf_GltfLatePrimitiveArray | Mesh data wrapper for delayed primitive array loading from glTF file |
| CRWGltf_GltfMaterialMap | Material manager for exporting into glTF format |
| CRWGltf_GltfOStreamWriter | Rapidjson::Writer wrapper for forward declaration |
| CRWGltf_GltfPrimArrayData | An element within primitive array - vertex attribute or element indexes |
| CRWGltf_GltfSceneNodeMap | Indexed map of scene nodes with custom search algorithm |
| CRWGltf_MaterialCommon | GlTF 1.0 format common (obsolete) material definition |
| CRWGltf_MaterialMetallicRoughness | GlTF 2.0 format PBR material definition |
| CRWGltf_TriangulationReader | RWMesh_TriangulationReader implementation creating Poly_Triangulation |
| CRWHeaderSection | |
| CRWHeaderSection_GeneralModule | Defines General Services for HeaderSection Entities (Share,Check,Copy; Trace already inherited) Depends (for case numbers) of Protocol from HeaderSection |
| CRWHeaderSection_ReadWriteModule | General module to read and write HeaderSection entities |
| CRWHeaderSection_RWFileDescription | Read & Write Module for FileDescription |
| CRWHeaderSection_RWFileName | Read & Write Module for FileName |
| CRWHeaderSection_RWFileSchema | Read & Write Module for FileSchema |
| CRWMesh | Auxiliary tools for RWMesh package |
| CRWMesh_CafReader | The general interface for importing mesh data into XDE document |
| CCafDocumentTools | Structure holding tools for filling the document |
| CRWMesh_CoordinateSystemConverter | Coordinate system converter defining the following tools: |
| CRWMesh_EdgeIterator | Auxiliary class to iterate through edges. Provides functionality to iterate through the edges of a shape. It inherits from RWMesh_ShapeIterator and implements methods to access and manipulate edge data |
| CRWMesh_FaceIterator | Auxiliary class to iterate through triangulated faces. Class is designed to provide an interface for iterating over the faces of a shape, specifically focusing on triangulated faces. It inherits from the RWMesh_ShapeIterator base class and extends its functionality to handle faces with triangulation data |
| CRWMesh_MaterialMap | Material manager. Provides an interface for collecting all materials within the document before writing it into file, and for copying associated image files (textures) into sub-folder near by exported model |
| CRWMesh_NodeAttributes | Attributes of the node |
| CRWMesh_ShapeIterator | This is a virtual base class for other shape iterators. Provides an abstract interface for iterating over the elements of a shape. It defines a set of pure virtual methods that must be implemented by derived classes to handle specific types of shapes and their elements |
| CRWMesh_TriangulationReader | Interface for reading primitive array from the buffer |
| CLoadingStatistic | |
| CRWMesh_TriangulationSource | Mesh data wrapper for delayed triangulation loading. Class inherits Poly_Triangulation so that it can be put temporarily into TopoDS_Face within assembly structure |
| CRWMesh_VertexIterator | Auxiliary class to iterate through vertices. Provides functionality to iterate through the vertices of a shape. It inherits from RWMesh_ShapeIterator and implements methods to access and manipulate vertex data |
| CRWObj | This class provides methods to read and write triangulation from / to the OBJ files |
| CRWObj_CafReader | The OBJ mesh reader into XDE document |
| CRWObj_CafWriter | OBJ writer context from XCAF document |
| CRWObj_IShapeReceiver | Interface to store shape attributes into document |
| CRWObj_Material | Material definition for OBJ file format |
| CRWObj_MtlReader | Reader of mtl files |
| CRWObj_ObjMaterialMap | Material MTL file writer for OBJ export |
| CRWObj_ObjWriterContext | Auxiliary low-level tool writing OBJ file |
| CRWObj_Reader | An abstract class implementing procedure to read OBJ file |
| CObjVec3iHasher | Hasher for 3 ordered integers |
| CVectorOfVertices | Auxiliary structure holding vertex data either with single or double floating point precision |
| CRWObj_SubMesh | Sub-mesh definition for OBJ reader |
| CRWObj_TriangulationReader | RWObj_Reader implementation dumping OBJ file into Poly_Triangulation |
| CRWPly_CafWriter | PLY writer context from XCAF document |
| CRWPly_PlyWriterContext | Auxiliary low-level tool writing PLY file |
| CRWStl | This class provides methods to read and write triangulation from / to the STL files |
| CRWStl_Reader | An abstract class implementing procedure to read STL file |
| CSelect3D_BVHIndexBuffer | Index buffer for BVH tree |
| CSelect3D_InteriorSensitivePointSet | This class handles the selection of arbitrary point set with internal type of sensitivity. The main principle is to split the point set given onto planar convex polygons and search for the overlap with one or more of them through traverse of BVH tree |
| CSelect3D_Pnt | |
| CSelect3D_PointData | |
| CSelect3D_SensitiveBox | A framework to define selection by a sensitive box |
| CSelect3D_SensitiveCircle | A framework to define sensitive 3D circles |
| CSelect3D_SensitiveCurve | A framework to define a sensitive 3D curve. In some cases this class can raise Standard_ConstructionError and Standard_OutOfRange exceptions. For more details see Select3D_SensitivePoly |
| CSelect3D_SensitiveCylinder | A framework to define selection by a sensitive cylinder or cone |
| CSelect3D_SensitiveEntity | Abstract framework to define 3D sensitive entities |
| CSelect3D_SensitiveFace | Sensitive Entity to make a face selectable. In some cases this class can raise Standard_ConstructionError and Standard_OutOfRange exceptions. For more details see Select3D_SensitivePoly |
| CSelect3D_SensitiveGroup | A framework to define selection of a sensitive group by a sensitive entity which is a set of 3D sensitive entities. Remark: 2 modes are possible for rectangle selection the group is considered selected 1) when all the entities inside are selected in the rectangle 2) only one entity inside is selected by the rectangle By default the "Match All entities" mode is set |
| CSelect3D_SensitivePoint | A framework to define sensitive 3D points |
| CSelect3D_SensitivePoly | Sensitive Entity to make a face selectable. In some cases this class can raise Standard_ConstructionError and Standard_OutOfRange exceptions from its member Select3D_PointData myPolyg |
| CSelect3D_SensitivePrimitiveArray | Sensitive for triangulation or point set defined by Primitive Array. The primitives can be optionally combined into patches within BVH tree to reduce its building time in expense of extra traverse time |
| CSelect3D_SensitiveSegment | A framework to define sensitive zones along a segment One gives the 3D start and end point |
| CSelect3D_SensitiveSet | This class is base class for handling overlap detection of complex sensitive entities. It provides an interface for building BVH tree for some set of entities. Thereby, each iteration of overlap detection is a traverse of BVH tree in fact. To use speed-up hierarchical structure in a custom complex sensitive entity, it is necessary to make that custom entity a descendant of this class and organize sub-entities in some container which allows referencing to elements by index. Note that methods taking index as a parameter are used for BVH build and the range of given index is [0; Size() - 1]. For example of usage see Select3D_SensitiveTriangulation |
| CBvhPrimitiveSet | The purpose of this class is to provide a link between BVH_PrimitiveSet and Select3D_SensitiveSet instance to build BVH tree for set of sensitives |
| CSelect3D_SensitiveSphere | A framework to define selection by a sensitive sphere |
| CSelect3D_SensitiveTriangle | A framework to define selection of triangles in a view. This comes into play in the detection of meshing and triangulation in surfaces. In some cases this class can raise Standard_ConstructionError and Standard_OutOfRange exceptions. For more details see Select3D_SensitivePoly |
| CSelect3D_SensitiveTriangulation | A framework to define selection of a sensitive entity made of a set of triangles |
| CSelect3D_SensitiveWire | A framework to define selection of a wire owner by an elastic wire band |
| CSelectBasics | Interface class for dynamic selection |
| CSelectBasics_PickResult | This structure provides unified access to the results of Matches() method in all sensitive entities, so that it defines a Depth (distance to the entity along picking ray) and a closest Point on entity |
| CSelectBasics_SelectingVolumeManager | This class provides an interface for selecting volume manager, which is responsible for all overlap detection methods and calculation of minimum depth, distance to center of geometry and detected closest point on entity |
| CSelectMgr | Auxiliary tools for SelectMgr package |
| CSelectMgr_AndFilter | A framework to define a selection filter for two or more types of entity |
| CSelectMgr_AndOrFilter | A framework to define an OR or AND selection filter. To use an AND selection filter call SetUseOrFilter with False parameter. By default the OR selection filter is used |
| CSelectMgr_AxisIntersector | This class contains representation of selecting axis, created in case of point selection and algorithms for overlap detection between this axis and sensitive entities |
| CSelectMgr_BaseFrustum | This class is an interface for different types of selecting frustums, defining different selection types, like point, box or polyline selection. It contains signatures of functions for detection of overlap by sensitive entity and initializes some data for building the selecting frustum |
| CSelectMgr_BaseIntersector | This class is an interface for different types of selecting intersector, defining different selection types, like point, box or polyline selection. It contains signatures of functions for detection of overlap by sensitive entity and initializes some data for building the selecting intersector |
| CSelectMgr_BVHThreadPool | Class defining a thread pool for building BVH for the list of Select3D_SensitiveEntity within background thread(s) |
| CBVHThread | Thread with back reference to thread pool and thread mutex in it |
| CSentry | Class providing a simple interface to mutexes for list of BVHThread |
| CSelectMgr_CompositionFilter | A framework to define a compound filter composed of two or more simple filters |
| CSelectMgr_EntityOwner | A framework to define classes of owners of sensitive primitives. The owner is the link between application and selection data structures. For the application to make its own objects selectable, it must define owner classes inheriting this framework |
| CSelectMgr_Filter | The root class to define filter objects for selection. Advance handling of objects requires the services of filters. These only allow dynamic detection and selection of objects which correspond to the criteria defined in each. Eight standard filters inheriting SelectMgr_Filter are defined in Open CASCADE. You can create your own filters by defining new filter classes inheriting this framework. You use these filters by loading them into an AIS interactive context |
| CSelectMgr_Frustum | This is an internal class containing representation of rectangular selecting frustum, created in case of point and box selection, and algorithms for overlap detection between selecting frustum and sensitive entities. The principle of frustum calculation: |
| CSelectMgr_FrustumBuilder | The purpose of this class is to provide unified interface for building selecting frustum depending on current camera projection and orientation matrices, window size and viewport parameters |
| CSelectMgr_OrFilter | A framework to define an or selection filter. This selects one or another type of sensitive entity |
| CSelectMgr_RectangularFrustum | This class contains representation of rectangular selecting frustum, created in case of point and box selection, and algorithms for overlap detection between selecting frustum and sensitive entities. The principle of frustum calculation: |
| CSelectionRectangle | Auxiliary structure to define selection primitive (point or box) In case of point selection min and max points are identical |
| CSelectMgr_SelectableObject | A framework to supply the structure of the object to be selected. At the first pick, this structure is created by calling the appropriate algorithm and retaining this framework for further picking. This abstract framework is inherited in Application Interactive Services (AIS), notably in AIS_InteractiveObject. Consequently, 3D selection should be handled by the relevant daughter classes and their member functions in AIS. This is particularly true in the creation of new interactive objects |
| CSelectMgr_SelectableObjectSet | The purpose of this class is to organize all selectable objects into data structure, allowing to build set of BVH trees for each transformation persistence subclass of selectable objects. This allow to minify number of updates for BVH trees - for example 2D persistent object subclass depends only on camera's projection and the corresponding BVH tree needs to be updated when camera's projection parameters change, while another tree for non-persistent objects can be left unchanged in this case |
| CIterator | Class to iterate sequentually over all objects from every subset |
| CSelectMgr_SelectingVolumeManager | This class is used to switch between active selecting volumes depending on selection type chosen by the user. The sample of correct selection volume initialization procedure: |
| CSelectMgr_Selection | Represents the state of a given selection mode for a Selectable Object. Contains all the sensitive entities available for this mode. An interactive object can have an indefinite number of modes of selection, each representing a "decomposition" into sensitive primitives; each primitive has an Owner (SelectMgr_EntityOwner) which allows us to identify the exact entity which has been detected. Each Selection mode is identified by an index. The set of sensitive primitives which correspond to a given mode is stocked in a SelectMgr_Selection object. By Convention, the default selection mode which allows us to grasp the Interactive object in its entirety will be mode 0. AIS_Trihedron : 4 selection modes |
| CSelectMgr_SelectionImageFiller | Abstract class for filling pixel with color. This is internal tool for SelectMgr_ViewerSelector::ToPixMap() |
| CSelectMgr_SelectionManager | A framework to manage selection from the point of view of viewer selectors. These can be added and removed, and selection modes can be activated and deactivated. In addition, objects may be known to all selectors or only to some |
| CSelectMgr_SensitiveEntity | The purpose of this class is to mark sensitive entities selectable or not depending on current active selection of parent object for proper BVH traverse |
| CSelectMgr_SensitiveEntitySet | This class is used to store all calculated sensitive entities of one selectable object. It provides an interface for building BVH tree which is used to speed-up the performance of searching for overlap among sensitives of one selectable object |
| CSelectMgr_SortCriterion | This class provides data and criterion for sorting candidate entities in the process of interactive selection by mouse click |
| CSelectMgr_ToleranceMap | An internal class for calculation of current largest tolerance value which will be applied for creation of selecting frustum by default. Each time the selection set is deactivated, maximum tolerance value will be recalculated. If a user enables custom precision using StdSelect_ViewerSelector3d::SetPixelTolerance, it will be applied to all sensitive entities without any checks |
| CSelectMgr_TriangularFrustum | This class contains representation of triangular selecting frustum, created in case of polyline selection, and algorithms for overlap detection between selecting frustum and sensitive entities. Overlap detection tests are implemented according to the terms of separating axis theorem (SAT). NOTE: the object of this class can be created only as part of SelectMgr_TriangularFrustumSet |
| CSelectionTriangle | Auxiliary structure to define selection triangle |
| CSelectMgr_TriangularFrustumSet | This class is used to handle polyline selection. The main principle of polyline selection algorithm is to split the polygon defined by polyline onto triangles. Than each of them is considered as a base for triangular frustum building. In other words, each triangle vertex will be projected from 2d screen space to 3d world space onto near and far view frustum planes. Thus, the projected triangles make up the bases of selecting frustum. When the set of such frustums is created, the function determining selection iterates through triangular frustum set and searches for overlap with any frustum |
| CSelectionPolyline | Auxiliary structure to define selection polyline |
| CSelectMgr_ViewClipRange | Class for handling depth clipping range. It is used to perform checks in case if global (for the whole view) clipping planes are defined inside of SelectMgr_RectangularFrustum class methods |
| CSelectMgr_ViewerSelector | A framework to define finding, sorting the sensitive primitives in a view. Services are also provided to define the return of the owners of those primitives selected. The primitives are sorted by criteria such as priority of the primitive or its depth in the view relative to that of other primitives. Note that in 3D, the inheriting framework StdSelect_ViewerSelector3d is only to be used if you do not want to use the services provided by AIS. Two tools are available to find and select objects found at a given position in the view. If you want to select the owners of all the objects detected at point x,y,z you use the Init - More - Next - Picked loop. If, on the other hand, you want to select only one object detected at that point, you use the Init - More - OnePicked loop. In this iteration, More is used to see if an object was picked and OnePicked, to get the object closest to the pick position. Viewer selectors are driven by SelectMgr_SelectionManager, and manipulate the SelectMgr_Selection objects given to them by the selection manager |
| CShapeAlgo | |
| CShapeAlgo_AlgoContainer | |
| CShapeAlgo_ToolContainer | Returns tools used by AlgoContainer |
| CShapeAnalysis | This package is intended to analyze geometrical objects and topological shapes. Analysis domain includes both exploring geometrical and topological properties of shapes and checking their conformance to Open CASCADE requirements. The directions of analysis provided by tools of this package are: computing quantities of subshapes, computing parameters of points on curve and surface, computing surface singularities, checking edge and wire consistency, checking edges order in the wire, checking face bounds orientation, checking small faces, analyzing shape tolerances, analyzing of free bounds of the shape |
| CShapeAnalysis_BoxBndTreeSelector | |
| CShapeAnalysis_CanonicalRecognition | This class provides operators for analysis surfaces and curves of shapes in order to find out more simple geometry entities, which could replace existing complex (for example, BSpline) geometry objects with given tolerance |
| CShapeAnalysis_CheckSmallFace | Analysis of the face size |
| CShapeAnalysis_Curve | Analyzing tool for 2d or 3d curve. Computes parameters of projected point onto a curve |
| CShapeAnalysis_Edge | Tool for analyzing the edge. Queries geometrical representations of the edge (3d curve, pcurve on the given face or surface) and topological sub-shapes (bounding vertices). Provides methods for analyzing geometry and topology consistency (3d and pcurve(s) consistency, their adjacency to the vertices) |
| CShapeAnalysis_FreeBoundData | This class is intended to represent free bound and to store its properties |
| CShapeAnalysis_FreeBounds | This class is intended to output free bounds of the shape |
| CShapeAnalysis_FreeBoundsProperties | This class is intended to calculate shape free bounds properties. This class provides the following functionalities: |
| CShapeAnalysis_Geom | Analyzing tool aimed to work on primitive geometrical objects |
| CShapeAnalysis_ShapeContents | Dumps shape contents |
| CShapeAnalysis_ShapeTolerance | Tool for computing shape tolerances (minimal, maximal, average), finding shape with tolerance matching given criteria, setting or limitating tolerances |
| CShapeAnalysis_Shell | This class provides operators to analyze edges orientation in the shell |
| CShapeAnalysis_Surface | Complements standard tool Geom_Surface by providing additional functionality for detection surface singularities, checking spatial surface closure and computing projections of 3D points onto a surface |
| CShapeAnalysis_TransferParameters | This tool is used for transferring parameters from 3d curve of the edge to pcurve and vice versa |
| CShapeAnalysis_TransferParametersProj | This tool is used for transferring parameters from 3d curve of the edge to pcurve and vice versa. This tool transfers parameters with help of projection points from curve 3d on curve 2d and vice versa |
| CShapeAnalysis_Wire | This class provides analysis of a wire to be compliant to CAS.CADE requirements |
| CShapeAnalysis_WireOrder | This class is intended to control and, if possible, redefine the order of a list of edges which define a wire Edges are not given directly, but as their bounds (start,end) |
| CShapeAnalysis_WireVertex | Analyzes and records status of vertices in a Wire |
| CShapeBuild | This package provides basic building tools for other packages in ShapeHealing. These tools are rather internal for ShapeHealing |
| CShapeBuild_Edge | This class provides low-level operators for building an edge 3d curve, copying edge with replaced vertices etc |
| CShapeBuild_ReShape | Rebuilds a Shape by making pre-defined substitutions on some of its components |
| CShapeBuild_Vertex | Provides low-level functions used for constructing vertices |
| CShapeConstruct | This package provides new algorithms for constructing new geometrical objects and topological shapes. It complements and extends algorithms available in Open CASCADE topological and geometrical toolkist. The functionality provided by this package are the following: projecting curves on surface, adjusting curve to have given start and end points. P |
| CShapeConstruct_Curve | Adjusts curve to have start and end points at the given points (currently works on lines and B-Splines only) |
| CShapeConstruct_MakeTriangulation | |
| CShapeConstruct_ProjectCurveOnSurface | This tool provides a method for computing pcurve by projecting 3d curve onto a surface. Projection is done by 23 or more points (this number is changed for B-Splines according to the following rule: the total number of the points is not less than number of spans * (degree + 1); it is increased recursively starting with 23 and is added with 22 until the condition is fulfilled). Isoparametric cases (if curve corresponds to U=const or V=const on the surface) are recognized with the given precision |
| CShapeCustom | This package is intended to convert geometrical objects and topological. The modifications of one geometrical object to another (one) geometrical object are provided. The supported modifications are the following: conversion of BSpline and Bezier surfaces to analytical form, conversion of indirect elementary surfaces (with left-handed coordinate systems) into direct ones, conversion of elementary surfaces to surfaces of revolution, conversion of surface of linear extrusion, revolution, offset surface to bspline, modification of parameterization, degree, number of segments of bspline surfaces, scale the shape |
| CShapeCustom_BSplineRestriction | This tool intended for approximation surfaces, curves and pcurves with specified degree , max number of segments, tolerance 2d, tolerance 3d. Specified continuity can be reduced if approximation with specified continuity was not done |
| CShapeCustom_ConvertToBSpline | Implement a modification for BRepTools Modifier algorithm. Converts Surface of Linear Exctrusion, Revolution and Offset surfaces into BSpline Surface according to flags |
| CShapeCustom_ConvertToRevolution | Implements a modification for the BRepTools Modifier algorithm. Converts all elementary surfaces into surfaces of revolution |
| CShapeCustom_Curve | Converts BSpline curve to periodic |
| CShapeCustom_Curve2d | Converts curve2d to analytical form with given precision or simplify curve2d |
| CShapeCustom_DirectModification | Implements a modification for the BRepTools Modifier algorithm. Will redress indirect surfaces |
| CShapeCustom_Modification | A base class of Modification's from ShapeCustom. Implements message sending mechanism |
| CShapeCustom_RestrictionParameters | This class is axuluary tool which contains parameters for BSplineRestriction class |
| CShapeCustom_Surface | Converts a surface to the analytical form with given precision. Conversion is done only the surface is bspline of bezier and this can be approximated by some analytical surface with that precision |
| CShapeCustom_SweptToElementary | Implements a modification for the BRepTools Modifier algorithm. Converts all elementary surfaces into surfaces of revolution |
| CShapeCustom_TrsfModification | Complements BRepTools_TrsfModification to provide reversible scaling regarding tolerances. Uses actual tolerances (attached to the shapes) not ones returned by BRep_Tool::Tolerance to work with tolerances lower than Precision::Confusion |
| CShapeExtend | This package provides general tools and data structures common for other packages in SHAPEWORKS and extending CAS.CADE structures. The following items are provided by this package: |
| CShapeExtend_BasicMsgRegistrator | Abstract class that can be used for attaching messages to the objects (e.g. shapes). It is used by ShapeHealing algorithms to attach a message describing encountered case (e.g. removing small edge from a wire) |
| CShapeExtend_ComplexCurve | Defines a curve which consists of several segments. Implements basic interface to it |
| CShapeExtend_CompositeSurface | Composite surface is represented by a grid of surfaces (patches) connected geometrically. Patches may have different parametrisation ranges, but they should be parametrised in the same manner so that parameter of each patch (u,v) can be converted to global parameter on the whole surface (U,V) with help of linear transformation: |
| CShapeExtend_Explorer | This class is intended to explore shapes and convert different representations (list, sequence, compound) of complex shapes. It provides tools for: |
| CShapeExtend_MsgRegistrator | Attaches messages to the objects (generic Transient or shape). The objects of this class are transmitted to the Shape Healing algorithms so that they could collect messages occurred during processing |
| CShapeExtend_WireData | This class provides a data structure necessary for work with the wire as with ordered list of edges, what is required for many algorithms. The advantage of this class is that it allows to work with wires which are not correct. The object of the class ShapeExtend_WireData can be initialized by TopoDS_Wire, and converted back to TopoDS_Wire. An edge in the wire is defined by its rank number. Operations of accessing, adding and removing edge at the given rank number are provided. On the whole wire, operations of circular permutation and reversing (both orientations of all edges and order of edges) are provided as well. This class also provides a method to check if the edge in the wire is a seam (if the wire lies on a face). This class is handled by reference. Such an approach gives the following advantages: |
| CShapeFix | This package provides algorithms for fixing problematic (violating Open CASCADE requirements) shapes. Tools from package ShapeAnalysis are used for detecting the problems. The detecting and fixing is done taking in account various criteria implemented in BRepCheck package. Each class of package ShapeFix deals with one certain type of shapes or with some family of problems |
| CShapeFix_ComposeShell | This class is intended to create a shell from the composite surface (grid of surfaces) and set of wires. It may be either division of the supporting surface of the face, or creating a shape corresponding to face on composite surface which is missing in CAS.CADE but exists in some other systems |
| CShapeFix_Edge | Fixing invalid edge. Geometrical and/or topological inconsistency: |
| CShapeFix_EdgeConnect | Rebuilds edges to connect with new vertices, was moved from ShapeBuild. Makes vertices to be shared to connect edges, updates positions and tolerances for shared vertices. Accepts edges bounded by two vertices each |
| CShapeFix_EdgeProjAux | Project 3D point (vertex) on pcurves to find Vertex Parameter on parametric representation of an edge |
| CShapeFix_Face | This operator allows to perform various fixes on face and its wires: fixes provided by ShapeFix_Wire, fixing orientation of wires, addition of natural bounds, fixing of missing seam edge, and detection and removal of null-area wires |
| CShapeFix_FaceConnect | Rebuilds connectivity between faces in shell |
| CShapeFix_FixSmallFace | Fixing face with small size |
| CShapeFix_FixSmallSolid | Fixing solids with small size |
| CShapeFix_FreeBounds | This class is intended to output free bounds of the shape (free bounds are the wires consisting of edges referenced by the only face). For building free bounds it uses ShapeAnalysis_FreeBounds class. This class complements it with the feature to reduce the number of open wires. This reduction is performed with help of connecting several adjacent open wires one to another what can lead to: |
| CShapeFix_IntersectionTool | Tool for fixing selfintersecting wire and intersecting wires |
| CShapeFix_Root | Root class for fixing operations Provides context for recording changes (optional), basic precision value and limit (minimal and maximal) values for tolerances, and message registrator |
| CShapeFix_Shape | Fixing shape in general |
| CShapeFix_ShapeTolerance | Modifies tolerances of sub-shapes (vertices, edges, faces) |
| CShapeFix_Shell | Fixing orientation of faces in shell |
| CShapeFix_Solid | Provides method to build a solid from a shells and orients them in order to have a valid solid with finite volume |
| CShapeFix_SplitCommonVertex | Two wires have common vertex - this case is valid in BRep model and isn't valid in STEP => before writing into STEP it is necessary to split this vertex (each wire must has one vertex) |
| CShapeFix_SplitTool | Tool for splitting and cutting edges; includes methods used in OverlappingTool and IntersectionTool |
| CShapeFix_Wire | This class provides a set of tools for repairing a wire |
| CShapeFix_Wireframe | Provides methods for fixing wireframe of shape |
| CShapeFix_WireSegment | This class is auxiliary class (data storage) used in ComposeShell. It is intended for representing segment of the wire (or whole wire). The segment itself is represented by ShapeExtend_WireData. In addition, some associated data necessary for computations are stored: |
| CShapeFix_WireVertex | Fixing disconnected edges in the wire Fixes vertices in the wire on the basis of pre-analysis made by ShapeAnalysis_WireVertex (given as argument). The Wire has formerly been loaded in a ShapeExtend_WireData |
| CShapePersistent | |
| CShapePersistent_BRep | |
| CPointRepresentation | |
| CPointOnCurve | |
| CPointsOnSurface | |
| CPointOnCurveOnSurface | |
| CPointOnSurface | |
| CCurveRepresentation | |
| CGCurve | |
| CCurve3D | |
| CCurveOnSurface | |
| CCurveOnClosedSurface | |
| CPolygon3D | |
| CPolygonOnTriangulation | |
| CPolygonOnClosedTriangulation | |
| CPolygonOnSurface | |
| CPolygonOnClosedSurface | |
| CCurveOn2Surfaces | |
| CShapePersistent_Geom | |
| CGeometry | |
| CgeometryBase | |
| CsubBase | |
| CsubBase_gp | |
| CsubBase_empty | |
| Cinstance | |
| CShapePersistent_Geom2d | |
| CShapePersistent_Geom2d_Curve | |
| CShapePersistent_Geom_Curve | |
| CShapePersistent_Geom_Surface | |
| CShapePersistent_HArray1 | |
| CShapePersistent_HArray2 | |
| CShapePersistent_HSequence | |
| CShapePersistent_Poly | |
| CShapePersistent_TopoDS | |
| CHShape | |
| CpTBase | |
| CtObject | |
| CtObject1 | |
| CShapeProcess | Shape Processing module allows to define and apply general Shape Processing as a customizable sequence of Shape Healing operators. The customization is implemented via user-editable resource file which defines sequence of operators to be executed and their parameters |
| CShapeProcess_Context | Provides convenient interface to resource file Allows to load resource file and get values of attributes starting from some scope, for example if scope is defined as "ToV4" and requested parameter is "exec.op", value of "ToV4.exec.op" parameter from the resource file will be returned |
| CShapeProcess_Operator | Abstract Operator class providing a tool to perform an operation on Context |
| CShapeProcess_OperLibrary | Provides a set of following operators |
| CShapeProcess_ShapeContext | Extends Context to handle shapes Contains map of shape-shape, and messages attached to shapes |
| CShapeProcess_UOperator | Defines operator as container for static function OperFunc. This allows user to create new operators without creation of new classes |
| CShapeProcessAPI_ApplySequence | Applies one of the sequence read from resource file |
| CShapeUpgrade | This package provides tools for splitting and converting shapes by some criteria. It provides modifications of the kind when one topological object can be converted or split in to several ones. In particular this package contains high level API classes which perform: converting geometry of shapes up to given continuity, splitting revolutions by U to segments less than given value, converting to beziers, splitting closed faces |
| CShapeUpgrade_ClosedEdgeDivide | |
| CShapeUpgrade_ClosedFaceDivide | Divides a Face with one or more seam edge to avoid closed faces. Splitting is performed by U and V direction. The number of resulting faces can be defined by user |
| CShapeUpgrade_ConvertCurve2dToBezier | Converts/splits a 2d curve to a list of beziers |
| CShapeUpgrade_ConvertCurve3dToBezier | Converts/splits a 3d curve of any type to a list of beziers |
| CShapeUpgrade_ConvertSurfaceToBezierBasis | Converts a plane, bspline surface, surface of revolution, surface of extrusion, offset surface to grid of bezier basis surface ( bezier surface, surface of revolution based on bezier curve, offset surface based on any previous type) |
| CShapeUpgrade_EdgeDivide | |
| CShapeUpgrade_FaceDivide | Divides a Face (both edges in the wires, by splitting curves and pcurves, and the face itself, by splitting supporting surface) according to splitting criteria |
| CShapeUpgrade_FaceDivideArea | Divides face by max area criterium |
| CShapeUpgrade_FixSmallBezierCurves | |
| CShapeUpgrade_FixSmallCurves | |
| CShapeUpgrade_RemoveInternalWires | Removes all internal wires having area less than specified min area |
| CShapeUpgrade_RemoveLocations | Removes all locations sub-shapes of specified shape |
| CShapeUpgrade_ShapeConvertToBezier | API class for performing conversion of 3D, 2D curves to bezier curves and surfaces to bezier based surfaces ( bezier surface, surface of revolution based on bezier curve, offset surface based on any previous type) |
| CShapeUpgrade_ShapeDivide | Divides a all faces in shell with given criteria Shell |
| CShapeUpgrade_ShapeDivideAngle | Splits all surfaces of revolution, cylindrical, toroidal, conical, spherical surfaces in the given shape so that each resulting segment covers not more than defined number of degrees (to segments less than 90) |
| CShapeUpgrade_ShapeDivideArea | Divides faces from specified shape by max area criterium |
| CShapeUpgrade_ShapeDivideClosed | Divides all closed faces in the shape. Class ShapeUpgrade_ClosedFaceDivide is used as divide tool |
| CShapeUpgrade_ShapeDivideClosedEdges | |
| CShapeUpgrade_ShapeDivideContinuity | API Tool for converting shapes with C0 geometry into C1 ones |
| CShapeUpgrade_ShellSewing | This class provides a tool for applying sewing algorithm from BRepBuilderAPI: it takes a shape, calls sewing for each shell, and then replaces sewed shells with use of ShapeBuild_ReShape |
| CShapeUpgrade_SplitCurve | Splits a curve with a criterion |
| CShapeUpgrade_SplitCurve2d | Splits a 2d curve with a criterion |
| CShapeUpgrade_SplitCurve2dContinuity | Corrects/splits a 2d curve with a continuity criterion. Tolerance is used to correct the curve at a knot that respects geometrically the criterion, in order to reduce the multiplicity of the knot |
| CShapeUpgrade_SplitCurve3d | Splits a 3d curve with a criterion |
| CShapeUpgrade_SplitCurve3dContinuity | Corrects/splits a 2d curve with a continuity criterion. Tolerance is used to correct the curve at a knot that respects geometrically the criterion, in order to reduce the multiplicity of the knot |
| CShapeUpgrade_SplitSurface | Splits a Surface with a criterion |
| CShapeUpgrade_SplitSurfaceAngle | Splits a surfaces of revolution, cylindrical, toroidal, conical, spherical so that each resulting segment covers not more than defined number of degrees |
| CShapeUpgrade_SplitSurfaceArea | Split surface in the parametric space in according specified number of splits on the |
| CShapeUpgrade_SplitSurfaceContinuity | Splits a Surface with a continuity criterion. At the present moment C1 criterion is used only. This tool works with tolerance. If C0 surface can be corrected at a knot with given tolerance then the surface is corrected, otherwise it is spltted at that knot |
| CShapeUpgrade_Tool | Tool is a root class for splitting classes Provides context for recording changes, basic precision value and limit (minimal and maximal) values for tolerances |
| CShapeUpgrade_UnifySameDomain | This tool tries to unify faces and edges of the shape which lie on the same geometry. Faces/edges are considering as 'same-domain' if a group of neighbouring faces/edges are lying on coincident surfaces/curves. In this case these faces/edges can be unified into one face/edge. ShapeUpgrade_UnifySameDomain is initialized by a shape and the next optional parameters: UnifyFaces - tries to unify all possible faces UnifyEdges - tries to unify all possible edges ConcatBSplines - if this flag is set to true then all neighbouring edges, which lay on BSpline or Bezier curves with C1 continuity on their common vertices, will be merged into one common edge |
| CShapeUpgrade_WireDivide | Divides edges in the wire lying on the face or free wires or free edges with a criterion. Splits 3D curve and pcurve(s) of the edge on the face. Other pcurves which may be associated with the edge are simply copied. If 3D curve is split then pcurve on the face is split as well, and vice-versa. Input shape is not modified. The modifications made are recorded in external context (ShapeBuild_ReShape). This tool is applied to all edges before splitting them in order to keep sharing |
| CStandard | The package Standard provides global memory allocator and other basic services used by other OCCT components |
| CStandard_ArrayStreamBuffer | Custom buffer object implementing STL interface std::streambuf for streamed reading from allocated memory block. Implements minimal sub-set of methods for passing buffer to std::istream, including seek support |
| CStandard_CLocaleSentry | We check _GNU_SOURCE for glibc extensions here and it is always defined by g++ compiler |
| CStandard_Condition | This is boolean flag intended for communication between threads. One thread sets this flag to TRUE to indicate some event happened and another thread either waits this event or checks periodically its state to perform job |
| CStandard_CStringHasher | |
| CStandard_Dump | This interface has some tool methods for stream (in JSON format) processing |
| CStandard_DumpValue | Type for storing a dump value with the stream position |
| CStandard_ErrorHandler | Class implementing mechanics of conversion of signals to exceptions |
| CCallback | Defines a base class for callback objects that can be registered in the OCC error handler (the class simulating C++ exceptions) so as to be correctly destroyed when error handler is activated |
| CStandard_Failure | Forms the root of the entire exception hierarchy. Inherits from std::exception and implements what() interface |
| CStandard_GUID | |
| CStandard_MMgrOpt | Open CASCADE memory manager optimized for speed |
| CStandard_MMgrRoot | |
| CStandard_OutOfMemory | Standard_OutOfMemory exception is defined explicitly and not by macro DEFINE_STANDARD_EXCEPTION, to avoid necessity of dynamic memory allocations during throwing and stack unwinding: |
| CStandard_Persistent | Root of "persistent" classes, a legacy support of object oriented databases, now outdated |
| CStandard_ReadBuffer | Auxiliary tool for buffered reading from input stream within chunks of constant size |
| CStandard_ReadLineBuffer | Auxiliary tool for buffered reading of lines from input stream |
| CStandard_Static_Assert | Static assert – empty default template |
| CStandard_Static_Assert< true > | Static assert – specialization for condition being true |
| CStandard_Transient | Abstract class which forms the root of the entire Transient class hierarchy |
| CStandard_Type | This class provides legacy interface (type descriptor) to run-time type information (RTTI) for OCCT classes inheriting from Standard_Transient |
| CStandard_UUID | |
| CStdDrivers | |
| CStdDrivers_DocumentRetrievalDriver | Retrieval driver of a Part document |
| CStdLDrivers | |
| CStdLDrivers_DocumentRetrievalDriver | Retrieval driver of a Part document |
| CStdLPersistent | |
| CStdLPersistent_Collection | |
| CStdLPersistent_Data | |
| CStdLPersistent_Dependency | |
| CStdLPersistent_Document | |
| CStdLPersistent_Function | |
| CStdLPersistent_HArray1 | |
| Cinstance | |
| Cnamed_instance | |
| CStdLPersistent_HArray2 | |
| Cinstance | |
| Cnamed_instance | |
| CStdLPersistent_HString | |
| CAscii | |
| CExtended | |
| CStdLPersistent_NamedData | |
| CStdLPersistent_Real | |
| CStdLPersistent_TreeNode | |
| CStdLPersistent_Value | |
| CTagSource | |
| CReference | |
| CComment | |
| CUAttribute | |
| CInteger | |
| CName | |
| CAsciiString | |
| CStdLPersistent_Variable | |
| CStdLPersistent_Void | |
| Cinstance | |
| CStdLPersistent_XLink | |
| CStdObject_Location | |
| CStdObject_Shape | |
| CStdObjMgt_Attribute | Root class for a temporary persistent object corresponding to an attribute |
| CStatic | |
| CSimple | |
| CSingleInt | |
| CSingleRef | |
| CStdObjMgt_MapOfInstantiators | |
| CStdObjMgt_Persistent | Root class for a temporary persistent object that reads data from a file and then creates transient object using the data |
| CStdObjMgt_ReadData | Auxiliary data used to read persistent objects from a file |
| CObjectSentry | Auxiliary class used to automate begin and end of reading object (eating opening and closing parenthesis) at constructor and destructor |
| CStdObjMgt_SharedObject | |
| CAbstractPersistentBase | |
| CSharedBase | |
| CDelayedBase | |
| CIgnoreData | |
| CDelayed | |
| CStdObjMgt_WriteData | Auxiliary data used to write persistent objects to a file |
| CObjectSentry | Auxiliary class used to automate begin and end of writing object (adding opening and closing parenthesis) at constructor and destructor |
| CStdPersistent | |
| CStdPersistent_DataXtd | |
| CGeometry | |
| CPosition | |
| CStdPersistent_DataXtd_Constraint | |
| CStdPersistent_DataXtd_PatternStd | |
| CStdPersistent_HArray1 | |
| CStdPersistent_Naming | |
| CNamedShape | |
| CName | |
| CName_1 | |
| CName_2 | |
| CNaming | |
| CNaming_1 | |
| CStdPersistent_PPrsStd | |
| CAISPresentation | |
| CAISPresentation_1 | |
| CStdPersistent_TopLoc | |
| CDatum3D | |
| CItemLocation | |
| CStdPersistent_TopoDS | |
| CpTShape | |
| CStdPrs_BRepFont | This tool provides basic services for rendering of vectorized text glyphs as BRep shapes. Single instance initialize single font for sequential glyphs rendering with implicit caching of already rendered glyphs. Thus position of each glyph in the text is specified by shape location |
| CStdPrs_BRepTextBuilder | Represents class for applying text formatting |
| CStdPrs_Curve | A framework to define display of lines, arcs of circles and conic sections. This is done with a fixed number of points, which can be modified |
| CStdPrs_DeflectionCurve | A framework to provide display of any curve with respect to the maximal chordal deviation defined in the Prs3d_Drawer attributes manager |
| CStdPrs_HLRPolyShape | Instantiates Prs3d_PolyHLRShape to define a display of a shape where hidden and visible lines are identified with respect to a given projection. StdPrs_HLRPolyShape works with a polyhedral simplification of the shape whereas StdPrs_HLRShape takes the shape itself into account. When you use StdPrs_HLRShape, you obtain an exact result, whereas, when you use StdPrs_HLRPolyShape, you reduce computation time but obtain polygonal segments. The polygonal algorithm is used |
| CStdPrs_HLRShape | Computes the presentation of objects with removal of their hidden lines for a specific projector. The exact algorithm is used |
| CStdPrs_HLRShapeI | Computes the presentation of objects with removal of their hidden lines for a specific projector |
| CStdPrs_HLRToolShape | |
| CStdPrs_Isolines | Tool for computing isoline representation for a face or surface. Depending on a flags set to the given Prs3d_Drawer instance, on-surface (is used by default) or on-triangulation isoline builder algorithm will be used. If the given shape is not triangulated, on-surface isoline builder will be applied regardless of Prs3d_Drawer flags |
| CPntOnIso | Auxiliary structure defining 3D point on isoline |
| CSegOnIso | Auxiliary structure defining segment of isoline |
| CStdPrs_Plane | A framework to display infinite planes |
| CStdPrs_PoleCurve | A framework to provide display of Bezier or BSpline curves (by drawing a broken line linking the poles of the curve) |
| CStdPrs_ShadedShape | Auxiliary procedures to prepare Shaded presentation of specified shape |
| CStdPrs_ShadedSurface | Computes the shading presentation of surfaces. Draws a surface by drawing the isoparametric curves with respect to a maximal chordial deviation. The number of isoparametric curves to be drawn and their color are controlled by the furnished Drawer |
| CStdPrs_ShapeTool | Describes the behaviour requested for a wireframe shape presentation |
| CStdPrs_ToolPoint | |
| CStdPrs_ToolRFace | Iterator over 2D curves restricting a face (skipping internal/external edges). In addition, the algorithm skips NULL curves - IsInvalidGeometry() can be checked if this should be handled within algorithm |
| CStdPrs_ToolTriangulatedShape | |
| CStdPrs_ToolVertex | |
| CStdPrs_WFDeflectionRestrictedFace | A framework to provide display of U and V isoparameters of faces, while allowing you to impose a deflection on them. Computes the wireframe presentation of faces with restrictions by displaying a given number of U and/or V isoparametric curves. The isoparametric curves are drawn with respect to a maximal chordial deviation. The presentation includes the restriction curves |
| CStdPrs_WFDeflectionSurface | Draws a surface by drawing the isoparametric curves with respect to a maximal chordial deviation. The number of isoparametric curves to be drawn and their color are controlled by the furnished Drawer |
| CStdPrs_WFPoleSurface | Computes the presentation of surfaces by drawing a double network of lines linking the poles of the surface in the two parametric direction. The number of lines to be drawn is controlled by the NetworkNumber of the given Drawer |
| CStdPrs_WFRestrictedFace | |
| CStdPrs_WFShape | Tool for computing wireframe presentation of a TopoDS_Shape |
| CStdPrs_WFSurface | Computes the wireframe presentation of surfaces by displaying a given number of U and/or V isoparametric curves. The isoparametric curves are drawn with respect to a given number of points |
| CStdSelect | The StdSelect package provides the following services |
| CStdSelect_BRepOwner | Defines Specific Owners for Sensitive Primitives (Sensitive Segments,Circles...). Used in Dynamic Selection Mechanism. A BRepOwner has an Owner (the shape it represents) and Users (One or More Transient entities). The highlight-unhighlight methods are empty and must be redefined by each User |
| CStdSelect_BRepSelectionTool | Tool to create specific selections (sets of primitives) for Shapes from Topology. These Selections may be used in dynamic selection Mechanism Given a Shape and a mode of selection (selection of vertices, edges,faces ...) , This Tool Computes corresponding sensitive primitives, puts them in an entity called Selection (see package SelectMgr) and returns it |
| CStdSelect_EdgeFilter | A framework to define a filter to select a specific type of edge. The types available include: |
| CStdSelect_FaceFilter | A framework to define a filter to select a specific type of face. The types available include: |
| CStdSelect_Shape | Presentable shape only for purpose of display for BRepOwner.. |
| CStdSelect_ShapeTypeFilter | A filter framework which allows you to define a filter for a specific shape type |
| CStdStorage | StdStorage package is used to write and read persistent objects. These objects are read and written by a retrieval or storage algorithm (compatible with legacy Storage_Schema) in a container (disk, memory, network ...). Drivers (FSD_File objects) assign a physical container for data to be stored or retrieved. The standard procedure for an application in reading a container is to call one of the Read functions providing either a file path or a driver opened for reading. Thes function update the instance of the StdStorage_Data class which contains the data being read. The standard procedure for an application in writing a container is the following: |
| CStdStorage_Bucket | |
| CStdStorage_BucketIterator | |
| CStdStorage_BucketOfPersistent | |
| CStdStorage_Data | A picture memorizing the stored in a container (for example, in a file). A StdStorage_Data object represents either: |
| CStdStorage_HeaderData | Storage header data section that contains some auxiliary information (application name, schema version, creation date, comments and so on...) |
| CStdStorage_Root | Describes a named persistent root |
| CStdStorage_RootData | Storage root data section contains root persistent objects |
| CStdStorage_TypeData | Storage type data section keeps association between persistent textual types and their numbers |
| CStepAP203_ApprovedItem | Representation of STEP SELECT type ApprovedItem |
| CStepAP203_CcDesignApproval | Representation of STEP entity CcDesignApproval |
| CStepAP203_CcDesignCertification | Representation of STEP entity CcDesignCertification |
| CStepAP203_CcDesignContract | Representation of STEP entity CcDesignContract |
| CStepAP203_CcDesignDateAndTimeAssignment | Representation of STEP entity CcDesignDateAndTimeAssignment |
| CStepAP203_CcDesignPersonAndOrganizationAssignment | Representation of STEP entity CcDesignPersonAndOrganizationAssignment |
| CStepAP203_CcDesignSecurityClassification | Representation of STEP entity CcDesignSecurityClassification |
| CStepAP203_CcDesignSpecificationReference | Representation of STEP entity CcDesignSpecificationReference |
| CStepAP203_CertifiedItem | Representation of STEP SELECT type CertifiedItem |
| CStepAP203_Change | Representation of STEP entity Change |
| CStepAP203_ChangeRequest | Representation of STEP entity ChangeRequest |
| CStepAP203_ChangeRequestItem | Representation of STEP SELECT type ChangeRequestItem |
| CStepAP203_ClassifiedItem | Representation of STEP SELECT type ClassifiedItem |
| CStepAP203_ContractedItem | Representation of STEP SELECT type ContractedItem |
| CStepAP203_DateTimeItem | Representation of STEP SELECT type DateTimeItem |
| CStepAP203_PersonOrganizationItem | Representation of STEP SELECT type PersonOrganizationItem |
| CStepAP203_SpecifiedItem | Representation of STEP SELECT type SpecifiedItem |
| CStepAP203_StartRequest | Representation of STEP entity StartRequest |
| CStepAP203_StartRequestItem | Representation of STEP SELECT type StartRequestItem |
| CStepAP203_StartWork | Representation of STEP entity StartWork |
| CStepAP203_WorkItem | Representation of STEP SELECT type WorkItem |
| CStepAP209_Construct | Basic tool for working with AP209 model |
| CStepAP214 | Complete AP214 CC1 , Revision 4 Upgrading from Revision 2 to Revision 4 : 26 Mar 1997 Splitting in sub-schemas : 5 Nov 1997 |
| CStepAP214_AppliedApprovalAssignment | |
| CStepAP214_AppliedDateAndTimeAssignment | |
| CStepAP214_AppliedDateAssignment | |
| CStepAP214_AppliedDocumentReference | |
| CStepAP214_AppliedExternalIdentificationAssignment | Representation of STEP entity AppliedExternalIdentificationAssignment |
| CStepAP214_AppliedGroupAssignment | Representation of STEP entity AppliedGroupAssignment |
| CStepAP214_AppliedOrganizationAssignment | |
| CStepAP214_AppliedPersonAndOrganizationAssignment | |
| CStepAP214_AppliedPresentedItem | |
| CStepAP214_AppliedSecurityClassificationAssignment | |
| CStepAP214_ApprovalItem | |
| CStepAP214_AutoDesignActualDateAndTimeAssignment | |
| CStepAP214_AutoDesignActualDateAssignment | |
| CStepAP214_AutoDesignApprovalAssignment | |
| CStepAP214_AutoDesignDateAndPersonAssignment | |
| CStepAP214_AutoDesignDateAndPersonItem | |
| CStepAP214_AutoDesignDateAndTimeItem | |
| CStepAP214_AutoDesignDatedItem | |
| CStepAP214_AutoDesignDocumentReference | |
| CStepAP214_AutoDesignGeneralOrgItem | |
| CStepAP214_AutoDesignGroupAssignment | |
| CStepAP214_AutoDesignGroupedItem | |
| CStepAP214_AutoDesignNominalDateAndTimeAssignment | |
| CStepAP214_AutoDesignNominalDateAssignment | |
| CStepAP214_AutoDesignOrganizationAssignment | |
| CStepAP214_AutoDesignOrganizationItem | |
| CStepAP214_AutoDesignPersonAndOrganizationAssignment | |
| CStepAP214_AutoDesignPresentedItem | |
| CStepAP214_AutoDesignPresentedItemSelect | |
| CStepAP214_AutoDesignReferencingItem | |
| CStepAP214_AutoDesignSecurityClassificationAssignment | |
| CStepAP214_Class | Representation of STEP entity Class |
| CStepAP214_DateAndTimeItem | |
| CStepAP214_DateItem | |
| CStepAP214_DocumentReferenceItem | |
| CStepAP214_ExternalIdentificationItem | Representation of STEP SELECT type ExternalIdentificationItem |
| CStepAP214_ExternallyDefinedClass | Representation of STEP entity ExternallyDefinedClass |
| CStepAP214_ExternallyDefinedGeneralProperty | Representation of STEP entity ExternallyDefinedGeneralProperty |
| CStepAP214_GroupItem | |
| CStepAP214_OrganizationItem | |
| CStepAP214_PersonAndOrganizationItem | |
| CStepAP214_PresentedItemSelect | |
| CStepAP214_Protocol | Protocol for StepAP214 Entities It requires StepAP214 as a Resource |
| CStepAP214_RepItemGroup | Representation of STEP entity RepItemGroup |
| CStepAP214_SecurityClassificationItem | |
| CStepAP242_DraughtingModelItemAssociation | Added for Dimensional Tolerances |
| CStepAP242_GeometricItemSpecificUsage | Added for Dimensional Tolerances |
| CStepAP242_IdAttribute | |
| CStepAP242_IdAttributeSelect | |
| CStepAP242_ItemIdentifiedRepresentationUsage | |
| CStepAP242_ItemIdentifiedRepresentationUsageDefinition | |
| CStepBasic_Action | Representation of STEP entity Action |
| CStepBasic_ActionAssignment | Representation of STEP entity ActionAssignment |
| CStepBasic_ActionMethod | Representation of STEP entity ActionMethod |
| CStepBasic_ActionRequestAssignment | Representation of STEP entity ActionRequestAssignment |
| CStepBasic_ActionRequestSolution | Representation of STEP entity ActionRequestSolution |
| CStepBasic_Address | |
| CStepBasic_ApplicationContext | |
| CStepBasic_ApplicationContextElement | |
| CStepBasic_ApplicationProtocolDefinition | |
| CStepBasic_Approval | |
| CStepBasic_ApprovalAssignment | |
| CStepBasic_ApprovalDateTime | Added from StepBasic Rev2 to Rev4 |
| CStepBasic_ApprovalPersonOrganization | |
| CStepBasic_ApprovalRelationship | |
| CStepBasic_ApprovalRole | |
| CStepBasic_ApprovalStatus | |
| CStepBasic_AreaUnit | |
| CStepBasic_CalendarDate | |
| CStepBasic_Certification | Representation of STEP entity Certification |
| CStepBasic_CertificationAssignment | Representation of STEP entity CertificationAssignment |
| CStepBasic_CertificationType | Representation of STEP entity CertificationType |
| CStepBasic_CharacterizedObject | Representation of STEP entity CharacterizedObject |
| CStepBasic_Contract | Representation of STEP entity Contract |
| CStepBasic_ContractAssignment | Representation of STEP entity ContractAssignment |
| CStepBasic_ContractType | Representation of STEP entity ContractType |
| CStepBasic_ConversionBasedUnit | |
| CStepBasic_ConversionBasedUnitAndAreaUnit | |
| CStepBasic_ConversionBasedUnitAndLengthUnit | |
| CStepBasic_ConversionBasedUnitAndMassUnit | |
| CStepBasic_ConversionBasedUnitAndPlaneAngleUnit | |
| CStepBasic_ConversionBasedUnitAndRatioUnit | |
| CStepBasic_ConversionBasedUnitAndSolidAngleUnit | |
| CStepBasic_ConversionBasedUnitAndTimeUnit | |
| CStepBasic_ConversionBasedUnitAndVolumeUnit | |
| CStepBasic_CoordinatedUniversalTimeOffset | |
| CStepBasic_Date | |
| CStepBasic_DateAndTime | |
| CStepBasic_DateAndTimeAssignment | |
| CStepBasic_DateAssignment | |
| CStepBasic_DateRole | |
| CStepBasic_DateTimeRole | |
| CStepBasic_DateTimeSelect | |
| CStepBasic_DerivedUnit | Added from StepBasic Rev2 to Rev4 |
| CStepBasic_DerivedUnitElement | Added from StepBasic Rev2 to Rev4 |
| CStepBasic_DesignContext | Class added to Schema AP214 around April 1996 |
| CStepBasic_DigitalDocument | |
| CStepBasic_DimensionalExponents | |
| CStepBasic_Document | Representation of STEP entity Document |
| CStepBasic_DocumentFile | Representation of STEP entity DocumentFile |
| CStepBasic_DocumentProductAssociation | Representation of STEP entity DocumentProductAssociation |
| CStepBasic_DocumentProductEquivalence | Representation of STEP entity DocumentProductEquivalence |
| CStepBasic_DocumentReference | |
| CStepBasic_DocumentRelationship | |
| CStepBasic_DocumentRepresentationType | Representation of STEP entity DocumentRepresentationType |
| CStepBasic_DocumentType | |
| CStepBasic_DocumentUsageConstraint | |
| CStepBasic_Effectivity | |
| CStepBasic_EffectivityAssignment | Representation of STEP entity EffectivityAssignment |
| CStepBasic_EulerAngles | Representation of STEP entity EulerAngles |
| CStepBasic_ExternalIdentificationAssignment | Representation of STEP entity ExternalIdentificationAssignment |
| CStepBasic_ExternallyDefinedItem | Representation of STEP entity ExternallyDefinedItem |
| CStepBasic_ExternalSource | Representation of STEP entity ExternalSource |
| CStepBasic_GeneralProperty | Representation of STEP entity GeneralProperty |
| CStepBasic_GeneralPropertyAssociation | Representation of STEP entity GeneralPropertyAssociation |
| CStepBasic_GeneralPropertyRelationship | Representation of STEP entity GeneralPropertyRelationship |
| CStepBasic_Group | Representation of STEP entity Group |
| CStepBasic_GroupAssignment | Representation of STEP entity GroupAssignment |
| CStepBasic_GroupRelationship | Representation of STEP entity GroupRelationship |
| CStepBasic_IdentificationAssignment | Representation of STEP entity IdentificationAssignment |
| CStepBasic_IdentificationRole | Representation of STEP entity IdentificationRole |
| CStepBasic_LengthMeasureWithUnit | |
| CStepBasic_LengthUnit | |
| CStepBasic_LocalTime | |
| CStepBasic_MassMeasureWithUnit | |
| CStepBasic_MassUnit | Representation of STEP entity MassUnit |
| CStepBasic_MeasureValueMember | For Select MeasureValue, i.e. : length_measure,time_measure,plane_angle_measure, solid_angle_measure,ratio_measure,parameter_value, context_dependent_measure,positive_length_measure, positive_plane_angle_measure,positive_ratio_measure, area_measure,volume_measure, count_measure |
| CStepBasic_MeasureWithUnit | |
| CStepBasic_MechanicalContext | |
| CStepBasic_NameAssignment | Representation of STEP entity NameAssignment |
| CStepBasic_NamedUnit | |
| CStepBasic_ObjectRole | Representation of STEP entity ObjectRole |
| CStepBasic_OrdinalDate | |
| CStepBasic_Organization | |
| CStepBasic_OrganizationalAddress | |
| CStepBasic_OrganizationAssignment | |
| CStepBasic_OrganizationRole | |
| CStepBasic_Person | |
| CStepBasic_PersonalAddress | |
| CStepBasic_PersonAndOrganization | |
| CStepBasic_PersonAndOrganizationAssignment | |
| CStepBasic_PersonAndOrganizationRole | |
| CStepBasic_PersonOrganizationSelect | |
| CStepBasic_PhysicallyModeledProductDefinition | |
| CStepBasic_PlaneAngleMeasureWithUnit | |
| CStepBasic_PlaneAngleUnit | |
| CStepBasic_Product | |
| CStepBasic_ProductCategory | |
| CStepBasic_ProductCategoryRelationship | Representation of STEP entity ProductCategoryRelationship |
| CStepBasic_ProductConceptContext | Representation of STEP entity ProductConceptContext |
| CStepBasic_ProductContext | |
| CStepBasic_ProductDefinition | |
| CStepBasic_ProductDefinitionContext | |
| CStepBasic_ProductDefinitionEffectivity | |
| CStepBasic_ProductDefinitionFormation | |
| CStepBasic_ProductDefinitionFormationRelationship | Representation of STEP entity ProductDefinitionFormationRelationship |
| CStepBasic_ProductDefinitionFormationWithSpecifiedSource | |
| CStepBasic_ProductDefinitionOrReference | |
| CStepBasic_ProductDefinitionReference | Representation of STEP entity Product_Definition_Reference |
| CStepBasic_ProductDefinitionReferenceWithLocalRepresentation | |
| CStepBasic_ProductDefinitionRelationship | Representation of STEP entity ProductDefinitionRelationship |
| CStepBasic_ProductDefinitionWithAssociatedDocuments | |
| CStepBasic_ProductOrFormationOrDefinition | Representation of STEP SELECT type ProductOrFormationOrDefinition |
| CStepBasic_ProductRelatedProductCategory | |
| CStepBasic_ProductType | |
| CStepBasic_RatioMeasureWithUnit | |
| CStepBasic_RatioUnit | |
| CStepBasic_RoleAssociation | Representation of STEP entity RoleAssociation |
| CStepBasic_RoleSelect | Representation of STEP SELECT type RoleSelect |
| CStepBasic_SecurityClassification | |
| CStepBasic_SecurityClassificationAssignment | |
| CStepBasic_SecurityClassificationLevel | |
| CStepBasic_SiUnit | |
| CStepBasic_SiUnitAndAreaUnit | |
| CStepBasic_SiUnitAndLengthUnit | |
| CStepBasic_SiUnitAndMassUnit | |
| CStepBasic_SiUnitAndPlaneAngleUnit | |
| CStepBasic_SiUnitAndRatioUnit | |
| CStepBasic_SiUnitAndSolidAngleUnit | |
| CStepBasic_SiUnitAndThermodynamicTemperatureUnit | |
| CStepBasic_SiUnitAndTimeUnit | |
| CStepBasic_SiUnitAndVolumeUnit | |
| CStepBasic_SizeMember | For immediate members of SizeSelect, i.e. : ParameterValue (a Real) |
| CStepBasic_SizeSelect | |
| CStepBasic_SolidAngleMeasureWithUnit | |
| CStepBasic_SolidAngleUnit | |
| CStepBasic_SourceItem | Representation of STEP SELECT type SourceItem |
| CStepBasic_ThermodynamicTemperatureUnit | Representation of STEP entity ThermodynamicTemperatureUnit |
| CStepBasic_TimeMeasureWithUnit | |
| CStepBasic_TimeUnit | |
| CStepBasic_UncertaintyMeasureWithUnit | |
| CStepBasic_Unit | Implements a select type unit (NamedUnit or DerivedUnit) |
| CStepBasic_VersionedActionRequest | Representation of STEP entity VersionedActionRequest |
| CStepBasic_VolumeUnit | |
| CStepBasic_WeekOfYearAndDayDate | |
| CSTEPCAFControl_ActorWrite | Extends ActorWrite from STEPControl by analysis of whether shape is assembly (based on information from DECAF) |
| CSTEPCAFControl_Controller | Extends Controller from STEPControl in order to provide ActorWrite adapted for writing assemblies from DECAF Note that ActorRead from STEPControl is used for reading (inherited automatically) |
| CSTEPCAFControl_ExternFile | Auxiliary class serving as container for data resulting from translation of external file |
| CSTEPCAFControl_GDTProperty | This class provides tools for access (read) the GDT properties |
| CSTEPCAFControl_Reader | Provides a tool to read STEP file and put it into DECAF document. Besides transfer of shapes (including assemblies) provided by STEPControl, supports also colors and part names |
| CSTEPCAFControl_Writer | Provides a tool to write DECAF document to the STEP file. Besides transfer of shapes (including assemblies) provided by STEPControl, supports also colors and part names |
| CSTEPConstruct | Defines tools for creation and investigation STEP constructs used for representing various kinds of data, such as product and assembly structure, unit contexts, associated information The creation of these structures is made according to currently active schema (AP203 or AP214 CD2 or DIS) This is taken from parameter write.step.schema |
| CSTEPConstruct_AP203Context | Maintains context specific for AP203 (required data and management information such as persons, dates, approvals etc.) It contains static entities (which can be shared), default values for person and organisation, and also provides tool for creating management entities around specific part (SDR) |
| CSTEPConstruct_Assembly | This operator creates and checks an item of an assembly, from its basic data : a ShapeRepresentation, a Location .. |
| CSTEPConstruct_ContextTool | Maintains global context tool for writing. Gives access to Product Definition Context (one per Model) Maintains ApplicationProtocolDefinition entity (common for all products) Also maintains context specific for AP203 and provides set of methods to work with various STEP constructs as required by Actor |
| CSTEPConstruct_ExternRefs | Provides a tool for analyzing (reading) and creating (writing) references to external files in STEP |
| CSTEPConstruct_Part | Provides tools for creating STEP structures associated with part (SDR), such as PRODUCT, PDF etc., as required by current schema Also allows to investigate and modify this data |
| CSTEPConstruct_RenderingProperties | Class for working with STEP rendering properties. Provides functionality to create and manipulate rendering properties used for specifying visual appearance in STEP format. This class handles both parsing of STEP entities and creation of new ones |
| CSTEPConstruct_Styles | Provides a mechanism for reading and writing shape styles (such as color) to and from the STEP file This tool maintains a list of styles, either taking them from STEP model (reading), or filling it by calls to AddStyle or directly (writing). Some methods deal with general structures of styles and presentations in STEP, but there are methods which deal with particular implementation of colors (as described in RP) |
| CSTEPConstruct_Tool | Provides basic functionalities for tools which are intended for encoding/decoding specific STEP constructs |
| CSTEPConstruct_UnitContext | Tool for creation (encoding) and decoding (for writing and reading accordingly) context defining units and tolerances (uncerntanties) |
| CSTEPConstruct_ValidationProps | This class provides tools for access (write and read) the validation properties on shapes in the STEP file. These are surface area, solid volume and centroid |
| CSTEPControl_ActorRead | This class performs the transfer of an Entity from AP214 and AP203, either Geometric or Topologic |
| CSTEPControl_ActorWrite | This class performs the transfer of a Shape from TopoDS to AP203 or AP214 (CD2 or DIS) |
| CSTEPControl_Controller | Defines basic controller for STEP processor |
| CSTEPControl_Reader | Reads STEP files, checks them and translates their contents into Open CASCADE models. The STEP data can be that of a whole model or that of a specific list of entities in the model. As in XSControl_Reader, you specify the list using a selection. For the translation of iges files it is possible to use next sequence: To change translation parameters class Interface_Static should be used before beginning of translation (see STEP Parameters and General Parameters) Creation of reader - STEPControl_Reader reader; To load s file in a model use method reader.ReadFile("filename.stp") To print load results reader.PrintCheckLoad(failsonly,mode) where mode is equal to the value of enumeration IFSelect_PrintCount For definition number of candidates : int nbroots = reader. NbRootsForTransfer(); To transfer entities from a model the following methods can be used: for the whole model - reader.TransferRoots(); to transfer a list of entities: reader.TransferList(list); to transfer one entity occ::handle<Standard_Transient> ent = reader.RootForTransfer(num); reader.TransferEntity(ent), or reader.TransferOneRoot(num), or reader.TransferOne(num), or reader.TransferRoot(num) To obtain the result the following method can be used: reader.NbShapes() and reader.Shape(num); or reader.OneShape(); To print the results of transfer use method: reader.PrintCheckTransfer(failwarn,mode); where printfail is equal to the value of enumeration IFSelect_PrintFail, mode see above; or reader.PrintStatsTransfer(); Gets correspondence between a STEP entity and a result shape obtained from it. occ::handle<XSControl_WorkSession> WS = reader.WS(); if ( WS->TransferReader()->HasResult(ent) ) TopoDS_Shape shape = WS->TransferReader()->ShapeResult(ent); |
| CSTEPControl_Writer | This class creates and writes STEP files from Open CASCADE models. A STEP file can be written to an existing STEP file or to a new one. Translation can be performed in one or several operations. Each translation operation outputs a distinct root entity in the STEP file |
| CStepData | Gives basic data definition for Step Interface. Any class of a data model described in EXPRESS Language is candidate to be managed by a Step Interface |
| CStepData_DefaultGeneral | DefaultGeneral defines a GeneralModule which processes Unknown Entity from StepData only |
| CStepData_Described | General frame to describe entities with Description (Simple or Complex) |
| CStepData_ECDescr | Describes a Complex Entity (Plex) as a list of Simple ones |
| CStepData_EDescr | This class is intended to describe the authorized form for an entity, either Simple or Plex |
| CStepData_EnumTool | This class gives a way of conversion between the value of an enumeration and its representation in STEP An enumeration corresponds to an integer with reserved values, which begin to 0 In STEP, it is represented by a name in capital letter and limited by two dots, e.g. .UNKNOWN |
| CStepData_ESDescr | This class is intended to describe the authorized form for a Simple (not Plex) Entity, as a list of fields |
| CStepData_Factors | Class for using units variables |
| CStepData_Field | Defines a generally defined Field for STEP data : can be used either in any kind of entity to implement it or in free format entities in a "late-binding" mode A field can have : no value (or derived), a single value of any kind, a list of value : single or double list |
| CStepData_FieldList | Describes a list of fields, in a general way This basic class is for a null size list Subclasses are for 1, N (fixed) or Dynamic sizes |
| CStepData_FieldList1 | Describes a list of ONE field |
| CStepData_FieldListD | Describes a list of fields, in a general way This basic class is for a null size list Subclasses are for 1, N (fixed) or Dynamic sizes |
| CStepData_FieldListN | Describes a list of fields, in a general way This basic class is for a null size list Subclasses are for 1, N (fixed) or Dynamic sizes |
| CStepData_FileProtocol | A FileProtocol is defined as the addition of several already existing Protocols. It corresponds to the definition of a SchemaName with several Names, each one being attached to a specific Protocol. Thus, a File defined with a compound Schema is processed as any other one, once built the equivalent compound Protocol, a FileProtocol |
| CStepData_FileRecognizer | |
| CStepData_FreeFormEntity | A Free Form Entity allows to record any kind of STEP parameters, in any way of typing It is implemented with an array of fields A Complex entity can be defined, as a chain of FreeFormEntity (see Next and As) |
| CStepData_GeneralModule | Specific features for General Services adapted to STEP |
| CStepData_GlobalNodeOfWriterLib | |
| CStepData_NodeOfWriterLib | |
| CStepData_PDescr | This class is intended to describe the authorized form for a parameter, as a type or a value for a field |
| CStepData_Plex | A Plex (for Complex) Entity is defined as a list of Simple Members ("external mapping") The types of these members must be in alphabetic order |
| CStepData_Protocol | Description of Basic Protocol for Step The class Protocol from StepData itself describes a default Protocol, which recognizes only UnknownEntities. Sub-classes will redefine CaseNumber and, if necessary, NbResources and Resources |
| CStepData_ReadWriteModule | Defines basic File Access Module (Recognize, Read, Write) That is : ReaderModule (Recognize & Read) + Write for StepWriter (for a more centralized description) Warning : A sub-class of ReadWriteModule, which belongs to a particular Protocol, must use the same definition for Case Numbers (give the same Value for a StepType defined as a String from a File as the Protocol does for the corresponding Entity) |
| CStepData_SelectArrReal | |
| CStepData_SelectInt | A SelectInt is a SelectMember specialised for a basic integer type in a select which also accepts entities : this one has NO NAME. For a named select, see SelectNamed |
| CStepData_SelectMember | The general form for a Select Member. A Select Member can, either define a value of a basic type (such as an integer) with an additional information : a name or list of names which precise the meaning of this value or be an alternate value in a select, which also accepts an entity (in this case, the name is not mandatory) |
| CStepData_SelectNamed | This select member can be of any kind, and be named But its takes more memory than some specialised ones This class allows one name for the instance |
| CStepData_SelectReal | A SelectReal is a SelectMember specialised for a basic real type in a select which also accepts entities : this one has NO NAME For a named select, see SelectNamed |
| CStepData_SelectType | SelectType is the basis used for SELECT_TYPE definitions from the EXPRESS form. A SELECT_TYPE in EXPRESS is an enumeration of Types, it corresponds in a way to a Super-Type, but with no specific Methods, and no exclusivity (a given Type can be member of several SELECT_TYPES, plus be itself a SUB_TYPE) |
| CStepData_Simple | A Simple Entity is defined by a type (which can heve super types) and a list of parameters |
| CStepData_StepDumper | Provides a way to dump entities processed through STEP, with these features : |
| CStepData_StepModel | Gives access to |
| CStepData_StepReaderData | Specific FileReaderData for Step Contains literal description of entities (for each one : type as a string, ident, parameter list) provides references evaluation, plus access to literal data and specific access methods (Boolean, XY, XYZ) |
| CStepData_StepReaderTool | Specific FileReaderTool for Step; works with FileReaderData provides references evaluation, plus access to literal data and specific methods defined by FileReaderTool Remarks : works with a ReaderLib to load Entities |
| CStepData_StepWriter | Manages atomic file writing, under control of StepModel (for general organisation of file) and each class of Transient (for its own parameters) : prepares text to be written then writes it A stream cannot be used because Step limits line length at 72 In more, a specific object offers more appropriate functions |
| CStepData_UndefinedEntity | Undefined entity specific to Step Interface, in which StepType is defined at each instance, or is a SubList of another one Uses an UndefinedContent, that from Interface is suitable. Also an Entity defined by STEP can be "Complex Type" (see ANDOR clause in Express) |
| CStepData_WriterLib | |
| CStepDimTol_AngularityTolerance | Representation of STEP entity AngularityTolerance |
| CStepDimTol_CircularRunoutTolerance | Representation of STEP entity CircularRunoutTolerance |
| CStepDimTol_CoaxialityTolerance | Representation of STEP entity CoaxialityTolerance |
| CStepDimTol_CommonDatum | Representation of STEP entity CommonDatum |
| CStepDimTol_ConcentricityTolerance | Representation of STEP entity ConcentricityTolerance |
| CStepDimTol_CylindricityTolerance | Representation of STEP entity CylindricityTolerance |
| CStepDimTol_Datum | Representation of STEP entity Datum |
| CStepDimTol_DatumFeature | Representation of STEP entity DatumFeature |
| CStepDimTol_DatumOrCommonDatum | |
| CStepDimTol_DatumReference | Representation of STEP entity DatumReference |
| CStepDimTol_DatumReferenceCompartment | Representation of STEP entity DatumReferenceCompartment |
| CStepDimTol_DatumReferenceElement | Representation of STEP entity DatumReferenceElement |
| CStepDimTol_DatumReferenceModifier | |
| CStepDimTol_DatumReferenceModifierWithValue | Representation of STEP entity DatumReferenceModifierWithValue |
| CStepDimTol_DatumSystem | Representation of STEP entity DatumSystem |
| CStepDimTol_DatumSystemOrReference | |
| CStepDimTol_DatumTarget | Representation of STEP entity DatumTarget |
| CStepDimTol_FlatnessTolerance | Representation of STEP entity FlatnessTolerance |
| CStepDimTol_GeneralDatumReference | Representation of STEP entity GeneralDatumReference |
| CStepDimTol_GeometricTolerance | Representation of STEP entity GeometricTolerance |
| CStepDimTol_GeometricToleranceRelationship | Representation of STEP entity GeometricToleranceRelationship |
| CStepDimTol_GeometricToleranceTarget | |
| CStepDimTol_GeometricToleranceWithDatumReference | Representation of STEP entity GeometricToleranceWithDatumReference |
| CStepDimTol_GeometricToleranceWithDefinedAreaUnit | Representation of STEP entity GeometricToleranceWithDefinedAreaUnit |
| CStepDimTol_GeometricToleranceWithDefinedUnit | Representation of STEP entity GeometricToleranceWithDefinedUnit |
| CStepDimTol_GeometricToleranceWithMaximumTolerance | Representation of STEP entity GeometricToleranceWithMaximumTolerance |
| CStepDimTol_GeometricToleranceWithModifiers | Representation of STEP entity GeometricToleranceWithModifiers |
| CStepDimTol_GeoTolAndGeoTolWthDatRef | |
| CStepDimTol_GeoTolAndGeoTolWthDatRefAndGeoTolWthMaxTol | |
| CStepDimTol_GeoTolAndGeoTolWthDatRefAndGeoTolWthMod | |
| CStepDimTol_GeoTolAndGeoTolWthDatRefAndModGeoTolAndPosTol | |
| CStepDimTol_GeoTolAndGeoTolWthDatRefAndUneqDisGeoTol | |
| CStepDimTol_GeoTolAndGeoTolWthMaxTol | |
| CStepDimTol_GeoTolAndGeoTolWthMod | |
| CStepDimTol_LineProfileTolerance | Representation of STEP entity LineProfileTolerance |
| CStepDimTol_ModifiedGeometricTolerance | Representation of STEP entity ModifiedGeometricTolerance |
| CStepDimTol_NonUniformZoneDefinition | Representation of STEP entity NonUniformZoneDefinition |
| CStepDimTol_ParallelismTolerance | Representation of STEP entity ParallelismTolerance |
| CStepDimTol_PerpendicularityTolerance | Representation of STEP entity PerpendicularityTolerance |
| CStepDimTol_PlacedDatumTargetFeature | Representation of STEP entity PlacedDatumTargetFeature |
| CStepDimTol_PositionTolerance | Representation of STEP entity PositionTolerance |
| CStepDimTol_ProjectedZoneDefinition | Representation of STEP entity ProjectedZoneDefinition |
| CStepDimTol_RoundnessTolerance | Representation of STEP entity RoundnessTolerance |
| CStepDimTol_RunoutZoneDefinition | Representation of STEP entity ToleranceZoneDefinition |
| CStepDimTol_RunoutZoneOrientation | Added for Dimensional Tolerances |
| CStepDimTol_ShapeToleranceSelect | Representation of STEP SELECT type ShapeToleranceSelect |
| CStepDimTol_SimpleDatumReferenceModifierMember | Defines SimpleDatumReferenceModifier as unique member of DatumReferenceModifier Works with an EnumTool |
| CStepDimTol_StraightnessTolerance | Representation of STEP entity StraightnessTolerance |
| CStepDimTol_SurfaceProfileTolerance | Representation of STEP entity SurfaceProfileTolerance |
| CStepDimTol_SymmetryTolerance | Representation of STEP entity SymmetryTolerance |
| CStepDimTol_ToleranceZone | Representation of STEP entity ToleranceZone |
| CStepDimTol_ToleranceZoneDefinition | Representation of STEP entity ToleranceZoneDefinition |
| CStepDimTol_ToleranceZoneForm | Added for Dimensional Tolerances |
| CStepDimTol_ToleranceZoneTarget | |
| CStepDimTol_TotalRunoutTolerance | Representation of STEP entity TotalRunoutTolerance |
| CStepDimTol_UnequallyDisposedGeometricTolerance | Representation of STEP entity UnequallyDisposedGeometricTolerance |
| CSTEPEdit | Provides tools to exploit and edit a set of STEP data : editors, selections . |
| CSTEPEdit_EditContext | EditContext is an Editor fit for Product Definition Context (one per Model) , i.e. : |
| CSTEPEdit_EditSDR | EditSDR is an Editor fit for a Shape Definition Representation which designates a Product Definition |
| CStepElement_AnalysisItemWithinRepresentation | Representation of STEP entity AnalysisItemWithinRepresentation |
| CStepElement_Curve3dElementDescriptor | Representation of STEP entity Curve3dElementDescriptor |
| CStepElement_CurveElementEndReleasePacket | Representation of STEP entity CurveElementEndReleasePacket |
| CStepElement_CurveElementFreedom | Representation of STEP SELECT type CurveElementFreedom |
| CStepElement_CurveElementFreedomMember | Representation of member for STEP SELECT type CurveElementFreedom |
| CStepElement_CurveElementPurpose | Representation of STEP SELECT type CurveElementPurpose |
| CStepElement_CurveElementPurposeMember | Representation of member for STEP SELECT type CurveElementPurpose |
| CStepElement_CurveElementSectionDefinition | Representation of STEP entity CurveElementSectionDefinition |
| CStepElement_CurveElementSectionDerivedDefinitions | Representation of STEP entity CurveElementSectionDerivedDefinitions |
| CStepElement_ElementAspect | Representation of STEP SELECT type ElementAspect |
| CStepElement_ElementAspectMember | Representation of member for STEP SELECT type ElementAspect |
| CStepElement_ElementDescriptor | Representation of STEP entity ElementDescriptor |
| CStepElement_ElementMaterial | Representation of STEP entity ElementMaterial |
| CStepElement_MeasureOrUnspecifiedValue | Representation of STEP SELECT type MeasureOrUnspecifiedValue |
| CStepElement_MeasureOrUnspecifiedValueMember | Representation of member for STEP SELECT type MeasureOrUnspecifiedValue |
| CStepElement_Surface3dElementDescriptor | Representation of STEP entity Surface3dElementDescriptor |
| CStepElement_SurfaceElementProperty | Representation of STEP entity SurfaceElementProperty |
| CStepElement_SurfaceElementPurpose | Representation of STEP SELECT type SurfaceElementPurpose |
| CStepElement_SurfaceElementPurposeMember | Representation of member for STEP SELECT type SurfaceElementPurpose |
| CStepElement_SurfaceSection | Representation of STEP entity SurfaceSection |
| CStepElement_SurfaceSectionField | Representation of STEP entity SurfaceSectionField |
| CStepElement_SurfaceSectionFieldConstant | Representation of STEP entity SurfaceSectionFieldConstant |
| CStepElement_SurfaceSectionFieldVarying | Representation of STEP entity SurfaceSectionFieldVarying |
| CStepElement_UniformSurfaceSection | Representation of STEP entity UniformSurfaceSection |
| CStepElement_Volume3dElementDescriptor | Representation of STEP entity Volume3dElementDescriptor |
| CStepElement_VolumeElementPurpose | Representation of STEP SELECT type VolumeElementPurpose |
| CStepElement_VolumeElementPurposeMember | Representation of member for STEP SELECT type VolumeElementPurpose |
| CStepFEA_AlignedCurve3dElementCoordinateSystem | Representation of STEP entity AlignedCurve3dElementCoordinateSystem |
| CStepFEA_AlignedSurface3dElementCoordinateSystem | Representation of STEP entity AlignedSurface3dElementCoordinateSystem |
| CStepFEA_ArbitraryVolume3dElementCoordinateSystem | Representation of STEP entity ArbitraryVolume3dElementCoordinateSystem |
| CStepFEA_ConstantSurface3dElementCoordinateSystem | Representation of STEP entity ConstantSurface3dElementCoordinateSystem |
| CStepFEA_Curve3dElementProperty | Representation of STEP entity Curve3dElementProperty |
| CStepFEA_Curve3dElementRepresentation | Representation of STEP entity Curve3dElementRepresentation |
| CStepFEA_CurveElementEndCoordinateSystem | Representation of STEP SELECT type CurveElementEndCoordinateSystem |
| CStepFEA_CurveElementEndOffset | Representation of STEP entity CurveElementEndOffset |
| CStepFEA_CurveElementEndRelease | Representation of STEP entity CurveElementEndRelease |
| CStepFEA_CurveElementInterval | Representation of STEP entity CurveElementInterval |
| CStepFEA_CurveElementIntervalConstant | Representation of STEP entity CurveElementIntervalConstant |
| CStepFEA_CurveElementIntervalLinearlyVarying | Representation of STEP entity CurveElementIntervalLinearlyVarying |
| CStepFEA_CurveElementLocation | Representation of STEP entity CurveElementLocation |
| CStepFEA_DegreeOfFreedom | Representation of STEP SELECT type DegreeOfFreedom |
| CStepFEA_DegreeOfFreedomMember | Representation of member for STEP SELECT type CurveElementFreedom |
| CStepFEA_DummyNode | Representation of STEP entity DummyNode |
| CStepFEA_ElementGeometricRelationship | Representation of STEP entity ElementGeometricRelationship |
| CStepFEA_ElementGroup | Representation of STEP entity ElementGroup |
| CStepFEA_ElementOrElementGroup | Representation of STEP SELECT type ElementOrElementGroup |
| CStepFEA_ElementRepresentation | Representation of STEP entity ElementRepresentation |
| CStepFEA_FeaAreaDensity | Representation of STEP entity FeaAreaDensity |
| CStepFEA_FeaAxis2Placement3d | Representation of STEP entity FeaAxis2Placement3d |
| CStepFEA_FeaCurveSectionGeometricRelationship | Representation of STEP entity FeaCurveSectionGeometricRelationship |
| CStepFEA_FeaGroup | Representation of STEP entity FeaGroup |
| CStepFEA_FeaLinearElasticity | Representation of STEP entity FeaLinearElasticity |
| CStepFEA_FeaMassDensity | Representation of STEP entity FeaMassDensity |
| CStepFEA_FeaMaterialPropertyRepresentation | Representation of STEP entity FeaMaterialPropertyRepresentation |
| CStepFEA_FeaMaterialPropertyRepresentationItem | Representation of STEP entity FeaMaterialPropertyRepresentationItem |
| CStepFEA_FeaModel | Representation of STEP entity FeaModel |
| CStepFEA_FeaModel3d | Representation of STEP entity FeaModel3d |
| CStepFEA_FeaModelDefinition | Representation of STEP entity FeaModelDefinition |
| CStepFEA_FeaMoistureAbsorption | Representation of STEP entity FeaMoistureAbsorption |
| CStepFEA_FeaParametricPoint | Representation of STEP entity FeaParametricPoint |
| CStepFEA_FeaRepresentationItem | Representation of STEP entity FeaRepresentationItem |
| CStepFEA_FeaSecantCoefficientOfLinearThermalExpansion | Representation of STEP entity FeaSecantCoefficientOfLinearThermalExpansion |
| CStepFEA_FeaShellBendingStiffness | Representation of STEP entity FeaShellBendingStiffness |
| CStepFEA_FeaShellMembraneBendingCouplingStiffness | Representation of STEP entity FeaShellMembraneBendingCouplingStiffness |
| CStepFEA_FeaShellMembraneStiffness | Representation of STEP entity FeaShellMembraneStiffness |
| CStepFEA_FeaShellShearStiffness | Representation of STEP entity FeaShellShearStiffness |
| CStepFEA_FeaSurfaceSectionGeometricRelationship | Representation of STEP entity FeaSurfaceSectionGeometricRelationship |
| CStepFEA_FeaTangentialCoefficientOfLinearThermalExpansion | Representation of STEP entity FeaTangentialCoefficientOfLinearThermalExpansion |
| CStepFEA_FreedomAndCoefficient | Representation of STEP entity FreedomAndCoefficient |
| CStepFEA_FreedomsList | Representation of STEP entity FreedomsList |
| CStepFEA_GeometricNode | Representation of STEP entity GeometricNode |
| CStepFEA_Node | Representation of STEP entity Node |
| CStepFEA_NodeDefinition | Representation of STEP entity NodeDefinition |
| CStepFEA_NodeGroup | Representation of STEP entity NodeGroup |
| CStepFEA_NodeRepresentation | Representation of STEP entity NodeRepresentation |
| CStepFEA_NodeSet | Representation of STEP entity NodeSet |
| CStepFEA_NodeWithSolutionCoordinateSystem | Representation of STEP entity NodeWithSolutionCoordinateSystem |
| CStepFEA_NodeWithVector | Representation of STEP entity NodeWithVector |
| CStepFEA_ParametricCurve3dElementCoordinateDirection | Representation of STEP entity ParametricCurve3dElementCoordinateDirection |
| CStepFEA_ParametricCurve3dElementCoordinateSystem | Representation of STEP entity ParametricCurve3dElementCoordinateSystem |
| CStepFEA_ParametricSurface3dElementCoordinateSystem | Representation of STEP entity ParametricSurface3dElementCoordinateSystem |
| CStepFEA_Surface3dElementRepresentation | Representation of STEP entity Surface3dElementRepresentation |
| CStepFEA_SymmetricTensor22d | Representation of STEP SELECT type SymmetricTensor22d |
| CStepFEA_SymmetricTensor23d | Representation of STEP SELECT type SymmetricTensor23d |
| CStepFEA_SymmetricTensor23dMember | Representation of member for STEP SELECT type SymmetricTensor23d |
| CStepFEA_SymmetricTensor42d | Representation of STEP SELECT type SymmetricTensor42d |
| CStepFEA_SymmetricTensor43d | Representation of STEP SELECT type SymmetricTensor43d |
| CStepFEA_SymmetricTensor43dMember | Representation of member for STEP SELECT type SymmetricTensor43d |
| CStepFEA_Volume3dElementRepresentation | Representation of STEP entity Volume3dElementRepresentation |
| CStepFile_ReadData | |
| CStepGeom_Axis1Placement | |
| CStepGeom_Axis2Placement | |
| CStepGeom_Axis2Placement2d | |
| CStepGeom_Axis2Placement3d | |
| CStepGeom_BezierCurve | |
| CStepGeom_BezierCurveAndRationalBSplineCurve | |
| CStepGeom_BezierSurface | |
| CStepGeom_BezierSurfaceAndRationalBSplineSurface | |
| CStepGeom_BoundaryCurve | |
| CStepGeom_BoundedCurve | |
| CStepGeom_BoundedSurface | |
| CStepGeom_BSplineCurve | |
| CStepGeom_BSplineCurveWithKnots | |
| CStepGeom_BSplineCurveWithKnotsAndRationalBSplineCurve | |
| CStepGeom_BSplineSurface | |
| CStepGeom_BSplineSurfaceWithKnots | |
| CStepGeom_BSplineSurfaceWithKnotsAndRationalBSplineSurface | |
| CStepGeom_CartesianPoint | |
| CStepGeom_CartesianTransformationOperator | |
| CStepGeom_CartesianTransformationOperator2d | Added from StepGeom Rev2 to Rev4 |
| CStepGeom_CartesianTransformationOperator3d | |
| CStepGeom_Circle | |
| CStepGeom_CompositeCurve | |
| CStepGeom_CompositeCurveOnSurface | |
| CStepGeom_CompositeCurveSegment | |
| CStepGeom_Conic | |
| CStepGeom_ConicalSurface | |
| CStepGeom_Curve | |
| CStepGeom_CurveBoundedSurface | Representation of STEP entity CurveBoundedSurface |
| CStepGeom_CurveOnSurface | |
| CStepGeom_CurveReplica | |
| CStepGeom_CylindricalSurface | |
| CStepGeom_DegeneratePcurve | |
| CStepGeom_DegenerateToroidalSurface | |
| CStepGeom_Direction | |
| CStepGeom_ElementarySurface | |
| CStepGeom_Ellipse | |
| CStepGeom_EvaluatedDegeneratePcurve | |
| CStepGeom_GeometricRepresentationContext | |
| CStepGeom_GeometricRepresentationContextAndGlobalUnitAssignedContext | |
| CStepGeom_GeometricRepresentationContextAndParametricRepresentationContext | |
| CStepGeom_GeometricRepresentationItem | |
| CStepGeom_GeomRepContextAndGlobUnitAssCtxAndGlobUncertaintyAssCtx | |
| CStepGeom_Hyperbola | |
| CStepGeom_IntersectionCurve | |
| CStepGeom_Line | |
| CStepGeom_OffsetCurve3d | |
| CStepGeom_OffsetSurface | |
| CStepGeom_OrientedSurface | Representation of STEP entity OrientedSurface |
| CStepGeom_OuterBoundaryCurve | |
| CStepGeom_Parabola | |
| CStepGeom_Pcurve | |
| CStepGeom_PcurveOrSurface | |
| CStepGeom_Placement | |
| CStepGeom_Plane | |
| CStepGeom_Point | |
| CStepGeom_PointOnCurve | |
| CStepGeom_PointOnSurface | |
| CStepGeom_PointReplica | |
| CStepGeom_Polyline | |
| CStepGeom_QuasiUniformCurve | |
| CStepGeom_QuasiUniformCurveAndRationalBSplineCurve | |
| CStepGeom_QuasiUniformSurface | |
| CStepGeom_QuasiUniformSurfaceAndRationalBSplineSurface | |
| CStepGeom_RationalBSplineCurve | |
| CStepGeom_RationalBSplineSurface | |
| CStepGeom_RectangularCompositeSurface | |
| CStepGeom_RectangularTrimmedSurface | |
| CStepGeom_ReparametrisedCompositeCurveSegment | |
| CStepGeom_SeamCurve | |
| CStepGeom_SphericalSurface | |
| CStepGeom_SuParameters | Representation of STEP entity SuParameters |
| CStepGeom_Surface | |
| CStepGeom_SurfaceBoundary | Representation of STEP SELECT type SurfaceBoundary |
| CStepGeom_SurfaceCurve | |
| CStepGeom_SurfaceCurveAndBoundedCurve | Complex type: bounded_curve + surface_curve needed for curve_bounded_surfaces (S4132) |
| CStepGeom_SurfaceOfLinearExtrusion | |
| CStepGeom_SurfaceOfRevolution | |
| CStepGeom_SurfacePatch | |
| CStepGeom_SurfaceReplica | |
| CStepGeom_SweptSurface | |
| CStepGeom_ToroidalSurface | |
| CStepGeom_TrimmedCurve | |
| CStepGeom_TrimmingMember | For immediate members of TrimmingSelect, i.e. : ParameterValue (a Real) |
| CStepGeom_TrimmingSelect | |
| CStepGeom_UniformCurve | |
| CStepGeom_UniformCurveAndRationalBSplineCurve | |
| CStepGeom_UniformSurface | |
| CStepGeom_UniformSurfaceAndRationalBSplineSurface | |
| CStepGeom_Vector | |
| CStepGeom_VectorOrDirection | |
| CStepKinematics_ActuatedKinematicPair | Representation of STEP entity ActuatedKinematicPair |
| CStepKinematics_ActuatedKinPairAndOrderKinPair | Representation of STEP entity ActuatedKinPairAndOrderKinPair |
| CStepKinematics_ContextDependentKinematicLinkRepresentation | Representation of STEP entity ContextDependentKinematicLinkRepresentation |
| CStepKinematics_CylindricalPair | Representation of STEP entity CylindricalPair |
| CStepKinematics_CylindricalPairValue | Representation of STEP entity CylindricalPairValue |
| CStepKinematics_CylindricalPairWithRange | Representation of STEP entity CylindricalPairWithRange |
| CStepKinematics_FullyConstrainedPair | Representation of STEP entity FullyConstrainedPair |
| CStepKinematics_GearPair | Representation of STEP entity GearPair |
| CStepKinematics_GearPairValue | Representation of STEP entity GearPairValue |
| CStepKinematics_GearPairWithRange | Representation of STEP entity GearPairWithRange |
| CStepKinematics_HighOrderKinematicPair | Representation of STEP entity HighOrderKinematicPair |
| CStepKinematics_HomokineticPair | Representation of STEP entity HomokineticPair |
| CStepKinematics_KinematicJoint | Representation of STEP entity KinematicJoint |
| CStepKinematics_KinematicLink | Representation of STEP entity KinematicLink |
| CStepKinematics_KinematicLinkRepresentation | Representation of STEP entity KinematicLinkRepresentation |
| CStepKinematics_KinematicLinkRepresentationAssociation | Representation of STEP entity KinematicLinkRepresentationAssociation |
| CStepKinematics_KinematicPair | Representation of STEP entity KinematicPair |
| CStepKinematics_KinematicPropertyDefinitionRepresentation | Representation of STEP entity KinematicPropertyDefinitionRepresentation |
| CStepKinematics_KinematicPropertyMechanismRepresentation | Representation of STEP entity KinematicPropertyMechanismRepresentation |
| CStepKinematics_KinematicTopologyDirectedStructure | Representation of STEP entity KinematicTopologyDirectedStructure |
| CStepKinematics_KinematicTopologyNetworkStructure | Representation of STEP entity KinematicTopologyNetworkStructure |
| CStepKinematics_KinematicTopologyRepresentationSelect | Representation of STEP SELECT type KinematicTopologyRepresentationSelect |
| CStepKinematics_KinematicTopologyStructure | Representation of STEP entity KinematicTopologyStructure |
| CStepKinematics_LinearFlexibleAndPinionPair | Representation of STEP entity LinearFlexibleAndPinionPair |
| CStepKinematics_LinearFlexibleAndPlanarCurvePair | Representation of STEP entity LinearFlexibleAndPlanarCurvePair |
| CStepKinematics_LinearFlexibleLinkRepresentation | Representation of STEP entity LinearFlexibleLinkRepresentation |
| CStepKinematics_LowOrderKinematicPair | Representation of STEP entity LowOrderKinematicPair |
| CStepKinematics_LowOrderKinematicPairValue | Representation of STEP entity LowOrderKinematicPairValue |
| CStepKinematics_LowOrderKinematicPairWithMotionCoupling | Representation of STEP entity LowOrderKinematicPairWithMotionCoupling |
| CStepKinematics_LowOrderKinematicPairWithRange | Representation of STEP entity LowOrderKinematicPairWithRange |
| CStepKinematics_MechanismRepresentation | Representation of STEP entity MechanismRepresentation |
| CStepKinematics_MechanismStateRepresentation | |
| CStepKinematics_OrientedJoint | Representation of STEP entity OrientedJoint |
| CStepKinematics_PairRepresentationRelationship | Representation of STEP entity PairRepresentationRelationship |
| CStepKinematics_PairValue | Representation of STEP entity PairValue |
| CStepKinematics_PlanarCurvePair | Representation of STEP entity PlanarCurvePair |
| CStepKinematics_PlanarCurvePairRange | Representation of STEP entity PlanarCurvePairRange |
| CStepKinematics_PlanarPair | Representation of STEP entity PlanarPair |
| CStepKinematics_PlanarPairValue | Representation of STEP entity PlanarPairValue |
| CStepKinematics_PlanarPairWithRange | Representation of STEP entity PlanarPairWithRange |
| CStepKinematics_PointOnPlanarCurvePair | Representation of STEP entity PointOnPlanarCurvePair |
| CStepKinematics_PointOnPlanarCurvePairValue | Representation of STEP entity PointOnPlanarCurvePairValue |
| CStepKinematics_PointOnPlanarCurvePairWithRange | Representation of STEP entity PointOnPlanarCurvePairWithRange |
| CStepKinematics_PointOnSurfacePair | Representation of STEP entity PointOnSurfacePair |
| CStepKinematics_PointOnSurfacePairValue | Representation of STEP entity PointOnSurfacePairValue |
| CStepKinematics_PointOnSurfacePairWithRange | Representation of STEP entity PointOnSurfacePairWithRange |
| CStepKinematics_PrismaticPair | Representation of STEP entity PrismaticPair |
| CStepKinematics_PrismaticPairValue | Representation of STEP entity PrismaticPairValue |
| CStepKinematics_PrismaticPairWithRange | Representation of STEP entity PrismaticPairWithRange |
| CStepKinematics_ProductDefinitionKinematics | Representation of STEP entity ProductDefinitionKinematics |
| CStepKinematics_ProductDefinitionRelationshipKinematics | Representation of STEP entity ProductDefinitionRelationshipKinematics |
| CStepKinematics_RackAndPinionPair | Representation of STEP entity RackAndPinionPair |
| CStepKinematics_RackAndPinionPairValue | Representation of STEP entity RackAndPinionPairValue |
| CStepKinematics_RackAndPinionPairWithRange | Representation of STEP entity RackAndPinionPairWithRange |
| CStepKinematics_RevolutePair | Representation of STEP entity RevolutePair |
| CStepKinematics_RevolutePairValue | Representation of STEP entity RevolutePairValue |
| CStepKinematics_RevolutePairWithRange | Representation of STEP entity RevolutePairWithRange |
| CStepKinematics_RigidLinkRepresentation | Representation of STEP entity RigidLinkRepresentation |
| CStepKinematics_RigidPlacement | Representation of STEP SELECT type RigidPlacement |
| CStepKinematics_RollingCurvePair | Representation of STEP entity RollingCurvePair |
| CStepKinematics_RollingCurvePairValue | Representation of STEP entity RollingCurvePairValue |
| CStepKinematics_RollingSurfacePair | Representation of STEP entity RollingSurfacePair |
| CStepKinematics_RollingSurfacePairValue | Representation of STEP entity RollingSurfacePairValue |
| CStepKinematics_RotationAboutDirection | Representation of STEP entity RotationAboutDirection |
| CStepKinematics_ScrewPair | Representation of STEP entity ScrewPair |
| CStepKinematics_ScrewPairValue | Representation of STEP entity ScrewPairValue |
| CStepKinematics_ScrewPairWithRange | Representation of STEP entity ScrewPairWithRange |
| CStepKinematics_SlidingCurvePair | Representation of STEP entity SlidingCurvePair |
| CStepKinematics_SlidingCurvePairValue | Representation of STEP entity SlidingCurvePairValue |
| CStepKinematics_SlidingSurfacePair | Representation of STEP entity SlidingSurfacePair |
| CStepKinematics_SlidingSurfacePairValue | Representation of STEP entity SlidingSurfacePairValue |
| CStepKinematics_SpatialRotation | Representation of STEP SELECT type SpatialRotation |
| CStepKinematics_SphericalPair | Representation of STEP entity SphericalPair |
| CStepKinematics_SphericalPairSelect | Representation of STEP SELECT type SphericalPairSelect |
| CStepKinematics_SphericalPairValue | Representation of STEP entity SphericalPairValue |
| CStepKinematics_SphericalPairWithPin | Representation of STEP entity SphericalPairWithPin |
| CStepKinematics_SphericalPairWithPinAndRange | Representation of STEP entity SphericalPairWithPinAndRange |
| CStepKinematics_SphericalPairWithRange | Representation of STEP entity SphericalPairWithRange |
| CStepKinematics_SurfacePair | Representation of STEP entity SurfacePair |
| CStepKinematics_SurfacePairWithRange | Representation of STEP entity SurfacePairWithRange |
| CStepKinematics_UnconstrainedPair | Representation of STEP entity UnconstrainedPair |
| CStepKinematics_UnconstrainedPairValue | Representation of STEP entity UnconstrainedPairValue |
| CStepKinematics_UniversalPair | Representation of STEP entity UniversalPair |
| CStepKinematics_UniversalPairValue | Representation of STEP entity UniversalPairValue |
| CStepKinematics_UniversalPairWithRange | Representation of STEP entity UniversalPairWithRange |
| CStepRepr_AllAroundShapeAspect | Added for Dimensional Tolerances |
| CStepRepr_Apex | Added for Dimensional Tolerances |
| CStepRepr_AssemblyComponentUsage | Representation of STEP entity AssemblyComponentUsage |
| CStepRepr_AssemblyComponentUsageSubstitute | |
| CStepRepr_BetweenShapeAspect | Added for Dimensional Tolerances |
| CStepRepr_BooleanRepresentationItem | |
| CStepRepr_CentreOfSymmetry | Added for Dimensional Tolerances |
| CStepRepr_CharacterizedDefinition | Representation of STEP SELECT type CharacterizedDefinition |
| CStepRepr_CharacterizedRepresentation | |
| CStepRepr_CompGroupShAspAndCompShAspAndDatumFeatAndShAsp | Added for Dimensional Tolerances |
| CStepRepr_CompositeGroupShapeAspect | Added for Dimensional Tolerances |
| CStepRepr_CompositeShapeAspect | Added for Dimensional Tolerances |
| CStepRepr_CompoundRepresentationItem | Added for Dimensional Tolerances |
| CStepRepr_CompShAspAndDatumFeatAndShAsp | Added for Dimensional Tolerances |
| CStepRepr_ConfigurationDesign | Representation of STEP entity ConfigurationDesign |
| CStepRepr_ConfigurationDesignItem | Representation of STEP SELECT type ConfigurationDesignItem |
| CStepRepr_ConfigurationEffectivity | Representation of STEP entity ConfigurationEffectivity |
| CStepRepr_ConfigurationItem | Representation of STEP entity ConfigurationItem |
| CStepRepr_ConstructiveGeometryRepresentation | |
| CStepRepr_ConstructiveGeometryRepresentationRelationship | |
| CStepRepr_ContinuosShapeAspect | Added for Dimensional Tolerances |
| CStepRepr_DataEnvironment | Representation of STEP entity DataEnvironment |
| CStepRepr_DefinitionalRepresentation | |
| CStepRepr_DerivedShapeAspect | Added for Dimensional Tolerances |
| CStepRepr_DescriptiveRepresentationItem | |
| CStepRepr_Extension | Added for Dimensional Tolerances |
| CStepRepr_ExternallyDefinedRepresentation | |
| CStepRepr_FeatureForDatumTargetRelationship | Representation of STEP entity DimensionalLocation |
| CStepRepr_FunctionallyDefinedTransformation | |
| CStepRepr_GeometricAlignment | Added for Dimensional Tolerances |
| CStepRepr_GlobalUncertaintyAssignedContext | |
| CStepRepr_GlobalUnitAssignedContext | |
| CStepRepr_IntegerRepresentationItem | |
| CStepRepr_ItemDefinedTransformation | Added from StepRepr Rev2 to Rev4 |
| CStepRepr_MakeFromUsageOption | Representation of STEP entity MakeFromUsageOption |
| CStepRepr_MappedItem | |
| CStepRepr_MaterialDesignation | |
| CStepRepr_MaterialProperty | Representation of STEP entity MaterialProperty |
| CStepRepr_MaterialPropertyRepresentation | Representation of STEP entity MaterialPropertyRepresentation |
| CStepRepr_MeasureRepresentationItem | Implements a measure_representation_item entity which is used for storing validation properties (e.g. area) for shapes |
| CStepRepr_MechanicalDesignAndDraughtingRelationship | |
| CStepRepr_NextAssemblyUsageOccurrence | Representation of STEP entity NextAssemblyUsageOccurrence |
| CStepRepr_ParallelOffset | Added for Dimensional Tolerances |
| CStepRepr_ParametricRepresentationContext | |
| CStepRepr_PerpendicularTo | Added for Dimensional Tolerances |
| CStepRepr_ProductConcept | Representation of STEP entity ProductConcept |
| CStepRepr_ProductDefinitionShape | Representation of STEP entity ProductDefinitionShape |
| CStepRepr_ProductDefinitionUsage | Representation of STEP entity ProductDefinitionUsage |
| CStepRepr_PromissoryUsageOccurrence | |
| CStepRepr_PropertyDefinition | Representation of STEP entity PropertyDefinition |
| CStepRepr_PropertyDefinitionRelationship | Representation of STEP entity PropertyDefinitionRelationship |
| CStepRepr_PropertyDefinitionRepresentation | Representation of STEP entity PropertyDefinitionRepresentation |
| CStepRepr_QuantifiedAssemblyComponentUsage | Representation of STEP entity QuantifiedAssemblyComponentUsage |
| CStepRepr_RealRepresentationItem | |
| CStepRepr_Representation | |
| CStepRepr_RepresentationContext | |
| CStepRepr_RepresentationContextReference | Representation of STEP entity RepresentationContextReference |
| CStepRepr_RepresentationItem | |
| CStepRepr_RepresentationMap | |
| CStepRepr_RepresentationOrRepresentationReference | Representation of STEP SELECT type RepresentationOrRepresentationReference |
| CStepRepr_RepresentationReference | Representation of STEP entity RepresentationReference |
| CStepRepr_RepresentationRelationship | |
| CStepRepr_RepresentationRelationshipWithTransformation | |
| CStepRepr_RepresentedDefinition | Representation of STEP SELECT type RepresentedDefinition |
| CStepRepr_ReprItemAndLengthMeasureWithUnit | |
| CStepRepr_ReprItemAndLengthMeasureWithUnitAndQRI | |
| CStepRepr_ReprItemAndMeasureWithUnit | Base class for complex types (MEASURE_REPRESENTATION_ITEM, MEASURE_WITH_UNIT, REPRESENTATION_ITEM, LENGTH_MEASURE_WITH_UNIT/PLANE_ANGLE_MEASURE_WITH_UNIT) |
| CStepRepr_ReprItemAndMeasureWithUnitAndQRI | Base class for complex types (MEASURE_REPRESENTATION_ITEM, MEASURE_WITH_UNIT, QUALIFIED_REPRESENTATION_ITEM REPRESENTATION_ITEM, LENGTH_MEASURE_WITH_UNIT/PLANE_ANGLE_MEASURE_WITH_UNIT) |
| CStepRepr_ReprItemAndPlaneAngleMeasureWithUnit | |
| CStepRepr_ReprItemAndPlaneAngleMeasureWithUnitAndQRI | |
| CStepRepr_ShapeAspect | |
| CStepRepr_ShapeAspectDerivingRelationship | Added for Dimensional Tolerances |
| CStepRepr_ShapeAspectRelationship | Representation of STEP entity ShapeAspectRelationship |
| CStepRepr_ShapeAspectTransition | Representation of STEP entity ShapeAspectTransition |
| CStepRepr_ShapeDefinition | |
| CStepRepr_ShapeRepresentationRelationship | |
| CStepRepr_ShapeRepresentationRelationshipWithTransformation | |
| CStepRepr_SpecifiedHigherUsageOccurrence | Representation of STEP entity SpecifiedHigherUsageOccurrence |
| CStepRepr_StructuralResponseProperty | Representation of STEP entity StructuralResponseProperty |
| CStepRepr_StructuralResponsePropertyDefinitionRepresentation | Representation of STEP entity StructuralResponsePropertyDefinitionRepresentation |
| CStepRepr_SuppliedPartRelationship | |
| CStepRepr_Tangent | Added for Dimensional Tolerances |
| CStepRepr_Transformation | |
| CStepRepr_ValueRange | Added for Dimensional Tolerances |
| CStepRepr_ValueRepresentationItem | |
| CStepSelect_Activator | Performs Actions specific to StepSelect, i.e. creation of Step Selections and Counters, plus dumping specific to Step |
| CStepSelect_FileModifier | |
| CStepSelect_FloatFormat | This class gives control out format for floatting values : ZeroSuppress or no, Main Format, Format in Range (for values around 1.), as StepWriter allows to manage it. Formats are given under C-printf form |
| CStepSelect_ModelModifier | |
| CStepSelect_StepType | StepType is a Signature specific to Step definitions : it considers the type as defined in STEP Schemas, the same which is used in files. For a Complex Type, if its definition is known, StepType produces the list of basic types, separated by commas, the whole between brackets : "(TYPE1,TYPE2..)". If its precise definition is not known (simply it is known as Complex, it can be recognised, but the list is produced at Write time only), StepType produces : "(..COMPLEX TYPE..)" |
| CStepSelect_WorkLibrary | Performs Read and Write a STEP File with a STEP Model Following the protocols, Copy may be implemented or not |
| CSTEPSelections_AssemblyComponent | |
| CSTEPSelections_AssemblyExplorer | |
| CSTEPSelections_AssemblyLink | |
| CSTEPSelections_Counter | |
| CSTEPSelections_SelectAssembly | |
| CSTEPSelections_SelectDerived | |
| CSTEPSelections_SelectFaces | This selection returns "STEP faces" |
| CSTEPSelections_SelectForTransfer | |
| CSTEPSelections_SelectGSCurves | This selection returns "curves in the geometric_set (except composite curves)" |
| CSTEPSelections_SelectInstances | |
| CStepShape_AdvancedBrepShapeRepresentation | |
| CStepShape_AdvancedFace | |
| CStepShape_AngularLocation | Representation of STEP entity AngularLocation |
| CStepShape_AngularSize | Representation of STEP entity AngularSize |
| CStepShape_Block | |
| CStepShape_BooleanOperand | |
| CStepShape_BooleanResult | |
| CStepShape_BoxDomain | |
| CStepShape_BoxedHalfSpace | |
| CStepShape_BrepWithVoids | |
| CStepShape_ClosedShell | |
| CStepShape_CompoundShapeRepresentation | Representation of STEP entity CompoundShapeRepresentation |
| CStepShape_ConnectedEdgeSet | Representation of STEP entity ConnectedEdgeSet |
| CStepShape_ConnectedFaceSet | |
| CStepShape_ConnectedFaceShapeRepresentation | Representation of STEP entity ConnectedFaceShapeRepresentation |
| CStepShape_ConnectedFaceSubSet | Representation of STEP entity ConnectedFaceSubSet |
| CStepShape_ContextDependentShapeRepresentation | |
| CStepShape_CsgPrimitive | |
| CStepShape_CsgSelect | |
| CStepShape_CsgShapeRepresentation | |
| CStepShape_CsgSolid | |
| CStepShape_DefinitionalRepresentationAndShapeRepresentation | Implements complex type (DEFINITIONAL_REPRESENTATION,REPRESENTATION,SHAPE_REPRESENTATION) |
| CStepShape_DimensionalCharacteristic | Representation of STEP SELECT type DimensionalCharacteristic |
| CStepShape_DimensionalCharacteristicRepresentation | Representation of STEP entity DimensionalCharacteristicRepresentation |
| CStepShape_DimensionalLocation | Representation of STEP entity DimensionalLocation |
| CStepShape_DimensionalLocationWithPath | Representation of STEP entity DimensionalLocationWithPath |
| CStepShape_DimensionalSize | Representation of STEP entity DimensionalSize |
| CStepShape_DimensionalSizeWithPath | Representation of STEP entity DimensionalSizeWithPath |
| CStepShape_DirectedDimensionalLocation | Representation of STEP entity DirectedDimensionalLocation |
| CStepShape_Edge | |
| CStepShape_EdgeBasedWireframeModel | Representation of STEP entity EdgeBasedWireframeModel |
| CStepShape_EdgeBasedWireframeShapeRepresentation | Representation of STEP entity EdgeBasedWireframeShapeRepresentation |
| CStepShape_EdgeCurve | |
| CStepShape_EdgeLoop | |
| CStepShape_ExtrudedAreaSolid | |
| CStepShape_ExtrudedFaceSolid | |
| CStepShape_Face | |
| CStepShape_FaceBasedSurfaceModel | Representation of STEP entity FaceBasedSurfaceModel |
| CStepShape_FaceBound | |
| CStepShape_FaceOuterBound | |
| CStepShape_FaceSurface | |
| CStepShape_FacetedBrep | |
| CStepShape_FacetedBrepAndBrepWithVoids | |
| CStepShape_FacetedBrepShapeRepresentation | |
| CStepShape_GeometricallyBoundedSurfaceShapeRepresentation | |
| CStepShape_GeometricallyBoundedWireframeShapeRepresentation | |
| CStepShape_GeometricCurveSet | |
| CStepShape_GeometricSet | |
| CStepShape_GeometricSetSelect | |
| CStepShape_HalfSpaceSolid | |
| CStepShape_LimitsAndFits | Added for Dimensional Tolerances |
| CStepShape_Loop | |
| CStepShape_LoopAndPath | |
| CStepShape_ManifoldSolidBrep | |
| CStepShape_ManifoldSurfaceShapeRepresentation | |
| CStepShape_MeasureQualification | Added for Dimensional Tolerances |
| CStepShape_MeasureRepresentationItemAndQualifiedRepresentationItem | Added for Dimensional Tolerances Complex Type between MeasureRepresentationItem and QualifiedRepresentationItem |
| CStepShape_NonManifoldSurfaceShapeRepresentation | Representation of STEP entity NonManifoldSurfaceShapeRepresentation |
| CStepShape_OpenShell | |
| CStepShape_OrientedClosedShell | |
| CStepShape_OrientedEdge | |
| CStepShape_OrientedFace | |
| CStepShape_OrientedOpenShell | |
| CStepShape_OrientedPath | |
| CStepShape_Path | |
| CStepShape_PlusMinusTolerance | Added for Dimensional Tolerances |
| CStepShape_PointRepresentation | Representation of STEP entity PointRepresentation |
| CStepShape_PolyLoop | |
| CStepShape_PrecisionQualifier | Added for Dimensional Tolerances |
| CStepShape_QualifiedRepresentationItem | Added for Dimensional Tolerances |
| CStepShape_ReversibleTopologyItem | |
| CStepShape_RevolvedAreaSolid | |
| CStepShape_RevolvedFaceSolid | |
| CStepShape_RightAngularWedge | |
| CStepShape_RightCircularCone | |
| CStepShape_RightCircularCylinder | |
| CStepShape_SeamEdge | Representation of STEP entity SeamEdge |
| CStepShape_ShapeDefinitionRepresentation | Representation of STEP entity ShapeDefinitionRepresentation |
| CStepShape_ShapeDimensionRepresentation | Representation of STEP entity ShapeDimensionRepresentation |
| CStepShape_ShapeDimensionRepresentationItem | |
| CStepShape_ShapeRepresentation | |
| CStepShape_ShapeRepresentationWithParameters | Representation of STEP entity ShapeRepresentationWithParameters |
| CStepShape_Shell | |
| CStepShape_ShellBasedSurfaceModel | |
| CStepShape_SolidModel | |
| CStepShape_SolidReplica | |
| CStepShape_Sphere | |
| CStepShape_Subedge | Representation of STEP entity Subedge |
| CStepShape_Subface | Representation of STEP entity Subface |
| CStepShape_SurfaceModel | |
| CStepShape_SweptAreaSolid | |
| CStepShape_SweptFaceSolid | |
| CStepShape_ToleranceMethodDefinition | Added for Dimensional Tolerances |
| CStepShape_ToleranceValue | Added for Dimensional Tolerances |
| CStepShape_TopologicalRepresentationItem | |
| CStepShape_Torus | |
| CStepShape_TransitionalShapeRepresentation | |
| CStepShape_TypeQualifier | Added for Dimensional Tolerances |
| CStepShape_ValueFormatTypeQualifier | Added for Dimensional Tolerances |
| CStepShape_ValueQualifier | Added for Dimensional Tolerances |
| CStepShape_Vertex | |
| CStepShape_VertexLoop | |
| CStepShape_VertexPoint | |
| CStepTidy_DuplicateCleaner | A class to merge STEP entities. This class is used to merge equal STEP entities in the work session and remove duplicates. It uses the child classes of StepTidy_EntityReducer class to perform the merging. The child classes of StepTidy_EntityReducer are specialized for different types of entities. StepTidy_EntityReducer implements the basic logic for searching and merging entities while child classes implement the logic for replacing specific type of entities in the specific type of sharing entities. Classes StepTidy_*Hasher are used to hash the entities and compare them. They define which entities are considered equal to each other. The hashers are used in the StepTidy_EntityReducer class to store the entities in a map. The map is used to find the duplicates and replace them. From this perspective of this module, 'equal' or 'duplicate' entities are those that has equal names and very close numerical values, like for example Cartesian points with coordinates that are equal up to 1e-12 or Vectors with equal orientations and magnitudes up to 1e-12. After the merging this class calls its own method to remove the duplicates. How to use: |
| CStepToGeom | This class provides static methods to convert STEP geometric entities to OCCT. The methods returning handles will return null handle in case of error. The methods returning boolean will return True if succeeded and False if error |
| CStepToTopoDS | This package implements the mapping between AP214 Shape representation and CAS.CAD Shape Representation. The source schema is Part42 (which is included in AP214) |
| CStepToTopoDS_Builder | |
| CStepToTopoDS_GeometricTool | This class contains some algorithmic services specific to the mapping STEP to CAS.CADE |
| CStepToTopoDS_MakeTransformed | Produces instances by Transformation of a basic item |
| CStepToTopoDS_NMTool | Provides data to process non-manifold topology when reading from STEP |
| CStepToTopoDS_PointPair | Stores a pair of Points from step |
| CStepToTopoDS_Root | This class implements the common services for all classes of StepToTopoDS which report error and sets and returns precision |
| CStepToTopoDS_Tool | This Tool Class provides Information to build a Cas.Cad BRep from a ProSTEP Shape model |
| CStepToTopoDS_TranslateCompositeCurve | Translate STEP entity composite_curve to TopoDS_Wire If surface is given, the curve is assumed to lie on that surface and in case if any segment of it is a curve_on_surface, the pcurve for that segment will be taken. Note: a segment of composite_curve may be itself composite_curve. Only one-level protection against cyclic references is implemented |
| CStepToTopoDS_TranslateCurveBoundedSurface | Translate curve_bounded_surface into TopoDS_Face |
| CStepToTopoDS_TranslateEdge | |
| CStepToTopoDS_TranslateEdgeLoop | |
| CStepToTopoDS_TranslateFace | |
| CStepToTopoDS_TranslatePolyLoop | |
| CStepToTopoDS_TranslateShell | |
| CStepToTopoDS_TranslateSolid | |
| CStepToTopoDS_TranslateVertex | |
| CStepToTopoDS_TranslateVertexLoop | |
| CStepVisual_AnnotationCurveOccurrence | |
| CStepVisual_AnnotationCurveOccurrenceAndGeomReprItem | Added for Dimensional Tolerances Complex STEP entity AnnotationCurveOccurrence & AnnotationOccurrence & GeometricRepresentationItem & RepresentationItem & StyledItem |
| CStepVisual_AnnotationFillArea | |
| CStepVisual_AnnotationFillAreaOccurrence | |
| CStepVisual_AnnotationOccurrence | |
| CStepVisual_AnnotationPlane | |
| CStepVisual_AnnotationPlaneElement | |
| CStepVisual_AnnotationText | |
| CStepVisual_AnnotationTextOccurrence | |
| CStepVisual_AreaInSet | |
| CStepVisual_AreaOrView | |
| CStepVisual_BackgroundColour | |
| CStepVisual_BoxCharacteristicSelect | |
| CStepVisual_CameraImage | |
| CStepVisual_CameraImage2dWithScale | |
| CStepVisual_CameraImage3dWithScale | |
| CStepVisual_CameraModel | |
| CStepVisual_CameraModelD2 | |
| CStepVisual_CameraModelD3 | |
| CStepVisual_CameraModelD3MultiClipping | |
| CStepVisual_CameraModelD3MultiClippingInterectionSelect | |
| CStepVisual_CameraModelD3MultiClippingIntersection | |
| CStepVisual_CameraModelD3MultiClippingUnion | |
| CStepVisual_CameraModelD3MultiClippingUnionSelect | |
| CStepVisual_CameraUsage | |
| CStepVisual_CharacterizedObjAndRepresentationAndDraughtingModel | Added for Dimensional Tolerances Complex STEP entity Characterized_Object & Characterized_Representation & Draughting_Model & Representation |
| CStepVisual_Colour | |
| CStepVisual_ColourRgb | |
| CStepVisual_ColourSpecification | |
| CStepVisual_ComplexTriangulatedFace | Representation of STEP entity ComplexTriangulatedFace |
| CStepVisual_ComplexTriangulatedSurfaceSet | Representation of STEP entity ComplexTriangulatedSurfaceSet |
| CStepVisual_CompositeText | |
| CStepVisual_CompositeTextWithExtent | |
| CStepVisual_ContextDependentInvisibility | |
| CStepVisual_ContextDependentOverRidingStyledItem | |
| CStepVisual_CoordinatesList | |
| CStepVisual_CubicBezierTessellatedEdge | Representation of STEP entity CubicBezierTessellatedEdge |
| CStepVisual_CubicBezierTriangulatedFace | Representation of STEP entity CubicBezierTriangulatedFace |
| CStepVisual_CurveStyle | |
| CStepVisual_CurveStyleFont | |
| CStepVisual_CurveStyleFontPattern | |
| CStepVisual_CurveStyleFontSelect | |
| CStepVisual_DirectionCountSelect | |
| CStepVisual_DraughtingAnnotationOccurrence | |
| CStepVisual_DraughtingCallout | |
| CStepVisual_DraughtingCalloutElement | |
| CStepVisual_DraughtingModel | Representation of STEP entity DraughtingModel |
| CStepVisual_DraughtingPreDefinedColour | |
| CStepVisual_DraughtingPreDefinedCurveFont | |
| CStepVisual_EdgeOrCurve | Representation of STEP SELECT type EdgeOrCurve |
| CStepVisual_ExternallyDefinedCurveFont | Representation of STEP entity ExternallyDefinedCurveFont |
| CStepVisual_ExternallyDefinedTextFont | Representation of STEP entity ExternallyDefinedTextFont |
| CStepVisual_FaceOrSurface | Representation of STEP SELECT type FaceOrSurface |
| CStepVisual_FillAreaStyle | |
| CStepVisual_FillAreaStyleColour | |
| CStepVisual_FillStyleSelect | |
| CStepVisual_FontSelect | |
| CStepVisual_Invisibility | |
| CStepVisual_InvisibilityContext | |
| CStepVisual_InvisibleItem | |
| CStepVisual_LayeredItem | |
| CStepVisual_MarkerMember | Defines MarkerType as unique member of MarkerSelect Works with an EnumTool |
| CStepVisual_MarkerSelect | |
| CStepVisual_MechanicalDesignGeometricPresentationArea | |
| CStepVisual_MechanicalDesignGeometricPresentationRepresentation | |
| CStepVisual_NullStyleMember | Defines NullStyle as unique member of PresentationStyleSelect Works with an EnumTool |
| CStepVisual_OverRidingStyledItem | |
| CStepVisual_PathOrCompositeCurve | Representation of STEP SELECT type PathOrCompositeCurve |
| CStepVisual_PlanarBox | |
| CStepVisual_PlanarExtent | |
| CStepVisual_PointStyle | |
| CStepVisual_PreDefinedColour | |
| CStepVisual_PreDefinedCurveFont | |
| CStepVisual_PreDefinedItem | |
| CStepVisual_PreDefinedTextFont | |
| CStepVisual_PresentationArea | |
| CStepVisual_PresentationLayerAssignment | |
| CStepVisual_PresentationLayerUsage | Added from StepVisual Rev2 to Rev4 |
| CStepVisual_PresentationRepresentation | |
| CStepVisual_PresentationRepresentationSelect | |
| CStepVisual_PresentationSet | |
| CStepVisual_PresentationSize | |
| CStepVisual_PresentationSizeAssignmentSelect | |
| CStepVisual_PresentationStyleAssignment | |
| CStepVisual_PresentationStyleByContext | |
| CStepVisual_PresentationStyleSelect | |
| CStepVisual_PresentationView | |
| CStepVisual_PresentedItem | |
| CStepVisual_PresentedItemRepresentation | Added from StepVisual Rev2 to Rev4 |
| CStepVisual_RenderingPropertiesSelect | Representation of STEP SELECT type RenderingPropertiesSelect |
| CStepVisual_RepositionedTessellatedGeometricSet | Representation of complex STEP entity RepositionedTessellatedGeometricSet |
| CStepVisual_RepositionedTessellatedItem | Representation of STEP entity RepositionedTessellatedItem |
| CStepVisual_StyleContextSelect | |
| CStepVisual_StyledItem | |
| CStepVisual_StyledItemTarget | |
| CStepVisual_SurfaceSideStyle | |
| CStepVisual_SurfaceStyleBoundary | |
| CStepVisual_SurfaceStyleControlGrid | |
| CStepVisual_SurfaceStyleElementSelect | |
| CStepVisual_SurfaceStyleFillArea | |
| CStepVisual_SurfaceStyleParameterLine | |
| CStepVisual_SurfaceStyleReflectanceAmbient | Representation of STEP entity SurfaceStyleReflectanceAmbient |
| CStepVisual_SurfaceStyleReflectanceAmbientDiffuse | Representation of STEP entity SurfaceStyleReflectanceAmbientDiffuse |
| CStepVisual_SurfaceStyleReflectanceAmbientDiffuseSpecular | Representation of STEP entity SurfaceStyleReflectanceAmbientDiffuseSpecular |
| CStepVisual_SurfaceStyleRendering | Representation of STEP entity SurfaceStyleRendering |
| CStepVisual_SurfaceStyleRenderingWithProperties | Representation of STEP entity SurfaceStyleRenderingWithProperties |
| CStepVisual_SurfaceStyleSegmentationCurve | |
| CStepVisual_SurfaceStyleSilhouette | |
| CStepVisual_SurfaceStyleTransparent | Representation of STEP entity SurfaceStyleTransparent |
| CStepVisual_SurfaceStyleUsage | |
| CStepVisual_Template | |
| CStepVisual_TemplateInstance | |
| CStepVisual_TessellatedAnnotationOccurrence | |
| CStepVisual_TessellatedConnectingEdge | Representation of STEP entity TessellatedConnectingEdge |
| CStepVisual_TessellatedCurveSet | |
| CStepVisual_TessellatedEdge | Representation of STEP entity TessellatedEdge |
| CStepVisual_TessellatedEdgeOrVertex | Representation of STEP SELECT type TessellatedEdgeOrVertex |
| CStepVisual_TessellatedFace | Representation of STEP entity TessellatedFace |
| CStepVisual_TessellatedGeometricSet | |
| CStepVisual_TessellatedItem | |
| CStepVisual_TessellatedPointSet | Representation of STEP entity TessellatedPointSet |
| CStepVisual_TessellatedShapeRepresentation | Representation of STEP entity TessellatedShapeRepresentation |
| CStepVisual_TessellatedShapeRepresentationWithAccuracyParameters | Representation of STEP entity TessellatedShapeRepresentationWithAccuracyParameters |
| CStepVisual_TessellatedShell | Representation of STEP entity TessellatedShell |
| CStepVisual_TessellatedSolid | Representation of STEP entity TessellatedSolid |
| CStepVisual_TessellatedStructuredItem | Representation of STEP entity TessellatedStructuredItem |
| CStepVisual_TessellatedSurfaceSet | Representation of STEP entity TessellatedSurfaceSet |
| CStepVisual_TessellatedVertex | Representation of STEP entity TessellatedVertex |
| CStepVisual_TessellatedWire | Representation of STEP entity TessellatedWire |
| CStepVisual_TextLiteral | |
| CStepVisual_TextOrCharacter | |
| CStepVisual_TextStyle | |
| CStepVisual_TextStyleForDefinedFont | |
| CStepVisual_TextStyleWithBoxCharacteristics | |
| CStepVisual_TriangulatedFace | Representation of STEP entity TriangulatedFace |
| CStepVisual_TriangulatedSurfaceSet | Representation of STEP entity TriangulatedSurfaceSet |
| CStepVisual_ViewVolume | |
| CStlAPI | Offers the API for STL data manipulation |
| CStlAPI_Reader | Reading from stereolithography format. Reads STL file and creates a shape composed of triangular faces, one per facet. IMPORTANT: This approach is very inefficient, especially for large files. IMPORTANT: Consider reading STL file to Poly_Triangulation object instead (see class RWStl) |
| CStlAPI_Writer | This class creates and writes STL files from Open CASCADE shapes. An STL file can be written to an existing STL file or to a new one |
| CStorage | Storage package is used to write and read persistent objects. These objects are read and written by a retrieval or storage algorithm (Storage_Schema object) in a container (disk, memory, network ...). Drivers (FSD_File objects) assign a physical container for data to be stored or retrieved. The standard procedure for an application in reading a container is the following: |
| CStorage_BaseDriver | Root class for drivers. A driver assigns a physical container to data to be stored or retrieved, for instance a file. The FSD package provides two derived concrete classes : |
| CStorage_Bucket | |
| CStorage_BucketIterator | |
| CStorage_BucketOfPersistent | |
| CStorage_CallBack | |
| CStorage_Data | A picture memorizing the data stored in a container (for example, in a file). A Storage_Data object represents either: |
| CStorage_DefaultCallBack | |
| CStorage_HeaderData | |
| CStorage_InternalData | |
| CStorage_Root | A root object extracted from a Storage_Data object. A Storage_Root encapsulates a persistent object which is a root of a Storage_Data object. It contains additional information: the name and the data type of the persistent object. When retrieving a Storage_Data object from a container (for example, a file) you access its roots with the function Roots which returns a sequence of root objects. The provided functions allow you to request information about each root of the sequence. You do not create explicit roots: when inserting data in a Storage_Data object, you just provide the persistent object and optionally its name to the function AddRoot |
| CStorage_RootData | |
| CStorage_Schema | Root class for basic storage/retrieval algorithms. A Storage_Schema object processes: |
| CStorage_TypeData | |
| CStorage_TypedCallBack | |
| CSWDRAW | Provides DRAW interface to the functionalities of Shape Healing toolkit (SHAPEWORKS Delivery Unit) |
| CSWDRAW_ShapeAnalysis | Contains commands to activate package ShapeAnalysis List of DRAW commands and corresponding functionalities: tolerance - ShapeAnalysis_ShapeTolerance projcurve - ShapeAnalysis_Curve projface - ShapeAnalysis_Surface |
| CSWDRAW_ShapeCustom | Contains commands to activate package ShapeCustom List of DRAW commands and corresponding functionalities: directfaces - ShapeCustom::DirectFaces scaleshape - ShapeCustom::ScaleShape |
| CSWDRAW_ShapeExtend | Contains commands to activate package ShapeExtend List of DRAW commands and corresponding functionalities: sortcompound - ShapeExtend_Explorer::SortedCompound |
| CSWDRAW_ShapeFix | Contains commands to activate package ShapeFix List of DRAW commands and corresponding functionalities: edgesameparam - ShapeFix::SameParameter settolerance - ShapeFix_ShapeTolerance stwire - ShapeFix_Wire reface - ShapeFix_Face repcurve - ShapeFix_PCurves |
| CSWDRAW_ShapeProcess | Contains commands to activate package ShapeProcess |
| CSWDRAW_ShapeProcessAPI | Contains commands to activate package ShapeProcessAPI |
| CSWDRAW_ShapeTool | Defines functions to control shapes (in way useful for XSTEP), additional features which should be basic, or call tools which are bound with transfer needs. But these functions work on shapes, geometry, nothing else (no file, no model, no entity) |
| CSWDRAW_ShapeUpgrade | Contains commands to activate package ShapeUpgrade List of DRAW commands and corresponding functionalities: DT_ShapeDivide - ShapeUpgrade_ShapeDivide DT_PlaneDividedFace - ShapeUpgrade_PlaneDividedFace DT_PlaneGridShell - ShapeUpgrade_PlaneGridShell DT_PlaneFaceCommon - ShapeUpgrade_PlaneFaceCommon DT_Split2dCurve - ShapeUpgrade_Split2dCurve DT_SplitCurve - ShapeUpgrade_SplitCurve DT_SplitSurface - ShapeUpgrade_SplitSurface DT_SupportModification - ShapeUpgrade_DataMapOfShapeSurface DT_Debug - ShapeUpgrade::SetDebug shellsolid - ShapeAnalysis_Shell/ShapeUpgrade_ShellSewing |
| CSweep_NumShape | Gives a simple indexed representation of a Directing Edge topology |
| CSweep_NumShapeIterator | This class provides iteration services required by the Swept Primitives for a Directing NumShape Line |
| CSweep_NumShapeTool | This class provides the indexation and type analysis services required by the NumShape Directing Shapes of Swept Primitives |
| CTCollection | The package <TCollection> provides the services for the transient basic data structures |
| CTCollection_AsciiString | Class defines a variable-length sequence of 8-bit characters. Despite class name (kept for historical reasons), it is intended to store UTF-8 string, not just ASCII characters. However, multi-byte nature of UTF-8 is not considered by the following methods: |
| CTCollection_ExtendedString | A variable-length sequence of "extended" (UNICODE) characters (16-bit character type). It provides editing operations with built-in memory management to make ExtendedString objects easier to use than ordinary extended character arrays. ExtendedString objects follow "value semantics", that is, they are the actual strings, not handles to strings, and are copied through assignment. You may use HExtendedString objects to get handles to strings |
| CTCollection_HAsciiString | A variable-length sequence of ASCII characters (normal 8-bit character type). It provides editing operations with built-in memory management to make HAsciiString objects easier to use than ordinary character arrays. HAsciiString objects are handles to strings |
| CTCollection_HExtendedString | A variable-length sequence of "extended" (UNICODE) characters (16-bit character type). It provides editing operations with built-in memory management to make ExtendedString objects easier to use than ordinary extended character arrays. HExtendedString objects are handles to strings |
| CTColStd_HPackedMapOfInteger | |
| CTDataStd | This package defines standard attributes for modelling. These allow you to create and modify labels and attributes for many basic data types. Standard topological and visualization attributes have also been created. To find an attribute attached to a specific label, you use the GUID of the type of attribute you are looking for. To do this, first find this information using the method GetID as follows: Standard_GUID anID = MyAttributeClass::GetID(); Then, use the method Find for the label as follows: bool HasAttribute = aLabel.Find(anID,anAttribute); Note For information on the relations between this component of OCAF and the others, refer to the OCAF User's Guide |
| CTDataStd_AsciiString | Used to define an AsciiString attribute containing a TCollection_AsciiString |
| CTDataStd_BooleanArray | An array of boolean values |
| CTDataStd_BooleanList | Contains a list of bolleans |
| CTDataStd_ByteArray | An array of Byte (unsigned char) values |
| CTDataStd_ChildNodeIterator | Iterates on the ChildStepren step of a step, at the first level only. It is possible to ask the iterator to explore all the sub step levels of the given one, with the option "allLevels" |
| CTDataStd_Comment | Comment attribute. may be associated to any label to store user comment |
| CTDataStd_Current | This attribute, located at root label, manage an access to a current label |
| CTDataStd_DeltaOnModificationOfByteArray | This class provides default services for an AttributeDelta on a MODIFICATION action |
| CTDataStd_DeltaOnModificationOfExtStringArray | This class provides default services for an AttributeDelta on a MODIFICATION action |
| CTDataStd_DeltaOnModificationOfIntArray | This class provides default services for an AttributeDelta on a MODIFICATION action |
| CTDataStd_DeltaOnModificationOfIntPackedMap | This class provides default services for an AttributeDelta on a MODIFICATION action |
| CTDataStd_DeltaOnModificationOfRealArray | This class provides default services for an AttributeDelta on a MODIFICATION action |
| CTDataStd_Directory | Associates a directory in the data framework with a TDataStd_TagSource attribute. You can create a new directory label and add sub-directory or object labels to it, |
| CTDataStd_Expression | |
| CTDataStd_ExtStringArray | ExtStringArray Attribute. Handles an array of UNICODE strings (represented by the TCollection_ExtendedString class) |
| CTDataStd_ExtStringList | Contains a list of ExtendedString |
| CTDataStd_GenericEmpty | An ancestor attribute for all attributes which have no fields. If an attribute inherits this one it should not have drivers for persistence |
| CTDataStd_GenericExtString | An ancestor attribute for all attributes which have TCollection_ExtendedString field. If an attribute inherits this one it should not have drivers for persistence. Also this attribute provides functionality to have on the same label same attributes with different IDs |
| CTDataStd_HDataMapOfStringByte | Extension of NCollection_DataMap<TCollection_ExtendedString, uint8_t> class to be manipulated by handle |
| CTDataStd_HDataMapOfStringHArray1OfInteger | Extension of NCollection_DataMap<TCollection_ExtendedString, occ::handle<NCollection_HArray1<int>>> class to be manipulated by handle |
| CTDataStd_HDataMapOfStringHArray1OfReal | Extension of NCollection_DataMap<TCollection_ExtendedString, occ::handle<NCollection_HArray1<double>>> class to be manipulated by handle |
| CTDataStd_HDataMapOfStringInteger | Extension of NCollection_DataMap<TCollection_ExtendedString, int> class to be manipulated by handle |
| CTDataStd_HDataMapOfStringReal | Extension of NCollection_DataMap<TCollection_ExtendedString, double> class to be manipulated by handle |
| CTDataStd_HDataMapOfStringString | Extension of NCollection_DataMap<TCollection_ExtendedString, TCollection_ExtendedString> class to be manipulated by handle |
| CTDataStd_Integer | The basis to define an integer attribute |
| CTDataStd_IntegerArray | Contains an array of integers |
| CTDataStd_IntegerList | Contains a list of integers |
| CTDataStd_IntPackedMap | Attribute for storing TColStd_PackedMapOfInteger |
| CTDataStd_Name | Used to define a name attribute containing a string which specifies the name |
| CTDataStd_NamedData | Contains a named data |
| CTDataStd_NoteBook | NoteBook Object attribute |
| CTDataStd_Real | The basis to define a real number attribute |
| CTDataStd_RealArray | A framework for an attribute composed of a real number array |
| CTDataStd_RealList | Contains a list of doubles |
| CTDataStd_ReferenceArray | Contains an array of references to the labels |
| CTDataStd_ReferenceList | Contains a list of references |
| CTDataStd_Relation | |
| CTDataStd_Tick | Defines a boolean attribute. If it exists at a label - true, Otherwise - false |
| CTDataStd_TreeNode | Allows you to define an explicit tree of labels which you can also edit. Without this class, the data structure cannot be fully edited. This service is required if for presentation purposes, you want to create an application with a tree which allows you to organize and link data as a function of application features |
| CTDataStd_UAttribute | |
| CTDataStd_Variable | |
| CTDataXtd | This package defines extension of standard attributes for modelling (mainly for work with geometry) |
| CTDataXtd_Axis | The basis to define an axis attribute |
| CTDataXtd_Constraint | The groundwork to define constraint attributes. The constraint attribute contains the following sorts of data: |
| CTDataXtd_Geometry | This class is used to model construction geometry. The specific geometric construction of the attribute is defined by an element of the enumeration TDataXtd_GeometryEnum. This attribute may also be used to qualify underlying geometry of the associated NamedShape. for Constructuion element by example |
| CTDataXtd_Pattern | General pattern model |
| CTDataXtd_PatternStd | To create a PatternStd (LinearPattern, CircularPattern, RectangularPattern, RadialCircularPattern, MirrorPattern) |
| CTDataXtd_Placement | |
| CTDataXtd_Plane | The basis to define a plane attribute. Warning: Use TDataXtd_Geometry attribute to retrieve the gp_Pln of the Plane attribute |
| CTDataXtd_Point | The basis to define a point attribute. The topological attribute must contain a vertex. You use this class to create reference points in a design |
| CTDataXtd_Position | Position of a Label |
| CTDataXtd_Presentation | Attribute containing parameters of presentation of the shape, e.g. the shape attached to the same label and displayed using TPrsStd tools (see TPrsStd_AISPresentation) |
| CTDataXtd_Shape | A Shape is associated in the framework with : a NamedShape attribute |
| CTDataXtd_Triangulation | An Ocaf attribute containing a mesh (Poly_Triangulation). It duplicates all methods from Poly_Triangulation. It is highly recommended to modify the mesh through the methods of this attribute, but not directly via the underlying Poly_Triangulation object. In this case Undo/Redo will work fine and robust |
| CTDF | This package provides data framework for binding features and data structures |
| CTDF_Attribute | A class each application has to implement. It is used to contain the application data. This abstract class, alongwith Label, is one of the cornerstones of Model Editor. The groundwork is to define the root of information. This information is to be attached to a Label, and could be of any of the following types: |
| CTDF_AttributeDelta | This class describes the services we need to implement Delta and Undo/Redo services |
| CTDF_AttributeIterator | |
| CTDF_ChildIDIterator | Iterates on the children of a label, to find attributes having ID as Attribute ID |
| CTDF_ChildIterator | Iterates on the children of a label, at the first level only. It is possible to ask the iterator to explore all the sub label levels of the given one, with the option "allLevels" |
| CTDF_ClosureMode | This class provides options closure management |
| CTDF_ClosureTool | This class provides services to build the closure of an information set. This class gives services around the transitive enclosure of a set of information, starting from a list of label. You can set closure options by using IDFilter (to select or exclude specific attribute IDs) and CopyOption objects and by giving to Closure method |
| CTDF_ComparisonTool | This class provides services to compare sets of information. The use of this tool can works after a copy, acted by a CopyTool |
| CTDF_CopyLabel | This class gives copy of source label hierarchy |
| CTDF_CopyTool | This class provides services to build, copy or paste a set of information |
| CTDF_Data | This class is used to manipulate a complete independent, self sufficient data structure and its services: |
| CTDF_DataSet | This class is a set of TDF information like labels and attributes |
| CTDF_DefaultDeltaOnModification | This class provides a default implementation of a TDF_DeltaOnModification |
| CTDF_DefaultDeltaOnRemoval | This class provides a default implementation of a TDF_DeltaOnRemoval |
| CTDF_Delta | A set of AttributeDelta for a given transaction number and reference time number. A delta set is available at <aSourceTime>. If applied, it restores the TDF_Data in the state it was at <aTargetTime> |
| CTDF_DeltaOnAddition | This class provides default services for an AttributeDelta on an ADDITION action |
| CTDF_DeltaOnForget | This class provides default services for an AttributeDelta on an Forget action |
| CTDF_DeltaOnModification | This class provides default services for an AttributeDelta on a MODIFICATION action |
| CTDF_DeltaOnRemoval | This class provides default services for an AttributeDelta on a REMOVAL action |
| CTDF_DeltaOnResume | This class provides default services for an AttributeDelta on an Resume action |
| CTDF_DerivedAttribute | Class provides global access (through static methods) to all derived attributes information. It is used internally by macros for registration of derived attributes and driver-tables for getting this data |
| CTDF_IDFilter | This class offers filtering services around an ID list |
| CTDF_Label | This class provides basic operations to define a label in a data structure. A label is a feature in the feature hierarchy. A label is always connected to a Data from TDF. To a label is attached attributes containing the software components information |
| CTDF_LabelNode | |
| CTDF_Reference | This attribute is used to store in the framework a reference to an other label |
| CTDF_RelocationTable | This is a relocation dictionary between source and target labels, attributes or any transient(useful for copy or paste actions). Note that one target value may be the relocation value of more than one source object |
| CTDF_TagSource | This attribute manage a tag provider to create child labels of a given one |
| CTDF_Tool | This class provides general services for a data framework |
| CTDF_Transaction | This class offers services to open, commit or abort a transaction in a more secure way than using Data from TDF. If you forget to close a transaction, it will be automatically aborted at the destruction of this object, at the closure of its scope |
| CTDocStd | This package define CAF main classes |
| CTDocStd_Application | The abstract root class for all application classes. They are in charge of: |
| CTDocStd_ApplicationDelta | |
| CTDocStd_CompoundDelta | A delta set is available at <aSourceTime>. If applied, it restores the TDF_Data in the state it was at <aTargetTime> |
| CTDocStd_Context | |
| CTDocStd_Document | The contents of a TDocStd_Application, a document is a container for a data framework composed of labels and attributes. As such, TDocStd_Document is the entry point into the data framework. To gain access to the data, you create a document as follows: occ::handle<TDocStd_Document> MyDF = new TDocStd_Document The document also allows you to manage: |
| CTDocStd_Modified | Transient attribute which register modified labels. This attribute is attached to root label |
| CTDocStd_MultiTransactionManager | Class for synchronization of transactions within multiple documents. Each transaction of this class involvess one transaction in each modified document |
| CTDocStd_Owner | This attribute located at the root label of the framework contains a back reference to the owner TDocStd_Document, providing access to the document from any label. private class Owner; |
| CTDocStd_PathParser | Parse an OS path |
| CTDocStd_XLink | An attribute to store the path and the entry of external links. These refer from one data structure to a data structure in another document |
| CTDocStd_XLinkIterator | Iterates on Reference attributes. This is an iterator giving all the external references of a Document |
| CTDocStd_XLinkRoot | This attribute is the root of all external references contained in a Data from TDF. Only one instance of this class is added to the TDF_Data root label. Starting from this attribute all the Reference are linked together, to be found easily |
| CTDocStd_XLinkTool | This tool class is used to copy the content of source label under target label. Only child labels and attributes of source are copied. attributes located out of source scope are not copied by this algorithm. Depending of the called method an external reference is set in the target document to registered the externallink. Provide services to set, update and perform external references. Warning1: Nothing is provided in this class about the opportunity to copy, set a link or update it. Such decisions must be under application control. Warning2: If the document manages shapes, use after copy TNaming::ChangeShapes(target,M) to make copy of shapes |
| CTFunction_Driver | This driver class provide services around function execution. One instance of this class is built for the whole session. The driver is bound to the DriverGUID in the DriverTable class. It allows you to create classes which inherit from this abstract class. These subclasses identify the various algorithms which can be applied to the data contained in the attributes of sub-labels of a model. A single instance of this class and each of its subclasses is built for the whole session |
| CTFunction_DriverTable | A container for instances of drivers. You create a new instance of TFunction_Driver and use the method AddDriver to load it into the driver table |
| CTFunction_Function | Provides the following two services |
| CTFunction_GraphNode | Provides links between functions |
| CTFunction_IFunction | Interface class for usage of Function Mechanism |
| CTFunction_Iterator | Iterator of the graph of functions |
| CTFunction_Logbook | This class contains information which is written and read during the solving process. Information is divided in three groups |
| CTFunction_Scope | Keeps a scope of functions |
| CTNaming | A topological attribute can be seen as a hook into the topological structure. To this hook, data can be attached and references defined. It is used for keeping and access to topological objects and their evolution. All topological objects are stored in the one user-protected TNaming_UsedShapes attribute at the root label of the data framework. This attribute contains map with all topological shapes, used in this document. To all other labels TNaming_NamedShape attribute can be added. This attribute contains references (hooks) to shapes from the TNaming_UsedShapes attribute and evolution of these shapes. TNaming_NamedShape attribute contains a set of pairs of hooks: old shape and new shape (see the figure below). It allows not only get the topological shapes by the labels, but also trace evolution of the shapes and correctly resolve dependent shapes by the changed one. If shape is just-created, then the old shape for accorded named shape is an empty shape. If a shape is deleted, then the new shape in this named shape is empty. Different algorithms may dispose sub-shapes of the result shape at the individual label depending on necessity: |
| CTNaming_Builder | A tool to create and maintain topological attributes. Constructor creates an empty TNaming_NamedShape attribute at the given label. It allows adding "old shape" and "new
shape" pairs with the specified evolution to this named shape. One evolution type per one builder must be used |
| CTNaming_CopyShape | |
| CTNaming_DeltaOnModification | This class provides default services for an AttributeDelta on a MODIFICATION action |
| CTNaming_DeltaOnRemoval | |
| CTNaming_Identifier | |
| CTNaming_Iterator | A tool to visit the contents of a named shape attribute. Pairs of shapes in the attribute are iterated, one being the pre-modification or the old shape, and the other the post-modification or the new shape. This allows you to have a full access to all contents of an attribute. If, on the other hand, you are only interested in topological entities stored in the attribute, you can use the functions GetShape and CurrentShape in TNaming_Tool |
| CTNaming_IteratorOnShapesSet | |
| CTNaming_Localizer | |
| CTNaming_Name | Store the arguments of Naming |
| CTNaming_NamedShape | The basis to define an attribute for the storage of topology and naming data. This attribute contains two parts: |
| CTNaming_Naming | This attribute store the topological naming of any selected shape, when this shape is not already attached to a specific label. This class is also used to solve it when the arguments of the topological naming are modified |
| CTNaming_NamingTool | |
| CTNaming_NewShapeIterator | Iterates on all the descendants of a shape |
| CTNaming_OldShapeIterator | Iterates on all the ascendants of a shape |
| CTNaming_RefShape | |
| CTNaming_SameShapeIterator | To iterate on all the label which contained a given shape |
| CTNaming_Scope | |
| CTNaming_Selector | This class provides a single API for selection of shapes. This involves both identification and selection of shapes in the data framework. If the selected shape is modified, this selector will solve its identifications. This class is the user interface for topological naming resources |
| CTNaming_ShapesSet | |
| CTNaming_Tool | A tool to get information on the topology of a named shape attribute. This information is typically a TopoDS_Shape object. Using this tool, relations between named shapes are also accessible |
| CTNaming_TranslateTool | Tool to copy underlying TShape of a Shape. The TranslateTool class is provided to support the translation of topological data structures Transient to Transient |
| CTNaming_Translator | Only for Shape Copy test - to move in DNaming |
| CTNaming_UsedShapes | Global attribute located under root label to store all the shapes handled by the framework Set of Shapes Used in a Data from TDF Only one instance by Data, it always Stored as Attribute of The Root |
| CTObj_Application | This is a base class for OCAF based TObj models with declared virtual methods |
| CTObj_Assistant | This class provides interface to the static data to be used during save or load models |
| CTObj_CheckModel | |
| CTObj_HiddenPartition | |
| CTObj_LabelIterator | |
| CTObj_Model | |
| CTObj_ModelIterator | |
| CTObj_Object | Basis class for transient objects in OCAF-based models |
| CTObj_ObjectIterator | |
| CTObj_OcafObjectIterator | |
| CTObj_Partition | |
| CTObj_Persistence | |
| CTObj_ReferenceIterator | |
| CTObj_SequenceIterator | |
| CTObj_TIntSparseArray | |
| CTObj_TModel | |
| CTObj_TNameContainer | |
| CTObj_TObject | |
| CTObj_TReference | |
| CTObj_TXYZ | |
| CTObjDRAW | Provides DRAW commands for work with TObj data structures |
| CTopAbs | This package gives resources for Topology oriented applications such as: Topological Data Structure, Topological Algorithms |
| CTopBas_TestInterference | |
| CTopCnx_EdgeFaceTransition | TheEdgeFaceTransition is an algorithm to compute the cumulated transition for interferences on an edge |
| CTopExp | This package provides basic tools to explore the topological data structures |
| CTopExp_Explorer | An Explorer is a Tool to visit a Topological Data Structure from the TopoDS package |
| CTopLoc_Datum3D | Describes a coordinate transformation, i.e. a change to an elementary 3D coordinate system, or position in 3D space. A Datum3D is always described relative to the default datum. The default datum is described relative to itself: its origin is (0,0,0), and its axes are (1,0,0) (0,1,0) (0,0,1) |
| CTopLoc_ItemLocation | An ItemLocation is an elementary coordinate system in a Location |
| CTopLoc_Location | A Location is a composite transition. It comprises a series of elementary reference coordinates, i.e. objects of type TopLoc_Datum3D, and the powers to which these objects are raised |
| CTopLoc_SListNodeOfItemLocation | |
| CTopLoc_SListOfItemLocation | An SListOfItemLocation is a LISP like list of Items. An SListOfItemLocation is: . Empty. . Or it has a Value and a Tail which is an other SListOfItemLocation |
| CTopoDS_AlertAttribute | Alert attribute object storing TopoDS shape in its field |
| CTopoDS_AlertWithShape | Alert object storing TopoDS shape in its field |
| CTopoDS_Builder | A Builder is used to create Topological Data Structures. It is the root of the Builder class hierarchy |
| CTopoDS_Compound | Describes a compound which |
| CTopoDS_CompSolid | Describes a composite solid which |
| CTopoDS_Edge | Describes an edge which |
| CTopoDS_Face | Describes a face which |
| CTopoDS_HShape | Class to manipulate a Shape with handle |
| CTopoDS_Iterator | Iterates on the underlying shape underlying a given TopoDS_Shape object, providing access to its component sub-shapes. Each component shape is returned as a TopoDS_Shape with an orientation, and a compound of the original values and the relative values |
| CTopoDS_Shape | Describes a shape which |
| CTopoDS_Shell | Describes a shell which |
| CTopoDS_Solid | Describes a solid shape which |
| CTopoDS_TCompound | A TCompound is an all-purpose set of Shapes |
| CTopoDS_TCompSolid | A set of solids connected by their faces |
| CTopoDS_TEdge | A topological part of a curve in 2D or 3D, the boundary is a set of oriented Vertices |
| CTopoDS_TFace | A topological part of a surface or of the 2D space. The boundary is a set of wires and vertices |
| CTopoDS_TShape | A TShape is a topological structure describing a set of points in a 2D or 3D space |
| CTopoDS_TShell | A set of faces connected by their edges |
| CTopoDS_TSolid | A Topological part of 3D space, bounded by shells, edges and vertices |
| CTopoDS_TVertex | A Vertex is a topological point in two or three dimensions. TVertex has no children (sub-shapes) |
| CTopoDS_TWire | A set of edges connected by their vertices |
| CTopoDS_Vertex | Describes a vertex which |
| CTopoDS_Wire | Describes a wire which |
| CTopoDSToStep | This package implements the mapping between CAS.CAD Shape representation and AP214 Shape Representation. The target schema is pms_c4 (a subset of AP214) |
| CTopoDSToStep_Builder | This builder Class provides services to build a ProSTEP Shape model from a Cas.Cad BRep |
| CTopoDSToStep_FacetedTool | This Tool Class provides Information about Faceted Shapes to be mapped to STEP |
| CTopoDSToStep_MakeBrepWithVoids | This class implements the mapping between classes Solid from TopoDS and BrepWithVoids from StepShape. All the topology and geometry comprised into the shell or the solid are taken into account and translated |
| CTopoDSToStep_MakeFacetedBrep | This class implements the mapping between classes Shell or Solid from TopoDS and FacetedBrep from StepShape. All the topology and geometry comprised into the shell or the solid are taken into account and translated |
| CTopoDSToStep_MakeFacetedBrepAndBrepWithVoids | This class implements the mapping between classes Solid from TopoDS and FacetedBrepAndBrepWithVoids from StepShape. All the topology and geometry comprised into the shell or the solid are taken into account and translated |
| CTopoDSToStep_MakeGeometricCurveSet | This class implements the mapping between a Shape from TopoDS and a GeometricCurveSet from StepShape in order to create a GeometricallyBoundedWireframeRepresentation |
| CTopoDSToStep_MakeManifoldSolidBrep | This class implements the mapping between classes Shell or Solid from TopoDS and ManifoldSolidBrep from StepShape. All the topology and geometry comprised into the shell or the solid are taken into account and translated |
| CTopoDSToStep_MakeShellBasedSurfaceModel | This class implements the mapping between classes Face, Shell or Solid from TopoDS and ShellBasedSurfaceModel from StepShape. All the topology and geometry comprised into the shape are taken into account and translated |
| CTopoDSToStep_MakeStepEdge | This class implements the mapping between classes Edge from TopoDS and TopologicalRepresentationItem from StepShape |
| CTopoDSToStep_MakeStepFace | This class implements the mapping between classes Face from TopoDS and TopologicalRepresentationItem from StepShape |
| CTopoDSToStep_MakeStepVertex | This class implements the mapping between classes Vertex from TopoDS and TopologicalRepresentationItem from StepShape |
| CTopoDSToStep_MakeStepWire | This class implements the mapping between classes Wire from TopoDS and TopologicalRepresentationItem from StepShape |
| CTopoDSToStep_MakeTessellatedItem | This class implements the mapping between Face, Shell fromTopoDS and TriangulatedFace from StepVisual |
| CTopoDSToStep_Root | This class implements the common services for all classes of TopoDSToStep which report error |
| CTopoDSToStep_Tool | This Tool Class provides Information to build a ProSTEP Shape model from a Cas.Cad BRep |
| CTopoDSToStep_WireframeBuilder | This builder Class provides services to build a ProSTEP Wireframemodel from a Cas.Cad BRep |
| CTopOpeBRep | This package provides the topological operations on the BRep data structure |
| CTopOpeBRep_Bipoint | |
| CTopOpeBRep_DSFiller | Provides class methods to fill a datastructure with results of intersections |
| CTopOpeBRep_EdgesFiller | Fills a TopOpeBRepDS_DataStructure with Edge/Edge intersection data described by TopOpeBRep_EdgesIntersector |
| CTopOpeBRep_EdgesIntersector | Describes the intersection of two edges on the same surface |
| CTopOpeBRep_FaceEdgeFiller | |
| CTopOpeBRep_FaceEdgeIntersector | Describes the intersection of a face and an edge |
| CTopOpeBRep_FacesFiller | Fills a DataStructure from TopOpeBRepDS with the result of Face/Face intersection described by FacesIntersector from TopOpeBRep. if the faces have same Domain, record it in the DS. else record lines and points and attach list of interferences to the faces, the lines and the edges |
| CTopOpeBRep_FacesIntersector | Describes the intersection of two faces |
| CTopOpeBRep_FFDumper | |
| CTopOpeBRep_FFTransitionTool | |
| CTopOpeBRep_GeomTool | Provide services needed by the DSFiller |
| CTopOpeBRep_Hctxee2d | |
| CTopOpeBRep_Hctxff2d | |
| CTopOpeBRep_LineInter | |
| CTopOpeBRep_Point2d | |
| CTopOpeBRep_PointClassifier | |
| CTopOpeBRep_PointGeomTool | Provide services needed by the Fillers |
| CTopOpeBRep_ShapeIntersector | Intersect two shapes |
| CTopOpeBRep_ShapeIntersector2d | Intersect two shapes |
| CTopOpeBRep_ShapeScanner | Find, among the subshapes SS of a reference shape RS, the ones which 3D box interferes with the box of a shape S (SS and S are of the same type) |
| CTopOpeBRep_VPointInter | |
| CTopOpeBRep_VPointInterClassifier | |
| CTopOpeBRep_VPointInterIterator | |
| CTopOpeBRep_WPointInter | |
| CTopOpeBRep_WPointInterIterator | |
| CTopOpeBRepBuild_Area1dBuilder | |
| CTopOpeBRepBuild_Area2dBuilder | The Area2dBuilder algorithm is used to construct Faces from a LoopSet, where the Loop is the composite topological object of the boundary, here wire or block of edges. The LoopSet gives an iteration on Loops. For each Loop it indicates if it is on the boundary (wire) or if it results from an interference (block of edges). The result of the Area2dBuilder is an iteration on areas. An area is described by a set of Loops |
| CTopOpeBRepBuild_Area3dBuilder | The Area3dBuilder algorithm is used to construct Solids from a LoopSet, where the Loop is the composite topological object of the boundary, here wire or block of edges. The LoopSet gives an iteration on Loops. For each Loop it indicates if it is on the boundary (wire) or if it results from an interference (block of edges). The result of the Area3dBuilder is an iteration on areas. An area is described by a set of Loops |
| CTopOpeBRepBuild_AreaBuilder | The AreaBuilder algorithm is used to reconstruct complex topological objects as Faces or Solids |
| CTopOpeBRepBuild_BlockBuilder | |
| CTopOpeBRepBuild_BlockIterator | Iterator on the elements of a block |
| CTopOpeBRepBuild_Builder | The Builder algorithm constructs topological objects from an existing topology and new geometries attached to the topology. It is used to construct the result of a topological operation; the existing topologies are the parts involved in the topological operation and the new geometries are the intersection lines and points |
| CTopOpeBRepBuild_Builder1 | Extension of the class TopOpeBRepBuild_Builder dedicated to avoid bugs in "Rebuilding Result" algorithm for the case of SOLID/SOLID Boolean Operations |
| CTopOpeBRepBuild_BuilderON | |
| CTopOpeBRepBuild_CompositeClassifier | Classify composite Loops, i.e, loops that can be either a Shape, or a block of Elements |
| CTopOpeBRepBuild_CorrectFace2d | |
| CTopOpeBRepBuild_EdgeBuilder | |
| CTopOpeBRepBuild_FaceAreaBuilder | The FaceAreaBuilder algorithm is used to construct Faces from a LoopSet, where the Loop is the composite topological object of the boundary, here wire or block of edges. The LoopSet gives an iteration on Loops. For each Loop it indicates if it is on the boundary (wire) or if it results from an interference (block of edges). The result of the FaceAreaBuilder is an iteration on areas. An area is described by a set of Loops |
| CTopOpeBRepBuild_FaceBuilder | |
| CTopOpeBRepBuild_FuseFace | |
| CTopOpeBRepBuild_GIter | |
| CTopOpeBRepBuild_GTool | |
| CTopOpeBRepBuild_GTopo | |
| CTopOpeBRepBuild_HBuilder | The HBuilder algorithm constructs topological objects from an existing topology and new geometries attached to the topology. It is used to construct the result of a topological operation; the existing topologies are the parts involved in the topological operation and the new geometries are the intersection lines and points |
| CTopOpeBRepBuild_Loop | Loop is an existing shape (Shell,Wire) or a set of shapes (Faces,Edges) which are connex. a set of connex shape is represented by a BlockIterator |
| CTopOpeBRepBuild_LoopClassifier | Classify loops in order to build Areas |
| CTopOpeBRepBuild_LoopSet | |
| CTopOpeBRepBuild_Pave | |
| CTopOpeBRepBuild_PaveClassifier | This class compares vertices on an edge |
| CTopOpeBRepBuild_PaveSet | Class providing an exploration of a set of vertices to build edges. It is similar to LoopSet from TopOpeBRepBuild where Loop is Pave |
| CTopOpeBRepBuild_ShapeListOfShape | Represent shape + a list of shape |
| CTopOpeBRepBuild_ShapeSet | Auxiliary class providing an exploration of a set of shapes to build faces or solids. To build faces : shapes are wires, elements are edges. To build solids : shapes are shells, elements are faces. The ShapeSet stores a list of shapes, a list of elements to start reconstructions, and a map to search neighbours. The map stores the connection between elements through subshapes of type <SubShapeType> given in constructor. <SubShapeType> is: |
| CTopOpeBRepBuild_ShellFaceClassifier | Classify faces and shells. shapes are Shells, Elements are Faces |
| CTopOpeBRepBuild_ShellFaceSet | Bound is a shell, a boundelement is a face. The ShapeSet stores : |
| CTopOpeBRepBuild_ShellToSolid | This class builds solids from a set of shells SSh and a solid F |
| CTopOpeBRepBuild_SolidAreaBuilder | The SolidAreaBuilder algorithm is used to construct Solids from a LoopSet, where the Loop is the composite topological object of the boundary, here wire or block of edges. The LoopSet gives an iteration on Loops. For each Loop it indicates if it is on the boundary (wire) or if it results from an interference (block of edges). The result of the SolidAreaBuilder is an iteration on areas. An area is described by a set of Loops |
| CTopOpeBRepBuild_SolidBuilder | |
| CTopOpeBRepBuild_Tools | Auxiliary methods used in TopOpeBRepBuild_Builder1 class |
| CTopOpeBRepBuild_Tools2d | |
| CTopOpeBRepBuild_VertexInfo | |
| CTopOpeBRepBuild_WireEdgeClassifier | Classify edges and wires. shapes are Wires, Element are Edge |
| CTopOpeBRepBuild_WireEdgeSet | Bound is a wire, a boundelement is an edge. The ShapeSet stores : |
| CTopOpeBRepBuild_WireToFace | This class builds faces from a set of wires SW and a face F. The face must have and underlying surface, say S. All of the edges of all of the wires must have a 2d representation on surface S (except if S is planar) |
| CTopOpeBRepDS | This package provides services used by the TopOpeBRepBuild package performing topological operations on the BRep data structure |
| CTopOpeBRepDS_Association | |
| CTopOpeBRepDS_BuildTool | Provides a Tool to build topologies. Used to instantiate the Builder algorithm |
| CTopOpeBRepDS_Check | Tool verifying integrity and structure of DS |
| CTopOpeBRepDS_Curve | A Geom curve and a tolerance |
| CTopOpeBRepDS_CurveData | |
| CTopOpeBRepDS_CurveExplorer | |
| CTopOpeBRepDS_CurveIterator | |
| CTopOpeBRepDS_CurvePointInterference | An interference with a parameter |
| CTopOpeBRepDS_DataStructure | The DataStructure stores : |
| CTopOpeBRepDS_Dumper | |
| CTopOpeBRepDS_Edge3dInterferenceTool | Tool computing edge / face complex transition, Interferences of edge reference are given by I = (T on face, G = point or vertex, S = edge) |
| CTopOpeBRepDS_EdgeInterferenceTool | Tool computing complex transition on Edge |
| CTopOpeBRepDS_EdgeVertexInterference | An interference with a parameter (ShapeShapeInterference) |
| CTopOpeBRepDS_EIR | EdgeInterferenceReducer |
| CTopOpeBRepDS_Explorer | |
| CTopOpeBRepDS_FaceEdgeInterference | ShapeShapeInterference |
| CTopOpeBRepDS_FaceInterferenceTool | Tool computing complex transition on Face |
| CTopOpeBRepDS_Filter | |
| CTopOpeBRepDS_FIR | FaceInterferenceReducer |
| CTopOpeBRepDS_GapFiller | |
| CTopOpeBRepDS_GapTool | |
| CTopOpeBRepDS_GeometryData | Mother-class of SurfaceData, CurveData, PointData |
| CTopOpeBRepDS_HDataStructure | |
| CTopOpeBRepDS_Interference | An interference is the description of the attachment of a new geometry on a geometry. For example an intersection point on an Edge or on a Curve |
| CTopOpeBRepDS_InterferenceIterator | Iterate on interferences of a list, matching conditions on interferences. Nota: inheritance of ListIteratorOfListOfInterference from TopOpeBRepDS has not been done because of the impossibility of naming the classical More, Next methods which are declared as static in TCollection_ListIteratorOfList ... . ListIteratorOfList has benn placed as a field of InterferenceIterator |
| CTopOpeBRepDS_InterferenceTool | |
| CTopOpeBRepDS_ListOfShapeOn1State | Represent a list of shape |
| CTopOpeBRepDS_Marker | |
| CTopOpeBRepDS_Point | A Geom point and a tolerance |
| CTopOpeBRepDS_PointData | |
| CTopOpeBRepDS_PointExplorer | |
| CTopOpeBRepDS_PointIterator | |
| CTopOpeBRepDS_Reducer | Reduce interferences of a data structure (HDS) used in topological operations |
| CTopOpeBRepDS_ShapeData | |
| CTopOpeBRepDS_ShapeShapeInterference | Interference |
| CTopOpeBRepDS_ShapeWithState | |
| CTopOpeBRepDS_SolidSurfaceInterference | Interference |
| CTopOpeBRepDS_Surface | A Geom surface and a tolerance |
| CTopOpeBRepDS_SurfaceCurveInterference | Interference with a 2d curve |
| CTopOpeBRepDS_SurfaceData | |
| CTopOpeBRepDS_SurfaceExplorer | |
| CTopOpeBRepDS_SurfaceIterator | |
| CTopOpeBRepDS_TKI | |
| CTopOpeBRepDS_TOOL | |
| CTopOpeBRepDS_Transition | |
| CTopOpeBRepTool | This package provides services used by the TopOpeBRep package performing topological operations on the BRep data structure |
| CTopOpeBRepTool_AncestorsTool | Describes the ancestors tool needed by the class DSFiller from TopOpeInter |
| CTopOpeBRepTool_BoxSort | |
| CTopOpeBRepTool_C2DF | |
| CTopOpeBRepTool_CLASSI | |
| CTopOpeBRepTool_connexity | |
| CTopOpeBRepTool_CORRISO | Fref is built on x-periodic surface (x=u,v). S built on Fref's geometry, should be UVClosed |
| CTopOpeBRepTool_CurveTool | |
| CTopOpeBRepTool_face | |
| CTopOpeBRepTool_FuseEdges | This class can detect vertices in a face that can be considered useless and then perform the fuse of the edges and remove the useless vertices. By useles vertices, we mean: |
| CTopOpeBRepTool_GeomTool | |
| CTopOpeBRepTool_HBoxTool | |
| CTopOpeBRepTool_makeTransition | |
| CTopOpeBRepTool_mkTondgE | |
| CTopOpeBRepTool_PurgeInternalEdges | Remove from a shape, the internal edges that are not connected to any face in the shape. We can get the list of the edges as a DataMapOfShapeListOfShape with a Face of the Shape as the key and a list of internal edges as the value. The list of internal edges means edges that are not connected to any face in the shape |
| CTopOpeBRepTool_REGUS | |
| CTopOpeBRepTool_REGUW | |
| CTopOpeBRepTool_ShapeClassifier | |
| CTopOpeBRepTool_ShapeExplorer | Extends TopExp_Explorer by counting index of current item (for tracing and debug) |
| CTopOpeBRepTool_ShapeTool | |
| CTopOpeBRepTool_SolidClassifier | |
| CTopOpeBRepTool_TOOL | |
| CTopTools | The TopTools package provides utilities for the topological data structure |
| CTopTools_LocationSet | The class LocationSet stores a set of location in a relocatable state |
| CTopTools_ShapeMapHasher | Hash tool, used for generating maps of shapes in topology |
| CTopTools_ShapeSet | A ShapeSets contains a Shape and all its sub-shapes and locations. It can be dump, write and read |
| CTopTrans_CurveTransition | This algorithm is used to compute the transition of a Curve intersecting a curvilinear boundary |
| CTopTrans_SurfaceTransition | This algorithm is used to compute the transition of a 3D surface intersecting a topological surfacic boundary on a 3D curve ( intersection curve ). The boundary is described by a set of faces each face is described by |
| CTPrsStd_AISPresentation | An attribute to associate an AIS_InteractiveObject to a label in an AIS viewer. This attribute works in collaboration with TPrsStd_AISViewer. Note that all the Set... and Unset... attribute methods as well as the query methods for visualization attributes and the HasOwn... test methods are shortcuts to the respective AIS_InteractiveObject settings |
| CTPrsStd_AISViewer | The groundwork to define an interactive viewer attribute. This attribute stores an interactive context at the root label. You can only have one instance of this class per data framework |
| CTPrsStd_AxisDriver | An implementation of TPrsStd_Driver for axes |
| CTPrsStd_ConstraintDriver | An implementation of TPrsStd_Driver for constraints |
| CTPrsStd_ConstraintTools | |
| CTPrsStd_Driver | |
| CTPrsStd_DriverTable | This class is a container to record (AddDriver) binding between GUID and TPrsStd_Driver. You create a new instance of TPrsStd_Driver and use the method AddDriver to load it into the driver table |
| CTPrsStd_GeometryDriver | This method is an implementation of TPrsStd_Driver for geometries |
| CTPrsStd_NamedShapeDriver | An implementation of TPrsStd_Driver for named shapes |
| CTPrsStd_PlaneDriver | An implementation of TPrsStd_Driver for planes |
| CTPrsStd_PointDriver | An implementation of TPrsStd_Driver for points |
| CTransfer_ActorDispatch | This class allows to work with a TransferDispatch, i.e. to transfer entities from a data set to another one defined by the same interface norm, with the following features : |
| CTransfer_ActorOfFinderProcess | The original class was renamed. Compatibility only |
| CTransfer_ActorOfProcessForFinder | |
| CTransfer_ActorOfProcessForTransient | |
| CTransfer_ActorOfTransientProcess | The original class was renamed. Compatibility only |
| CTransfer_Binder | A Binder is an auxiliary object to Map the Result of the Transfer of a given Object : it records the Result of the Unitary Transfer (Resulting Object), status of progress and error (if any) of the Process |
| CTransfer_BinderOfTransientInteger | This type of Binder allows to attach as result, besides a Transient Object, an Integer Value, which can be an Index in the Object if it defines a List, for instance |
| CTransfer_DataInfo | Gives information on an object Used as template to instantiate Mapper and SimpleBinder This class is for Transient |
| CTransfer_DispatchControl | This is an auxiliary class for TransferDispatch, which allows to record simple copies, as CopyControl from Interface, but based on a TransientProcess. Hence, it allows in addition more actions (such as recording results of adaptations) |
| CTransfer_Finder | Finder allows to map any kind of object as a Key for a Map. This works by defining, for a Hash Code, that of the real Key, not of the Finder which acts only as an intermediate. When a Map asks for the HashCode of a Finder, this one returns the code it has determined at creation time |
| CTransfer_FinderProcess | Adds specific features to the generic definition : PrintTrace is adapted |
| CTransfer_FindHasher | FindHasher defines HashCode for Finder, which is : ask a Finder its HashCode! Because this is the Finder itself which brings the HashCode for its Key |
| CTransfer_IteratorOfProcessForFinder | |
| CTransfer_IteratorOfProcessForTransient | |
| CTransfer_MapContainer | |
| CTransfer_MultipleBinder | Allows direct binding between a starting Object and the Result of its transfer, when it can be made of several Transient Objects. Compared to a Transcriptor, it has no Transfer Action |
| CTransfer_ProcessForFinder | |
| CTransfer_ProcessForTransient | Manages Transfer of Transient Objects. Produces also ActorOfTransientProcess (deferred class), IteratorOfTransientProcess (for Results), TransferMapOfTransientProcess (internally used) Normally uses as TransientProcess, which adds some specifics |
| CTransfer_ResultFromModel | ResultFromModel is used to store a final result stored in a TransientProcess, respectfully to its structuration in scopes by using a set of ResultFromTransient Hence, it can be regarded as a passive equivalent of the stored data in the TransientProcess, while an Iterator gives a flat view of it |
| CTransfer_ResultFromTransient | This class, in conjunction with ResultFromModel, allows to record the result of a transfer initially stored in a TransientProcess |
| CTransfer_SimpleBinderOfTransient | An adapted instantiation of SimpleBinder for Transient Result, i.e. ResultType can be computed from the Result itself, instead of being static |
| CTransfer_TransferDispatch | A TransferDispatch is aimed to dispatch Entities between two Interface Models, by default by copying them, as CopyTool, but with more capabilities of adapting : Copy is redefined to firstly pass the hand to a TransferProcess. If this gives no result, standard Copy is called |
| CTransfer_TransferInput | A TransferInput is a Tool which fills an InterfaceModel with the result of the Transfer of CasCade Objects, once determined The Result comes from a TransferProcess, either from Transient (the Complete Result is considered, it must contain only Transient Objects) |
| CTransfer_TransferIterator | Defines an Iterator on the result of a Transfer Available for Normal Results or not (Erroneous Transfer) It gives several kinds of Information, and allows to consider various criteria (criteria are cumulative) |
| CTransfer_TransferOutput | A TransferOutput is a Tool which manages the transfer of entities created by an Interface, stored in an InterfaceModel, into a set of Objects suitable for an Application Objects to be transferred are given, by method Transfer (which calls Transfer from TransientProcess) A default action is available to get all roots of the Model Result is given as a TransferIterator (see TransferProcess) Also, it is possible to pilot directly the TransientProcess |
| CTransfer_TransientListBinder | This binder binds several (a list of) Transients with a starting entity, when this entity itself corresponds to a simple list of Transients. Each part is not seen as a sub-result of an independent component, but as an item of a built-in list |
| CTransfer_TransientMapper | |
| CTransfer_TransientProcess | Adds specific features to the generic definition : TransientProcess is intended to work from an InterfaceModel to a set of application objects |
| CTransfer_VoidBinder | VoidBinder is used to bind a starting item with a status, error or warning messages, but no result It is interpreted by TransferProcess, which admits a VoidBinder to be over-written, and copies its check to the new Binder |
| CTransferBRep | This package gathers services to simply read files and convert them to Shapes from CasCade. IE. it can be used in conjunction with purely CasCade software |
| CTransferBRep_BinderOfShape | Allows direct binding between a starting Object and the Result of its transfer when it is Unique. The Result itself is defined as a formal parameter <Shape from TopoDS> Warning : While it is possible to instantiate BinderOfShape with any Type for the Result, it is not advisable to instantiate it with Transient Classes, because such Results are directly known and managed by TransferProcess & Co, through SimpleBinderOfTransient : this class looks like instantiation of BinderOfShape, but its method ResultType is adapted (reads DynamicType of the Result) |
| CTransferBRep_Reader | This class offers a simple, easy to call, way of transferring data from interface files to Shapes from CasCade It must be specialized according to each norm/protocol, by : |
| CTransferBRep_ShapeBinder | A ShapeBinder is a BinderOfShape with some additional services to cast the Result under various kinds of Shapes |
| CTransferBRep_ShapeInfo | Gives information on an object, see template DataInfo This class is for Shape |
| CTransferBRep_ShapeListBinder | This binder binds several (a list of) shapes with a starting entity, when this entity itself corresponds to a simple list of shapes. Each part is not seen as a sub-result of an independent component, but as an item of a built-in list |
| CTransferBRep_ShapeMapper | |
| CTransferBRep_TransferResultInfo | Data structure for storing information on transfer result. At the moment it dispatches information for the following types: |
| CUnits | This package provides all the facilities to create and question a dictionary of units, and also to manipulate measurements which are real values with units |
| CUnits_Dimensions | This class includes all the methods to create and manipulate the dimensions of the physical quantities |
| CUnits_Explorer | This class provides all the services to explore UnitsSystem or UnitsDictionary |
| CUnits_Lexicon | This class defines a lexicon useful to analyse and recognize the different key words included in a sentence. The lexicon is stored in a sequence of tokens |
| CUnits_MathSentence | This class defines all the methods to create and compute an algebraic formula |
| CUnits_Measurement | This class defines a measurement which is the association of a real value and a unit |
| CUnits_Quantity | This class stores in its field all the possible units of all the unit systems for a given physical quantity. Each unit's value is expressed in the S.I. unit system |
| CUnits_Sentence | This class describes all the methods to create and compute an expression contained in a string |
| CUnits_ShiftedToken | The ShiftedToken class inherits from Token and describes tokens which have a gap in addition of the multiplicative factor. This kind of token allows the description of linear functions which do not pass through the origin, of the form: |
| CUnits_ShiftedUnit | This class is useful to describe units with a shifted origin in relation to another unit. A well known example is the Celsius degrees in relation to Kelvin degrees. The shift of the Celsius origin is 273.15 Kelvin degrees |
| CUnits_Token | This class defines an elementary word contained in a Sentence object |
| CUnits_Unit | This class defines an elementary word contained in a physical quantity |
| CUnits_UnitsDictionary | This class creates a dictionary of all the units you want to know |
| CUnits_UnitSentence | This class describes all the facilities to manipulate and compute units contained in a string expression |
| CUnits_UnitsLexicon | This class defines a lexicon useful to analyse and recognize the different key words included in a sentence. The lexicon is stored in a sequence of tokens |
| CUnits_UnitsSystem | This class allows the user to define his own system of units |
| CUnitsAPI | The UnitsAPI global functions are used to convert a value from any unit into another unit. Principles Conversion is executed among three unit systems: |
| CUnitsMethods | Class for using global units variables |
| CUTL | |
| CV3d | This package contains the set of commands and services of the 3D Viewer. It provides a set of high level commands to control the views and viewing modes |
| CV3d_AmbientLight | Creation of an ambient light source in a viewer |
| CV3d_CircularGrid | |
| CV3d_DirectionalLight | Directional light source for a viewer |
| CV3d_ImageDumpOptions | The structure defines options for image dump functionality |
| CV3d_Plane | Obsolete clip plane presentation class. Ported on new core of Graphic3d_ClipPlane approach. Please access Graphic3d_ClipPlane via ClipPlane() method to use it for standard clipping workflow. Example of use: |
| CV3d_PositionalLight | Creation and modification of an isolated (positional) light source. It is also defined by the color and two attenuation factors ConstAttentuation() and LinearAttentuation(). The resulting attenuation factor determining the illumination of a surface depends on the following formula: |
| CV3d_PositionLight | Base class for Positional, Spot and Directional Light classes |
| CV3d_RectangularGrid | |
| CV3d_SpotLight | Creation and modification of a spot. The attenuation factor F determines the illumination of a surface: |
| CV3d_Trihedron | Class for presentation of trihedron object |
| CV3d_View | Defines the application object VIEW for the VIEWER application. The methods of this class allow the editing and inquiring the parameters linked to the view. Provides a set of services common to all types of view. Warning: The default parameters are defined by the class Viewer (Example : SetDefaultViewSize()). Certain methods are mouse oriented, and it is necessary to know the difference between the start and the continuation of this gesture in putting the method into operation. Example : Shifting the eye-view along the screen axes |
| CV3d_Viewer | Defines services on Viewer type objects. The methods of this class allow editing and interrogation of the parameters linked to the viewer its friend classes (View,light,plane) |
| CViewerTest | |
| CViewerTest_AutoUpdater | Auxiliary tool to control view updates |
| CViewerTest_CmdParser | Command parser |
| CViewerTest_ContinuousRedrawer | Auxiliary tool performing continuous redraws of specified window. Tool creates an extra working thread pushing content invalidation messages to specific window using Aspect_Window::InvalidateContent() method. Normally, GUI application should done continuous rendering in simple fashion - just by drawing next frame without waiting for new events from windowing system; however, implementation of this approach is problematic in context of ViewerTest due to message loop binding mechanism implied by Tcl/Tk |
| CViewerTest_EventManager | Used to manage mouse event (move,select) By default the events are transmitted to interactive context |
| CViewerTest_V3dView | Setting additional flag to store 2D mode of the View to avoid scene rotation by mouse/key events |
| CViewerTest_VinitParams | Parameters for creating new view |
| CVrml | Vrml package implements the specification of the VRML (Virtual Reality Modeling Language ). VRML is a standard language for describing interactive 3-D objects and worlds delivered across Internet. Actual version of Vrml package have made for objects of VRML version 1.0. This package is used by VrmlConverter package. The developer should already be familiar with VRML specification before using this package |
| CVrml_AsciiText | Defines a AsciiText node of VRML specifying geometry shapes. This node represents strings of text characters from ASCII coded character set. All subsequent strings advance y by -( size * spacing). The justification field determines the placement of the strings in the x dimension. LEFT (the default) places the left edge of each string at x=0. CENTER places the center of each string at x=0. RIGHT places the right edge of each string at x=0. Text is rendered from left to right, top to bottom in the font set by FontStyle. The default value for the wigth field indicates the natural width should be used for that string |
| CVrml_Cone | Defines a Cone node of VRML specifying geometry shapes. This node represents a simple cone, whose central axis is aligned with the y-axis. By default, the cone is centred at (0,0,0) and has size of -1 to +1 in the all three directions. the cone has a radius of 1 at the bottom and height of 2, with its apex at 1 and its bottom at -1. The cone has two parts: the sides and the bottom |
| CVrml_Coordinate3 | Defines a Coordinate3 node of VRML specifying properties of geometry and its appearance. This node defines a set of 3D coordinates to be used by a subsequent IndexedFaceSet, IndexedLineSet, or PointSet node. This node does not produce a visible result during rendering; it simply replaces the current coordinates in the rendering state for subsequent nodes to use |
| CVrml_Cube | Defines a Cube node of VRML specifying geometry shapes. This node represents a cuboid aligned with the coordinate axes. By default, the cube is centred at (0,0,0) and measures 2 units in each dimension, from -1 to +1. A cube's width is its extent along its object-space X axis, its height is its extent along the object-space Y axis, and its depth is its extent along its object-space Z axis |
| CVrml_Cylinder | Defines a Cylinder node of VRML specifying geometry shapes. This node represents a simple capped cylinder centred around the y-axis. By default, the cylinder is centred at (0,0,0) and has size of -1 to +1 in the all three dimensions. The cylinder has three parts: the sides, the top (y=+1) and the bottom (y=-1) |
| CVrml_DirectionalLight | Defines a directional light node of VRML specifying properties of lights. This node defines a directional light source that illuminates along rays parallel to a given 3-dimensional vector Color is written as an RGB triple. Light intensity must be in the range 0.0 to 1.0, inclusive |
| CVrml_FontStyle | Defines a FontStyle node of VRML of properties of geometry and its appearance. The size field specifies the height (in object space units) of glyphs rendered and determines the vertical spacing of adjacent lines of text |
| CVrml_Group | Defines a Group node of VRML specifying group properties. This node defines the base class for all group nodes. Group is a node that contains an ordered list of child nodes. This node is simply a container for the child nodes and does not alter the traversal state in any way. During traversal, state accumulated for a child is passed on to each successive child and then to the parents of the group (Group does not push or pop traversal state as separator does) |
| CVrml_IndexedFaceSet | Defines a IndexedFaceSet node of VRML specifying geometry shapes. This node represents a 3D shape formed by constructing faces (polygons) from vertices located at the current coordinates. IndexedFaceSet uses the indices in its coordIndex to define polygonal faces. An index of -1 separates faces (so a -1 at the end of the list is optional) |
| CVrml_IndexedLineSet | Defines a IndexedLineSet node of VRML specifying geometry shapes. This node represents a 3D shape formed by constructing polylines from vertices located at the current coordinates. IndexedLineSet uses the indices in its coordIndex field to specify the polylines. An index of -1 separates one polyline from the next (thus, a final -1 is optional). the current polyline has ended and the next one begins. Treatment of the current material and normal binding is as follows: The PER_PART binding specifies a material or normal for each segment of the line. The PER_FACE binding specifies a material or normal for each polyline. PER_VERTEX specifies a material or normal for each vertex. The corresponding _INDEXED bindings are the same, but use the materialIndex or normalIndex indices. The DEFAULT material binding is equal to OVERALL. The DEFAULT normal binding is equal to PER_VERTEX_INDEXED; if insufficient normals exist in the state, the lines will be drawn unlit. The same rules for texture coordinate generation as IndexedFaceSet are used |
| CVrml_Info | Defines a Info node of VRML specifying properties of geometry and its appearance. It is used to store information in the scene graph, Typically for application-specific purposes, copyright messages, or other strings |
| CVrml_Instancing | Defines "instancing" - using the same instance of a node multiple times. It is accomplished by using the "DEF" and "USE" keywords. The DEF keyword both defines a named node, and creates a single instance of it. The USE keyword indicates that the most recently defined instance should be used again. If several nades were given the same name, then the last DEF encountered during parsing "wins". DEF/USE is limited to a single file |
| CVrml_LOD | Defines a LOD (level of detailization) node of VRML specifying properties of geometry and its appearance. This group node is used to allow applications to switch between various representations of objects automatically. The children of this node typically represent the same object or objects at the varying of Levels Of Detail (LOD), from highest detail to lowest |
| CVrml_Material | Defines a Material node of VRML specifying properties of geometry and its appearance. This node defines the current surface material properties for all subsequent shapes. Material sets several components of the current material during traversal. Different shapes interpret materials with multiple values differently. To bind materials to shapes, use a MaterialBinding node |
| CVrml_MaterialBinding | Defines a MaterialBinding node of VRML specifying properties of geometry and its appearance. Material nodes may contain more than one material. This node specifies how the current materials are bound to shapes that follow in the scene graph. Each shape node may interpret bindings differently. For example, a Sphere node is always drawn using the first material in the material node, no matter what the current MaterialBinding, while a Cube node may use six different materials to draw each of its six faces, depending on the MaterialBinding |
| CVrml_MatrixTransform | Defines a MatrixTransform node of VRML specifying matrix and transform properties. This node defines 3D transformation with a 4 by 4 matrix. By default: a11=1 a12=0 a13=0 a14=0 a21=0 a22=1 a23=0 a24=0 a31=0 a32=0 a33=1 a34=0 a41=0 a42=0 a43=0 a44=1 It is written to the file in row-major order as 16 Real numbers separated by whitespace. For example , matrix expressing a translation of 7.3 units along the X axis is written as: 1 0 0 0 0 1 0 0 0 0 1 0 7.3 0 0 1 |
| CVrml_Normal | Defines a Normal node of VRML specifying properties of geometry and its appearance. This node defines a set of 3D surface normal vectors to be used by vertex-based shape nodes (IndexedFaceSet, IndexedLineSet, PointSet) that follow it in the scene graph. This node does not produce a visible result during rendering; it simply replaces the current normals in the rendering state for subsequent nodes to use. This node contains one multiple-valued field that contains the normal vectors |
| CVrml_NormalBinding | Defines a NormalBinding node of VRML specifying properties of geometry and its appearance. This node specifies how the current normals are bound to shapes that follow in the scene graph. Each shape node may interpret bindings differently. The bindings for faces and vertices are meaningful only for shapes that are made from faces and vertices. Similarly, the indexed bindings are only used by the shapes that allow indexing. For bindings that require multiple normals, be sure to have at least as many normals defined as are necessary; otherwise, errors will occur |
| CVrml_OrthographicCamera | OrthographicCamera node of VRML specifying properties of cameras. An orthographic camera defines a parallel projection from a viewpoint. This camera does not diminish objects with distance, as a PerspectiveCamera does. The viewing volume for an orthographic camera is a rectangular parallelepiped (a box) |
| CVrml_PerspectiveCamera | PerspectiveCamera node of VRML specifying properties of cameras. A perspective camera defines a perspective projection from a viewpoint. The viewing volume for a perspective camera is a truncated right pyramid |
| CVrml_PointLight | Defines a point light node of VRML specifying properties of lights. This node defines a point light source at a fixed 3D location A point source illuminates equally in all directions; that is omni-directional. Color is written as an RGB triple. Light intensity must be in the range 0.0 to 1.0, inclusive |
| CVrml_PointSet | Defines a PointSet node of VRML specifying geometry shapes |
| CVrml_Rotation | Defines a Rotation node of VRML specifying matrix and transform properties. This node defines a 3D rotation about an arbitrary axis through the origin. Bydefault: myRotation = (0 0 1 0) |
| CVrml_Scale | Defines a Scale node of VRML specifying transform properties. This node defines a 3D scaling about the origin. By default: myRotation = (1 1 1) |
| CVrml_Separator | Defines a Separator node of VRML specifying group properties. This group node performs a push (save) of the traversal state before traversing its children and a pop (restore) after traversing them. This isolates the separator's children from the rest of the scene graph. A separator can include lights, cameras, coordinates, normals, bindings, and all other properties. Separators can also perform render culling. Render culling skips over traversal of the separator's children if they are not going to be rendered, based on the comparison of the separator's bounding box with the current view volume. Culling is controlled by the renderCulling field. These are set to AUTO by default, allowing the implementation to decide whether or not to cull |
| CVrml_SFImage | Defines SFImage type of VRML field types |
| CVrml_SFRotation | Defines SFRotation type of VRML field types. The 4 values represent an axis of rotation followed by amount of right-handed rotation about the that axis, in radians |
| CVrml_ShapeHints | Defines a ShapeHints node of VRML specifying properties of geometry and its appearance. The ShapeHints node indicates that IndexedFaceSets are solid, contain ordered vertices, or contain convex faces. These hints allow VRML implementations to optimize certain rendering features. Optimizations that may be performed include enabling back-face culling and disabling two-sided lighting. For example, if an object is solid and has ordered vertices, an implementation may turn on backface culling and turn off two-sided lighting. To ensure that an IndexedFaceSet can be viewed from either direction, set shapeType to be UNKNOWN_SHAPE_TYPE. If you know that your shapes are closed and will alwsys be viewed from the outside, set vertexOrdering to be either CLOCKWISE or COUNTERCLOCKWISE (depending on how you built your object), and set shapeType to be SOLID. Placing this near the top of your VRML file will allow the scene to be rendered much faster. The ShapeHints node also affects how default normals are generated. When an IndexedFaceSet has to generate default normals, it uses the creaseAngle field to determine which edges should be smoothly shaded and which ones should have a sharp crease. The crease angle is the angle between surface normals on adjacent polygons. For example, a crease angle of .5 radians (the default value) means that an edge between two adjacent polygonal faces will be smooth shaded if the normals to the two faces form an angle that is less than .5 radians (about 30 degrees). Otherwise, it will be faceted |
| CVrml_Sphere | Defines a Sphere node of VRML specifying geometry shapes. This node represents a sphere. By default, the sphere is centred at (0,0,0) and has a radius of 1 |
| CVrml_SpotLight | Spot light node of VRML nodes specifying properties of lights. This node defines a spotlight light source. A spotlight is placed at a fixed location in 3D-space and illuminates in a cone along a particular direction. The intensity of the illumination drops off exponentially as a ray of light diverges from this direction toward the edges of cone. The rate of drop-off and agle of the cone are controlled by the dropOfRate and cutOffAngle Color is written as an RGB triple. Light intensity must be in the range 0.0 to 1.0, inclusive |
| CVrml_Switch | Defines a Switch node of VRML specifying group properties. This group node traverses one, none, or all of its children. One can use this node to switch on and off the effects of some properties or to switch between different properties. The whichChild field specifies the index of the child to traverse, where the first child has index 0. A value of -1 (the default) means do not traverse any children. A value of -3 traverses all children, making the switch behave exactly like a regular Group |
| CVrml_Texture2 | Defines a Texture2 node of VRML specifying properties of geometry and its appearance. This property node defines a texture map and parameters for that map The texture can be read from the URL specified by the filename field. To turn off texturing, set the filename field to an empty string (""). Textures can alsobe specified inline by setting the image field to contain the texture data. By default: myFilename ("") myImage (0 0 0) myWrapS (Vrml_REPEAT) myWrapT (Vrml_REPEAT) |
| CVrml_Texture2Transform | Defines a Texture2Transform node of VRML specifying properties of geometry and its appearance. This node defines a 2D transformation applied to texture coordinates. This affect the way textures are applied to the surfaces of subsequent shapes. Transformation consisits of (in order) a non-uniform scale about an arbitrary center point, a rotation about that same point, and a translation. This allows a user to change the size and position of the textures on the shape. By default: myTranslation (0 0) myRotation (0) myScaleFactor (1 1) myCenter (0 0) |
| CVrml_TextureCoordinate2 | Defines a TextureCoordinate2 node of VRML specifying properties of geometry and its appearance. This node defines a set of 2D coordinates to be used to map textures to the vertices of subsequent PointSet, IndexedLineSet, or IndexedFaceSet objects. It replaces the current texture coordinates in the rendering state for the shapes to use. Texture coordinates range from 0 to 1 across the texture. The horizontal coordinate, called S, is specified first, followed by vertical coordinate, T. By default: myPoint (0 0) |
| CVrml_Transform | Defines a Transform of VRML specifying transform properties. This node defines a geometric 3D transformation consisting of (in order) a (possibly) non-uniform scale about an arbitrary point, a rotation about an arbitrary point and axis and translation. By default: myTranslation (0,0,0) myRotation (0,0,1,0) myScaleFactor (1,1,1) myScaleOrientation (0,0,1,0) myCenter (0,0,0) |
| CVrml_TransformSeparator | Defines a TransformSeparator node of VRML specifying group properties. This group node is similar to separator node in that it saves state before traversing its children and restores it afterwards. This node can be used to isolate transformations to light sources or objects |
| CVrml_Translation | Defines a Translation of VRML specifying transform properties. This node defines a translation by 3D vector. By default: myTranslation (0,0,0) |
| CVrml_WWWAnchor | Defines a WWWAnchor node of VRML specifying group properties. The WWWAnchor group node loads a new scene into a VRML browser when one of its children is closen. Exactly how a user "chooses" a child of the WWWAnchor is up to the VRML browser. WWWAnchor with an empty ("") name does nothing when its children are chosen. WWWAnchor behaves like a Separator, pushing the traversal state before traversing its children and popping it afterwards |
| CVrml_WWWInline | Defines a WWWInline node of VRML specifying group properties. The WWWInline group node reads its children from anywhere in the World Wide Web. Exactly when its children are read is not defined; reading the children may be delayed until the WWWInline is actually displayed. WWWInline with an empty ("") name does nothing. WWWInline behaves like a Separator, pushing the traversal state before traversing its children and popping it afterwards. By defaults: myName ("") myBboxSize (0,0,0) myBboxCenter (0,0,0) |
| CVrmlAPI | API for writing to VRML 1.0 |
| CVrmlAPI_CafReader | The Vrml mesh reader into XDE document |
| CVrmlAPI_Writer | Creates and writes VRML files from Open CASCADE shapes. A VRML file can be written to an existing VRML file or to a new one |
| CVrmlConverter_Curve | Curve - computes the presentation of objects to be seen as curves (the computation will be made with a constant number of points), converts this one into VRML objects and writes (adds) them into anOStream. All requested properties of the representation are specify in aDrawer of Drawer class (VrmlConverter). This kind of the presentation is converted into IndexedLineSet (VRML) |
| CVrmlConverter_DeflectionCurve | DeflectionCurve - computes the presentation of objects to be seen as curves, converts this one into VRML objects and writes (adds) into anOStream. All requested properties of the representation are specify in aDrawer. This kind of the presentation is converted into IndexedLineSet (VRML). The computation will be made according to a maximal chordial deviation |
| CVrmlConverter_Drawer | Qualifies the aspect properties for the VRML conversation of a specific kind of object. This includes for example color, maximal chordial deviation, etc.. |
| CVrmlConverter_HLRShape | HLRShape - computes the presentation of objects with removal of their hidden lines for a specific projector, converts them into VRML objects and writes (adds) them into anOStream. All requested properties of the representation are specify in aDrawer of Drawer class. This kind of the presentation is converted into IndexedLineSet and if they are defined in Projector info: PerspectiveCamera, OrthographicCamera, DirectionLight, PointLight, SpotLight from Vrml package |
| CVrmlConverter_IsoAspect | Qualifies the aspect properties for the VRML conversation of iso curves |
| CVrmlConverter_LineAspect | Qualifies the aspect properties for the VRML conversation of a Curve and a DeflectionCurve |
| CVrmlConverter_PointAspect | Qualifies the aspect properties for the VRML conversation of a Point Set |
| CVrmlConverter_Projector | Defines projector and calculates properties of cameras and lights from Vrml (OrthograpicCamera, PerspectiveCamera, DirectionalLight, PointLight, SpotLight and MatrixTransform) to display all scene shapes with arbitrary locations for requested the Projection Vector, High Point Direction and the Focus and adds them (method Add) to anOSream |
| CVrmlConverter_ShadedShape | ShadedShape - computes the shading presentation of shapes by triangulation algorithms, converts this one into VRML objects and writes (adds) into anOStream. All requested properties of the representation including the maximal chordial deviation are specify in aDrawer. This kind of the presentation is converted into IndexedFaceSet (VRML) |
| CVrmlConverter_ShadingAspect | Qualifies the aspect properties for the VRML conversation of ShadedShape |
| CVrmlConverter_WFDeflectionRestrictedFace | WFDeflectionRestrictedFace - computes the wireframe presentation of faces with restrictions by displaying a given number of U and/or V isoparametric curves, converts his into VRML objects and writes (adds) them into anOStream. All requested properties of the representation are specify in aDrawer of Drawer class (Prs3d). This kind of the presentation is converted into IndexedFaceSet and IndexedLineSet (VRML) |
| CVrmlConverter_WFDeflectionShape | WFDeflectionShape - computes the wireframe presentation of compound set of faces, edges and vertices by displaying a given number of U and/or V isoparametric curves, converts this one into VRML objects and writes (adds) them into anOStream. All requested properties of the representation are specify in aDrawer. This kind of the presentation is converted into IndexedLineSet and PointSet (VRML) |
| CVrmlConverter_WFRestrictedFace | WFRestrictedFace - computes the wireframe presentation of faces with restrictions by displaying a given number of U and/or V isoparametric curves, converts this one into VRML objects and writes (adds) into anOStream. All requested properties of the representation are specify in aDrawer. This kind of the presentation is converted into IndexedLineSet (VRML) |
| CVrmlConverter_WFShape | WFShape - computes the wireframe presentation of compound set of faces, edges and vertices by displaying a given number of U and/or V isoparametric curves converts this one into VRML objects and writes (adds) them into anOStream. All requested properties of the representation are specify in aDrawer. This kind of the presentation is converted into IndexedLineSet and PointSet (VRML) |
| CVrmlData_Appearance | |
| CVrmlData_ArrayVec3d | |
| CVrmlData_Box | |
| CVrmlData_Color | |
| CVrmlData_Cone | |
| CVrmlData_Coordinate | |
| CVrmlData_Cylinder | |
| CVrmlData_Faceted | |
| CVrmlData_Geometry | |
| CVrmlData_Group | |
| CVrmlData_ImageTexture | |
| CVrmlData_InBuffer | |
| CVrmlData_IndexedFaceSet | |
| CVrmlData_IndexedLineSet | |
| CVrmlData_Material | |
| CVrmlData_Node | |
| CVrmlData_Normal | |
| CVrmlData_Scene | |
| CVrmlData_ShapeConvert | |
| CShapeData | |
| CVrmlData_ShapeNode | |
| CVrmlData_Sphere | |
| CVrmlData_Texture | |
| CVrmlData_TextureCoordinate | |
| CVrmlData_TextureTransform | Implementation of the TextureTransform node |
| CVrmlData_UnknownNode | |
| CVrmlData_WorldInfo | |
| CWasm_Window | This class defines WebAssembly window (HTML5 canvas) intended for creation of OpenGL (WebGL) context |
| CWNT_HIDSpaceMouse | Wrapper over Space Mouse data chunk within WM_INPUT event (known also as Raw Input in WinAPI). This class predefines specific list of supported devices, which does not depend on 3rdparty library provided by mouse vendor. Supported input chunks: |
| CXBRepMesh_Factory | Factory for creating XBRepMesh meshing algorithm instances. This factory is registered under the name "XBRepMesh" and provides an alternative meshing algorithm based on BRepMesh_IncrementalMesh |
| CXCAFApp_Application | Implements an Application for the DECAF documents |
| CXCAFDimTolObjects_DatumObject | Access object to store datum |
| CXCAFDimTolObjects_DimensionObject | Access object to store dimension data |
| CXCAFDimTolObjects_GeomToleranceObject | Access object to store dimension and tolerance |
| CXCAFDimTolObjects_Tool | |
| CXCAFDoc | Definition of general structure of DECAF document and tools to work with it |
| CXCAFDoc_Area | Attribute to store area |
| CXCAFDoc_AssemblyGraph | |
| CIterator | Graph iterator |
| CXCAFDoc_AssemblyItemId | Unique item identifier in the hierarchical product structure. A full path to an assembly component in the "part-of" graph starting from the root node |
| CXCAFDoc_AssemblyItemRef | An attribute that describes a weak reference to an assembly item or to a subshape or to an assembly label attribute |
| CXCAFDoc_AssemblyIterator | Iterator in depth along the assembly tree |
| CXCAFDoc_AssemblyTool | Provides generic methods for traversing assembly tree and graph |
| CXCAFDoc_Centroid | Attribute to store centroid |
| CXCAFDoc_ClippingPlaneTool | Provide tool for management of ClippingPlane section of document. Provide tool to store, retrieve, remove and modify clipping planes. Each clipping plane consists of gp_Pln and its name |
| CXCAFDoc_Color | Attribute to store color |
| CXCAFDoc_ColorTool | Provides tools to store and retrieve attributes (colors) of TopoDS_Shape in and from TDocStd_Document A Document is intended to hold different attributes of ONE shape and it's sub-shapes Provide tools for management of Colors section of document |
| CXCAFDoc_Datum | Attribute to store datum |
| CXCAFDoc_Dimension | Attribute that identifies a dimension in the GD&T table. Its parent label is used as a container to store data provided by XCAFDimTolObjects_DimensionObject |
| CXCAFDoc_DimTol | Attribute to store dimension and tolerance |
| CXCAFDoc_DimTolTool | Attribute containing GD&T section of XCAF document. Provide tools for GD&T section management |
| CXCAFDoc_DocumentTool | Defines sections structure of an XDE document. attribute marking CAF document as being DECAF document. Creates the sections structure of the document |
| CXCAFDoc_Editor | Tool for edit structure of document |
| CXCAFDoc_GeomTolerance | Attribute to store dimension and tolerance |
| CXCAFDoc_GraphNode | This attribute allow user multirelation tree of labels. This GraphNode is experimental Graph that not control looping and redundance. Attribute containing sequence of father's and child's labels. Provide create and work with Graph in XCAFDocument |
| CXCAFDoc_LayerTool | Provides tools to store and retrieve attributes (Layers) of TopoDS_Shape in and from TDocStd_Document A Document is intended to hold different attributes of ONE shape and it's sub-shapes Provide tools for management of Layers section of document |
| CXCAFDoc_LengthUnit | Used to define a Length Unit attribute containing a length unit info |
| CXCAFDoc_Location | Attribute to store TopLoc_Location |
| CXCAFDoc_Material | Attribute to store material |
| CXCAFDoc_MaterialTool | Provides tools to store and retrieve attributes (materials) of TopoDS_Shape in and from TDocStd_Document A Document is intended to hold different attributes of ONE shape and it's sub-shapes Provide tools for management of Materialss section of document |
| CXCAFDoc_Note | A base note attribute. Any note contains the name of the user created the note and the creation timestamp |
| CXCAFDoc_NoteBalloon | A comment note attribute. Contains a textual comment |
| CXCAFDoc_NoteBinData | |
| CXCAFDoc_NoteComment | A comment note attribute. Contains a textual comment |
| CXCAFDoc_NotesTool | A tool to annotate items in the hierarchical product structure. There are two basic entities, which operates the notes tool: notes and annotated items. A note is a user defined data structure derived from XCAFDoc_Note attribute that is attached to a separate label under the notes hive. An annotated item is represented by XCAFDoc_AssemblyItemRef attribute attached to a separate label under the annotated items hive. Notes are linked with annotated items by means of XCAFDoc_GraphNode attribute. Notes play parent roles and annotated items - child roles |
| CXCAFDoc_ShapeMapTool | Attribute containing map of sub shapes |
| CXCAFDoc_ShapeTool | A tool to store shapes in an XDE document in the form of assembly structure, and to maintain this structure. Attribute containing Shapes section of DECAF document. Provide tools for management of Shapes section. The API provided by this class allows to work with this structure regardless of its low-level implementation. All the shapes are stored on child labels of a main label which is XCAFDoc_DocumentTool::LabelShapes(). The label for assembly also has sub-labels, each of which represents the instance of another shape in that assembly (component). Such sub-label stores reference to the label of the original shape in the form of TDataStd_TreeNode with GUID XCAFDoc::ShapeRefGUID(), and its location encapsulated into the NamedShape. For correct work with an XDE document, it is necessary to use methods for analysis and methods for working with shapes. For example: if ( STool->IsAssembly(aLabel) ) { bool subchilds = false; (default) int nbc = STool->NbComponents (aLabel[,subchilds]); } If subchilds is True, commands also consider sub-levels. By default, only level one is checked. In this example, number of children from the first level of assembly will be returned. Methods for creation and initialization: Constructor: XCAFDoc_ShapeTool::XCAFDoc_ShapeTool() Getting a guid: Standard_GUID GetID (); Creation (if does not exist) of ShapeTool on label L: occ::handle<XCAFDoc_ShapeTool> XCAFDoc_ShapeTool::Set(const TDF_Label& L) Analyze whether shape is a simple shape or an instance or a component of an assembly or it is an assembly ( methods of analysis). For example: STool->IsShape(aLabel) ; Analyze that the label represents a shape (simple shape, assembly or reference) or STool->IsTopLevel(aLabel); Analyze that the label is a label of a top-level shape. Work with simple shapes, assemblies and instances ( methods for work with shapes). For example: Add shape: bool makeAssembly; // True to interpret a Compound as an Assembly, False to take it as a whole aLabel = STool->AddShape(aShape, makeAssembly); Get shape: TDF_Label aLabel... // A label must be present if (aLabel.IsNull()) { ... no such label : abandon .. } TopoDS_Shape aShape; aShape = STool->GetShape(aLabel); if (aShape.IsNull()) { ... this label is not for a Shape ... } To get a label from shape. bool findInstance = false; (this is default value) aLabel = STool->FindShape(aShape [,findInstance]); if (aLabel.IsNull()) { ... no label found for this shape ... } |
| CXCAFDoc_View | Attribute to store view |
| CXCAFDoc_ViewTool | Provides tools to store and retrieve Views in and from TDocStd_Document Each View contains parts XCAFDoc_View attribute with all information about camera and view window. Also each view contain information of displayed shapes and GDTs as sets of shape and GDT labels |
| CXCAFDoc_VisMaterial | Attribute storing Material definition for visualization purposes |
| CXCAFDoc_VisMaterialCommon | Common (obsolete) material definition |
| CXCAFDoc_VisMaterialPBR | Metallic-roughness PBR material definition |
| CXCAFDoc_VisMaterialTool | Provides tools to store and retrieve attributes (visualization materials) of TopoDS_Shape in and from TDocStd_Document |
| CXCAFDoc_Volume | Attribute to store volume |
| CXCAFNoteObjects_NoteObject | Object to store note auxiliary data |
| CXCAFPrs | Presentation (visualiation, selection etc.) tools for DECAF documents |
| CXCAFPrs_AISObject | Implements AIS_InteractiveObject functionality for shape in DECAF document |
| CXCAFPrs_DocumentExplorer | Document iterator through shape nodes |
| CXCAFPrs_DocumentIdIterator | Auxiliary tool for iterating through Path identification string |
| CXCAFPrs_DocumentNode | Structure defining document node |
| CXCAFPrs_Driver | Implements a driver for presentation of shapes in DECAF document. Its the only purpose is to initialize and return XCAFPrs_AISObject object on request |
| CXCAFPrs_Style | Represents a set of styling settings applicable to a (sub)shape |
| CXCAFPrs_Texture | Texture holder |
| CXCAFView_Object | Access object for saved view |
| CXDEDRAW | Provides DRAW commands for work with DECAF data structures |
| CXDEDRAW_Colors | Contains commands to work with colors |
| CXDEDRAW_Common | |
| CXDEDRAW_GDTs | Contains commands to work with GDTs |
| CXDEDRAW_Layers | Contains commands to work with layers |
| CXDEDRAW_Notes | Contains commands to work with notes |
| CXDEDRAW_Props | Contains commands to work with geometric validation properties of shapes |
| CXDEDRAW_Shapes | Contains commands to work with shapes and assemblies |
| CXDEDRAW_Views | Contains commands to work with GDTs |
| CXmlDrivers | |
| CXmlDrivers_DocumentRetrievalDriver | |
| CXmlDrivers_DocumentStorageDriver | |
| CXmlLDrivers | |
| CXmlLDrivers_DocumentRetrievalDriver | |
| CXmlLDrivers_DocumentStorageDriver | |
| CXmlLDrivers_NamespaceDef | |
| CXmlMDataStd | Storage and Retrieval drivers for modelling attributes. Transient attributes are defined in package TDataStd |
| CXmlMDataStd_AsciiStringDriver | TDataStd_AsciiString attribute Driver |
| CXmlMDataStd_BooleanArrayDriver | |
| CXmlMDataStd_BooleanListDriver | |
| CXmlMDataStd_ByteArrayDriver | |
| CXmlMDataStd_ExpressionDriver | Attribute Driver |
| CXmlMDataStd_ExtStringArrayDriver | Attribute Driver |
| CXmlMDataStd_ExtStringListDriver | |
| CXmlMDataStd_GenericEmptyDriver | |
| CXmlMDataStd_GenericExtStringDriver | Attribute Driver |
| CXmlMDataStd_IntegerArrayDriver | Attribute Driver |
| CXmlMDataStd_IntegerDriver | Attribute Driver |
| CXmlMDataStd_IntegerListDriver | |
| CXmlMDataStd_IntPackedMapDriver | TDataStd_IntPackedMap attribute Driver |
| CXmlMDataStd_NamedDataDriver | |
| CXmlMDataStd_RealArrayDriver | Attribute Driver |
| CXmlMDataStd_RealDriver | Attribute Driver |
| CXmlMDataStd_RealListDriver | |
| CXmlMDataStd_ReferenceArrayDriver | |
| CXmlMDataStd_ReferenceListDriver | |
| CXmlMDataStd_TreeNodeDriver | Attribute Driver |
| CXmlMDataStd_UAttributeDriver | Attribute Driver |
| CXmlMDataStd_VariableDriver | Attribute Driver |
| CXmlMDataXtd | Storage and Retrieval drivers for modelling attributes. Transient attributes are defined in package TDataXtd |
| CXmlMDataXtd_ConstraintDriver | Attribute Driver |
| CXmlMDataXtd_GeometryDriver | Attribute Driver |
| CXmlMDataXtd_PatternStdDriver | Attribute Driver |
| CXmlMDataXtd_PositionDriver | Attribute Driver |
| CXmlMDataXtd_PresentationDriver | Attribute Driver |
| CXmlMDataXtd_TriangulationDriver | TDataStd_Mesh attribute XML Driver |
| CXmlMDF | This package provides classes and methods to translate a transient DF into a persistent one and vice versa |
| CXmlMDF_ADriver | Attribute Storage/Retrieval Driver |
| CXmlMDF_ADriverTable | A driver table is an object building links between object types and object drivers. In the translation process, a driver table is asked to give a translation driver for each current object to be translated |
| CXmlMDF_DerivedDriver | A universal driver for the attribute that inherits another attribute with ready to used persistence mechanism implemented (already has a driver to store/retrieve) |
| CXmlMDF_ReferenceDriver | Attribute Driver |
| CXmlMDF_TagSourceDriver | Attribute Driver |
| CXmlMDocStd | Driver for TDocStd_XLink |
| CXmlMDocStd_XLinkDriver | Attribute Driver |
| CXmlMFunction | |
| CXmlMFunction_FunctionDriver | Attribute Driver |
| CXmlMFunction_GraphNodeDriver | XML persistence driver for dependencies of a function |
| CXmlMFunction_ScopeDriver | XML persistence driver for a scope of functions |
| CXmlMNaming | |
| CXmlMNaming_NamedShapeDriver | |
| CXmlMNaming_NamingDriver | |
| CXmlMNaming_Shape1 | The XmlMNaming_Shape1 is the Persistent view of a TopoDS_Shape |
| CXmlMXCAFDoc | Storage and Retrieval drivers for modelling attributes. Transient attributes are defined in package XCAFDoc |
| CXmlMXCAFDoc_AssemblyItemRefDriver | Attribute Driver |
| CXmlMXCAFDoc_CentroidDriver | Attribute Driver |
| CXmlMXCAFDoc_ColorDriver | Attribute Driver |
| CXmlMXCAFDoc_DatumDriver | Attribute Driver |
| CXmlMXCAFDoc_DimTolDriver | Attribute Driver |
| CXmlMXCAFDoc_GraphNodeDriver | Attribute Driver |
| CXmlMXCAFDoc_LengthUnitDriver | Attribute Driver |
| CXmlMXCAFDoc_LocationDriver | Attribute Driver |
| CXmlMXCAFDoc_MaterialDriver | Attribute Driver |
| CXmlMXCAFDoc_NoteBinDataDriver | Attribute Driver |
| CXmlMXCAFDoc_NoteCommentDriver | Attribute Driver |
| CXmlMXCAFDoc_NoteDriver | Attribute Driver |
| CXmlMXCAFDoc_VisMaterialDriver | Attribute Driver |
| CXmlMXCAFDoc_VisMaterialToolDriver | XML persistence driver for XCAFDoc_VisMaterialTool |
| CXmlObjMgt | This package defines services to manage the storage grain of data produced by applications and those classes to manage persistent extern reference |
| CXmlObjMgt_Array1 | The class Array1 represents unidimensional array of fixed size known at run time. The range of the index is user defined. Warning: Programs clients of such class must be independent of the range of the first element. Then, a C++ for loop must be written like this for (i = A->Lower(); i <= A->Upper(); i++) |
| CXmlObjMgt_GP | Translation of gp (simple geometry) objects |
| CXmlObjMgt_Persistent | Root for XML-persistence |
| CXmlObjMgt_RRelocationTable | Retrieval relocation table is modeled as a child class of NCollection_DataMap<int, occ::handle<Standard_Transient>> that stores a handle to the file header section. With that attribute drivers have access to the file header section |
| CXmlObjMgt_SRelocationTable | Stored relocation table is modeled as a child class of NCollection_DataMap<int, occ::handle<Standard_Transient>> that stores a handle to the file header section. With that attribute drivers have access to the file header section |
| CXmlTObjDrivers | Class for registering storage/retrieval drivers for TObj XML persistence |
| CXmlTObjDrivers_DocumentRetrievalDriver | |
| CXmlTObjDrivers_DocumentStorageDriver | |
| CXmlTObjDrivers_IntSparseArrayDriver | |
| CXmlTObjDrivers_ModelDriver | |
| CXmlTObjDrivers_ObjectDriver | |
| CXmlTObjDrivers_ReferenceDriver | |
| CXmlTObjDrivers_XYZDriver | |
| CXmlXCAFDrivers | |
| CXmlXCAFDrivers_DocumentRetrievalDriver | Retrieval driver of a XS document |
| CXmlXCAFDrivers_DocumentStorageDriver | Storage driver of a XS document |
| CXSAlgo | |
| CXSAlgo_AlgoContainer | |
| CXSAlgo_ShapeProcessor | Shape Processing module. Allows to define and apply general Shape Processing as a customizable sequence of operators |
| CXSControl | This package provides complements to IFSelect & Co for control of a session |
| CXSControl_ConnectedShapes | From a TopoDS_Shape, or from the entity which has produced it, searches for the shapes, and the entities which have produced them in last transfer, which are adjacent to it by VERTICES |
| CXSControl_Controller | This class allows a general X-STEP engine to run generic functions on any interface norm, in the same way. It includes the transfer operations. I.e. it gathers the already available general modules, the engine has just to know it |
| CXSControl_FuncShape | Defines additional commands for XSControl to : |
| CXSControl_Functions | Functions from XSControl gives access to actions which can be commanded with the resources provided by XSControl: especially Controller and Transfer |
| CXSControl_Reader | A groundwork to convert a shape to data which complies with a particular norm. This data can be that of a whole model or that of a specific list of entities in the model. You specify the list using a single selection or a combination of selections. A selection is an operator which computes a list of entities from a list given in input. To specify the input, you can use: |
| CXSControl_SelectForTransfer | This selection selects the entities which are recognised for transfer by an Actor for Read : current one or another one |
| CXSControl_SignTransferStatus | This Signatures gives the Transfer Status of an entity, as recorded in a TransferProcess. It can be : |
| CXSControl_TransferReader | A TransferReader performs, manages, handles results of, transfers done when reading a file (i.e. from entities of an InterfaceModel, to objects for Imagine) |
| CXSControl_TransferWriter | TransferWriter gives help to control transfer to write a file after having converted data from Cascade/Imagine |
| CXSControl_Utils | This class provides various useful utility routines, to facilitate handling of most common data structures : transients (type, type name ...), strings (ascii or extended, pointed or handled or ...), shapes (reading, writing, testing ...), sequences & arrays (of strings, of transients, of shapes ...), .. |
| CXSControl_Vars | Defines a receptacle for externally defined variables, each one has a name |
| CXSControl_WorkSession | This WorkSession completes the basic one, by adding : |
| CXSControl_Writer | This class gives a simple way to create then write a Model compliant to a given norm, from a Shape The model can then be edited by tools by other appropriate tools |
| CXSDRAW | Basic package to work functions of X-STEP (IFSelect & Co) under control of DRAW |
| CXSDRAW_Functions | Defines additional commands for XSDRAW to : |
| CXSDRAW_Vars | Vars for DRAW session (i.e. DBRep and DrawTrSurf) |
| CXSDRAWDE | |
| CXSDRAWGLTF | |
| CXSDRAWIGES | |
| CXSDRAWOBJ | |
| CXSDRAWPLY | |
| CXSDRAWSTEP | |
| CXSDRAWSTL | |
| CXSDRAWSTL_DataSource | The sample DataSource for working with STLMesh_Mesh |
| CXSDRAWSTL_DataSource3D | The sample DataSource3D for working with STLMesh_Mesh |
| CXSDRAWSTL_DrawableMesh | |
| CXSDRAWVRML | |
| CXw_Window | This class defines XLib window intended for creation of OpenGL context |
| CyyFlexLexer | |
OCCT 8.0.1
1.17.0