Open CASCADE Technology
7.1.0.beta

►NBRepMesh  
►NBVH  
►NGraphic3d_TransformUtils  Helper class that implements transformation matrix functionality 
►Nopencascade  
►NOpenGl  
►NOpenGl_HashMapInitializer  
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_HCurve2d  Root class for 2D curves manipulated by handles, 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 specific class is provided: Geom2dAdaptor_HCurve for a curve from the Geom2d package 
CAdaptor2d_HLine2d  
CAdaptor2d_HOffsetCurve  
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_HCurve  Root class for 3D curves manipulated by handles, 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_HCurveOnSurface  
CAdaptor3d_HIsoCurve  
CAdaptor3d_HSurface  Root class for surfaces manipulated by handles, 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_HSurface for a surface from the Geom package 
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 relativly 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 algorithmes 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 boundarys 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 uiso or viso on F(U,V) This can be usefull to optimize the <Func> methode ContInU, ContInV : Continuity waiting in u and v PrecisCode : Precision on approximation's error mesurement 1 : Fast computation and average precision 2 : Average computation and good precision 3 : Slow computation and very good precision MaxDegInU : Maximum udegree waiting in U MaxDegInV : Maximum udegree 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 : Maximun 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_Data  
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 intervall [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 averrage 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_AngleDimension  Angle dimension. Can be constructed: 
CAIS_Animation  Class represents single animation. It is defined with: 
CAIS_AnimationCamera  Camera animation 
CAIS_AnimationObject  Animation defining object transformation 
CAIS_AnimationProgress  Structure defining current animation progress 
CAIS_AnimationTimer  Auxiliary class defining the animation timer 
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 nonnull 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_C0RegularityFilter  
CAIS_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 
CAIS_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 
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 subshapes properties 
CAIS_ColorScale  Class for drawing a custom color scale 
CAIS_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 
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_DiameterDimension  Diameter dimension. Can be constructued: 
►CAIS_Dimension  AIS_Dimension is a base class for 2D presentations of linear (length, diameter, radius) and angular dimensions 
CAIS_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 
CAIS_EllipseRadiusDimension  Computes geometry ( basis curve and plane of dimension) for input shape aShape from TopoDS Root class for MinRadiusDimension and MaxRadiusDimension 
CAIS_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 
CAIS_EqualRadiusRelation  
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_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 
CAIS_GlobalStatus  Stores information about objects in graphic context: 
CAIS_GraphicTool  
CAIS_IdenticRelation  Constructs a constraint by a relation of identity between two or more datums figuring in shape Interactive Objects 
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. You must distinguish two states in the Interactive Context: 
CAIS_InteractiveObject  Defines a class of objects with display and selection services. Entities which are visualized and selected are Interactive Objects. You can make use of classes of standard Interactive Objects for which all necessary methods have already been programmed, or you can implement your own classes of Interactive Objects. Specific attributes of entities such as arrow aspect for dimensions must be loaded in a Drawer. This Drawer is then applied to the Interactive Object in view. There are four types of Interactive Object in AIS: the construction element or Datum, the Relation, which includes both dimensions and constraints, the Object, and finally, when the object is of an unknown type, the None type. Inside these categories, a signature, or index, provides the possibility of additional characterization. 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 the methods, Signature and Type. Warning In the case of attribute methods, methods for standard attributes are virtual. They must be redefined by the inheriting classes. Setcolor for a point and Setcolor for a plane, for example, do not affect the same attributes in the Drawer 
CAIS_LengthDimension  Length dimension. Can be constructued: 
CAIS_Line  Constructs line datums to be used in construction of composite shapes 
CAIS_LocalContext  Defines a specific context for selection. It becomes possible to: 
CAIS_LocalStatus  Stored Info about temporary objects 
►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: 
CAIS_ManipulatorOwner  Entity owner for selection management of AIS_Manipulator object 
CAIS_MaxRadiusDimension  Ellipse Max radius dimension of a Shape which can be Edge or Face (planar or cylindrical(surface of extrusion or surface of offset)) 
CAIS_MidPointRelation  Presentation of equal distance to point myMidPoint 
CAIS_MinRadiusDimension  – Ellipse Min radius dimension of a Shape which can be Edge or Face (planar or cylindrical(surface of extrusion or surface of offset)) 
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 memorycostly calculations of presentation are avoided 
CAIS_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 
CAIS_ParallelRelation  A framework to display constraints of parallelism between two or more Interactive Objects. These entities can be faces or edges 
CAIS_PerpendicularRelation  A framework to display constraints of perpendicularity between two or more interactive datums. These datums can be edges or faces 
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_RadiusDimension  Radius dimension. Can be constructued: 
CAIS_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: 
CAIS_RubberBand  Presentation for drawing rubber band selection. It supports rectangle and polygonal selection. It is constructed in 2d overlay. Default configaration 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 nonHLR  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 nonnull 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_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 
CAIS_TangentRelation  A framework to display tangency constraints between two or more Interactive Objects of the datum type. The datums are normally faces or edges 
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 32bit integers instead of classic Quantity_Color values. Interactive selection of triangles and vertices is not yet implemented 
CAIS_Trihedron  Create a selectable trihedron there are 4 modes of selection : mode = 0 to select trihedron ,priority = 1 mode = 1 to select its origin ,priority = 5 mode = 2 to select its axis ,priority = 3 mode = 3 to select its planes ,priority = 2 a trihedron has 1 origin, 3 axes and 3 planes. Warning For the presentation of trihedra, the default unit of length is the millimeter, and the default value for the representation of axes is 10. To modify these dimensions, you must temporarily recover the Drawer. From inside it, you take the aspect in which the values for length are stocked. For trihedra, this is FirstAxisLength from Prs3d_DatumAspect(). Change the values inside this Aspect and recalculate the presentation. If you want to use extended selection modes, different than 0, you should take care of removing of the shapes from the interactive context that has been computed for selection; it might be necessary when you change selection mode. You can use methods Axis, Point, Plane to retrieve the shapes 
CAIS_TypeFilter  Selects Interactive Objects through their types. The filter questions each Interactive Object in local context to determine whether it has an nonnull 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 
Calist  
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 continous 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 threedimensional 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 addd 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 considere the curve is given by its representation S(C2D(u)) If the curve is a curve on 2 surfaces S1 and S2 and C2D1 C2D2 are the two corresponding Pcurve, we considere the curve is given by its representation 1/2(S1(C2D1(u) + S2 (C2D2(u))) 
CApprox_CurvlinFunc  Defines an abstract curve with curvilinear parametrization 
CApprox_Data  
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  
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 do nothing. WARRNING: Do not close display connection manualy! 
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_NeutralWindow  Defines a platformneutral 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_RectangularGrid  
CAspect_Window  Defines a window 
CBinDrivers  
CBinDrivers_DocumentRetrievalDriver  
CBinDrivers_DocumentStorageDriver  Persistent implemention 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 implemention 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_CommentDriver  Attribute Driver 
CBinMDataStd_DirectoryDriver  Directory attribute Driver 
CBinMDataStd_ExpressionDriver  Attribute Driver 
CBinMDataStd_ExtStringArrayDriver  Array of extended string attribute Driver 
CBinMDataStd_ExtStringListDriver  
CBinMDataStd_IntegerArrayDriver  Array of Integer attribute Driver 
CBinMDataStd_IntegerDriver  Integer attribute Driver 
CBinMDataStd_IntegerListDriver  
CBinMDataStd_IntPackedMapDriver  TDataStd_IntPackedMap attribute Driver 
CBinMDataStd_NamedDataDriver  
CBinMDataStd_NameDriver  TDataStd_Name attribute Driver 
CBinMDataStd_NoteBookDriver  NoteBook attribute Driver 
CBinMDataStd_RealArrayDriver  Array of Real attribute Driver 
CBinMDataStd_RealDriver  Real attribute Driver 
CBinMDataStd_RealListDriver  
CBinMDataStd_ReferenceArrayDriver  
CBinMDataStd_ReferenceListDriver  
CBinMDataStd_RelationDriver  Attribute Driver 
CBinMDataStd_TickDriver  Tick attribute driver 
CBinMDataStd_TreeNodeDriver  Attribute Driver 
CBinMDataStd_UAttributeDriver  Attribute Driver 
CBinMDataStd_VariableDriver  Attribute Driver 
CBinMDataXtd  Storage and Retrieval drivers for modelling attributes 
CBinMDataXtd_AxisDriver  Axis attribute Driver 
CBinMDataXtd_ConstraintDriver  Attribute Driver 
CBinMDataXtd_GeometryDriver  Attribute Driver 
CBinMDataXtd_PatternStdDriver  Attribute Driver 
CBinMDataXtd_PlacementDriver  Placement attribute Driver 
CBinMDataXtd_PlaneDriver  Plane attribute Driver 
CBinMDataXtd_PointDriver  Point attribute Driver 
CBinMDataXtd_PositionDriver  Position Attribute Driver 
CBinMDataXtd_PresentationDriver  Presentation Attribute Driver 
CBinMDataXtd_ShapeDriver  Shape attribute 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_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_AreaDriver  
CBinMXCAFDoc_CentroidDriver  
CBinMXCAFDoc_ColorDriver  
CBinMXCAFDoc_ColorToolDriver  
CBinMXCAFDoc_DatumDriver  
CBinMXCAFDoc_DimensionDriver  
CBinMXCAFDoc_DimTolDriver  
CBinMXCAFDoc_DimTolToolDriver  
CBinMXCAFDoc_DocumentToolDriver  
CBinMXCAFDoc_GeomToleranceDriver  
CBinMXCAFDoc_GraphNodeDriver  
CBinMXCAFDoc_LayerToolDriver  
CBinMXCAFDoc_LocationDriver  
CBinMXCAFDoc_MaterialDriver  
CBinMXCAFDoc_MaterialToolDriver  
CBinMXCAFDoc_ShapeToolDriver  
CBinMXCAFDoc_VolumeDriver  
CBinObjMgt_Persistent  Binary persistent representation of an object. Really it is used as a buffer for read/write an object 
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_LocationSet  The class LocationSet stores a set of location in a relocatable state 
CBinTools_ShapeSet  Writes topology in OStream in binary format 
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 trimed 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 exept at the extremitys 
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 
CBiTgte_HCurveOnEdge  
CBiTgte_HCurveOnVertex  
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  
CBlendFunc_ChamfInv  
CBlendFunc_ChAsym  
CBlendFunc_ChAsymInv  
CBlendFunc_ConstRad  
CBlendFunc_ConstRadInv  
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_Ruled  
CBlendFunc_RuledInv  
CBlendFunc_Tensor  Used to store the "gradient of gradient" 
CBnd_B2d  
CBnd_B2f  
CBnd_B3d  
CBnd_B3f  
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 
CBnd_BoundSortBox2d  A tool to compare a 2D bounding box with a set of 2D 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 
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: 
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: 
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 
CBnd_Sphere  This class represents a bounding sphere of a geometric entity (triangle, segment of line or whatever else) 
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  Root interface for algorithms 
CBOPAlgo_ArgumentAnalyzer  Check the validity of argument(s) for Boolean Operations 
CBOPAlgo_BOP  
CBOPAlgo_Builder  
CBOPAlgo_BuilderArea  The root class for algorithms to build faces/solids from set of edges/faces 
CBOPAlgo_BuilderFace  The algorithm to build faces from set of edges 
CBOPAlgo_BuilderShape  Root class for algorithms that has shape as result 
CBOPAlgo_BuilderSolid  The algorithm to build solids from set of faces 
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 shape on selfinterference 
CBOPAlgo_CheckResult  Information about faulty shapes and faulty types can't be processed by Boolean Operations 
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_PaveFiller  
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 three flags used by intersection algorithm 
CBOPAlgo_ShellSplitter  The class provides the splitting of the set of connected faces on separate loops 
CBOPAlgo_Tools  
CBOPAlgo_WireEdgeSet  
CBOPAlgo_WireSplitter  
CBOPCol_Box2DBndTreeSelector  
CBOPCol_BoxBndTreeSelector  
CBOPCol_Cnt  
CBOPCol_ContextCnt  
CBOPCol_ContextFunctor  
CBOPCol_Functor  
CBOPCol_NCVector  
CBOPDS_CommonBlock  The class BOPDS_CommonBlock is to store the information about pave blocks that have geometry coincidence (in terms of a tolerance) with a) other pave block(s) b) face(s) 
CBOPDS_CoupleOfPaveBlocks  
CBOPDS_Curve  The class BOPDS_Curve is to store the information about intersection curve 
CBOPDS_DS  The class BOPDS_DS provides the control the data structure for partition and boolean operation algorithms 
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 subshapes of arguments of an operation (see the class BOPDS_DS) in terms of theirs bounding boxes 2.provides interface to iterare the pairs of intersected subshapes of given type 
CBOPDS_IteratorSI  The class BOPDS_IteratorSI is 1.to compute selfintersections between BRep subshapes 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 subshapes of given type 
CBOPDS_PassKey  The class BOPDS_PassKey is to provide possibility to map objects that have a set of integer IDs as a base 
CBOPDS_PassKeyBoolean  
CBOPDS_PassKeyMapHasher  
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_PaveMapHasher  
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 1.to compute intersections between two subsets of BRep subshapes of arguments of an operation (see the class BOPDS_DS) in terms of theirs bounding boxes 2.provides interface to iterare the pairs of intersected subshapes of given type 
CBOPDS_Tools  The class BOPDS_Tools contains a set auxiliary static functions of the package BOPDS 
CBOPTest  
CBOPTest_DrawableShape  
CBOPTest_Objects  
CBOPTools  
CBOPTools_AlgoTools  
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_ConnexityBlock  
CBOPTools_CoupleOfShape  
CBOPTools_EdgeSet  
CBOPTools_Set  
CBOPTools_SetMapHasher  
CBOPTools_ShapeSet  Implementation of some formal opereations with a set of shapes 
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 carful with some algorithm! 
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_HCompCurve  
CBRepAdaptor_HCurve  
CBRepAdaptor_HCurve2d  
CBRepAdaptor_HSurface  
CBRepAdaptor_Surface  The Surface from BRepAdaptor allows to use a Face of the BRep topology look like a 3D surface 
CBRepAlgo  The BRepAlgo package provides a full range of services to perform Old Boolean Operations in Open CASCADE. Attention: The New Boolean Operation has replaced the Old Boolean Operations algorithm in the BrepAlgoAPI package in Open CASCADE 
CBRepAlgo_AsDes  SD to store descendants and ascendants of Shapes 
CBRepAlgo_BooleanOperation  The abstract class BooleanOperation is the root class of Boolean operations. A BooleanOperation object stores the two shapes in preparation for the Boolean operation specified in one of the classes inheriting from this one. These include: 
CBRepAlgo_BooleanOperations  
CBRepAlgo_Common  Describes functions for performing a topological common operation (Boolean intersection). A Common object provides the framework for: 
CBRepAlgo_Cut  Describes functions for performing a topological cut operation (Boolean subtraction). A Cut object provides the framework for: 
CBRepAlgo_DSAccess  
CBRepAlgo_EdgeConnector  Used by DSAccess to reconstruct an EdgeSet of connected edges. The result produced by MakeBlock is a list of nonstandard TopoDS_wire, which can present connexions of edge of order > 2 in certain vertex. The method IsWire indicates standard/nonstandard character of all wire produced 
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_Fuse  Describes functions for performing a topological fusion operation (Boolean union). A Fuse object provides the framework for: 
CBRepAlgo_Image  Stores link between a shape <S> and a shape <NewS> obtained from <S>. <NewS> is an image of <S> 
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 
CBRepAlgo_Section  Construction of the section lines between two shapes. For this Boolean operation, each face of the first shape is intersected by each face of the second shape. The resulting intersection edges are brought together into a compound object, but not chained or grouped into wires. Computation of the intersection of two Shapes or Surfaces The two parts involved in this Boolean operation may be defined from geometric surfaces: the most common use is the computation of the planar section of a shape. A Section object provides the framework for: 
CBRepAlgo_Tool  
CBRepAlgoAPI_Algo  Root interface for algorithms 
CBRepAlgoAPI_BooleanOperation  The abstract class BooleanOperation is the root class of Boolean Operations (see Overview). Boolean Operations algorithm is divided onto two parts 
CBRepAlgoAPI_BuilderAlgo  The clsss contains API level of General Fuse algorithm 
CBRepAlgoAPI_Check  The class Check provides a diagnostic tool for checking single shape or couple of shapes. Single shape is checking on topological validity, small edges and selfinterference. For couple of shapes added check on validity for boolean operation of given type 
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_Fuse  The class provides Boolean fusion operation between arguments and tools (Boolean Union) 
CBRepAlgoAPI_Section  The algorithm is to build a Secton operation between arguments and tools. The result of Section operation consists of vertices and edges. The result of Section operation contains: 
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 informations (see the Value method) and logical informations 
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: 20150424 Created by: NIKOLAI BUKHALOV Copyright (c) 2015 OPEN CASCADE SAS 
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_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 nonregular curves on the surface. The resulting shell contains all these faces. Construction of a Shell from a nonC2 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 (execpt 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  Class BRepBuilderAPI_VertexInspector derived from NCollection_CellFilter_InspectorXYZ This class define the Inspector interface 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  
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 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_SelfIntersection  Tool class for detection of selfsections 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 subset of potentially overlapped faces 
CBRepExtrema_ShapeProximity  Tool class for shape proximity detection. For two given shapes and given tolerance (offset from the mesh) the algorithm allows to determine whether or not they are overlapped. The algorithm input consists of any shapes which can be decomposed into individual faces (used as basic shape elements). High performance is achieved through the use of existing triangulation of faces. So poly triangulation (with the desired deflection) should already be built. Note that solution is approximate (and corresponds to the deflection used for triangulation) 
CBRepExtrema_SolutionElem  This class is used to store information relative to the minimum distance between two shapes 
CBRepExtrema_TriangleSet  Triangle set corresponding to specific face 
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_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 approximatively 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  NSide 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. This 3 curves will have the same parametrization as the Bissectrice. This class is to be send 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) on the left of spine. The Wire or the Face must be planar 
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 diplacement 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  
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 algorithmes 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 nonadaptive 2D Gauss integration algorithms 
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 : 
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 
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 methos 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 
CBRepLProp  These global functions compute the degree of continuity of a curve built by concatenation of two edges at their junction point 
CBRepLProp_CLProps  
CBRepLProp_CurveTool  
CBRepLProp_SLProps  
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  Constucts links between the Wire or the Face of the explorer and the BasicElts contained in the bisecting locus 
CBRepMesh_Circle  Describes a 2d circle with a size of only 3 Standard_Real numbers instead of gp who needs 7 Standard_Real numbers 
CBRepMesh_CircleInspector  Auxilary class to find circles shot by the given point 
CBRepMesh_CircleTool  Create sort and destroy the circles used in triangulation. 
CBRepMesh_Classifier  Auxilary class contains information about correctness of discretized face and used for classification of points regarding face internals 
CBRepMesh_DataStructureOfDelaun  Describes the data structure necessary for the mesh algorithms in two dimensions plane or on surface by meshing in UV space 
CBRepMesh_Delaun  Compute the Delaunay's triangulation with the algorithm of Watson 
CBRepMesh_DiscretFactory  This class intended to setup / retrieve default triangulation algorithm. 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_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_EdgeTessellator  Auxiliary class implements functionality producing tessellated representation of an edge based on edge geometry 
CBRepMesh_FaceAttribute  Auxiliary class for FastDiscret and FastDiscretFace classes 
►CBRepMesh_FastDiscret  Algorithm to mesh a shape with respect of the frontier the deflection and by option the shared components. 
CBRepMesh_FastDiscretFace  Algorithm to mesh a face with respect of the frontier the deflection and by option the shared components 
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_IEdgeTool  Interface class providing API for edge tessellation tools 
CBRepMesh_IncrementalMesh  Builds the mesh of a shape with respect of their correctly triangulated parts 
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_PairOfPolygon  
CBRepMesh_SelectorOfDataStructureOfDelaun  Describes a selector and an iterator on a selector of components of a mesh 
CBRepMesh_ShapeTool  
CBRepMesh_Triangle  Light weighted structure representing triangle of mesh consisting of oriented links 
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 thir position 
►CBRepMesh_WireChecker  Auxilary class intended to check correctness of discretized face. In particular, checks boundaries of discretized face for self intersections and gaps 
CBRepMesh_WireInterferenceChecker  Auxilary class implementing functionality for checking interference between two discretized wires 
CBRepOffset  
CBRepOffset_Analyse  Analyse of a shape consit to Find the part of edges convex concave tangent 
CBRepOffset_Inter2d  Computes the intersections betwwen edges on a face stores result is SD as AsDes from BRepOffset 
CBRepOffset_Inter3d  Computes the intersection face face in a set of faces Store the result in a SD as AsDes 
CBRepOffset_Interval  
CBRepOffset_MakeLoops  
CBRepOffset_MakeOffset  
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_Tool  
CBRepOffsetAPI_DraftAngle  Taperadding 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 contigous 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. Selfintersections are removed. A MakeEvolved object provides a framework for: 
CBRepOffsetAPI_MakeFilling  NSide 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 <S> and a set of faces {Fi} from <S>, builds a solid composed by two shells closed by the {Fi}. First shell <SS> is composed by all the faces of <S> 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 pipelike 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) 
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 algoritm 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 halfspaces. A halfspace 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 halfspace is located. A halfspace 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 subshapes 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 
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_GTrsfModification  Defines a modification of the geometry by a GTrsf from gp. All methods return True and transform the geometry 
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_Quilt  A Tool to glue faces at common edges and reconstruct shells 
CBRepTools_ReShape  Rebuilds a Shape by making predefined 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 Bspline curve Library 
CBSplCLib_Cache  A cache class for Bezier and Bspline curves 
CBSplCLib_EvaluatorFunction  
CBSplSLib  BSplSLib Bspline surface Library This package provides an implementation of geometric functions for rational and non rational, periodic and non periodic Bspline surface computation 
CBSplSLib_Cache  A cache class for Bezier and Bspline surfaces 
CBSplSLib_EvaluatorFunction  
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 1020% lower in comparison with optimal settings). Note that multiple threads can be used only with thread safe BVH primitive sets 
CBVH_Box  Defines axis aligned bounding box (AABB) based on BVH vectors 
CBVH_Builder  Performs construction of BVH tree using bounding boxes (AABBs) of abstract objects 
CBVH_BuildQueue  Commandqueue for parallel building of BVH nodes 
CBVH_BuildThread  Wrapper for BVH build thread 
CBVH_BuildTool  Tool object to call BVH builder subroutines 
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_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 SAHbased 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_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_QuickSorter  Performs centroidbased sorting of abstract set along the given axis (X  0, Y  1, Z  2) using quick sort 
CBVH_RadixSorter  Performs radix sort of a BVH primitive set using 10bit Morton codes (or 1024 x 1024 x 1024 grid) 
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_Transform  Stores transform properties of geometric object 
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 axisaligned 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, raytracing, searching of nearest objects, and view frustum culling 
CBVH_Triangulation  Triangulation as an example of BVH primitive set 
CCDF  
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_Session  
CCDF_Store  
CCDF_StoreList  
CCDM_Application  
CCDM_COutMessageDriver  AMessageDriver for output to COUT (only ASCII strings) 
CCDM_Document  An applicative document is an instance of a class inheriting CDM_Document. These documents have the following properties: 
CCDM_MessageDriver  
CCDM_MetaData  
CCDM_NullMessageDriver  MessageDriver that writes nowhere 
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 bsplines. 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_HElSpine  
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: 
Ccilist  
Ccllist  
CCocoa_LocalPool  Auxiliary class to create local pool 
CCocoa_Window  This class defines Cocoa window 
Ccomplex  
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 tyhe method IsOnArc return False. Such a point is contains geometrical informations (see the Value method) and logical informations 
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 parameteric 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 Bspline curve. The circle is a Circ2d from package gp and its parametrization is : P (U) = Loc + R * (Cos(U) * Xdir + 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 nonrational Bezier curves into a BSpline curve. A CompBezierCurvesToBSplineCurve object provides a framework for: 
CConvert_CompPolynomialToPoles  Convert a serie of Polynomial NDimensional Curves that are have continuity CM to an NDimensional 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 ndimensional 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 (n1) * (myMaxDegree + 1) * myDimension + (d1) * 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 represent adequatly the function with the required continuity 
CConvert_ConeToBSplineSurface  This algorithm converts a bounded Cone into a rational Bspline surface. The cone a Cone from package gp. Its parametrization is : P (U, V) = Loc + V * Zdir + (R + V*Tan(Ang)) * (Cos(U)*Xdir + 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 semiangle. 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 Bspline surface. The cylinder is a Cylinder from package gp. The parametrization of the cylinder is : P (U, V) = Loc + V * Zdir + Radius * (Xdir*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 (CylinderToBSplineSurface, ConeToBSplineSurface, SphereToBSplineSurface, TorusToBSplineSurface). 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. This data consists of the following: 
CConvert_EllipseToBSplineCurve  This algorithm converts a ellipse into a rational Bspline curve. The ellipse is represented an Elips2d from package gp with the parametrization : P (U) = Loc + (MajorRadius * Cos(U) * Xdir + MinorRadius * 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 Bspline curve. The hyperbola is an Hypr2d from package gp with the parametrization : P (U) = Loc + (MajorRadius * Cosh(U) * Xdir + MinorRadius * 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 Bspline 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 Bspline surface. The sphere is a Sphere from package gp. The parametrization of the sphere is P (U, V) = Loc + Radius * Sin(V) * Zdir + Radius * Cos(V) * (Cos(U)*Xdir + 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 Bspline surface. The torus is a Torus from package gp. The parametrization of the torus is : P (U, V) = Loc + MinorRadius * Sin(V) * Zdir + (MajorRadius+MinorRadius*Cos(V)) * (Cos(U)*Xdir + 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  This package implements functions for basis geometric computation on curves and surfaces. The tolerance criterions used in this package are Resolution from package gp and RealEpsilon from class Real of package Standard 
CCSLib_Class2d  *** Class2d : Low level algorithm for 2d classification this class was moved from package BRepTopAdaptor 
CCSLib_NormalPolyDef  
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 informations concerning hidden lines on a view 
CDBRep_IsoBuilder  Creation of isoparametric curves 
CDDataStd  <>commands for Standard Attributes. 
CDDataStd_DrawDriver  Root class of drivers to build draw variables from TDF_Label. Priority rule to display standard attributes is : 
CDDataStd_DrawPresentation  Draw presentaion of a label of a document 
CDDataStd_TreeBrowser  <>Browses a TreeNode from TDataStd. 
CDDF  Provides facilities to manipulate data framework in a DrawCommands environment 
CDDF_AttributeBrowser  
CDDF_Browser  Browses a data framework from TDF 
CDDF_Data  Encapsulates a data framework from TDF in a drawable object 
CDDF_IOStream  
CDDF_Transaction  This class encapsulates TDF_Transaction 
CDDocStd  This package provides Draw services to test CAF standard documents (see TDocStd package) 
CDDocStd_DrawDocument  <>draw variable for TDocStd_Document. 
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  
Cdoublecomplex  
CDPrsStd  <>commands for presentation based on AIS 
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 interpretor to define Draw commands 
CDraw_Marker2D  
CDraw_Marker3D  
CDraw_Number  To store nummbers 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_SaveAndRestore  
CDraw_Segment2D  
CDraw_Segment3D  
CDraw_Text2D  
CDraw_Text3D  
CDraw_View  
CDraw_Viewer  
CDraw_Window  
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 drawned in the plane XOY 
CDrawTrSurf_Drawable  This class adds to the Drawable3D methods to display Curves and Curves on Surface 
CDrawTrSurf_Point  A drawable point 
CDrawTrSurf_Polygon2D  Used to display a 2d polygon 
CDrawTrSurf_Polygon3D  Used to display a 3d polygon 
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  
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: 
CEvent  
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 nary 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 builtin functions such as Sin,Cos, etc, and by creating variables 
CExprIntrp_GenFct  Implements an interpreter for defining functions. All its functionnalities can be found in class GenExp 
CExprIntrp_GenRel  Implements an interpreter for equations or system of equations made of expressions of package Expr 
CExtrema_CCLocFOfLocECC  
CExtrema_CCLocFOfLocECC2d  
CExtrema_Curve2dTool  
CExtrema_CurveTool  
CExtrema_ECC  
CExtrema_ECC2d  
CExtrema_ELPCOfLocateExtPC  
CExtrema_ELPCOfLocateExtPC2d  
CExtrema_EPCOfELPCOfLocateExtPC  
CExtrema_EPCOfELPCOfLocateExtPC2d  
CExtrema_EPCOfExtPC  
CExtrema_EPCOfExtPC2d  
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_ExtPC  
CExtrema_ExtPC2d  
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_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_GenLocateExtCS  With two close points it calculates the distance between two surfaces. This distance can be a minimum or a maximum 
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_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_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_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_LocateExtPC  
CExtrema_LocateExtPC2d  
CExtrema_LocECC  
CExtrema_LocECC2d  
CExtrema_LocEPCOfLocateExtPC  
CExtrema_LocEPCOfLocateExtPC2d  
CExtrema_PCFOfEPCOfELPCOfLocateExtPC  
CExtrema_PCFOfEPCOfELPCOfLocateExtPC2d  
CExtrema_PCFOfEPCOfExtPC  
CExtrema_PCFOfEPCOfExtPC2d  
CExtrema_PCLocFOfLocEPCOfLocateExtPC  
CExtrema_PCLocFOfLocEPCOfLocateExtPC2d  
CExtrema_POnCurv  
CExtrema_POnCurv2d  
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 
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 twodimensional, 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  Algorithme 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, Flexsion 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 ith basis function of expansion and (') means derivative 
CFEmTool_LinearFlexion  Criterium of LinearFlexion To HermitJacobi elements 
CFEmTool_LinearJerk  Criterion of LinearJerk To HermitJacobi elements 
CFEmTool_LinearTension  Criterium of LinearTension To HermitJacobi 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 
CFont_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 
CFont_BRepTextBuilder  Represents class for applying text formatting 
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_FTLibrary  Wrapper over FT_Library. Provides access to FreeType library 
CFont_Rect  Auxiliary POD structure  2D rectangle definition 
CFont_SystemFont  Structure for store of Font System Information 
CFont_TextFormatter  This class intended to prepare formatted text 
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_MakeArcOfEllipse  Implements construction algorithms for an arc of ellipse in 3D space. The result is a Geom_TrimmedCurve curve. A MakeArcOfEllipse object provides a framework for: 
CGC_MakeArcOfHyperbola  Implements construction algorithms for an arc of hyperbola in 3D space. The result is a Geom_TrimmedCurve curve. A MakeArcOfHyperbola object provides a framework for: 
CGC_MakeArcOfParabola  Implements construction algorithms for an arc of parabola in 3D space. The result is a Geom_TrimmedCurve curve. A MakeArcOfParabola object provides a framework for: 
CGC_MakeCircle  This class implements the following algorithms used to create Cirlec from Geom 
CGC_MakeConicalSurface  This class implements the following algorithms used to create a ConicalSurface from Geom 
CGC_MakeCylindricalSurface  This class implements the following algorithms used to create a CylindricalSurface from Geom 
CGC_MakeEllipse  This class implements construction algorithms for an ellipse in 3D space. The result is a Geom_Ellipse ellipse. A MakeEllipse object provides a framework for: 
CGC_MakeHyperbola  This class implements construction algorithms for a hyperbola in 3D space. The result is a Geom_Hyperbola hyperbola. A MakeHyperbola object provides a framework for: 
CGC_MakeLine  This class implements the following algorithms used to create a Line from Geom 
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_MakePlane  This class implements the following algorithms used to create a Plane from gp 
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_MakeScale  This class implements an elementary construction algorithm for a scaling transformation in 3D space. The result is a Geom_Transformation transformation (a scaling transformation with the center point <Point> and the scaling value <Scale>). A MakeScale object provides a framework for: 
CGC_MakeSegment  Implements construction algorithms for a line segment in 3D space. Makes a segment of Line from the 2 points <P1> and <P2>. The result is a Geom_TrimmedCurve curve. A MakeSegment 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_MakeTrimmedCone  Implements construction algorithms for a trimmed cone limited by two planes orthogonal to its axis. The result is a Geom_RectangularTrimmedSurface surface. A MakeTrimmedCone provides a framework for: 
CGC_MakeTrimmedCylinder  Implements construction algorithms for a trimmed cylinder limited by two planes orthogonal to its axis. The result is a Geom_RectangularTrimmedSurface surface. A MakeTrimmedCylinder provides a framework for: 
CGC_Root  This class implements the common services for all classes of gce which report error 
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 lefthand 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 
CGCE2d_MakeArcOfCircle  Implements construction algorithms for an arc of circle in the plane. The result is a Geom2d_TrimmedCurve curve. A MakeArcOfCircle object provides a framework for: 
CGCE2d_MakeArcOfEllipse  Implements construction algorithms for an arc of ellipse in the plane. The result is a Geom2d_TrimmedCurve curve. A MakeArcOfEllipse object provides a framework for: 
CGCE2d_MakeArcOfHyperbola  Implements construction algorithms for an arc of hyperbola in the plane. The result is a Geom2d_TrimmedCurve curve. A MakeArcOfHyperbola object provides a framework for: 
CGCE2d_MakeArcOfParabola  Implements construction algorithms for an arc of parabola in the plane. The result is a Geom2d_TrimmedCurve curve. A MakeArcOfParabola object provides a framework for: 
CGCE2d_MakeCircle  This class implements the following algorithms used to create Circle from Geom2d 
CGCE2d_MakeEllipse  This class implements the following algorithms used to create Ellipse from Geom2d 
CGCE2d_MakeHyperbola  This class implements the following algorithms used to create Hyperbola from Geom2d 
CGCE2d_MakeLine  This class implements the following algorithms used to create a Line from Geom2d 
CGCE2d_MakeMirror  This class implements elementary construction algorithms for a symmetrical transformation in 2D space about a point or axis. The result is a Geom2d_Transformation transformation. A MakeMirror object provides a framework for: 
CGCE2d_MakeParabola  This class implements the following algorithms used to create Parabola from Geom2d 
CGCE2d_MakeRotation  This class implements an elementary construction algorithm for a rotation in 2D space. The result is a Geom2d_Transformation transformation. A MakeRotation object provides a framework for: 
CGCE2d_MakeScale  This class implements an elementary construction algorithm for a scaling transformation in 2D space. The result is a Geom2d_Transformation transformation. A MakeScale object provides a framework for: 
CGCE2d_MakeSegment  Implements construction algorithms for a line segment in the plane. The result is a Geom2d_TrimmedCurve curve. A MakeSegment object provides a framework for: 
CGCE2d_MakeTranslation  This class implements elementary construction algorithms for a translation in 2D space. The result is a Geom2d_Transformation transformation. A MakeTranslation object provides a framework for: 
CGCE2d_Root  This class implements the common services for all classes of gce which report error 
Cgce_MakeCirc  This class implements the following algorithms used to create Circ from gp 
Cgce_MakeCirc2d  This class implements the following algorithms used to create Circ2d from gp 
Cgce_MakeCone  This class implements the following algorithms used to create a Cone from gp 
Cgce_MakeCylinder  This class implements the following algorithms used to create a Cylinder from gp 
Cgce_MakeDir  This class implements the following algorithms used to create a Dir from gp 
Cgce_MakeDir2d  This class implements the following algorithms used to create a Dir2d from gp 
Cgce_MakeElips  This class implements the following algorithms used to create an ellipse from gp 
Cgce_MakeElips2d  This class implements the following algorithms used to create Elips2d from gp 
Cgce_MakeHypr  This class implements the following algorithms used to create Hyperbola from gp 
Cgce_MakeHypr2d  This class implements the following algorithms used to create a 2d Hyperbola from gp 
Cgce_MakeLin  This class implements the following algorithms used to create a Lin from gp 
Cgce_MakeLin2d  This class implements the following algorithms used to create Lin2d from gp 
Cgce_MakeMirror  This class mplements 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  This class implements the following algorithms used to create Parab from gp. Defines the parabola in the parameterization range : ]infinite, +infinite[ The vertex of the parabola is the "Location" point of the local coordinate system (axis placement) of the parabola 
Cgce_MakeParab2d  This class implements the following algorithms used to create Parab2d from gp. Defines an infinite parabola. An axis placement one axis defines the local cartesian coordinate system ("XAxis") of the parabola. The vertex of the parabola is the "Location" point of the local coordinate system of the parabola. The "XAxis" of the parabola is its axis of symmetry. The "XAxis" is oriented from the vertex of the parabola to the Focus of the parabola. The "YAxis" is parallel to the directrix of the parabola and its "Location" point is the vertex of the parabola. The equation of the parabola in the local coordinate system is Y**2 = (2*P) * X P is the distance between the focus and the directrix of the parabola called Parameter). The focal length F = P/2 is the distance between the vertex and the focus of the parabola 
Cgce_MakePln  This class implements the following algorithms used to create a Plane from gp 
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  This class implements the common services for all classes of gce which report error 
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 minimisation 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. The distribution is defined: 
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. Note: this algorithm is faster than a GCPnts_UniformDeflection algorithm, and is able to work with non"C2" continuous curves. However, it generates more points in the distribution 
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_UniformAbscissa  This class allows to compute a uniform distribution of points on a curve (ie 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 nonrational 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*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: 
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 selfintersect. 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 follow : 
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 
CGeom2dAdaptor_GHCurve  
CGeom2dAdaptor_HCurve  Provides an interface between the services provided by any curve from the package Geom2d and those required of the curve by algorithms, which use it 
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 algorithmes to do the conversion between equivalent geometric entities from package Geom2d. It gives the possibility : . to obtain the Bspline representation of bounded curves. . to split a Bspline curve into several Bspline curves with some constraints of continuity, . to convert a Bspline curve into several Bezier curves or surfaces. All the geometric entities used in this package are bounded. References : . Generating the Bezier Points of Bspline 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 Bsplines (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_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 
CGeom2dEvaluator_Curve  Interface for calculation of values and derivatives for different kinds of curves in 2D. Works both with adaptors and curves 
CGeom2dEvaluator_OffsetCurve  Allows to calculate values and derivatives for offset curves in 2D 
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 independant variables 
CGeom2dGcc_FunctionTanCuCuOnCu  This abstract class describes a set on N Functions of M independant 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): 
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_PCLocFOfTheLocateExtPCOfTheProjPCurOfGInter  
CGeom2dInt_TheCurveLocatorOfTheProjPCurOfGInter  
CGeom2dInt_TheDistBetweenPCurvesOfTheIntPCurvePCurveOfGInter  
CGeom2dInt_TheIntConicCurveOfGInter  
CGeom2dInt_TheIntersectorOfTheIntConicCurveOfGInter  
CGeom2dInt_TheIntPCurvePCurveOfGInter  
CGeom2dInt_TheLocateExtPCOfTheProjPCurOfGInter  
CGeom2dInt_ThePolygon2dOfTheIntPCurvePCurveOfGInter  
CGeom2dInt_TheProjPCurOfGInter  
CGeom2dLProp_CLProps2d  
CGeom2dLProp_CurAndInf2d  An algorithm for computing local properties of a curve. These properties include: 
CGeom2dLProp_Curve2dTool  
CGeom2dLProp_FuncCurExt  Function used to find the extremas of curvature in 2d 
CGeom2dLProp_FuncCurNul  Function used to find the inflections in 2d 
CGeom2dLProp_NumericCurInf2d  Computes the locals extremas of curvature and the inflections of a bounded curve in 2d 
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 righthanded 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 nonrational Bezier curve 
CGeom_BezierSurface  Describes a rational or nonrational 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 Bspline curve can be Uniform or nonuniform Rational or nonrational Periodic or nonperiodic 
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 righthanded 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 righthanded coordinate system (gp_Ax2 object), where: 
CGeom_ConicalSurface  Describes a cone. A cone is defined by the halfangle 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: 
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 righthanded 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 righthanded 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 selfintersect. 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_OsculatingSurface  
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: 
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 algorithmes 
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 
CGeomAdaptor_GHCurve  
CGeomAdaptor_GHSurface  
CGeomAdaptor_HCurve  An interface between the services provided by any curve from the package Geom and those required of the curve by algorithms which use it 
CGeomAdaptor_HSurface  An interface between the services provided by any surface from the package Geom and those required of the surface by algorithms which use it. Provides a surface handled by reference 
CGeomAdaptor_HSurfaceOfLinearExtrusion  
CGeomAdaptor_HSurfaceOfRevolution  
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 
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 
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 
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 Bspline surface the discontinuities are localised at the knot values. Between two knots values the Bspline 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 Bspline functions and Mult the multiplicity of the knot of range Index in the given direction. If for your computation you need to have Bspline surface with a minima of continuity it can be interesting to know between which knot values, a Bspline 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 Bspline 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 nonrational 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 
CGeometryTest  This package provides commands for curves and surface 
CGeomEvaluator_Curve  Interface for calculation of values and derivatives for different kinds of curves in 3D. Works both with adaptors and curves 
CGeomEvaluator_OffsetCurve  Allows to calculate values and derivatives for offset curves in 3D 
CGeomEvaluator_OffsetSurface  Allows to calculate values and derivatives for offset surfaces 
CGeomEvaluator_Surface  Interface for calculation of values and derivatives for different kinds of surfaces. Works both with adaptors and surfaces 
CGeomEvaluator_SurfaceOfExtrusion  Allows to calculate values and derivatives for surfaces of linear extrusion 
CGeomEvaluator_SurfaceOfRevolution  Allows to calculate values and derivatives for surfaces of revolution 
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 an 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 informations 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))) systeme are the same like section shape coordinates in (O,(OX, OY, OZ)) systeme 
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 usefull and desapear soon 
CGeomFill_DiscreteTrihedron  Defined Discrete Trihedron Law. The requirement for path curve is only G1. The result is C0continuous 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 
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_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 knotvector, 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 bulid 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 
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 : wether or not those are reversed 
CGeomLib_CheckBSplineCurve  Checks for the end tangents : wether or not those are reversed regarding the third or n3rd control 
CGeomLib_CheckCurveOnSurface  Computes the max distance between 3Dcurve and 2Dcurve 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 condition 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 responcibility 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_CLProps  
CGeomLProp_CurveTool  
CGeomLProp_SLProps  
CGeomLProp_SurfaceTool  
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 subclass 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 subclass 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_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 subclass 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 subclass 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 subclass 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 ISOIS 1030342 
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 subclass 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 subclass 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 nonpersistent 
Cgp_Ax1  Describes an axis in 3D space. An axis is defined by: 
Cgp_Ax2  Describes a righthanded 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 righthanded ("direct sense") or lefthanded ("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 halfangle 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 nonpersistent transformation in 3D space. This transformation is a general transformation. It can be a Trsf from gp, 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 Trsf2d from package gp, 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 righthanded, 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 nonpersistent 2D cartesian point 
Cgp_Quaternion  Represents operation of rotation in 3d space as queternion 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 nonpersistent 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 nonpersistent transformation in 2D space. The following transformations are implemented : . Translation, Rotation, Scale . Symmetry with respect to a point and a line. Complex transformations can be obtained by combining the previous elementary transformations using the method Multiply. The transformations can be represented as follow : 
Cgp_Vec  Defines a nonpersistent vector in 3D space 
Cgp_Vec2d  Defines a nonpersistent 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 algorithmes 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. It can be an elementary curve from package gp such as 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 (curve, surface, solid, set of points). It is possible to compose the properties of several "compound geometric systems" too 
CGProp_PEquation  A framework to analyze a collection  or cloud 
CGProp_PGProps  A framework for computing the global properties of a set of points. A point mass is attached to each point. The global mass of the system is the sum of each individual mass. By default, the point mass is equal to 1 and the mass of a system composed of N points is equal to N. Warning A framework of this sort provides functions to handle sets of points easily. But, like any GProp_GProps object, by using the Add function, it can theoretically bring together the computed global properties and those of a system more complex than a set of points . The mass of each point and the density of each component of the composed system must be coherent. Note that this coherence cannot be checked. Nonetheless, you are advised to restrict your use of a GProp_PGProps object to a set of points and to create a GProp_GProps object in order to bring together global properties of different systems 
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 (surface of the gp package) 
CGProp_VelGProps  Computes the global properties and the volume of a geometric solid (3D closed region of space) The solid can be elementary(definition in the gp package) 
CGraphic3d_ArrayOfPoints  Contains points array definition 
CGraphic3d_ArrayOfPolygons  Contains polygons array definition 
CGraphic3d_ArrayOfPolylines  Contains polylines array definition 
CGraphic3d_ArrayOfPrimitives  This class furnish services to defined and fill an array of primitives compatible with the use of the OPENGl glDrawArrays() or glDrawElements() functions. NOTE that the main goal of this kind of primitive is to avoid multiple copies of datas between each layer of the software. So the array datas exist only one time and the use of SetXxxxxx() methods enable to change dynamically the aspect of this primitive 
CGraphic3d_ArrayOfQuadrangles  Contains quatrangles array definition 
CGraphic3d_ArrayOfQuadrangleStrips  Contains quadrangles strip array definition 
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_AspectText3d  Creates and updates a group of attributes for text primitives. This group contains the color, font, expansion factor (height/width ratio), and intercharacter space 
CGraphic3d_Attribute  Vertex attribute definition 
CGraphic3d_AxisAspect  Class that stores style for one graduated trihedron axis such as colors, lengths and customization flags. It is used in Graphic3d_GraduatedTrihedron 
CGraphic3d_BoundBuffer  Bounds buffer 
CGraphic3d_BSDF  Describes material's BSDF (Bidirectional Scattering Distribution Function) used for physicallybased 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_Camera  Camera class provides objectoriented approach to setting up projection and orientation properties of 3D view 
CGraphic3d_CameraTile  Class defines the area (Tile) inside a view 
CGraphic3d_CLight  Light definition 
CGraphic3d_ClipPlane  Container for properties describing graphic driver clipping planes. It is up to application to create instances of this class and specify its properties. The instances are passed into graphic driver or other facilities that implement clipping features (e.g. selection). Depending on usage context the class can be used to specify: 
CGraphic3d_CStructure  Lowlevel graphic structure interface 
CGraphic3d_CTexture  
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 "viewdependent") 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_Fresnel  Describes Fresnel reflectance parameters 
CGraphic3d_GraduatedTrihedron  Defines the class of a graduated trihedron. It contains main style parameters for implementation of graduated trihedron 
CGraphic3d_GraphicDriver  This class allows the definition of a graphic driver for 3d interface (currently only OpenGl driver is used) 
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_HighlightStyle  A class for setting up highlight properties, such as: 
CGraphic3d_IndexBuffer  Index buffer 
CGraphic3d_MarkerImage  This class is used to store bitmaps and images for markers rendering. It can convert bitmap texture stored in TColStd_HArray1OfByte 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, Absorbtion 
CGraphic3d_PolygonOffset  Polygon offset parameters 
CGraphic3d_RenderingParams  Helper class to store rendering parameters 
CGraphic3d_SequenceOfHClipPlane  Class defining the sequence of clipping planes 
CGraphic3d_ShaderAttribute  Describes custom vertex shader attribute 
CGraphic3d_ShaderObject  Forward declaration 
CGraphic3d_ShaderProgram  This class is responsible for managing shader programs 
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. Keywords: Structure, StructureManager, Display, Erase, Highlight, UnHighlight, Visible, Priority, Selectable, Visible, Visual, Connection, Ancestors, Descendants, Transformation 
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_Texture1D  This is an abstract class for managing 1D textures 
CGraphic3d_Texture1Dmanual  This class provides the implementation of a manual 1D texture. you MUST provides texture coordinates on your facets if you want to see your texture 
CGraphic3d_Texture1Dsegment  This class provides the implementation of a 1D texture applyable along a segment. You might use the SetSegment() method to set the way the texture is "streched" on facets 
CGraphic3d_Texture2D  This abstract class for managing 2D textures 
CGraphic3d_Texture2Dmanual  This class defined a manual texture 2D facets MUST define texture coordinate if you want to see somethings on 
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_TextureEnv  This class provides environment texture 
CGraphic3d_TextureMap  This is an abstract class for managing texture applyable 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_TransformPers  Class for keeping and computing transformation persistence. Note that instance of this class can not define no transformation persistence Graphic3d_TMF_None  NULL handle should be used for this purpose 
CGraphic3d_UniformValue  Describes specific value of custom uniform variable 
CGraphic3d_UniformValueTypeID  Generates unique type identifier for variable value 
CGraphic3d_UniformValueTypeID< Graphic3d_Vec2 >  
CGraphic3d_UniformValueTypeID< Graphic3d_Vec2i >  
CGraphic3d_UniformValueTypeID< Graphic3d_Vec3 >  
CGraphic3d_UniformValueTypeID< Graphic3d_Vec3i >  
CGraphic3d_UniformValueTypeID< Graphic3d_Vec4 >  
CGraphic3d_UniformValueTypeID< Graphic3d_Vec4i >  
CGraphic3d_UniformValueTypeID< Standard_Integer >  
CGraphic3d_UniformValueTypeID< Standard_ShortReal >  
CGraphic3d_ValueInterface  Interface for generic variable value 
CGraphic3d_Vector  This class allows the creation and update of a 3D vector 
CGraphic3d_Vertex  This class represents a graphical 3D point 
CGraphic3d_ViewAffinity  Structure display state 
CGraphic3d_WorldViewProjState  Helper class for keeping reference on worldviewprojection state. Helpful for synchronizing state of WVP dependent data structures 
CGraphic3d_ZLayerSettings  Structure defines list of ZLayer properties 
CGUID  
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_HeaderRecognizer  Recognizes STEP Standard Header Entities (FileName, FileDescription, FileSchema) 
CHeaderSection_Protocol  Protocol for HeaderSection Entities It requires HeaderSection as a Resource 
CHermit  This is used to reparameterize Rational BSpline Curves so that we can concatenate them later to build C1 Curves It builds and 1Dreparameterizing 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  
CHLRAlgo_Coincidence  The Coincidence class is used in an Inteference to store informations 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 
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 
►CHLRAlgo_PolyHidingData  Data structure of a set of Hiding Triangles 
CHLRAlgo_PolyInternalData  To Update OutLines 
►CHLRAlgo_PolyInternalNode  To Update OutLines 
CHLRAlgo_PolyInternalSegment  To Update OutLines 
►CHLRAlgo_PolyShellData  All the PolyData of a Shell 
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_CLProps  
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 
CHLRBRep_LineTool  The LineTool class provides class methods to access the methodes of the Line 
CHLRBRep_MyImpParToolOfTheIntersectorOfTheIntConicCurveOfCInter  
CHLRBRep_PCLocFOfTheLocateExtPCOfTheProjPCurOfCInter  
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_SLProps  
CHLRBRep_SLPropsATool  
CHLRBRep_Surface  
CHLRBRep_SurfaceTool  
CHLRBRep_TheCSFunctionOfInterCSurf  
CHLRBRep_TheCurveLocatorOfTheProjPCurOfCInter  
CHLRBRep_TheDistBetweenPCurvesOfTheIntPCurvePCurveOfCInter  
CHLRBRep_TheExactInterCSurf  
CHLRBRep_TheIntConicCurveOfCInter  
CHLRBRep_TheInterferenceOfInterCSurf  
CHLRBRep_TheIntersectorOfTheIntConicCurveOfCInter  
CHLRBRep_TheIntPCurvePCurveOfCInter  
CHLRBRep_TheLocateExtPCOfTheProjPCurOfCInter  
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  
Cicilist  
CIFGraph_AllConnected  This class gives content of the CONNECTED COMPONANT(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 subpart An Articulation Point divides the graph in two (or more) disconnected subgraphs Identifying Articulation Points allows improving efficiency of spliting a set of Entities into subsets 
CIFGraph_Compare  This class evaluates effect of two compared subparts : cumulation (union), common part (intersectionoverlapping) part specific to first subpart 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 Componants in a Graph. They define disjoined sets of Entities 
CIFGraph_Cumulate  This class evaluates effect of cumulated subparts : 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 componants in a graph which are Cycles 
CIFGraph_ExternalSources  This class gives entities which are Source of entities of a subpart, but are not contained by this subpart 
CIFGraph_SCRoots  Determines strong componants in a graph which are Roots 
CIFGraph_StrongComponants  Determines strong componants of a graph, that is isolated entities (single componants) 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 subparts, identified by each class (according to its algorithm) Internal Iteration concerns Entities of a subpart SubParts 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 (optionnal) : 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 informations used by Model Modifiers apart from the target model itself, and the CopyTool which must be passed directly 
CIFSelect_ContextWrite  This class gathers various informations 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 subset 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 readonly or readwrite 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 splitted 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, accoding 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 subentities as one per Item, or several (for instance if an Entity binds couples of subentities, 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 : subclasses 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 sublist of Input list (for more specific, see SelectExtract for filtered sublists, 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 controled 
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 sublist 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 independant 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 subset 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 Componants, local roots of a set of Entities : they can be Single Componants (containing one Entity) or Cycles This class gives a more secure result than SelectRoots (which considers only Single Componants) 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 Componants 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 dependances) 
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 interprete and run them 
CIFSelect_ShareOut  This class gathers the informations 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 subitems separated by sets of 3 blanks It is possible to define tabulations between subitems 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 recommanded 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 <02> 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 highlevel 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); Standard_Boolean colormode = reader.GetColorMode(); Layers reader.SetLayerMode(layermode); Standard_Boolean layermode = reader.GetLayerMode(); Names reader.SetNameMode(namemode); Standard_Boolean 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); Standard_Boolean colormode = writer.GetColorMode(); Layers writer.SetLayerMode(layermode); Standard_Boolean layermode = writer.GetLayerMode(); Names writer.SetNameMode(namemode); Standard_Boolean namemode = writer.GetNameMode(); 
CIGESControl_ActorWrite  Actor to write Shape to IGES 
CIGESControl_AlgoContainer  
CIGESControl_Controller  Controller for IGES5.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 Standard_True or Standard_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 Standard_True or Standard_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 componant which can be either undefined (let Void), defined as a Reference to an entity, or as a Rank, integer value adressing 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  Litteral/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 subsets (or the complete set) of the IGES Norm, such as Solid + Draw (which are normally independant), 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 IGES5.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 (optionnal) 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 correspondant 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 treatement of IGESModel and Recognition of UndefinedFreeFormatEntity 
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 occurence 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 accomodate 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 <2021> 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 <08, 100200, 105> in package IGESDimen Used for formatting boxed text in different ways 
CIGESDimen_GeneralSymbol  Defines General Symbol, Type <228>, Form <03,50019999> 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 <112> 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 <3138> 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 Xaxis 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 BRep 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 <05> in package IGESGeom A parametric equation obtained by dividing two summations involving weights (which are real numbers), the control points, and BSpline basis functions 
CIGESGeom_BSplineSurface  Defines IGESBSplineSurface, Type <128> Form <09> in package IGESGeom A parametric equation obtained by dividing two summations involving weights (which are real numbers), the control points, and BSpline 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 <03> 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 <13,1113,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 nonzero vector in Euclidean 3space 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 nonzero 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 <01> 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 Bsplines, 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, WilsonFowler, Modified WilsonFowler, BSpline. 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, WilsonFowler, Modified WilsonFowler, BSpline 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 Bspline 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 threerow 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 Cprintf 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, "WhithoutBackP" 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 thr 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 Independant 1 Physically Dependant 2 Logically Dependant 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 BRep 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 postorder 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 semiangle 
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 IGES5.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 translatin 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 trans 