The 3D ACIS® Modeler (ACIS) is Spatial’s prominent 3D solid modeling engine. 3D InterOp is a CAD data translation framework (Interoperability)
ACIS Release Notes/R19
From DocR19
Contents |
Blending
Functional Changes
Retain Features with Disconnected Blend Graphs
Prior to R19 when multiple disconnected graphs of edges were supplied to blend fixing APIs, the action of blending on engulfed features was unpredictable; blending may not have retained those features. This limitation has been removed in R19.
 Edges Marked in Red Are Blended in a Single API Call |
 From R19, Blending Retains the Engulfed Boss |
Retain Features with Mixed Convexity Blend Graphs
Prior to R19 when multiple edges with different convexity were supplied to blend fixing APIs, the action of blending on engulfed features was unpredictable; blending may not have retained those features. This limitation has been removed in R19.
 Before Blend |
 After Blend |
Retain Features with Vertex Blend Being Part of Blend Graph
Prior to R19 when all edges of a vertex were supplied to blend fixing APIs, the action of blending on engulfed features was unpredictable; blending may not have retained those features. This limitation has been removed in R19. However, if those blended edges (with a common vertex) are of mixed convexity, then blending cannot retain engulfed features.
 Before Blend |
 After Blend |
Vertex Blend Side-cap
Prior to R19 when all the edges at a vertex were supplied to blend fixing APIs, the outcome of blending on features in the vicinity was unpredictable. If the features were interfering with the spring curve of the blend sheet and a side-cap was required to solve the blend, then blending may not have succeeded. This limitation has been removed in R19.
 Before Blend |
 After Blend |
Side-cap and Roll-on Option
You can create blends with a large radius even if one of the approaches among capping and roll-on fails, the other is tried, and a solution returned if valid. Blending falls back to roll-on if side-cap fails or produces an undesired result. This is one of the blending enhancements in R19.
 Before Blend |
 After Blend |
 Before Blend |
 After Blend |
Remote Miter
You can create blends where blend faces interact with each other and the interaction cannot be predicted solely by analyzing the connectivity of the edges being blended. Interaction can be detected and solved only after the blend faces are generated and analyzed. Blend faces may interact with each other at their ends or along the spring edges. The final blend sheet is produced by solving the miter between blend sequences. This is one of the blending enhancements in R19.
 Before Blend |
 After Blend |
 Before Blend |
 After Blend |
Moved Header Files
Header File blseq.hxx
The header file blseq.hxx has been moved from the Blending Public Interfaces to the Blending Protected Interfaces.
Booleans
New functionality
New API: api_project_wire_to_body
A new API, api_project_wire_to_body, has been introduced for projecting a wire body onto a sheet or solid body and (optionally) imprinting the projected wire. The signature of the API is
outcome api_project_wire_to_body( const BODY* wire_body, BODY* target_body, project_options* po = NULL, AcisOptions* ao = NULL)
The Scheme extension for accessing the API is bool:project-wire-to-body.
New API: api_project_edge_to_face
A new API, api_project_edge_to_face, has been introduced for projecting an edge onto a face. The signature of the API is
outcome api_project_edge_to_face( const EDGE * edge, const FACE * face, ENTITY_LIST * elist, project_options* po = NULL, AcisOptions * ao = NULL)
The Scheme extension for accessing the API is edge:project-to-face.
New Class: project_options
A new options class, project_options, has been introduced to supply options to the new projection APIs api_project_wire_to_body and api_project_edge_to_face. The project_options object supplies information to, and retrieves information from, a given projection and imprint operation. The equivalent Scheme data type is proj-options.
The Scheme extensions for creating a project_options object and accessing it are:
- bool:proj-options
- proj-options:get-projected-entities
- proj-options:get-associated-entities
- proj-options:add-seed-pair
- proj-options:clear-seeds
- proj-options:set-target-faces
- proj-options:clear-target-faces.
Changes to Existing Functionality
Changes to APIs
In version R19 the following boolean APIs may take BoolOptions as an additional argument. Scheme extensions and journaling functions are correspondingly modified.
outcome api_imprint(BODY *tool,BODY *blank,BoolOptions *boolopts,AcisOptions *ao = NULL); outcome api_intersect(BODY *tool,BODY *blank,BoolOptions *boolopts,AcisOptions *ao = NULL); outcome api_subtract(BODY *tool,BODY *blank,BoolOptions *boolopts,AcisOptions *ao = NULL); outcome api_unite(BODY *tool,BODY *blank,BoolOptions *boolopts,AcisOptions *ao = NULL); outcome api_fafa_int(FACE *tool,FACE *blank,BODY *&graph,BoolOptions *bool_opts,AcisOptions *ao = NULL); outcome api_edfa_int(EDGE *edge,FACE *face,ENTITY_LIST *&inter,BoolOptions *bool_opts,AcisOptions *ao = NULL); outcome api_imprint_stitch(BODY *b1,BODY *b2,BoolOptions *bool_opts,AcisOptions *ao = NULL); outcome api_selectively_intersect(const int number_faces,FACE *tool_faces[],FACE *blank_faces[], BoolOptions *boolopts,AcisOptions *ao = NULL); outcome api_bool_make_intersection_graph(BODY *tool,BODY *blank,BODY *&graph,BOOL_TYPE type, const glue_options *glue_opts,BoolOptions *boolopts,AcisOptions *ao = NULL); outcome api_bool_make_intersection_graph_wo_bool_end(BODY *tool,BODY *blank,BODY *&graph,BOOL_TYPE type, const glue_options *glue_opts,BoolOptions *boolopts,AcisOptions *ao = NULL); outcome api_selectively_imprint(BODY *tool,ENTITY_LIST &tool_faces,BODY *blank,ENTITY_LIST &blank_faces, logical split_checking,ENTITY_LIST &intgraph_edges,BoolOptions *boolopts,AcisOptions *ao = NULL); outcome api_boolean_complete(BOOL_TYPE op,NDBOOL_KEEP ndbool_keep,BODY *&result_body, BoolOptions *bool_opts,AcisOptions *ao = NULL); outcome api_boolean_chop_complete(logical nonreg,BODY *&outside,BODY *&leftovers,NDBOOL_KEEP ndbool_keep, BODY *&result_body,BoolOptions *bool_opts,AcisOptions *ao = NULL); outcome api_planar_slice(BODY *ent,const SPAposition &pt,const SPAunit_vector &normal,BODY *&slice, BoolOptions *bool_opts,AcisOptions* ao = NULL);
Note: Introduction of the new signatures means that there is now a compile-time ambiguity if a single untyped NULL is passed explicitly to these APIs. For instance in the call api_imprint(tool,blank,NULL) the NULL pointer can either be interpreted as a BoolOptions pointer or AcisOptions pointer, which result in different function calls, although both functions have identical run-time behavior.
The following function calls are all unambiguous and have identical behavior:
api_imprint(tool,blank); api_imprint(tool,blank, (BoolOptions *) NULL); api_imprint(tool,blank, (AcisOptions *) NULL); api_imprint(tool,blank, NULL, NULL);
and similarly for the other APIs.
Changes to BoolOptions
Tracking Imprinted Entities
In R19 it is now possible to retrieve two lists following an imprint operation. The lists contain the edges and vertices which were imprinted on the blank and tool bodies during the imprint. The tracking of imprinted entities is controlled by a flag which is set and retrieved by the two new member functions:
BoolOptions::set_track_entities(logical); logical BoolOptions::get_track_entities() const;
The new member function
BoolOptions::get_imprinted_entities(bool_body_type, ENTITY_LIST &);
is used to return the lists on each body, where the new enumerated type bool_body_type takes the values BOOL_BODY_BLANK or BOOL_BODY_TOOL.
The new member function
BoolOptions::get_associated_entities(ENTITY *ent, ENTITY_LIST& assoc_ents);
is used to return the entities on the other body which are associated with a given ENTITY. In the case of imprint the elements of the lists actually correspond with each other and the list returned is at most of length 1.
The equivalent new Scheme extensions are:
Determining if Blank and Tool Clash
A new member function of BoolOptions has been introduced.
body_clash_type BoolOptions::get_clash_info() const
This allows a query to be made as to whether the blank and tool clashed, following a call to a regular Boolean API taking a BoolOptions object as input. The return value is one of the following:
CLASH_UNKNOWN CLASH_NONE (blank and tool are completely disjoint) CLASH_UNSPECIFIED (blank and tool clash, they may be abutting or intersecting)
The equivalent new Scheme extension is bool-options:get-clash-info.
Deprecated header files
The header files bool_api_options_prot.hxx and boolapi_prot.hxx should not be used in R19 and may be removed in future. It is recommended to use bool_api_options.hxx and boolapi.hxx instead.
Faceter
Functional Changes and New APIs
Embedded Vertex and Faceting
In the past, embedded edges of non-zero length were included as nodes in the faceting solution, but zero-length edges (embedded vertices) were not. Now they are all included as nodes in the faceting solution. If you want the old behavior, and do not want embedded vertices forced into the solution as facet nodes, call the faceting APIs with the class AcisOptions, setting the version in AcisOptions to 18.0.0 or less.
Adaptive Faceting
Significant performance and quality improvements have been made to the adaptive faceting algorithm, which may be activated via the option header adaptive_triangles. Refer to Adaptive Faceting for more details.
New Option: facet_fix_outside_nodes
Created new option which ensures a faces facet nodes lie inside the face, but has a slight negative performance impact.
New Option: facet_grid_to_curves
When FALSE (default), the faceter will use the straight lines between edge facet nodes when calculating interior facet nodes. When TRUE, the faceter will use the geometric curve of the edge. When set to FALSE, the calculation of intersections of facet gird lines and the face edge is much quicker.
To gain performance in faceting, this option is set to FALSE (default). The Faceter gains performance by calculating where the facet grid intersects the edge by using the straight edges of the facet nodes along the edge, rather than the geometric curve of the edge. These intersection points are typically used to determine if a potential facet node falls inside or outside the face boundary, and then the intersection is typically thrown away. However, near the boundaries of some faces there may exist areas of low curvature in 3D yet high curvature in parametric space. In these cases, using the straight line may give the wrong result, and an interior facet node may land outside the boundary of the face. In cases where 3D curvature is very different from parametric curvature, you may wish to change this option to TRUE. The process of using the straight lines between edge nodes occurs only when appropriate. Hence, this process does not occur when it is determined that it can lead to incorrect results; such as when the face has high curvature near singularities. Also it is not used when AF_GRID_TO_EDGES is enabled (on) and the intersection points are not thrown away.
Intersectors
Functional Changes and New APIs
User Tolerance for Silhouette APIs
An overload of api_silhouette_edges has been introduced, which takes the new silhouette_options object. Currently, this object allows you to pass in a 3-space tolerance which Spatial strongly recommends that it be greater than SPAresabs and less than SPAresfit. The resulting silhouette edges should lie within the tolerance of the true silhouette curve. Refer to the new Scheme extension silhouette:options and to the updated Scheme extension face:get-silhouette for details.
New signature for api_project_curve_to_surface
A new signature for api_project_curve_to_surface has been introduced:
outcome api_project_curve_to_surface( const curve & in_curve, const SPAinterval & in_range, const surface & in_surface, curve ** & curves_on_surface, int & num_curves, AcisOptions * ao = NULL)
The advantage of the new signature is that the API is now able to return multiple curves. The old signature could only return a single curve and returned a failed outcome if the projection contained more than one curve. The old signature for api_project_curve_to_surface will be deprecated in a future release and it is no longer a documented API. Therefore, Spatial encourages you to use the new signature.
The Scheme extension, curve:project-to-surface for accessing the API has also changed in order to provide more consistency between the naming of APIs and Scheme extensions; it now takes an acis-options object. The syntax for the extension is as follows:
(curve:project-to-surface in-curve in-surface [ao])
Kernel
Functional Changes and New APIs
Projecting a Helix onto a Plane
The function:
logical is_helix(curve const & the_curve, const SPAinterval & domain, SPAvector & axis, SPAposition & root = *(SPAposition*) NULL_REF, double & pitch = *(double*) NULL_REF, double & radius = *(double*) NULL_REF, logical & right_handed = *(logical*) NULL_REF );
in law.hxx now returns TRUE for helical parameter curves (which are v-parameter lines) on swept helical surfaces.
Projection: Special Cases
When projecting curves onto a plane, in case of straight or ellipse, the function bounded_curve::project_to_plane, returns straight or degenerate_curve for straight and ellipse or straight for ellipse. In case of exact_int_cur, the returned curve is of the same type, unless adjacent control points on the projection plane coincide, in which case the general projection algorithm is used.
Copy Logic Modified for Bounding Box
The copy logic for BODY, LUMP, SHELL, SUBSHELL, WIRE, FACE, LOOP, TCOEDGE, and EDGE has been modified so that any bounding-box that is present on the input is to be copied to the destination. This is invoked through each of the aforementioned entity's COPY_DEF, which is used by these ACIS standards:
- shallow-copy (api_copy_entity / api_copy_entity_list)
- deep-copy (api_deep_copy_entity / api_deep_copy_entity_list)
- down-copy (api_down_copy_entity)
Support for Reading/Writing Wide Character Strings
Two global functions have been added in support of reading and writing wide character strings through the currently installed FileInterface (for save/restore): read_wstring and write_wstring.
Correspondingly, two methods of the same name have been added to FileInterface.
So that the wide character data can be written into our single byte text file (sat), the FileInterface::write_wstring method encodes the wide character string into a stream of "printable ASCII" single-byte characters when written with write_wstring. Upon reading using the FileInterface::read_wstring method, the data is decoded back into the original wide character string.
Tag Manager Enhancement
The BASE_TAG_MANAGER get_next_tag method has been enhanced to optionally post-increment the array index and grow the tag array if necessary. Pass a logical TRUE argument to get this new behavior. This defaults to FALSE, which results in pre-R19 behavior.
Moved Classes
Class corner
The class corner has been moved from the net_spl.hxx in the Kernel public interfaces to netspl_corner.hxx in the Kernel protected interfaces. Additionally, the class name corner has been changed to netspl_corner.
Local Operations
Functional Changes
Offset Body with Free Edges (Sheet Offset)
The restriction on the API api_offset_body that disallowed input bodies containing free edges has been removed.
Modified Faces
In R19, you may find a reduction in the total number of modified faces returned by api_get_modified_faces after calling Local Operations such as api_remove_faces. Use api_get_modified_faces to retrieve the number of created, modified, or deleted faces during the remove faces operation.
Error Info
The number of circumstances in which a failed LOPS API returns an ENTITY indicating the problem area has been improved.
Scheme Support
Error Propagation
Local Operations (LOP, REM, SHL, RBI) Scheme commands used to fail and highlight the error entities. From R19 these commands return a list of error entities, extracted from the correspondent error_info contained in the result outcome of its API.
Model Analysis
ACIS Checker
Extend check for non-G0 curves
The check for non-G0 curves has been extended to detect discontinuities in curves of class surf_int_cur.
Curves in the class surf_int_cur are defined as the projection of a B-spline curve onto a surface. If there is a G1 discontinuity on the surface, then the result of this projection can be non-G0 (even when the curve is close to the surface and the projection distance is therefore small). The new check tests whether a curve of class surf_int_cur is connected where it crosses a surface discontinuity, and reports a checker error when it is not. The message associated with this check error is "EDGE curve is not G0 continuous".
Note: The use of curves of class surf_int_cur has been deprecated, and it is recommended that another type of curve is used. For example, it is often possible to replace a curve of class surf_int_cur with a curve of class par_int_cur.
Object Relationships
Functional Changes and New APIs
Point in body API performance
The containment function api_point_in_body has been enhanced substantially to improve both performance and robustness.
Failsafe Entity Point Distance
If the version of the function api_entity_point_distance, which takes as input a SPAentity_point_distance_options options class, is unable to determine the containment of any of the input positions, then the outcome of the API will contain a non-NULL error_info of the derived type list_index_error_info. Refer to the Entity Point Distance article for a fuller description of accessing the list_index_error_info information.
The Scheme function entity:point-distance has been updated to return an additional list of integers if the function fails to compute the containment for any of the input positions.
Function find_entity_entity_distance (undocumented)
There has been a signature change to the undocumented function find_entity_entity_distance (sgquery.hxx). If build problems are encountered, please consider using the relevant recommended api, api_entity_entity_distance or api_entity_point_distance.
New Classes
Class list_index_error_info
A new class list_index_error_info has been introduced to return error information for list-based APIs. This class is used by api_entity_point_distance to return information about failing calculations.
Offsetting
New APIs
New API: api_offset_face_loops
A new API, api_offset_face_loops, has been introduced for creating a new face by offsetting the loops of a (non-planar) face. The signature of the API is
outcome api_offset_face_loops( FACE* iFace, double iOffsetDist, BODY*& oResultBody, AcisOptions* ao = NULL) outcome api_offset_face_loops( FACE* iFace, ENTITY_LIST& iEdges, double iOffsetDist, BODY*& oResultBody, AcisOptions* ao = NULL)
The Scheme extension for accessing the API is face:offset-loops.
Moved APIs
Helical Edge
The function api_edge_helix has been moved from the SPAofst component to the SPAcstr component. Accordingly, this function is now declared in cstrapi.hxx rather than ofstapi.hxx.
Sweeping
Functional Changes
Helical Sweep Intersection Check
R19 introduces a quick helical sweep intersection check during the extension of sweep surfaces with helical path. This feature improves the speed of self-intersection check.
Moved APIs
The api_offset_face_loops APIs have been moved from sweepapi.hxx to ofstapi.hxx
New Product-specific Features
HOOPS/ACIS Bridge
Functional Changes and New APIs
New Signature: HA_Compute_Component_Entity_Pointer
R19 introduces a new signature for the function HA_Compute_Component_Entity_Pointer:
component_entity_handle* HA_Compute_Component_Entity_Pointer( HC_KEY comp_key, HC_KEY ent_key)
Given HOOPS keys corresponding to a particular assembly component and to an ENTITY belonging to that component, this function returns a pointer to the corresponding component-entity. If either of the specified keys is invalid, or if no such component-entity exists, the function returns NULL.
New Function: HA_Compute_Component_Entity_Keys
R19 introduces the new function HA_Compute_Component_Entity_Keys:
logical HA_Compute_Component_Entity_Keys( component_entity* comp_ent, HC_KEY& comp_key, HC_KEY& ent_key)
Given a pointer to a particular component-entity within an assembly, this function sets the HOOPS keys corresponding to its component and ENTITY segments to their current values. If unsuccessful for any reason, the function returns FALSE.
