|
Purpose:
|
Base class for all
ACIS surface types that defines the basic virtual functions that are supplied for all specific surface classes.
|
|
|
Derivation:
|
surface : ACIS_OBJECT : -
|
|
|
Filename:
|
kern/kernel/kerngeom/surface/surdef.hxx
|
|
|
Description:
|
The surface class is the base class that all
ACIS surface types (plane, cone, sphere, torus, and spline) are derived. The surface class defines the basic virtual functions that are supplied for all specific surface classes. Some of these functions are pure; i.e., the derived classes must define their own version; others have default definitions that can be used by the derived classes.
|
|
|
All
ACIS surfaces have a parameterization scheme defined for them; however, the analytic surfaces (plane, cone, sphere, and torus) are not considered parametric surfaces. The only true parametric surface is the spline surface.
|
|
|
The parameterization of any
ACIS surface maps a rectangle within a 2D vector space (u,v-parameter space) into a 3D real vector space
(xyz object space). A surface is closed in u (or v) if the opposite sides of the rectangle map into identical curves in object space. If the derivatives also match at these boundaries, the surface is periodic in that parameter. If one side of this rectangle maps into a single point in object space, this point is a parametric singularity. If the surface normal is not continuous at this point, the point is a surface singularity.
|
|
|
The parameterization can be either right-handed; i.e., the surface normal is the cross product of u and
v, or left-handed; i.e., the normal is the cross product of
v and
u.
|
|
|
References:
|
by KERN
|
blend_support, exp_par_cur, int_cur, law_par_cur, off_spl_sur, skin_spl_sur, stripc, surf_surf_int, surface_law_data, taper_spl_sur
|
|
BASE
|
SPApar_box
|
|
|
Data:
|
protected SPApar_box subset_range;
|
|
Any surface may be subset to a given parameter range.
|
|
|
Constructor:
|
public: surface::surface
();
|
|
|
C++ allocation constructor requests memory for this object but does not populate it.
|
|
|
|
|
|
Destructor:
|
public: virtual surface::~surface
();
|
|
|
C++ destructor, deleting a
surface.
|
|
|
|
|
Methods:
|
public: virtual int surface::accurate_derivs
(
|
|
|
SPApar_box const&
|
|
// parameter box
|
|
|
|
= * (SPApar_box* ) 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 surface. If there is no limit to the number of accurate derivatives, this method returns the
ALL_SURFACE_DERIVATIVES value.
|
|
|
|
|
|
|
public: virtual const double*
|
|
|
surface::all_discontinuities_u (
|
|
|
int& n_discont,
|
// number of disc.
|
|
|
int order
|
// max order
|
|
|
);
|
|
|
Returns (in a read-only array) the number and parameter values of discontinuities of the surface up to the given order (maximum three).
|
|
|
|
|
|
|
public: virtual const double*
|
|
|
surface::all_discontinuities_v (
|
|
|
int& n_discont,
|
// # of disc.
|
|
|
int order
|
// max order
|
|
|
);
|
|
|
Returns (in a read-only array) the number and parameter values of discontinuities of the surface up to the given order (maximum three).
|
|
|
|
|
|
|
public: virtual SPAbox surface::bound
(
|
|
|
SPAbox const&,
|
|
// box
|
|
|
SPAtransf const&
|
|
// transformation
|
|
|
|
= * (SPAtransf* ) NULL_REF
|
|
|
) const;
|
|
|
Returns a box around a surface bounded in object space. This box need not be the smallest box that contains the specified portion of the surface, but it must balance the tightness of the bound against the cost of the evaluation.
|
|
|
|
|
|
|
public: virtual SPAbox surface::bound
(
|
|
|
SPApar_box const&
|
|
|
// parameter box
|
|
|
|
= * (SPApar_box* ) NULL_REF,
|
|
|
SPAtransf const&
|
|
|
// transformation
|
|
|
|
= * (SPAtransf* ) NULL_REF
|
|
|
) const;
|
|
|
Returns a box around a surface bounded in parameter space. This box need not be the smallest box that contains the specified portion of the surface, but it must balance the tightness of the bound against the cost of the evaluation.
|
|
|
|
|
|
|
public: virtual void surface::change_event
();
|
|
|
Notifies the derived type that the surface has been changed (e.g., the
subset_range has changed) so that it can update itself. The default version of the function does nothing.
|
|
|
|
|
|
|
public: virtual check_status_list* surface::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 surface, 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 surface 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 surface::closed_u
() const;
|
|
|
Determines whether the surface is closed, smoothly or not, in the
u-parameter direction. A closed method always returns
TRUE if the corresponding periodic method returns
TRUE.
|
|
|
|
|
|
|
public: virtual logical surface::closed_v
() const;
|
|
|
Determines whether the surface is closed, smoothly or not, in the
v-parameter direction. A closed method always returns
TRUE if the corresponding periodic method returns
TRUE.
|
|
|
|
|
|
|
public: surface* surface::copy_surf
() const;
|
|
|
Makes a copy of the given surface. This method calls
make_copy.
|
|
|
|
|
|
|
public: virtual void surface::debug
(
|
|
|
char const*,
|
// title line
|
|
|
FILE*
|
// file name
|
|
|
|
= debug_file_ptr
|
|
|
) const = 0;
|
|
|
Prints out a title line and details about the surface to the debug file or to the specified file.
|
|
|
|
|
|
|
public: virtual surface* surface::deep_copy
(
|
|
|
pointer_map* pm
|
// list of items within
|
|
|
|
= NULL
|
// the entity that are
|
|
|
|
|
// already deep copied
|
|
|
) const = 0;
|
|
|
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.
|
|
|
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.
|
|
|
|
|
|
|
public: virtual const double*
|
|
|
surface::discontinuities_u (
|
|
|
int& n_discont,
|
// number of discont.
|
|
|
int order
|
// curve order
|
|
|
) const;
|
|
|
Returns in a read-only array the number and parameter values of discontinuities of the surface, of the given order (maximum three).
|
|
|
|
|
|
|
public: virtual const double*
|
|
|
surface::discontinuities_v (
|
|
|
int& n_discont,
|
// number of discont.
|
|
|
int order
|
// curve order
|
|
|
) const;
|
|
|
Returns in a read-only array the number and parameter values of discontinuities of the surface, of the given order (maximum three).
|
|
|
|
|
|
|
public: virtual int surface::discontinuous_at_u
(
|
|
|
double u
|
// parameter
|
|
|
) const;
|
|
|
Returns whether a particular parameter value is a discontinuity.
|
|
|
|
|
|
|
public: virtual int surface::discontinuous_at_v
(
|
|
|
double v
|
// parameter
|
|
|
) const;
|
|
|
Returns whether a particular parameter value is a discontinuity.
|
|
|
|
|
|
|
public: virtual void surface::eval
(
|
|
|
SPApar_pos const&,
|
// parameter
|
|
|
SPAposition&,
|
// point position
|
|
|
SPAvector*
|
// first derivatives
|
|
|
|
= NULL,
|
// array of length 2 in
|
|
|
|
|
// the order Xu, Xv
|
|
|
SPAvector*
|
// second derivatives
|
|
|
|
= NULL
|
// array of length 3 in
|
|
|
|
|
// the order Xuu, Xuv,
|
|
|
|
|
// Xvv
|
|
|
) const;
|
|
|
Finds the point on a parametric surface with given parameter values, and optionally the first and second derivatives as well.
|
|
|
|
|
|
|
public: virtual int surface::evaluate
(
|
|
|
SPApar_pos const&,
|
|
|
// pt on surface
|
|
|
SPAposition&,
|
|
|
// at given param
|
|
|
|
|
|
|
// values
|
|
|
SPAvector**
|
|
|
// array of ptrs
|
|
|
|
= NULL,
|
|
|
// to array of
|
|
|
|
|
|
|
// vectors
|
|
|
int
|
|
|
|
// number of
|
|
|
|
= 0,
|
|
|
// derivatives
|
|
|
evaluate_surface_quadrant
|
|
// eval. location
|
|
|
|
= evaluate_surface_unknown
|
|
|
) const;
|
|
|
Calculates derivatives, of any order up to the number requested, and stores them in vectors provided by the user. This method returns the number of derivatives it was able to calculate; usually, this equals the requested number. A certain number are evaluated directly and 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 pointers may be
NULL in which case the corresponding derivatives will not be returned. Otherwise they must point to arrays long enough for all the derivatives of that order.
|
|
|
|
|
|
|
public: virtual int surface::evaluate_iter
(
|
|
|
SPApar_pos const&,
|
|
|
// pt on surface
|
|
|
surface_evaldata*,
|
|
|
// data supplying
|
|
|
|
|
|
|
// initial
|
|
|
|
|
|
|
// values, and
|
|
|
|
|
|
|
// set to reflect
|
|
|
|
|
|
|
// the results of
|
|
|
|
|
|
|
// this
|
|
|
|
|
|
|
// evaluation
|
|
|
SPAposition&,
|
|
|
// at given param
|
|
|
|
|
|
|
// values
|
|
|
SPAvector**
|
|
|
// array of ptrs
|
|
|
|
= NULL,
|
|
|
// to array of
|
|
|
|
|
|
|
// vectors
|
|
|
int
|
|
|
|
// number of
|
|
|
|
= 0,
|
|
|
// derivatives
|
|
|
evaluate_surface_quadrant
|
|
// eval. location
|
|
|
|
= evaluate_surface_unknown
|
|
|
) 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 double surface::eval_cross
(
|
|
|
SPApar_pos const&,
|
// given parameter values
|
|
|
SPAunit_vector const&
|
// given normal
|
|
|
) const;
|
|
|
Finds the curvature of a cross-section curve of the parametric surface at the point with the given parameter values. The cross-section curve is given by the intersection of the surface with a plane passing through the point and with the given normal.
|
|
|
|
|
|
|
public: virtual SPAunit_vector surface::eval_normal
(
|
|
|
SPApar_pos const&
|
// parameter values
|
|
|
) const;
|
|
|
Finds the normal to a parametric surface at a point with the given parameter values.
|
|
|
|
|
|
|
public: virtual SPAunit_vector surface::eval_outdir
(
|
|
|
SPApar_pos const&
|
// parameter values
|
|
|
) const;
|
|
|
Finds the outward direction from the surface at a point with the given parameter values. This method usually returns the normal, but if the nearest point is a singularity (like the apex of a cone), this method still returns an outward direction.
|
|
|
|
|
|
|
public: virtual SPAposition surface::eval_position
(
|
|
|
SPApar_pos const&
|
// parameter values
|
|
|
) const;
|
|
|
Finds the point on a parametric surface with the given parameter values.
|
|
|
|
|
|
|
public: surf_princurv surface::eval_prin_curv
(
|
|
|
SPApar_pos const&
|
// parameter values
|
|
|
) const;
|
|
|
Finds the principle aces of curvature of the surface at a point with the given parameter values.
|
|
|
|
|
|
|
public: virtual void surface::eval_prin_curv
(
|
|
|
SPApar_pos const&,
|
// parameter values
|
|
|
SPAunit_vector&,
|
// first axis direction
|
|
|
double&,
|
// 1st dir. curvature
|
|
|
SPAunit_vector&,
|
// second axis direction
|
|
|
double&
|
// 2nd direction crvtr.
|
|
|
) const;
|
|
|
Finds the principle aces of curvature of the surface at a point with the given parameter values and the curvatures in those directions.
|
|
|
|
|
|
|
protected: int
|
|
|
surface::finite_difference_derivatives (
|
|
|
SPApar_pos const&,
|
|
// parameter
|
|
|
SPAposition&,
|
|
// point on surface
|
|
|
|
|
|
// at given parameter
|
|
|
SPAvector**,
|
|
// array of ptrs to
|
|
|
|
|
|
// array of vectors
|
|
|
int,
|
|
// # derivatives
|
|
|
int,
|
|
// # derivatives
|
|
|
|
|
|
// evaluated
|
|
|
double,
|
|
// finite diff.
|
|
|
|
|
|
// step to
|
|
|
|
|
|
// use in u param.
|
|
|
double,
|
|
// finite diff.
|
|
|
|
|
|
// step to
|
|
|
|
|
|
// use in v param.
|
|
|
evaluate_surface_quadrant
|
// evaluation
|
|
|
|
|
|
// quadrant
|
|
|
) const;
|
|
|
Evaluates higher derivatives than are available accurately in
evaluate by finite differencing. This method is available to any derived class for use in its own
evaluate. It calls back the
evaluate function for adjacent points to evaluate a number of derivatives, so
evaluate must ensure that this does not cause a further call to this method.
|
|
|
|
|
|
|
public: virtual const discontinuity_info&
|
|
|
surface::get_disc_info_u() const;
|
|
|
Return read-only access to
discontinuity_info objects, if they exist. The default version of the functions return null.
|
|
|
|
|
|
|
public: virtual const discontinuity_info&
|
|
|
surface::get_disc_info_v() const;
|
|
|
Return read-only access to
discontinuity_info objects, if they exist. The default version of the functions return null.
|
|
|
|
|
|
|
public: virtual curve*
|
|
|
surface::get_path () const;
|
|
|
Returns the path curve.
|
|
|
|
|
|
|
public: virtual sweep_path_type
|
|
|
surface::get_path_type () const;
|
|
|
Returns the sweep path type for this
surface.
|
|
|
|
|
|
|
public: virtual curve* surface::get_profile
(
|
|
|
double
|
// parameter
|
|
|
) const;
|
|
|
Returns the sweep profile on the
surface.
|
|
|
|
|
|
|
public: virtual law*
|
|
|
surface::get_rail () const;
|
|
|
Returns the rail law for the swept
surface.
|
|
|
|
|
|
|
public: virtual logical
|
|
|
surface::left_handed_uv () const;
|
|
|
Indicates whether the parameter coordinate system of the surface is right-handed or left-handed. With a right-handed system, the output normal at any point is given by the cross product of the increasing
u-direction with the increasing
v-direction, in that order. With a left-handed system, the outward normal is in the opposite direction from this cross product.
|
|
|
|
|
|
|
public: void surface::limit
(
|
|
|
SPApar_box const&
|
// parameter box
|
|
|
);
|
|
|
Limits a subset to the given parameter box.
|
|
|
|
|
|
|
public: void surface::limit_u
(
|
|
|
SPAinterval const&
|
// u interval
|
|
|
);
|
|
|
Limits a subset to the given
u interval.
|
|
|
|
|
|
|
public: void surface::limit_v
(
|
|
|
SPAinterval const&
|
// v interval
|
|
|
);
|
|
|
Limits a subset to the given
v interval.
|
|
|
|
|
|
|
public: virtual surface*
|
|
|
surface::make_copy () const = 0;
|
|
|
Makes a copy of this
surface on the heap, and returns a pointer to it.
|
|
|
|
|
|
|
public: virtual surface_evaldata*
|
|
|
surface::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: virtual surface& surface::negate
() = 0;
|
|
|
Reverses the sense of a surface.
|
|
|
|
|
|
|
public: virtual surf_normcone surface::normal_cone
(
|
|
|
SPApar_box const&,
|
|
// parameter box
|
|
|
logical
|
|
// approx results OK?
|
|
|
|
= FALSE,
|
|
|
SPAtransf const&
|
|
// transformation
|
|
|
|
= * (SPAtransf* ) NULL_REF
|
|
|
) const;
|
|
|
Returns a cone bounding the normal direction of the surface. The cone has its apex at the origin, and it has a given axis direction and positive half-angle. If logical is
TRUE, then this method finds a quick approximation. 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 turned object indicate whether the cone is the best available, and if this result is inside or outside the best cone.
|
|
|
|
|
|
|
public: logical surface::operator!=
(
|
|
|
surface const& rhs
|
// surface
|
|
|
) const;
|
|
|
Tests two surfaces for equality. This method does not guarantee equality for effectively-equal surfaces, but it is guaranteed to determine inequality if the two surfaces are not equal. Use this result for optimization.
|
|
|
|
|
|
|
public: virtual surface& surface::operator*=
(
|
|
|
SPAtransf const&
|
// transformation
|
|
|
) = 0;
|
|
|
Transforms the surface by the given transformation.
|
|
|
|
|
|
|
public: virtual logical surface::operator==
(
|
|
|
surface const&
|
// surface
|
|
|
) const;
|
|
|
Tests two surfaces for inequality. This method does not guarantee equality for effectively-equal surfaces, but it is guaranteed to determine inequality if the two surfaces are not equal. Use this result for optimization.
|
|
|
|
|
|
|
public: virtual SPApar_pos surface::param
(
|
|
|
SPAposition const&,
|
|
// given point
|
|
|
SPApar_pos const&
|
|
// parameter guess
|
|
|
|
= * (SPApar_pos* ) NULL_REF
|
|
|
) const;
|
|
|
Finds the parameter values of a point on a surface given an optional first guess.
|
|
|
|
|
|
|
public: virtual logical surface::parametric
() const;
|
|
|
Returns
TRUE if the surface is a parametric surface; otherwise, it returns
FALSE. This reflects the fundamental nature of the surface and it is used by the
ACIS kernel to avoid using parameters when they are not necessary. For a surface, the
ACIS kernel does not use any of the parameter-based functions, though they are implemented for the sake of those components and applications that prefer parameter-based representations of every surface.
|
|
|
Whether to declare a surface parametric or not depends on the implementation of the point-based evaluations. If the availability of a good approximation to the point's parameter values makes no significant improvement to the speed of these functions, then the surface is nonparametric; otherwise, it is parametric. A plane is an obvious nonparametric surface; a B-spline is a parametric surface.
|
|
|
|
|
|
|
public: SPApar_dir surface::param_dir
(
|
|
|
SPAunit_vector const&,
|
// object-space direction
|
|
|
SPApar_pos const&
|
// parameter value
|
|
|
) const;
|
|
|
Finds the direction in parameter space of a given object-space direction on a surface at a given parameter value.
|
|
|
|
|
|
|
public: virtual double
|
|
|
surface::param_period_u () const;
|
|
|
Returns the period of a periodic parametric surface. If the surface is not parametric or is not periodic in the
u-direction, this method returns 0.
|
|
|
|
|
|
|
public: virtual double
|
|
|
surface::param_period_v () const;
|
|
|
Returns the period of a periodic parametric surface. If the surface is not parametric or is not periodic in the
v-direction, this method returns 0.
|
|
|
|
|
|
|
public: virtual SPApar_box surface::param_range
(
|
|
|
SPAbox const&
|
// box
|
|
|
|
= * (SPAbox* ) NULL_REF
|
|
|
) const;
|
|
|
Returns the principle parameter range of a surface. A periodic surface is defined for all parameter values in the periodic direction by reducing the given parameter modulo the period into this principle range. For a surface that is open or nonperiodic in the chosen direction, the surface evaluation functions are defined only for the parameter values in the returned range.
|
|
|
If a box is provided, the parameter range returned may be restricted to a portion of the surface that is guaranteed to contain all portions of the surface that lie within the region of interest. If none is provided and the parameter range in some direction is unbounded, then this method returns an empty interval.
|
|
|
|
|
|
|
public: virtual SPAinterval surface::param_range_u
(
|
|
|
SPAbox const&
|
// box
|
|
|
|
= * (SPAbox* ) NULL_REF
|
|
|
) const;
|
|
|
Returns the principle parameter range of a surface in the
u-parameter direction. A periodic surface is defined for all parameter values in the periodic direction by reducing the given parameter modulo the period into this principle range. For a surface that is open or nonperiodic in the chosen direction, the surface evaluation functions are defined only for the parameter values in the returned range.
|
|
|
If a box is provided, the parameter range returned may be restricted to a portion of the surface that is guaranteed to contain all portions of the surface that lie within the region of interest. If none is provided and the parameter range in some direction is unbounded, then this method returns an empty interval.
|
|
|
|
|
|
|
public: virtual SPAinterval surface::param_range_v
(
|
|
|
SPAbox const&
|
// box
|
|
|
|
= * (SPAbox* ) NULL_REF
|
|
|
) const;
|
|
|
Returns the principle parameter range of a surface in the
v-parameter direction. A periodic surface is defined for all parameter values in the periodic direction by reducing the given parameter modulo the period into this principle range. For a surface that is open or nonperiodic in the chosen direction, the surface evaluation functions are defined only for the parameter values in the returned range.
|
|
|
If a box is provided, the parameter range returned may be restricted to a portion of the surface that is guaranteed to contain all portions of the surface that lie within the region of interest. If none is provided and the parameter range in some direction is unbounded, then this method returns an empty interval.
|
|
|
|
|
|
|
public: virtual SPApar_vec surface::param_unitvec
(
|
|
|
SPAunit_vector const&,
|
// object space direction
|
|
|
SPApar_pos const&
|
// parameter position
|
|
|
) const;
|
|
|
Finds the rate of change in the surface parameter corresponding to a unit velocity in a given object-space direction at a given position in parameter space.
|
|
|
|
|
|
|
public: virtual logical surface::periodic_u
() const;
|
|
|
Determines if the surface is periodic in the
u-parameter direction (i.e., it is smoothly closed so that faces can run over the seam).
|
|
|
|
|
|
|
public: virtual logical surface::periodic_v
() const;
|
|
|
Determines if the surface is periodic in the
v-parameter direction (i.e., it is smoothly closed so that faces can run over the seam).
|
|
|
|
|
|
|
public: virtual logical surface::planar
(
|
|
|
SPAposition&,
|
// point on the surface
|
|
|
SPAunit_vector&
|
// axis direction
|
|
|
) const;
|
|
|
Reports if a surface is planar.
|
|
|
|
|
|
|
public: virtual double surface::point_cross
(
|
|
|
SPAposition const&,
|
|
// point
|
|
|
SPAunit_vector const&,
|
|
// given normal
|
|
|
SPApar_pos const&
|
|
// parameter guess
|
|
|
|
= * (SPApar_pos* ) NULL_REF
|
|
|
) const;
|
|
|
Finds the curvature of a cross-section curve of the surface at the given point. The cross-section curve is given by the intersection of the surface with a plane passing through the given point and with the given normal.
|
|
|
|
|
|
|
public: virtual SPAunit_vector surface::point_normal
(
|
|
|
SPAposition const&,
|
|
// given point
|
|
|
SPApar_pos const&
|
|
// parameter guess
|
|
|
|
= * (SPApar_pos* ) NULL_REF
|
|
|
) const = 0;
|
|
|
Finds the normal to the surface at a point on the surface nearest to the given point.
|
|
|
|
|
|
|
public: virtual SPAunit_vector surface::point_outdir
(
|
|
|
SPAposition const&,
|
|
// given point
|
|
|
SPApar_pos const&
|
|
// parameter guess
|
|
|
|
= * (SPApar_pos* ) NULL_REF
|
|
|
) const;
|
|
|
Finds the outward direction from the surface at a point with the given parameter values. This method usually is the normal, but if the nearest point is a singularity (like the apex of a cone), this method still returns an outward direction. The base class definition returns
point_normal, which is used by default on by simple surfaces.
|
|
|
|
|
|
|
public: virtual void surface::point_perp
(
|
|
|
SPAposition const&,
|
|
|
// given point
|
|
|
SPAposition&,
|
|
|
// foot
|
|
|
SPAunit_vector&,
|
|
|
// normal to
|
|
|
|
|
|
|
// surface
|
|
|
surf_princurv&,
|
|
|
// principle
|
|
|
|
|
|
|
// curvature
|
|
|
SPApar_pos const&
|
|
|
// param guess
|
|
|
|
= * (SPApar_pos* ) NULL_REF,
|
|
|
SPApar_pos&
|
|
|
// actual param
|
|
|
|
= * (SPApar_pos* ) NULL_REF,
|
|
|
logical f_weak
|
|
|
// weak flag
|
|
|
|
= FALSE
|
|
|
// internal use
|
|
|
) const = 0;
|
|
|
Finds the point on the surface nearest to the given point and optionally, the normal to and the principle curvatures of the surface at that point. If the surface is parametric, this method also returns the parameter values at the found point.
|
|
|
|
|
|
|
public: void surface::point_perp
(
|
|
|
SPAposition const& pos,
|
|
|
// given point
|
|
|
SPAposition& foot,
|
|
|
// foot
|
|
|
SPApar_pos const&
|
|
|
// param position
|
|
|
|
param_guess
|
|
|
// param guess
|
|
|
|
= * (SPApar_pos* ) NULL_REF,
|
|
|
SPApar_pos& param_actual
|
|
|
// parameter
|
|
|
|
= * (SPApar_pos* ) NULL_REF,
|
|
|
logical f_weak
|
|
|
// weak flag
|
|
|
|
= FALSE
|
|
|
// internal use
|
|
|
) const;
|
|
|
Finds the point on the surface nearest to the given point and optionally, the normal to and the principle curvatures of the surface at that point. If the surface is parametric, this method also returns the parameter values at the found point.
|
|
|
|
|
|
|
public: void surface::point_perp
(
|
|
|
SPAposition const& pos,
|
|
|
// given point
|
|
|
SPAposition& foot,
|
|
|
// foot
|
|
|
SPAunit_vector& norm,
|
|
|
// normal to
|
|
|
|
|
|
|
// surface
|
|
|
SPApar_pos const&
|
|
|
// param position
|
|
|
|
param_guess
|
|
|
// param guess
|
|
|
|
= * (SPApar_pos* ) NULL_REF,
|
|
|
SPApar_pos& param_actual
|
|
|
// actual param
|
|
|
|
= * (SPApar_pos* ) NULL_REF,
|
|
|
logical f_weak
|
|
|
// weak flag
|
|
|
|
= FALSE
|
|
|
// internal use
|
|
|
) const;
|
|
|
Finds the point on the surface nearest to the given point and optionally, the normal to and the principle curvatures of the surface at that point. If the surface is parametric, this method also returns the parameter values at the found point.
|
|
|
|
|
|
|
public: surf_princurv surface::point_prin_curv
(
|
|
|
SPAposition const&,
|
|
// point
|
|
|
SPApar_pos const&
|
|
// parameter guess
|
|
|
|
= * (SPApar_pos* ) NULL_REF
|
|
|
) const;
|
|
|
Finds the principle axes of curvature of the surface at a given point and the curvatures in those directions in a structure defined for the purpose.
|
|
|
|
|
|
|
public: virtual void surface::point_prin_curv
(
|
|
|
SPAposition const&,
|
|
// position
|
|
|
SPAunit_vector&,
|
|
// 1st axis direction
|
|
|
double&,
|
|
// 1st dir. curvature
|
|
|
SPAunit_vector&,
|
|
// 2nd axis direction
|
|
|
double&,
|
|
// 2nd dir. curvature
|
|
|
SPApar_pos const&
|
|
// parameter guess
|
|
|
|
= * (SPApar_pos* ) NULL_REF
|
|
|
) const = 0;
|
|
|
Finds the principle axes of curvature of the surface at a given point and the curvatures in those directions.
|
|
|
|
|
|
|
public: void surface::restore_data
();
|
|
|
Restore the data for a
surface from a save file.
|
|
|
if (restore_version_number >= BNDSUR_VERSION)
|
|
read_interval
|
subset
u interval
|
|
|
read_interval
|
|
subset
v interval
|
|
|
|
|
|
|
public: virtual void surface::save
() const = 0;
|
|
|
Calls the virtual save method for the particular type of surface.
|
|
|
|
|
|
|
public: void surface::save_data
() const;
|
|
|
Save the information for the
surface to a save file.
|
|
|
|
|
|
|
public: void surface::save_surface
() const;
|
|
|
Saves the surface if the surface is of an unknown type or
NULL. It checks for
NULL then calls the
save method.
|
|
|
|
|
|
|
public: virtual logical surface::singular_u
(
|
|
|
double
|
// u-parameter value
|
|
|
) const;
|
|
|
Determines whether the surface parameterization is singular at the specified
u-parameter value. The only singularity recognized is where every value of the nonconstant parameter generates the same object-space point, and these can only occur at the ends of the parameter range.
|
|
|
|
|
|
|
public: virtual logical surface::singular_v
(
|
|
|
double
|
// v-parameter value
|
|
|
) const;
|
|
|
Determines whether the surface parameterization is singular at the specified
v-parameter value. The only singularity recognized is where every value of the nonconstant parameter generates the same object-space point, and these can only occur at the ends of the parameter range.
|
|
|
|
|
|
|
public: virtual int surface::split_at_kinks_u
(
|
|
|
spline**& pieces,
|
// split pieces
|
|
|
double curvature = 0.0
|
// curvature
|
|
|
) const;
|
|
|
Divides a surface into separate pieces which are smooth (and therefore suitable for offsetting or blending). The surface is split if the curvature exceeds the minimum curvature argument. If it is closed after this, it is then split into two. The split pieces are stored in the pieces argument. The function returns the count of split pieces. Only implemented for splines and elliptical cones.
|
|
|
|
|
|
|
public: virtual int surface::split_at_kinks_v
(
|
|
|
spline**& pieces,
|
// split pieces
|
|
|
double curvature = 0.0
|
// curvature
|
|
|
) const;
|
|
|
Divides a surface into separate pieces which are smooth (and therefore suitable for offsetting or blending). The surface is split if the curvature exceeds the minimum curvature argument. If it is closed after this, it is then split into two. The split pieces are stored in the pieces argument. The function returns the count of split pieces. Only implemented for splines and elliptical cones.
|
|
|
|
|
|
|
public: surface* surface::subset
(
|
|
|
SPApar_box const&
|
// parameter box
|
|
|
) const;
|
|
|
Constructs a subset copy within the given parameter box.
|
|
|
|
|
|
|
public: logical surface::subsetted
() const;
|
|
|
Determines whether the surface has a significant subset range.
|
|
|
|
|
|
|
public: logical surface::subsetted_u
() const;
|
|
|
Determines whether the surface has a significant subset range in the
u direction.
|
|
|
|
|
|
|
public: logical surface::subsetted_v
() const;
|
|
|
Determines whether the surface has a significant subset range in the
v direction.
|
|
|
|
|
|
|
public: SPApar_box surface::subset_box
() const;
|
|
|
Returns a subset of the surface.
|
|
|
|
|
|
|
public: surface* surface::subset_u
(
|
|
|
SPAinterval const&
|
// u interval
|
|
|
) const;
|
|
|
Constructs a subset copy within the given
u interval.
|
|
|
|
|
|
|
public: SPAinterval surface::subset_u_interval
() const;
|
|
|
Returns a subset interval.
|
|
|
|
|
|
|
public: surface* surface::subset_v
(
|
|
|
SPAinterval const&
|
// v interval
|
|
|
) const;
|
|
|
Constructs a subset copy within the given
v interval.
|
|
|
|
|
|
|
public: SPAinterval surface::subset_v_interval
() const;
|
|
|
Returns a subset interval.
|
|
|
|
|
|
|
public: logical surface::test_point
(
|
|
|
SPAposition const& pos,
|
|
|
// point
|
|
|
SPApar_pos const& uv_guess
|
|
// param guess
|
|
|
|
= * (SPApar_pos* ) NULL_REF,
|
|
|
SPApar_pos& uv_actual
|
|
|
// actual param
|
|
|
|
= * (SPApar_pos* ) NULL_REF
|
|
|
) const;
|
|
|
Determines if a point lies on the surface to the system precision.
|
|
|
|
|
|
|
public: virtual logical surface::test_point_tol
(
|
|
|
SPAposition const&,
|
|
|
// point
|
|
|
double
|
|
|
// tolerance
|
|
|
|
= 0,
|
|
|
// (defaults to
|
|
|
|
|
|
|
// SPAresabs)
|
|
|
SPApar_pos const&
|
|
|
// param guess
|
|
|
|
= * (SPApar_pos* ) NULL_REF,
|
|
|
SPApar_pos&
|
|
|
// actual param
|
|
|
|
= * (SPApar_pos* ) NULL_REF
|
|
|
) const = 0;
|
|
|
Determines whether a point lies on the surface to the given tolerance.
|
|
|
|
|
|
|
public: virtual int surface::type
() const = 0;
|
|
|
Returns the type of
surface.
|
|
|
|
|
|
|
public: virtual char const*
|
|
|
surface::type_name () const = 0;
|
|
|
Returns the string "surface".
|
|
|
|
|
|
|
public: virtual logical surface::undef
() const;
|
|
|
Determines whether a surface is defined or undefined. A
NULL or generic surface are always undefined; other surfaces depend on their contents.
|
|
|
|
|
|
|
public: logical surface::undefined
() const;
|
|
|
Determines whether a surface is defined or undefined. A
NULL or generic surface are always undefined; other surfaces depend on their contents.
|
|
|
|
|
|
|
public: void surface::unlimit
();
|
|
|
Removes the subsetting from this surface.
|
|
|
|
|
|
|
public: void surface::unlimit_u
();
|
|
|
Removes the subsetting from this surface in the
u direction.
|
|
|
|
|
|
|
public: void surface::unlimit_v
();
|
|
|
Removes the subsetting from this surface in the
v direction.
|
|
|
|
|
|
|
public: surface* surface::unsubset
() const;
|
|
|
Constructs a copy of the unbounded surface underlying this one.
|
|
|
|
|
|
|
public: surface* surface::unsubset_u
() const;
|
|
|
Constructs a copy of the unbounded surface underlying this one in the
u direction
|
|
|
|
|
|
|
public: surface* surface::unsubset_v
() const;
|
|
|
Constructs a copy of the unbounded surface underlying this one in the
v direction.
|
|
|
|
|
|
|
public: virtual curve* surface::u_param_line
(
|
|
|
double
|
// v parameter
|
|
|
) const;
|
|
|
Constructs a parameter line on the surface. A
u-parameter line runs in the direction of increasing
u parameter, at constant
v. The parameterization int he nonconstant direction matches that of the surface, and it has the range obtained by the use of
param_range_u. If the supplied constant parameter value is outside the valid range for the surface, or if it is at a singularity, this method returns
NULL.
|
|
|
The new curve is constructed in free storage, so it is the responsibility of the caller to ensure that it is correctly deleted.
|
|
|
|
|
|
|
public: virtual curve* surface::v_param_line
(
|
|
|
double
|
// u parameter
|
|
|
) const;
|
|
|
Constructs a parameter line on the surface. A
v-parameter line runs in the direction of increasing
v parameter, at constant
u. The parameterization int he nonconstant direction matches that of the surface, and it has the range obtained by the use of
param_range_v. If the supplied constant parameter value is outside the valid range for the surface, or if it is at a singularity, this method returns
NULL.
|
|
|
The new curve is constructed in free storage, so it is the responsibility of the caller to ensure that it is correctly deleted.
|
|
|
Internal Use:
|
full_size
|
|
|
|
|
|
Related Fncs:
|
restore_surface, surf_deriv_to_curv
|