curves
[Geometry]

Collaboration diagram for curves:

Files
file	curdef.hxx
Classes
class	bounded_arc
	Defines a bounded_arc as a subtype of a bounded_curve. More...
class	bounded_curve
	Defines a bounded curve. More...
class	bounded_line
	Defines a bounded_line as a subtype of bounded_curve. More...
class	com_cur
	Contains the actual node and element data. More...
class	compcurv
	Curve that is the general representation of a patchwork curve used to represent boundaries of a meshsurf, which is a patchwork surface. More...
class	curve
	Provides methods and data common to all curve subclasses. More...
class	ellipse
	Defines an ellipse curve. More...
class	exact_int_cur
	Represents an exact intersection spline curve. More...
class	helix
	Defines a (possibly tapered) helical curve. More...
class	int_cur
	Defines interpolated curves. More...
class	intcurve
	An interpolated curve type. More...
class	off_int_cur
	Represents a spline curve obtained by the intersection of two surfaces that are offsets of the given surfaces. More...
class	par_int_cur
	Represents an exact spline curve in the parameter space of a surface. More...
class	straight
	Defines an infinite straight line represented by a point and a unit vector specifying the direction. More...
class	var_rad_const
	Declaration of the derived class var_rad_const. More...
class	var_rad_fixed_width
	Defines a constant cross section radius for a variable radius function. More...
class	var_rad_functional
	Defines a functional form of a variable radius function. More...
class	var_rad_rot_ellipse
	Defines a rotational radius ellipse for a variable radius function. More...
class	var_rad_two_ends
	Defines a two-ends form of a variable radius function. More...
class	var_radius
	Defines the variable radius. More...
enum	evaluate_curve_side
	Restores a curve. More...
enum	extremum_type
	Restores a curve. More...
typedef curve *(*	rest_cu_fn_type )()
	Restores a curve.
	curve::curve ()
	Constructs a curve (default constructor).
curve *	dispatch_restore_cu (char *)
	Restores a curve.
curve *	dispatch_restore_cu (int)
	Restores a curve.
curve *	restore_curve ()
	Restores a curve.
#define	BOUNDING_CYLINDER   curve_boundcyl
	Restores a curve.
Defines
#define	compcurv_type   40
	Define an identifying type for compcurv curve.
Enumerations
enum	CURVE_EXTENSION_TYPE
	Number specifies the extension type. More...
enum	par_int_cur_dir
	Specifies the curve direction. More...
enum	radius_forms
	Specifies the type of the blend radius function. More...
Functions
virtual int	curve::accurate_derivs (const SPAinterval &range=*(SPAinterval *) NULL_REF) const
	Returns the number of derivatives of this curve that can be found accurately and relatively directly.
virtual const double *	curve::all_discontinuities (int &n_discont, int order)
	Returns the number and parameter values of all discontinuities of this curve, up to the given order (maximum three).
virtual double	curve::approx_error () const
	Returns the maximum error between the approximate evaluation of this curve and the true evaluation of it.
SPAbox	curve::bound (double start, double end, const SPAtransf &transf=*(SPAtransf *) NULL_REF) const
	Retained temporarily for historical reasons.
virtual SPAbox	curve::bound (const SPAbox &region, const SPAtransf &transf=*(SPAtransf *) NULL_REF) const =0
	Returns an object space bounding box surrounding the portion of this curve within the given box.
virtual SPAbox	curve::bound (const SPAinterval &range, const SPAtransf &transf=*(SPAtransf *) NULL_REF) const =0
	Returns a box surrounding the portion of this curve between two parameter values.
virtual SPAbox	curve::bound (const SPAposition &pos1, const SPAposition &pos2, const SPAtransf &transf=*(SPAtransf *) NULL_REF) const =0
	Finds a box around this curve, or portion thereof, bounded by points on the curve increasing in parameter value.
virtual void	curve::change_event ()
	Notifies the derived type that this curve has been changed.
virtual check_status_list *	curve::check (const check_fix &input=*(const check_fix *) NULL_REF, check_fix &result=*(check_fix *) NULL_REF, const check_status_list *chks=(const check_status_list *) NULL_REF)
	Checks for any data errors in this curve, and corrects the errors if possible.
virtual logical	curve::closed () const =0
	Indicates whether this curve is closed.
virtual void	curve::closest_point (const SPAposition &pos, SPAposition &foot, const SPAparameter &param_guess=*(SPAparameter *) NULL_REF, SPAparameter &param_actual=*(SPAparameter *) NULL_REF) const
	Finds the closest point on this curve (the foot) to the given point.
curve *	curve::copy_curve () const
	Makes a copy of this curve.
virtual void	curve::debug (const char *lead, FILE *fp=debug_file_ptr) const =0
	Writes a description of this curve to a file.
virtual int_cur *	surf_int_cur::deep_copy (pointer_map *pm=NULL) const
	Creates a copy of an item that does not share any data with the original.
virtual curve *	curve::deep_copy (pointer_map *pm=NULL) const =0
	Creates a copy of this object that does not share any data with the original.
virtual const double *	curve::discontinuities (int &n_discont, int order) const
	Returns the number and parameter values of discontinuities of this curve, of the given order (maximum three), in a read-only array.
virtual int	curve::discontinuous_at (double t) const
	Determines whether a particular parameter value represents a discontinuity of this curve.
virtual curve_boundcyl	curve::enclosing_cylinder (const SPAinterval &range=*(SPAinterval *) NULL_REF) const =0
	Returns a cylinder that encloses the portion of this curve bounded by the given parameter interval.
virtual void	curve::eval (double param, SPAposition &pos, SPAvector &first_deriv=*(SPAvector *) NULL_REF, SPAvector &second_deriv=*(SPAvector *) NULL_REF, logical eval_repeated=FALSE, logical approx_ok=FALSE) const
	Evaluates this curve at a given parameter value, returning the position and the first and second derivatives (all optionally).
virtual SPAvector	curve::eval_curvature (double param, logical eval_repeated=FALSE, logical approx_ok=FALSE) const
	Finds the curvature at the given parameter value on this curve.
virtual SPAvector	curve::eval_deriv (double param, logical eval_repeated=FALSE, logical approx_ok=FALSE) const
	Finds the derivative (direction and magnitude) at the given parameter value on this curve.
virtual double	curve::eval_deriv_len (double param, logical eval_repeated=FALSE, logical approx_ok=FALSE) const
	Finds the magnitude of the derivative at the given parameter value on this curve.
virtual SPAunit_vector	curve::eval_direction (double param, logical eval_repeated=FALSE, logical approx_ok=FALSE) const
	Finds the tangent direction at the given parameter value on this curve.
virtual SPAposition	curve::eval_position (double param, logical eval_repeated=FALSE, logical approx_ok=FALSE) const
	Finds the point on this curve corresponding to a given parameter value.
virtual int	curve::evaluate (double param, SPAposition &pos, SPAvector **derivs=NULL, int num=0, evaluate_curve_side side=evaluate_curve_unknown) const
	Calculates derivatives, of any order up to the number requested, and store them in vectors provided by the user.
virtual int	curve::evaluate_iter (double param, curve_evaldata *ini_data, SPAposition &pos, SPAvector **derivs=NULL, int num=0, evaluate_curve_side side=evaluate_curve_unknown) const
	Calculates derivatives, of any order up to the number requested, in an iterative fashion.
virtual curve_extremum *	curve::find_extrema (const SPAunit_vector &dir) const =0
	Finds the extrema of this curve in a given direction.
virtual int	curve::finite_difference_derivatives (double param, SPAposition &pos, SPAvector **derivs, int nd, int nfound, double dt, evaluate_curve_side side) const
	Evaluate higher derivatives than are available accurately in evaluate by finite differencing.
bounded_curve *	get_bounded_curve (EDGE *edge, logical apply_transf=TRUE)
	Gets a bounded_curve from an EDGE.
virtual const discontinuity_info &	curve::get_disc_info () const
	Returns read-only access to a discontinuity_info object, if there is one.
virtual int	curve::high_curvature (double k, SPAinterval *&spans) const
	Finds regions of high curvature of this curve.
static int	surf_int_cur::id ()
	Returns the ID for the surf_int_cur list.
virtual law *	curve::law_form ()
	Returns a pointer to the law form of this curve, or else NULL.
virtual double	curve::length (double param1, double param2, logical approx_ok=TRUE) const =0
	Returns the algebraic distance (arc length) along this curve between the two given parameters.
virtual double	curve::length_param (double param, double length, logical approx_ok=TRUE) const =0
	Returns the parameter value of the point on this curve at the given algebraic arc length from that defined by the given parameter.
void	curve::limit (const SPAinterval &range)
	Subsets this curve in place, ensuring canonical results if the underlying curve is bounded or periodic.
virtual curve *	curve::make_copy () const =0
	Makes a copy of this curve.
virtual curve_evaldata *	curve::make_evaldata () const
	Constructs a data object to retain evaluation information across calls to the evaluate_iter method.
virtual logical	curve::need_save_as_approx (int save_to_version, logical check_progenitors) const
	Queries whether the object needs to be saved to an old version as an approximation.
virtual curve &	curve::negate ()=0
	Reverses the sense of this curve.
logical	curve::operator!= (const curve &cur) const
	Tests this curve for inequality to another curve.
straight	operator* (straight const &input, SPAtransf const &trans)
	Applies transformation to straight curve.
intcurve	operator* (intcurve const &intcur, SPAtransf const &trans)
	Returns a copy of the transformed curve.
helix	operator* (helix const &name, SPAtransf const &transf)
	Returns a helix transformed by the given transformation.
ellipse	operator* (ellipse const &name, SPAtransf const &transf)
	Returns an ellipse transformed by the given transformation.
virtual curve &	curve::operator*= (const SPAtransf &transf)=0
	Transforms this curve.
virtual logical	curve::operator== (const curve &cur) const
	Tests this curve for equality to another curve.
virtual double	curve::param (const SPAposition &pos, const SPAparameter &param_guess=*(SPAparameter *) NULL_REF) const =0
	Finds the parameter value of a given position on the curve.
virtual double	curve::param_period () const =0
	Returns the period of a periodic curve, or 0 if this curve is not periodic.
virtual SPAinterval	curve::param_range (const SPAbox &region=*(SPAbox *) NULL_REF) const =0
	Returns the principal parameter range of this curve.
virtual pcurve *	curve::pcur (int n, logical copy_curve=FALSE) const
	Returns the nth parametric curve.
virtual logical	curve::pcur_present (int n) const
	Determines if the nth parameter-space curve is defined for this curve.
virtual logical	curve::periodic () const =0
	Indicates if this curve is periodic.
virtual SPAvector	curve::point_curvature (const SPAposition &pos, const SPAparameter &param_guess=*(SPAparameter *) NULL_REF) const =0
	Finds the curvature of this curve at the given point.
virtual SPAunit_vector	curve::point_direction (const SPAposition &pos, const SPAparameter &param_guess=*(SPAparameter *) NULL_REF) const =0
	Finds tangent direction of this curve at the given point.
void	curve::point_perp (const SPAposition &point, SPAposition &foot, const SPAparameter &param_guess=*(SPAparameter *) NULL_REF, SPAparameter &param_actual=*(SPAparameter *) NULL_REF, logical f_weak=FALSE) const
	Finds the foot of the perpendicular from the given point to this curve and the corresponding parameter value.
void	curve::point_perp (const SPAposition &point, SPAposition &foot, SPAunit_vector &tangent, const SPAparameter &param_guess=*(SPAparameter *) NULL_REF, SPAparameter &param_actual=*(SPAparameter *) NULL_REF, logical f_weak=FALSE) const
	Finds the foot of the perpendicular from the given point to this curve, the tangent to the curve at that point, and the corresponding parameter value.
virtual void	curve::point_perp (const SPAposition &point, SPAposition &foot, SPAunit_vector &tangent, SPAvector &curvature, const SPAparameter &param_guess=*(SPAparameter *) NULL_REF, SPAparameter &actual_param=*(SPAparameter *) NULL_REF, logical f_weak=FALSE) const =0
	Finds the foot of the perpendicular from the given point to this curve, the tangent and curvature of the curve at that point, and the corresponding parameter value.
void	curve::restore_data ()
	Restores the data for this curve, according to its type.
subtype_object *	restore_int_int_cur ()
virtual void	curve::save () const =0
	Saves a curve of unknown type, together with its type code for later retrieval.
void	curve::save_curve () const
	Saves a curve of unknown type, or NULL.
virtual void	surf_int_cur::save_data () const
	Save the information for the surf_int_cur to a save file.
void	curve::save_data () const
	Saves a curve of a known type.
virtual curve *	curve::split (double param, const SPAposition &pos=*(SPAposition *) NULL_REF)
	Splits this curve at the given parameter value, if possible.
curve *	curve::subset (const SPAinterval &range) const
	Constructs a subsetted copy of this curve.
logical	curve::subsetted () const
	Indicates whether this curve has a significant subset range.
	surf_int_cur::surf_int_cur (const surf_int_cur &input)
	C++ copy constructor requests memory for this object and populates it with the data from the object supplied as an argument.
	surf_int_cur::surf_int_cur (bs3_curve splcur, double tol, surface const &surf1, surface const &surf2, bs2_curve cur1, bs2_curve cur2, logical trcur=TRUE, const SPAinterval &range=*(const class SPAinterval *) NULL_REF)
	C++ initialize constructor requests memory for this object and populates it with the data supplied as arguments.
	surf_int_cur::surf_int_cur (bs3_curve splcur, double tol, surface const &surf=*(surface *) NULL_REF, bs2_curve cur=NULL, logical trcur=TRUE, const SPAinterval &range=*(const class SPAinterval *) NULL_REF)
	C++ initialize constructor requests memory for this object and populates it with the data supplied as arguments.
virtual curve_tancone	curve::tangent_cone (const SPAinterval &range, logical approx_OK=FALSE, const SPAtransf &transf=*(SPAtransf *) NULL_REF) const =0
	Returns a cone bounding the tangent direction of this curve.
logical	curve::test_point (const SPAposition &pos, const SPAparameter &param_guess=*(SPAparameter *) NULL_REF, SPAparameter &param_actual=*(SPAparameter *) NULL_REF) const
	Tests point-on-curve, optionally returning the exact parameter value if the point is on this curve.
virtual logical	curve::test_point_tol (const SPAposition &pos, double tol=0, const SPAparameter &param_guess=*(SPAparameter *) NULL_REF, SPAparameter &param_actual=*(SPAparameter *) NULL_REF) const =0
	Tests point-on-curve to a given precision, optionally returning the exact parameter value if the point is on this curve.
virtual int	surf_int_cur::type () const
	Returns the type of surf_int_cur.
virtual int	curve::type () const =0
	Returns an identifier that specifies the curve type.
virtual char const *	surf_int_cur::type_name () const
	Returns the string "surfcur".
virtual char const *	curve::type_name () const =0
	Returns the string "curve".
virtual logical	curve::undef () const
	Indicates whether this curve is properly defined.
logical	curve::undefined () const
	Indicates whether this curve is properly defined.
void	curve::unlimit ()
	Removes the parameter limits from this curve.
curve *	curve::unsubset () const
	Constructs a copy of the unbounded curve underlying this one.
virtual	curve::~curve ()
	C++ destructor, deleting a curve.
Friends
curve *	curve::restore_curve ()
	Restores a curve.

---

Define Documentation

#define BOUNDING_CYLINDER   curve_boundcyl

Restores a curve.

Role: Although this internal function is intended strictly for ACIS usage, a minimal amount of information about this function is provided for the sole purpose of being able to understand and trace restoration from a SAT file. This function should never be called directly, because it makes assumptions about the availability of a SAT file, the location of the input pointer into the SAT file, and the validity of SAT data it expects to read in. It also may start a lengthy process of nested function or class method calls, which have many of the same assumptions.

The restore function does the actual work of restoring the curve. It calls the base class, then reads the selector, if the save file is new enough. This reads the curve type and then switches in the run-time table to the correct restore routine.

    if (restore_version_number < CURVE_VERSION)
       read_int            Integer for the type of curve.
       dispatch_restore_cu Supply the number for the type of curve.
    else
       read_id             Reads in the string associated with the curve identification.
       dispatch_restore_cu Supply the curve identification for the type of curve.

Effect: Read-only

include <curdef.hxx>

#define compcurv_type   40

Define an identifying type for compcurv curve.

---

Typedef Documentation

typedef curve*(* rest_cu_fn_type)()

Restores a curve.

Role: Although this internal function is intended strictly for ACIS usage, a minimal amount of information about this function is provided for the sole purpose of being able to understand and trace restoration from a SAT file. This function should never be called directly, because it makes assumptions about the availability of a SAT file, the location of the input pointer into the SAT file, and the validity of SAT data it expects to read in. It also may start a lengthy process of nested function or class method calls, which have many of the same assumptions.

The restore function does the actual work of restoring the curve. It calls the base class, then reads the selector, if the save file is new enough. This reads the curve type and then switches in the run-time table to the correct restore routine.

    if (restore_version_number < CURVE_VERSION)
       read_int            Integer for the type of curve.
       dispatch_restore_cu Supply the number for the type of curve.
    else
       read_id             Reads in the string associated with the curve identification.
       dispatch_restore_cu Supply the curve identification for the type of curve.

Effect: Read-only

include <curdef.hxx>

---

Enumeration Type Documentation

enum CURVE_EXTENSION_TYPE

Number specifies the extension type.

Parameters:

	EXTEND_CURVATURE	extend the curvature
	EXTEND_TANGENT	extend the tangent

include <sub_int.hxx>

enum evaluate_curve_side

Restores a curve.

Role: Although this internal function is intended strictly for ACIS usage, a minimal amount of information about this function is provided for the sole purpose of being able to understand and trace restoration from a SAT file. This function should never be called directly, because it makes assumptions about the availability of a SAT file, the location of the input pointer into the SAT file, and the validity of SAT data it expects to read in. It also may start a lengthy process of nested function or class method calls, which have many of the same assumptions.

The restore function does the actual work of restoring the curve. It calls the base class, then reads the selector, if the save file is new enough. This reads the curve type and then switches in the run-time table to the correct restore routine.

    if (restore_version_number < CURVE_VERSION)
       read_int            Integer for the type of curve.
       dispatch_restore_cu Supply the number for the type of curve.
    else
       read_id             Reads in the string associated with the curve identification.
       dispatch_restore_cu Supply the curve identification for the type of curve.

Effect: Read-only

include <curdef.hxx>

enum extremum_type

Restores a curve.

Role: Although this internal function is intended strictly for ACIS usage, a minimal amount of information about this function is provided for the sole purpose of being able to understand and trace restoration from a SAT file. This function should never be called directly, because it makes assumptions about the availability of a SAT file, the location of the input pointer into the SAT file, and the validity of SAT data it expects to read in. It also may start a lengthy process of nested function or class method calls, which have many of the same assumptions.

The restore function does the actual work of restoring the curve. It calls the base class, then reads the selector, if the save file is new enough. This reads the curve type and then switches in the run-time table to the correct restore routine.

    if (restore_version_number < CURVE_VERSION)
       read_int            Integer for the type of curve.
       dispatch_restore_cu Supply the number for the type of curve.
    else
       read_id             Reads in the string associated with the curve identification.
       dispatch_restore_cu Supply the curve identification for the type of curve.

Effect: Read-only

include <curdef.hxx>

enum par_int_cur_dir

Specifies the curve direction.

Parameters:

	par_int_cur_u	u parameter curve.
	par_int_cur_v	v parameter curve.
	par_int_cur_unset	unset.
	par_int_cur_general	neither a u or v parameter curve.

include <par_int.hxx>

enum radius_forms

Specifies the type of the blend radius function.

Parameters:

	RADIUS_UNSET	Radius function is not set.
	TWO_ENDS	Two-end radius function defined by the two blend radii at the beginning and at the end of the blend sequence.
	FUNCTIONAL	Functional radius function--radius variation along the defining curve is determined by an (arbitrary) function R(t), where t is the parameter along the defining curve of the blend.
	FIXED_WIDTH	Implicit radius function--blend radius variation is not specified explicitely, instead, the current radius is found so that the distance between the blend springs is equal to the given "blend width" value.
	HOLDLINE	Implicit radius function--blend radius variation is not specified explicitely, instead, the currend radius is found so that one of the blend spring curves coincides with the given "holdline" curve (while the blend is still tangent to the surface conaining the holdline).

include <var_rad.hxx>

---

Function Documentation

virtual int curve::accurate_derivs

(

const SPAinterval &

range = *(SPAinterval *) NULL_REF

)

const [virtual, inherited]

Returns the number of derivatives of this curve that can be found accurately and relatively directly.

Role: Returns the number of derivatives that can be found by evaluate accurately and relatively directly, rather than by finite differencing over the given portion of the curve. If there is no limit to the number of accurate derivatives, returns the value ALL_CURVE_DERIVATIVES.

Parameters:

range

portion of the curve to be considered (optional).

Reimplemented in compcurv, ellipse, helix, intcurve, and straight.

virtual const double* curve::all_discontinuities	(	int &	n_discont,
		int	order
	)			[virtual, inherited]

Returns the number and parameter values of all discontinuities of this curve, up to the given order (maximum three).

Role: The returned array is read-only.

Parameters:

	n_discont	number of discontinuities found.
	order	maximum order of the discontinuities.

Reimplemented in intcurve.

virtual double curve::approx_error

(

)

const [virtual, inherited]

Returns the maximum error between the approximate evaluation of this curve and the true evaluation of it.

Reimplemented in compcurv, and intcurve.

SPAbox curve::bound	(	double	start,
		double	end,
		const SPAtransf &	transf = *(SPAtransf*)NULL_REF
	)			const [inline, inherited]

Retained temporarily for historical reasons.

Parameters:

	start	start parameter.
	end	end parameter.
	transf	transformation.

Reimplemented in compcurv, ellipse, intcurve, and straight.

virtual SPAbox curve::bound	(	const SPAbox &	region,
		const SPAtransf &	transf = *(SPAtransf *) NULL_REF
	)			const [pure virtual, inherited]

Returns an object space bounding box surrounding the portion of this curve within the given box.

Role: There is no guarantee that the box will be minimal.

Parameters:

	region	the region of interest.
	transf	optional transformation.

Implemented in compcurv, ellipse, helix, intcurve, and straight.

virtual SPAbox curve::bound	(	const SPAinterval &	range,
		const SPAtransf &	transf = *(SPAtransf *) NULL_REF
	)			const [pure virtual, inherited]

Returns a box surrounding the portion of this curve between two parameter values.

Role: The resulting box is not necessarily the minimal one.

Parameters:

	range	the range of interest.
	transf	optional transformation.

Implemented in compcurv, ellipse, helix, intcurve, and straight.

virtual SPAbox curve::bound	(	const SPAposition &	pos1,
		const SPAposition &	pos2,
		const SPAtransf &	transf = *(SPAtransf *) NULL_REF
	)			const [pure virtual, inherited]

Finds a box around this curve, or portion thereof, bounded by points on the curve increasing in parameter value.

Role: The points lie on the curve as supplied, not as transmitted. The resulting box is not necessarily the minimal one.

Parameters:

	pos1	first bounding position.
	pos2	second bounding position.
	transf	optional transformation.

Implemented in compcurv, ellipse, helix, intcurve, and straight.

virtual void curve::change_event

(

)

[virtual, inherited]

Notifies the derived type that this curve has been changed.

Role: Used when the subset_range has changed, so that the curve can update itself. The default version of this method does nothing.

Reimplemented in intcurve.

virtual check_status_list* curve::check	(	const check_fix &	input = *(const check_fix *) NULL_REF,
		check_fix &	result = *(check_fix *) NULL_REF,
		const check_status_list *	chks = (const check_status_list *) NULL_REF
	)			[virtual, inherited]

Checks for any data errors in this curve, and corrects the errors if possible.

Role: The various arguments provide control over which checks are made, which fixes can be applied and which fixes were actually applied. The function returns a list of errors that remain in the curve on exit.

The default for allowed fixes is none (nothing fixed). If the list of checks to be made is null, then every possible check will be made. Otherwise, the function will only check for things in the list. The return value for the function will then be a subset of this list.

Parameters:

	input	set of flags for fixes allowed.
	result	fixes applied.
	chks	checks to be made (default is none).

Reimplemented in helix, and intcurve.

virtual logical curve::closed

(

)

const [pure virtual, inherited]

Indicates whether this curve is closed.

Role: A closed curve joins itself (smoothly or not) at the ends of its principal parameter range. This function should always return TRUE if periodic returns TRUE.

Implemented in compcurv, ellipse, helix, intcurve, and straight.

virtual void curve::closest_point	(	const SPAposition &	pos,
		SPAposition &	foot,
		const SPAparameter &	param_guess = *(SPAparameter*)NULL_REF,
		SPAparameter &	param_actual = *(SPAparameter*)NULL_REF
	)			const [inline, virtual, inherited]

Finds the closest point on this curve (the foot) to the given point.

Role: Optionally finds its parameter value as well. If an input parameter is supplied (as the first SPAparameter argument), the foot found is only the local solution nearest to the supplied parameter position. Any of the return value arguments may be a NULL reference, in which case it is simply ignored.

Parameters:

	pos	position whose closest curve point is desired.
	foot	closest position on the curve.
	param_guess	parameter guess.
	param_actual	actual parameter.

Reimplemented in ellipse, and intcurve.

curve* curve::copy_curve

(

)

const [inline, inherited]

Makes a copy of this curve.

curve::curve

(

)

[inline, inherited]

Constructs a curve (default constructor).

Role: Requests memory for this object but does not populate it.

virtual void curve::debug	(	const char *	lead,
		FILE *	fp = debug_file_ptr
	)			const [pure virtual, inherited]

Writes a description of this curve to a file.

Parameters:

	lead	leader string.
	fp	FILE pointer.

Implemented in compcurv, ellipse, helix, intcurve, and straight.

virtual int_cur* surf_int_cur::deep_copy

(

pointer_map *

pm = NULL

)

const [virtual, inherited]

Creates a copy of an item that does not share any data with the original.

Role: Allocates new storage for all member data and any pointers. Returns a pointer to the copied item.

Parameters:

pm

list of items within the entity that are already deep copied.

virtual curve* curve::deep_copy

(

pointer_map *

pm = NULL

)

const [pure virtual, inherited]

Creates a copy of this object that does not share any data with the original.

Role: Allocates new storage for all member data and any pointers. Returns a pointer to the copied item.

In a deep copy, all the information about the copied item is self-contained in a new memory block. By comparison, a shallow copy stores only the first instance of the item in memory, and increments the reference count for each copy.

The pointer_map keeps a list of all pointers in the original object that have already been deep copied. For example, a deep copy of a complex model results in self contained data, but identical sub-parts within the model are allowed to share a single set of data.

Parameters:

pm

list of items within the object that are already deep copied.

Implemented in compcurv, ellipse, helix, intcurve, and straight.

virtual const double* curve::discontinuities	(	int &	n_discont,
		int	order
	)			const [virtual, inherited]

Returns the number and parameter values of discontinuities of this curve, of the given order (maximum three), in a read-only array.

Parameters:

	n_discont	number of discontinuities found.
	order	order of the discontinuities.

Reimplemented in intcurve.

virtual int curve::discontinuous_at

(

double

t

)

const [virtual, inherited]

Determines whether a particular parameter value represents a discontinuity of this curve.

Parameters:

t

parameter value to test.

Reimplemented in intcurve.

curve* dispatch_restore_cu

(

char *

)

Restores a curve.

Role: Although this internal function is intended strictly for ACIS usage, a minimal amount of information about this function is provided for the sole purpose of being able to understand and trace restoration from a SAT file. This function should never be called directly, because it makes assumptions about the availability of a SAT file, the location of the input pointer into the SAT file, and the validity of SAT data it expects to read in. It also may start a lengthy process of nested function or class method calls, which have many of the same assumptions.

The restore function does the actual work of restoring the curve. It calls the base class, then reads the selector, if the save file is new enough. This reads the curve type and then switches in the run-time table to the correct restore routine.

    if (restore_version_number < CURVE_VERSION)
       read_int            Integer for the type of curve.
       dispatch_restore_cu Supply the number for the type of curve.
    else
       read_id             Reads in the string associated with the curve identification.
       dispatch_restore_cu Supply the curve identification for the type of curve.

Effect: Read-only

include <curdef.hxx>

curve* dispatch_restore_cu

(

int

)

Restores a curve.

Role: Although this internal function is intended strictly for ACIS usage, a minimal amount of information about this function is provided for the sole purpose of being able to understand and trace restoration from a SAT file. This function should never be called directly, because it makes assumptions about the availability of a SAT file, the location of the input pointer into the SAT file, and the validity of SAT data it expects to read in. It also may start a lengthy process of nested function or class method calls, which have many of the same assumptions.

The restore function does the actual work of restoring the curve. It calls the base class, then reads the selector, if the save file is new enough. This reads the curve type and then switches in the run-time table to the correct restore routine.

    if (restore_version_number < CURVE_VERSION)
       read_int            Integer for the type of curve.
       dispatch_restore_cu Supply the number for the type of curve.
    else
       read_id             Reads in the string associated with the curve identification.
       dispatch_restore_cu Supply the curve identification for the type of curve.

Effect: Read-only

include <curdef.hxx>

virtual curve_boundcyl curve::enclosing_cylinder

(

const SPAinterval &

range = *(SPAinterval *) NULL_REF

)

const [pure virtual, inherited]

Returns a cylinder that encloses the portion of this curve bounded by the given parameter interval.

Parameters:

range

the parameter interval.

Implemented in compcurv, ellipse, helix, intcurve, and straight.

virtual void curve::eval	(	double	param,
		SPAposition &	pos,
		SPAvector &	first_deriv = *(SPAvector *) NULL_REF,
		SPAvector &	second_deriv = *(SPAvector *) NULL_REF,
		logical	eval_repeated = FALSE,
		logical	approx_ok = FALSE
	)			const [virtual, inherited]

Evaluates this curve at a given parameter value, returning the position and the first and second derivatives (all optionally).

Role: The first logical argument, if TRUE, is a guarantee from the calling code that the most recent call to any curve or surface member function was in fact to the routine for the same curve as the current call. It allows an implementation to cache useful intermediate results to speed up repeated calculations, but must be used with extreme care.

The second logical argument may be set to TRUE if an approximate return value is acceptable. Here approximate is not well-defined, but may be assumed to be sufficient for visual inspection of the curve.

Parameters:

	param	parameter value at which to perform the evaluation.
	pos	position on curve at the specified parameter.
	first_deriv	first derivative at the specified parameter.
	second_deriv	second derivative at the specified parameter.
	eval_repeated	flag to signal a repeated evaluation.
	approx_ok	flag to signal that approximate results are OK.

Reimplemented in compcurv, ellipse, helix, intcurve, and straight.

virtual SPAvector curve::eval_curvature	(	double	param,
		logical	eval_repeated = FALSE,
		logical	approx_ok = FALSE
	)			const [virtual, inherited]

Finds the curvature at the given parameter value on this curve.

Role: See the description of the eval method regarding the two logical arguments.

Parameters:

	param	parameter value at which to perform the evaluation.
	eval_repeated	flag to signal a repeated evaluation.
	approx_ok	flag to signal that approximate results are OK.

Reimplemented in compcurv, intcurve, and straight.

virtual SPAvector curve::eval_deriv	(	double	param,
		logical	eval_repeated = FALSE,
		logical	approx_ok = FALSE
	)			const [virtual, inherited]

Finds the derivative (direction and magnitude) at the given parameter value on this curve.

Role: See the description of the eval method regarding the two logical arguments.

Parameters:

	param	parameter value at which to perform the evaluation.
	eval_repeated	flag to signal a repeated evaluation.
	approx_ok	flag to signal that approximate results are OK.

Reimplemented in compcurv, and intcurve.

virtual double curve::eval_deriv_len	(	double	param,
		logical	eval_repeated = FALSE,
		logical	approx_ok = FALSE
	)			const [virtual, inherited]

Finds the magnitude of the derivative at the given parameter value on this curve.

Role: See the description of the eval method regarding the two logical arguments.

Parameters:

	param	parameter value at which to perform the evaluation.
	eval_repeated	flag to signal a repeated evaluation.
	approx_ok	flag to signal that approximate results are OK.

Reimplemented in straight.

virtual SPAunit_vector curve::eval_direction	(	double	param,
		logical	eval_repeated = FALSE,
		logical	approx_ok = FALSE
	)			const [virtual, inherited]

Finds the tangent direction at the given parameter value on this curve.

Role: See the description of the eval method regarding the two logical arguments.

Parameters:

	param	parameter value at which to perform the evaluation.
	eval_repeated	flag to signal a repeated evaluation.
	approx_ok	flag to signal that approximate results are OK.

Reimplemented in intcurve.

virtual SPAposition curve::eval_position	(	double	param,
		logical	eval_repeated = FALSE,
		logical	approx_ok = FALSE
	)			const [virtual, inherited]

Finds the point on this curve corresponding to a given parameter value.

Role: See the description of the eval method regarding the two logical arguments.

Parameters:

	param	parameter value at which to perform the evaluation.
	eval_repeated	flag to signal a repeated evaluation.
	approx_ok	flag to signal that approximate results are OK.

Reimplemented in compcurv, and intcurve.

virtual int curve::evaluate	(	double	param,
		SPAposition &	pos,
		SPAvector **	derivs = NULL,
		int	num = 0,
		evaluate_curve_side	side = evaluate_curve_unknown
	)			const [virtual, inherited]

Calculates derivatives, of any order up to the number requested, and store them in vectors provided by the user.

Role: This function returns the number it was able to calculate; this is equal to the number requested in all but the most exceptional circumstances. A certain number are evaluated directly and (more or less) accurately; higher derivatives are automatically calculated by finite differencing. The accuracy of these decreases with the order of the derivative, as the cost increases.

Any of the derivs pointers may be NULL, in which case the corresponding derivative will not be returned.

Parameters:

	param	the parameter at which the curve is to be evaluated.
	pos	point on the curve at the given parameter.
	derivs	pointer arrays of derivatives.
	num	the number of derivatives required.
	side	the evaluation location - above, below, or "don't care".

Reimplemented in compcurv, ellipse, helix, intcurve, and straight.

virtual int curve::evaluate_iter	(	double	param,
		curve_evaldata *	ini_data,
		SPAposition &	pos,
		SPAvector **	derivs = NULL,
		int	num = 0,
		evaluate_curve_side	side = evaluate_curve_unknown
	)			const [virtual, inherited]

Calculates derivatives, of any order up to the number requested, in an iterative fashion.

Role: The purpose of this method is the same as that of evaluate, but evaluate_iter is additionally supplied with a data object that contains results from a previous close evaluation, for use as initial values for any iteration involved. This object may furthermore be updated to reflect the results of this evaluation. The default implementation simply ignores this object and calls evaluate.

Parameters:

	param	the parameter at which the curve is to be evaluated.
	ini_data	data supplying initial values.
	pos	point on the curve at the given parameter.
	derivs	pointer arrays of derivatives.
	num	the number of derivatives required.
	side	the evaluation location - above, below, or "don't care".

Reimplemented in intcurve.

virtual curve_extremum* curve::find_extrema

(

const SPAunit_vector &

dir

)

const [pure virtual, inherited]

Finds the extrema of this curve in a given direction.

Parameters:

dir

direction in which to find the extrema.

Implemented in compcurv, ellipse, helix, intcurve, and straight.

virtual int curve::finite_difference_derivatives	(	double	param,
		SPAposition &	pos,
		SPAvector **	derivs,
		int	nd,
		int	nfound,
		double	dt,
		evaluate_curve_side	side
	)			const [protected, virtual, inherited]

Evaluate higher derivatives than are available accurately in evaluate by finite differencing.

Role: Any of the derivs pointers may be NULL, in which case the corresponding derivative will not be returned.

Parameters:

	param	the parameter at which the curve is to be evaluated.
	pos	point on the curve at the given parameter.
	derivs	pointer arrays of derivatives.
	nd	the number of derivatives required.
	nfound	the number of derivatives already evaluated, and directly evaluable in the neighborhood of the param.
	dt	the finite differencing step to use.
	side	the evaluation location - above, below, or "don't care".

bounded_curve* get_bounded_curve	(	EDGE *	edge,
		logical	apply_transf = TRUE
	)

Gets a bounded_curve from an EDGE.

Role: The bounded_curve contains a copy of the curve pointed to by the EDGE. If the EDGE belongs to a BODY, then by default the BODY transformation is applied, so the bounded curve is always defined in the model coordinate system rather than in the coordinate system of the BODY.

This method differs from the constructor for bounded curve in that it checks the type of the curve of the EDGE, and creates the appropriate type of bounded curve. For example, if the EDGE points to a STRAIGHT, this method creates a bounded line and returns it.

Effect: Read-only

Parameters:

	edge	EDGE from which to get the bounded curve.
	apply_transf	flag to apply the BODY transformation.

include <bnd_crv.hxx>

virtual const discontinuity_info& curve::get_disc_info

(

)

const [virtual, inherited]

Returns read-only access to a discontinuity_info object, if there is one.

Role: The default version of this method returns NULL.

Reimplemented in intcurve.

virtual int curve::high_curvature	(	double	k,
		SPAinterval *&	spans
	)			const [virtual, inherited]

Finds regions of high curvature of this curve.

Role: This method stores an array of intervals in the spans argument, to signify ranges over which the curvature exceeds k. It returns the number of intervals stored.

Parameters:

	k	maximum curvature.
	spans	the interval list.

Reimplemented in ellipse, helix, and straight.

static int surf_int_cur::id

(

)

[static, inherited]

Returns the ID for the surf_int_cur list.

virtual law* curve::law_form

(

)

[inline, virtual, inherited]

Returns a pointer to the law form of this curve, or else NULL.

Reimplemented in ellipse, helix, intcurve, and straight.

virtual double curve::length	(	double	param1,
		double	param2,
		logical	approx_ok = TRUE
	)			const [pure virtual, inherited]

Returns the algebraic distance (arc length) along this curve between the two given parameters.

Role: The sign is positive if the parameter values are given in increasing order and negative if they are in decreasing order.

Parameters:

	param1	first parameter bounding the arc.
	param2	second parameter bounding the arc.
	approx_ok	If approx_ok is true, and the curve has a B-spline approximation, then this approximation is used in the length calculation.

Implemented in compcurv, ellipse, helix, intcurve, and straight.

virtual double curve::length_param	(	double	param,
		double	length,
		logical	approx_ok = TRUE
	)			const [pure virtual, inherited]

Returns the parameter value of the point on this curve at the given algebraic arc length from that defined by the given parameter.

Role: This method is the inverse of the length method. The result is not defined for a bounded nonperiodic curve if the param argument is outside the parameter range, or if the length argument is outside the range bounded by the values for the ends of the parameter range.

Parameters:

	param	datum parameter value.
	length	arc length.
	approx_ok	If approx_ok is true, and the curve has a B-spline approximation, then this approximation is used in the length calculation.

Implemented in compcurv, ellipse, helix, intcurve, and straight.

void curve::limit

(

const SPAinterval &

range

)

[inherited]

Subsets this curve in place, ensuring canonical results if the underlying curve is bounded or periodic.

Parameters:

range

subset range.

virtual curve* curve::make_copy

(

)

const [pure virtual, inherited]

Makes a copy of this curve.

Role: This is a pure virtual function to ensure that each derived class defines its own.

Implemented in compcurv, ellipse, helix, intcurve, and straight.

virtual curve_evaldata* curve::make_evaldata

(

)

const [virtual, inherited]

Constructs a data object to retain evaluation information across calls to the evaluate_iter method.

Role: This is to allow subsidiary calls within an iterative evaluator to start iteration much closer to the required result than is possible just using the curve information itself. The default returns NULL, indicating that no special information is required or usable.

Reimplemented in intcurve.

virtual logical curve::need_save_as_approx	(	int	save_to_version,
		logical	check_progenitors
	)			const [virtual, inherited]

Queries whether the object needs to be saved to an old version as an approximation.

Role: Called by SAT save APIs with check_progenitors==TRUE to determine if an object needs to be tolerantly simplified before being saved to an old version. The check_progenitors flag indicates that the object should call need_save_as_approx() on any curve or surface construction geometry upon which it depends, and return TRUE if any of the progenitors do. Customers with their own derived curve or surface types should override this routine to return TRUE whenever they want their geometry to be imported (as a B-spline approximation) into other applications or when saving to a version of their application before the derived geometry type in question existed.

Parameters:

	save_to_version	ACIS version to which the object will be saved
	check_progenitors	if TRUE, query construction geometry and base class as well

Reimplemented in helix, and intcurve.

virtual curve& curve::negate

(

)

[pure virtual, inherited]

Reverses the sense of this curve.

Implemented in compcurv, ellipse, helix, intcurve, and straight.

logical curve::operator!=

(

const curve &

cur

)

const [inline, inherited]

Tests this curve for inequality to another curve.

Parameters:

cur

curve to compare for inequality.

straight operator*	(	straight const &	input,
		SPAtransf const &	trans
	)

Applies transformation to straight curve.

Parameters:

	input	input straight curve.
	trans	transformation to use.

include <strdef.hxx>

intcurve operator*	(	intcurve const &	intcur,
		SPAtransf const &	trans
	)

Returns a copy of the transformed curve.

Parameters:

	intcur	intcurve.
	trans	transformation.

include <intdef.hxx>

helix operator*	(	helix const &	name,
		SPAtransf const &	transf
	)

Returns a helix transformed by the given transformation.

Parameters:

	name	helix to transform.
	transf	transformation.

include <heldef.hxx>

ellipse operator*	(	ellipse const &	name,
		SPAtransf const &	transf
	)

Returns an ellipse transformed by the given transformation.

Parameters:

	name	ellipse to transform.
	transf	transformation.

include <elldef.hxx>

virtual curve& curve::operator*=

(

const SPAtransf &

transf

)

[pure virtual, inherited]

Transforms this curve.

Parameters:

transf

transformation to apply.

Implemented in compcurv, ellipse, helix, intcurve, and straight.

virtual logical curve::operator==

(

const curve &

cur

)

const [virtual, inherited]

Tests this curve for equality to another curve.

Role: This method is not guaranteed to return TRUE for effectively-equal curves, but is guaranteed to return FALSE if the curves are not equal. The result can be used for optimization. The default is FALSE.

Parameters:

cur

curve to compare for equality.

Reimplemented in compcurv, ellipse, helix, intcurve, and straight.

virtual double curve::param	(	const SPAposition &	pos,
		const SPAparameter &	param_guess = *(SPAparameter *) NULL_REF
	)			const [pure virtual, inherited]

Finds the parameter value of a given position on the curve.

Parameters:

	pos	the position for which the parameter value is to be found.
	param_guess	parameter guess.

Implemented in compcurv, ellipse, helix, intcurve, and straight.

virtual double curve::param_period

(

)

const [pure virtual, inherited]

Returns the period of a periodic curve, or 0 if this curve is not periodic.

Implemented in compcurv, ellipse, helix, intcurve, and straight.

virtual SPAinterval curve::param_range

(

const SPAbox &

region = *(SPAbox *) NULL_REF

)

const [pure virtual, inherited]

Returns the principal parameter range of this curve.

Role: The definition of a periodic curve is extended to all parameter values by reducing the given parameter modulo the period into this principal range. For an open unbounded curve, the principal range is conventionally the empty interval. For bounded open or nonperiodic curves the curve evaluation functions are defined only for parameter values in this range. If a region of interest is provided, a valid range is always returned, even for an unbounded curve, representing a portion of the curve that is guaranteed to include all segments that lie within the region of interest.

Parameters:

region

region of interest.

Implemented in compcurv, ellipse, helix, intcurve, and straight.

virtual pcurve* curve::pcur	(	int	n,
		logical	copy_curve = FALSE
	)			const [virtual, inherited]

Returns the nth parametric curve.

Role: If this curve is defined with respect to n or more surfaces and the nth is parametric, this method returns the corresponding pcurve; otherwise, NULL is returned. If the argument is negative, this method returns the pcurve corresponding to the absolute value of the argument, but reversed in sense.

Parameters:

	n	integer denoting the parameter-space curve.
	copy_curve	flag indicating whether the pcurve returned is temporary - if so, the bs2_curve will not be copied, improving performance.

Reimplemented in intcurve.

virtual logical curve::pcur_present

(

int

n

)

const [virtual, inherited]

Determines if the nth parameter-space curve is defined for this curve.

Parameters:

n

integer denoting the parameter-space curve.

Reimplemented in intcurve.

virtual logical curve::periodic

(

)

const [pure virtual, inherited]

Indicates if this curve is periodic.

Role: If so, it joins itself smoothly at the ends of its principal parameter range, so that EDGEs span the seam.

Implemented in compcurv, ellipse, helix, intcurve, and straight.

virtual SPAvector curve::point_curvature	(	const SPAposition &	pos,
		const SPAparameter &	param_guess = *(SPAparameter *) NULL_REF
	)			const [pure virtual, inherited]

Finds the curvature of this curve at the given point.

Parameters:

	pos	position of the point at which the curvature is to be found.
	param_guess	parameter guess.

Implemented in compcurv, ellipse, helix, intcurve, and straight.

virtual SPAunit_vector curve::point_direction	(	const SPAposition &	pos,
		const SPAparameter &	param_guess = *(SPAparameter *) NULL_REF
	)			const [pure virtual, inherited]

Finds tangent direction of this curve at the given point.

Parameters:

	pos	position of the point at which the tangent direction is to be found.
	param_guess	parameter guess.

Implemented in compcurv, ellipse, helix, intcurve, and straight.

void curve::point_perp	(	const SPAposition &	point,
		SPAposition &	foot,
		const SPAparameter &	param_guess = *(SPAparameter *) NULL_REF,
		SPAparameter &	param_actual = *(SPAparameter *) NULL_REF,
		logical	f_weak = FALSE
	)			const [inherited]

Finds the foot of the perpendicular from the given point to this curve and the corresponding parameter value.

Role: And its parameter value. If an input parameter value is supplied (as the first parameter argument), the perpendicular found is the one nearest to the supplied parameter position; otherwise, it is the one that the curve is nearest to the given point. Any of the return value arguments may be a NULL reference, in which case it is simply ignored.

Parameters:

	point	the input position.
	foot	the position on the curve.
	param_guess	parameter guess.
	param_actual	the actual parameter.
	f_weak	weak flag.

Reimplemented in compcurv, ellipse, helix, intcurve, and straight.

void curve::point_perp	(	const SPAposition &	point,
		SPAposition &	foot,
		SPAunit_vector &	tangent,
		const SPAparameter &	param_guess = *(SPAparameter *) NULL_REF,
		SPAparameter &	param_actual = *(SPAparameter *) NULL_REF,
		logical	f_weak = FALSE
	)			const [inherited]

Finds the foot of the perpendicular from the given point to this curve, the tangent to the curve at that point, and the corresponding parameter value.

Role: If an input parameter value is supplied (as the param_guess argument), the perpendicular found is the one nearest to the corresponding position; otherwise, it is the one at which the curve is nearest to the given point. Any of the return value arguments may be a NULL reference, in which case it is ignored.

Parameters:

	point	the input position.
	foot	the position on the curve.
	tangent	the returned tangent.
	param_guess	parameter guess.
	param_actual	the actual parameter.
	f_weak	weak flag.

Reimplemented in compcurv, ellipse, helix, intcurve, and straight.

virtual void curve::point_perp	(	const SPAposition &	point,
		SPAposition &	foot,
		SPAunit_vector &	tangent,
		SPAvector &	curvature,
		const SPAparameter &	param_guess = *(SPAparameter *) NULL_REF,
		SPAparameter &	actual_param = *(SPAparameter *) NULL_REF,
		logical	f_weak = FALSE
	)			const [pure virtual, inherited]

Finds the foot of the perpendicular from the given point to this curve, the tangent and curvature of the curve at that point, and the corresponding parameter value.

Role: If an input parameter value is supplied (as the param_guess argument), the perpendicular found is the one nearest to the corresponding position; otherwise, it is the one at which the curve is nearest to the given point. Any of the return value arguments may be a NULL reference, in which case it is ignored.

Parameters:

	point	the input position.
	foot	the position on the curve.
	tangent	the returned tangent.
	curvature	the curvature at the curve position.
	param_guess	parameter guess.
	param_actual	the actual parameter.
	f_weak	weak flag.

Implemented in compcurv, ellipse, helix, intcurve, and straight.

curve* restore_curve

(

)

Restores a curve.

Role: Although this internal function is intended strictly for ACIS usage, a minimal amount of information about this function is provided for the sole purpose of being able to understand and trace restoration from a SAT file. This function should never be called directly, because it makes assumptions about the availability of a SAT file, the location of the input pointer into the SAT file, and the validity of SAT data it expects to read in. It also may start a lengthy process of nested function or class method calls, which have many of the same assumptions.

The restore function does the actual work of restoring the curve. It calls the base class, then reads the selector, if the save file is new enough. This reads the curve type and then switches in the run-time table to the correct restore routine.

    if (restore_version_number < CURVE_VERSION)
       read_int            Integer for the type of curve.
       dispatch_restore_cu Supply the number for the type of curve.
    else
       read_id             Reads in the string associated with the curve identification.
       dispatch_restore_cu Supply the curve identification for the type of curve.

Effect: Read-only

include <curdef.hxx>

void curve::restore_data

(

)

[inherited]

Restores the data for this curve, according to its type.

Role: The base class version of this method only restores the subset_range member. For convenience, it can be called by derived class versions.

The restore operation switches on a table defined by static instances. This invokes a simple friend function which constructs an object of the right derived type. Then it calls the appropriate base class member function to do the actual work. The restore_data function for each class can be called in circumstances when it is known what type of curve is to be expected and a curve of that type is on hand to be filled in.

    if (restore_version_number >= BNDCUR_VERSION)
       read_interval		Interval for the subset range. 

Reimplemented in compcurv, ellipse, helix, intcurve, and straight.

subtype_object* restore_int_int_cur

(

)

As a result, it has to get at the surface and pcurve pointers.

include <intdef.hxx>

virtual void curve::save

(

)

const [pure virtual, inherited]

Saves a curve of unknown type, together with its type code for later retrieval.

Implemented in compcurv, ellipse, helix, intcurve, and straight.

void curve::save_curve

(

)

const [inherited]

Saves a curve of unknown type, or NULL.

Role: Simply checks for NULL, then calls save.

virtual void surf_int_cur::save_data

(

)

const [virtual, inherited]

Save the information for the surf_int_cur to a save file.

void curve::save_data

(

)

const [inherited]

Saves a curve of a known type.

Role: The context determines the curve type, so that no type code is necessary. The base class version simply saves the subset_range member - for convenience, it can be called by derived class versions.

Reimplemented in ellipse, helix, intcurve, and straight.

virtual curve* curve::split	(	double	param,
		const SPAposition &	pos = *(SPAposition *) NULL_REF
	)			[virtual, inherited]

Splits this curve at the given parameter value, if possible.

Role: If the curve is splittable (not closed - in practice, one defined or approximated by one or more splines), constructs a new curve coincident with and with the same parameterization as the given curve and modifies the given curve to represent only the remainder of the curve. If the curve cannot be split, returns NULL. The default is to make the curve nonsplittable.

Parameters:

	param	parameter value at which to split.
	pos	position through which the curve should pass.

Reimplemented in compcurv, and intcurve.

curve* curve::subset

(

const SPAinterval &

range

)

const [inherited]

Constructs a subsetted copy of this curve.

Parameters:

range

the subet range.

Reimplemented in compcurv, and intcurve.

logical curve::subsetted

(

)

const [inherited]

Indicates whether this curve has a significant subset range.

surf_int_cur::surf_int_cur

(

const surf_int_cur &

input

)

[inherited]

C++ copy constructor requests memory for this object and populates it with the data from the object supplied as an argument.

Parameters:

input

input curve.

surf_int_cur::surf_int_cur	(	bs3_curve	splcur,
		double	tol,
		surface const &	surf1,
		surface const &	surf2,
		bs2_curve	cur1,
		bs2_curve	cur2,
		logical	trcur = TRUE,
		const SPAinterval &	range = *(const class SPAinterval *) NULL_REF
	)			[inherited]

C++ initialize constructor requests memory for this object and populates it with the data supplied as arguments.

Parameters:

	splcur	spline curve.
	tol	fit tolerance.
	surf1	1st surface for curve.
	surf2	2nd surface for curve.
	cur1	1st curve in param space.
	cur2	2nd curve in param space.
	trcur	surface for true curve.
	range	safe range for curve.

surf_int_cur::surf_int_cur	(	bs3_curve	splcur,
		double	tol,
		surface const &	surf = *(surface *) NULL_REF,
		bs2_curve	cur = NULL,
		logical	trcur = TRUE,
		const SPAinterval &	range = *(const class SPAinterval *) NULL_REF
	)			[inherited]

C++ initialize constructor requests memory for this object and populates it with the data supplied as arguments.

Parameters:

	splcur	spline curve.
	tol	fit tolerance.
	surf	surface where curve lies.
	cur	curve in param space.
	trcur	surface for true curve.
	range	safe range for curve.

virtual curve_tancone curve::tangent_cone	(	const SPAinterval &	range,
		logical	approx_OK = FALSE,
		const SPAtransf &	transf = *(SPAtransf *) NULL_REF
	)			const [pure virtual, inherited]

Returns a cone bounding the tangent direction of this curve.

Role: The cone is deemed to have its apex at the origin and have a given axis direction and (positive) half angle. If the logical argument is TRUE, then a quick approximation may be found. The approximate result may lie wholly within or wholly outside the guaranteed bound (obtained with a FALSE argument), but may not cross from inside to outside. Flags in the returned object indicate whether the cone is in fact the best available and, if not, whether this result is inside or outside the best cone.

Parameters:

	range	the given range.
	approx_OK	approximate result is ok.
	transf	transformation to apply.

Implemented in compcurv, ellipse, helix, intcurve, and straight.

logical curve::test_point	(	const SPAposition &	pos,
		const SPAparameter &	param_guess = *(SPAparameter*)NULL_REF,
		SPAparameter &	param_actual = *(SPAparameter*)NULL_REF
	)			const [inline, inherited]

Tests point-on-curve, optionally returning the exact parameter value if the point is on this curve.

Role: This method tests to standard system precision.

Parameters:

	pos	position of the point to test.
	param_guess	parameter guess.
	param_actual	actual parameter.

virtual logical curve::test_point_tol	(	const SPAposition &	pos,
		double	tol = 0,
		const SPAparameter &	param_guess = *(SPAparameter *) NULL_REF,
		SPAparameter &	param_actual = *(SPAparameter *) NULL_REF
	)			const [pure virtual, inherited]

Tests point-on-curve to a given precision, optionally returning the exact parameter value if the point is on this curve.

Parameters:

	pos	position of the point to test.
	tol	tolerance within which to test.
	param_guess	parameter guess.
	param_actual	actual parameter.

Implemented in compcurv, ellipse, helix, intcurve, and straight.

virtual int surf_int_cur::type

(

)

const [virtual, inherited]

Returns the type of surf_int_cur.

virtual int curve::type

(

)

const [pure virtual, inherited]

Returns an identifier that specifies the curve type.

Implemented in compcurv, ellipse, helix, intcurve, and straight.

virtual char const* surf_int_cur::type_name

(

)

const [virtual, inherited]

Returns the string "surfcur".

virtual char const* curve::type_name

(

)

const [pure virtual, inherited]

Returns the string "curve".

Implemented in compcurv, ellipse, helix, intcurve, and straight.

virtual logical curve::undef

(

)

const [virtual, inherited]

Indicates whether this curve is properly defined.

Role: A NULL or generic curve is always undefined - other curves depend on their contents.

Reimplemented in compcurv, ellipse, helix, intcurve, and straight.

logical curve::undefined

(

)

const [inline, inherited]

Indicates whether this curve is properly defined.

Role: A NULL or generic curve is always undefined - other curves depend on their contents.

void curve::unlimit

(

)

[inherited]

Removes the parameter limits from this curve.

curve* curve::unsubset

(

)

const [inherited]

Constructs a copy of the unbounded curve underlying this one.

virtual curve::~curve

(

)

[virtual, inherited]

C++ destructor, deleting a curve.

Role: Ensures a derived class destructor is consulted when destroying a curve.

---

Friends

curve* restore_curve

(

)

[friend, inherited]

Restores a curve.

Role: Although this internal function is intended strictly for ACIS usage, a minimal amount of information about this function is provided for the sole purpose of being able to understand and trace restoration from a SAT file. This function should never be called directly, because it makes assumptions about the availability of a SAT file, the location of the input pointer into the SAT file, and the validity of SAT data it expects to read in. It also may start a lengthy process of nested function or class method calls, which have many of the same assumptions.

The restore function does the actual work of restoring the curve. It calls the base class, then reads the selector, if the save file is new enough. This reads the curve type and then switches in the run-time table to the correct restore routine.

    if (restore_version_number < CURVE_VERSION)
       read_int            Integer for the type of curve.
       dispatch_restore_cu Supply the number for the type of curve.
    else
       read_id             Reads in the string associated with the curve identification.
       dispatch_restore_cu Supply the curve identification for the type of curve.

Effect: Read-only