Loading...
Searching...
No Matches
opennurbs_point.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>.
//
////////////////////////////////////////////////////////////////
*/
////////////////////////////////////////////////////////////////
//
// defines double precision point, vector, and array classes
//
////////////////////////////////////////////////////////////////
#if !defined(ON_POINT_INC_)
#define ON_POINT_INC_
#include <pcl/pcl_exports.h>
class ON_BoundingBox;
class ON_Xform;
class ON_Line;
class ON_Plane;
class ON_2dPoint;
class ON_3dPoint;
class ON_4dPoint;
class ON_2dVector;
class ON_3dVector;
class ON_2fVector;
class ON_3fVector;
class ON_Interval;
////////////////////////////////////////////////////////////////
//
// ON_Interval
//
class PCL_EXPORTS ON_CLASS ON_Interval
{
public:
static const ON_Interval EmptyInterval; // (ON_UNSET_VALUE,ON_UNSET_VALUE)
////////
// The default constructor creates an empty interval (ON_UNSET_VALUE,ON_UNSET_VALUE)
ON_Interval();
ON_Interval(double t0,double t1);
~ON_Interval();
bool operator!=(const ON_Interval&) const;
bool operator==(const ON_Interval&) const;
// Interval = [m_t[0], m_t[1]]
double m_t[2];
/*
Description:
Sets interval to (ON_UNSET_VALUE,ON_UNSET_VALUE)
See Also:
ON_Interval::Set
*/
void Destroy();
/*
Description:
Sets interval to [t0,t1]
Parameters:
t0 - [in]
t1 - [in]
See Also:
ON_Interval::ON_Interval( double, double )
*/
void Set(
double t0,
double t1
);
/*
Description:
Convert normalized parameter to interval value, or pair of values.
Parameters:
normalized_parameter - [in]
Returns:
Interval parameter
min*(1.0-normalized_parameter) + max*normalized_parameter
See Also:
ON_Interval::NormalizedParameterAt
*/
double ParameterAt (
double normalized_parameter
) const;
ON_Interval ParameterAt (
ON_Interval normalized_interval
) const;
/*
Description:
Convert interval value, or pair of values, to normalized parameter.
Parameters:
interval_parameter - [in] value in interval
Returns:
Normalized parameter x so that
min*(1.0-x) + max*x = interval_parameter.
See Also:
ON_Interval::ParameterAt
*/
double NormalizedParameterAt (
double interval_parameter
) const;
ON_Interval NormalizedParameterAt (
ON_Interval interval_parameter
) const;
double& operator[](int); // returns (index<=0) ? m_t[0] : m_t[1]
double operator[](int) const; // returns (index<=0) ? m_t[0] : m_t[1]
double& operator[](unsigned int); // returns (index<=0) ? m_t[0] : m_t[1]
double operator[](unsigned int) const; // returns (index<=0) ? m_t[0] : m_t[1]
double Min() const; // returns smaller of m_t[0] and m_t[1]
double Max() const; // returns larger of m_t[0] and m_t[1]
double Mid() const; // returns 0.5*(m_t[0] + m_t[1])
double Length() const;
bool IsIncreasing() const; // returns true if m_t[0] < m_t[1]
bool IsDecreasing() const; // returns true if m_t[0] > m_t[0];
bool IsInterval() const; // returns truc if m_t[0] != m_t[1]
bool IsSingleton() const; // returns true if m_t[0] == m_t[1] != ON_UNSET_VALUE
bool IsEmptyInterval() const; // returns true if m_t[0] == m_t[1] == ON_UNSET_VALUE
bool IsValid() const; // returns ON_IsValid(m_t[0]) && ON_IsValid(m_t[1])
// OBSOLETE - Use IsEmptyInterval()
bool IsEmptySet() const; // returns true if m_t[0] == m_t[1] == ON_UNSET_VALUE
bool MakeIncreasing(); // returns true if resulting interval IsIncreasing()
/*
Returns:
@untitled table
0 this is idential to other
-1 this[0] < other[0]
+1 this[0] > other[0]
-1 this[0] == other[0] and this[1] < other[1]
+1 this[0] == other[0] and this[1] > other[1]
*/
int Compare( const ON_Interval& other ) const;
/*
Description:
Test a value t to see if it is inside the interval.
Parameters:
t - [in] value to test
bTestOpenInterval - [in]
If false, t is tested to see if it satisfies min <= t <= max.
If true, t is tested to see if it satisfies min < t < max.
Returns:
true if t is in the interval and false if t is not
in the interval.
*/
bool Includes(
double t,
bool bTestOpenInterval = false
) const;
/*
Description:
Test an interval to see if it is contained in this interval.
Parameters:
other - [in] interval to test
bProperSubSet - [in] if true, then the test is for a proper subinterval.
Returns:
If bProperSubSet is false, then the result is true when
this->Min() <= other.Min() and other.Max() <= this->Max().
If bProperSubSet is true, then the result is true when
this->Min() <= other.Min() and other.Max() <= this->Max()
and at least one of the inequalites is strict.
*/
bool Includes(
const ON_Interval& other,
bool bProperSubSet = false
) const;
/*
Description:
Changes interval to [-m_t[1],-m_t[0]].
*/
void Reverse();
/*
Description:
Swaps m_t[0] and m_t[1].
*/
void Swap();
//////////
// If the intersection is not empty, then
// intersection = [max(this.Min(),arg.Min()), min(this.Max(),arg.Max())]
// Intersection() returns true if the intersection is not empty.
// The interval [ON_UNSET_VALUE,ON_UNSET_VALUE] is considered to be
// the empty set interval. The result of any intersection involving an
// empty set interval or disjoint intervals is the empty set interval.
bool Intersection( // this = this intersect arg
const ON_Interval&
);
//////////
// If the intersection is not empty, then
// intersection = [max(argA.Min(),argB.Min()), min(argA.Max(),argB.Max())]
// Intersection() returns true if the intersection is not empty.
// The interval [ON_UNSET_VALUE,ON_UNSET_VALUE] is considered to be
// the empty set interval. The result of any intersection involving an
// empty set interval or disjoint intervals is the empty set interval.
bool Intersection( // this = intersection of two args
const ON_Interval&,
const ON_Interval&
);
//////////
// The union of an empty set and an increasing interval is the increasing
// interval. The union of two empty sets is empty. The union of an empty
// set an a non-empty interval is the non-empty interval.
// The union of two non-empty intervals is
// union = [min(this.Min(),arg.Min()), max(this.Max(),arg.Max()),]
// Union() returns true if the union is not empty.
bool Union( // this = this union arg
const ON_Interval&
);
bool Union( // this = this union arg
double t
);
bool Union( // this = this union arg
int count,
const double* t
);
//////////
// The union of an empty set and an increasing interval is the increasing
// interval. The union of two empty sets is empty. The union of an empty
// set an a non-empty interval is the non-empty interval.
// The union of two non-empty intervals is
// union = [min(argA.Min(),argB.Min()), max(argA.Max(),argB.Max()),]
// Union() returns true if the union is not empty.
bool Union( // this = union of two args
const ON_Interval&,
const ON_Interval&
);
};
////////////////////////////////////////////////////////////////
//
// ON_2dPoint
//
class PCL_EXPORTS ON_CLASS ON_2dPoint
{
public:
double x, y;
static const ON_2dPoint Origin; // (0.0,0.0)
static const ON_2dPoint UnsetPoint; // (ON_UNSET_VALUE,ON_UNSET_VALUE)
// use implicit destructor, copy constructor
ON_2dPoint(); // x,y not initialized
ON_2dPoint(double x,double y);
ON_2dPoint(const ON_3dPoint& ); // from 3d point
ON_2dPoint(const ON_4dPoint& ); // from 4d point
ON_2dPoint(const ON_2dVector& ); // from 2d vector
ON_2dPoint(const ON_3dVector& ); // from 3d vector
ON_2dPoint(const double*); // from double[2] array
ON_2dPoint(const class ON_2fPoint&); // from 2f point
ON_2dPoint(const class ON_3fPoint&); // from 3f point
ON_2dPoint(const class ON_4fPoint&); // from 4f point
ON_2dPoint(const class ON_2fVector&); // from 2f point
ON_2dPoint(const class ON_3fVector&); // from 3f point
ON_2dPoint(const float*); // from float[2] array
// (double*) conversion operators
operator double*();
operator const double*() const;
// use implicit operator=(const ON_2dPoint&)
ON_2dPoint& operator=(const ON_3dPoint&);
ON_2dPoint& operator=(const ON_4dPoint&);
ON_2dPoint& operator=(const ON_2dVector&);
ON_2dPoint& operator=(const ON_3dVector&);
ON_2dPoint& operator=(const double*); // point = double[2] support
ON_2dPoint& operator=(const ON_2fPoint&);
ON_2dPoint& operator=(const ON_3fPoint&);
ON_2dPoint& operator=(const ON_4fPoint&);
ON_2dPoint& operator=(const ON_2fVector&);
ON_2dPoint& operator=(const ON_3fVector&);
ON_2dPoint& operator=(const float*); // point = float[2] support
ON_2dPoint& operator*=(double);
ON_2dPoint& operator/=(double);
ON_2dPoint& operator+=(const ON_2dPoint&); // Adding this was a mistake - cannot remove without breaking SDK
ON_2dPoint& operator+=(const ON_2dVector&);
ON_2dPoint& operator+=(const ON_3dVector&); // Adding this was a mistake - cannot remove without breaking SDK
ON_2dPoint& operator-=(const ON_2dPoint&); // Adding this was a mistake - cannot remove without breaking SDK
ON_2dPoint& operator-=(const ON_2dVector&);
ON_2dPoint& operator-=(const ON_3dVector&); // Adding this was a mistake - cannot remove without breaking SDK
ON_2dPoint operator*(int) const;
ON_2dPoint operator/(int) const;
ON_2dPoint operator*(float) const;
ON_2dPoint operator/(float) const;
ON_2dPoint operator*(double) const;
ON_2dPoint operator/(double) const;
ON_2dPoint operator+(const ON_2dPoint&) const;
ON_2dPoint operator+(const ON_2dVector&) const;
ON_2dVector operator-(const ON_2dPoint&) const;
ON_2dPoint operator-(const ON_2dVector&) const;
ON_3dPoint operator+(const ON_3dPoint&) const;
ON_3dPoint operator+(const ON_3dVector&) const;
ON_3dVector operator-(const ON_3dPoint&) const;
ON_3dPoint operator-(const ON_3dVector&) const;
ON_2dPoint operator+(const ON_2fPoint&) const;
ON_2dPoint operator+(const ON_2fVector&) const;
ON_2dVector operator-(const ON_2fPoint&) const;
ON_2dPoint operator-(const ON_2fVector&) const;
ON_3dPoint operator+(const ON_3fPoint&) const;
ON_3dPoint operator+(const ON_3fVector&) const;
ON_3dVector operator-(const ON_3fPoint&) const;
ON_3dPoint operator-(const ON_3fVector&) const;
double operator*(const ON_2dPoint&) const; // dot product for points acting as vectors
double operator*(const ON_2dVector&) const; // dot product for points acting as vectors
double operator*(const ON_4dPoint&) const;
ON_2dPoint operator*(const ON_Xform&) const;
bool operator==(const ON_2dPoint&) const;
bool operator!=(const ON_2dPoint&) const;
// dictionary order comparisons
bool operator<=(const ON_2dPoint&) const;
bool operator>=(const ON_2dPoint&) const;
bool operator<(const ON_2dPoint&) const;
bool operator>(const ON_2dPoint&) const;
// index operators mimic double[2] behavior
double& operator[](int);
double operator[](int) const;
double& operator[](unsigned int);
double operator[](unsigned int) const;
/*
Returns:
False if any coordinate is infinte, a nan, or ON_UNSET_VALUE.
*/
bool IsValid() const;
/*
Returns:
True if every coordinate is ON_UNSET_VALUE.
*/
bool IsUnsetPoint() const;
// set 2d point value
void Set(double x,double y);
double DistanceTo( const ON_2dPoint& ) const;
int MaximumCoordinateIndex() const;
double MaximumCoordinate() const; // absolute value of maximum coordinate
int MinimumCoordinateIndex() const;
double MinimumCoordinate() const; // absolute value of minimum coordinate
void Zero(); // set all coordinates to zero;
// These transform the point in place. The transformation matrix acts on
// the left of the point; i.e., result = transformation*point
void Transform(
const ON_Xform&
);
void Rotate( // rotatation in XY plane
double angle, // angle in radians
const ON_2dPoint& center // center of rotation
);
void Rotate( // rotatation in XY plane
double sin_angle, // sin(angle)
double cos_angle, // cos(angle)
const ON_2dPoint& center // center of rotation
);
};
ON_DECL
ON_2dPoint operator*(int, const ON_2dPoint&);
ON_DECL
ON_2dPoint operator*(float, const ON_2dPoint&);
ON_DECL
ON_2dPoint operator*(double, const ON_2dPoint&);
////////////////////////////////////////////////////////////////
//
// ON_3dPoint
//
class PCL_EXPORTS ON_CLASS ON_3dPoint
{
public:
double x, y, z;
static const ON_3dPoint Origin; // (0.0,0.0,0.0)
static const ON_3dPoint UnsetPoint; // (ON_UNSET_VALUE,ON_UNSET_VALUE,ON_UNSET_VALUE)
// use implicit destructor, copy constructor
ON_3dPoint(); // x,y,z not initialized
ON_3dPoint(double x,double y,double z);
ON_3dPoint(const ON_2dPoint& ); // from 2d point
ON_3dPoint(const ON_4dPoint& ); // from 4d point
ON_3dPoint(const ON_2dVector& ); // from 2d vector
ON_3dPoint(const ON_3dVector& ); // from 3d vector
ON_3dPoint(const double*); // from double[3] array
ON_3dPoint(const class ON_2fPoint&); // from 2f point
ON_3dPoint(const class ON_3fPoint&); // from 3f point
ON_3dPoint(const class ON_4fPoint&); // from 4f point
ON_3dPoint(const class ON_2fVector&); // from 2f point
ON_3dPoint(const class ON_3fVector&); // from 3f point
ON_3dPoint(const float*); // from float[3] array
// (double*) conversion operators
operator double*();
operator const double*() const;
// use implicit operator=(const ON_3dPoint&)
ON_3dPoint& operator=(const ON_2dPoint&);
ON_3dPoint& operator=(const ON_4dPoint&);
ON_3dPoint& operator=(const ON_2dVector&);
ON_3dPoint& operator=(const ON_3dVector&);
ON_3dPoint& operator=(const double*); // point = double[3] support
ON_3dPoint& operator=(const class ON_2fPoint&);
ON_3dPoint& operator=(const class ON_3fPoint&);
ON_3dPoint& operator=(const class ON_4fPoint&);
ON_3dPoint& operator=(const class ON_2fVector&);
ON_3dPoint& operator=(const class ON_3fVector&);
ON_3dPoint& operator=(const float*); // point = float[3] support
ON_3dPoint& operator*=(double);
ON_3dPoint& operator/=(double);
ON_3dPoint& operator+=(const ON_3dPoint&); // Adding this was a mistake - cannot remove without breaking SDK
ON_3dPoint& operator+=(const ON_3dVector&);
ON_3dPoint& operator-=(const ON_3dPoint&); // Adding this was a mistake - cannot remove without breaking SDK
ON_3dPoint& operator-=(const ON_3dVector&);
ON_3dPoint operator*(int) const;
ON_3dPoint operator/(int) const;
ON_3dPoint operator*(float) const;
ON_3dPoint operator/(float) const;
ON_3dPoint operator*(double) const;
ON_3dPoint operator/(double) const;
ON_3dPoint operator+(const ON_3dPoint&) const;
ON_3dPoint operator+(const ON_3dVector&) const;
ON_3dVector operator-(const ON_3dPoint&) const;
ON_3dPoint operator-(const ON_3dVector&) const;
ON_3dPoint operator+(const ON_2dPoint&) const;
ON_3dPoint operator+(const ON_2dVector&) const;
ON_3dVector operator-(const ON_2dPoint&) const;
ON_3dPoint operator-(const ON_2dVector&) const;
ON_3dPoint operator+(const ON_3fPoint&) const;
ON_3dPoint operator+(const ON_3fVector&) const;
ON_3dVector operator-(const ON_3fPoint&) const;
ON_3dPoint operator-(const ON_3fVector&) const;
ON_3dPoint operator+(const ON_2fPoint&) const;
ON_3dPoint operator+(const ON_2fVector&) const;
ON_3dVector operator-(const ON_2fPoint&) const;
ON_3dPoint operator-(const ON_2fVector&) const;
double operator*(const ON_3dPoint&) const; // dot product for points acting as vectors
double operator*(const ON_3dVector&) const; // dot product for points acting as vectors
double operator*(const ON_4dPoint&) const;
ON_3dPoint operator*(const ON_Xform&) const;
bool operator==(const ON_3dPoint&) const;
bool operator!=(const ON_3dPoint&) const;
// dictionary order comparisons
bool operator<=(const ON_3dPoint&) const;
bool operator>=(const ON_3dPoint&) const;
bool operator<(const ON_3dPoint&) const;
bool operator>(const ON_3dPoint&) const;
// index operators mimic double[3] behavior
double& operator[](int);
double operator[](int) const;
double& operator[](unsigned int);
double operator[](unsigned int) const;
/*
Returns:
False if any coordinate is infinte, a nan, or ON_UNSET_VALUE.
*/
bool IsValid() const;
/*
Returns:
True if every coordinate is ON_UNSET_VALUE.
*/
bool IsUnsetPoint() const;
// set 3d point value
void Set(double x,double y,double z);
double DistanceTo( const ON_3dPoint& ) const;
int MaximumCoordinateIndex() const;
double MaximumCoordinate() const; // absolute value of maximum coordinate
int MinimumCoordinateIndex() const;
double MinimumCoordinate() const; // absolute value of minimum coordinate
double Fuzz( double tolerance = ON_ZERO_TOLERANCE ) const; // tolerance to use when comparing 3d points
void Zero(); // set all coordinates to zero;
// These transform the point in place. The transformation matrix acts on
// the left of the point; i.e., result = transformation*point
void Transform(
const ON_Xform&
);
void Rotate(
double angle, // angle in radians
const ON_3dVector& axis, // axis of rotation
const ON_3dPoint& center // center of rotation
);
void Rotate(
double sin_angle, // sin(angle)
double cos_angle, // cos(angle)
const ON_3dVector& axis, // axis of rotation
const ON_3dPoint& center // center of rotation
);
};
ON_DECL
ON_3dPoint operator*(int, const ON_3dPoint&);
ON_DECL
ON_3dPoint operator*(float, const ON_3dPoint&);
ON_DECL
ON_3dPoint operator*(double, const ON_3dPoint&);
////////////////////////////////////////////////////////////////
//
// ON_4dPoint (homogeneous coordinates)
//
class PCL_EXPORTS ON_CLASS ON_4dPoint
{
public:
double x, y, z, w;
// use implicit destructor, copy constructor
ON_4dPoint(); // x,y,z,w not initialized
ON_4dPoint(double x,double y,double z,double w);
ON_4dPoint(const ON_2dPoint& ); // from 2d point
ON_4dPoint(const ON_3dPoint& ); // from 3d point
ON_4dPoint(const ON_2dVector& ); // from 2d vector
ON_4dPoint(const ON_3dVector& ); // from 3d vector
ON_4dPoint(const double*); // from double[4] array
ON_4dPoint(const ON_2fPoint& ); // from 2f point
ON_4dPoint(const ON_3fPoint& ); // from 3f point
ON_4dPoint(const ON_4fPoint& ); // from 3f point
ON_4dPoint(const ON_2fVector& ); // from 2f vector
ON_4dPoint(const ON_3fVector& ); // from 3f vector
ON_4dPoint(const float*); // from float[4] array
// (double*) conversion operators
operator double*();
operator const double*() const;
// use implicit operator=(const ON_4dPoint&)
ON_4dPoint& operator=(const ON_2dPoint&);
ON_4dPoint& operator=(const ON_3dPoint&);
ON_4dPoint& operator=(const ON_2dVector&);
ON_4dPoint& operator=(const ON_3dVector&);
ON_4dPoint& operator=(const double*); // point = double[4] support
ON_4dPoint& operator=(const class ON_2fPoint&);
ON_4dPoint& operator=(const class ON_3fPoint&);
ON_4dPoint& operator=(const class ON_4fPoint&);
ON_4dPoint& operator=(const class ON_2fVector&);
ON_4dPoint& operator=(const class ON_3fVector&);
ON_4dPoint& operator=(const float*); // point = float[4] support
ON_4dPoint& operator*=(double);
ON_4dPoint& operator/=(double);
ON_4dPoint& operator+=(const ON_4dPoint&); // sum w = sqrt(|w1*w2|)
ON_4dPoint& operator-=(const ON_4dPoint&); // difference w = sqrt(|w1*w2|)
ON_4dPoint operator*(double) const;
ON_4dPoint operator/(double) const;
ON_4dPoint operator+(const ON_4dPoint&) const; // sum w = sqrt(|w1*w2|)
ON_4dPoint operator-(const ON_4dPoint&) const; // difference w = sqrt(|w1*w2|)
double operator*(const ON_4dPoint&) const;
ON_4dPoint operator*(const ON_Xform&) const;
// projective comparison
// (i.e., [x,y,z,w] == [c*x,c*y,c*z,c*w] is true for nonzero c)
bool operator==(ON_4dPoint) const;
bool operator!=(const ON_4dPoint&) const;
// index operators mimic double[4] behavior
double& operator[](int);
double operator[](int) const;
double& operator[](unsigned int);
double operator[](unsigned int) const;
/*
Returns:
False if any coordinate is infinte, a nan, or ON_UNSET_VALUE.
*/
bool IsValid() const;
/*
Returns:
True if every coordinate is ON_UNSET_VALUE.
*/
bool IsUnsetPoint() const;
// set 4d point value
void Set(double x,double y,double z,double w);
int MaximumCoordinateIndex() const;
double MaximumCoordinate() const; // absolute value of maximum coordinate
int MinimumCoordinateIndex() const;
double MinimumCoordinate() const; // absolute value of minimum coordinate
void Zero(); // set all 4 coordinates to zero;
bool Normalize(); // set so x^2 + y^2 + z^2 + w^2 = 1
// These transform the point in place. The transformation matrix acts on
// the left of the point; i.e., result = transformation*point
void Transform(
const ON_Xform&
);
};
ON_DECL
ON_4dPoint operator*(double, const ON_4dPoint&);
////////////////////////////////////////////////////////////////
//
// ON_2dVector
//
class PCL_EXPORTS ON_CLASS ON_2dVector
{
public:
double x, y;
static const ON_2dVector ZeroVector; // (0.0,0.0)
static const ON_2dVector XAxis; // (1.0,0.0)
static const ON_2dVector YAxis; // (0.0,1.0)
static const ON_2dVector UnsetVector; // (ON_UNSET_VALUE,ON_UNSET_VALUE)
// Description:
// A index driven function to get unit axis vectors.
// Parameters:
// index - [in] 0 returns (1,0), 1 returns (0,1)
// Returns:
// Unit 2d vector with vector[i] = (i==index)?1:0;
static const ON_2dVector& UnitVector(
int // index
);
// use implicit destructor, copy constructor
ON_2dVector(); // x,y not initialized
ON_2dVector(double x,double y);
ON_2dVector(const ON_3dVector& ); // from 3d vector
ON_2dVector(const ON_2dPoint& ); // from 2d point
ON_2dVector(const ON_3dPoint& ); // from 3d point
ON_2dVector(const double*); // from double[2] array
ON_2dVector(const ON_2fVector& ); // from 2f vector
ON_2dVector(const ON_3fVector& ); // from 3f vector
ON_2dVector(const ON_2fPoint& ); // from 2f point
ON_2dVector(const ON_3fPoint& ); // from 3f point
ON_2dVector(const float*); // from double[2] array
// (double*) conversion operators
operator double*();
operator const double*() const;
// use implicit operator=(const ON_2dVector&)
ON_2dVector& operator=(const ON_3dVector&);
ON_2dVector& operator=(const ON_2dPoint&);
ON_2dVector& operator=(const ON_3dPoint&);
ON_2dVector& operator=(const double*); // vector = double[2] support
ON_2dVector& operator=(const ON_2fVector&);
ON_2dVector& operator=(const ON_3fVector&);
ON_2dVector& operator=(const ON_2fPoint&);
ON_2dVector& operator=(const ON_3fPoint&);
ON_2dVector& operator=(const float*); // vector = float[2] support
ON_2dVector operator-() const;
ON_2dVector& operator*=(double);
ON_2dVector& operator/=(double);
ON_2dVector& operator+=(const ON_2dVector&);
ON_2dVector& operator-=(const ON_2dVector&);
// DO NOT ADD ANY MORE overrides of += or -=
double operator*(const ON_2dVector&) const; // inner (dot) product
double operator*(const ON_2dPoint&) const; // inner (dot) product (point acting as vector)
double operator*(const ON_2fVector&) const; // inner (dot) product
ON_2dVector operator*(int) const;
ON_2dVector operator/(int) const;
ON_2dVector operator*(float) const;
ON_2dVector operator/(float) const;
ON_2dVector operator*(double) const;
ON_2dVector operator/(double) const;
ON_2dVector operator+(const ON_2dVector&) const;
ON_2dPoint operator+(const ON_2dPoint&) const;
ON_2dVector operator-(const ON_2dVector&) const;
ON_2dPoint operator-(const ON_2dPoint&) const;
ON_3dVector operator+(const ON_3dVector&) const;
ON_3dPoint operator+(const ON_3dPoint&) const;
ON_3dVector operator-(const ON_3dVector&) const;
ON_3dPoint operator-(const ON_3dPoint&) const;
ON_2dVector operator+(const ON_2fVector&) const;
ON_2dPoint operator+(const ON_2fPoint&) const;
ON_2dVector operator-(const ON_2fVector&) const;
ON_2dPoint operator-(const ON_2fPoint&) const;
ON_3dVector operator+(const ON_3fVector&) const;
ON_3dPoint operator+(const ON_3fPoint&) const;
ON_3dVector operator-(const ON_3fVector&) const;
ON_3dPoint operator-(const ON_3fPoint&) const;
double operator*(const ON_4dPoint&) const;
ON_2dVector operator*(const ON_Xform&) const;
bool operator==(const ON_2dVector&) const;
bool operator!=(const ON_2dVector&) const;
// dictionary order comparisons
bool operator<=(const ON_2dVector&) const;
bool operator>=(const ON_2dVector&) const;
bool operator<(const ON_2dVector&) const;
bool operator>(const ON_2dVector&) const;
// index operators mimic double[2] behavior
double& operator[](int);
double operator[](int) const;
double& operator[](unsigned int);
double operator[](unsigned int) const;
/*
Returns:
False if any coordinate is infinte, a nan, or ON_UNSET_VALUE.
*/
bool IsValid() const;
/*
Returns:
True if every coordinate is ON_UNSET_VALUE.
*/
bool IsUnsetVector() const;
// set 2d vector value
void Set(double x,double y);
int MaximumCoordinateIndex() const;
double MaximumCoordinate() const; // absolute value of maximum coordinate
int MinimumCoordinateIndex() const;
double MinimumCoordinate() const; // absolute value of minimum coordinate
double LengthSquared() const;
double Length() const;
// Signed area of the parallelagram. The volume element.
// returns x*B.y - y*B.x
double WedgeProduct(const ON_2dVector& B) const;
bool Decompose( // Computes a, b such that this vector = a*X + b*Y
// Returns false if unable to solve for a,b. This happens
// when X,Y is not really a basis.
//
// If X,Y is known to be an orthonormal frame,
// then a = V*X, b = V*Y will compute
// the same result more quickly.
const ON_2dVector&, // X
const ON_2dVector&, // Y
double*, // a
double* // b
) const;
int IsParallelTo(
// returns 1: this and other vectors are parallel
// -1: this and other vectors are anti-parallel
// 0: this and other vectors are not parallel
// or at least one of the vectors is zero
const ON_2dVector& other, // other vector
double angle_tolerance = ON_DEFAULT_ANGLE_TOLERANCE // optional angle tolerance (radians)
) const;
bool IsPerpendicularTo(
// returns true: this and other vectors are perpendicular
// false: this and other vectors are not perpendicular
// or at least one of the vectors is zero
const ON_2dVector& other, // other vector
double angle_tolerance = ON_DEFAULT_ANGLE_TOLERANCE // optional angle tolerance (radians)
) const;
void Zero(); // set all coordinates to zero;
void Reverse(); // negate all coordinates
bool Unitize(); // returns false if vector has zero length
// Description:
// Test a vector to see if it is very short
//
// Parameters:
// tiny_tol - [in] (default = ON_ZERO_TOLERANCE) a nonzero
// value used as the coordinate zero tolerance.
//
// Returns:
// ( fabs(x) <= tiny_tol && fabs(y) <= tiny_tol )
//
bool IsTiny(
double tiny_tol = ON_ZERO_TOLERANCE // tiny_tol
) const;
// Returns:
// true if vector is the zero vector.
bool IsZero() const;
// Returns:
// true if vector is valid and has length 1.
bool IsUnitVector() const;
// set this vector to be perpendicular to another vector
bool PerpendicularTo( // Result is not unitized.
// returns false if input vector is zero
const ON_2dVector&
);
// set this vector to be perpendicular to a line defined by 2 points
bool PerpendicularTo(
const ON_2dPoint&,
const ON_2dPoint&
);
// These transform the vector in place. The transformation matrix acts on
// the left of the vector; i.e., result = transformation*vector
void Transform(
const ON_Xform& // can use ON_Xform here
);
void Rotate(
double angle // angle in radians
);
void Rotate(
double sin_angle, // sin(angle)
double cos_angle // cos(angle)
);
};
ON_DECL
ON_2dVector operator*(int, const ON_2dVector&);
ON_DECL
ON_2dVector operator*(float, const ON_2dVector&);
ON_DECL
ON_2dVector operator*(double, const ON_2dVector&);
///////////////////////////////////////////////////////////////
//
// ON_2dVector utilities
//
ON_DECL
double
ON_DotProduct(
const ON_2dVector&,
const ON_2dVector&
);
ON_DECL
ON_3dVector
ON_CrossProduct(
const ON_2dVector&,
const ON_2dVector&
);
ON_DECL
double
ON_WedgeProduct( // signed area of the parallelagram. Volume element.
const ON_2dVector& A, // returns A.x * B.y - A.y * B.x
const ON_2dVector& B
);
ON_DECL
bool
ON_IsOrthogonalFrame( // true if X, Y are nonzero and mutually perpendicular
const ON_2dVector&, // X
const ON_2dVector& // Y
);
ON_DECL
bool
ON_IsOrthonormalFrame( // true if X, Y are orthogonal and unit length
const ON_2dVector&, // X
const ON_2dVector& // Y
);
ON_DECL
bool
ON_IsRightHandFrame( // true if X, Y are orthonormal and right handed
const ON_2dVector&, // X
const ON_2dVector& // Y
);
////////////////////////////////////////////////////////////////
//
// ON_3dVector
//
class PCL_EXPORTS ON_CLASS ON_3dVector
{
public:
double x, y, z;
static const ON_3dVector ZeroVector; // (0.0,0.0,0.0)
static const ON_3dVector XAxis; // (1.0,0.0,0.0)
static const ON_3dVector YAxis; // (0.0,1.0,0.0)
static const ON_3dVector ZAxis; // (0.0,0.0,1.0)
static const ON_3dVector UnsetVector; // (ON_UNSET_VALUE,ON_UNSET_VALUE,ON_UNSET_VALUE)
// Description:
// A index driven function to get unit axis vectors.
// Parameters:
// index - [in] 0 returns (1,0,0), 1 returns (0,1,0),
// 2 returns (0,0,1)
// Returns:
// Unit 3d vector with vector[i] = (i==index)?1:0;
static const ON_3dVector& UnitVector(
int // index
);
// use implicit destructor, copy constructor
ON_3dVector(); // x,y,z not initialized
ON_3dVector(double x,double y,double z);
ON_3dVector(const ON_2dVector& ); // from 2d vector
ON_3dVector(const ON_2dPoint& ); // from 2d point
ON_3dVector(const ON_3dPoint& ); // from 3d point
ON_3dVector(const double*); // from double[3] array
ON_3dVector(const ON_2fVector& ); // from 2f vector
ON_3dVector(const ON_3fVector& ); // from 3f vector
ON_3dVector(const ON_2fPoint& ); // from 2f point
ON_3dVector(const ON_3fPoint& ); // from 3f point
ON_3dVector(const float*); // from float[3] array
// (double*) conversion operators
operator double*();
operator const double*() const;
// use implicit operator=(const ON_3dVector&)
ON_3dVector& operator=(const ON_2dVector&);
ON_3dVector& operator=(const ON_2dPoint&);
ON_3dVector& operator=(const ON_3dPoint&);
ON_3dVector& operator=(const double*); // vector = double[3] support
ON_3dVector& operator=(const ON_2fVector&);
ON_3dVector& operator=(const ON_3fVector&);
ON_3dVector& operator=(const ON_2fPoint&);
ON_3dVector& operator=(const ON_3fPoint&);
ON_3dVector& operator=(const float*); // vector = float[3] support
ON_3dVector operator-() const;
ON_3dVector& operator*=(double);
ON_3dVector& operator/=(double);
ON_3dVector& operator+=(const ON_3dVector&);
ON_3dVector& operator-=(const ON_3dVector&);
// DO NOT ADD ANY MORE overrides of += or -=
double operator*(const ON_3dVector&) const; // inner (dot) product
double operator*(const ON_3dPoint&) const; // inner (dot) product
double operator*(const ON_3fVector&) const; // inner (dot) product
ON_3dVector operator*(int) const;
ON_3dVector operator/(int) const;
ON_3dVector operator*(float) const;
ON_3dVector operator/(float) const;
ON_3dVector operator*(double) const;
ON_3dVector operator/(double) const;
ON_3dVector operator+(const ON_3dVector&) const;
ON_3dPoint operator+(const ON_3dPoint&) const;
ON_3dVector operator-(const ON_3dVector&) const;
ON_3dPoint operator-(const ON_3dPoint&) const;
ON_3dVector operator+(const ON_2dVector&) const;
ON_3dPoint operator+(const ON_2dPoint&) const;
ON_3dVector operator-(const ON_2dVector&) const;
ON_3dPoint operator-(const ON_2dPoint&) const;
ON_3dVector operator+(const ON_3fVector&) const;
ON_3dPoint operator+(const ON_3fPoint&) const;
ON_3dVector operator-(const ON_3fVector&) const;
ON_3dPoint operator-(const ON_3fPoint&) const;
ON_3dVector operator+(const ON_2fVector&) const;
ON_3dPoint operator+(const ON_2fPoint&) const;
ON_3dVector operator-(const ON_2fVector&) const;
ON_3dPoint operator-(const ON_2fPoint&) const;
double operator*(const ON_4dPoint&) const;
ON_3dVector operator*(const ON_Xform&) const;
bool operator==(const ON_3dVector&) const;
bool operator!=(const ON_3dVector&) const;
// dictionary order comparisons
bool operator<=(const ON_3dVector&) const;
bool operator>=(const ON_3dVector&) const;
bool operator<(const ON_3dVector&) const;
bool operator>(const ON_3dVector&) const;
// index operators mimic double[3] behavior
double& operator[](int);
double operator[](int) const;
double& operator[](unsigned int);
double operator[](unsigned int) const;
/*
Returns:
False if any coordinate is infinte, a nan, or ON_UNSET_VALUE.
*/
bool IsValid() const;
/*
Returns:
True if every coordinate is ON_UNSET_VALUE.
*/
bool IsUnsetVector() const;
// set 3d vector value
void Set(double x,double y,double z);
int MaximumCoordinateIndex() const;
double MaximumCoordinate() const; // absolute value of maximum coordinate
int MinimumCoordinateIndex() const;
double MinimumCoordinate() const; // absolute value of minimum coordinate
double LengthSquared() const;
double Length() const;
bool Decompose( // Computes a, b, c such that this vector = a*X + b*Y + c*Z
// Returns false if unable to solve for a,b,c. This happens
// when X,Y,Z is not really a basis.
//
// If X,Y,Z is known to be an orthonormal frame,
// then a = V*X, b = V*Y, c = V*Z will compute
// the same result more quickly.
const ON_3dVector&, // X
const ON_3dVector&, // Y
const ON_3dVector&, // Z
double*, // a
double*, // b
double* // c
) const;
int IsParallelTo(
// returns 1: this and other vectors are parallel
// -1: this and other vectors are anti-parallel
// 0: this and other vectors are not parallel
// or at least one of the vectors is zero
const ON_3dVector& other, // other vector
double angle_tolerance = ON_DEFAULT_ANGLE_TOLERANCE // optional angle tolerance (radians)
) const;
bool IsPerpendicularTo(
// returns true: this and other vectors are perpendicular
// false: this and other vectors are not perpendicular
// or at least one of the vectors is zero
const ON_3dVector& other, // other vector
double angle_tolerance = ON_DEFAULT_ANGLE_TOLERANCE // optional angle tolerance (radians)
) const;
double Fuzz( double tolerance = ON_ZERO_TOLERANCE ) const; // tolerance to use when comparing 3d vectors
void Zero(); // set all coordinates to zero;
void Reverse(); // negate all coordinates
bool Unitize(); // returns false if vector has zero length
double LengthAndUnitize(); // unitizes and returns initial length
// Description:
// Test a vector to see if it is very short
//
// Parameters:
// tiny_tol - [in] (default = ON_ZERO_TOLERANCE) a nonzero
// value used as the coordinate zero tolerance.
//
// Returns:
// ( fabs(x) <= tiny_tol && fabs(y) <= tiny_tol && fabs(z) <= tiny_tol )
//
bool IsTiny(
double tiny_tol = ON_ZERO_TOLERANCE // tiny_tol
) const;
// Returns:
// true if vector is the zero vector.
bool IsZero() const;
// Returns:
// true if vector is valid and has length 1.
bool IsUnitVector() const;
// set this vector to be perpendicular to another vector
bool PerpendicularTo( // Result is not unitized.
// returns false if input vector is zero
const ON_3dVector&
);
// set this vector to be perpendicular to a plane defined by 3 points
bool PerpendicularTo(
// about 3 times slower than
// ON_3dVector N = ON_CrossProduct(P1-P0,P2-P0);
// N.Unitize();
// returns false if points are coincident or colinear
const ON_3dPoint&, const ON_3dPoint&, const ON_3dPoint&
);
// These transform the vector in place. The transformation matrix acts on
// the left of the vector; i.e., result = transformation*vector
void Transform(
const ON_Xform& // can use ON_Xform here
);
void Rotate(
double angle, // angle in radians
const ON_3dVector& axis // axis of rotation
);
void Rotate(
double sin_angle, // sin(angle)
double cos_angle, // cos(angle)
const ON_3dVector& axis // axis of rotation
);
};
class PCL_EXPORTS ON_CLASS ON_3dRay
{
public:
ON_3dRay();
~ON_3dRay();
ON_3dPoint m_P;
ON_3dVector m_V;
};
/*
Description:
Typically the vector portion is a unit vector and
m_d = -(x*P.x + y*P.y + z*P.z) for a point P on the plane.
*/
class PCL_EXPORTS ON_CLASS ON_PlaneEquation : public ON_3dVector
{
public:
// C++ defaults for construction, destruction, copys, and operator=
// work fine.
static const ON_PlaneEquation UnsetPlaneEquation; // (ON_UNSET_VALUE,ON_UNSET_VALUE,ON_UNSET_VALUE,ON_UNSET_VALUE)
static const ON_PlaneEquation ZeroPlaneEquation; // (0.0,0.0,0.0,0.0)
ON_PlaneEquation();
ON_PlaneEquation(double xx, double yy, double zz, double dd);
/*
Description:
returns true if x, y, z, d are valid, finite doubles.
Remarks:
this function will return true if x, y and z are all zero.
See Also:
ON_PlaneEquation::IsSet().
*/
bool IsValid() const;
/*
Description:
returns true if x, y, z, d are valid, finite doubles and
at least one of x, y or z is not zero.
*/
bool IsSet() const;
/*
Description:
Sets (x,y,z) to a unitized N and then sets
d = -(x*P.x + y*P.y + z*P.z).
Parameters:
P - [in] point on the plane
N - [in] vector perpendicular to the plane
Returns:
true if input is valid.
*/
bool Create( ON_3dPoint P, ON_3dVector N );
/*
Description:
Evaluate the plane at a point.
Parameters:
P - [in]
Returns:
x*P.x + y*P.y + z*P.z + d;
*/
double ValueAt(ON_3dPoint P) const;
double ValueAt(ON_4dPoint P) const;
double ValueAt(ON_3dVector P) const;
double ValueAt(double x, double y, double z) const;
/*
Description:
Evaluate the plane at a list of point values.
Parameters:
Pcount - [in]
number of points
P - [in]
points
value - [in]
If not null, value[] must be an array of length at least Pcount.
The values will be stored in this array. If null, the an array
will be allocated with onmalloc() and returned.
value_range - [out]
If not null, the range of values will be returned here.
Returns:
An array of Pcount values. If the input parameter value was null,
then the array is allocated on the heap using onmalloc() and the
caller is responsible for calling onfree() when finished. If the
input is not valid, null is returned.
*/
double* ValueAt(
int Pcount,
const ON_3fPoint* P,
double* value,
double value_range[2]
) const;
double* ValueAt(
int Pcount,
const ON_3dPoint* P,
double* value,
double value_range[2]
) const;
/*
Description:
This function calculates and evalutes points that
would be exactly on the plane if double precision
aritmetic were mathematically perfect and returns
the largest value of the evaluations.
*/
double ZeroTolerance() const;
/*
Description:
Transform the plane equation so that, if e0 is the initial
equation, e1 is transformed equation and P is a point,
then e0.ValueAt(P) = e1.ValueAt(xform*P).
Parameters:
xform - [in]
Invertable transformation.
Returns:
True if the plane equation was successfully transformed.
False if xform is not invertable or the equation is not
valid.
Remarks:
This function has to invert xform. If you have apply the
same transformation to a bunch of planes, then it will be
more efficient to calculate xform's inverse transpose
and apply the resultingt transformation to the equation's
coefficients as if they were 4d point coordinates.
*/
bool Transform( const ON_Xform& xform );
/*
Description:
Get point on plane that is closest to a given point.
Parameters:
point - [in]
Returns:
A 3d point on the plane that is closest to the input point.
*/
ON_3dPoint ClosestPointTo( ON_3dPoint point ) const;
/*
Description:
Get the minimum value of the plane equation
on a bounding box.
Parameters:
bbox - [in]
Returns:
Minimum value of the plane equation on the bounding box.
*/
double MinimumValueAt(const ON_BoundingBox& bbox) const;
/*
Description:
Get the maximum value of the plane equation
on a bounding box.
Parameters:
bbox - [in]
Returns:
Maximum value of the plane equation on the bounding box.
*/
double MaximumValueAt(const ON_BoundingBox& bbox) const;
/*
Description:
Get the maximum value of the plane equation on a set of 3d points.
Parameters:
bRational - [in]
False if the points are euclidean (x,y,z)
True if the points are homogenous rational (x,y,z,w)
(x/w,y/w,z/w) is used to evaluate the value.
point_count - [in]
point_stride - [in]
i-th point's x coordinate = points[i*point_stride]
points - [in]
coordinates of points
stop_value - [in]
If stop_value is valid and not ON_UNSET_VALUE, then the
evaulation stops if a value > stop_value is found.
If stop_value = ON_UNSET_VALUE, then stop_value is ignored.
Returns:
Maximum value of the plane equation on the point list.
If the input is not valid, then ON_UNSET_VALUE is returned.
*/
double MaximumValueAt(
bool bRational,
int point_count,
int point_stride,
const double* points,
double stop_value
) const;
/*
Description:
Get the minimum value of the plane equation on a set of 3d points.
Parameters:
bRational - [in]
False if the points are euclidean (x,y,z)
True if the points are homogenous rational (x,y,z,w)
(x/w,y/w,z/w) is used to evaluate the value.
point_count - [in]
point_stride - [in]
i-th point's x coordinate = points[i*point_stride]
points - [in]
coordinates of points
stop_value - [in]
If stop_value is valid and not ON_UNSET_VALUE, then the
evaulation stops if a value < stop_value is found.
If stop_value = ON_UNSET_VALUE, then stop_value is ignored.
Returns:
Maximum value of the plane equation on the point list.
If the input is not valid, then ON_UNSET_VALUE is returned.
*/
double MinimumValueAt(
bool bRational,
int point_count,
int point_stride,
const double* points,
double stop_value
) const;
/*
Description:
Get the maximum absolute value of the plane equation
on a set of 3d points.
Parameters:
bRational - [in]
False if the points are euclidean (x,y,z)
True if the points are homogenous rational (x,y,z,w)
(x/w,y/w,z/w) is used to evaluate the value.
point_count - [in]
point_stride - [in]
i-th point's x coordinate = points[i*point_stride]
points - [in]
coordinates of points
stop_value - [in]
If stop_value >= 0.0, then the evaulation stops if an
absolute value > stop_value is found. If stop_value < 0.0
or stop_value is invalid, then stop_value is ignored.
Returns:
Maximum value of the plane equation on the point list.
If the input is not valid, then ON_UNSET_VALUE is returned.
*/
double MaximumAbsoluteValueAt(
bool bRational,
int point_count,
int point_stride,
const double* points,
double stop_value
) const;
/*
Description:
Test points on a bezier curve to see if they are near the plane.
Parameters:
bezcrv - [in]
s0 - [in]
s1 - [in] the interval from s0 to s1 is tested (s0 < s1)
sample_count - [in] number of interior points to test.
Numbers like 1, 3, 7, 15, ... work best.
endpoint_tolerance - [in] If >= 0, then the end points are
tested to see if the distance from the endpoints
is <= endpoint_tolerance.
interior_tolerance - [in] (>=0 and >=endpoint_tolerance)
This tolerance is used to test the interior sample points.
smin - [put] If not NULL, *smin = bezier parameter of nearest
test point.
smax - [put] If not NULL, *smax = bezier parameter of farthest
test point. If false is returned, this is the
parameter of the test point that failed.
Returns:
True if all the tested points passed the tolerance test.
False if at least one tested point failed the tolerance test.
(The test terminates when the first failure is encountered.)
*/
bool IsNearerThan(
const class ON_BezierCurve& bezcrv,
double s0,
double s1,
int sample_count,
double endpoint_tolerance,
double interior_tolerance,
double* smin,
double* smax
) const;
bool operator==(const ON_PlaneEquation&) const;
bool operator!=(const ON_PlaneEquation&) const;
double d; // 4th coefficient of the plane equation.
};
ON_DECL
ON_3dVector operator*(int, const ON_3dVector&);
ON_DECL
ON_3dVector operator*(float, const ON_3dVector&);
ON_DECL
ON_3dVector operator*(double, const ON_3dVector&);
///////////////////////////////////////////////////////////////
//
// ON_3dVector utilities
//
ON_DECL
double
ON_DotProduct(
const ON_3dVector&,
const ON_3dVector&
);
ON_DECL
ON_3dVector
ON_CrossProduct(
const ON_3dVector&,
const ON_3dVector&
);
ON_DECL
ON_3dVector
ON_CrossProduct( // 3d cross product for old fashioned arrays
const double*, // array of 3d doubles
const double* // array of 3d doubles
);
ON_DECL
double
ON_TripleProduct(
const ON_3dVector&,
const ON_3dVector&,
const ON_3dVector&
);
ON_DECL
double
ON_TripleProduct( // 3d triple product for old fashioned arrays
const double*, // array of 3d doubles
const double*, // array of 3d doubles
const double* // array of 3d doubles
);
ON_DECL
bool
ON_IsOrthogonalFrame( // true if X, Y, Z are nonzero and mutually perpendicular
const ON_3dVector&, // X
const ON_3dVector&, // Y
const ON_3dVector& // Z
);
ON_DECL
bool
ON_IsOrthonormalFrame( // true if X, Y, Z are orthogonal and unit length
const ON_3dVector&, // X
const ON_3dVector&, // Y
const ON_3dVector& // Z
);
ON_DECL
bool
ON_IsRightHandFrame( // true if X, Y, Z are orthonormal and right handed
const ON_3dVector&, // X
const ON_3dVector&, // Y
const ON_3dVector& // Z
);
///////////////////////////////////////////////////////////////
//
// common points and vectors
//
// ON_unset_point is obsolete - use ON_3dPoint::UnsetPoint
#define ON_unset_point ON_UNSET_POINT
// ON_UNSET_POINT is OBSOLETE - use ON_3dPoint::UnsetPoint
extern ON_EXTERN_DECL const ON_3dPoint ON_UNSET_POINT; // (ON_UNSET_VALUE,ON_UNSET_VALUE,ON_UNSET_VALUE)
// ON_UNSET_VECTOR is OBSOLETE - use ON_3dPoint::UnsetVector
extern ON_EXTERN_DECL const ON_3dVector ON_UNSET_VECTOR; // (ON_UNSET_VALUE,ON_UNSET_VALUE,ON_UNSET_VALUE)
// ON_origin is OBSOLETE - use ON_3dPoint::Origin
extern ON_EXTERN_DECL const ON_3dPoint ON_origin; // (0.0, 0.0, 0.0)
// ON_xaxis is OBSOLETE - use ON_3dPoint::XAxis
extern ON_EXTERN_DECL const ON_3dVector ON_xaxis; // (1.0, 0.0, 0.0)
// ON_yaxis is OBSOLETE - use ON_3dPoint::YAxis
extern ON_EXTERN_DECL const ON_3dVector ON_yaxis; // (0.0, 1.0, 0.0)
// ON_zaxis is OBSOLETE - use ON_3dPoint::ZAxis
extern ON_EXTERN_DECL const ON_3dVector ON_zaxis; // (0.0, 0.0, 1.0)
#include "opennurbs_fpoint.h"
////////////////////////////////////////////////////////////////
//
// ON_SurfaceCurvature
//
class PCL_EXPORTS ON_CLASS ON_SurfaceCurvature
{
public:
double k1, k2; // principal curvatures
double GaussianCurvature() const;
double MeanCurvature() const;
double MinimumRadius() const;
double MaximumRadius() const;
};
#endif
ON_2dPoint
Definition opennurbs_point.h:267
ON_2dPoint::operator=
ON_2dPoint & operator=(const double *)
ON_2dPoint::operator=
ON_2dPoint & operator=(const ON_3dVector &)
ON_2dPoint::operator-
ON_3dPoint operator-(const ON_3dVector &) const
ON_2dPoint::operator*
ON_2dPoint operator*(float) const
ON_2dPoint::operator-
ON_2dPoint operator-(const ON_2fVector &) const
ON_2dPoint::MaximumCoordinateIndex
int MaximumCoordinateIndex() const
ON_2dPoint::IsValid
bool IsValid() const
ON_2dPoint::operator*
double operator*(const ON_4dPoint &) const
ON_2dPoint::IsUnsetPoint
bool IsUnsetPoint() const
ON_2dPoint::operator==
bool operator==(const ON_2dPoint &) const
ON_2dPoint::operator+=
ON_2dPoint & operator+=(const ON_2dVector &)
ON_2dPoint::operator*
ON_2dPoint operator*(const ON_Xform &) const
ON_2dPoint::operator=
ON_2dPoint & operator=(const ON_4fPoint &)
ON_2dPoint::operator*
double operator*(const ON_2dVector &) const
ON_2dPoint::operator!=
bool operator!=(const ON_2dPoint &) const
ON_2dPoint::ON_2dPoint
ON_2dPoint(const class ON_2fPoint &)
ON_2dPoint::operator=
ON_2dPoint & operator=(const ON_2fVector &)
ON_2dPoint::operator-
ON_3dPoint operator-(const ON_3fVector &) const
ON_2dPoint::operator-
ON_3dVector operator-(const ON_3dPoint &) const
ON_2dPoint::MinimumCoordinateIndex
int MinimumCoordinateIndex() const
ON_2dPoint::Rotate
void Rotate(double angle, const ON_2dPoint &center)
ON_2dPoint::operator=
ON_2dPoint & operator=(const ON_2dVector &)
ON_2dPoint::operator[]
double & operator[](unsigned int)
ON_2dPoint::ON_2dPoint
ON_2dPoint(const ON_2dVector &)
ON_2dPoint::operator-=
ON_2dPoint & operator-=(const ON_2dVector &)
ON_2dPoint::operator+
ON_2dPoint operator+(const ON_2dPoint &) const
ON_2dPoint::Rotate
void Rotate(double sin_angle, double cos_angle, const ON_2dPoint &center)
ON_2dPoint::Origin
static const ON_2dPoint Origin
Definition opennurbs_point.h:271
ON_2dPoint::operator-
ON_2dVector operator-(const ON_2fPoint &) const
ON_2dPoint::operator+
ON_3dPoint operator+(const ON_3fVector &) const
ON_2dPoint::ON_2dPoint
ON_2dPoint(const double *)
ON_2dPoint::ON_2dPoint
ON_2dPoint(const class ON_3fVector &)
ON_2dPoint::operator/=
ON_2dPoint & operator/=(double)
ON_2dPoint::operator+
ON_3dPoint operator+(const ON_3dPoint &) const
ON_2dPoint::operator-
ON_2dVector operator-(const ON_2dPoint &) const
ON_2dPoint::operator=
ON_2dPoint & operator=(const ON_4dPoint &)
ON_2dPoint::operator+=
ON_2dPoint & operator+=(const ON_3dVector &)
ON_2dPoint::operator-
ON_2dPoint operator-(const ON_2dVector &) const
ON_2dPoint::operator+
ON_3dPoint operator+(const ON_3fPoint &) const
ON_2dPoint::operator+
ON_3dPoint operator+(const ON_3dVector &) const
ON_2dPoint::operator=
ON_2dPoint & operator=(const ON_3fPoint &)
ON_2dPoint::operator=
ON_2dPoint & operator=(const ON_2fPoint &)
ON_2dPoint::operator+
ON_2dPoint operator+(const ON_2fPoint &) const
ON_2dPoint::MaximumCoordinate
double MaximumCoordinate() const
ON_2dPoint::operator*
double operator*(const ON_2dPoint &) const
ON_2dPoint::operator*
ON_2dPoint operator*(int) const
ON_2dPoint::MinimumCoordinate
double MinimumCoordinate() const
ON_2dPoint::operator/
ON_2dPoint operator/(float) const
ON_2dPoint::operator-
ON_3dVector operator-(const ON_3fPoint &) const
ON_2dPoint::operator[]
double & operator[](int)
ON_2dPoint::operator*=
ON_2dPoint & operator*=(double)
ON_2dPoint::operator[]
double operator[](int) const
ON_2dPoint::Transform
void Transform(const ON_Xform &)
ON_2dPoint::operator=
ON_2dPoint & operator=(const ON_3fVector &)
ON_2dPoint::x
double x
Definition opennurbs_point.h:269
ON_2dPoint::ON_2dPoint
ON_2dPoint(const ON_4dPoint &)
ON_2dPoint::operator/
ON_2dPoint operator/(int) const
ON_2dPoint::operator>=
bool operator>=(const ON_2dPoint &) const
ON_2dPoint::DistanceTo
double DistanceTo(const ON_2dPoint &) const
ON_2dPoint::ON_2dPoint
ON_2dPoint(const class ON_2fVector &)
ON_2dPoint::operator[]
double operator[](unsigned int) const
ON_2dPoint::operator+
ON_2dPoint operator+(const ON_2dVector &) const
ON_2dPoint::Zero
void Zero()
ON_2dPoint::operator/
ON_2dPoint operator/(double) const
ON_2dPoint::operator<=
bool operator<=(const ON_2dPoint &) const
ON_2dPoint::UnsetPoint
static const ON_2dPoint UnsetPoint
Definition opennurbs_point.h:272
ON_2dPoint::ON_2dPoint
ON_2dPoint(double x, double y)
ON_2dPoint::operator>
bool operator>(const ON_2dPoint &) const
ON_2dPoint::operator=
ON_2dPoint & operator=(const ON_3dPoint &)
ON_2dPoint::operator<
bool operator<(const ON_2dPoint &) const
ON_2dPoint::ON_2dPoint
ON_2dPoint(const class ON_3fPoint &)
ON_2dPoint::ON_2dPoint
ON_2dPoint(const ON_3dPoint &)
ON_2dPoint::operator-=
ON_2dPoint & operator-=(const ON_2dPoint &)
ON_2dPoint::operator+
ON_2dPoint operator+(const ON_2fVector &) const
ON_2dPoint::ON_2dPoint
ON_2dPoint(const class ON_4fPoint &)
ON_2dPoint::operator*
ON_2dPoint operator*(double) const
ON_2dPoint::ON_2dPoint
ON_2dPoint(const ON_3dVector &)
ON_2dPoint::Set
void Set(double x, double y)
ON_2dPoint::ON_2dPoint
ON_2dPoint(const float *)
ON_2dPoint::operator-=
ON_2dPoint & operator-=(const ON_3dVector &)
ON_2dPoint::ON_2dPoint
ON_2dPoint()
ON_2dPoint::operator=
ON_2dPoint & operator=(const float *)
ON_2dPoint::operator+=
ON_2dPoint & operator+=(const ON_2dPoint &)
ON_2dVector
Definition opennurbs_point.h:675
ON_2dVector::x
double x
Definition opennurbs_point.h:677
ON_2dVector::operator+
ON_3dVector operator+(const ON_3dVector &) const
ON_2dVector::PerpendicularTo
bool PerpendicularTo(const ON_2dVector &)
ON_2dVector::IsTiny
bool IsTiny(double tiny_tol=ON_ZERO_TOLERANCE) const
ON_2dVector::ON_2dVector
ON_2dVector(const ON_2fPoint &)
ON_2dVector::operator=
ON_2dVector & operator=(const ON_2dPoint &)
ON_2dVector::operator=
ON_2dVector & operator=(const ON_3dPoint &)
ON_2dVector::UnitVector
static const ON_2dVector & UnitVector(int)
ON_2dVector::IsPerpendicularTo
bool IsPerpendicularTo(const ON_2dVector &other, double angle_tolerance=ON_DEFAULT_ANGLE_TOLERANCE) const
ON_2dVector::Length
double Length() const
ON_2dVector::Rotate
void Rotate(double sin_angle, double cos_angle)
ON_2dVector::operator-
ON_3dVector operator-(const ON_3fVector &) const
ON_2dVector::operator*
double operator*(const ON_2dPoint &) const
ON_2dVector::Transform
void Transform(const ON_Xform &)
ON_2dVector::ON_2dVector
ON_2dVector(double x, double y)
ON_2dVector::operator==
bool operator==(const ON_2dVector &) const
ON_2dVector::IsUnsetVector
bool IsUnsetVector() const
ON_2dVector::operator+
ON_2dVector operator+(const ON_2fVector &) const
ON_2dVector::operator[]
double & operator[](unsigned int)
ON_2dVector::operator=
ON_2dVector & operator=(const ON_2fVector &)
ON_2dVector::operator-
ON_3dVector operator-(const ON_3dVector &) const
ON_2dVector::PerpendicularTo
bool PerpendicularTo(const ON_2dPoint &, const ON_2dPoint &)
ON_2dVector::UnsetVector
static const ON_2dVector UnsetVector
Definition opennurbs_point.h:682
ON_2dVector::ZeroVector
static const ON_2dVector ZeroVector
Definition opennurbs_point.h:679
ON_2dVector::Unitize
bool Unitize()
ON_2dVector::operator+
ON_2dPoint operator+(const ON_2dPoint &) const
ON_2dVector::YAxis
static const ON_2dVector YAxis
Definition opennurbs_point.h:681
ON_2dVector::operator*
ON_2dVector operator*(float) const
ON_2dVector::operator-
ON_3dPoint operator-(const ON_3dPoint &) const
ON_2dVector::WedgeProduct
double WedgeProduct(const ON_2dVector &B) const
ON_2dVector::Rotate
void Rotate(double angle)
ON_2dVector::operator+=
ON_2dVector & operator+=(const ON_2dVector &)
ON_2dVector::operator=
ON_2dVector & operator=(const float *)
ON_2dVector::operator*
double operator*(const ON_2dVector &) const
ON_2dVector::ON_2dVector
ON_2dVector(const double *)
ON_2dVector::operator-
ON_2dVector operator-() const
ON_2dVector::operator[]
double operator[](int) const
ON_2dVector::IsParallelTo
int IsParallelTo(const ON_2dVector &other, double angle_tolerance=ON_DEFAULT_ANGLE_TOLERANCE) const
ON_2dVector::operator-
ON_2dPoint operator-(const ON_2fPoint &) const
ON_2dVector::operator*
double operator*(const ON_4dPoint &) const
ON_2dVector::IsZero
bool IsZero() const
ON_2dVector::ON_2dVector
ON_2dVector(const float *)
ON_2dVector::operator+
ON_3dPoint operator+(const ON_3fPoint &) const
ON_2dVector::operator-
ON_2dPoint operator-(const ON_2dPoint &) const
ON_2dVector::operator[]
double & operator[](int)
ON_2dVector::ON_2dVector
ON_2dVector(const ON_3dPoint &)
ON_2dVector::MaximumCoordinate
double MaximumCoordinate() const
ON_2dVector::operator*=
ON_2dVector & operator*=(double)
ON_2dVector::MaximumCoordinateIndex
int MaximumCoordinateIndex() const
ON_2dVector::operator+
ON_3dPoint operator+(const ON_3dPoint &) const
ON_2dVector::operator>=
bool operator>=(const ON_2dVector &) const
ON_2dVector::operator*
ON_2dVector operator*(double) const
ON_2dVector::operator+
ON_2dVector operator+(const ON_2dVector &) const
ON_2dVector::operator/
ON_2dVector operator/(double) const
ON_2dVector::operator=
ON_2dVector & operator=(const ON_3fPoint &)
ON_2dVector::operator=
ON_2dVector & operator=(const ON_3dVector &)
ON_2dVector::operator<
bool operator<(const ON_2dVector &) const
ON_2dVector::Zero
void Zero()
ON_2dVector::operator[]
double operator[](unsigned int) const
ON_2dVector::IsUnitVector
bool IsUnitVector() const
ON_2dVector::XAxis
static const ON_2dVector XAxis
Definition opennurbs_point.h:680
ON_2dVector::operator=
ON_2dVector & operator=(const double *)
ON_2dVector::operator*
double operator*(const ON_2fVector &) const
ON_2dVector::operator/
ON_2dVector operator/(float) const
ON_2dVector::operator>
bool operator>(const ON_2dVector &) const
ON_2dVector::LengthSquared
double LengthSquared() const
ON_2dVector::operator-=
ON_2dVector & operator-=(const ON_2dVector &)
ON_2dVector::MinimumCoordinateIndex
int MinimumCoordinateIndex() const
ON_2dVector::operator=
ON_2dVector & operator=(const ON_2fPoint &)
ON_2dVector::ON_2dVector
ON_2dVector(const ON_3dVector &)
ON_2dVector::operator/
ON_2dVector operator/(int) const
ON_2dVector::operator/=
ON_2dVector & operator/=(double)
ON_2dVector::operator=
ON_2dVector & operator=(const ON_3fVector &)
ON_2dVector::operator<=
bool operator<=(const ON_2dVector &) const
ON_2dVector::MinimumCoordinate
double MinimumCoordinate() const
ON_2dVector::ON_2dVector
ON_2dVector(const ON_3fPoint &)
ON_2dVector::operator+
ON_3dVector operator+(const ON_3fVector &) const
ON_2dVector::IsValid
bool IsValid() const
ON_2dVector::Reverse
void Reverse()
ON_2dVector::operator!=
bool operator!=(const ON_2dVector &) const
ON_2dVector::operator-
ON_2dVector operator-(const ON_2fVector &) const
ON_2dVector::ON_2dVector
ON_2dVector()
ON_2dVector::operator-
ON_2dVector operator-(const ON_2dVector &) const
ON_2dVector::operator-
ON_3dPoint operator-(const ON_3fPoint &) const
ON_2dVector::Set
void Set(double x, double y)
ON_2dVector::operator*
ON_2dVector operator*(const ON_Xform &) const
ON_2dVector::operator*
ON_2dVector operator*(int) const
ON_2dVector::ON_2dVector
ON_2dVector(const ON_2dPoint &)
ON_2dVector::Decompose
bool Decompose(const ON_2dVector &, const ON_2dVector &, double *, double *) const
ON_2dVector::ON_2dVector
ON_2dVector(const ON_2fVector &)
ON_2dVector::ON_2dVector
ON_2dVector(const ON_3fVector &)
ON_2dVector::operator+
ON_2dPoint operator+(const ON_2fPoint &) const
ON_2fPoint
Definition opennurbs_fpoint.h:39
ON_2fVector
Definition opennurbs_fpoint.h:400
ON_3dPoint
Definition opennurbs_point.h:419
ON_3dPoint::operator*
double operator*(const ON_3dPoint &) const
ON_3dPoint::operator*=
ON_3dPoint & operator*=(double)
ON_3dPoint::ON_3dPoint
ON_3dPoint(const ON_2dPoint &)
ON_3dPoint::ON_3dPoint
ON_3dPoint(const class ON_3fPoint &)
ON_3dPoint::operator=
ON_3dPoint & operator=(const ON_2dVector &)
ON_3dPoint::operator*
double operator*(const ON_3dVector &) const
ON_3dPoint::MaximumCoordinateIndex
int MaximumCoordinateIndex() const
ON_3dPoint::operator-
ON_3dVector operator-(const ON_3dPoint &) const
ON_3dPoint::operator=
ON_3dPoint & operator=(const ON_3dVector &)
ON_3dPoint::ON_3dPoint
ON_3dPoint(const ON_4dPoint &)
ON_3dPoint::operator==
bool operator==(const ON_3dPoint &) const
ON_3dPoint::operator+
ON_3dPoint operator+(const ON_2fPoint &) const
ON_3dPoint::ON_3dPoint
ON_3dPoint(const class ON_2fVector &)
ON_3dPoint::Rotate
void Rotate(double sin_angle, double cos_angle, const ON_3dVector &axis, const ON_3dPoint &center)
ON_3dPoint::ON_3dPoint
ON_3dPoint(double x, double y, double z)
ON_3dPoint::operator-
ON_3dVector operator-(const ON_3fPoint &) const
ON_3dPoint::operator-=
ON_3dPoint & operator-=(const ON_3dPoint &)
ON_3dPoint::Transform
void Transform(const ON_Xform &)
ON_3dPoint::ON_3dPoint
ON_3dPoint(const double *)
ON_3dPoint::operator=
ON_3dPoint & operator=(const class ON_2fVector &)
ON_3dPoint::operator*
ON_3dPoint operator*(float) const
ON_3dPoint::operator/
ON_3dPoint operator/(int) const
ON_3dPoint::DistanceTo
double DistanceTo(const ON_3dPoint &) const
ON_3dPoint::Rotate
void Rotate(double angle, const ON_3dVector &axis, const ON_3dPoint &center)
ON_3dPoint::operator<=
bool operator<=(const ON_3dPoint &) const
ON_3dPoint::operator=
ON_3dPoint & operator=(const class ON_3fVector &)
ON_3dPoint::operator[]
double operator[](int) const
ON_3dPoint::operator-
ON_3dVector operator-(const ON_2fPoint &) const
ON_3dPoint::operator+
ON_3dPoint operator+(const ON_2dVector &) const
ON_3dPoint::operator/
ON_3dPoint operator/(float) const
ON_3dPoint::operator+
ON_3dPoint operator+(const ON_2fVector &) const
ON_3dPoint::IsValid
bool IsValid() const
ON_3dPoint::operator*
ON_3dPoint operator*(int) const
ON_3dPoint::operator-
ON_3dVector operator-(const ON_2dPoint &) const
ON_3dPoint::operator*
ON_3dPoint operator*(const ON_Xform &) const
ON_3dPoint::operator[]
double operator[](unsigned int) const
ON_3dPoint::MinimumCoordinate
double MinimumCoordinate() const
ON_3dPoint::operator=
ON_3dPoint & operator=(const double *)
ON_3dPoint::operator/
ON_3dPoint operator/(double) const
ON_3dPoint::operator+=
ON_3dPoint & operator+=(const ON_3dVector &)
ON_3dPoint::operator>
bool operator>(const ON_3dPoint &) const
ON_3dPoint::Set
void Set(double x, double y, double z)
ON_3dPoint::operator*
double operator*(const ON_4dPoint &) const
ON_3dPoint::UnsetPoint
static const ON_3dPoint UnsetPoint
Definition opennurbs_point.h:424
ON_3dPoint::operator=
ON_3dPoint & operator=(const class ON_4fPoint &)
ON_3dPoint::operator/=
ON_3dPoint & operator/=(double)
ON_3dPoint::operator+
ON_3dPoint operator+(const ON_2dPoint &) const
ON_3dPoint::operator=
ON_3dPoint & operator=(const float *)
ON_3dPoint::operator+=
ON_3dPoint & operator+=(const ON_3dPoint &)
ON_3dPoint::operator!=
bool operator!=(const ON_3dPoint &) const
ON_3dPoint::IsUnsetPoint
bool IsUnsetPoint() const
ON_3dPoint::operator=
ON_3dPoint & operator=(const class ON_3fPoint &)
ON_3dPoint::operator-
ON_3dPoint operator-(const ON_2fVector &) const
ON_3dPoint::operator[]
double & operator[](int)
ON_3dPoint::operator+
ON_3dPoint operator+(const ON_3fPoint &) const
ON_3dPoint::operator>=
bool operator>=(const ON_3dPoint &) const
ON_3dPoint::x
double x
Definition opennurbs_point.h:421
ON_3dPoint::ON_3dPoint
ON_3dPoint(const class ON_4fPoint &)
ON_3dPoint::ON_3dPoint
ON_3dPoint(const ON_2dVector &)
ON_3dPoint::ON_3dPoint
ON_3dPoint()
ON_3dPoint::Zero
void Zero()
ON_3dPoint::operator-
ON_3dPoint operator-(const ON_2dVector &) const
ON_3dPoint::operator-=
ON_3dPoint & operator-=(const ON_3dVector &)
ON_3dPoint::ON_3dPoint
ON_3dPoint(const class ON_2fPoint &)
ON_3dPoint::ON_3dPoint
ON_3dPoint(const class ON_3fVector &)
ON_3dPoint::MinimumCoordinateIndex
int MinimumCoordinateIndex() const
ON_3dPoint::operator=
ON_3dPoint & operator=(const ON_4dPoint &)
ON_3dPoint::operator-
ON_3dPoint operator-(const ON_3fVector &) const
ON_3dPoint::operator<
bool operator<(const ON_3dPoint &) const
ON_3dPoint::ON_3dPoint
ON_3dPoint(const ON_3dVector &)
ON_3dPoint::operator=
ON_3dPoint & operator=(const ON_2dPoint &)
ON_3dPoint::operator+
ON_3dPoint operator+(const ON_3dPoint &) const
ON_3dPoint::Origin
static const ON_3dPoint Origin
Definition opennurbs_point.h:423
ON_3dPoint::operator-
ON_3dPoint operator-(const ON_3dVector &) const
ON_3dPoint::operator=
ON_3dPoint & operator=(const class ON_2fPoint &)
ON_3dPoint::Fuzz
double Fuzz(double tolerance=ON_ZERO_TOLERANCE) const
ON_3dPoint::operator*
ON_3dPoint operator*(double) const
ON_3dPoint::operator+
ON_3dPoint operator+(const ON_3dVector &) const
ON_3dPoint::MaximumCoordinate
double MaximumCoordinate() const
ON_3dPoint::operator[]
double & operator[](unsigned int)
ON_3dPoint::ON_3dPoint
ON_3dPoint(const float *)
ON_3dPoint::operator+
ON_3dPoint operator+(const ON_3fVector &) const
ON_3dRay
Definition opennurbs_point.h:1178
ON_3dRay::ON_3dRay
ON_3dRay()
ON_3dRay::m_P
ON_3dPoint m_P
Definition opennurbs_point.h:1183
ON_3dRay::~ON_3dRay
~ON_3dRay()
ON_3dRay::m_V
ON_3dVector m_V
Definition opennurbs_point.h:1184
ON_3dVector
Definition opennurbs_point.h:953
ON_3dVector::PerpendicularTo
bool PerpendicularTo(const ON_3dVector &)
ON_3dVector::operator/
ON_3dVector operator/(double) const
ON_3dVector::operator=
ON_3dVector & operator=(const float *)
ON_3dVector::operator=
ON_3dVector & operator=(const ON_2fVector &)
ON_3dVector::Decompose
bool Decompose(const ON_3dVector &, const ON_3dVector &, const ON_3dVector &, double *, double *, double *) const
ON_3dVector::IsValid
bool IsValid() const
ON_3dVector::operator-
ON_3dVector operator-() const
ON_3dVector::Reverse
void Reverse()
ON_3dVector::operator=
ON_3dVector & operator=(const ON_2fPoint &)
ON_3dVector::operator>
bool operator>(const ON_3dVector &) const
ON_3dVector::operator+
ON_3dPoint operator+(const ON_2dPoint &) const
ON_3dVector::operator*
ON_3dVector operator*(double) const
ON_3dVector::operator<=
bool operator<=(const ON_3dVector &) const
ON_3dVector::ZeroVector
static const ON_3dVector ZeroVector
Definition opennurbs_point.h:957
ON_3dVector::operator*
ON_3dVector operator*(const ON_Xform &) const
ON_3dVector::operator-
ON_3dPoint operator-(const ON_3dPoint &) const
ON_3dVector::operator-
ON_3dPoint operator-(const ON_2fPoint &) const
ON_3dVector::operator[]
double & operator[](unsigned int)
ON_3dVector::ZAxis
static const ON_3dVector ZAxis
Definition opennurbs_point.h:960
ON_3dVector::operator<
bool operator<(const ON_3dVector &) const
ON_3dVector::Transform
void Transform(const ON_Xform &)
ON_3dVector::operator/
ON_3dVector operator/(int) const
ON_3dVector::ON_3dVector
ON_3dVector()
ON_3dVector::operator[]
double operator[](unsigned int) const
ON_3dVector::IsParallelTo
int IsParallelTo(const ON_3dVector &other, double angle_tolerance=ON_DEFAULT_ANGLE_TOLERANCE) const
ON_3dVector::operator+
ON_3dPoint operator+(const ON_3dPoint &) const
ON_3dVector::UnitVector
static const ON_3dVector & UnitVector(int)
ON_3dVector::LengthAndUnitize
double LengthAndUnitize()
ON_3dVector::operator[]
double & operator[](int)
ON_3dVector::XAxis
static const ON_3dVector XAxis
Definition opennurbs_point.h:958
ON_3dVector::x
double x
Definition opennurbs_point.h:955
ON_3dVector::operator!=
bool operator!=(const ON_3dVector &) const
ON_3dVector::operator-
ON_3dVector operator-(const ON_3fVector &) const
ON_3dVector::operator*
double operator*(const ON_3dVector &) const
ON_3dVector::operator*
double operator*(const ON_3dPoint &) const
ON_3dVector::Rotate
void Rotate(double sin_angle, double cos_angle, const ON_3dVector &axis)
ON_3dVector::ON_3dVector
ON_3dVector(const float *)
ON_3dVector::operator-
ON_3dPoint operator-(const ON_2dPoint &) const
ON_3dVector::operator+
ON_3dVector operator+(const ON_2fVector &) const
ON_3dVector::IsUnsetVector
bool IsUnsetVector() const
ON_3dVector::ON_3dVector
ON_3dVector(const ON_2fVector &)
ON_3dVector::ON_3dVector
ON_3dVector(const ON_3fVector &)
ON_3dVector::ON_3dVector
ON_3dVector(const ON_3dPoint &)
ON_3dVector::operator+=
ON_3dVector & operator+=(const ON_3dVector &)
ON_3dVector::operator-=
ON_3dVector & operator-=(const ON_3dVector &)
ON_3dVector::operator*
ON_3dVector operator*(float) const
ON_3dVector::operator+
ON_3dVector operator+(const ON_3fVector &) const
ON_3dVector::MinimumCoordinate
double MinimumCoordinate() const
ON_3dVector::operator[]
double operator[](int) const
ON_3dVector::operator/
ON_3dVector operator/(float) const
ON_3dVector::operator=
ON_3dVector & operator=(const ON_3fPoint &)
ON_3dVector::ON_3dVector
ON_3dVector(const ON_2fPoint &)
ON_3dVector::MaximumCoordinateIndex
int MaximumCoordinateIndex() const
ON_3dVector::operator/=
ON_3dVector & operator/=(double)
ON_3dVector::operator=
ON_3dVector & operator=(const ON_2dPoint &)
ON_3dVector::ON_3dVector
ON_3dVector(const double *)
ON_3dVector::operator=
ON_3dVector & operator=(const double *)
ON_3dVector::ON_3dVector
ON_3dVector(double x, double y, double z)
ON_3dVector::operator-
ON_3dVector operator-(const ON_3dVector &) const
ON_3dVector::UnsetVector
static const ON_3dVector UnsetVector
Definition opennurbs_point.h:961
ON_3dVector::operator>=
bool operator>=(const ON_3dVector &) const
ON_3dVector::operator*
double operator*(const ON_4dPoint &) const
ON_3dVector::MinimumCoordinateIndex
int MinimumCoordinateIndex() const
ON_3dVector::IsPerpendicularTo
bool IsPerpendicularTo(const ON_3dVector &other, double angle_tolerance=ON_DEFAULT_ANGLE_TOLERANCE) const
ON_3dVector::operator+
ON_3dVector operator+(const ON_2dVector &) const
ON_3dVector::Length
double Length() const
ON_3dVector::operator=
ON_3dVector & operator=(const ON_2dVector &)
ON_3dVector::Rotate
void Rotate(double angle, const ON_3dVector &axis)
ON_3dVector::IsUnitVector
bool IsUnitVector() const
ON_3dVector::operator*
double operator*(const ON_3fVector &) const
ON_3dVector::IsZero
bool IsZero() const
ON_3dVector::operator+
ON_3dVector operator+(const ON_3dVector &) const
ON_3dVector::ON_3dVector
ON_3dVector(const ON_2dPoint &)
ON_3dVector::ON_3dVector
ON_3dVector(const ON_2dVector &)
ON_3dVector::operator-
ON_3dPoint operator-(const ON_3fPoint &) const
ON_3dVector::Set
void Set(double x, double y, double z)
ON_3dVector::operator*=
ON_3dVector & operator*=(double)
ON_3dVector::LengthSquared
double LengthSquared() const
ON_3dVector::operator+
ON_3dPoint operator+(const ON_2fPoint &) const
ON_3dVector::operator-
ON_3dVector operator-(const ON_2fVector &) const
ON_3dVector::ON_3dVector
ON_3dVector(const ON_3fPoint &)
ON_3dVector::Unitize
bool Unitize()
ON_3dVector::IsTiny
bool IsTiny(double tiny_tol=ON_ZERO_TOLERANCE) const
ON_3dVector::YAxis
static const ON_3dVector YAxis
Definition opennurbs_point.h:959
ON_3dVector::operator*
ON_3dVector operator*(int) const
ON_3dVector::operator==
bool operator==(const ON_3dVector &) const
ON_3dVector::operator=
ON_3dVector & operator=(const ON_3dPoint &)
ON_3dVector::operator+
ON_3dPoint operator+(const ON_3fPoint &) const
ON_3dVector::Fuzz
double Fuzz(double tolerance=ON_ZERO_TOLERANCE) const
ON_3dVector::Zero
void Zero()
ON_3dVector::operator-
ON_3dVector operator-(const ON_2dVector &) const
ON_3dVector::PerpendicularTo
bool PerpendicularTo(const ON_3dPoint &, const ON_3dPoint &, const ON_3dPoint &)
ON_3dVector::MaximumCoordinate
double MaximumCoordinate() const
ON_3dVector::operator=
ON_3dVector & operator=(const ON_3fVector &)
ON_3fPoint
Definition opennurbs_fpoint.h:175
ON_3fVector
Definition opennurbs_fpoint.h:632
ON_4dPoint
Definition opennurbs_point.h:573
ON_4dPoint::operator*
double operator*(const ON_4dPoint &) const
ON_4dPoint::operator+=
ON_4dPoint & operator+=(const ON_4dPoint &)
ON_4dPoint::operator[]
double & operator[](int)
ON_4dPoint::operator!=
bool operator!=(const ON_4dPoint &) const
ON_4dPoint::ON_4dPoint
ON_4dPoint()
ON_4dPoint::Transform
void Transform(const ON_Xform &)
ON_4dPoint::ON_4dPoint
ON_4dPoint(double x, double y, double z, double w)
ON_4dPoint::ON_4dPoint
ON_4dPoint(const ON_2fVector &)
ON_4dPoint::operator-
ON_4dPoint operator-(const ON_4dPoint &) const
ON_4dPoint::operator=
ON_4dPoint & operator=(const class ON_2fVector &)
ON_4dPoint::ON_4dPoint
ON_4dPoint(const ON_3fVector &)
ON_4dPoint::operator[]
double operator[](int) const
ON_4dPoint::w
double w
Definition opennurbs_point.h:575
ON_4dPoint::operator/
ON_4dPoint operator/(double) const
ON_4dPoint::IsUnsetPoint
bool IsUnsetPoint() const
ON_4dPoint::operator=
ON_4dPoint & operator=(const ON_3dVector &)
ON_4dPoint::operator==
bool operator==(ON_4dPoint) const
ON_4dPoint::IsValid
bool IsValid() const
ON_4dPoint::operator[]
double operator[](unsigned int) const
ON_4dPoint::ON_4dPoint
ON_4dPoint(const double *)
ON_4dPoint::ON_4dPoint
ON_4dPoint(const float *)
ON_4dPoint::MaximumCoordinate
double MaximumCoordinate() const
ON_4dPoint::operator=
ON_4dPoint & operator=(const double *)
ON_4dPoint::operator=
ON_4dPoint & operator=(const class ON_3fPoint &)
ON_4dPoint::ON_4dPoint
ON_4dPoint(const ON_3dVector &)
ON_4dPoint::MaximumCoordinateIndex
int MaximumCoordinateIndex() const
ON_4dPoint::operator[]
double & operator[](unsigned int)
ON_4dPoint::ON_4dPoint
ON_4dPoint(const ON_3fPoint &)
ON_4dPoint::ON_4dPoint
ON_4dPoint(const ON_2dVector &)
ON_4dPoint::ON_4dPoint
ON_4dPoint(const ON_3dPoint &)
ON_4dPoint::operator/=
ON_4dPoint & operator/=(double)
ON_4dPoint::MinimumCoordinate
double MinimumCoordinate() const
ON_4dPoint::operator=
ON_4dPoint & operator=(const ON_2dVector &)
ON_4dPoint::ON_4dPoint
ON_4dPoint(const ON_2dPoint &)
ON_4dPoint::operator=
ON_4dPoint & operator=(const ON_2dPoint &)
ON_4dPoint::Zero
void Zero()
ON_4dPoint::Set
void Set(double x, double y, double z, double w)
ON_4dPoint::operator=
ON_4dPoint & operator=(const class ON_3fVector &)
ON_4dPoint::operator-=
ON_4dPoint & operator-=(const ON_4dPoint &)
ON_4dPoint::operator=
ON_4dPoint & operator=(const class ON_2fPoint &)
ON_4dPoint::operator*
ON_4dPoint operator*(double) const
ON_4dPoint::ON_4dPoint
ON_4dPoint(const ON_2fPoint &)
ON_4dPoint::operator=
ON_4dPoint & operator=(const class ON_4fPoint &)
ON_4dPoint::Normalize
bool Normalize()
ON_4dPoint::operator*=
ON_4dPoint & operator*=(double)
ON_4dPoint::operator*
ON_4dPoint operator*(const ON_Xform &) const
ON_4dPoint::operator=
ON_4dPoint & operator=(const float *)
ON_4dPoint::MinimumCoordinateIndex
int MinimumCoordinateIndex() const
ON_4dPoint::ON_4dPoint
ON_4dPoint(const ON_4fPoint &)
ON_4dPoint::operator=
ON_4dPoint & operator=(const ON_3dPoint &)
ON_4dPoint::operator+
ON_4dPoint operator+(const ON_4dPoint &) const
ON_4fPoint
Definition opennurbs_fpoint.h:311
ON_BezierCurve
Definition opennurbs_bezier.h:149
ON_BoundingBox
Definition opennurbs_bounding_box.h:26
ON_Interval
Definition opennurbs_point.h:49
ON_Interval::Swap
void Swap()
ON_Interval::Reverse
void Reverse()
ON_Interval::EmptyInterval
static const ON_Interval EmptyInterval
Definition opennurbs_point.h:52
ON_Interval::operator[]
double & operator[](unsigned int)
ON_Interval::IsValid
bool IsValid() const
ON_Interval::IsDecreasing
bool IsDecreasing() const
ON_Interval::Destroy
void Destroy()
ON_Interval::Union
bool Union(const ON_Interval &)
ON_Interval::Set
void Set(double t0, double t1)
ON_Interval::Max
double Max() const
ON_Interval::NormalizedParameterAt
ON_Interval NormalizedParameterAt(ON_Interval interval_parameter) const
ON_Interval::IsEmptyInterval
bool IsEmptyInterval() const
ON_Interval::IsIncreasing
bool IsIncreasing() const
ON_Interval::ParameterAt
double ParameterAt(double normalized_parameter) const
ON_Interval::operator==
bool operator==(const ON_Interval &) const
ON_Interval::Compare
int Compare(const ON_Interval &other) const
ON_Interval::~ON_Interval
~ON_Interval()
ON_Interval::IsSingleton
bool IsSingleton() const
ON_Interval::NormalizedParameterAt
double NormalizedParameterAt(double interval_parameter) const
ON_Interval::Length
double Length() const
ON_Interval::IsEmptySet
bool IsEmptySet() const
ON_Interval::Includes
bool Includes(const ON_Interval &other, bool bProperSubSet=false) const
ON_Interval::operator[]
double operator[](unsigned int) const
ON_Interval::IsInterval
bool IsInterval() const
ON_Interval::ParameterAt
ON_Interval ParameterAt(ON_Interval normalized_interval) const
ON_Interval::Intersection
bool Intersection(const ON_Interval &)
ON_Interval::Union
bool Union(int count, const double *t)
ON_Interval::Mid
double Mid() const
ON_Interval::ON_Interval
ON_Interval(double t0, double t1)
ON_Interval::Includes
bool Includes(double t, bool bTestOpenInterval=false) const
ON_Interval::Union
bool Union(const ON_Interval &, const ON_Interval &)
ON_Interval::Intersection
bool Intersection(const ON_Interval &, const ON_Interval &)
ON_Interval::Min
double Min() const
ON_Interval::MakeIncreasing
bool MakeIncreasing()
ON_Interval::operator[]
double & operator[](int)
ON_Interval::ON_Interval
ON_Interval()
ON_Interval::operator!=
bool operator!=(const ON_Interval &) const
ON_Interval::operator[]
double operator[](int) const
ON_Interval::Union
bool Union(double t)
ON_Line
Definition opennurbs_line.h:21
ON_PlaneEquation
Definition opennurbs_point.h:1193
ON_PlaneEquation::UnsetPlaneEquation
static const ON_PlaneEquation UnsetPlaneEquation
Definition opennurbs_point.h:1198
ON_PlaneEquation::ValueAt
double * ValueAt(int Pcount, const ON_3dPoint *P, double *value, double value_range[2]) const
ON_PlaneEquation::MaximumAbsoluteValueAt
double MaximumAbsoluteValueAt(bool bRational, int point_count, int point_stride, const double *points, double stop_value) const
ON_PlaneEquation::ValueAt
double ValueAt(ON_3dVector P) const
ON_PlaneEquation::ClosestPointTo
ON_3dPoint ClosestPointTo(ON_3dPoint point) const
ON_PlaneEquation::MinimumValueAt
double MinimumValueAt(bool bRational, int point_count, int point_stride, const double *points, double stop_value) const
ON_PlaneEquation::IsSet
bool IsSet() const
ON_PlaneEquation::MaximumValueAt
double MaximumValueAt(bool bRational, int point_count, int point_stride, const double *points, double stop_value) const
ON_PlaneEquation::operator==
bool operator==(const ON_PlaneEquation &) const
ON_PlaneEquation::Create
bool Create(ON_3dPoint P, ON_3dVector N)
ON_PlaneEquation::IsNearerThan
bool IsNearerThan(const class ON_BezierCurve &bezcrv, double s0, double s1, int sample_count, double endpoint_tolerance, double interior_tolerance, double *smin, double *smax) const
ON_PlaneEquation::ZeroTolerance
double ZeroTolerance() const
ON_PlaneEquation::ON_PlaneEquation
ON_PlaneEquation()
ON_PlaneEquation::ZeroPlaneEquation
static const ON_PlaneEquation ZeroPlaneEquation
Definition opennurbs_point.h:1199
ON_PlaneEquation::Transform
bool Transform(const ON_Xform &xform)
ON_PlaneEquation::IsValid
bool IsValid() const
ON_PlaneEquation::operator!=
bool operator!=(const ON_PlaneEquation &) const
ON_PlaneEquation::MinimumValueAt
double MinimumValueAt(const ON_BoundingBox &bbox) const
ON_PlaneEquation::ValueAt
double * ValueAt(int Pcount, const ON_3fPoint *P, double *value, double value_range[2]) const
ON_PlaneEquation::MaximumValueAt
double MaximumValueAt(const ON_BoundingBox &bbox) const
ON_PlaneEquation::ON_PlaneEquation
ON_PlaneEquation(double xx, double yy, double zz, double dd)
ON_PlaneEquation::d
double d
Definition opennurbs_point.h:1469
ON_PlaneEquation::ValueAt
double ValueAt(ON_4dPoint P) const
ON_PlaneEquation::ValueAt
double ValueAt(ON_3dPoint P) const
ON_PlaneEquation::ValueAt
double ValueAt(double x, double y, double z) const
ON_Plane
Definition opennurbs_plane.h:21
ON_SurfaceCurvature
Definition opennurbs_point.h:1580
ON_SurfaceCurvature::MaximumRadius
double MaximumRadius() const
ON_SurfaceCurvature::MeanCurvature
double MeanCurvature() const
ON_SurfaceCurvature::MinimumRadius
double MinimumRadius() const
ON_SurfaceCurvature::GaussianCurvature
double GaussianCurvature() const
ON_SurfaceCurvature::k1
double k1
Definition opennurbs_point.h:1582
ON_Xform
Definition opennurbs_xform.h:29