intcurve
List of: Classes
Subjects: Construction Geometry, SAT Save and Restore
Contents: Kernel

Purpose: An interpolated curve type.

Derivation: intcurve : curve : ACIS_OBJECT : -

SAT Identifier: "intcurve"

Filename: kern/kernel/kerngeom/curve/intdef.hxx

Description: An intcurve is the general representation of any curve that is not defined by an explicit equation, but by reference to other geometric entities. This includes the intersection between two surfaces, the projection of a curve onto a surface, an exact spline curve, or any other general curve.


The intcurve class represents parametric object-space curves that map an interval of the real line into a 3D real vector space (object-space). This mapping is continuous, and one-to-one except possibly at the ends of the interval whose images may coincide. It is differentiable twice, and the direction of the first derivative with respect to the parameter must be continuous. This direction is the positive sense of the curve.


If the two ends of the curve are different in object space, the curve is open. If they are the same, it is closed. If the curve joins itself smoothly, the curve is periodic, and its period is the length of the interval that it is primarily defined. A periodic curve is defined for all parameter values by adding a multiple of the period to the parameter value so that the result is within the definition interval, and evaluating the curve at that resultant parameter. The point at the ends of the primary interval is known as the seam.


The intcurve class provides an abstraction of the concept of a parametric representation of an interpolated curve. This interpolated curve can be either an "exact" curve or an "approximate" curve that is a fit to a true curve within some fit tolerance.


The intcurve contains a "reversed" bit together with a pointer to another structure, an int_cur or something derived from it that contains the bulk of the information about the curve.


Providing this indirection serves two purposes. First, when an intcurve is duplicated, the copy simply points to the same int_cur, avoiding copying the bulk of the data. The system maintains a use count in each int_cur, that allows automatic duplication if a shared int_cur is to be modified, and deletes any int_cur no longer accessible.


Second, the int_cur contains virtual functions. These virtual functions perform all the operations defined for intcurves that depend on the method of definition of the true curve, so new curve types can be defined by declaring and implementing derived classes. The intcurve and everything using it require no changes to make use of the new definition.


The base class int_cur contains the following information for defining the curve:


- A use count indicating the number of times the int_cur is referred.

- A pointer to a bs3_curve, that represents a spline approximation to the true curve.

- A fitting tolerance representing the precision of the spline approximation to the true curve. This is 0.0 for an exact fit and greater than 0.0 for an approximation.

- Pointers to two surfaces containing the true curve. A class derived from int_cur can use them in different ways but the true curve must lie on each of the surfaces. Either or both surface can be NULL.

- A pointer to two 2D parametric space curves, one on each of the non-NULL, spline surfaces defined above, that represent the 3D spline approximation.


Classes derived from int_cur can contain additional information and record the creation method of the true spline curve.


This file defines the class intcurve, the base class int_cur, which implements curves of intersection between two surfaces (as well as exact spline curves), and an auxiliary class restore_ic_def, which is used to declare int_cur and any derived class to the "restore" system, to allow the correct derived class to be restored from backing store.

References: KERN discontinuity_info, int_cur

by KERN INTCURVE, imp_par_cur, int_cur, int_int_cur

Constructor: public: intcurve::intcurve ();


C++ allocation constructor requests memory for this object but does not populate it.






public: intcurve::intcurve (


bs3_curve,
// bs3_curve


double,
// tolerance


surface const&,
// first surface


surface const&,
// second surface


bs2_curve
// first bs2_curve



= NULL,


bs2_curve
// second bs2_curve



= NULL,


const SPAtransf&
// interval



= * (SPAtransf*) NULL_REF,


logical parametric_is_primary// parametric is



= FALSE
// primary


);


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


Usually, this method is used for constructing exact spline curves.






public: intcurve::intcurve (


curve_interp&, // interpolated curve


SPAbox const& // bounding box



= * (SPAbox* ) NULL_REF


);


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


The curve_interp object contains all the data and methods needed to do the interpolation. In addition, a box is supplied within which the fit tolerance must be met.






public: intcurve::intcurve (


intcurve const& // intcurve


);


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






public: intcurve::intcurve (


int_cur* // int_cur


);


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


This creates an intcurve object when the underlying int_cur has been constructed. The int_cur is a derived type which does not need a curve fit or uses a non-standard one.




Destructor: public: intcurve::~intcurve ();


C++ destructor, deleting an intcurve. Deletes an intcurve by manipulating the use count of the underlying int_cur structure.



Methods: public: virtual int intcurve::accurate_derivs (


SPAinterval const&
// interval



= * (SPAinterval*) NULL_REF


) const;


Returns the number of derivatives that evaluate finds accurately and directly, rather than by finite differencing, over the given portion of the curve. If there is no limit to the number of accurate derivatives, this method returns the value ALL_CURVE_DERIVATIVES.






public: virtual const double*


intcurve::all_discontinuities (


int& n_discont, // number of




// discontinuities


int order // order


);


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






public: virtual double


intcurve::approx_error () const;


Returns a distance value, which represents the greatest discrepancy between positions calculated by calls to eval or eval_position with the approximate results OK logical set by turns to TRUE and FALSE.






public: SPAbox intcurve::bound (


double start,
// first position


double end,
// second position


SPAtransf const& t
// transformation



= * (SPAtransf* ) NULL_REF


) const;


Returns a box enclosing the two given points on the undefined curve line.






public: virtual SPAbox intcurve::bound (


SPAbox const&,
// bounding box


SPAtransf const&
// transformation



= * (SPAtransf* ) NULL_REF


) const;


Returns a box surrounding that portion of the curve within the given box.






public: virtual SPAbox intcurve::bound (


SPAinterval const&,
// interval


SPAtransf const&
// transformation



= * (SPAtransf* ) NULL_REF


) const;


Returns a box surrounding that portion of the curve within the given parameter interval.






public: virtual SPAbox intcurve::bound (


SPAposition const&,
// first position


SPAposition const&,
// second position


SPAtransf const&
// transformation



= * (SPAtransf* ) NULL_REF


) const;


Returns a box enclosing the two given points on the undefined curve line.






public: int intcurve::bs1_hull_angles_ok () const;


Returns 1 if the bs1_curve hull turning angles are known to be acceptable, 0 if they are not acceptable, and -1 if unknown.






public: int


intcurve::bs1_hull_self_intersects () const;


Returns 1 if the bs1_curve hull is known to self intersect, 0 if it does not, and -1 if unknown.






public: int intcurve::bs1_knots_on_curve () const;


Returns 1 if the bs1_curve knots are known to lie on the curve, 0 if they do not, and -1 if unknown.






public: int intcurve::bs2_hull_angles_ok () const;


Returns 1 if the bs2_curve hull turning angles are known to be acceptable, 0 if they are not acceptable, and -1 if unknown.






public: int


intcurve::bs2_hull_self_intersects () const;


Returns 1 if the bs2_curve hull is known to self intersect, 0 if it does not, and -1 if unknown.






public: int intcurve::bs2_knots_on_curve () const;


Returns 1 if the bs2_curve knots are known to lie on the curve, 0 if they do not, and -1 if unknown.






public: virtual void intcurve::change_event ();


Notifies the derived type that the curve has been changed (e.g. the subset_range has changed) so that it can update itself.






public: virtual check_status_list* intcurve::check (


const check_fix& input

// flags for



= * (const check_fix*)
// allowed



NULL_REF,

// fixes


check_fix& result

// fixes applied



= * (check_fix*) NULL_REF,


const check_status_list*

// checks to be



= (const check_status_list*) // made, default



NULL_REF

// is none


);


Check for any data errors in the curve, and correct the errors if possible. 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 the set of flags which say which fixes are allowable is none (nothing is 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.






public: virtual logical intcurve::closed () const;


Indicates if a curve is closed. A closed curve joins itself (smoothly or not) at the ends of its principal parameter range. This method always returns TRUE if periodic returns TRUE.






public: virtual void intcurve::closest_point (


SPAposition const& pos,

// position


SPAposition& foot,

// foot position


SPAparameter const& param_guess // input guess



= * (SPAparameter* )NULL_REF,// value of






// param


SPAparameter& param_actual
// actual value



= * (SPAparameter* )NULL_REF // of param


) const;


Finds the closest point on the curve (the foot) to the given point, and optionally its parameter value. If an input parameter value is supplied (as the first parameter argument), the foot found is only a 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.






public: bs3_curve intcurve::cur (


double tol // tolerance



= -1.0


) const;


Returns the underlying bs3_curve; otherwise, it returns NULL if there is no int_cur.






public: logical intcurve::cur_present () const;


Returns TRUE if the nth parameter-space curve is defined (i.e. pcur() would return a non-NULL pcurve pointer), FALSE otherwise.






public: virtual void intcurve::debug (


char const*, // title line


FILE* // file name



= debug_file_ptr


) const;


Outputs a title line and the details of the intcurve for inspection to standard output or to the specified file.






public: virtual curve* intcurve::deep_copy (


pointer_map* pm // list of items within



= NULL // the entity that are




// already deep copied


) const;


Creates a copy of an item that does not share any data with the original. Allocates new storage for all member data and any pointers. Returns a pointer to the copied item.






public: virtual const double*


intcurve::discontinuities (


int& n_discont, // # discontinuities


int order // curve order


) const;


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






public: virtual int intcurve::discontinuous_at (


double t // parameter value


) const;


Determines whether a particular parameter value is a discontinuity.






public: virtual curve_boundcyl


intcurve::enclosing_cylinder (


const SPAinterval&
// interval



= * (SPAinterval*) NULL_REF


) const;


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






public: virtual void intcurve::eval (


double,
// parameter value


SPAposition&,
// position


SPAvector&
// first derivative



= * (SPAvector* ) NULL_REF,


SPAvector&
// second derivative



= * (SPAvector* ) NULL_REF,


logical
// perform a repeat



= FALSE,
// evaluation on a





// curve whose





// underlying





// geometry data has





// not changed?


logical
// approx results OK?



= FALSE


) const;


Evaluates the curve, giving the position and the first and second derivatives.






public: virtual int intcurve::evaluate (


double,
// parameter value


SPAposition&,
// point


SPAvector**
// first derivative



= NULL,


int

// second derivative



= 0,


evaluate_curve_side
// which side of





// discontinuity to



= evaluate_curve_unknown // evaluate


) const;


Evaluates the position and the first and second derivatives at given parameter value.






public: virtual int intcurve::evaluate_iter (


double,
// parameter


curve_evaldata*,
// data supplying





// initial values,





// and set to reflect





// the results of





// this evaluation


SPAposition&,
// point on curve at





// given parameter


SPAvector**
// array of pointers



= NULL,
// to vectors, of





// size nd. Any of





// the pointers may





// be null, in which





// case the





// corresponding





// derivative will





// not be returned


int

// number of



= 0,
// derivatives





// required (nd)


evaluate_curve_side
// evaluation





// location - above,





// below or don't



= evaluate_curve_unknown // care


) const;


The evaluate_iter function is just like evaluate, but is supplied with a data object which contains results from a previous close evaluation, for use as initial values for any iteration involved.






public: virtual SPAvector intcurve::eval_curvature (


double, // parameter value


logical // perform a repeat



= FALSE, // evaluation on a




// curve whose underlying




// geometry data has not




// changed?


logical // approx results OK?



= FALSE


) const;


Finds the curvature at a point on the curve.






public: virtual SPAvector intcurve::eval_deriv (


double, // parameter value


logical // perform a repeat



= FALSE, // evaluation on a




// curve whose underlying




// geometry data has not




// changed?


logical // approx results OK?



= FALSE


) const;


Finds the parametric derivative, magnitude, and direction, at a point on the curve.






public: virtual SPAunit_vector


intcurve::eval_direction (


double, // parameter on the curve


logical // determine tangency



= FALSE,


logical // approx results OK?



= FALSE


) const;


Find the tangent direction at the given parameter value on the curve.






public: virtual SPAposition intcurve::eval_position (


double, // parameter value


logical // perform a repeat



= FALSE, // evaluation on a




// curve whose underlying




// geometry data has not




// changed?


logical // approx results OK?



= FALSE


) const;


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






public: virtual curve_extremum*


intcurve::find_extrema (


SPAunit_vector const& // direction


) const;


Finds the extrema of an intersection curve in a given direction, ignoring its ends unless it is closed.






public: double intcurve::fitol () const;


Returns the fit tolerance; otherwise, it returns 0 if there is no precise int_cur.






public: virtual const discontinuity_info&


intcurve::get_disc_info() const;


Returns read-only access to a discontinuity_info object, if there is one. The default version of the function returns NULL.






public: int_cur const&


intcurve::get_int_cur () const;


Returns the fit tolerance, but should not be used unless absolutely necessary.






public: int intcurve::hull1_enclosure () const;


Returns 1 if the bs1_curve hull is known to enclose the curve, 0 if it does not, and -1 if unknown.






public: int intcurve::hull2_enclosure () const;


Returns 1 if the bs2_curve hull is known to enclose the curve, 0 if it does not, and -1 if unknown.






public: logical intcurve::join (


intcurve& second, // intcurve


int order // discontinuity order



= -1


);


Join two pieces of intcurve together, adding a discontinuity of the given order at the join (if order is not supplied, or is nonpositive, then it is calculated).


The curves must be suitable for joining. The following conditions must be satisfied:


1. The start of the second curve must match the end of 'this'.

2. The underlying int_curs must have the same type.

3. The first curve must be unlimited above, and the second curve unlimited below.


If any of these conditions are violated, the function returns FALSE and the curves are unchanged.


The other ends may also match, in which case they will also be joined and the final curve will be periodic.






public: law* intcurve::law_form ();


Returns the law form for an intcurve.






public: virtual double intcurve::length (


double, // first parameter


double // second parameter


) const;


Returns the algebraic distance along the curve between the given parameters. The value is positive if the parameter values are given in increasing order and negative if they are in decreasing order. The result is undefined if either parameter value is outside the parameter range of a bounded curve. For a periodic curve, the parameters are not reduced to the principal range, and so the portion of the curve evaluated may include several complete circuits. This method is always a monotonically increasing function of its second argument if the first is held constant, and a decreasing function of its first argument if the second is held constant.






public: virtual double intcurve::length_param (


double, // datum parameter


double // arc length


) const;


Returns the parameter value of the point on the curve at the given algebraic arc length from that defined by the datum parameter. The result is not defined for a bounded nonperiodic curve if the datum parameter is outside the parameter range, or if the length is outside the range bounded by the values for the ends of the parameter range.






public: virtual curve* intcurve::make_copy () const;


Virtual function to copy a curve without knowing what its type is.






public: virtual curve_evaldata*


intcurve::make_evaldata () const;


Construct a data object to retain evaluation information across calls to evaluate_iter. 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.






public: void intcurve::make_single_ref ();


Ensure that the reference supplied points to a singly-used record. Take no action if it is already single, otherwise copy everything.






public: virtual curve& intcurve::negate ();


Negates an intcurve in place. This is a curve virtual function, which is why it returns a curve& instead of an intcurve&.






public: virtual curve& intcurve::operator*= (


SPAtransf const& // transformation


);


Transforms a curve in place. This is complicated by the effort to maintain sharing when several intcurves sharing the same int_cur are transformed successively with the same transformation. A list of transformed versions of each int_cur is maintained, and this method searches for a match before making a new one.






public: intcurve intcurve::operator- () const;


Negates the curve.






public: intcurve& intcurve::operator= (


intcurve const& // intcurve


);


Assignment operator, which copies only the intcurve record and adjusts the use counts of the underlying information.






public: virtual logical intcurve::operator== (


curve const& // intcurve


) const;


Tests two curves for equality. This method does not guarantee to say "equal" for effectively-equal curves, but it is guaranteed to say "not equal" if they are indeed not equal. Use the result for optimization, but not where it really matters. The default always says "not equal."






public: virtual double intcurve::param (


SPAposition const&,

// position


SPAparameter const&

// parameter



= * (SPAparameter*) NULL_REF


) const;


Returns the parameter value for a given point.






public: virtual double


intcurve::param_period () const;


Returns the period of a periodic curve; otherwise, it returns 0 if the curve is not periodic.






public: virtual SPAinterval intcurve::param_range (


SPAbox const& // bounding box



= * (SPAbox* ) NULL_REF


) const;


Returns the range of parameter values.






public: virtual pcurve* intcurve::pcur (


int
// index


) const;


Returns the parametric curves with respect to the surfaces defining this intcurve. int may be 1 or 2, representing the two surfaces in order, or -1 or -2 meaning the negation of those pcurves.






public: bs2_curve intcurve::pcur1 (


logical force // force surface return



= FALSE


) const;


Returns a curve in parameter space of surface returned by surf1 or surf2 respectively, if the surface is parametric. Returns NULL if the surface (as returned by the functions above) is NULL or not parametric.






public: bs2_curve intcurve::pcur2 (


logical force // force surface return



= FALSE


) const;


Returns a curve in parameter space of surface returned by surf1 or surf2 respectively, if the surface is parametric. Returns NULL if the surface (as returned by the functions above) is NULL or not parametric.






public: virtual logical intcurve::pcur_present (


int
// nth parameter-space




// curve


) const;


Returns TRUE if the nth parameter-space curve is defined (i.e., pcur returns a non-NULL pcurve pointer); otherwise, it returns FALSE.






public: virtual logical intcurve::periodic () const;


Indicates if the curve is periodic. A periodic curve joins itself smoothly with matching derivatives at the ends of its principal parameter range so that edges may span the seam.






public: virtual SPAvector intcurve::point_curvature (


SPAposition const&,

// point


SPAparameter const&

// param guess



= * (SPAparameter*) NULL_REF


) const;


Finds the curvature at a point on the intcurve.






public: virtual SPAunit_vector


intcurve::point_direction (


SPAposition const&,

// point


SPAparameter const&

// param guess



= * (SPAparameter*) NULL_REF


) const;


Finds the tangent direction to the intcurve at a given point.






public: virtual void intcurve::point_perp (


SPAposition const&,

// position


SPAposition&,

// foot


SPAunit_vector&,

// tangent


SPAvector&,

// curvature


SPAparameter const&

// guess value



= * (SPAparameter* ) NULL_REF,


SPAparameter&

// actual value



= * (SPAparameter* ) NULL_REF,


logical f_weak

//



= FALSE


) const;


Finds the foot of the perpendicular from the given point to the curve and the curve tangent direction and curvature at that point and its parameter value. If an input parameter value is supplied as the guess value, the perpendicular found is the one nearest to the supplied parameter position; otherwise, it is the one at which the curve is nearest to the given point. Any of the return value arguments may be NULL reference, in which case it is simply ignored.






public: void intcurve::point_perp (


SPAposition const& pos,

// position


SPAposition& foot,

// foot


SPAparameter const& guess
// guess value



= * (SPAparameter*) NULL_REF,


SPAparameter& actual

// actual value



= * (SPAparameter*) NULL_REF,


logical f_weak

//



= FALSE


) const;


Finds the foot of the perpendicular from the given point to the curve and its parameter value. If an input parameter value is supplied as the guess value, the perpendicular found is the one nearest to the supplied parameter 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 simply ignored.






public: void intcurve::point_perp (


SPAposition const& pos,

// position


SPAposition& foot,

// foot


SPAunit_vector& foot_dt,

// normal


SPAparameter const& guess
// guess value



= * (SPAparameter* ) NULL_REF,


SPAparameter& actual

// actual value



= * (SPAparameter* ) NULL_REF,


logical f_weak

//



= FALSE


) const;


Finds the foot of the perpendicular from the given point to the curve and the tangent direction to the curve at that point and its parameter value. If an input parameter value is supplied as the guess value, the perpendicular found is the one nearest to the supplied parameter position; otherwise, it is the one at which the curve is nearest to the given point. Any of the return value arguments may be NULL reference, in which case it is simply ignored.






public: void intcurve::reparam (


double, // start point


double // end point


);


Reparameterizes the splines to start and end at the given values, which are in increasing order.






public: void intcurve::restore_data ();


Restores the data from a save file. The restore operation switches on a table defined by static instances of the restore_cu_def class. 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 surface is to be expected and a surface of that type is on hand to be filled in.


read_logical Curve direction either "forward" or "reversed".

if (restore_version_number < INTCURVE_VERSION)

// Restore as a surface-surface intersection object. The

// restore function for int_int_cur handles the possibility

// that it is in fact exact or a surf_int_cur.

subtype_object * dispatch_restore_subtype



Called with "cur" and "surfintcur". Restore just the data associated with that type of curve. In earlier versions, there was only one type of int_cur, which covered what is now "exact", "surf", and "int". There was no ID.

else

// Switch to the right restore routine, using the standard

// system mechanism. Note that the argument is to enable

// the reader to distinguish old-style types where "exact"

// was both an int_cur and a spl_sur. They are now "exactcur"

// and "exactsur".

subtype_object * dispatch_restore_subtype Called with "cur"

curve::restore_data
Restore the underlying curve. Generic curve data.






public: logical intcurve::reversed () const;


Returns TRUE if the intcurve is reversed.






public: SPAinterval intcurve::safe_range () const;


Returns the safe range or an empty interval if there is no int_cur.






public: virtual void intcurve::save () const;


Saves the curve type or id, then calls save_data.






public: void intcurve::save_data () const;


Saves the intcurve data to a save file.






public: void intcurve::set_bs_hull_angles_ok (


int pcu_no, // enclosure


int hull_angles_ok // unknown, false,




// or true


);


Sets the property in the underlying int_cur, of the bs2_curve hull not turning too sharply. The first argument should be 1 or 2 to indicate the bs2_curve which the enclosure is being set for, and the second integer argument should be -1, 0 or 1, to indicate that the property is unknown, FALSE or TRUE.






public: void intcurve::set_bs_hull_self_intersects (


int pcu_no, // enclosure


int hull_self_ints // unknown, false,




// or true


);


Sets the property in the underlying int_cur, of the bs2_curve hull self-intersecting (or not). The first argument should be 1 or 2, to indicate the bs2_curve which the enclosure is being set for, and the second integer argument should be -1, 0 or 1, to indicate that the property is unknown, FALSE or TRUE.






public: void intcurve::set_bs_knots_on_curve (


int pcu_no, // enclosure


int knots_on_cu // unknown, false,




// or true


);


Sets the property in the underlying int_cur, of the bs2_curve of whether the knots lie on the intcurve. The first argument should be 1 or 2, to indicate the bs2_curve which the enclosure is being set for, and the second integer argument should be -1, 0 or 1, to indicate that the property is unknown, FALSE or TRUE.






public: void intcurve::set_cur (


bs3_curve, // bs3 curve data


double tol // tolerance



= -1.0


);


Replaces the underlying bs3_curve approximation. If the supplied tolerance is negative, then it will be left unchanged.






public: void intcurve::set_hull_enclosure (


int pcu_no, // enclosure


int encl // value


);


Sets the curve enclosure in the underlying int_cur. The first argument should be 1 or 2, to indicate the bs2_curve which the enclosure is being set for, and the second integer argument should be -1, 0 or 1, to give the value for the hull enclosure.






public: void intcurve::set_periodic ();


Marks an intcurve as periodic. This is used after splitting a periodic intcurve to restore the periodic status that the split changed to closed.






public: virtual curve* intcurve::split (


double,

// param value


SPAposition const&

// exact position



= * (SPAposition* ) NULL_REF


);


Divides an intcurve into two pieces at a parameter value. This method creates a new intcurve on the heap, but either one of the intcurves may have a NULL actual curve. The supplied curve is modified to be the latter section, and the initial section is returned as a value.






public: curve* intcurve::subset (


SPAinterval const& // interval


) const;


Constructs a new curve, which is a copy of the portion of the given one within the specified parameter bounds.






public: surface const& intcurve::surf1 (


logical force // force surface to



= FALSE // be returned


) const;


Returns the first surface supporting the curve. By default, surfaces are only returned if the true curve lies on the surface. Surfaces defining the curve but distant from it are not returned. To force the surface to be returned regardless, the logical flag should be set to TRUE.






public: surface const& intcurve::surf2 (


logical force // force surface to



= FALSE // be returned


) const;


Returns the second surface supporting the curve. By default, surfaces are only returned if the true curve lies on the surface. Surfaces defining the curve but distant from it are not returned. To force the surface to be returned regardless, the logical flag should be set to TRUE.






public: curve_tancone intcurve::tangent_cone (


SPAinterval const& range, // interval


logical approx_OK,
// approx results OK?


SPAtransf const& t
// transformation



= * (SPAtransf* ) NULL_REF


) const;


Returns a cone bounding the tangent direction of a curve. The cone has its apex at the origin and a given axis direction and (positive) half-angle. If approx_OK 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 it may not cross from inside to outside. Flags in the returned object indicate whether the cone is in fact the best available, and if this result is inside or outside the best cone.






public: virtual logical intcurve::test_point_tol (


SPAposition const&,

// point


double

// tolerance



= 0,


SPAparameter const&

// start point



= * (SPAparameter* ) NULL_REF,


SPAparameter&

// end point



= * (SPAparameter* ) NULL_REF


) const;


Tests a point-on-curve to a given tolerance. Only true points are near to the end points.






public: virtual int intcurve::type () const;


Returns the type of intcurve.






public: virtual char const*


intcurve::type_name () const;


Returns the string "intcurve".






public: virtual logical intcurve::undef () const;


Indicates if the curve is defined or undefined.

Internal Use: full_size




Related Fncs: restore_intcurve, restore_int_int_cur






friend: intcurve operator* (


intcurve const&, // intcurve


SPAtransf const& // transform


);


Returns a copy of the transformed curve.
PDF/KERN/32CLF.PDF
HTM/DATA/KERN/KERN/32CLF/0013.HTM