#include <ParamSurfaceInt.h>
Inheritance diagram for Go::ParamSurfaceInt:
Public Member Functions | |
| ParamSurfaceInt (boost::shared_ptr< ParamSurface > surf, ParamGeomInt *parent=0) | |
| Constructor. | |
| virtual | ~ParamSurfaceInt () |
| Destructor. | |
| virtual void | point (Point &pt, const double *tpar) const |
| Evaluate the object in the input parameter. | |
| virtual void | point (std::vector< Point > &pt, const double *tpar, int derivs, const bool *from_right=0, double resolution=1.0e-12) const |
| Evaluate the object in the input parameter, with the specified number of derivatives. | |
| virtual ParamSurfaceInt * | getParamSurfaceInt () |
| Return a pointer to this object. | |
| boost::shared_ptr< ParamSurface > | getParamSurface () |
| Return pointer to the parametric surface defining this object. | |
| boost::shared_ptr< const ParamSurface > | getParamSurface () const |
| Return pointer to the parametric surface defining this object. | |
| boost::shared_ptr< ParamSurface > | getParentParamSurface (RectDomain &domain) |
| Return pointer to a subsurface of the parent surface for this object. | |
| boost::shared_ptr< ParamSurface > | getParentParamSurface () |
| Return pointer to the parent surface for this object. | |
| virtual boost::shared_ptr< ParamSurfaceInt > | makeIntObject (boost::shared_ptr< ParamSurface > surf) |
| Return an intersection object for the input surface, using this object as parent. | |
| virtual boost::shared_ptr< ParamCurveInt > | makeIntCurve (boost::shared_ptr< ParamCurve > crv, ParamGeomInt *parent) |
| Return an intersection object for the input curve, using parameter parent as parent. | |
| virtual int | numParams () const |
| The number of parameters in the object. | |
| boost::shared_ptr< ParamCurve > | getIsoCurve (double param_start, double param_end, double isoval, bool pardir_is_u) const |
| Returns the specified isocurve. | |
| boost::shared_ptr< ParamCurve > | getConstantParameterCurve (int dir, double par) |
| Return a curveOnSurface along the current surface in the given direction and parameter value. | |
| virtual void | getLengthAndWiggle (double *length, double *wiggle) |
| Return an estimate on the size and wiggle of the object. | |
| virtual bool | hasInnerKnots (int pardir) const |
| Return true if the object has any inner knots in the specified parameter direction. | |
| virtual bool | hasCriticalVals (int pardir) const |
| Return true if the object has any critical parameter values in the specified parameter direction. | |
| virtual bool | hasCriticalValsOrKnots (int pardir) const |
| Return true if the object has any critical parameter values or inner knots in the specified parameter direction. | |
| virtual bool | canDivide (int pardir) |
| Return true if we are allowed to divide in the specified parameter direction. | |
| virtual std::vector< double > | getCriticalVals (int pardir) const |
| Return the critical parameter values in the specified direction. | |
| virtual std::vector< double > | getInnerKnotVals (int pardir, bool sort=false) const |
| Return the inner knot values in the specified direction. | |
| virtual std::vector< double > | getCriticalValsAndKnots (int pardir) const |
| Return the critical parameter values and inner knots for object. | |
| virtual int | getMeshSize (int dir) |
| Return the size of the geometric sample mesh in the specified direction. | |
| virtual double | paramFromMesh (int dir, int idx) |
| Return the corresponding mesh parameter. | |
|
virtual std::vector< double >::iterator | getMesh () |
| Return the geometric sample mesh for the parametric function. | |
| virtual double | startParam (int pardir) const |
| Return the start parameter value in the specified direction. | |
| virtual double | endParam (int pardir) const |
| Return the end parameter in the specified direction. | |
| virtual bool | boundaryPoint (const double *par, double eps) const |
| Return true if the specified point lies within eps from the boundary. | |
| std::vector< double > | getMima () const |
| Return the domain of the surface. | |
| virtual bool | inCorner (const double *par, double epspar) const |
| Check if parameter point lies close to a corner of the parameter domain. | |
| virtual void | subdivide (int pardir, double par, std::vector< boost::shared_ptr< ParamGeomInt > > &subdiv_objs, std::vector< boost::shared_ptr< ParamGeomInt > > &bd_objs) |
| Subdivide the object in the specified parameter direction and parameter value. | |
| virtual std::vector< boost::shared_ptr< ParamSurfaceInt > > | subSurfaces (double from_upar, double from_vpar, double to_upar, double to_vpar, double fuzzy) |
| Return the subsurface(s) on the input domain. | |
| virtual CompositeBox | compositeBox () const |
| Create the CompositeBox for the parametric object. | |
| virtual DirectionCone | directionCone () const |
| A cone which contains all normals of the object. | |
| virtual void | getBoundaryObjects (std::vector< boost::shared_ptr< BoundaryGeomInt > > &bd_objs) |
| Return the boundary objects of this object. | |
| virtual int | checkPeriodicity (int pardir) const |
| Check if the object is periodic in the specified direction. | |
| virtual int | dimension () const |
| The dimension of the geometric space. | |
| virtual const RectDomain & | getDomain () const |
| Return the rectangular domain of the surface. | |
| const RectDomain & | getDegDomain (double epsge) |
| Return a rectangular domain of the surface which is slightly reduced in the degenerate case. | |
| virtual bool | isSimple () |
| Estimates if the current surface is simple enough for a singularity iteration. | |
| virtual bool | isSpline () |
| Verify whether the object is a spline. | |
| virtual bool | isIsoParametric (ParamCurveInt *curve, int dir, double par, double ptol, double tol) |
| Check if a curve is an iso parametric curve in the current surface. | |
| virtual double | getOptimizedConeAngle (Point &axis1, Point &axis2) |
| We try to treat problems which will never result in a simple case by shrinking the domain slightly, resulting in smaller cones. | |
| virtual void | knotIntervalFuzzy (double &u, double &v, double utol, double vtol) const |
| Find the knot intervals for which u and v lie inside, moving the value u or v if they lie close to a knot. | |
| virtual double | nextSegmentVal (int dir, double par, bool forward, double tol) const |
| Return the value of the knot next to the input parameter par. | |
| bool | isDegenerate (double epsge) |
| Verfify whether the object is degenerate. | |
| virtual int | isDegenerate (double epsge, int dir) |
| Verfify whether the object is degenerate in the specified direction. | |
| virtual bool | isDegenerate (double epsge, int dir, double *par) |
| Verfify whether the object is degenerate in the specified direction and parameter. | |
| double | isolateDegPar (int dir, int deg_edge, double threshold, double *deg_factor=NULL) |
| Return info on parameter domain which needs special treatment near a degenerated edge. | |
| void | setDegTriang () |
| Set dege_triang info. | |
| bool | getDegTriang () |
| Get deg_triang info. | |
| double | getParOffBd (int dir, bool atstart, double tol) const |
| Estimate the parameter value of a surface a specified distance from a given edge. | |
| void | first_fund_form (double u, double v, bool u_from_right, bool v_from_right, double &E, double &F, double &G) const |
| Return the coefficients necessary to calculate the first fundamental form of the surface in the parameter point. | |
| void | second_fund_form (double u, double v, bool u_from_right, bool v_from_right, double &L, double &M, double &N) const |
| Return the coefficients necessary to calculate the second fundamental form of the surface in the parameter point. | |
| void | derivs (double u, double v, Point &deriv_u, Point &deriv_v, bool from_right_1=true, bool from_right_2=true) const |
| Return the partial derivatives in the input parameter point. | |
| void | normal (double u, double v, Point &normal, bool from_right_1=true, bool from_right_2=true) const |
| Calculate the normal in the specified parameter point. | |
| virtual RotatedBox | getRotatedBox (std::vector< Point > &axis) const |
| Create a box containing the geometric sample mesh in the input coordinate system. | |
| void | axisFromCorners (Point &axis1, Point &axis2) const |
| Use the corner points of the parameter domain to create axes. | |
| virtual void | splitAtG0 (double angtol, std::vector< boost::shared_ptr< ParamSurfaceInt > > &subG1) |
| Requests from selfintersection computation. | |
| void | getSingularity (double eps, double sing_par[], Point &sing_pt, double &sing_val, double *seed) |
| Iterate for a surface singularity. | |
| bool | canSelfIntersect (double epsge) const |
| Check if the current surface can selfintersect. | |
| virtual boost::shared_ptr< ParamSurfaceInt > | getNormalSurface () const |
| Returns the normal surface corresponding to this surface. | |
| virtual bool | canImplicitize () |
| Check whether the objects fulfills the requirements to implicitize. | |
| virtual bool | implicitize (double tol) |
| Implicitize the object. | |
| virtual bool | getImplicit (double tol, double &tol2, AlgObj3DInt &alg_obj_3d_int) |
| Get the implicit representation of the object. | |
Protected Attributes | |
| boost::shared_ptr< ParamSurface > | surf_ |
| int | dim_ |
| double | deg_tol_ |
| bool | deg_triang_ |
|
std::vector< std::pair< double, int > > | segment_ [2] |
| bool | bd_deg_ [4] |
| RectDomain | domain_ |
| RectDomain | deg_domain_ |
| int | nmesh_ [2] |
| std::vector< double > | mesh_ |
| DirectionCone | cone_ |
| bool | lw_set_ |
| double | length_ [2] |
| double | wiggle_ [2] |
| std::vector< Point > | temp_point_array_ |
| boost::shared_ptr< ImplicitizeSurfaceAlgo > | impl_sf_algo_ |
| double | implicit_tol_ |
| int | impl_deg_ |
| boost::shared_ptr< AlgObj3DInt > | implicit_obj_ |
| double | implicit_err_ |
Definition at line 55 of file ParamSurfaceInt.h.
| Go::ParamSurfaceInt::ParamSurfaceInt | ( | boost::shared_ptr< ParamSurface > | surf, | |
| ParamGeomInt * | parent = 0 | |||
| ) | [explicit] |
Constructor.
| surf | the parametric surface defining the intersection object. | |
| parent | the parent object to this object. |
| virtual void Go::ParamSurfaceInt::point | ( | Point & | pt, | |
| const double * | tpar | |||
| ) | const [inline, virtual] |
Evaluate the object in the input parameter.
| pt | the Point to be returned. | |
| tpar | the parameter in which to evaluate. The size of the array should be equal to numParams(). |
Implements Go::ParamObjectInt.
Definition at line 71 of file ParamSurfaceInt.h.
References surf_.
| virtual void Go::ParamSurfaceInt::point | ( | std::vector< Point > & | pt, | |
| const double * | tpar, | |||
| int | derivs, | |||
| const bool * | from_right = 0, |
|||
| double | resolution = 1.0e-12 | |||
| ) | const [inline, virtual] |
Evaluate the object in the input parameter, with the specified number of derivatives.
| pt | the vecotr of points to be returned. | |
| tpar | the parameter in which to evaluate. The size of the array should be equal to numParams(). | |
| derivs | the number of derivatives to calculate. | |
| from_right | if true the evaluation is to be performed from the right side of the parameter value. | |
| resolution | tolerance used when determining whether parameters are located at special values of the parameter domain (in particualar: knot values in case of spline objects. |
Implements Go::ParamObjectInt.
Definition at line 85 of file ParamSurfaceInt.h.
References surf_.
| virtual ParamSurfaceInt* Go::ParamSurfaceInt::getParamSurfaceInt | ( | ) | [virtual] |
Return a pointer to this object.
Reimplemented from Go::ParamObjectInt.
| boost::shared_ptr<ParamSurface> Go::ParamSurfaceInt::getParamSurface | ( | ) | [inline] |
Return pointer to the parametric surface defining this object.
Definition at line 112 of file ParamSurfaceInt.h.
References surf_.
| boost::shared_ptr<const ParamSurface> Go::ParamSurfaceInt::getParamSurface | ( | ) | const [inline] |
Return pointer to the parametric surface defining this object.
Definition at line 118 of file ParamSurfaceInt.h.
References surf_.
| boost::shared_ptr<ParamSurface> Go::ParamSurfaceInt::getParentParamSurface | ( | RectDomain & | domain | ) |
Return pointer to a subsurface of the parent surface for this object.
If no such surface exist, we use the surface of this object instead.
| domain | the parametric domain of the subsurface. |
| boost::shared_ptr<ParamSurface> Go::ParamSurfaceInt::getParentParamSurface | ( | ) |
Return pointer to the parent surface for this object.
If no such surface exist, we use the surface of this object instead.
| virtual boost::shared_ptr<ParamSurfaceInt> Go::ParamSurfaceInt::makeIntObject | ( | boost::shared_ptr< ParamSurface > | surf | ) | [virtual] |
Return an intersection object for the input surface, using this object as parent.
| surf | the parametric surface defining the intersection object. |
Reimplemented in Go::SplineSurfaceInt.
| virtual boost::shared_ptr<ParamCurveInt> Go::ParamSurfaceInt::makeIntCurve | ( | boost::shared_ptr< ParamCurve > | crv, | |
| ParamGeomInt * | parent | |||
| ) | [virtual] |
Return an intersection object for the input curve, using parameter parent as parent.
| crv | the parametric curve defining the intersection object. | |
| parent | the parent to the created intersection object. |
Reimplemented in Go::SplineSurfaceInt.
| boost::shared_ptr<ParamCurve> Go::ParamSurfaceInt::getIsoCurve | ( | double | param_start, | |
| double | param_end, | |||
| double | isoval, | |||
| bool | pardir_is_u | |||
| ) | const |
Returns the specified isocurve.
| param_start | start parameter for the isocurve. | |
| param_end | end parameter for the isocurve. | |
| isoval | the value for the isoparameter. | |
| pardir_is_u | if 'pardir_is_u' is 'true', then the first parameter is the running direction and the second parameter is the isoparameter; vice versa for 'pardir_is_u' equal to 'false'. |
| boost::shared_ptr<ParamCurve> Go::ParamSurfaceInt::getConstantParameterCurve | ( | int | dir, | |
| double | par | |||
| ) |
Return a curveOnSurface along the current surface in the given direction and parameter value.
| dir | the direction of the constant parameter curve. Indexing starts at 0. | |
| par | the isoparameter for the curve. |
| virtual void Go::ParamSurfaceInt::getLengthAndWiggle | ( | double * | length, | |
| double * | wiggle | |||
| ) | [virtual] |
Return an estimate on the size and wiggle of the object.
| length | the approximative length of the object in the corresponding parameter directions. The size of the array should be equal to numParams(). | |
| wiggle | a scalar representing the wiggle of the object in the corresponding parameter directions. The size of the array should be equal to numParams(). |
Implements Go::ParamObjectInt.
| virtual bool Go::ParamSurfaceInt::hasInnerKnots | ( | int | pardir | ) | const [virtual] |
Return true if the object has any inner knots in the specified parameter direction.
| pardir | the parameter direction in question. Indexing starts at 0. |
Implements Go::ParamObjectInt.
Reimplemented in Go::SplineSurfaceInt.
| virtual bool Go::ParamSurfaceInt::hasCriticalVals | ( | int | pardir | ) | const [virtual] |
Return true if the object has any critical parameter values in the specified parameter direction.
| pardir | the parameter direction in question. Indexing starts at 0. |
Implements Go::ParamObjectInt.
| virtual bool Go::ParamSurfaceInt::hasCriticalValsOrKnots | ( | int | pardir | ) | const [virtual] |
Return true if the object has any critical parameter values or inner knots in the specified parameter direction.
| pardir | the parameter direction in question. Indexing starts at 0. |
Implements Go::ParamObjectInt.
Reimplemented in Go::SplineSurfaceInt.
| virtual bool Go::ParamSurfaceInt::canDivide | ( | int | pardir | ) | [virtual] |
Return true if we are allowed to divide in the specified parameter direction.
| pardir | the parameter direction in question. |
Implements Go::ParamObjectInt.
| virtual std::vector<double> Go::ParamSurfaceInt::getCriticalVals | ( | int | pardir | ) | const [virtual] |
Return the critical parameter values in the specified direction.
| pardir | the parameter direction in question. Indexing starts at 0. |
Implements Go::ParamObjectInt.
| virtual std::vector<double> Go::ParamSurfaceInt::getInnerKnotVals | ( | int | pardir, | |
| bool | sort = false | |||
| ) | const [virtual] |
Return the inner knot values in the specified direction.
| pardir | the parameter direction in question. Indexing starts at 0. | |
| sort | the returned values may be sorted by the function. |
Implements Go::ParamObjectInt.
Reimplemented in Go::SplineSurfaceInt.
| virtual std::vector<double> Go::ParamSurfaceInt::getCriticalValsAndKnots | ( | int | pardir | ) | const [virtual] |
Return the critical parameter values and inner knots for object.
| pardir | the parameter direction in question. Indexing starts at 0. |
Implements Go::ParamObjectInt.
Reimplemented in Go::SplineSurfaceInt.
| virtual int Go::ParamSurfaceInt::getMeshSize | ( | int | dir | ) | [virtual] |
Return the size of the geometric sample mesh in the specified direction.
| dir | the parameter direction in question. Indexing starts at 0. |
Implements Go::ParamGeomInt.
Reimplemented in Go::SplineSurfaceInt.
| virtual double Go::ParamSurfaceInt::paramFromMesh | ( | int | dir, | |
| int | idx | |||
| ) | [virtual] |
Return the corresponding mesh parameter.
| dir | the parameter direction in question. Indexing starts at 0. | |
| idx | the mesh idx in the specified direction. Indexing starts at 0. |
Implements Go::ParamGeomInt.
Reimplemented in Go::SplineSurfaceInt.
| virtual double Go::ParamSurfaceInt::startParam | ( | int | pardir | ) | const [virtual] |
Return the start parameter value in the specified direction.
| pardir | the parameter direction in question. Indexing starts at 0. |
Implements Go::ParamObjectInt.
| virtual double Go::ParamSurfaceInt::endParam | ( | int | pardir | ) | const [virtual] |
Return the end parameter in the specified direction.
| pardir | the parameter direction in question. Indexing starts at 0. |
Implements Go::ParamObjectInt.
| virtual bool Go::ParamSurfaceInt::boundaryPoint | ( | const double * | par, | |
| double | eps | |||
| ) | const [virtual] |
Return true if the specified point lies within eps from the boundary.
| par | the parameter in which to evaluate. Size of array should be equal to numParams(). | |
| eps | the tolerance defining the boundary neighbourhood. |
Implements Go::ParamObjectInt.
| std::vector<double> Go::ParamSurfaceInt::getMima | ( | ) | const |
Return the domain of the surface.
| virtual bool Go::ParamSurfaceInt::inCorner | ( | const double * | par, | |
| double | epspar | |||
| ) | const [virtual] |
Check if parameter point lies close to a corner of the parameter domain.
| par | the input parameter point. | |
| epspar | the parametric tolerance defining the neighbourhood. |
Reimplemented from Go::ParamObjectInt.
| virtual void Go::ParamSurfaceInt::subdivide | ( | int | pardir, | |
| double | par, | |||
| std::vector< boost::shared_ptr< ParamGeomInt > > & | subdiv_objs, | |||
| std::vector< boost::shared_ptr< ParamGeomInt > > & | bd_objs | |||
| ) | [virtual] |
Subdivide the object in the specified parameter direction and parameter value.
| pardir | direction in which to subdive. Indexing starts at 0. | |
| par | parameter in which to subdivide. | |
| subdiv_objs | The subparts of this object. Of the same geometric dimension as this object. | |
| bd_objs | the boundaries between the returned subdiv_objs. Of geometric dimension 1 less than this object. |
Implements Go::ParamGeomInt.
| virtual std::vector<boost::shared_ptr<ParamSurfaceInt> > Go::ParamSurfaceInt::subSurfaces | ( | double | from_upar, | |
| double | from_vpar, | |||
| double | to_upar, | |||
| double | to_vpar, | |||
| double | fuzzy | |||
| ) | [virtual] |
Return the subsurface(s) on the input domain.
For a trimmed surface there may be more than one surface, for a surface defined on a rectangular domain there will be only one.
| from_upar | start parameter in the first parameter direction. | |
| from_vpar | start parameter in the second parameter direction. | |
| to_upar | end parameter in the first parameter direction. | |
| to_vpar | end parameter in the second parameter direction. | |
| fuzzy | allowed alteration of an input parameter value. Typically this applies to a spline surface, where we do not want knots to lie too close whilst not being equal. |
| virtual CompositeBox Go::ParamSurfaceInt::compositeBox | ( | ) | const [virtual] |
Create the CompositeBox for the parametric object.
Implements Go::ParamGeomInt.
| virtual DirectionCone Go::ParamSurfaceInt::directionCone | ( | ) | const [virtual] |
A cone which contains all normals of the object.
Implements Go::ParamGeomInt.
Reimplemented in Go::SplineSurfaceInt.
| virtual void Go::ParamSurfaceInt::getBoundaryObjects | ( | std::vector< boost::shared_ptr< BoundaryGeomInt > > & | bd_objs | ) | [virtual] |
Return the boundary objects of this object.
| bd_objs | the boundary objects of this object. |
Implements Go::ParamGeomInt.
Reimplemented in Go::SplineSurfaceInt.
| virtual int Go::ParamSurfaceInt::checkPeriodicity | ( | int | pardir | ) | const [virtual] |
Check if the object is periodic in the specified direction.
Analyze periodicity of surface based on number of repeating knots and control points. The return value is -1 if the surface ends are disjoint, otherwise k if cv is C^k continuous. These are sufficient but not necessary conditions for periodicity, so it is possible that a higher degree of periodicity exists. Should not be called on this layer, should be overruled by inherited class.
| pardir | the parameter direction in question. |
Reimplemented from Go::ParamGeomInt.
Reimplemented in Go::SplineSurfaceInt.
| virtual const RectDomain& Go::ParamSurfaceInt::getDomain | ( | ) | const [inline, virtual] |
Return the rectangular domain of the surface.
Definition at line 351 of file ParamSurfaceInt.h.
References domain_.
| const RectDomain& Go::ParamSurfaceInt::getDegDomain | ( | double | epsge | ) |
Return a rectangular domain of the surface which is slightly reduced in the degenerate case.
| virtual bool Go::ParamSurfaceInt::isSimple | ( | ) | [virtual] |
Estimates if the current surface is simple enough for a singularity iteration.
Checks the span of the normal cone and the size of the surface
Reimplemented in Go::SplineSurfaceInt.
| virtual bool Go::ParamSurfaceInt::isSpline | ( | ) | [virtual] |
Verify whether the object is a spline.
Implements Go::ParamGeomInt.
Reimplemented in Go::SplineSurfaceInt.
| virtual bool Go::ParamSurfaceInt::isIsoParametric | ( | ParamCurveInt * | curve, | |
| int | dir, | |||
| double | par, | |||
| double | ptol, | |||
| double | tol | |||
| ) | [inline, virtual] |
Check if a curve is an iso parametric curve in the current surface.
NB! Only valid for splines
Reimplemented in Go::SplineSurfaceInt.
Definition at line 371 of file ParamSurfaceInt.h.
| virtual double Go::ParamSurfaceInt::getOptimizedConeAngle | ( | Point & | axis1, | |
| Point & | axis2 | |||
| ) | [virtual] |
We try to treat problems which will never result in a simple case by shrinking the domain slightly, resulting in smaller cones.
This is useful for scenarios where the normals are parallell in a boundary point.
| axis1 | first vector defining a projection plane | |
| axis2 | second vector defining a projection plane |
Implements Go::ParamGeomInt.
Reimplemented in Go::SplineSurfaceInt.
| virtual void Go::ParamSurfaceInt::knotIntervalFuzzy | ( | double & | u, | |
| double & | v, | |||
| double | utol, | |||
| double | vtol | |||
| ) | const [virtual] |
Find the knot intervals for which u and v lie inside, moving the value u or v if they lie close to a knot.
| u | the u parameter value | |
| v | the v parameter value | |
| utol | the parametric tolerance deciding if the input parameter u should be moved. | |
| vtol | the parametric tolerance deciding if the input parameter v should be moved. |
Reimplemented in Go::SplineSurfaceInt.
| virtual double Go::ParamSurfaceInt::nextSegmentVal | ( | int | dir, | |
| double | par, | |||
| bool | forward, | |||
| double | tol | |||
| ) | const [virtual] |
Return the value of the knot next to the input parameter par.
| dir | the parameter direction in question. Indexing starts at 0. | |
| par | the parameter value | |
| forward | if true we return the closest knot to the right, otherwise the closest knot to the left. | |
| tol | the tolerance to determine if par is already located on the start of the next segment. |
Reimplemented in Go::SplineSurfaceInt.
| bool Go::ParamSurfaceInt::isDegenerate | ( | double | epsge | ) |
Verfify whether the object is degenerate.
| epsge | the geometric tolerance defining degeneracy. |
| virtual int Go::ParamSurfaceInt::isDegenerate | ( | double | epsge, | |
| int | dir | |||
| ) | [virtual] |
Verfify whether the object is degenerate in the specified direction.
| epsge | the geometric tolerance defining degeneracy. | |
| dir | the parameter direction in question. |
Reimplemented from Go::ParamGeomInt.
| virtual bool Go::ParamSurfaceInt::isDegenerate | ( | double | epsge, | |
| int | dir, | |||
| double * | par | |||
| ) | [virtual] |
Verfify whether the object is degenerate in the specified direction and parameter.
| epsge | the geometric tolerance defining degeneracy. | |
| dir | the parameter direction in question. | |
| par | the parameter in which to evaluate. Size of array should be equal to numParams(). |
Implements Go::ParamGeomInt.
| double Go::ParamSurfaceInt::isolateDegPar | ( | int | dir, | |
| int | deg_edge, | |||
| double | threshold, | |||
| double * | deg_factor = NULL | |||
| ) |
Return info on parameter domain which needs special treatment near a degenerated edge.
| dir | the parameter direction in question. Indexing starts at 0. | |
| deg_edge | the degenerate edge | |
| threshold | a tolerance |
| void Go::ParamSurfaceInt::setDegTriang | ( | ) | [inline] |
Set dege_triang info.
Variable useful for surfaces with degenerated edge(s).
Definition at line 438 of file ParamSurfaceInt.h.
References deg_triang_.
| bool Go::ParamSurfaceInt::getDegTriang | ( | ) | [inline] |
Get deg_triang info.
Variable useful for surfaces with degenerated edge(s).
Definition at line 443 of file ParamSurfaceInt.h.
References deg_triang_.
| double Go::ParamSurfaceInt::getParOffBd | ( | int | dir, | |
| bool | atstart, | |||
| double | tol | |||
| ) | const |
Estimate the parameter value of a surface a specified distance from a given edge.
| dir | the parameter direction in question. | |
| atstart | true if we are the start of the parameter interval, false otherwise. | |
| tol | influencing how far from the edge we should move. |
| void Go::ParamSurfaceInt::first_fund_form | ( | double | u, | |
| double | v, | |||
| bool | u_from_right, | |||
| bool | v_from_right, | |||
| double & | E, | |||
| double & | F, | |||
| double & | G | |||
| ) | const [inline] |
Return the coefficients necessary to calculate the first fundamental form of the surface in the parameter point.
| u | the first parameter value. | |
| v | the second parameter value. | |
| u_from_right | if true then evaluate from the right, otherwise from the left. | |
| v_from_right | if true then evaluate from the right, otherwise from the left. | |
| E | the first coefficient for the first fundamental form. | |
| F | the second coefficient for the first fundamental form. | |
| G | the third coefficient for the first fundamental form. |
Definition at line 467 of file ParamSurfaceInt.h.
References surf_, and temp_point_array_.
| void Go::ParamSurfaceInt::second_fund_form | ( | double | u, | |
| double | v, | |||
| bool | u_from_right, | |||
| bool | v_from_right, | |||
| double & | L, | |||
| double & | M, | |||
| double & | N | |||
| ) | const [inline] |
Return the coefficients necessary to calculate the second fundamental form of the surface in the parameter point.
| u | the first parameter value. | |
| v | the second parameter value. | |
| u_from_right | if true then evaluate from the right, otherwise from the left. | |
| v_from_right | if true then evaluate from the right, otherwise from the left. | |
| L | the first coefficient for the second fundamental form. | |
| M | the second coefficient for the second fundamental form. | |
| N | the third coefficient for the second fundamental form. |
Definition at line 498 of file ParamSurfaceInt.h.
References surf_, and temp_point_array_.
| void Go::ParamSurfaceInt::derivs | ( | double | u, | |
| double | v, | |||
| Point & | deriv_u, | |||
| Point & | deriv_v, | |||
| bool | from_right_1 = true, |
|||
| bool | from_right_2 = true | |||
| ) | const [inline] |
Return the partial derivatives in the input parameter point.
| u | the first parameter value. | |
| v | the second parameter value. | |
| deriv_u | the partial derivative in the u-direction. | |
| deriv_v | the partial derivative in the u-direction. | |
| from_right_1 | if true then calculate from the left int the first parameter parameter direction, otherwise from the right. | |
| from_right_2 | if true then calculate from the left int the second parameter parameter direction, otherwise from the right. |
Definition at line 531 of file ParamSurfaceInt.h.
References surf_, and temp_point_array_.
| void Go::ParamSurfaceInt::normal | ( | double | u, | |
| double | v, | |||
| Point & | normal, | |||
| bool | from_right_1 = true, |
|||
| bool | from_right_2 = true | |||
| ) | const [inline] |
Calculate the normal in the specified parameter point.
| u | the first parameter value. | |
| v | the second parameter value. | |
| normal | the calculated normal in the parameter point. | |
| from_right_1 | if true then calculate from the left int the first parameter parameter direction, otherwise from the right. | |
| from_right_2 | if true then calculate from the left int the second parameter parameter direction, otherwise from the right. |
Definition at line 554 of file ParamSurfaceInt.h.
References surf_, and temp_point_array_.
| virtual RotatedBox Go::ParamSurfaceInt::getRotatedBox | ( | std::vector< Point > & | axis | ) | const [virtual] |
Create a box containing the geometric sample mesh in the input coordinate system.
| axis | the axis defining the coordinate system. The size of vector axis is 2, the last point is given as the cross product axis[0]axis[1]. |
Reimplemented in Go::SplineSurfaceInt.
| void Go::ParamSurfaceInt::axisFromCorners | ( | Point & | axis1, | |
| Point & | axis2 | |||
| ) | const |
Use the corner points of the parameter domain to create axes.
| axis1 | the first axis. | |
| axis2 | the second axis. |
| virtual void Go::ParamSurfaceInt::splitAtG0 | ( | double | angtol, | |
| std::vector< boost::shared_ptr< ParamSurfaceInt > > & | subG1 | |||
| ) | [virtual] |
Requests from selfintersection computation.
Split at G1 discontinuities
| angtol | angular tolerance defining G1 discontinuity | |
| subG1 | vector of subdivided patches that are G1 |
Reimplemented in Go::SplineSurfaceInt.
| void Go::ParamSurfaceInt::getSingularity | ( | double | eps, | |
| double | sing_par[], | |||
| Point & | sing_pt, | |||
| double & | sing_val, | |||
| double * | seed | |||
| ) |
Iterate for a surface singularity.
| eps | numerical tolerance | |
| sing_par | parameters of the singularity | |
| sing_pt | the singular point | |
| sing_val | a number that measures the quality of the singularity | |
| seed | initial guess for singularity in parameter plane |
| bool Go::ParamSurfaceInt::canSelfIntersect | ( | double | epsge | ) | const |
Check if the current surface can selfintersect.
Uses normal cone and tangent cones.
| epsge | a geometric tolerance |
| virtual boost::shared_ptr<ParamSurfaceInt> Go::ParamSurfaceInt::getNormalSurface | ( | ) | const [inline, virtual] |
Returns the normal surface corresponding to this surface.
Reimplemented in Go::SplineSurfaceInt.
Definition at line 610 of file ParamSurfaceInt.h.
| virtual bool Go::ParamSurfaceInt::canImplicitize | ( | ) | [inline, virtual] |
Check whether the objects fulfills the requirements to implicitize.
Reimplemented in Go::SplineSurfaceInt.
Definition at line 619 of file ParamSurfaceInt.h.
| virtual bool Go::ParamSurfaceInt::implicitize | ( | double | tol | ) | [inline, virtual] |
Implicitize the object.
| tol | the geoemtric tolerance for the implicitization. |
Reimplemented in Go::SplineSurfaceInt.
Definition at line 625 of file ParamSurfaceInt.h.
| virtual bool Go::ParamSurfaceInt::getImplicit | ( | double | tol, | |
| double & | tol2, | |||
| AlgObj3DInt & | alg_obj_3d_int | |||
| ) | [inline, virtual] |
Get the implicit representation of the object.
Garbage is returned if we are not able to implicitize.
| tol | geometric tolerance for the implicitization procedure. | |
| tol2 | geometric estimate for the accuracy of the implicitized object. Not yet in use!!! | |
| alg_obj_3d_int | the algebraic object containing the implicitized surface. |
Reimplemented in Go::SplineSurfaceInt.
Definition at line 638 of file ParamSurfaceInt.h.
1.5.1