opennurbs_polycurve.h
/* $NoKeywords: $ */
/*
//
// Copyright (c) 1993-2012 Robert McNeel & Associates. All rights reserved.
// OpenNURBS, Rhinoceros, and Rhino3D are registered trademarks of Robert
// McNeel & Associates.
//
// THIS SOFTWARE IS PROVIDED "AS IS" WITHOUT EXPRESS OR IMPLIED WARRANTY.
// ALL IMPLIED WARRANTIES OF FITNESS FOR ANY PARTICULAR PURPOSE AND OF
// MERCHANTABILITY ARE HEREBY DISCLAIMED.
//
// For complete openNURBS copyright information see <http://www.opennurbs.org>.
//
////////////////////////////////////////////////////////////////
*/
////////////////////////////////////////////////////////////////
//
// Definition of poly curve (composite curve)
//
////////////////////////////////////////////////////////////////
#if !defined(OPENNURBS_POLYCURVE_INC_)
#define OPENNURBS_POLYCURVE_INC_
/*
Description:
An ON_PolyCurve is an ON_Curve represented by a sequence of
contiguous ON_Curve segments. A valid polycurve is represented
by an array m_segment of Count()>=1 curve objects and a strictly
increasing array m_t of Count()+1 parameter values. The i-th
curve segment, when considered as part of the polycurve, is affinely
reparamaterized from m_t[i] to m_t[i+1], i.e., m_segment[i].Domain()[0]
is mapped to m_t[i] and m_segment[i].Domain()[1] is mapped to m_t[i+1].
*/
class ON_PolyCurve;
class ON_CLASS ON_PolyCurve : public ON_Curve
{
ON_OBJECT_DECLARE(ON_PolyCurve);
public:
// virtual ON_Object::DestroyRuntimeCache override
void DestroyRuntimeCache( bool bDelete = true );
public:
ON_PolyCurve();
ON_PolyCurve( int ); // int = initial capacity - use when a good estimate
// of the number of segments is known.
ON_PolyCurve(const ON_PolyCurve&);
void Destroy();
virtual ~ON_PolyCurve();
void EmergencyDestroy(); // call if memory used by ON_PolyCurve becomes invalid
ON_PolyCurve& operator=(const ON_PolyCurve&);
/////////////////////////////////////////////////////////////////
// ON_Object overrides
// virtual ON_Object::SizeOf override
unsigned int SizeOf() const;
// virtual ON_Object::DataCRC override
ON__UINT32 DataCRC(ON__UINT32 current_remainder) const;
/*
Description:
Tests an object to see if its data members are correctly
initialized.
Parameters:
text_log - [in] if the object is not valid and text_log
is not NULL, then a brief englis description of the
reason the object is not valid is appened to the log.
The information appended to text_log is suitable for
low-level debugging purposes by programmers and is
not intended to be useful as a high level user
interface tool.
Returns:
@untitled table
true object is valid
false object is invalid, uninitialized, etc.
Remarks:
Overrides virtual ON_Object::IsValid
*/
ON_BOOL32 IsValid( ON_TextLog* text_log = NULL ) const;
/*
Description:
Tests an object to see if its data members are correctly
initialized.
Parameters:
bAllowGaps - [in]
If true, gaps are allowed between polycurve segments.
If false, gaps are not allowed between polycurve segments.
text_log - [in] if the object is not valid and text_log
is not NULL, then a brief englis description of the
reason the object is not valid is appened to the log.
The information appended to text_log is suitable for
low-level debugging purposes by programmers and is
not intended to be useful as a high level user
interface tool.
Returns:
@untitled table
true object is valid
false object is invalid, uninitialized, etc.
Remarks:
Overrides virtual ON_Object::IsValid
*/
bool IsValid( bool bAllowGaps, ON_TextLog* text_log ) const;
void Dump( ON_TextLog& ) const; // for debugging
ON_BOOL32 Write(
ON_BinaryArchive& // open binary file
) const;
ON_BOOL32 Read(
ON_BinaryArchive& // open binary file
);
/////////////////////////////////////////////////////////////////
// ON_Geometry overrides
int Dimension() const;
ON_BOOL32 GetBBox( // returns true if successful
double*, // minimum
double*, // maximum
ON_BOOL32 = false // true means grow box
) const;
/*
Description:
Get tight bounding box.
Parameters:
tight_bbox - [in/out] tight bounding box
bGrowBox -[in] (default=false)
If true and the input tight_bbox is valid, then returned
tight_bbox is the union of the input tight_bbox and the
curve's tight bounding box.
xform -[in] (default=NULL)
If not NULL, the tight bounding box of the transformed
curve is calculated. The curve is not modified.
Returns:
True if a valid tight_bbox is returned.
*/
bool GetTightBoundingBox(
ON_BoundingBox& tight_bbox,
int bGrowBox = false,
const ON_Xform* xform = 0
) const;
ON_BOOL32 Transform(
const ON_Xform&
);
// virtual ON_Geometry::IsDeformable() override
bool IsDeformable() const;
// virtual ON_Geometry::MakeDeformable() override
bool MakeDeformable();
ON_BOOL32 SwapCoordinates(
int, int // indices of coords to swap
);
// virtual ON_Geometry override
bool EvaluatePoint( const class ON_ObjRef& objref, ON_3dPoint& P ) const;
/////////////////////////////////////////////////////////////////
// ON_Curve overrides
ON_Curve* DuplicateCurve() const;
ON_Interval Domain() const;
// Description:
// virtual ON_Curve::SetDomain override.
// Set the domain of the curve
// Parameters:
// t0 - [in]
// t1 - [in] new domain will be [t0,t1]
// Returns:
// true if successful.
ON_BOOL32 SetDomain(
double t0,
double t1
);
bool ChangeDimension(
int desired_dimension
);
/*
Description:
If this curve is closed, then modify it so that
the start/end point is at curve parameter t.
Parameters:
t - [in] curve parameter of new start/end point. The
returned curves domain will start at t.
Returns:
true if successful.
Remarks:
Overrides virtual ON_Curve::ChangeClosedCurveSeam
*/
ON_BOOL32 ChangeClosedCurveSeam(
double t
);
int SpanCount() const; // number of smooth spans in curve
ON_BOOL32 GetSpanVector( // span "knots"
double* // array of length SpanCount() + 1
) const; //
int Degree( // returns maximum algebraic degree of any span
// ( or a good estimate if curve spans are not algebraic )
) const;
ON_BOOL32 IsLinear( // true if curve locus is a line segment between
// between specified points
double = ON_ZERO_TOLERANCE // tolerance to use when checking linearity
) const;
/*
Description:
Several types of ON_Curve can have the form of a polyline including
a degree 1 ON_NurbsCurve, an ON_PolylineCurve, and an ON_PolyCurve
all of whose segments are some form of polyline. IsPolyline tests
a curve to see if it can be represented as a polyline.
Parameters:
pline_points - [out] if not NULL and true is returned, then the
points of the polyline form are returned here.
t - [out] if not NULL and true is returned, then the parameters of
the polyline points are returned here.
Returns:
@untitled table
0 curve is not some form of a polyline
>=2 number of points in polyline form
*/
int IsPolyline(
ON_SimpleArray<ON_3dPoint>* pline_points = NULL,
ON_SimpleArray<double>* pline_t = NULL
) const;
ON_BOOL32 IsArc( // ON_Arc.m_angle > 0 if curve locus is an arc between
// specified points
const ON_Plane* = NULL, // if not NULL, test is performed in this plane
ON_Arc* = NULL, // if not NULL and true is returned, then arc parameters
// are filled in
double = ON_ZERO_TOLERANCE // tolerance to use when checking
) const;
ON_BOOL32 IsPlanar(
ON_Plane* = NULL, // if not NULL and true is returned, then plane parameters
// are filled in
double = ON_ZERO_TOLERANCE // tolerance to use when checking
) const;
ON_BOOL32 IsInPlane(
const ON_Plane&, // plane to test
double = ON_ZERO_TOLERANCE // tolerance to use when checking
) const;
ON_BOOL32 IsClosed( // true if curve is closed (either curve has
void // clamped end knots and euclidean location of start
) const; // CV = euclidean location of end CV, or curve is
// periodic.)
ON_BOOL32 IsPeriodic( // true if curve is a single periodic segment
void
) const;
/*
Description:
Search for a derivatitive, tangent, or curvature discontinuity.
Parameters:
c - [in] type of continity to test for. If ON::C1_continuous
t0 - [in] search begins at t0
t1 - [in] (t0 < t1) search ends at t1
t - [out] if a discontinuity is found, the *t reports the
parameter at the discontinuity.
hint - [in/out] if GetNextDiscontinuity will be called repeatedly,
passing a "hint" with initial value *hint=0 will increase the speed
of the search.
dtype - [out] if not NULL, *dtype reports the kind of discontinuity
found at *t. A value of 1 means the first derivative or unit tangent
was discontinuous. A value of 2 means the second derivative or
curvature was discontinuous.
cos_angle_tolerance - [in] default = cos(1 degree) Used only when
c is ON::G1_continuous or ON::G2_continuous. If the cosine
of the angle between two tangent vectors
is <= cos_angle_tolerance, then a G1 discontinuity is reported.
curvature_tolerance - [in] (default = ON_SQRT_EPSILON) Used only when
c is ON::G2_continuous or ON::Gsmooth_continuous.
ON::G2_continuous:
If K0 and K1 are curvatures evaluated
from above and below and |K0 - K1| > curvature_tolerance,
then a curvature discontinuity is reported.
ON::Gsmooth_continuous:
If K0 and K1 are curvatures evaluated from above and below
and the angle between K0 and K1 is at least twice angle tolerance
or ||K0| - |K1|| > (max(|K0|,|K1|) > curvature_tolerance,
then a curvature discontinuity is reported.
Returns:
true if a discontinuity was found on the interior of the interval (t0,t1).
Remarks:
Overrides ON_Curve::GetNextDiscontinuity.
*/
bool GetNextDiscontinuity(
ON::continuity c,
double t0,
double t1,
double* t,
int* hint=NULL,
int* dtype=NULL,
double cos_angle_tolerance=ON_DEFAULT_ANGLE_TOLERANCE_COSINE,
double curvature_tolerance=ON_SQRT_EPSILON
) const;
/*
Description:
Test continuity at a curve parameter value.
Parameters:
c - [in] continuity to test for
t - [in] parameter to test
hint - [in] evaluation hint
point_tolerance - [in] if the distance between two points is
greater than point_tolerance, then the curve is not C0.
d1_tolerance - [in] if the difference between two first derivatives is
greater than d1_tolerance, then the curve is not C1.
d2_tolerance - [in] if the difference between two second derivatives is
greater than d2_tolerance, then the curve is not C2.
cos_angle_tolerance - [in] default = cos(1 degree) Used only when
c is ON::G1_continuous or ON::G2_continuous. If the cosine
of the angle between two tangent vectors
is <= cos_angle_tolerance, then a G1 discontinuity is reported.
curvature_tolerance - [in] (default = ON_SQRT_EPSILON) Used only when
c is ON::G2_continuous or ON::Gsmooth_continuous.
ON::G2_continuous:
If K0 and K1 are curvatures evaluated
from above and below and |K0 - K1| > curvature_tolerance,
then a curvature discontinuity is reported.
ON::Gsmooth_continuous:
If K0 and K1 are curvatures evaluated from above and below
and the angle between K0 and K1 is at least twice angle tolerance
or ||K0| - |K1|| > (max(|K0|,|K1|) > curvature_tolerance,
then a curvature discontinuity is reported.
Returns:
true if the curve has at least the c type continuity at the parameter t.
Remarks:
Overrides ON_Curve::IsContinuous.
*/
bool IsContinuous(
ON::continuity c,
double t,
int* hint = NULL,
double point_tolerance=ON_ZERO_TOLERANCE,
double d1_tolerance=ON_ZERO_TOLERANCE,
double d2_tolerance=ON_ZERO_TOLERANCE,
double cos_angle_tolerance=ON_DEFAULT_ANGLE_TOLERANCE_COSINE,
double curvature_tolerance=ON_SQRT_EPSILON
) const;
ON_BOOL32 Reverse(); // reverse parameterizatrion
// Domain changes from [a,b] to [-b,-a]
/*
Description:
Force the curve to start at a specified point.
Parameters:
start_point - [in]
Returns:
true if successful.
Remarks:
Some start points cannot be moved. Be sure to check return
code.
See Also:
ON_Curve::SetEndPoint
ON_Curve::PointAtStart
ON_Curve::PointAtEnd
*/
// virtual
ON_BOOL32 SetStartPoint(
ON_3dPoint start_point
);
/*
Description:
Force the curve to end at a specified point.
Parameters:
end_point - [in]
Returns:
true if successful.
Remarks:
Some end points cannot be moved. Be sure to check return
code.
See Also:
ON_Curve::SetStartPoint
ON_Curve::PointAtStart
ON_Curve::PointAtEnd
*/
//virtual
ON_BOOL32 SetEndPoint(
ON_3dPoint end_point
);
ON_BOOL32 Evaluate( // returns false if unable to evaluate
double, // evaluation parameter
int, // number of derivatives (>=0)
int, // array stride (>=Dimension())
double*, // array of length stride*(ndir+1)
int = 0, // optional - determines which side to evaluate from
// 0 = default
// < 0 to evaluate from below,
// > 0 to evaluate from above
int* = 0 // optional - evaluation hint (int) used to speed
// repeated evaluations
) const;
// Description:
// virtual ON_Curve::Trim override.
// Removes portions of the curve outside the specified interval.
// Parameters:
// domain - [in] interval of the curve to keep. Portions of the
// curve before curve(domain[0]) and after curve(domain[1]) are
// removed.
// Returns:
// true if successful.
ON_BOOL32 Trim(
const ON_Interval& domain
);
// Description:
// Where possible, analytically extends curve to include domain.
// Parameters:
// domain - [in] if domain is not included in curve domain,
// curve will be extended so that its domain includes domain.
// Will not work if curve is closed. Original curve is identical
// to the restriction of the resulting curve to the original curve domain,
// Returns:
// true if successful.
bool Extend(
const ON_Interval& domain
);
// Description:
// virtual ON_Curve::Split override.
// Divide the curve at the specified parameter. The parameter
// must be in the interior of the curve's domain. The pointers
// passed to Split must either be NULL or point to an ON_Curve
// object of the same of the same type. If the pointer is NULL,
// then a curve will be created in Split(). You may pass "this"
// as one of the pointers to Split().
// Parameters:
// t - [in] parameter in interval Domain().
// left_side - [out] left portion of curve
// right_side - [out] right portion of curve
// Example:
// For example, if crv were an ON_NurbsCurve, then
//
// ON_NurbsCurve right_side;
// crv.Split( crv.Domain().Mid() &crv, &right_side );
//
// would split crv at the parametric midpoint, put the left side
// in crv, and return the right side in right_side.
ON_BOOL32 Split(
double t, // t = curve parameter to split curve at
ON_Curve*& left_side, // left portion returned here
ON_Curve*& right_side // right portion returned here
) const;
int GetNurbForm( // returns 0: unable to create NURBS representation
// with desired accuracy.
// 1: success - returned NURBS parameterization
// matches the curve's to wthe desired accuracy
// 2: success - returned NURBS point locus matches
// the curve's to the desired accuracy but, on
// the interior of the curve's domain, the
// curve's parameterization and the NURBS
// parameterization may not match to the
// desired accuracy.
ON_NurbsCurve&,
double = 0.0,
const ON_Interval* = NULL // OPTIONAL subdomain of polycurve
) const;
int HasNurbForm( // returns 0: unable to create NURBS representation
// with desired accuracy.
// 1: success - returned NURBS parameterization
// matches the curve's to wthe desired accuracy
// 2: success - returned NURBS point locus matches
// the curve's to the desired accuracy but, on
// the interior of the curve's domain, the
// curve's parameterization and the NURBS
// parameterization may not match to the
// desired accuracy.
) const;
// virtual ON_Curve::GetCurveParameterFromNurbFormParameter override
ON_BOOL32 GetCurveParameterFromNurbFormParameter(
double, // nurbs_t
double* // curve_t
) const;
// virtual ON_Curve::GetNurbFormParameterFromCurveParameter override
ON_BOOL32 GetNurbFormParameterFromCurveParameter(
double, // curve_t
double* // nurbs_t
) const;
/////////////////////////////////////////////////////////////////
// Interface
int Count() const; // number of segment curves
// These operator[] functions return NULL if index is out of range
ON_Curve* operator[](int) const;
/*
Description:
Returns a pointer to a segment curve.
Parameters:
segment_index - [in] 0 based index (0 <= segment_index < Count() )
Returns:
A pointer to the segment curve. Returns NULL if segment_index < 0
or segment_index >= Count().
*/
ON_Curve* SegmentCurve(
int segment_index
) const;
/*
Description:
Converts a polycurve parameter to a segment curve parameter.
Parameters:
polycurve_parameter - [in]
Returns:
Segment curve evaluation parameter or ON_UNSET_VALUE if the
segment curve parameter cannot be computed.
See Also:
ON_PolyCurve::PolyCurveParameter
*/
double SegmentCurveParameter(
double polycurve_parameter
) const;
/*
Description:
Converts a segment curve parameter to a polycurve parameter.
Parameters:
segment_index - [in]
segmentcurve_parameter - [in]
Returns:
Polycurve evaluation parameter or ON_UNSET_VALUE if the
polycurve curve parameter cannot be computed.
See Also:
ON_PolyCurve::SegmentCurveParameter
*/
double PolyCurveParameter(
int segment_index,
double segmentcurve_parameter
) const;
/*
Description:
Returns the polycurve subdomain assigned to a segment curve.
Parameters:
segment_index - [in] 0 based index (0 <= segment_index < Count() )
Returns:
The polycurve subdomain assigned to a segment curve.
Returns ([ON_UNSET_VALUE,ON_UNSET_VALUE) if segment_index < 0
or segment_index >= Count().
*/
ON_Interval SegmentDomain(
int segment_index
) const;
/*
Description:
Find the segment used for evaluation at polycurve_parameter.
Parameters:
polycurve_parameter - [in]
Returns:
index of the segment used for evaluation at polycurve_parameter.
If polycurve_parameter < Domain.Min(), then 0 is returned.
If polycurve_parameter > Domain.Max(), then Count()-1 is returned.
*/
int SegmentIndex(
double polycurve_parameter
) const;
/*
Description:
Find the segments with support on sub_domain.
Parameters:
sub_domain - [in] increasing interval
segment_index0 - [out]
segment_index1 - [out] segments with index i where
*segment_index0 <= i < *segment_index1 are the segments
with support on the sub_domain
Returns:
number of segments with support on sub_domain.
*/
int SegmentIndex(
ON_Interval sub_domain,
int* segment_index0,
int* segment_index1
) const;
ON_Curve* FirstSegmentCurve() const; // returns NULL if count = 0
ON_Curve* LastSegmentCurve() const; // returns NULL if count = 0
/*
Description:
Search the curve for gaps between the sub curve segments.
Parameters:
segment_index0 - [in]
The search for gaps starts at with the comparing
the end of segment[segment_index0] and the start of
segment[segment_index0+1].
Returns:
0:
No gaps were found.
i > segment_index0:
The end of polycuve segment[i-1] is not coincident
with the start of polycurve segment[i].
*/
int FindNextGap( int segment_index0 ) const;
/*
Description:
Determine if there is a gap between the end of
segment[segment_index] and the start of segment[segment_index+1].
Parameters:
segment_index - [in]
>= 0
Returns:
true:
segment_index was valid and there is a gap between
the end of segment[segment_index] and the start of
segment[segment_index+1].
*/
bool HasGapAt( int segment_index ) const;
// Replace calls to HasGap() with FindNextGap(0)
ON_DEPRECATED int HasGap() const;
/*
Description:
Modify the one or both locations at the end of
segment[gap_index-1] and the start of segment[gap_index]
so they are coindicent.
Parameters:
gap_index - [in] 1 <= gap_index < Count()
If the locations at the end of segment[gap_index-1] and
the start of segment[gap_index] are not identical, then
an attempt is made to modify the segments so these
locations are closer.
ends_to_modify - [in]
0: (suggested)
The code will decide what segments to modify.
1:
modify the end location of segment[gap_index-1]
2:
modify the start location of segment[gap_index]
Returns:
True if a modification was performed and HasGap(gap_index-1)
returns 0 after the modification.
False if no modification was preformed because there
was no gap or because one could not be performed.
Remarks:
Note that passing the return value from FindNextGap() will
close the gap found by FindNextGap().
*/
bool CloseGap( int gap_index, int segments_to_modify );
/*
Description:
Searches for and closes all gaps that can be found.
Returns:
Number of gaps that were closed.
*/
int CloseGaps();
void Reserve( int ); // make sure capacity is at least the specified count
// ON_Curve pointers added with Prepend(), Append(), PrependAndMatch(), AppendANdMatch(),and Insert() are deleted
// by ~ON_PolyCurve(). Use ON_CurveProxy( ON_Curve*) if you want
// the original curve segment to survive ~ON_PolyCurve().
ON_BOOL32 Prepend( ON_Curve* ); // Prepend curve.
ON_BOOL32 Append( ON_Curve* ); // Append curve.
ON_BOOL32 Insert(
int, // segment_index,
ON_Curve*
);
//PrependAndMatch() and AppendAndMatch() return false if this->IsCLosed() or
//this->Count() > 0 and curve is closed
ON_BOOL32 PrependAndMatch(ON_Curve*); //Prepend and match end of curve to start of polycurve
ON_BOOL32 AppendAndMatch(ON_Curve*); //Append and match start of curve to end of polycurve
ON_BOOL32 Remove(); // delete last segment and reduce count by 1
ON_BOOL32 Remove( int ); // delete specified segment and reduce count by 1
//////////
// Use the HarvestSegment() function when you want to prevent a
// segment from being destroyed by ~ON_PolyCurve(). HarvestSegment()
// replaces the polycurve segment with a NULL. Count() and parameter
// information remains unchanged.
ON_Curve* HarvestSegment( int );
/*
Returns:
True if a curve in the m_segment[] array is an ON_PolyCurve.
*/
bool IsNested() const;
/*
Description:
Same as RemoveNestingEx().
Remarks:
RemoveNestingEx was added to avoid breaking the SDK.
*/
void RemoveNesting();
/*
Description:
Removes the nested of polycurves. The result will have not
have an ON_PolyCurve as a segment but will have identical
locus and parameterization.
Returns:
True if a nested polycurve was removed. False
if no nested polycurves were found.
*/
bool RemoveNestingEx();
/*
Returns:
True if the domains of the curves in the m_segment[] array exactly
match the domains of the segments specified in the m_t[] array.
Put another way, returns true if SegmentDomain(i) = SegmentCurve(i).Domain()
for every segment index.
*/
bool HasSynchronizedSegmentDomains() const;
/*
Description:
Sets the domain of the curve int the m_segment[] array to exactly
match the domain defined in the m_t[] array. This is not required,
but can simplify some coding situations.
Returns:
True if at least one segment was reparameterized. False if no
changes were made.
*/
bool SynchronizeSegmentDomains();
//////////
// Expert user function
// Sets the m_segment[index] to crv.
void SetSegment(int index, ON_Curve* crv);
//////////
/*
Description:
Expert user function to set the m_t[] array.
Parameters:
t - [in] increasing array of SegmentCount()+1 parameters.
Returns
True if successful.
*/
bool SetParameterization( const double* t );
/*
Description:
Lookup a parameter in the m_t array, optionally using a built in snap tolerance to
snap a parameter value to an element of m_t.
Parameters:
t - [in] parameter
index -[out] index into m_t such that if the function returns true then t is equal
to, or is within tolerance of m_t[index].
if function returns false then the value of index is
@table
condition value of index
t<m_t[0] or m_t is empty -1
m_t[i] < t < m_t[i+1] i for 0<=i<=m_t.Count()-2
t>m_t[ m_t.Count()-1] m_t.Count()-1
bEnableSnap -[in] if true use tolerance when comparing to m_t values
Returns
true if the t is exactly equal to, or within tolerance of
(only if bEnableSnap==true) m_t[index].
*/
bool ParameterSearch(double t, int& index, bool bEnableSnap) const;
/*
Returns:
Reference to m_segment.
*/
const ON_CurveArray& SegmentCurves() const;
/*
Returns:
Reference to m_t.
*/
const ON_SimpleArray<double>& SegmentParameters() const;
/////////////////////////////////////////////////////////////////
// Implementation
private:
// The curves in this array are deleted by ~ON_PolyCurve().
// Use ON_CurveProxy classes if you don't want ON_PolyCurve()
// to destroy the curve.
ON_CurveArray m_segment; // array of pointers to curves
// all have the same dimension
// and are contiguous to tolerance
ON_SimpleArray<double> m_t; // ON_PolyCurve segment parameterizations
};
#endif
ON_3dPoint
Definition: opennurbs_point.h:419
ON_Arc
Definition: opennurbs_arc.h:35
ON_BinaryArchive
Definition: opennurbs_archive.h:732
ON_BoundingBox
Definition: opennurbs_bounding_box.h:26
ON_CurveArray
Definition: opennurbs_curve.h:1144
ON_Curve
Definition: opennurbs_curve.h:89
ON_Interval
Definition: opennurbs_point.h:49
ON_NurbsCurve
Definition: opennurbs_nurbscurve.h:30
ON_ObjRef
Definition: opennurbs_objref.h:168
ON_Plane
Definition: opennurbs_plane.h:21
ON_PolyCurve
Definition: opennurbs_polycurve.h:38
ON_PolyCurve::SegmentIndex
int SegmentIndex(ON_Interval sub_domain, int *segment_index0, int *segment_index1) const
ON_PolyCurve::Count
int Count() const
ON_PolyCurve::Extend
bool Extend(const ON_Interval &domain)
ON_PolyCurve::SetEndPoint
ON_BOOL32 SetEndPoint(ON_3dPoint end_point)
ON_PolyCurve::Write
ON_BOOL32 Write(ON_BinaryArchive &) const
ON_PolyCurve::ChangeClosedCurveSeam
ON_BOOL32 ChangeClosedCurveSeam(double t)
ON_PolyCurve::SetSegment
void SetSegment(int index, ON_Curve *crv)
ON_PolyCurve::GetBBox
ON_BOOL32 GetBBox(double *, double *, ON_BOOL32=false) const
ON_PolyCurve::SetStartPoint
ON_BOOL32 SetStartPoint(ON_3dPoint start_point)
ON_PolyCurve::ParameterSearch
bool ParameterSearch(double t, int &index, bool bEnableSnap) const
ON_PolyCurve::Trim
ON_BOOL32 Trim(const ON_Interval &domain)
ON_PolyCurve::RemoveNesting
void RemoveNesting()
ON_PolyCurve::Prepend
ON_BOOL32 Prepend(ON_Curve *)
ON_PolyCurve::IsPeriodic
ON_BOOL32 IsPeriodic(void) const
ON_PolyCurve::ON_PolyCurve
ON_PolyCurve(const ON_PolyCurve &)
ON_PolyCurve::Dump
void Dump(ON_TextLog &) const
ON_PolyCurve::RemoveNestingEx
bool RemoveNestingEx()
ON_PolyCurve::Destroy
void Destroy()
ON_PolyCurve::IsInPlane
ON_BOOL32 IsInPlane(const ON_Plane &, double=ON_ZERO_TOLERANCE) const
ON_PolyCurve::DataCRC
ON__UINT32 DataCRC(ON__UINT32 current_remainder) const
ON_PolyCurve::SegmentParameters
const ON_SimpleArray< double > & SegmentParameters() const
ON_PolyCurve::LastSegmentCurve
ON_Curve * LastSegmentCurve() const
ON_PolyCurve::SynchronizeSegmentDomains
bool SynchronizeSegmentDomains()
ON_PolyCurve::Reserve
void Reserve(int)
ON_PolyCurve::ChangeDimension
bool ChangeDimension(int desired_dimension)
ON_PolyCurve::GetSpanVector
ON_BOOL32 GetSpanVector(double *) const
ON_PolyCurve::Evaluate
ON_BOOL32 Evaluate(double, int, int, double *, int=0, int *=0) const
ON_PolyCurve::FindNextGap
int FindNextGap(int segment_index0) const
ON_PolyCurve::Remove
ON_BOOL32 Remove(int)
ON_PolyCurve::GetTightBoundingBox
bool GetTightBoundingBox(ON_BoundingBox &tight_bbox, int bGrowBox=false, const ON_Xform *xform=0) const
ON_PolyCurve::SegmentCurves
const ON_CurveArray & SegmentCurves() const
ON_PolyCurve::Dimension
int Dimension() const
ON_PolyCurve::GetNextDiscontinuity
bool GetNextDiscontinuity(ON::continuity c, double t0, double t1, double *t, int *hint=NULL, int *dtype=NULL, double cos_angle_tolerance=ON_DEFAULT_ANGLE_TOLERANCE_COSINE, double curvature_tolerance=ON_SQRT_EPSILON) const
ON_PolyCurve::GetCurveParameterFromNurbFormParameter
ON_BOOL32 GetCurveParameterFromNurbFormParameter(double, double *) const
ON_PolyCurve::GetNurbForm
int GetNurbForm(ON_NurbsCurve &, double=0.0, const ON_Interval *=NULL) const
ON_PolyCurve::SwapCoordinates
ON_BOOL32 SwapCoordinates(int, int)
ON_PolyCurve::CloseGaps
int CloseGaps()
ON_PolyCurve::HasSynchronizedSegmentDomains
bool HasSynchronizedSegmentDomains() const
ON_PolyCurve::ON_PolyCurve
ON_PolyCurve(int)
ON_PolyCurve::PolyCurveParameter
double PolyCurveParameter(int segment_index, double segmentcurve_parameter) const
ON_PolyCurve::HasGap
ON_DEPRECATED int HasGap() const
ON_PolyCurve::SizeOf
unsigned int SizeOf() const
ON_PolyCurve::~ON_PolyCurve
virtual ~ON_PolyCurve()
ON_PolyCurve::EvaluatePoint
bool EvaluatePoint(const class ON_ObjRef &objref, ON_3dPoint &P) const
ON_PolyCurve::operator[]
ON_Curve * operator[](int) const
ON_PolyCurve::ON_PolyCurve
ON_PolyCurve()
ON_PolyCurve::Insert
ON_BOOL32 Insert(int, ON_Curve *)
ON_PolyCurve::DestroyRuntimeCache
void DestroyRuntimeCache(bool bDelete=true)
ON_PolyCurve::IsLinear
ON_BOOL32 IsLinear(double=ON_ZERO_TOLERANCE) const
ON_PolyCurve::DuplicateCurve
ON_Curve * DuplicateCurve() const
ON_PolyCurve::SegmentCurveParameter
double SegmentCurveParameter(double polycurve_parameter) const
ON_PolyCurve::IsValid
ON_BOOL32 IsValid(ON_TextLog *text_log=NULL) const
ON_PolyCurve::EmergencyDestroy
void EmergencyDestroy()
ON_PolyCurve::SpanCount
int SpanCount() const
ON_PolyCurve::Degree
int Degree() const
ON_PolyCurve::SegmentDomain
ON_Interval SegmentDomain(int segment_index) const
ON_PolyCurve::IsContinuous
bool IsContinuous(ON::continuity c, double t, int *hint=NULL, double point_tolerance=ON_ZERO_TOLERANCE, double d1_tolerance=ON_ZERO_TOLERANCE, double d2_tolerance=ON_ZERO_TOLERANCE, double cos_angle_tolerance=ON_DEFAULT_ANGLE_TOLERANCE_COSINE, double curvature_tolerance=ON_SQRT_EPSILON) const
ON_PolyCurve::IsPlanar
ON_BOOL32 IsPlanar(ON_Plane *=NULL, double=ON_ZERO_TOLERANCE) const
ON_PolyCurve::SetParameterization
bool SetParameterization(const double *t)
ON_PolyCurve::AppendAndMatch
ON_BOOL32 AppendAndMatch(ON_Curve *)
ON_PolyCurve::IsDeformable
bool IsDeformable() const
ON_PolyCurve::HasGapAt
bool HasGapAt(int segment_index) const
ON_PolyCurve::PrependAndMatch
ON_BOOL32 PrependAndMatch(ON_Curve *)
ON_PolyCurve::FirstSegmentCurve
ON_Curve * FirstSegmentCurve() const
ON_PolyCurve::GetNurbFormParameterFromCurveParameter
ON_BOOL32 GetNurbFormParameterFromCurveParameter(double, double *) const
ON_PolyCurve::MakeDeformable
bool MakeDeformable()
ON_PolyCurve::Reverse
ON_BOOL32 Reverse()
ON_PolyCurve::IsArc
ON_BOOL32 IsArc(const ON_Plane *=NULL, ON_Arc *=NULL, double=ON_ZERO_TOLERANCE) const
ON_PolyCurve::IsValid
bool IsValid(bool bAllowGaps, ON_TextLog *text_log) const
ON_PolyCurve::CloseGap
bool CloseGap(int gap_index, int segments_to_modify)
ON_PolyCurve::SegmentIndex
int SegmentIndex(double polycurve_parameter) const
ON_PolyCurve::IsClosed
ON_BOOL32 IsClosed(void) const
ON_PolyCurve::HasNurbForm
int HasNurbForm() const
ON_PolyCurve::SetDomain
ON_BOOL32 SetDomain(double t0, double t1)
ON_PolyCurve::Transform
ON_BOOL32 Transform(const ON_Xform &)
ON_PolyCurve::IsNested
bool IsNested() const
ON_PolyCurve::Split
ON_BOOL32 Split(double t, ON_Curve *&left_side, ON_Curve *&right_side) const
ON_PolyCurve::SegmentCurve
ON_Curve * SegmentCurve(int segment_index) const
ON_PolyCurve::HarvestSegment
ON_Curve * HarvestSegment(int)
ON_PolyCurve::operator=
ON_PolyCurve & operator=(const ON_PolyCurve &)
ON_PolyCurve::Append
ON_BOOL32 Append(ON_Curve *)
ON_PolyCurve::IsPolyline
int IsPolyline(ON_SimpleArray< ON_3dPoint > *pline_points=NULL, ON_SimpleArray< double > *pline_t=NULL) const
ON_PolyCurve::Domain
ON_Interval Domain() const
ON_PolyCurve::Remove
ON_BOOL32 Remove()
ON_PolyCurve::Read
ON_BOOL32 Read(ON_BinaryArchive &)
ON_SimpleArray< ON_3dPoint >
ON_TextLog
Definition: opennurbs_textlog.h:23
ON_Xform
Definition: opennurbs_xform.h:29