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.
|