Topology and Geometry Queries
[Kernel Functionality]

Collaboration diagram for Topology and Geometry Queries:


Classes
class	SPA_sample_edges_options
	Provides a data structure for the sampling of contiguous, unbranched edges. More...
Enumerations
enum	loop_type
	Specifies the type of a loop classified by api_loop_type. More...
Functions
outcome	api_arc_len_samples_from_edges (ENTITY_LIST const &edges, int num_samp, SPAposition points, AcisOptions ao=NULL)
	Efficiently compute equal arc length samples from a set of one or more contiguous `EDGEs`.
outcome	api_equal_turning_samples_from_edges (ENTITY_LIST const &edges, int num_samp, SPAposition points, AcisOptions ao=NULL)
	Compute equal equal turning samples from a list of `EDGE`s.
outcome	api_extract_coed_info (COEDGE coedge, logical forward, logical outward, int num_pts, SPAposition pts, SPAunit_vector *tans)
	Computes the given number of equidistant points in the parametric space of the underlying curve for the `COEDGE`.
outcome	api_get_coedges (ENTITY ent, ENTITY_LIST &coedge_list, PAT_NEXT_TYPE include_pat=PAT_CAN_CREATE, AcisOptions ao=NULL)
	Gets all the coedges related to an entity.
outcome	api_get_curve_ends (EDGE crv, SPAposition &pt1, SPAposition &pt2, AcisOptions ao=NULL)
	Gets the end points of an edge.
outcome	api_get_edges (ENTITY ent, ENTITY_LIST &edge_list, PAT_NEXT_TYPE include_pat=PAT_CAN_CREATE, AcisOptions ao=NULL)
	Gets all the edges related to an entity.
outcome	api_get_ellipse_parameters (EDGE ell, SPAposition &center, SPAunit_vector &normal, SPAvector &major_axis, double &radius_ratio, double &start_angle, double &end_angle, AcisOptions ao=NULL)
	Gets the geometry data that defines a circle or an ellipse underlying an edge.
outcome	api_get_entities (ENTITY ent, ENTITY_LIST &ent_list, ENTITY_ID topology_ids, ENTITY_ID geometry_ids, PAT_NEXT_TYPE include_pat=PAT_CAN_CREATE, AcisOptions ao=NULL)
	Gets all specified entities related to an entity.
outcome	api_get_faces (ENTITY ent, ENTITY_LIST &face_list, PAT_NEXT_TYPE include_pat=PAT_CAN_CREATE, AcisOptions ao=NULL)
	Gets all faces related to an entity.
outcome	api_get_loops (ENTITY ent, ENTITY_LIST &loop_list, PAT_NEXT_TYPE include_pat=PAT_CAN_CREATE, AcisOptions ao=NULL)
	Gets all loops related to an entity.
outcome	api_get_lumps (ENTITY ent, ENTITY_LIST &lump_list, PAT_NEXT_TYPE include_pat=PAT_CAN_CREATE, AcisOptions ao=NULL)
	Gets all lumps related to an entity.
outcome	api_get_owner (ENTITY ent, ENTITY &owner, AcisOptions *ao=NULL)
	Gets the top level owner of an `ENTITY`.
outcome	api_get_shells (ENTITY ent, ENTITY_LIST &shell_list, PAT_NEXT_TYPE include_pat=PAT_CAN_CREATE, AcisOptions ao=NULL)
	Gets all shells related to an entity.
outcome	api_get_tcoedges (ENTITY ent, ENTITY_LIST &tcoedge_list, PAT_NEXT_TYPE include_pat=PAT_CAN_CREATE, AcisOptions ao=NULL)
	Gets all the tcoedges related to an entity.
outcome	api_get_tedges (ENTITY ent, ENTITY_LIST &tedge_list, PAT_NEXT_TYPE include_pat=PAT_CAN_CREATE, AcisOptions ao=NULL)
	Gets all the tedges related to an entity.
outcome	api_get_tvertices (ENTITY ent, ENTITY_LIST &tvertex_list, PAT_NEXT_TYPE include_pat=PAT_CAN_CREATE, AcisOptions ao=NULL)
	Gets all `TVERTEX`es related to an entity.
outcome	api_get_vertices (ENTITY ent, ENTITY_LIST &vertex_list, PAT_NEXT_TYPE include_pat=PAT_CAN_CREATE, AcisOptions ao=NULL)
	Gets all vertices related to an entity.
outcome	api_get_wires (ENTITY ent, ENTITY_LIST &out_list, PAT_NEXT_TYPE include_pat=PAT_CAN_CREATE, AcisOptions ao=NULL)
	Gets all the wires related to an entity.
outcome	api_loop_type (LOOP *in_loop, loop_type &type, int info[2]=NULL)
	Determines the `loop_type` of a given loop.
outcome	api_sample_edges (ENTITY_LIST const &edges, SPAposition_vector &points, SPA_sample_edges_options eso=NULL, AcisOptions ao=NULL)
	Compute samples from a list of `EDGE`s with user-specified maximum distance and turning angle.
outcome	api_sheet_loop (EDGE ed, ENTITY_LIST &loop, AcisOptions ao=NULL)
	Find the edges comprising a connected branch of the boundary of a sheet body or open solid which includes the input seed edge.
ENTITY *	find_loop (ENTITY ent1, ENTITY ent2)
	Get the face `LOOP` determined by the two input `ENTITY`s.
int	get_ATTRIB_SYS_TYPE ()
	Gets the type of system attribute.
int	get_ATTRIB_TSL_TYPE ()
	Gets the type of `TSL` attribute.
void	get_coedges (ENTITY *ent, ENTITY_LIST &coed_list, PAT_NEXT_TYPE include_pat=PAT_CAN_CREATE)
	Get a list of `COEDGE`s from an `ENTITY`.
void	get_connected_entities (ENTITY *ent, ENTITY_LIST &list)
	Get all connected `ENTITY`s.
logical	get_curve_center (EDGE *crv, SPAposition &center)
	Gets the center of a circular or elliptical `EDGE`.
void	get_edges (ENTITY *ent, ENTITY_LIST &edge_list, PAT_NEXT_TYPE include_pat=PAT_CAN_CREATE)
	Get a list of `EDGE`s from an `ENTITY`.
logical	get_entities (ENTITY *entity, ENTITY_LIST &list, ENTITY_ID topo_id, ENTITY_ID geom_id, PAT_NEXT_TYPE include_pat=PAT_CAN_CREATE)
	Gets all specified entities related to an entity.
void	get_faces (ENTITY *ent, ENTITY_LIST &face_list, PAT_NEXT_TYPE include_pat=PAT_CAN_CREATE)
	Get a list of `FACE`s from an `ENTITY`.
void	get_laminar_edges (ENTITY *ent, ENTITY_LIST &edge_list, PAT_NEXT_TYPE include_pat=PAT_CAN_CREATE)
	Get a list of laminar `EDGE`s from an `ENTITY`.
void	get_loops (ENTITY *ent, ENTITY_LIST &loop_list, PAT_NEXT_TYPE include_pat=PAT_CAN_CREATE)
	Get a list of `LOOP`s from an `ENTITY`.
void	get_lumps (ENTITY *ent, ENTITY_LIST &lump_list, PAT_NEXT_TYPE include_pat=PAT_CAN_CREATE)
	Get a list of `LUMP`s from an `ENTITY`.
double	SPA_sample_edges_options::get_maxLen () const
	Gets the max arc length between samples; this is meaningful only if using the methods `max_len` or `max_len_and_turning`.
double	SPA_sample_edges_options::get_maxTurning () const
	Gets the max turning between samples; this is meaningful only if using the methods `max_turning` or `max_len_and_turning`.
method	SPA_sample_edges_options::get_method () const
	Gets the method to be used for sampling, returning an enum `SPA_edges_sample_options::method`.
int	SPA_sample_edges_options::get_num_samp () const
	Gets the number of samples to get; this is meaningful only if using the methods `numsamp_arc_len` or `numsamp_equal_turning`.
void	get_shells (ENTITY *ent, ENTITY_LIST &shell_list, PAT_NEXT_TYPE include_pat=PAT_CAN_CREATE)
	Get a list of `SHELL`s from an `ENTITY`.
void	get_tcoedges (ENTITY *ent, ENTITY_LIST &tcoed_list, PAT_NEXT_TYPE include_pat=PAT_CAN_CREATE)
	Get a list of `TCOEDGE`s from an `ENTITY`.
void	get_tedges (ENTITY *ent, ENTITY_LIST &tedge_list, PAT_NEXT_TYPE include_pat=PAT_CAN_CREATE)
	Get a list of `TEDGE`s from an `ENTITY`.
void	get_tvertices (ENTITY *ent, ENTITY_LIST &tvert_list, PAT_NEXT_TYPE include_pat=PAT_CAN_CREATE)
	Get a list of `TVERTEX`es from an `ENTITY`.
void	get_vertices (ENTITY *ent, ENTITY_LIST &vert_list, PAT_NEXT_TYPE include_pat=PAT_CAN_CREATE)
	Get a list of `VERTEX`es from an `ENTITY`.
logical	get_wire_plane (WIRE *this_wire, SPAposition &centroid, SPAunit_vector &normal, logical apply_transf=TRUE)
	Gets the plane of a 3D `WIRE`.
void	get_wires (ENTITY *ent, ENTITY_LIST &wire_list, PAT_NEXT_TYPE include_pat=PAT_CAN_CREATE)
	Get a list of `WIRE`s from an `ENTITY`.
logical	is_analytic_face (const ENTITY *)
	Determines if the `ENTITY` is an analytic face; that is, a `FACE` whose underlying geometry is an analytic `surface`.
logical	is_ANNOTATION (const ENTITY *ent)
	Determines if an `ENTITY` is an `ANNOTATION`.
logical	is_APOINT (const ENTITY *ent)
	Determines if an `ENTITY` is an `APOINT`.
logical	is_ATTRIB (const ENTITY *ent)
	Determines if an `ENTITY` is an `ATTRIB`.
logical	is_ATTRIB_CT (const ENTITY *ent)
	Determines if an `ENTITY` is a `ATTRIB_CT`.
logical	is_ATTRIB_ST (const ENTITY *ent)
	Determines if an `ENTITY` is an `ATTRIB_ST`.
logical	is_BODY (const ENTITY *ent)
	Determines if an `ENTITY` is a `BODY`.
logical	is_circular (const curve *crv)
	Determines if a `curve` is a circular `ellipse`.
logical	is_circular_edge (const ENTITY *ent)
	Determines if an `ENTITY` is a circular edge; that is, an `EDGE` whose underlying geometry is a circular `ellipse`.
logical	is_closed_curve (EDGE *crv)
	Determines if a curve is closed.
logical	is_closed_solid_body (const ENTITY *ent)
	Determines if an `ENTITY` is a closed solid `BODY`.
logical	is_COEDGE (const ENTITY *ent)
	Determines if an `ENTITY` is a `COEDGE`.
logical	is_composite_curve (const curve *crv)
	Determines if a `curve` is a composite curve constructed from multiple `law`s.
logical	is_cone (const surface *surf)
	Determines if a `surface` is a `cone`.
logical	is_CONE (const ENTITY *ent)
	Determines if an `ENTITY` is a `CONE`.
logical	is_conical_face (const ENTITY *ent)
	Determines if an `ENTITY` is a conical face; that is, a `FACE` whose underlying geometry is a `cone`.
logical	is_connected_body (const ENTITY *ent)
	Determines if an `ENTITY` is a connected `BODY`.
logical	is_CURVE (const ENTITY *ent)
	Determines if an `ENTITY` is a `CURVE`.
logical	is_curve_edge (const ENTITY *ent)
	Determines if an `ENTITY` is a `EDGE` with a `CURVE`.
logical	is_cylinder (const surface *surf)
	This composite test checks for a `cone` that is cylindrical and circular.
logical	is_cylindrical_face (const ENTITY *ent)
	Determines if an `ENTITY` is a cylindrical face; that is, a `FACE` whose underlying geometry is a cylindrical `cone`.
logical	is_EDGE (const ENTITY *ent)
	Determines if an `ENTITY` is an `EDGE`.
logical	is_ellipse (const curve *crv)
	Determines if a `curve` is an `ellipse`.
logical	is_ELLIPSE (const ENTITY *ent)
	Determines if an `ENTITY` is an `ELLIPSE`.
logical	is_elliptical_edge (const ENTITY *ent)
	Determines if an `ENTITY` is an elliptical edge; that is, an `EDGE` whose underlying geometry is an `ellipse`.
logical	is_FACE (const ENTITY *ent)
	Determines if an `ENTITY` is a `FACE`.
logical	is_helical_edge (const ENTITY *ent)
	Determines if an `ENTITY` is a helical edge; that is, an `EDGE` whose underlying geometry is a `helix`.
logical	is_helix (const curve *crv)
	Determines if a `curve` is a `helix`.
logical	is_HELIX (const ENTITY *ent)
	Determines if an `ENTITY` is a `HELIX`.
logical	is_intcurve (const curve *crv)
	Determines if a `curve` is an `intcurve`.
logical	is_INTCURVE (const ENTITY *ent)
	Determines if an `ENTITY` is an `INTCURVE`.
logical	is_intcurve_edge (const ENTITY *ent)
	Determines if an `ENTITY` is an intcurve edge; that is, an `EDGE` whose underlying geometry is an `intcurve`.
logical	is_LAW (const ENTITY *ent)
	Determines if a specified `ENTITY` is a `LAW`.
logical	is_linear_edge (const ENTITY *ent)
	Determines if an `ENTITY` is a linear edge; that is, an `EDGE` whose underlying geometry is a `straight`.
logical	is_LOOP (const ENTITY *ent)
	Determines if an `ENTITY` is a `LOOP`.
logical	is_LUMP (const ENTITY *ent)
	Determines if an `ENTITY` is a `LUMP`.
logical	is_mixed_body (const ENTITY *ent)
	Determines if an `ENTITY` is a mixed `BODY`.
logical	is_PCURVE (const ENTITY *ent)
	Determines if an `ENTITY` is a `PCURVE`.
logical	is_planar_face (const ENTITY *ent)
	Determines if an `ENTITY` is a planar face; that is, a `FACE` whose underlying geometry is a `plane`.
logical	is_planar_wire (COEDGE *this_coedge, SPAposition &centroid, SPAunit_vector &normal, logical apply_transf=TRUE, logical use_winding_number=TRUE)
	Determines if a `WIRE` is planar.
logical	is_planar_wire (WIRE *this_wire, SPAposition &centroid, SPAunit_vector &normal, logical apply_transf=TRUE, logical use_winding_number=TRUE)
	Determines if a `WIRE` is planar.
logical	is_plane (const surface *surf)
	Determines if a `surface` is a `plane.`
logical	is_PLANE (const ENTITY *ent)
	Determines if an `ENTITY` is a `PLANE`.
logical	is_SHELL (const ENTITY *ent)
	Determines if an `ENTITY` is a `SHELL`.
logical	is_solid_body (const ENTITY *ent)
	Determines if an `ENTITY` is a solid `BODY`.
logical	is_SPACOLLECTION (const ENTITY *ent)
	Determines if an `ENTITY` is a `SPACOLLECTION`.
logical	is_sphere (const surface *surf)
	Determines if a `surface` is a `sphere`.
logical	is_SPHERE (const ENTITY *ent)
	Determines if an `ENTITY` is a `SPHERE`.
logical	is_spherical_face (const ENTITY *ent)
	Determines if an `ENTITY` is a spherical face; that is, a `FACE` whose underlying geometry is a `sphere`.
logical	is_spline (const surface *surf)
	Determines if a `surface` is a `spline`.
logical	is_SPLINE (const ENTITY *ent)
	Determines if an `ENTITY` is a `SPLINE`.
logical	is_spline_face (const ENTITY *ent)
	Determines if the `ENTITY` is a spline face; that is, a `FACE` whose underlying geometry is a `spline`.
logical	is_straight (const curve *crv)
	Determines if a `curve` is a `straight`.
logical	is_STRAIGHT (const ENTITY *ent)
	Determines if an `ENTITY` is a `STRAIGHT`.
logical	is_SUBSHELL (const ENTITY *ent)
	Determines if an `ENTITY` is a `SUBSHELL`.
logical	is_SURFACE (const ENTITY *ent)
	Determines if an `ENTITY` is a `SURFACE`.
logical	is_TEXT_ENT (const ENTITY *ent)
	Determines if an `ENTITY` is a `TEXT_ENT`.
logical	is_toplevel (const ENTITY *ent)
	Determines if an `ENTITY` is top level.
logical	is_toroidal_face (const ENTITY *ent)
	Determines if the `ENTITY` is a toroidal face; that is, a `FACE` whose underlying geometry is a `torus`.
logical	is_torus (const surface *surf)
	Determines if a `surface` is a `torus`.
logical	is_TORUS (const ENTITY *ent)
	Determines if an `ENTITY` is a `TORUS`.
logical	is_VERTEX (const ENTITY *ent)
	Determines if the `ENTITY` is a `VERTEX`.
logical	is_WIRE (const ENTITY *ent)
	Determines if an `ENTITY` is a `WIRE`.
logical	is_wire_body (const ENTITY *ent)
	Determines if an `ENTITY` is a wire `BODY`.
logical	isolated_vertex (VERTEX *vert)
	Determines if a vertex is an isolated vertex.
void	SPA_sample_edges_options::set_as_max_len (double maxLen)
	Sets the options for sampling with the method `max_len` Role: Sets the SPA_edges_sample_options to sample such that there is user-specified arc length of the curves between samples.
void	SPA_sample_edges_options::set_as_max_len_and_turning (double maxLen, double maxTurning)
	Sets the options for sampling with the method `max_len_and_turning` Role: Sets the SPA_edges_sample_options to sample such that between samples, either the arc length is user-specified, or the turning is user-specified, and neither is greater than the user-specifications.
void	SPA_sample_edges_options::set_as_max_turning (double maxTurning)
	Sets the options for sampling with the method `max_turning` Role: Sets the SPA_edges_sample_options to sample such that there is users-specified equal turning of the curves between samples.
void	SPA_sample_edges_options::set_as_num_samp_arc_len (int nSamp)
	Sets the options for sampling with the method `numsamp_arc_len` Role: Sets the SPA_edges_sample_options to sample such that there is equal arc length of the curves between samples, with the user-specified total number of samples.
void	SPA_sample_edges_options::set_as_num_samp_equal_turning (int nSamp)
	Sets the options for sampling with the method `numsamp_equal_turning` Role: Sets the SPA_edges_sample_options to sample such that there is equal turning of the curves between samples, with the user-specified total number of samples.

Enumeration Type Documentation

enum loop_type

Specifies the type of a loop classified by api_loop_type.

Parameters:

	loop_unknown	Unable to determine loop type.
	loop_periphery	Closed loop bounding "outside" of face.
	loop_hole	Closed loop bounding interior "hole" in face.
	loop_separation	Not Used
	loop_u_separation	Loop which crosses the "v" seam on a surface, an odd number of times, separating the surface in the u direction.
	loop_v_separation	Loop which crosses the "u" seam on a surface, an odd number of times, separating the surface in the v direction.
	loop_uv_separation	Loop which crosses both the "v" and "u" seams on a surface, an odd number of times, separating the surface in both the u and v directions.

include <ptfcenum.hxx>

Function Documentation

outcome api_arc_len_samples_from_edges	(	ENTITY_LIST const &	edges,
		int	num_samp,
		SPAposition *	points,
		AcisOptions *	ao = `NULL`
	)

Efficiently compute equal arc length samples from a set of one or more contiguous EDGEs.

The input edges must be contiguous within SPAresabs, or the corresponding TVERTEX tolerances.

Effect: Read-only.

Parameters:

	edges	input EDGEs.
	num_samp	input number of samples wanted; must be >= 2.
	points	returned SPApositions. Note: before calling, points must be allocated of size num_samp. The caller owns points, and must delete at the end of its lifetime.
	ao	ACIS options such as versioning and journaling.

include <wire_qry.hxx>

outcome api_equal_turning_samples_from_edges	(	ENTITY_LIST const &	edges,
		int	num_samp,
		SPAposition *	points,
		AcisOptions *	ao = `NULL`
	)

Compute equal equal turning samples from a list of EDGEs.

The turning is computed in magnitude - the direction is not considered. Non-G1 discontinuities in or between the edges can introduce inaccuracies, which are bounded by the size of the non-G1 angular jumps. The sample spacing should be larger than the largest non-G1 angular jump - visually sharp edge connections should not be included. The input edges must not all be geometrically linar (flat).

Effect: Read-only.

Parameters:

	edges	input EDGEs,
	num_samp	input number of samples wanted; must be >= 2.
	points	returned SPApositions. Note: before calling, points must be allocated of size num_samp. The caller owns points, and must delete at the end of its lifetime.
	ao	ACIS options such as versioning and journaling.

include <sample_edges.hxx>

outcome api_extract_coed_info	(	COEDGE *	coedge,
		logical	forward,
		logical	outward,
		int	num_pts,
		SPAposition *	pts,
		SPAunit_vector *	tans
	)

Computes the given number of equidistant points in the parametric space of the underlying curve for the COEDGE.

Role: This API returns surface tangents perpendicular to the curve. Sense flag forward controls the direction for ordering of points. Sense flag outward indicates whether the face tangent points away from or into the face. This function is useful for interpolating surfaces to join with the face.

Errors: NULL ENTITY or not a COEDGE.

Effect: Read-only

Journal: Not Available

Product(s): 3D ACIS Exchange, 3D Viz Exchange, 3D ACIS Modeler

Parameters:

	coedge	coedge of face.
	forward	forward direction of evaluation.
	outward	tangents point off of face.
	num_pts	size of arrays/number of points where to evaluate.
	pts	points along edge returned (user allocates arrays).
	tans	surface tangents along edge at positions returned.

include <kernapi.hxx>

outcome api_get_coedges	(	ENTITY *	ent,
		ENTITY_LIST &	coedge_list,
		PAT_NEXT_TYPE	include_pat = `PAT_CAN_CREATE`,
		AcisOptions *	ao = `NULL`
	)

Gets all the coedges related to an entity.

Role: If the input entity (ent) has COEDGEs (i.e., BODY, LUMP, FACE, etc.), this API returns all COEDGEs of the entity.

By default, patterned objects are included in the list of entities. In general, however, the parameter include_pat determines how this function deals with such objects. The user may specify one of the following actions through this argument:

PAT_CAN_CREATE: - patterned objects are created if they do not already exist, and are included in the list.
PAT_NO_CREATE: - only those patterned objects that have already been created are included in the list.
PAT_IGNORE: - no patterned objects besides seed pattern objects are included in the list.

Effect: Usually Read-only; however, if include_pat == PAT_CAN_CREATE and unexpanded patterns exist, then this function can create topological entities.

Journal: Available

Product(s): 3D ACIS Exchange, 3D Viz Exchange, 3D ACIS Modeler

Parameters:

	ent	entity to examine.
	coedge_list	returned list of coedges related to the input entity.
	include_pat	how to treat patterned coedges.
	ao	ACIS options.

include <kernapi.hxx>

outcome api_get_curve_ends	(	EDGE *	crv,
		SPAposition &	pt1,
		SPAposition &	pt2,
		AcisOptions *	ao = `NULL`
	)

Gets the end points of an edge.

Role: This API returns the end points of an edge. If the edge is part of a body that has an attached transformation, the returned positions will be transformed using the transformation of the body. This API function requires the edge to have an underlying curve.

Effect: Read-only

Journal: Not Available

Product(s): 3D ACIS Exchange, 3D Viz Exchange, 3D ACIS Modeler

Parameters:

	crv	the given edge.
	pt1	start position returned.
	pt2	end position returned.
	ao	ACIS options.

include <kernapi.hxx>

outcome api_get_edges	(	ENTITY *	ent,
		ENTITY_LIST &	edge_list,
		PAT_NEXT_TYPE	include_pat = `PAT_CAN_CREATE`,
		AcisOptions *	ao = `NULL`
	)

Gets all the edges related to an entity.

Role: If the input entity (ent) has EDGEs (i.e., BODY, LUMP, FACE, etc.), this API returns all EDGEs of the entity. The input entity can also be a VERTEX, in which case this API returns all EDGEs that share the common VERTEX.

By default, patterned objects are included in the list of entities. In general, however, the parameter include_pat determines how this function deals with such objects. The user may specify one of the following actions through this argument:

PAT_CAN_CREATE: - patterned objects are created if they do not already exist, and are included in the list.
PAT_NO_CREATE: - only those patterned objects that have already been created are included in the list.
PAT_IGNORE: - no patterned objects besides seed pattern objects are included in the list.

Effect: Usually Read-only; however, if include_pat == PAT_CAN_CREATE and unexpanded patterns exist, then this function can create topological entities.

Journal: Available

Product(s): 3D ACIS Exchange, 3D Viz Exchange, 3D ACIS Modeler

Parameters:

	ent	entity to examine.
	edge_list	returned list of edges related to the input entity.
	include_pat	how to treat patterned edges.
	ao	ACIS options.

include <kernapi.hxx>

outcome api_get_ellipse_parameters	(	EDGE *	ell,
		SPAposition &	center,
		SPAunit_vector &	normal,
		SPAvector &	major_axis,
		double &	radius_ratio,
		double &	start_angle,
		double &	end_angle,
		AcisOptions *	ao = `NULL`
	)

Gets the geometry data that defines a circle or an ellipse underlying an edge.

Errors: The curve under the EDGE is not an elliptical curve.

Effect: Read-only

Journal: Not Available

Product(s): 3D ACIS Exchange, 3D Viz Exchange, 3D ACIS Modeler

Parameters:

	ell	elliptical or circular edge.
	center	center returned.
	normal	normal to plane of ellipse returned.
	major_axis	major axis returned (length equals major radius).
	radius_ratio	ratio of major radius to minor radius returned.
	start_angle	start angle in radians returned.
	end_angle	end angle in radians returned.
	ao	ACIS options.

include <kernapi.hxx>

outcome api_get_entities	(	ENTITY *	ent,
		ENTITY_LIST &	ent_list,
		ENTITY_ID	topology_ids,
		ENTITY_ID	geometry_ids,
		PAT_NEXT_TYPE	include_pat = `PAT_CAN_CREATE`,
		AcisOptions *	ao = `NULL`
	)

Gets all specified entities related to an entity.

Role: This comprehensive API behaves analogous to the collection of like API's that return the related entities of a specific entity, such as api_get_faces and api_get_edges. This API however allows the specification of multiple entity types to be returned from a single pass of the traversal algorithm. The entity selection is made by passing a bit mask of topological IDs, and optionally geometrical IDs, to the API. The bit masks are created by "or-ing" the respective IDs together, as the following example demonstrates:

    ENTITY_ID topo_bits = FACE_ID | EDGE_ID;
    ENTITY_ID geom._bits = SURFACE_ID | CURVE_ID;

The ENTITY_ID bit masks are categorized into topology IDs and geometry IDs, and cannot be mixed. They are however, mutually exclusive within their respective groups.

The following topological IDs are available:

BODY_ID, LUMP_ID, SHELL_ID, SUBSHELL_ID, WIRE_ID, FACE_ID, LOOP_ID, COEDGE_ID, EDGE_ID, VERTEX_ID

The following geometrical IDs are available:

TRANSFORM_ID, APOINT_ID, PCURVE_ID, SURFACE_ID, CURVE_ID

Given a set of topological ID selections, the traversal algorithm searches for the selected entities from the level of the input entity within the topological hierarchy, and works its way down, selecting all that are lower in the hierarchical order. When the selection set contains entity IDs that are higher in the topological hierarchy than the input entity, then the higher-level entities that share the input entities are also selected.

Given a FACE input entity with LUMP_ID and LOOP_ID selection IDs, for example, the algorithm would select the owning LUMP, ignoring others, and would halt the traversal after selecting all loops of the face since the LOOP_ID is the lowest selection ID.

The algorithm does not traverse laterally and will simply select the input entity in this case. For example, given a FACE input entity and a FACE_ID selection, the input face would be returned.

The geometrical ID selections drive the algorithm in the same manner and assume the same level in the hierarchy as their topological owners.

By default, patterned objects are included in the list of entities. In general, however, the parameter include_pat determines how this function deals with such objects. The user may specify one of the following actions through this argument:

PAT_CAN_CREATE: - patterned objects are created if they do not already exist, and are included in the list.
PAT_NO_CREATE: - only those patterned objects that have already been created are included in the list.
PAT_IGNORE: - no patterned objects besides seed pattern objects are included in the list.

Effect: Usually Read-only; however, if include_pat == PAT_CAN_CREATE and unexpanded patterns exist, then this function can create topological entities.

Journal: Available

Product(s): 3D ACIS Exchange, 3D Viz Exchange, 3D ACIS Modeler

Parameters:

	ent	entity to examine.
	ent_list	returned list of related entities.
	topology_ids	topological selection.
	geometry_ids	geometrical selection.
	include_pat	how to treat patterned faces.
	ao	ACIS options.

include <kernapi.hxx>

outcome api_get_faces	(	ENTITY *	ent,
		ENTITY_LIST &	face_list,
		PAT_NEXT_TYPE	include_pat = `PAT_CAN_CREATE`,
		AcisOptions *	ao = `NULL`
	)

Gets all faces related to an entity.

Role: If the input entity (ent) is a BODY, LUMP, or SHELL, this API returns all FACEs of that entity. If the input entity is an EDGE, LOOP, or VERTEX, this API returns all FACEs that share the EDGE, LOOP, or VERTEX.

By default, patterned objects are included in the list of entities. In general, however, the parameter include_pat determines how this function deals with such objects. The user may specify one of the following actions through this argument:

PAT_CAN_CREATE: - patterned objects are created if they do not already exist, and are included in the list.
PAT_NO_CREATE: - only those patterned objects that have already been created are included in the list.
PAT_IGNORE: - no patterned objects besides seed pattern objects are included in the list.

Effect: Usually Read-only; however, if include_pat == PAT_CAN_CREATE and unexpanded patterns exist, then this function can create topological entities.

Journal: Available

Product(s): 3D ACIS Exchange, 3D Viz Exchange, 3D ACIS Modeler

Parameters:

	ent	entity to examine.
	face_list	returned list of faces related to the input entity.
	include_pat	how to treat patterned faces.
	ao	ACIS options.

include <kernapi.hxx>

outcome api_get_loops	(	ENTITY *	ent,
		ENTITY_LIST &	loop_list,
		PAT_NEXT_TYPE	include_pat = `PAT_CAN_CREATE`,
		AcisOptions *	ao = `NULL`
	)

Gets all loops related to an entity.

Role: If the input entity (ent) is a BODY, LUMP, FACE, EDGE, SHELL, or VERTEX, this API returns all LOOPs of that entity.

By default, patterned objects are included in the list of entities. In general, however, the parameter include_pat determines how this function deals with such objects. The user may specify one of the following actions through this argument:

PAT_CAN_CREATE: - patterned objects are created if they do not already exist, and are included in the list.
PAT_NO_CREATE: - only those patterned objects that have already been created are included in the list.
PAT_IGNORE: - no patterned objects besides seed pattern objects are included in the list.

Effect: Usually Read-only; however, if include_pat == PAT_CAN_CREATE and unexpanded patterns exist, then this function can create topological entities.

Journal: Available

Product(s): 3D ACIS Exchange, 3D Viz Exchange, 3D ACIS Modeler

Parameters:

	ent	entity to examine.
	loop_list	returned list of loops related to the input entity.
	include_pat	how to treat patterned loops.
	ao	ACIS options.

include <kernapi.hxx>

outcome api_get_lumps	(	ENTITY *	ent,
		ENTITY_LIST &	lump_list,
		PAT_NEXT_TYPE	include_pat = `PAT_CAN_CREATE`,
		AcisOptions *	ao = `NULL`
	)

Gets all lumps related to an entity.

Role: If the input entity (ent) is a BODY, SHELL, FACE, EDGE, LOOP, or VERTEX, this API returns all LUMPs of that entity.

By default, patterned objects are included in the list of entities. In general, however, the parameter include_pat determines how this function deals with such objects. The user may specify one of the following actions through this argument:

PAT_CAN_CREATE: - patterned objects are created if they do not already exist, and are included in the list.
PAT_NO_CREATE: - only those patterned objects that have already been created are included in the list.
PAT_IGNORE: - no patterned objects besides seed pattern objects are included in the list.

Effect: Usually Read-only; however, if include_pat == PAT_CAN_CREATE and unexpanded patterns exist, then this function can create topological entities.

Journal: Available

Product(s): 3D ACIS Exchange, 3D Viz Exchange, 3D ACIS Modeler

Parameters:

	ent	entity to examine.
	lump_list	returned list of lumps related to the input entity.
	include_pat	how to treat patterned lumps.
	ao	ACIS options.

include <kernapi.hxx>

outcome api_get_owner	(	ENTITY *	ent,
		ENTITY *&	owner,
		AcisOptions *	ao = `NULL`
	)

Gets the top level owner of an ENTITY.

Role: This API finds the top level ENTITY that "owns" the given ENTITY (ent). For the purpose of this API, an ENTITY owns another ENTITY if the second ENTITY is part of the definition of the first.

For example, if an EDGE is created with one of the curve-creation API functions, that EDGE is not owned by any other ENTITY. If a solid is created, the EDGEs of that solid are owned by the solid. For an EDGE, FACE, VERTEX, etc., that is a part of a solid, this API returns the BODY pointer of the solid. If the ENTITY is not owned by another ENTITY, then the pointer returns itself.

An ENTITY is top level when making a call to api_get_owner returns itself. Also, every ENTITY contains an owner method. This method returns the next higher ENTITY. If that object is the top level ENTITY, then the this pointer is returned. This means that if a FACE does not point to an owning SHELL, this FACE is top level for that model. A BODY is normally top level, but in some cases, there are others that are the top level ENTITY.

Effect: Read-only

Journal: Not Available

Product(s): 3D ACIS Exchange, 3D Viz Exchange, 3D ACIS Modeler

Parameters:

	ent	entity to determine owner.
	owner	top level owner of entity returned.
	ao	ACIS options.

include <kernapi.hxx>

outcome api_get_shells	(	ENTITY *	ent,
		ENTITY_LIST &	shell_list,
		PAT_NEXT_TYPE	include_pat = `PAT_CAN_CREATE`,
		AcisOptions *	ao = `NULL`
	)

Gets all shells related to an entity.

Role: If the input entity (ent) is a BODY, LUMP, FACE, EDGE, LOOP, or VERTEX, this API returns all SHELLs of that entity.

By default, patterned objects are included in the list of entities. In general, however, the parameter include_pat determines how this function deals with such objects. The user may specify one of the following actions through this argument:

PAT_CAN_CREATE: - patterned objects are created if they do not already exist, and are included in the list.
PAT_NO_CREATE: - only those patterned objects that have already been created are included in the list.
PAT_IGNORE: - no patterned objects besides seed pattern objects are included in the list.

Effect: Usually Read-only; however, if include_pat == PAT_CAN_CREATE and unexpanded patterns exist, then this function can create topological entities.

Journal: Available

Product(s): 3D ACIS Exchange, 3D Viz Exchange, 3D ACIS Modeler

Parameters:

	ent	entity to examine.
	shell_list	returned list of shells related to the input entity.
	include_pat	how to treat patterned shells.
	ao	ACIS options.

include <kernapi.hxx>

outcome api_get_tcoedges	(	ENTITY *	ent,
		ENTITY_LIST &	tcoedge_list,
		PAT_NEXT_TYPE	include_pat = `PAT_CAN_CREATE`,
		AcisOptions *	ao = `NULL`
	)

Gets all the tcoedges related to an entity.

Role: If the input entity (ent) has TCOEDGEs (i.e., BODY, LUMP, FACE, etc.), this function returns all TCOEDGEs of the entity.

By default, patterned objects are included in the list of entities. In general, however, the parameter include_pat determines how this function deals with such objects. The user may specify one of the following actions through this argument:

PAT_CAN_CREATE: - patterned objects are created if they do not already exist, and are included in the list.
PAT_NO_CREATE: - only those patterned objects that have already been created are included in the list.
PAT_IGNORE: - no patterned objects besides seed pattern objects are included in the list.

Effect: Usually Read-only; however, if include_pat == PAT_CAN_CREATE and unexpanded patterns exist, then this function can create topological entities.

Journal: Available

Product(s): 3D ACIS Exchange, 3D Viz Exchange, 3D ACIS Modeler

Parameters:

	ent	entity to examine.
	tcoedge_list	returned list of tcoedges related to the input entity.
	include_pat	how to treat patterned tcoedges.
	ao	ACIS options.

include <kernapi.hxx>

outcome api_get_tedges	(	ENTITY *	ent,
		ENTITY_LIST &	tedge_list,
		PAT_NEXT_TYPE	include_pat = `PAT_CAN_CREATE`,
		AcisOptions *	ao = `NULL`
	)

Gets all the tedges related to an entity.

Role: If the input entity (ent) has TEDGEs (i.e., BODY, LUMP, FACE, etc.), this function returns all TEDGEs of the entity. The input entity can also be a VERTEX, in which case this function returns all TEDGEs that share the common VERTEX.

By default, patterned objects are included in the list of entities. In general, however, the parameter include_pat determines how this function deals with such objects. The user may specify one of the following actions through this argument:

PAT_CAN_CREATE: - patterned objects are created if they do not already exist, and are included in the list.
PAT_NO_CREATE: - only those patterned objects that have already been created are included in the list.
PAT_IGNORE: - no patterned objects besides seed pattern objects are included in the list.

Effect: Usually Read-only; however, if include_pat == PAT_CAN_CREATE and unexpanded patterns exist, then this function can create topological entities.

Journal: Available

Product(s): 3D ACIS Exchange, 3D Viz Exchange, 3D ACIS Modeler

Parameters:

	ent	entity to examine.
	tedge_list	returned list of tedges related to the input entity.
	include_pat	how to treat patterned tedges.
	ao	ACIS options.

include <kernapi.hxx>

outcome api_get_tvertices	(	ENTITY *	ent,
		ENTITY_LIST &	tvertex_list,
		PAT_NEXT_TYPE	include_pat = `PAT_CAN_CREATE`,
		AcisOptions *	ao = `NULL`
	)

Gets all TVERTEXes related to an entity.

Role: If the specified entity (ent) is a BODY, LUMP, SHELL, FACE, EDGE, or LOOP, this function returns all TVERTEXes of that entity.

By default, patterned objects are included in the list of entities. In general, however, the parameter include_pat determines how this function deals with such objects. The user may specify one of the following actions through this argument:

PAT_CAN_CREATE: - patterned objects are created if they do not already exist, and are included in the list.
PAT_NO_CREATE: - only those patterned objects that have already been created are included in the list.
PAT_IGNORE: - no patterned objects besides seed pattern objects are included in the list.

Effect: Usually Read-only; however, if include_pat == PAT_CAN_CREATE and unexpanded patterns exist, then this function can create topological entities.

Journal: Available

Product(s): 3D ACIS Exchange, 3D Viz Exchange, 3D ACIS Modeler

Parameters:

	ent	entity to examine.
	tvertex_list	returned list of tvertices related to the input entity.
	include_pat	how to treat patterned tvertices.
	ao	ACIS options.

include <kernapi.hxx>

outcome api_get_vertices	(	ENTITY *	ent,
		ENTITY_LIST &	vertex_list,
		PAT_NEXT_TYPE	include_pat = `PAT_CAN_CREATE`,
		AcisOptions *	ao = `NULL`
	)

Gets all vertices related to an entity.

Role: If the specified entity (ent) is a BODY, LUMP, SHELL, FACE, EDGE, or LOOP, this API returns all VERTEXes of that entity.

By default, patterned objects are included in the list of entities. In general, however, the parameter include_pat determines how this function deals with such objects. The user may specify one of the following actions through this argument:

PAT_CAN_CREATE: - patterned objects are created if they do not already exist, and are included in the list.
PAT_NO_CREATE: - only those patterned objects that have already been created are included in the list.
PAT_IGNORE: - no patterned objects besides seed pattern objects are included in the list.

Effect: Usually Read-only; however, if include_pat == PAT_CAN_CREATE and unexpanded patterns exist, then this function can create topological entities.

Journal: Available

Product(s): 3D ACIS Exchange, 3D Viz Exchange, 3D ACIS Modeler

Parameters:

	ent	entity to examine.
	vertex_list	returned list of vertices related to the input entity.
	include_pat	how to treat patterned vertices.
	ao	ACIS options.

include <kernapi.hxx>

outcome api_get_wires	(	ENTITY *	ent,
		ENTITY_LIST &	out_list,
		PAT_NEXT_TYPE	include_pat = `PAT_CAN_CREATE`,
		AcisOptions *	ao = `NULL`
	)

Gets all the wires related to an entity.

Role: If the input entity (ent) has WIREs (i.e., BODY, LUMP, etc.), this API returns all the WIREs of the entity.

By default, patterned objects are included in the list of entities. In general, however, the parameter include_pat determines how this function deals with such objects. The user may specify one of the following actions through this argument:

PAT_CAN_CREATE: - patterned objects are created if they do not already exist, and are included in the list.
PAT_NO_CREATE: - only those patterned objects that have already been created are included in the list.
PAT_IGNORE: - no patterned objects besides seed pattern objects are included in the list.

Effect: Usually Read-only; however, if include_pat == PAT_CAN_CREATE and unexpanded patterns exist, then this function can create topological entities.

Journal: Available

Product(s): 3D ACIS Exchange, 3D Viz Exchange, 3D ACIS Modeler

Parameters:

	ent	entity to examine.
	out_list	returned list of wires related to the input entity.
	include_pat	how to treat patterned wires.
	ao	ACIS options.

include <kernapi.hxx>

outcome api_loop_type	(	LOOP *	in_loop,
		loop_type &	type,
		int	info[2] = `NULL`
	)

Determines the loop_type of a given loop.

Role: This API returns the type of a given loop. Types include:

loop_unknown
loop_periphery
loop_hole
loop_separation (not used)
loop_u_separation
loop_v_separation
loop_uv_separation

For more information on the loop classification refer to the Classification of Loops section of the Loop Technical Article.

Effect: Read-only

Journal: Not Available

Product(s): 3D ACIS Exchange, 3D Viz Exchange, 3D ACIS Modeler

Parameters:

in_loop Loop to test.

type Type of loop. Refer to loop_type for more details about loop types.

info

Array holding information about the loop.
If type is u or v separation loop, then:

info[0] is the number of seam crossing.

info[1] is the sense of the separation loop, that is, u separation loop.

&& info[1]==1 indicates that the loop is moving up (v increasing) in the parameter rectangle.

If type is u_v separation loop, then info[0] is the number of v seam crossings, and info[1] is the number of u seam crossing.

include <kernapi.hxx>

outcome api_sample_edges	(	ENTITY_LIST const &	edges,
		SPAposition_vector &	points,
		SPA_sample_edges_options *	eso = `NULL`,
		AcisOptions *	ao = `NULL`
	)

Compute samples from a list of EDGEs with user-specified maximum distance and turning angle.

The turning is computed in magnitude - the direction is not considered. Non-G1 discontinuities in or between the edges will be skipped in the turning computation.

Effect: Read-only.

Parameters:

	edges	input EDGEs,
	max_len	Maximum distance between points.
	max_turning	Maximum turning (integrated curvature) between points.
	points	returned SPAposition_vector.
	ao	ACIS options such as versioning and journaling.

include <sample_edges.hxx>

outcome api_sheet_loop	(	EDGE *	ed,
		ENTITY_LIST &	loop,
		AcisOptions *	ao = `NULL`
	)

Find the edges comprising a connected branch of the boundary of a sheet body or open solid which includes the input seed edge.

This is analogous to a loop of a face.

Role: This API finds all of the connected edges comprising a connected portion of a sheet body or open solid. The input edge is part of the returned boundary.

Limitations: The input edge must lie on a sheet boundary, that is, must have exactly one coedge and exactly one face.

Effect: Read-only

Journal: Available

Product(s): 3D ACIS Modeler

Parameters:

	edge	edge on the sheet body boundary
	loop	returned edges comprising the boundary
	ao	ACIS options such as journal, version

include <sheet_loop.hxx>

ENTITY* find_loop	(	ENTITY *	ent1,
		ENTITY *	ent2
	)

Get the face LOOP determined by the two input ENTITYs.

If the two ENTITYs do not define a unique LOOP, then the first LOOP that they have in common is returned. If they do not share a common LOOP, then NULL is returned.

include <get_top.hxx>

int get_ATTRIB_SYS_TYPE ( )

Gets the type of system attribute.

Effect: Read-only

include <acistype.hxx>

int get_ATTRIB_TSL_TYPE ( )

Gets the type of TSL attribute.

Effect: Read-only

include <acistype.hxx>

void get_coedges	(	ENTITY *	ent,
		ENTITY_LIST &	coed_list,
		PAT_NEXT_TYPE	include_pat = `PAT_CAN_CREATE`
	)

Get a list of COEDGEs from an ENTITY.

For additional information regarding the arguments and behavior of this function refer to the documentation for the API function api_get_coedges.

include <get_top.hxx>

void get_connected_entities	(	ENTITY *	ent,
		ENTITY_LIST &	list
	)

Get all connected ENTITYs.

logical get_curve_center	(	EDGE *	crv,
		SPAposition &	center
	)

Gets the center of a circular or elliptical EDGE.

Role: Returns FALSE if the edge was not circular or elliptical.

Effect: Read-only

Parameters:

	crv	curve.
	center	returns center.

include <curveq.hxx>

void get_edges	(	ENTITY *	ent,
		ENTITY_LIST &	edge_list,
		PAT_NEXT_TYPE	include_pat = `PAT_CAN_CREATE`
	)

Get a list of EDGEs from an ENTITY.

For additional information regarding the arguments and behavior of this function refer to the documentation for the API function api_get_edges.

include <get_top.hxx>

logical get_entities	(	ENTITY *	entity,
		ENTITY_LIST &	list,
		ENTITY_ID	topo_id,
		ENTITY_ID	geom_id,
		PAT_NEXT_TYPE	include_pat = `PAT_CAN_CREATE`
	)

Gets all specified entities related to an entity.

For additional information regarding the arguments and behavior of this function refer to the documentation for the API function api_get_entities.

Parameters:

	entity	given `ENTITY`
	list	Resulting list of `ENTITY`s
	topo_id	Type of topology to search for (may be composed)
	geom_id	Type of geometry to search for (may be composed)
	include_pat	include patterns

include <get_top.hxx>

void get_faces	(	ENTITY *	ent,
		ENTITY_LIST &	face_list,
		PAT_NEXT_TYPE	include_pat = `PAT_CAN_CREATE`
	)

Get a list of FACEs from an ENTITY.

For additional information regarding the arguments and behavior of this function refer to the documentation for the API function api_get_faces.

include <get_top.hxx>

void get_laminar_edges	(	ENTITY *	ent,
		ENTITY_LIST &	edge_list,
		PAT_NEXT_TYPE	include_pat = `PAT_CAN_CREATE`
	)

Get a list of laminar EDGEs from an ENTITY.

A laminar edge, or free edge, is represented by an EDGE with only one COEDGE.

include <get_top.hxx>

void get_loops	(	ENTITY *	ent,
		ENTITY_LIST &	loop_list,
		PAT_NEXT_TYPE	include_pat = `PAT_CAN_CREATE`
	)

Get a list of LOOPs from an ENTITY.

For additional information regarding the arguments and behavior of this function refer to the documentation for the API function api_get_loops.

include <get_top.hxx>

void get_lumps	(	ENTITY *	ent,
		ENTITY_LIST &	lump_list,
		PAT_NEXT_TYPE	include_pat = `PAT_CAN_CREATE`
	)

Get a list of LUMPs from an ENTITY.

For additional information regarding the arguments and behavior of this function refer to the documentation for the API function api_get_lumps.

include <get_top.hxx>

double SPA_sample_edges_options::get_maxLen ( ) const [inherited]

Gets the max arc length between samples; this is meaningful only if using the methods max_len or max_len_and_turning.

double SPA_sample_edges_options::get_maxTurning ( ) const [inherited]

Gets the max turning between samples; this is meaningful only if using the methods max_turning or max_len_and_turning.

method SPA_sample_edges_options::get_method ( ) const [inherited]

Gets the method to be used for sampling, returning an enum SPA_edges_sample_options::method.

int SPA_sample_edges_options::get_num_samp ( ) const [inherited]

Gets the number of samples to get; this is meaningful only if using the methods numsamp_arc_len or numsamp_equal_turning.

void get_shells	(	ENTITY *	ent,
		ENTITY_LIST &	shell_list,
		PAT_NEXT_TYPE	include_pat = `PAT_CAN_CREATE`
	)

Get a list of SHELLs from an ENTITY.

For additional information regarding the arguments and behavior of this function refer to the documentation for the API function api_get_shells.

include <get_top.hxx>

void get_tcoedges	(	ENTITY *	ent,
		ENTITY_LIST &	tcoed_list,
		PAT_NEXT_TYPE	include_pat = `PAT_CAN_CREATE`
	)

Get a list of TCOEDGEs from an ENTITY.

For additional information regarding the arguments and behavior of this function refer to the documentation for the API function api_get_tcoedges.

include <get_top.hxx>

void get_tedges	(	ENTITY *	ent,
		ENTITY_LIST &	tedge_list,
		PAT_NEXT_TYPE	include_pat = `PAT_CAN_CREATE`
	)

Get a list of TEDGEs from an ENTITY.

For additional information regarding the arguments and behavior of this function refer to the documentation for the API function api_get_tedges.

include <get_top.hxx>

void get_tvertices	(	ENTITY *	ent,
		ENTITY_LIST &	tvert_list,
		PAT_NEXT_TYPE	include_pat = `PAT_CAN_CREATE`
	)

Get a list of TVERTEXes from an ENTITY.

For additional information regarding the arguments and behavior of this function refer to the documentation for the API function api_get_tvertices.

include <get_top.hxx>

void get_vertices	(	ENTITY *	ent,
		ENTITY_LIST &	vert_list,
		PAT_NEXT_TYPE	include_pat = `PAT_CAN_CREATE`
	)

Get a list of VERTEXes from an ENTITY.

For additional information regarding the arguments and behavior of this function refer to the documentation for the API function api_get_vertices.

include <get_top.hxx>

logical get_wire_plane	(	WIRE *	this_wire,
		SPAposition &	centroid,
		SPAunit_vector &	normal,
		logical	apply_transf = `TRUE`
	)

Gets the plane of a 3D WIRE.

Effect: Read-only.

Parameters:

	this_wire	input WIRE.
	centroid	returned centroid.
	normal	returned normal.
	apply_transf	`TRUE` to apply the body's transform to the results.

include <wire_qry.hxx>

void get_wires	(	ENTITY *	ent,
		ENTITY_LIST &	wire_list,
		PAT_NEXT_TYPE	include_pat = `PAT_CAN_CREATE`
	)

Get a list of WIREs from an ENTITY.

For additional information regarding the arguments and behavior of this function refer to the documentation for the API function api_get_wires.

include <get_top.hxx>

logical is_analytic_face ( const ENTITY * )

Determines if the ENTITY is an analytic face; that is, a FACE whose underlying geometry is an analytic surface.

Role: Returns TRUE if the face is not a SPLINE.

Effect: Read-only

Parameters:

ent

entity to test.

include <acistype.hxx>

logical is_ANNOTATION ( const ENTITY * ent )

Determines if an ENTITY is an ANNOTATION.

Parameters:

ent

ENTITY to be queried.

include <kernapi.hxx>

logical is_APOINT ( const ENTITY * ent )

Determines if an ENTITY is an APOINT.

Role: This procedure takes an ENTITY as an argument and returns TRUE if the entity is an APOINT, FALSE if it is not. This procedure also checks for a NULL pointer.

Effect: Read-only

Parameters:

ent

entity to test.

include <acistype.hxx>

logical is_ATTRIB ( const ENTITY * ent )

Determines if an ENTITY is an ATTRIB.

Role: This procedure takes an ENTITY as an argument and returns TRUE if the ENTITY is an ATTRIB, FALSE if it is not. This procedure also checks for a NULL pointer.

Effect: Read-only

Parameters:

ent

entity to test.

include <acistype.hxx>

logical is_ATTRIB_CT ( const ENTITY * ent )

Determines if an ENTITY is a ATTRIB_CT.

Role: This procedure takes an ENTITY as an argument and returns TRUE if the entity is a ATTRIB_CT, FALSE if it is not. This procedure also checks for a NULL pointer.

Effect: Read-only

Parameters:

ent

entity.

include <at_ct.hxx>

logical is_ATTRIB_ST ( const ENTITY * ent )

Determines if an ENTITY is an ATTRIB_ST.

Role: This procedure takes an ENTITY as an argument and returns TRUE if the ENTITY is an ATTRIB_ST, FALSE if it is not. This procedure also checks for a NULL pointer.

Effect: Read-only

Parameters:

ent

entity to test.

include <acistype.hxx>

logical is_BODY ( const ENTITY * ent )

Determines if an ENTITY is a BODY.

Role: This procedure takes an ENTITY as an argument and returns TRUE if the entity is a BODY, FALSE if it is not. This procedure also checks for a NULL pointer.

Effect: Read-only

Parameters:

ent

entity to test.

include <acistype.hxx>

logical is_circular ( const curve * crv )

Determines if a curve is a circular ellipse.

Effect: Read-only

Parameters:

crv

curve to test.

include <acistype.hxx>

logical is_circular_edge ( const ENTITY * ent )

Determines if an ENTITY is a circular edge; that is, an EDGE whose underlying geometry is a circular ellipse.

Role: An edge with no geometry pointer returns FALSE.

Effect: Read-only

Parameters:

ent

entity to test.

include <acistype.hxx>

logical is_closed_curve ( EDGE * crv )

Determines if a curve is closed.

Effect: Read-only

Parameters:

crv

curve.

include <curveq.hxx>

logical is_closed_solid_body ( const ENTITY * ent )

Determines if an ENTITY is a closed solid BODY.

Role: This functions checks to see if the faces of a body are closed.

Effect: Read-only

Parameters:

ent

entity to test.

include <acistype.hxx>

logical is_COEDGE ( const ENTITY * ent )

Determines if an ENTITY is a COEDGE.

Role: This procedure takes an ENTITY as an argument and returns TRUE if the entity is a COEDGE, FALSE if it is not. This procedure also checks for a NULL pointer.

Effect: Read-only

Parameters:

ent

entity to test.

include <acistype.hxx>

logical is_composite_curve ( const curve * crv )

Determines if a curve is a composite curve constructed from multiple laws.

Effect: Read-only

Parameters:

crv

curve to test.

include <acistype.hxx>

logical is_cone ( const surface * surf )

Determines if a surface is a cone.

Effect: Read-only

Parameters:

surf

surface to test.

include <acistype.hxx>

logical is_CONE ( const ENTITY * ent )

Determines if an ENTITY is a CONE.

Role: This procedure takes an ENTITY as an argument and returns TRUE if the ENTITY is a CONE, FALSE if it is not. This procedure also checks for a NULL pointer.

Effect: Read-only

Parameters:

ent

entity to test.

include <acistype.hxx>

logical is_conical_face ( const ENTITY * ent )

Determines if an ENTITY is a conical face; that is, a FACE whose underlying geometry is a cone.

Effect: Read-only

Parameters:

ent

entity to test.

include <acistype.hxx>

logical is_connected_body ( const ENTITY * ent )

Determines if an ENTITY is a connected BODY.

Role: Returns TRUE if the BODY has exactly one LUMP.

Effect: Read-only

Parameters:

ent

entity to test.

include <acistype.hxx>

logical is_CURVE ( const ENTITY * ent )

Determines if an ENTITY is a CURVE.

Role: This procedure takes an ENTITY as an argument and returns TRUE if the entity is a CURVE, FALSE if it is not. This procedure also checks for a NULL pointer.

Effect: Read-only

Parameters:

ent

entity to test.

include <acistype.hxx>

logical is_curve_edge ( const ENTITY * ent )

Determines if an ENTITY is a EDGE with a CURVE.

Role: An edge with no geometry pointer returns FALSE.

Effect: Read-only

Parameters:

ent

entity to test.

include <acistype.hxx>

logical is_cylinder ( const surface * surf )

This composite test checks for a cone that is cylindrical and circular.

Effect: Read-only

Parameters:

surf

surface to test.

include <acistype.hxx>

logical is_cylindrical_face ( const ENTITY * ent )

Determines if an ENTITY is a cylindrical face; that is, a FACE whose underlying geometry is a cylindrical cone.

Effect: Read-only

Parameters:

ent

entity to test.

include <acistype.hxx>

logical is_EDGE ( const ENTITY * ent )

Determines if an ENTITY is an EDGE.

Role: This procedure takes an ENTITY as an argument and returns TRUE if the entity is an EDGE, FALSE if it is not. This procedure also checks for a NULL pointer.

Effect: Read-only

Parameters:

ent

entity to test.

include <acistype.hxx>

logical is_ellipse ( const curve * crv )

Determines if a curve is an ellipse.

Effect: Read-only

Parameters:

crv

curve to test.

include <acistype.hxx>

logical is_ELLIPSE ( const ENTITY * ent )

Determines if an ENTITY is an ELLIPSE.

Role: This procedure takes an ENTITY as an argument and returns TRUE if the ENTITY is an ELLIPSE, FALSE if it is not. This procedure also checks for a NULL pointer.

Effect: Read-only

Parameters:

ent

entity to test.

include <acistype.hxx>

logical is_elliptical_edge ( const ENTITY * ent )

Determines if an ENTITY is an elliptical edge; that is, an EDGE whose underlying geometry is an ellipse.

Role: An EDGE with no geometry pointer returns FALSE.

Effect: Read-only

Parameters:

ent

entity to test.

include <acistype.hxx>

logical is_FACE ( const ENTITY * ent )

Determines if an ENTITY is a FACE.

Role: This procedure takes an ENTITY as an argument and returns TRUE if the entity is a FACE, FALSE if it is not. This procedure also checks for a NULL pointer.

Effect: Read-only

Parameters:

ent

entity to test.

include <acistype.hxx>

logical is_helical_edge ( const ENTITY * ent )

Determines if an ENTITY is a helical edge; that is, an EDGE whose underlying geometry is a helix.

Role: An EDGE with no geometry pointer returns FALSE.

Effect: Read-only

Parameters:

ent

entity to test.

include <acistype.hxx>

logical is_helix ( const curve * crv )

Determines if a curve is a helix.

Effect: Read-only

Parameters:

crv

curve to test.

include <acistype.hxx>

logical is_HELIX ( const ENTITY * ent )

Determines if an ENTITY is a HELIX.

Role: This procedure takes an ENTITY as an argument and returns TRUE if the ENTITY is a HELIX, FALSE if it is not. This procedure also checks for a NULL pointer.

Effect: Read-only

Parameters:

ent

entity to test.

include <acistype.hxx>

logical is_intcurve ( const curve * crv )

Determines if a curve is an intcurve.

Effect: Read-only

Parameters:

crv

curve to test.

include <acistype.hxx>

logical is_INTCURVE ( const ENTITY * ent )

Determines if an ENTITY is an INTCURVE.

Role: This procedure takes an ENTITY as an argument and returns TRUE if the ENTITY is an INTCURVE, FALSE if it is not. This procedure also checks for a NULL pointer.

Effect: Read-only

Parameters:

ent

entity to test.

include <acistype.hxx>

logical is_intcurve_edge ( const ENTITY * ent )

Determines if an ENTITY is an intcurve edge; that is, an EDGE whose underlying geometry is an intcurve.

Role: An edge with no geometry pointer returns FALSE.

Effect: Read-only

Parameters:

ent

entity to test.

include <acistype.hxx>

logical is_LAW ( const ENTITY * ent )

Determines if a specified ENTITY is a LAW.

Effect: Read-only

Parameters:

ent

entity to test.

include <lawent.hxx>

logical is_linear_edge ( const ENTITY * ent )

Determines if an ENTITY is a linear edge; that is, an EDGE whose underlying geometry is a straight.

Role: An EDGE with no geometry pointer returns FALSE.

Effect: Read-only

Parameters:

ent

entity to test.

include <acistype.hxx>

logical is_LOOP ( const ENTITY * ent )

Determines if an ENTITY is a LOOP.

Role: This procedure takes an ENTITY as an argument and returns TRUE if the entity is a LOOP, FALSE if it is not. This procedure also checks for a NULL pointer.

Effect: Read-only

Parameters:

ent

entity to test.

include <acistype.hxx>

logical is_LUMP ( const ENTITY * ent )

Determines if an ENTITY is a LUMP.

Role: This procedure takes an ENTITY as an argument and returns TRUE if the entity is a LUMP, FALSE if it is not. This procedure also checks for a NULL pointer.

Effect: Read-only

Parameters:

ent

entity to test.

include <acistype.hxx>

logical is_mixed_body ( const ENTITY * ent )

Determines if an ENTITY is a mixed BODY.

Role: A BODY is mixed if the BODY's WIRE is NULL but the BODY has a LUMP and the SHELL of the LUMP has a WIRE and a FACE.

Effect: Read-only

Parameters:

ent

entity to test.

include <acistype.hxx>

logical is_PCURVE ( const ENTITY * ent )

Determines if an ENTITY is a PCURVE.

Role: This procedure takes an ENTITY as an argument and returns TRUE if the entity is an PCURVE, FALSE if it is not. This procedure also checks for a NULL pointer.

Effect: Read-only

Parameters:

ent

entity to test.

include <acistype.hxx>

logical is_planar_face ( const ENTITY * ent )

Determines if an ENTITY is a planar face; that is, a FACE whose underlying geometry is a plane.

Effect: Read-only

Parameters:

ent

entity to test.

include <acistype.hxx>

logical is_planar_wire	(	COEDGE *	this_coedge,
		SPAposition &	centroid,
		SPAunit_vector &	normal,
		logical	apply_transf = `TRUE`,
		logical	use_winding_number = `TRUE`
	)

Determines if a WIRE is planar.

Role: This signature of this API accepts a chain of coedges instead of a wire.

Effect: Read-only.

Parameters:

	this_coedge	given coedge.
	centroid	returned centroid.
	normal	returned normal.
	apply_transf	`TRUE` to apply the body's transform to the results.
	use_winding_number	logical for whether or not to use the winding number, default `TRUE`. NOTE: The `use_winding_number` flag has been deprecated as of R17. Setting `use_winding_number` to `FALSE` can give inaccurate results.

include <wire_qry.hxx>

logical is_planar_wire	(	WIRE *	this_wire,
		SPAposition &	centroid,
		SPAunit_vector &	normal,
		logical	apply_transf = `TRUE`,
		logical	use_winding_number = `TRUE`
	)

Determines if a WIRE is planar.

Role: An alternate signature of this API accepts a wire as a chain of coedges.

Effect: Read-only.

Parameters:

	this_wire	given wire.
	centroid	returned centroid.
	normal	returned normal.
	apply_transf	`TRUE` to apply the body's transform to the results.
	use_winding_number	logical for whether or not to use the winding number, default `TRUE`. NOTE: The `use_winding_number` flag has been deprecated as of R17. Setting `use_winding_number` to `FALSE` can give inaccurate results.

include <wire_qry.hxx>

logical is_plane ( const surface * surf )

Determines if a surface is a plane.

Effect: Read-only

Parameters:

surf

surface to test.

include <acistype.hxx>

logical is_PLANE ( const ENTITY * ent )

Determines if an ENTITY is a PLANE.

Role: This procedure takes an ENTITY as an argument and returns TRUE if the ENTITY is a PLANE, FALSE if it is not. This procedure also checks for a NULL pointer.

Effect: Read-only

Parameters:

ent

entity to test.

include <acistype.hxx>

logical is_SHELL ( const ENTITY * ent )

Determines if an ENTITY is a SHELL.

Role: This procedure takes an ENTITY as an argument and returns TRUE if the entity is a SHELL, FALSE if it is not. This procedure also checks for a NULL pointer.

Effect: Read-only

Parameters:

ent

entity to test.

include <acistype.hxx>

logical is_solid_body ( const ENTITY * ent )

Determines if an ENTITY is a solid BODY.

Role: A solid BODY has at least one LUMP and no WIREs. If the ENTITY is not a solid BODY or is NULL, then this function returns FALSE.

Effect: Read-only

Parameters:

ent

entity to test.

include <acistype.hxx>

logical is_SPACOLLECTION ( const ENTITY * ent )

Determines if an ENTITY is a SPACOLLECTION.

Role: This procedure takes an ENTITY as an argument and returns TRUE if the entity is a SPACOLLECTION, FALSE if it is not. This procedure also checks for a NULL pointer.

Effect: Read-only

Parameters:

ent

entity.

include <collection.hxx>

logical is_sphere ( const surface * surf )

Determines if a surface is a sphere.

Effect: Read-only

Parameters:

surf

surface to test.

include <acistype.hxx>

logical is_SPHERE ( const ENTITY * ent )

Determines if an ENTITY is a SPHERE.

Role: This procedure takes an ENTITY as an argument and returns TRUE if the ENTITY is a SPHERE, FALSE if it is not. This procedure also checks for a NULL pointer.

Effect: Read-only

Parameters:

ent

entity to test.

include <acistype.hxx>

logical is_spherical_face ( const ENTITY * ent )

Determines if an ENTITY is a spherical face; that is, a FACE whose underlying geometry is a sphere.

Effect: Read-only

Parameters:

ent

entity to test.

include <acistype.hxx>

logical is_spline ( const surface * surf )

Determines if a surface is a spline.

Effect: Read-only

Parameters:

surf

surface to test.

include <acistype.hxx>

logical is_SPLINE ( const ENTITY * ent )

Determines if an ENTITY is a SPLINE.

Role: This procedure takes an ENTITY as an argument and returns TRUE if the ENTITY is a SPLINE, FALSE if it is not. This procedure also checks for a NULL pointer.

Effect: Read-only

Parameters:

ent

entity to test.

include <acistype.hxx>

logical is_spline_face ( const ENTITY * ent )

Determines if the ENTITY is a spline face; that is, a FACE whose underlying geometry is a spline.

Effect: Read-only

Parameters:

ent

entity to test.

include <acistype.hxx>

logical is_straight ( const curve * crv )

Determines if a curve is a straight.

Effect: Read-only

Parameters:

crv

curve to test.

include <acistype.hxx>

logical is_STRAIGHT ( const ENTITY * ent )

Determines if an ENTITY is a STRAIGHT.

Role: This procedure takes an ENTITY as an argument and returns TRUE if the ENTITY is a STRAIGHT, FALSE if it is not. This procedure also checks for a NULL pointer.

Effect: Read-only

Parameters:

ent

entity to test.

include <acistype.hxx>

logical is_SUBSHELL ( const ENTITY * ent )

Determines if an ENTITY is a SUBSHELL.

Role: This procedure takes an ENTITY as an argument and returns TRUE if the entity is a SUBSHELL, FALSE if it is not. This procedure also checks for a NULL pointer.

Effect: Read-only

Parameters:

ent

entity to test.

include <acistype.hxx>

logical is_SURFACE ( const ENTITY * ent )

Determines if an ENTITY is a SURFACE.

Role: This procedure takes an ENTITY as an argument and returns TRUE if the ENTITY is a SURFACE, FALSE if it is not. This procedure also checks for a NULL pointer.

Effect: Read-only

Parameters:

ent

entity to test.

include <acistype.hxx>

logical is_TEXT_ENT ( const ENTITY * ent )

Determines if an ENTITY is a TEXT_ENT.

Effect: Read-only

Parameters:

ent

entity to test.

include <text.hxx>

logical is_toplevel ( const ENTITY * ent )

Determines if an ENTITY is top level.

This means there is no owner for this ENTITY.

Effect: Read-only

Parameters:

ent

entity.

include <getowner.hxx>

logical is_toroidal_face ( const ENTITY * ent )

Determines if the ENTITY is a toroidal face; that is, a FACE whose underlying geometry is a torus.

Effect: Read-only

Parameters:

ent

entity to test.

include <acistype.hxx>

logical is_torus ( const surface * surf )

Determines if a surface is a torus.

Effect: Read-only

Parameters:

surf

surface to test.

include <acistype.hxx>

logical is_TORUS ( const ENTITY * ent )

Determines if an ENTITY is a TORUS.

Role: This procedure takes an ENTITY as an argument and returns TRUE if the ENTITY is a TORUS, FALSE if it is not. This procedure also checks for a NULL pointer.

Effect: Read-only

Parameters:

ent

entity to test.

include <acistype.hxx>

logical is_VERTEX ( const ENTITY * ent )

Determines if the ENTITY is a VERTEX.

Role: This procedure takes an ENTITY as an argument and returns TRUE if the ENTITY is a VERTEX, FALSE if it is not. This procedure also checks for a NULL pointer.

Effect: Read-only

Parameters:

ent

entity to test.

include <acistype.hxx>

logical is_WIRE ( const ENTITY * ent )

Determines if an ENTITY is a WIRE.

Role: This procedure takes an ENTITY as an argument and returns TRUE if the entity is a WIRE, FALSE if it is not. This procedure also checks for a NULL pointer.

Effect: Read-only

Parameters:

ent

entity to test.

include <acistype.hxx>

logical is_wire_body ( const ENTITY * ent )

Determines if an ENTITY is a wire BODY.

Role: Returns TRUE if:

    BODY has no LUMPs and at least one WIRE
    or
    BODY has a LUMP, at least one WIRE, and no FACEs
Effect: Read-only

Parameters:

ent

entity to test.

include <acistype.hxx>

logical isolated_vertex ( VERTEX * vert )

Determines if a vertex is an isolated vertex.

Role: This function returns a logical value indicating whether the given vertex is an isolated vertex or not. Because a non-manifold vertex connecting multiple edge groups (or "separation surfaces") can be an isolated vertex on one separation surface and a non-isolated vertex on another separation surface, this function always returns FALSE for non-manifold vertices connecting multiple separation surfaces.

An isolated vertex is represented by a NULL edge; that is, an edge whose geometry pointer is NULL. The start and end vertex pointers of the edge point to the isolated vertex. The partner pointer of the coedge on the edge should also be NULL. If the vertex is an isolated, unembedded wire vertex, the next and previous pointers of the coedge are NULL. If the vertex represents a degenerate loop on a face (for instance, at the apex of a cone) the next and previous pointers of the coedge point to the coedge.

Parameters:

vert

the vertex to test.

include <testwire.hxx>

void SPA_sample_edges_options::set_as_max_len ( double maxLen ) [inherited]

Sets the options for sampling with the method max_len Role: Sets the SPA_edges_sample_options to sample such that there is user-specified arc length of the curves between samples.

Parameters:

maxLen

Between samples, the curves will be have equal arc length - except the arc length may be shorter between the last two samples.

void SPA_sample_edges_options::set_as_max_len_and_turning	(	double	maxLen,
		double	maxTurning
	)			`[inherited]`

Sets the options for sampling with the method max_len_and_turning Role: Sets the SPA_edges_sample_options to sample such that between samples, either the arc length is user-specified, or the turning is user-specified, and neither is greater than the user-specifications.

Except the last two samples may have both less arc length and less turning.

Parameters:

	maxLen	Upper bound for the arc length between samples - except the curves may be shorter between the last two samples.
	maxTurning	Radians; upper bound for the turning between samples - except the curves may turn less between the last two samples.

void SPA_sample_edges_options::set_as_max_turning ( double maxTurning ) [inherited]

Sets the options for sampling with the method max_turning Role: Sets the SPA_edges_sample_options to sample such that there is users-specified equal turning of the curves between samples.

Parameters:

maxTurning

Radians; between samples, the curves will be have equal turning - except the turning may turn less between the last two samples.

void SPA_sample_edges_options::set_as_num_samp_arc_len ( int nSamp ) [inherited]

Sets the options for sampling with the method numsamp_arc_len Role: Sets the SPA_edges_sample_options to sample such that there is equal arc length of the curves between samples, with the user-specified total number of samples.

Parameters:

nSamp

The total number of samples returned.

void SPA_sample_edges_options::set_as_num_samp_equal_turning ( int nSamp ) [inherited]

Sets the options for sampling with the method numsamp_equal_turning Role: Sets the SPA_edges_sample_options to sample such that there is equal turning of the curves between samples, with the user-specified total number of samples.

Parameters:

nSamp

The total number of samples returned.

Topology and Geometry Queries [Kernel Functionality]

Classes

Enumerations

Functions

Enumeration Type Documentation

Function Documentation

Topology and Geometry Queries
[Kernel Functionality]