| abs_law | Provides methods for the ABS mathematical function |
| acis_ha_part_entity_mgr | Concrete entity manager class for ACIS Assembly Modeling with the Scheme example application |
| acis_ha_part_entity_mgr_factory | Concrete entity manager factory class for creating acis_scm_entity_mgr objects |
| acis_handle_base | Represents an abstract handle to any ACIS operation, its inputs or its output |
| ACIS_OBJECT | Provides a base class for class level memory management of ACIS classes |
| acis_pm_entity_mgr | Concrete entity manager class for using the ACIS Part Management component in conjunction with ACIS Assembly Modeling |
| acis_pm_entity_mgr_factory | Concrete entity manager factory class for creating acis_pm_entity_mgr objects |
| acis_scm_entity_mgr | Concrete entity manager class for ACIS Assembly Modeling with the Scheme example application |
| acis_scm_entity_mgr_factory | Concrete entity manager factory class for creating acis_scm_entity_mgr objects |
| AcisJournal | Contains data and methods related to journaling operation |
| AcisLoftingInterface | Passes data from one interactive lofting API function to the next and controls the execution of the interactive lofting operation |
| AcisOptions | Implements an AcisOptions class |
| AcisSkinningInterface | Passes data from one interactive skinning API function to the next and controls the execution of the interactive skinning operation |
| AcisSLInterface | Abstract base class that defines the interactive skinning and lofting interfaces |
| AcisVersion | Creates an AcisVersion object |
| acovr_edge_constraint | Defines an edge constraint for advanced covering |
| acovr_gap_report | Boundary gap reporting |
| acovr_options | Options for covering with advanced covering |
| active_part | Declares a class to monitor the active part |
| ADM_draw_engine | Overrides the base class for the drawing engine |
| ADM_gidraw_engine | This class provides provides a concrete ADM_draw_engine for drawing ADM_default_icons with the ACIS GI kernel |
| ADM_giicon_draw_args | This class provides concrete draw arguments for drawing ADM_default_icons with the ACIS GI kernel |
| ADM_giregobj | This class provides a concrete ADM_regobj to the ADM kernel |
| ADM_giregobj_factory | This class provides a concrete ADM_regobj_factory to the ADM kernel, allowing the creation of concrete ADM_regobj objects |
| ADM_hoops_icon_factory | This is an example of the icon class factory implementation |
| ADM_hoopsregobj | This class provides a concrete ADM_regobj to the ADM kernel |
| ADM_hoopsregobj_factory | This class provides a concrete ADM_regobj_factory to the ADM kernel, allowing the creation of concrete ADM_regobj objects |
| adm_options | Class to override the AcisOptions algorithmic versioning for specific adm behaviors - use of boundary loads, and automatic surface trimming |
| ADM_regobj | Provides abstract registration methods to the kernel, allowing a deformable modeling hierarchy to register with the view controller |
| ADM_regobj_factory | This is used by the ACIS Deformable Modeling kernel to construct and destruct ADM_regobj objects |
| ADM_regobj_factory_mgr | Manages the singleton DM_regobj_factory providing global access to the unique instance |
| ADM_srf_icon | This class is used for drawing deformable surface tag objects in ACIS deformable modeling |
| ADM_srf_icon2 | This class is used for drawing deformable surface tag objects in ACIS deformable modeling |
| ADM_srf_icon3 | This class is used for drawing deformable surface tag objects in ACIS deformable modeling |
| ADMHOOPS_draw_engine | This class provides provides a concrete DM_draw_engine for drawing DM_default_icons with Hoops |
| ADMHOOPS_icon_draw_args | This class provides concrete draw arguments for drawing DM_default_icons with the HOOPS kernel |
| AF_POINT | AF_POINT is an element in a circular, doubly linked list, used when approximating a curve with a consecutive series of points |
| af_serializable_mesh | Provides a base class for meshes which can convert themselves into a form that is immediately digestable by visualization systems |
| align_options | Interface class for modifying the behavior of api_align |
| and_law | Provides methods for the AND boolean function |
| ANNOTATION | Defines a base class for adding information to the bulletin boards |
| APATTERN | |
| APOINT | Represents the position of a point as an object in the model |
| arccos_law | Provides methods for the ARCCOSINE mathematical function |
| arccosh_law | Provides methods for the ARCCOSH (Hyperbolic Arccosine) mathematical function |
| arccot_law | Provides methods for the ARCCOTANGENT mathematical function |
| arccoth_law | Provides methods for the ARCCOTH mathematical function |
| arccsc_law | Provides methods for the ARCCOSECANT mathematical function |
| arccsch_law | Provides methods for the ARCCOSECH mathematical function |
| arcsec_law | Provides methods for the ARCSECANT mathematical function |
| arcsech_law | Provides methods for the ARCSECH mathematical function |
| arcsin_law | Provides methods for the ARCSINE mathematical function |
| arcsinh_law | Provides methods for the ARCSINH (Hyperbolic Arcsine) mathematical function |
| arctan_law | Provides methods for the ARCTANGENT mathematical function |
| arctanh_law | Provides methods for the ARCTANH (Hyperbolic Arc Tangent) mathematical function |
| ASM_ASSEMBLY | Assembly Entity |
| asm_cleanup_options | Class object to encapsulate requests for optional behaviors when cleaning up handle objects |
| asm_get_options | Provides a data structure for passing optional arguments to assembly modeling "get" commands |
| asm_list_options | Class object to encapsulate requests for optional behaviors of assembly modeling list objects |
| asm_model | Class object to represent an assembly or part model within assembly modeling |
| asm_model_entity_mgr | Interface class to wrap customer "part model" and "assembly model" objects |
| asm_model_holder | Holds a pointer to an asm_model |
| asm_model_info | Structure to contain information about an assembly modeling model |
| asm_model_kern | Use-counted base class for asm_model |
| asm_model_list | Implements a variable length list of assembly models with set and index behavior and optional holding and counting mechanisms |
| ASM_MODEL_REF | Assembly model reference |
| asm_restore_options | |
| asm_save_options | Options object for asmi_save_model_list() |
| asmi_model_save_entities_options | Specifies options for using asmi_model_save_entities |
| ATT_BL_INST | Defines the instruction attributes that hang onto the edges and vertices of a blend sequence, that instruct the blend algorithm |
| ATT_CAP_FACE | Attribute to be attached to a cap face, to record the blank body which was used to generate the non-univex capping solution |
| ATTRIB | Represents common data and functionality for all attributes |
| ATTRIB_AGC | Designates to whom the attribute belongs |
| ATTRIB_ANNOTATION | Attaches an annotation to an entity |
| ATTRIB_BLEND | Defines the basic blend attribute from which derive specific blend attributes |
| ATTRIB_BLINFO | Defines attributes used internally by the blending algorithm to record intermediate results |
| ATTRIB_CELL | Implements an attribute pointing to a list of cells belonging to a lump |
| ATTRIB_CELL_INT_PRECEDENCE | Specifies the precedence associated with a 2D or 3D cell |
| ATTRIB_CELL_PRECEDENCE | Specifies the precedence associated with a 2D or 3D cell |
| ATTRIB_CFACE_VOL | Implements an attribute attached to a CFACE entity |
| ATTRIB_COL | Stores color information for an ENTITY |
| ATTRIB_CONST_CHAMFER | Defines a flat chamfer blend |
| ATTRIB_CONST_ROUND | Defines a circular rolling-ball blend of constant radius |
| ATTRIB_CT | Defines a root attribute for the Cellular Topology Component |
| ATTRIB_DC2ACIS | Connects the deformable curve functions to the ACIS modeler |
| ATTRIB_DM2ACIS | Connects the deformable model functions to the ACIS modeler |
| ATTRIB_DS2ACIS | Connects the deformable surface functions to the ACIS modeler |
| ATTRIB_EFINT | Defines an attribute to record the intersections of an edge of one body with a face of the other body, during a Boolean operation |
| ATTRIB_EYE | Defines the organization attribute class for the Faceter Component |
| ATTRIB_EYE_ATTACHED_MESH | Defines an attribute to attach facets to an entity as a MESH |
| ATTRIB_EYE_POINTLIST_HEADER | Stores the edge facets between faceter calls |
| ATTRIB_FACECFACE | Defines an attribute that records one or two CFACE entities that refer to a given face |
| ATTRIB_FACEINT | Defines an attribute to record the intersection of a face of one body with a face of the other body during a Boolean operation |
| ATTRIB_FFBLEND | Defines a general face-face blend |
| ATTRIB_GEN_ENTITY | Defines a generic attribute that "owns" an entity |
| ATTRIB_GEN_INTEGER | Defines a generic attribute that contains an integer value |
| ATTRIB_GEN_NAME | Defines a named attribute for the Generic Attributes Component |
| ATTRIB_GEN_POINTER | Defines a generic attribute that contains a reference to an entity |
| ATTRIB_GEN_POSITION | Defines a generic attribute that contains a position |
| ATTRIB_GEN_REAL | Defines a generic attribute that contains a real (double) value |
| ATTRIB_GEN_STRING | Defines a generic attribute that contains a string value |
| ATTRIB_GEN_VECTOR | Defines a generic attribute that contains a vector |
| ATTRIB_GEN_WSTRING | Defines a generic attribute that contains a wide character string value |
| ATTRIB_GENERIC | Defines the organization attribute class for the Generic Attributes Component |
| ATTRIB_IHL | Defines the organization attribute class for the Interactive Hidden Line Component (IHL) |
| ATTRIB_IHL_VW | Defines an attribute that attaches viewing information and hidden line data to an entity |
| ATTRIB_INTCOED | Defines an attribute for linking intersection graph entities with the relevant body entities |
| ATTRIB_INTEDGE | Defines an attribute for linking intersection edges with the intersecting entities |
| ATTRIB_INTGRAPH | Defines an attribute for classifying shells and lumps of two bodies participating in a Boolean operation |
| ATTRIB_INTVERT | Defines an attribute for linking graph vertices with the intersection record(s) giving rise to them |
| ATTRIB_RGB | Stores rgb color information for an ENTITY |
| ATTRIB_ST | Organization attribute from which various color, display, id, and other attributes are derived |
| ATTRIB_SYS | Organization base attribute class for the ACIS kernel |
| ATTRIB_TAG | Defines a base class that contains a pointer to the original input entity as well as a flag indicating if the entity still exists |
| ATTRIB_TSL | This C++ destructor should never be called directly |
| ATTRIB_VAR_BLEND | Defines the blend attribute for variable radius blends |
| ATTRIB_VBLEND | Defines the vertex blend attribute |
| ATTRIB_VOL_COL | Assigns a color to a volumetric region; that is, a three-dimensional cell |
| base_configuration | The base configuration object |
| base_curve_law_data | Abstract base class for accessing a curve_law_data with or without the ACIS kernel |
| base_pcurve_law_data | Abstract base class for accessing a pcurve_law_data with or without the ACIS kernel |
| base_pointer_map | This class tracks reference counting of sub-objects used in making a deep copy |
| base_surface_law_data | Abstract base class for accessing a surface_law_data with or without the ACIS kernel |
| BASE_TAG_MANAGER | An abstract base class that defines the entity reference tag management system interface |
| base_transform_law_data | Abstract base class for accessing transform_law_data with or without the ACIS kernel |
| base_wire_law_data | Abstract base class for accessing a wire_law_data with or without the ACIS kernel |
| bend_law | Creates a law to bend from a position around an axis in a given direction a specified amount |
| binary_law | Provides methods and data for laws that have two sublaws |
| BinaryFile | Defines the BinaryFile class for doing ACIS save and restore to binary files |
| blend1_data | Implementation of common data for stage one of blending |
| BLEND_ANNO_EDGE | Implements the annotations for blended edges |
| BLEND_ANNO_ENTITY | Implements annotation for blend |
| BLEND_ANNO_VERTEX | Implements the annotations for blended vertices |
| BLEND_ANNO_VERTEX_CHAMFER | Implements the annotations for chamfered vertices |
| BLEND_ANNOTATION | Implements the base class for blending annotations |
| blend_contact | Information about the contact point of the blend for a blend cross section |
| blend_spl_sur | Provides common functionality and data for all blend surfaces |
| BODY | Represents a wire, sheet, or solid body |
| body_clash_result | Data structure used to encapsulate the details of how two bodies clash |
| boolean_output_handle | Represents an abstract handle to the output from a Boolean operation |
| BoolOptions | Class to hold information and options for a Boolean operation |
| bounded_arc | Defines a bounded_arc as a subtype of a bounded_curve |
| bounded_curve | Defines a bounded curve |
| bounded_line | Defines a bounded_line as a subtype of bounded_curve |
| box_selector | Selects all points of a cloud within a box |
| bs3_surface_law | The bs3_surface_law's return the SPAposition of the spline approximating surface at the u,v parameters |
| BULLETIN | Describes a record of the changes to a single ENTITY during the current operation on the model |
| BULLETIN_BOARD | Contains a list of BULLETINS recording changes to ENTITYs during the current operation on the model |
| BULLETIN_LIST | Implements a variable length list of bulletins |
| CATTessPointPolyIter | Class defining the iterator on the points resulting from a Tessellation operator |
| ceil_law | Provides methods for the CEILING mathematical function |
| CELL | Represents an n-dimensional cell, representing an n-dimensional manifold |
| CELL2D | Represents a two-dimensional cell, consisting of one or more sheet faces |
| CELL3D | Represents a three-dimensional cell, whose interior is a connected, 3-manifold (i.e.,volumetric) region |
| CFACE | A reference to one side of a FACE |
| chamfer_wire_options | Set specific options for api_chamfer_wire_vertex Limitations: Not implemented yet |
| check_bad_fitol_details | A class for returning details of a check status error |
| check_high_curvature_details | |
| check_self_intersection_details | A class for returning details of a check status error |
| check_status_details | A class for returning details of a check status error |
| check_status_list | Implements the list of return codes for status checking |
| closest_point_selector | Selects the closest points to a test point from a cloud |
| COEDGE | Relates EDGEs to adjacent EDGEs and to owning ENTITYs |
| complex_number | Creates a data structure for the manipulation of complex number |
| component_entity_handle | Assembly modeling proxy for the occurrence of an ENTITY within an assembly component |
| component_entity_handle_holder | Holds a pointer to a component_entity_handle |
| component_entity_handle_list | Implements a variable length list of component entity handles with set and index behavior and optional holding and counting mechanisms |
| component_handle | Assembly modeling proxy for an assembly component |
| component_handle_holder | Holds a pointer to an component_handle |
| component_handle_list | Implements a variable length list of component handles with set and index behavior and optional holding and counting mechanisms |
| composite_law | Constructs the composition of two functions |
| cone | Defines the elliptical single cone |
| CONE | Defines a cone as an object in the model |
| constant_law | Creates a law that is constant |
| convert_to_spline_options | Defines a class for specifying options used in spline-conversion operations |
| COPY_ANNOTATION | Defines the annotation class for the copy operation |
| cos_law | Provides methods for the COSINE mathematical function |
| cosh_law | Provides methods for the COSH (Hyperbolic Cosine) mathematical function |
| cot_law | Provides methods for the COTANGENT mathematical function |
| coth_law | Provides methods for the COTH (Hyperbolic Cotangent) mathematical function |
| cover_options | The cover_options object is used to control behavior of the covering API functions, including: api_cover_circuits, api_cover_sheet, and api_cover_wires |
| cross_law | Provides methods for the cross product mathematical function |
| csc_law | Provides methods for the COSECANT mathematical function |
| csch_law | Provides methods for the COSECH (Hyperbolic Cosecant) mathematical function |
| CSHELL | Represents one portion of a 3D cell's boundary |
| curvature_error_info | Error information from an offset surface operation |
| curvature_law | This law returns the curvature of the path sub law It is not defined for x's where the path sub law's derivative is undefined |
| curve | Provides methods and data common to all curve subclasses |
| CURVE | Defines a generic curve as an object in the model |
| curve_bounds | Specifies the curve bounds of interest |
| curve_curve_int | Represents the intersection of a curve with another curve and returns the intersections as a list |
| curve_curve_userdata | Provides a hook for a client intersector to attach private information to an intersection |
| curve_interp | Contains arrays to be interpolated and the information necessary for the interpolation |
| curve_irregularities | Implements a linked list of parameter values at which a curve has a C1 or G1 discontinuity |
| curve_law | Returns the position on a curve when evaluated |
| curve_law_data | Serves as a wrapper for an ACIS curve object |
| curve_surf_int | Represents the intersection of a curve with a surface and returns the intersections as a list |
| curve_surf_userdata | Provides a hook for a client intersector to attach private information to an intersection |
| curveclosest_law | Curve closest point |
| curveperp_law | Curve point perp |
| cvty | Class representing the convexity at a point or along a single edge (or something equivalent), such as "convex", or "tangent_convex" |
| dbend_law | The derivative of the bend law for space warps |
| dcurve_law | Returns a position or one of the derivatives on a curve |
| DEBUG_LIST | Defines a simple list pointer, which allows all active lists to be scanned |
| default_entity_mgr | Concrete entity manager class that simply wraps an ENTITY_LIST |
| default_entity_mgr_factory | Concrete entity manager factory class for creating default_entity_mgr objects |
| defeature_options | Options for local operations |
| DELTA_STATE | Contains a sequence of bulletin boards |
| DELTA_STATE_LIST | Implements a variable length list of delta states |
| derivative_law | Derivative law |
| detect_blend_options | Options for blend detection |
| detect_feature_options | Options for feature detection and blend detection |
| discontinuity_info | Stores discontinuity information for a curve or surface |
| division_law | Provides methods for the division mathematical function |
| DM_act_icon | This class is used for drawing area constraint tag objects in deformable modeling |
| DM_ald_icon | This class is used for drawing area load tag objects in deformable modeling |
| DM_att_icon | This class is used for drawing point attractor tag objects in deformable modeling |
| DM_cct_icon | This class is used for drawing curve constraint tag objects in deformable modeling |
| DM_cld_icon | This class is used for drawing curve load tag objects in deformable modeling |
| DM_cpt_icon | The DM_cpt_icon draws an array of control points |
| DM_crv_icon | This class is used for drawing deformable curve tag objects in deformable modeling |
| DM_dbl_array | This class is a pseudo-read-only container class for double type supporting deformable modeling geometry query methods |
| DM_dbx_icon | The DM_dbx_icon draws and manages an outline corresponding to the image of a parameter sub-rectangle on a deformable surface |
| DM_def_icon_cmd_args | This class provides an abstract interface (an Execute method) to the DM_default_icons for encapsulating state change commands |
| DM_def_icon_draw_args | This class provides an abstract interface for passing arguments to the Draw() methods of the DM default icons supplied in the dmicon library |
| DM_def_icon_query_args | This class provides an abstract interface to the DM_default_icons for encapsulating query commands |
| DM_default_icon | Base class for the icon objects in the dmicon and admicon libraries |
| DM_default_icon_factory | This is an example of the icon class factory implementation |
| DM_dpr_icon | This class is used for drawing distributed pressure tag objects in deformable modeling |
| DM_draw_engine | This class provides an abstract draw primitive interface between the deformable modeling icons and the view-controller |
| DM_draw_engine_mgr | This class manages the singleton |
| DM_grd_icon | This class draws and manages a rectangular grid of lines |
| DM_ica_draw_option | This class is a DM_def_icon_cmd_args that encapsulates a command to set a DM_default_icon draw options |
| DM_ica_grid | This class is a DM_def_icon_cmd_args that encapsulates a command to set a DM_default_icon draw grid density |
| DM_ica_on_off | This class is a DM_def_icon_cmd_args that encapsulates a command to switch an icon on or off (draw or don't draw) |
| DM_ica_width | This class is a DM_def_icon_cmd_args that encapsulates a command to set a DM_default_icon draw width |
| DM_icon | This class provides abstract notify methods to the deformable modeling kernel for drawing services |
| DM_icon_cmd_args | This interface class provides a command object to forward client requests through the DM_icon::Set_state method to the DM_icon |
| DM_icon_draw_args | This interface class provides an encapsulation mechanism for passing arguments to the DM_icon::Draw method |
| DM_icon_factory | The DM_icon_factory class provides an abstract interface to the deformable modeling kernel for creating and destroying DM_icon objects |
| DM_icon_factory_mgr | This class manages the singleton DM_icon_factory, providing global access to the unique instance |
| DM_icon_query_args | This interface class encapsulates queries that can be sent to DM_icon objects |
| DM_icq_draw_grid | This class is a DM_def_icon_query_args that encapsulates a command to query DM_default_icon draw grid density |
| DM_icq_draw_option | This class is a DM_def_icon_query_args that encapsulates a command to query DM_default_icon draw options |
| DM_lct_icon | This class is used for drawing curve link constraint tag objects in deformable modeling |
| DM_lld_icon | This class is used for drawing curve link load tag objects in deformable modeling |
| DM_pct_icon | This class is used for drawing point constraint tag objects in deformable modeling |
| DM_ppr_icon | This class is used for drawing point pressure tag objects in deformable modeling |
| DM_rend_options | This class is used internally by the dmicon library for encapsulating draw options |
| DM_rtnerr_hurler | This class provides a protocol for handling exceptions across interfaces |
| DM_spr_icon | This class is used for drawing point spring load tag objects in deformable modeling |
| DM_sps_icon | This class is used for drawing point spring set load tag objects in deformable modeling |
| DM_srf_icon | This class is used for drawing deformable surface tag objects in standalone deformable modeling |
| DM_syserr_hurler | This class provides a protocol for handling exceptions across interfaces |
| DM_tag_array | The DM_tag_array class supports tag query methods and icon broadcast methods |
| DM_vec_icon | This class is used for drawing vector load tag objects in deformable modeling |
| domain_law | Domain law |
| dot_law | Provides methods for the dot product mathematical function |
| dpcurve_law | This law is the same as pcurve_law with an extra law_data field that holds how many derivatives to take |
| DS_crv_cstrn | DS_CSTRN_SRC delete stop src_ src_CW comment |
| DS_dmod | Pointer to this class acts as an handle |
| DS_pfunc | Pointer to this class acts as an handle |
| DS_poly_zone | The DS_poly_zone is used for building a DS_area_load |
| DS_zone | Pointer to this class acts as an handle |
| dsurface_law | This law is the same as surface_law with an extra law_data field that holds how many derivatives to take |
| dwire_law | This law is the same as wire_law with an extra law_data field that holds how many derivatives to take |
| e_law | Constant law with e (Eulers Constant) |
| ed_cvty_info | Returns the convexity of an edge (or equivalent) |
| EDGE | Represents a physical edge |
| edge_entity_rel | Represents the relationship between an EDGE and an ENTITY |
| edge_face_int | Records information about edge-face intersections |
| edge_tolstitch_options | Specifies that api_stitch should use restricted tolerant stitching |
| EE_LIST | Defines a wrapper for ENTITY_LIST that is an ENTITY, with full support for save/restore and rollback |
| ellipse | Defines an ellipse curve |
| ELLIPSE | Defines an ellipse as an object in the model |
| ENTITY | Represents common data and functionality that is mandatory in all classes that are permanent objects in the model |
| entity_and_filter | Returns TRUE if both of its two child filters return TRUE |
| entity_binary_filter | Combines entity_and_filter and entity_or_filter classes |
| entity_callback | Provides notification of changes to entities |
| entity_callback_list | Provides a type-safe interface to the toolkit_callback_list class and the execute command |
| entity_clash_pair | This class holds the result of clash-testing a pair of EDGE or FACE entities |
| entity_error_info_legacy | |
| entity_filter | Provides generic methods and data for all filters |
| entity_gvertex | Creates an instance of a graph vertex that holds an entity pointer as data |
| entity_handle | Assembly modeling proxy for an ENTITY object |
| entity_handle_holder | Holds a pointer to an entity_handle |
| entity_handle_list | Implements a variable length list of entity handles with set and index behavior and optional holding and counting mechanisms |
| entity_hit | Represents an intersection of a ray with a face, edge, or vertex |
| entity_hit_list | Represents a variable length, read-only list of entity_hit objects |
| ENTITY_IHL | Defines organizational class for all IHL entity classes |
| ENTITY_LIST | Implements a variable length list of entities with set and index behavior |
| entity_mgr_factory | Abstract class from which customers derive factory objects to create entity manager sub-class objects |
| entity_not_filter | Returns TRUE if and only if its child filter returns FALSE, and vice versa |
| entity_notification_handler | Allows an application to notify its sub-systems of ENTITY events |
| entity_or_filter | Returns TRUE if either of its two child filters returns TRUE |
| ENTITY_PHL | Defines owning organization for other PHL entity classes |
| ENTITY_PHLV5 | Defines owning organization for other PHL entity classes |
| entity_test_filter | Returns TRUE if the given C++ test function returns TRUE |
| entity_with_ray | Combines an ENTITY and a pick_ray |
| enum_entry | Structure defining a pair of value/string and used in the enum_table class |
| enum_table | Defines objects for storing the mapping between the enum values and their string representation |
| equal_law | Provides methods for the equal boolean function |
| ERROR_ENTITY | Stores information about improper intersections in an ENTITY |
| error_info | Class for storing entity-based ACIS error information |
| error_info_base | Defines objects for returning ACIS error information |
| error_info_base_list | Acts as a collection class for error_info_base objects, that is, it implements a variable length list of error_info_base objects |
| error_info_list | Acts as a collection class for error_info objects, that is, it implements a variable length list of error_info objects |
| error_list_info | Chains a list of error_info_base objects together |
| even_law | Provides methods for the even value than boolean function |
| exact_int_cur | Represents an exact intersection spline curve |
| exact_stitch_options | Specifies that api_stitch should use exact stitching |
| exit_callback | Executes standard exit for ACIS |
| exp_law | Provides methods for the EXP mathematical function |
| exponent_law | Provides methods for the exponent mathematical function |
| FACE | Represents a bounded portion of a SURFACE |
| facet_options | Interface class for representing user-specified faceting requirements |
| facet_options_expert | A facet-options class that is appropriate to workflows demanding the maximum control over faceting |
| facet_options_precise | A facet-options class that is appropriate to workflows demanding precise meshes |
| facet_options_visualization | A facet-options class that is appropriate to workflows demanding efficient visualization |
| false_law | False law |
| ff_header | Enables lists of face-face intersections to be chained together |
| FileInfo | Contains additional required file header information |
| FileInterface | Defines an abstract base class for saving and restoring ACIS ENTITY data |
| floor_law | Provides methods for the FLOOR mathematical function |
| frenet_law | Describes a vector field for a given curve that points in the direction of curvature |
| GA_bridge_options | Options object to allow control of the GGCM ACIS bridge functions |
| GA_soft_fix_data | Support data structure that holds Soft Fixing information (ie |
| GA_WORKSPACE | Constraint manager instance object to solve problem consisting of a set of constraints |
| gaussian_curvature_law | The gaussian_curvature_law's return the Gaussian curvature at the u,v coordinates of the surface |
| GC_Object | Virtual class from which objects which have pointers to objects which are allocated off the heap can be derived |
| gedge | Creates an instance of a graph edge for use in graph theory |
| generic_graph | Creates an instance of a graph for the graph theory mathematical operations |
| GLOBAL_MESH_MANAGER | This class provides an example of a mesh manager using the global-indexed protocol |
| glue_options | Class to hold information and options for a glue operation |
| greater_than_law | Provides methods for the greater than boolean function |
| greater_than_or_equal_law | Provides methods for the greater or equal than boolean function |
| gvertex | Creates an instance of a graph vertex for use in graph theory |
| ha_rendering_context | Rendering context |
| ha_rendering_options | Rendering Options |
| helix | Defines a (possibly tapered) helical curve |
| HELIX | Defines a helix as an object in the model |
| history_callbacks | Provides callbacks for history management |
| history_callbacks_list | Provides a list of callbacks for history |
| HISTORY_MANAGER | Creates a history state on the specified history stream |
| HISTORY_STREAM | Contains a sequence of delta states that represents a model's history |
| HISTORY_STREAM_LIST | Implements a variable length list of HISTORY_STREAMs |
| hit | Represents an intersection of a ray with a face, edge, or vertex |
| i_aux_data_holder | Interface to hold heterogenous data with appropriate descriptions |
| i_data_element | Interface to a data element |
| i_data_set | Interface to a set of data elements |
| i_data_set_list | Interface to a list of data sets |
| ID_ATTRIB | Allows identification of entities in a table |
| identity_law | Provides methods and data that return one term of the input value |
| IEntityConverter | Interface to be implemented by custom ENTITY conversion classes |
| IHL_CAMERA | Defines a camera viewpoint against which hidden lines are calculated |
| IHL_EDGE | Defines an edge in the hidden line data structure |
| IHL_OUTPUT_MANAGER | Defines a class to control output from IHL |
| IHL_SEGMENT | Defines a hidden line segment with visibility information |
| IHL_STDOUT_MANAGER | Defines an output manager for interactive hidden line (IHL) data that is used by the Scheme AIDE |
| IMPRINT_ANNOTATION | Defines the annotation class for the imprint operation |
| INDEXED_MESH | Shows an example of a mesh that stores indices to a vertex array |
| INDEXED_MESH_MANAGER | This class provides an example of a mesh manager using the indexed protocol |
| input_callback | Creates the standard input for ACIS |
| insanity_data | This class holds information about problems (insanities) found when checking an ACIS model |
| insanity_list | Implements a linked list of problems (insanities) that are found when checking a model |
| insanity_sub_category | This class allows the representation of different sub-categories of entity insanity |
| int_cur | Defines an abstract base class from which intcurve definitions are derived |
| int_law | Provides methods for the integer value than boolean function |
| intcurve | A parametric curve class |
| INTCURVE | Defines a parametric curve as an object in the model |
| integer_list_stream | Container class derived from list_stream that stores integers |
| KT_asm_model_scene | A kinematics scene consists of a set of robots a set of background objects and a set of paths for the robots to follow |
| KT_asm_model_scene_options | Class to control KT_asm_model_scene |
| KT_bubble_locator | Provides a location with a radius to support avoidance |
| KT_display_scene | Interface to provide display of robotics scenes |
| KT_display_scene_options | Class to control KT_display_scene |
| KT_geometry_locator | Provides a location to constrain KT_link objects with respect to each other |
| KT_GGCM_joint | Constructs constraints in the GGCM workspace for the joint depending on its type |
| KT_GGCM_link | Constructs constraints in the GGCM workspace for the joint depending on its type |
| KT_GGCM_manipulator | Manipulator to work with GGCM constraint manager |
| KT_GGCM_object | Constructs constraints in the GGCM workspace for an object |
| KT_GGCM_robot | Derived class to use the GGCM to solve reverse kinematics |
| KT_GGCM_robot_options | Class to control KT_GGCM_robots |
| KT_GGCM_scene | Extension to KT_scene to provide GGCM solution of reverse kinematics |
| KT_GGCM_scene_options | Class to control KT_GGCM_scenes |
| KT_GGCM_scene_parser | Base class for parsing XML files to create scenes |
| KT_HOOPS_item | Extends the KT_item base class to load HMF data from file into the HOOPS database |
| KT_HOOPS_joint | Extends the KT_GGCM_joint base class to display the dials for the joints |
| KT_HOOPS_scene | Implements the KT_display_scene interfaces to provide HOOPS display |
| KT_HOOPS_scene_options | Implements the KT_display_scene_options interface to provide control to HOOPS display |
| KT_HOOPS_scene_parser | Extends the KT_scene_parser base class to load HMF data from file into the HOOPS database |
| KT_item | Describes an item in the background of a kinematics scene in terms of its position orientation |
| KT_joint | Provides the data required to define a joint between two links |
| KT_link | Base class for a link description |
| KT_list | Manager for list entries, handles iteration, names etc |
| KT_list_entry | Base class for objects in linked lists |
| KT_locator | Base class for a location |
| KT_manipulator | Holds a list of joints a pointer to a TPC locator on one of the links in the robot and a separate BODY which is located at the position the TPC should achieve |
| KT_path | Describes a path as a series of waypoints |
| KT_robot | Base class for a robot description |
| KT_robot_options | Abstract base class to control KT_robots |
| KT_scene | A kinematics scene consists of a set of robots a set of background objects and a set of paths for the robots to follow |
| KT_scene_log_text | Simple encapsulation of wchar_t for use with logging text for the scene takes care of memory allocation and release |
| KT_scene_options | Abstract base class to control KT_scenes |
| KT_scene_parser | Base class for parsing XML files to create scenes |
| KT_waypoint | Describes a target position to be achieved |
| KT_xml_parser | Base class for parsing XML |
| KT_xml_tag_parameter | Base class for describing a parameter in an XML class |
| law | Serves as the base class for all derived law classes |
| LAW | Stores a law mathematics function as an entity for saving to and restoring from a SAT file |
| law_data | Serves as a wrapper for ACIS objects, for passing as arguments to laws |
| law_law_data | Serves as a wrapper for a law object, for passing into unary and multiple law data classes |
| length_law | Curve length |
| length_param_law | Curve range |
| less_than_law | Provides methods for the less than boolean function |
| less_than_or_equal_law | Provides methods for the less or equal than boolean function |
| LINKED_MESH | A LINKED_MESH is a series of points connected by links in a number of ways, in order to facilitate fast processing while creating the facets and using the facets |
| LINKED_MESH_MANAGER | This class provides an example of a mesh manager using linked data |
| LIST_HEADER | Implements a variable length list of entries of type void* |
| list_index_error_info | Class for storing list-based ACIS error information |
| list_stream< T > | Use this array based container class to manage large data sets |
| list_stream_options | Use this class to customize the behaviour of list_stream objects |
| Loft_Connected_Coedge_List | Loft input structure |
| log_law | Provides methods for the log mathematical function |
| LOOP | Represents a set of connected EDGEs that bound a FACE |
| lop_options | Options for local operations |
| LUMP | Represents a bounded, connected portion of space |
| make_ewires_opts | Options for make_ewires |
| map_law | The map_law takes in a sub_law as its first law_data and a path as its second law_data and its maps the SPAinterval [0,1] to the domain of the given path |
| mass_props | Defines a class for returning quantities obtained by mass-property calculations |
| mass_props_options | Defines a class for specifying options used in mass-property calculations |
| max_curvature_law | The max_curvature_law's return the greater curvature value at the u,v coordinates of the surface |
| max_law | Represents the maximum of its component laws |
| mean_curvature_law | The mean_curvature_law's return the mean curvature at the u,v coordinates of the surface |
| MESH | Defines a generic base mesh class that can be attached to an entity |
| MESH_MANAGER | A MESH_MANAGER class directs output of the facet data |
| MESH_NODE | A MESH_NODE represents the point of coincident vertices of many facets (or one facet) |
| MESH_POLYGON | Represents a series of vertices making a facet |
| mesh_polygon | Defines an interface to a polygon in a mesh |
| MESH_POLYNODE | The MESH_POLYNODE represents a point, or vertex, of one facet, It is where the bulk of the information of the facets exist, such as position, parametric parameters, and normal vector |
| message_list | Message list item |
| message_module | Contains all messages for a module |
| METHOD_ARGS | Defines the virtual method ID that must return a unique character string to allow runtime identification of overloaded methods |
| METHOD_ID | Identifies runtime methods |
| METHOD_TABLE | Holds the table of runtime method implementation functions for a class |
| min_curvature_law | The min_curvature_law's return the lessor curvature value at the u,v coordinates of the surface |
| min_law | Represents the minimum of its component laws |
| min_rotation_law | The min_rotation_law cashes an array of vectors of size vec_size |
| minimize_options | Supplies the specific minimization actions to api_minimize_entities |
| minus_law | Provides methods for the minus, or subtraction, mathematical function |
| mod_law | Provides methods for the mod mathematical function |
| modeler_state | Defines a class to capture the current tolerance values and option settings |
| multiple_data_law | Provides methods and data for laws that have multiple law data members |
| multiple_law | Provides methods and data for laws that have multiple sublaws |
| mutex_object | Defines a helper class to assure proper ownership of mutex_resource objects |
| mutex_resource | Defines a class containing OS specific mutual exclusion primitives |
| natural_log_law | Provides methods for the NATURAL LOG mathematical function |
| nearest_nbrs_selector | Selects a user specified number of nearest neighbors of a specified point |
| negate_law | Provides methods for the unary minus, or negation, mathematical function |
| NO_MERGE_ATTRIB | Specifies a user-defined attribute that signals that the entity is not to be merged out of the body |
| NORENDER_ATTRIB | Defines a generic attribute type that can mark a face or entity to not be rendered |
| norm_law | Provides methods for the normalize mathematical function |
| not_equal_law | Provides methods for the not equal than boolean function |
| not_law | Provides methods for the not boolean function |
| odd_law | Provides methods for the odd value boolean function |
| off_int_cur | Represents a spline curve obtained by the intersection of two surfaces that are offsets of the given surfaces |
| off_spl_sur | Represents the offset of a surface |
| offset_error_info | Error information from an offset operation |
| offset_options | Options for offset operations |
| option_header | Records a value that denotes whether the option is on, off, or set to a given value |
| or_law | Provides methods for the OR boolean function |
| outcome | Defines a class for holding the results of API calls |
| output_callback | Creates output callback standard output for ACIS |
| page_statistics | The page system statistics |
| par_int_cur | Represents an exact spline curve in the parameter space of a surface |
| param_info | Data representing type and, in some cases, parameter information about a point on an ENTITY |
| param_string | References parameters |
| PART | Provides methods and data for grouping entities together as parts |
| PART_CONTEXT | The PART_CONTEXT object |
| path_law_data | Serves as a wrapper for either a curve or wire object, for input into a law |
| pattern | Provides all information necessary to generate a regular or irregular pattern of entities from a single, "seed" entity |
| PATTERN_ANNOTATION | Implements the annotations for patterned entities |
| pcurve | Defines a 2D curve defined in the parameter space of a parametric surface |
| PCURVE | Defines a 2D parameter-space approximation to a curve as an object in the model |
| pcurve_interp | Fits a parameter space curve |
| pcurve_law | Creates a law to support parameter curve calculations |
| pcurve_law_data | Serves as a wrapper for ACIS pcurve objects, for passing them as arguments to laws |
| PE_MESH_MANAGER | Defines a mesh manager for interactive hidden line removal (IHL) |
| permanent_domain_law | Permanent domain law |
| phl_body_occurrence | Defines a phl_body_occurrence |
| PHLV5_EDGE | Defines an PHLV5 edge |
| PHLV5_OCC | Defines an PHLV5 occurrence |
| phlv5_options | Specifies options for hidden line removal |
| PHLV5_SEGMENT | Defines an PHLV5 segment |
| pi_law | Constant PI law |
| pick_ray | Maps a 2D graphic pick on an entity position defined in model space |
| piecewise_law | The piecewise_law takes a sequence of sub laws of the form c1 s1 c2 s2 |
| PLANE | Defines a plane as an object in the model |
| plane | Defines a planar surface |
| plus_law | Provides methods for the plus, or addition, mathematical function |
| point_entity_rel | Relates an APOINT to an ENTITY |
| pointer_map | This class tracks reference counting of sub-objects used in making a deep copy |
| POLYEDGE_MESH | Defines a mesh for the Interactive Hidden Line Component (IHL) |
| POLYGON | Defines a POLYGON |
| POLYGON_POINT_MESH | Defines a collection of polygons |
| POLYGON_POINT_MESH_MANAGER | Specializes the MESH_MANAGER class when a mesh is maintained as a POLYGON_POINT_MESH |
| POLYGON_VERTEX | Defines a vertex on a polygon |
| polygon_vertex | The polygon_vertex class is used to store the data at a polygon vertex |
| position_array | Creates dynamic arrays of positions |
| position_distance_pair | This struct is useful for closet-point and related queries |
| position_distance_pair_set | Represents an ordered set of position distance pairs |
| position_list_stream | Container class derived from list_stream for SPAposition objects |
| PPM_ON_FACE_MESH_MANAGER | Shows how a MESH-derived mesh is attached to a face |
| prime_law | Provides methods for the prime value than boolean function |
| PRIMITIVE_ANNOTATION | Used for primitive annotations |
| project_options | Class to hold information and options for a projection operation |
| pt_cvty_info | Returns the convexity of a single point along an edge (or equivalent) |
| rand_law | Provides methods for the RANDOM mathematical function |
| rat_poly_vec | A SPAvector of rational polynomials (or more accurately a rational polynomial of vectors, as the denominator is the same for all coordinates) |
| ray | Represents a 3D ray |
| rayfire_options | Represents common data and functionality for ray fire options |
| rb_blend_spl_sur | Implements the constant radius rolling ball blend surface |
| rbase_app_callback | Implements routines to handle various rendering application callbacks for image output and interrupts |
| readonly_error_info_base_list | Acts as a collection class for error_info_base objects, that is, it implements a variable length list of error_info_base objects |
| REFINEMENT | Controls the accuracy and types of polygons generated in the faceter |
| rem_error_info | Error entities from a remove face operation |
| remove_face_info | Information about a successful remove operation |
| Render_Arg | Provides the mechanism for getting and setting shader parameters |
| Render_Color | Represents an RGB color |
| RenderingObject | The RenderingObject object |
| restore_def | Records an entity type name, a pointer to a restore_data routine for that type of entity, and a link pointer |
| restore_progress_data | Class for recording the part restore progress data |
| rgb_color | Defines the red, green, and blue colors for the display |
| RH_BACKGROUND | Defines a background |
| RH_ENTITY | Provides common methods and data for other rendering classes |
| RH_ENVIRONMENT_MAP | Defines an environment map |
| RH_FOREGROUND | Defines a foreground |
| RH_LIGHT | Defines a light source |
| RH_MATERIAL | Defines a material consisting of color, displacement, reflectance, and transparency |
| RH_TEXTURE_SPACE | Defines a texture space |
| roll_callback | Notifies the user about the start and the end of a roll operation |
| roll_callback_list | Provides a type-safe interface to the toolkit_callback_list and the execute method |
| rot_spl_sur | Represents a surface of rotation |
| rotate_law | This law takes in three values and returns three values The first argument to the rotate_law is a law |
| rough_align_options | Rough_align_options is used to control the behavior of rough_align_entity_to_points |
| SabFile | Performs save and restore to stream files |
| safe_floating_type< type > | Defines a class with thread-local storage for and behavior of floating point data types |
| safe_function_type< type > | Defines a class with thread-local storage for and behavior of function pointers |
| safe_integral_type< type > | Defines a class with thread-local storage for and behavior of integral data types |
| safe_object_pointer< type > | Defines a class with thread-local storage for and behavior of object pointers |
| safe_pointer_type< type > | Defines a class with thread-local storage for and behavior of generic pointers |
| SatFile | Defines the SatFile class for doing ACIS save and restore to stream files in text format |
| scheme_error_callback_list | Provides a type-safe interface to the toolkit_callback_list and the execute method |
| scm_pick_manager | The scm_pick_manager object |
| ScmObject | Declaration of Scheme object data type |
| sec_law | Provides methods for the SECANT mathematical function |
| sech_law | Provides methods for the SECH mathematical function |
| SEQUENTIAL_MESH | A SEQUENTIAL_MESH is the base class for INDEXED_MESH and LINKED_MESH |
| set_law | This law returns 1 if the sub law is greater than zero else it returns zero |
| sg_edge_ent_rel_union | Determines the relationship type |
| SHELL | Represents the external boundary of a LUMP, or the internal boundary of a void (unoccupied space) within a LUMP |
| shell_lump | Records the classification of shells or wires that do not contribute to any intersection |
| silhouette_options | Represents common data and functionality for silhouette options |
| SIMPLE_INDEXED_MESH | A mesh format that stores indices to a vertex array |
| SIMPLE_INDEXED_MESH_MANAGER | To show an example of a mesh manager using the indexed protocol |
| simplify_options | This class contains parameters that govern the behavior of api_simplify_entity |
| sin_law | Provides methods for the SINE mathematical function |
| sinh_law | Provides methods for the SINH (Hyperbolic Sine) mathematical function |
| size_law | Size law |
| SKIN_ANNO_END_EDGE | Defines the annotation class relating to an edge on the end (capping) face |
| SKIN_ANNO_END_FACE | Defines the annotation class for the end face that corresponds to the coedges of the last profile used for skinning |
| SKIN_ANNO_LAT_EDGE | Defines the annotation class for a lateral edge that corresponds to the profile vertices connected by that lateral edge in skinning |
| SKIN_ANNO_LAT_FACE | Defines the annotation class for a lateral face (skinned face) that corresponds to the profile coedges from which the lateral face is skinned |
| SKIN_ANNO_START_EDGE | Defines the annotation class relating to a edge on the start (capping) face |
| SKIN_ANNO_START_FACE | Defines the annotation class for the start face that corresponds to the coedges of the first profile that is used for skinning |
| SKIN_ANNOTATION | Implements the base class for skinning annotations |
| skin_options | Sets options for skinning |
| skin_spl_sur | Defines a skin surface between a list of curves |
| slice_options | This class will provide user an interface to customize the behavior of slice operation |
| slice_output_handle | Represents a handle to the output from a Slice operation |
| slice_output_query | This class allows a user to create an explicit wire body from slice output handle |
| slice_selector | Selects all points within a desired thickness of a plane |
| sortable_integer_ls | Container class with sorting capabiliteis derived from integer_list_stream |
| SPA_approx_options | This class is used as a base for the SPA_EDGE_approx_options and SPA_COEDGE_approx_options classes |
| SPA_COEDGE_approx_options | The SPA_COEDGE_approx_options object is used to control the behavior of the signature of api_approx that approximates a coedge |
| SPA_EDGE_approx_options | The SPA_EDGE_approx_options object is used to control the behavior of the signature of api_approx that approximates an edge |
| SPA_edge_line_arc_options | This options class is used as input for api_edge_approx_line_arc |
| SPA_progress_info | Abstract base class for providing progress information |
| SPA_sample_edges_options | Provides a data structure for the sampling of contiguous, unbranched edges |
| SPA_spring_back_def | Definition of the mapping which fulfills the springback deformation |
| SPA_spring_back_options | Optional inputs for a springback deformation |
| spa_unlock_result | Stores the outcome of the license validation process |
| SPAbox | Represents a bounding box |
| SPAboxing_options | Represents common data and functionality for all boxing options |
| SPACOLLECTION | An ENTITY that contains and manages a collection of entities |
| SPAdouble_vector | Provides functionality similar to std::vector<double> within ACIS |
| SPAentity_point_distance_options | Represents common data and functionality for entity-point distance options |
| SPAGROUP | An implementation of a SPACOLLECTION with predefined actions and behaviors |
| SPAinterval | Records an interval on the real line |
| SPAmatrix | Defines a 3x3 affine transformation acting on vectors and positions |
| SPAnvector | Implements an n dimensional vector |
| SPApar_box | Defines a 2D bounding box in parameter space by four values of class parameter: low_u, high_u, low_v, high_v |
| SPApar_dir | This class defines a parametric direction vector on a surface in 2D parameter-space |
| SPApar_pos | Defines a parameter position in the parameter-space of a surface |
| SPApar_transf | Defines a parameter space transformation containing scaling and translation components |
| SPApar_vec | This class defines a vector (du, dv) in 2D parameter-space |
| SPAparameter | Defines a curve parameter value |
| SPApoint_cloud | This is the central class in ACIS Point Cloud Functionality |
| SPApoint_cloud_custom_data | Implements a SPApoint_cloud_custom_data class |
| SPApoint_cloud_iterator | Implements a SPApoint_cloud_iterator class |
| SPApoint_cloud_options | Implements a SPApoint_cloud_options class |
| SPAposition | Represents position vectors (points) in 3D Cartesian space that are subject to certain vector and transformation operations |
| SPAposition_cloud | SPAposition_cloud is a class for geometrically querying large sets of points |
| SPAposition_cloud_iterator | SPAposition_cloud_iterator allows you to get the points from a SPAposition_cloud or SPAposition_subcloud object |
| SPAposition_cloud_selector | SPAposition_cloud objects are organized into subclouds |
| SPAposition_subcloud | SPAposition_subcloud represents a subset of a SPAposition_cloud |
| SPAposition_vector | Provides functionality similar to std::vector<SPAposition> within ACIS |
| Spatial_abs_hurler | This abstract base class class provides a protocol for handling exceptions across interfaces |
| Spatial_syserr_hurler | Provides a protocol for handling exceptions across interfaces |
| SPAtransf | Represents a general 3D affine transformation |
| SPAunit_vector | Provides a direction in 3D Cartesian space that has unit length |
| SPAvector | Represents a displacement vector in 3D Cartesian space |
| SPHERE | Defines a sphere as an object in the model |
| sphere | Spherical surface definition |
| sphere_selector | Selects all points within a sphere |
| spl_sur | Defines an abstract base class from which spline surface definitions are derived |
| splgrid | Defines a data structure for the construction of a B-spline surface |
| SPLINE | Defines a spline as an object in the model |
| spline | Represents a parametric surface |
| SPLIT_ANNOTATION | Defines the annotation class for split operations |
| splsurf | Defines a data structure used to construct a B-spline surface |
| sqrt_law | Provides methods and data for the square root mathematical function |
| standard_error_info | Encapsulates standard error information |
| step_law | The step_law always takes an odd number of sub laws starting at zero the odd numbered (i.e |
| stitch_options | Abstract base class from which specific stitch options classes, such as exact_stitch_options, tolerant_stitch_options and edge_tolstitch_options, are derived |
| stitch_progress_info | Abstract base class for providing stitch progress information |
| STL_MESH_MANAGER | Writes data to an stl formatted file |
| straight | Defines an infinite straight line represented by a point and a unit vector specifying the direction |
| STRAIGHT | Defines a straight line as an object in the model |
| StreamFinder | Used by the DistributeStates function below to find the HISTORY_STREAM corresponding to a given entity |
| sub_spl_sur | Subsetted spline surface |
| SUBSHELL | Represents a subdivision of a SHELL or SUBSHELL |
| subtrans_object | Defines a shared-subtype class that is subject to transformations |
| subtype_object | Defines the master object from which all subtype objects must be derived |
| sum_spl_sur | Represents a surface built by the linear summation of two curves |
| SUPERCELL | Provides a hierarchical cellular data structure |
| surf_normcone | Provides a return value for normal_cone, which returns a cone bounding the surface normal |
| surf_princurv | Provides the return value for the principal curvature functions, returning two directions and two curvatures for a surface |
| surf_surf_int | Represents the intersection of two face surfaces and returns zero or more curves |
| surface | Base class for all ACIS surface types, which defines the basic virtual functions that are supplied for all specific surface classes |
| SURFACE | Defines a generic surface as an object in the model |
| surface_law | Returns the position on a surface |
| surface_law_data | Serves as a wrapper for ACIS surface objects |
| surfnorm_law | Composes a law mathematical function that returns the normal to a surface at a given position |
| surfperp_law | Surface point perp |
| surfvec_law | Surface vector law |
| SWEEP_ANNO_EDGE_LAT | Defines the annotation class for the lateral topology corresponding to an edge of the profile which becomes a face in sweeping |
| SWEEP_ANNO_EDGE_MITER | Defines annotation relating to miter edges created during sweep sweep |
| SWEEP_ANNO_EDGE_TOP | Defines the top topology from a swept edge, which is another edge |
| SWEEP_ANNO_END_CAPS | Defines annotation relating to capping faces of a sweep |
| SWEEP_ANNO_VERTEX_LAT | Defines annotation relating to vertex of lateral topology of a sweep |
| SWEEP_ANNO_VERTEX_MITER | Defines annotation relating to miter vretices created during sweep sweep |
| SWEEP_ANNO_VERTEX_TOP | Defines annotation relating to the vertices at the top of a sweep |
| SWEEP_ANNOTATION | Implements the base class for sweeping annotations |
| sweep_options | Provides a data structure for sweeping operations to be used in the function api_sweep_with_options |
| sweep_spl_sur | Defines the perpendicular sweep of a planar profile curve along a path curve |
| TaggedData | Tracks data and its type for saving and restoring unknown ENTITY types |
| tan_law | Provides methods for the TANGENT mathematical function |
| tanh_law | Provides methods for the TANH (Hyperbolic Tangent) mathematical function |
| TCOEDGE | Internal to ACIS and not intended for direct usage |
| TEDGE | Although this internal class is intended strictly for ACIS usage, a minimal amount of information about this class is provided for the sole purpose of being able to understand and trace restoration from a SAT file |
| tedge_repair_options | Specifies the options for api_check_and_fix_tedge |
| tensor | Defines a 3 x 3 tensor |
| term_law | Provides methods for the term mathematical function that returns a single dimensional element of a multidimensional function |
| TEXT_ANNOTATION | Defines a simple annotation attribute for testing annotations |
| TEXT_ENT | Stores simple text display information |
| thread_work_base | Defines a simple producer-consumer work queue with thread management |
| times_law | Provides methods for the times, or multiplication, mathematical function |
| tk_list | Base class that can be used to manage a list of items |
| tolerance_param | Options object part containing tolerance information Role: Objects of this class hold a tolerance |
| tolerant_stitch_options | Specifies that api_stitch and api_stitch_nonmanifold should use tolerant stitching |
| tolerize_entity_opts | Options object for use with api_tolerze_entity <bre> <bf>Role:<> This object allows the user to communicate with the API |
| toolkit_callback | Defines the toolkit_callback base class and the toolkit_callback_list class |
| toolkit_callback_list | Stores the list of toolkit_callbacks |
| TORUS | Defines a torus as an object in the model |
| torus | Represents tori |
| transf_decompose_data | Represents the decomposition of a general transformation into a series of elementary transformations |
| TRANSFORM | Represents an overall transformation applied to a BODY, and is saved as part of the model |
| transform_law | Applies an ACIS transform to a law that returns a three dimensional position |
| transform_law_data | Serves as a wrapper for an ACIS SPAtransf object |
| true_law | True law |
| tube_options | Creates a data structure to facilitate generalizing selective Booleans |
| TVERTEX | Internal to ACIS and not intended for direct usage |
| twist_path_law | The twist_law constructor takes three laws A SPAvector field to twist (i.e the zero twist value or rail_law) A curve_law to twist it around and a twist_law that gives the angle of twist in radians |
| unary_data_law | Provides methods and data for laws that have one law data member |
| unary_law | Provides methods and data for laws that have one sublaw |
| unbend_law | The unbend law for space warps |
| UNDEFC | Defines a curve that is undefined except for its end points as an object in the model |
| UNITS_SCALE | Defines the UNITS_SCALE class |
| unknown_text_pointer | Implements the member functions to point to an object containing textual data to be read from a save file |
| unstitch_nm_options | Hold information and options for an unstitching of non-manifolds operation |
| va_base_mesh_options | Options object that controls the generation of meshes by the EDA Mesher |
| va_mesh | Abstract base class |
| va_surface_mesh_options | Options object that controls the generation of surface meshes by the EDA Mesher |
| va_surfmesh | Bridge class that provides for the automatic generation of linear or parabolic triangular or quadrilateral elements given an input surface geometry |
| va_tet_mesh_options | Options object that controls the generation of tetrahedral meshes by the EDA Mesher |
| va_tetmesh | Bridge class that provides for the automatic generation of linear or parabolic tetrahedral elements given a surface mesh (VA_SURFMESH) as input geometry |
| var_cross_section | Evaluates the cross section of a blend surface |
| var_rad_const | Declaration of the derived class var_rad_const |
| var_rad_fixed_width | Defines a constant cross section radius for a variable radius function |
| var_rad_functional | Defines a functional form of a variable radius function |
| var_rad_rot_ellipse | Defines a rotational radius ellipse for a variable radius function |
| var_rad_two_ends | Defines a two-ends form of a variable radius function |
| var_radius | Defines the variable radius |
| VBL_SURF | Defines the vertex blend surface class |
| vector_law | Combines one dimensional laws into a multi-dimensional law |
| VERTEX | Represents a corner of a FACE and/or the end of an EDGE |
| VERTEX_TEMPLATE | Creates parameter templates |
| VOID_LIST | Creates a variable-length list of void*'s |
| WARP_ANNO_FACE | Implements the annotations for space-warped faces |
| WARP_ANNOTATION | Implements the annotations for space-warped entities |
| WCS | Defines a working coordinate system |
| WCS_callback | Provides notification of changes to the WCS |
| WCS_callback_list | Provides a type-safe interface to toolkit_callback_list class and the execute command |
| WIRE | Represents a collection of edges that are owned by a body but are not attached to faces and do not enclose any volume |
| wire_law | Wire_law's return the parametric postion of a wire where the parameterization has been scaled to the length of each of the sub coedges and starts at zero and ends at the length of the wire |
| wire_law_data | Serves as a wrapper for an ACIS WIRE object |
| wire_offset_options | Provides a data structure for wire offsetting operations to be used in the function api_offset_planar_wire |