Public Member Functions
	AffPoint ()

	AffPoint (const AffPoint &P)

	AffPoint (const AffVector &v)

	AffPoint (double xx, double yy, double zz=0.0)

	AffPoint (const double P[])

	AffPoint (const float P[])

virtual	~AffPoint ()

AffPoint	operator= (const AffPoint &rhs)

AffPoint	operator+= (const AffVector &rhs)

AffPoint	operator+= (const AffPoint &rhs)

AffPoint	operator-= (const AffVector &rhs)

AffPoint	operator*= (double f)

AffPoint	operator/= (double f)

double	operator[] (int index) const

AffPoint	operator+ (const AffPoint &p2) const

AffPoint	operator* (double f) const

AffPoint	operator/ (double f) const

AffVector	operator- (const AffPoint &p2) const

AffPoint	operator+ (const AffVector &v2) const

AffPoint	operator- (const AffVector &v2) const

double *	aCoords (double *coords, int offset=0) const

double *	aCoords (double coords[][3], int offset=0) const

float *	aCoords (float *coords, int offset=0) const

float *	aCoords (float coords[][3], int offset=0) const

void	assign (double xx, double yy, double zz)

void	barycentricCoords (const AffPoint &P1, const AffPoint &P2, const AffPoint &P3, double &b1, double &b2, double &b3) const

void	barycentricCoords (const AffPoint &P1, const AffPoint &P2, double &b1, double &b2) const

bool	coincidentWith (const AffPoint &p) const

double	distanceFromLine (const AffPoint &B, const AffVector &u) const

double	distanceFromOrigin () const

double	distanceSquaredFromLine (const AffPoint &B, const AffVector &u) const

double	distanceSquaredFromOrigin () const

double	distanceSquaredTo (const AffPoint &p) const

double	distanceTo (const AffPoint &p) const

double	normalize ()

double *	pCoords (double *coords, double w, int offset=0) const

float *	pCoords (float *coords, float w, int offset=0) const

void	swizzle (char xyz[3])

void	toCylindrical (double &r, double &theta, double &z) const

void	toSpherical (double &rho, double &theta, double &phi) const

Static Public Member Functions
static AffPoint	centroid (const AffPoint p[], int nPoints)

static AffPoint	fromBarycentricCoords (const AffPoint &P1, const AffPoint &P2, const AffPoint &P3, double b1, double b2, double b3)

static AffPoint	fromBarycentricCoords (const AffPoint &P1, const AffPoint &P2, double b1, double b2)

static AffPoint	fromCylindrical (double r, double theta, double z)

static AffPoint	fromSpherical (double rho, double theta, double phi)

static double	getCoincidenceTolerance ()

static double	maxOffsetInDirection (const AffPoint &ref, const AffVector &dir, const AffPoint buf[], int bufSize, int &index1, int &index2)

static double	ratio (const AffPoint &a, const AffPoint &b, const AffPoint &c)

static void	setCoincidenceTolerance (double tol)

Public Attributes
double	x

double	y

double	z

Static Public Attributes
static const AffPoint	origin = AffPoint(0.0 , 0.0 , 0.0)

static const AffPoint	xAxisPoint = AffPoint(1.0 , 0.0 , 0.0)

static const AffPoint	yAxisPoint = AffPoint(0.0 , 1.0 , 0.0)

static const AffPoint	zAxisPoint = AffPoint(0.0 , 0.0 , 1.0)

Constructor & Destructor Documentation

cryph::AffPoint::AffPoint ( )

Default constructor creates a point at the origin.

cryph::AffPoint::AffPoint ( const AffPoint & P )

The copy constructor.

Parameters

P	[INPUT ONLY] the point whose coordinates are to initialize "this"

cryph::AffPoint::AffPoint ( const AffVector & v )

Construct a point from a vector (i.e., "this" point = origin + v)

Parameters

v	[INPUT ONLY] a vector

cryph::AffPoint::AffPoint	(	double	xx,
		double	yy,
		double	zz = `0.0`
	)

Creates a point at the specified location.

Parameters

xx	[INPUT ONLY] the x coordinate
yy	[INPUT ONLY] the y coordinate
zz	[INPUT ONLY] the z coordinate (defaults to 0.0)

cryph::AffPoint::AffPoint ( const double P[] )

Construct from a double array

Parameters

P	[INPUT ONLY] an array assumed to be of length 3 holding (x, y, z)

cryph::AffPoint::AffPoint ( const float P[] )

Construct from a float array

Parameters

P	[INPUT ONLY] an array assumed to be of length 3 holding (x, y, z)

cryph::AffPoint::~AffPoint ( )

virtual

The destructor

Member Function Documentation

double * cryph::AffPoint::aCoords	(	double *	coords,
		int	offset = `0`
	)		const

Extract the coordinates of "this" point into an array of double, starting at the given offset. Among other things, this method is useful for interfacing with OpenGL, especially routines like glBufferData. For example, a caller can allocate an array of an appropriate size, then loop over an array of AffPoint instances, invoking the aCoords method as follows:

double* buf = new double[3*NUM_POINTS];
for (int i=0 ; i<NUM_POINTS ; i++)
    affPointArray[i].aCoords(buf, 3*i);
glBufferData(GL_ARRAY_BUFFER, 3*NUM_POINTS*sizeof(double), buf, GL_STATIC_DRAW);
delete [] buf;

Parameters

coords	[OUTPUT ONLY] the array into which the (x, y, z) coordinates of "this" point are to be copied. Must be at least (offset+3) positions long.
offset	[INPUT ONLY] the starting location in coords where the coordinates are to be placed (defaults to 0)

Returns: the given coords array pointer so that the method call can be used as a parameter to an OpenGL function expecting an array of double

See also: pCoords

double * cryph::AffPoint::aCoords	(	double	coords[][3],
		int	offset = `0`
	)		const

Extract the coordinates of "this" point into an array of "dvec3" (a built-in GLSL data type essentially equivalent to "typedef double dvec[3];"), starting at the given offset. Among other things, this method is useful for interfacing with OpenGL, especially routines like glBufferData. For example, a caller can allocate an array of an appropriate size, then loop over an array of AffPoint instances, invoking the aCoords method as follows:

dvec3* buf = new dvec3[NUM_POINTS]; // assuming the "typedef" above
for (int i=0 ; i<NUM_POINTS ; i++)
    affPointArray[i].aCoords(buf, i);
glBufferData(GL_ARRAY_BUFFER, NUM_POINTS*sizeof(dvec3), buf, GL_STATIC_DRAW);
delete [] buf;

Parameters

coords	[OUTPUT ONLY] the array into which the (x, y, z) coordinates of "this" point are to be copied. Must be at least (offset+1) positions long.
offset	[INPUT ONLY] the starting location in coords where the coordinates are to be placed (defaults to 0)

Returns: the given coords array pointer so that the method call can be used as a parameter to an OpenGL function expecting an array of double

See also: pCoords

float * cryph::AffPoint::aCoords	(	float *	coords,
		int	offset = `0`
	)		const

Extract the coordinates of "this" point into an array of float, starting at the given offset. Among other things, this method is useful for interfacing with OpenGL, especially routines like glBufferData. For example, a caller can allocate an array of an appropriate size, then loop over an array of AffPoint instances, invoking the aCoords method as follows:

float* buf = new float[3*NUM_POINTS];
for (int i=0 ; i<NUM_POINTS ; i++)
    affPointArray[i].aCoords(buf, 3*i);
glBufferData(GL_ARRAY_BUFFER, 3*NUM_POINTS*sizeof(float), buf, GL_STATIC_DRAW);
delete [] buf;

Parameters

coords	[OUTPUT ONLY] the array into which the (x, y, z) coordinates of "this" point are to be copied. Must be at least (offset+3) positions long.
offset	[INPUT ONLY] the starting location in coords where the coordinates are to be placed (defaults to 0)

Returns: the given coords array pointer so that the method call can be used as a parameter to an OpenGL function expecting an array of float

See also: pCoords

float * cryph::AffPoint::aCoords	(	float	coords[][3],
		int	offset = `0`
	)		const

Extract the coordinates of "this" point into an array of "vec3" (a built-in GLSL data type essentially equivalent to "typedef float vec[3];"), starting at the given offset. Among other things, this method is useful for interfacing with OpenGL, especially routines like glBufferData. For example, a caller can allocate an array of an appropriate size, then loop over an array of AffPoint instances, invoking the aCoords method as follows:

vec3* buf = new vec3[NUM_POINTS]; // assuming the "typedef" above
for (int i=0 ; i<NUM_POINTS ; i++)
    affPointArray[i].aCoords(buf, i);
glBufferData(GL_ARRAY_BUFFER, NUM_POINTS*sizeof(vec3), buf, GL_STATIC_DRAW);
delete [] buf;

Parameters

coords	[OUTPUT ONLY] the array into which the (x, y, z) coordinates of "this" point are to be copied. Must be at least (offset+1) positions long.
offset	[INPUT ONLY] the starting location in coords where the coordinates are to be placed (defaults to 0)

Returns: the given coords array pointer so that the method call can be used as a parameter to an OpenGL function expecting an array of float

See also: pCoords

void cryph::AffPoint::assign	(	double	xx,
		double	yy,
		double	zz
	)

Reset the (x, y, z) coordinates of "this" point

Parameters

xx	[INPUT ONLY] the new x coordinate
yy	[INPUT ONLY] the new y coordinate
zz	[INPUT ONLY] the new z coordinate

void cryph::AffPoint::barycentricCoords	(	const AffPoint &	P1,
		const AffPoint &	P2,
		const AffPoint &	P3,
		double &	b1,
		double &	b2,
		double &	b3
	)		const

Compute the Barycentric coordinates (b1, b2, b3) of "this" point with respect to the three given reference points, P1, P2, and P3. We assume "this" point lies in the plane determined by the points P1, P2, and P3. On return, b1, b2, and b3 will have been computed such that: (i) b1 + b2 + b3 = 1, (ii) "this" point = b1*P1 + b2*P2 + b3*P3, and (iii) none of "this" point, P1, P2, or P3 will have been changed. Furthermore, if "this" point lies in the triangle P1-P2-P3, then b1>=0, b2>=0, and b3>=0.

Parameters

P1	[INPUT ONLY] the first reference point
P2	[INPUT ONLY] the second reference point
P3	[INPUT ONLY] the third reference point
b1	[OUTPUT ONLY] b1 the returned Barycentric coordinate (associated with P1)
b2	[OUTPUT ONLY] b2 the returned Barycentric coordinate (associated with P2)
b3	[OUTPUT ONLY] b3 the returned Barycentric coordinate (associated with P3)

See also: fromBarycentricCoords

void cryph::AffPoint::barycentricCoords	(	const AffPoint &	P1,
		const AffPoint &	P2,
		double &	b1,
		double &	b2
	)		const

Compute the Barycentric coordinates (b1, b2) of "this" point with respect to the two given reference points, P1 and P2. We assume "this" point lies on the line determined by the points P1 and P2. On return, b1 and b2 will have been computed such that: (i) b1 + b2 = 1, (ii) "this" point = b1*P1 + b2*P2, and (iii) none of "this" point, P1, or P2 will have been changed. Furthermore, if ("this" point lies between P1 and P2 on the line, then b1>=0 and b2>=0.

Parameters

P1	[INPUT ONLY] the first reference point
P2	[INPUT ONLY] the second reference point
b1	[OUTPUT ONLY] the returned Barycentric coordinate (associated with P1)
b2	[OUTPUT ONLY] the returned Barycentric coordinate (associated with P2)

See also: fromBarycentricCoords

AffPoint cryph::AffPoint::centroid	(	const AffPoint	p[],
		int	nPoints
	)

static

Compute and return the centroid of the given array of points

Parameters

p	[INPUT ONLY] an array of AffPoint instances
nPoints	[INPUT ONLY] the number of AffPoint instances in the array, p

Returns: the computed centroid

bool cryph::AffPoint::coincidentWith ( const AffPoint & p ) const

Determine whether "this" point is coincident with P within the current coincidence tolerance

Parameters

P	[INPUT ONLY] the point to be compared with "this" point

Returns: true if and only if "this" point is coincident with P within the current coincidence tolerance.

See also: getCoincidenceTolerance; setCoincidenceTolerance

double cryph::AffPoint::distanceFromLine	(	const AffPoint &	B,
		const AffVector &	u
	)		const

Compute and return the distance from "this" point to the given line

Parameters

B	[INPUT ONLY] a point on the line
u	[INPUT ONLY] a vector along the line

Returns: the distance from "this" point to the line(B, u)

double cryph::AffPoint::distanceFromOrigin ( ) const

Compute the distance from "this" point to the origin

Returns: the distance

double cryph::AffPoint::distanceSquaredFromLine	(	const AffPoint &	B,
		const AffVector &	u
	)		const

Compute and return the distance squared from "this" point to the given line

Parameters

B	[INPUT ONLY] a point on the line
u	[INPUT ONLY] a vector along the line

Returns: the square of the distance from "this" point to the line(B, u)

double cryph::AffPoint::distanceSquaredFromOrigin ( ) const

Compute the square of the distance from "this" point to the origin

Returns: the square of the distance from "this" point to the origin

double cryph::AffPoint::distanceSquaredTo ( const AffPoint & p ) const

Compute the square of the distance from "this" point to the given point

Parameters

P	[INPUT ONLY] the point whose distance squared from "this" point we seek

Returns: the square of the distance from "this" point to the given point

double cryph::AffPoint::distanceTo ( const AffPoint & p ) const

Compute the distance from "this" point to the given point

Parameters

P	[INPUT ONLY] the point whose distance from "this" point we seek

Returns: the distance from "this" point to the given point

static AffPoint cryph::AffPoint::fromBarycentricCoords	(	const AffPoint &	P1,
		const AffPoint &	P2,
		const AffPoint &	P3,
		double	b1,
		double	b2,
		double	b3
	)

inlinestatic

Compute and return the point whose barycentric coordinates are (b1, b2, b3) with respect to the reference points P1, P2, and P3

Parameters

P1	[INPUT ONLY] the first input reference point
P2	[INPUT ONLY] the second input reference point
P3	[INPUT ONLY] the third input reference point
b1	[INPUT ONLY] the Barycentric coordinate for P1
b2	[INPUT ONLY] the Barycentric coordinate for P2
b3	[INPUT ONLY] the Barycentric coordinate for P3

Returns: the computed point

See also: barycentricCoords

static AffPoint cryph::AffPoint::fromBarycentricCoords	(	const AffPoint &	P1,
		const AffPoint &	P2,
		double	b1,
		double	b2
	)

inlinestatic

Compute and return the point whose barycentric coordinates are (b1, b2) with respect to the reference points P1 and P2

Parameters

P1	[INPUT ONLY] the first input reference point
P2	[INPUT ONLY] the second input reference point
b1	[INPUT ONLY] the Barycentric coordinate for P1
b2	[INPUT ONLY] the Barycentric coordinate for P2

Returns: the computed point

See also: barycentricCoords

static AffPoint cryph::AffPoint::fromCylindrical	(	double	r,
		double	theta,
		double	z
	)

inlinestatic

Compute and return the point with the given cylindrical coordinates

Parameters

r	[INPUT ONLY] the radial cylindrical coordinate
theta	[INPUT ONLY] the theta cylindrical coordinate
z	[INPUT ONLY] the z coordinate

Returns: the computed point

See also: toCylindrical

static AffPoint cryph::AffPoint::fromSpherical	(	double	rho,
		double	theta,
		double	phi
	)

inlinestatic

Compute and return the point with the given spherical coordinates

Parameters

rho	[INPUT ONLY] the distance from the origin to the desired point
theta	[INPUT ONLY] the desired theta
phi	[INPUT ONLY] the desired phi

See also: toSpherical

static double cryph::AffPoint::getCoincidenceTolerance ( )

inlinestatic

Get the current point coincidence tolerance.

Returns: the current tolerance

See also: setCoincidenceTolerance; coincidentWith

double cryph::AffPoint::maxOffsetInDirection	(	const AffPoint &	ref,
		const AffVector &	dir,
		const AffPoint	buf[],
		int	bufSize,
		int &	index1,
		int &	index2
	)

static

Find the point in the given buffer of points that is farthest away away in the given direction. If that point is 'P', the function return value is "(P-ref).dir". If there is exactly one such farthest point, then the indices index1 and index2 will both contain the index of 'P' in 'buf'. If several points tie, then index1 and index2 are the indices of the first succession of adjacent points all at that offset. If there are multiple sets of adjacent tieing points, only the indices of the first are returned.

Parameters

ref	[INPUT ONLY] a reference point used to compute distances
dir	[INPUT ONLY] a vector which, along with 'ref', define a plane away from which distances are measured.
buf	[INPUT ONLY] the array of points to be analyzed
bufSize	[INPUT ONLY] the number of points in 'buf'
index1	[OUTPUT ONLY] as described above
index2	[OUTPUT ONLY] as described above

double cryph::AffPoint::normalize ( )

Move "this" point along the line through the origin until it lies on the unit sphere centered at the origin.

AffPoint cryph::AffPoint::operator* ( double f ) const

inline

Scales "this" point by f and returns the result as an AffPoint

Parameters

f	[INPUT ONLY] the scale factor

Returns: the scaled AffPoint

AffPoint cryph::AffPoint::operator*= ( double f )

Scales the coordinates of "this" point by f

Parameters

f	[INPUT ONLY] the scale factor

Returns: the value of the scaled AffPoint

AffPoint cryph::AffPoint::operator+ ( const AffPoint & p2 ) const

inline

Adds "this" point to p2 and returns the result as an AffPoint

Parameters

p2	[INPUT ONLY] the point to add

Returns: the sum of "this" point and p2

AffPoint cryph::AffPoint::operator+ ( const AffVector & v2 ) const

inline

Adds the vector v2 to "this" point and returns the result as an AffPoint

Parameters

v2	[INPUT ONLY] the vector to add

Returns: the AffPoint resulting from adding v2 to "this" point

AffPoint cryph::AffPoint::operator+= ( const AffVector & rhs )

Adds the coordinates of rhs to "this" point

Parameters

rhs	[INPUT ONLY] a const reference to an AffVector

Returns: the result of incrementing the AffPoint

AffPoint cryph::AffPoint::operator+= ( const AffPoint & rhs )

Adds the coordinates of rhs to "this" point

Parameters

rhs	[INPUT ONLY] a const reference to an AffPoint

Returns: the result of incrementing the AffPoint

AffVector cryph::AffPoint::operator- ( const AffPoint & p2 ) const

inline

Subtracts p2 from "this" point and returns the result as an AffVector

Parameters

p2	[INPUT ONLY] the point to subtract

Returns: the AffVector resulting from subtracting p2 from "this" point

AffPoint cryph::AffPoint::operator- ( const AffVector & v2 ) const

inline

Subtracts the vector v2 from "this" point and returns the result as an AffPoint

Parameters

v2	[INPUT ONLY] the vector to subtract

Returns: the AffPoint resulting from subtracting v2 from "this" point

AffPoint cryph::AffPoint::operator-= ( const AffVector & rhs )

Subtracts the coordinates of rhs from "this" point

Parameters

rhs	[INPUT ONLY] a const reference to an AffVector

Returns: the result of decrementing the AffPoint

AffPoint cryph::AffPoint::operator/ ( double f ) const

inline

Divides "this" point by f (i.e., scales by 1/f) and returns the result as an AffPoint

Parameters

f	[INPUT ONLY] the divisor

Returns: the AffPoint divided by f

AffPoint cryph::AffPoint::operator/= ( double f )

Divides the coordinates of "this" point by f (i.e., scales by 1/f)

Parameters

f	[INPUT ONLY] the divisor

Returns: the value of the divided AffPoint

AffPoint cryph::AffPoint::operator= ( const AffPoint & rhs )

Assigns the coordinates of rhs to "this" point

Parameters

rhs	[INPUT ONLY] a const reference to an AffPoint

Returns: the value assigned

double cryph::AffPoint::operator[] ( int index ) const

Returns x (if index = 0); y (if index is 1); z (if index is 2) The returned value cannot be used as an l-value.

Parameters

index [INPUT ONLY] the desired coordinate

Returns: the selected point coordinate

double * cryph::AffPoint::pCoords	(	double *	coords,
		double	w,
		int	offset = `0`
	)		const

Extract the coordinates of "this" point into an array of double, starting at the given offset. While doing so, embed each point in projective space using the given w coordinate. Among other things, this method is useful for interfacing with OpenGL, especially routines like glBufferData. For example, a caller can allocate an array of an appropriate size, then loop over an array of AffPoint instances, invoking the pCoords method as follows:

double* buf = new double[4*NUM_POINTS];
for (int i=0 ; i<NUM_POINTS ; i++)
    affPointArray[i].pCoords(buf, 4*i);
glBufferData(GL_ARRAY_BUFFER, 4*NUM_POINTS*sizeof(double), buf, GL_STATIC_DRAW);
delete [] buf;

Parameters

coords	[OUTPUT ONLY] the array into which the (x, y, z, w) projective space coordinates of "this" point are to be copied. Must be at least (offset+4) positions long.
offset	[INPUT ONLY] the starting location in coords where the coordinates are to be placed (defaults to 0)

Returns: the given coords array pointer so that the method call can be used as a parameter to an OpenGL function expecting an array of double

See also: aCoords

float * cryph::AffPoint::pCoords	(	float *	coords,
		float	w,
		int	offset = `0`
	)		const

Extract the coordinates of "this" point into an array of float, starting at the given offset. While doing so, embed each point in projective space using the given w coordinate. Among other things, this method is useful for interfacing with OpenGL, especially routines like glBufferData. For example, a caller can allocate an array of an appropriate size, then loop over an array of AffPoint instances, invoking the pCoords method as follows:

float* buf = new float[4*NUM_POINTS];
for (int i=0 ; i<NUM_POINTS ; i++)
    affPointArray[i].pCoords(buf, 4*i);
glBufferData(GL_ARRAY_BUFFER, 4*NUM_POINTS*sizeof(float), buf, GL_STATIC_DRAW);
delete [] buf;

Parameters

coords	[OUTPUT ONLY] the array into which the (x, y, z, w) projective space coordinates of "this" point are to be copied. Must be at least (offset+4) positions long.
offset	[INPUT ONLY] the starting location in coords where the coordinates are to be placed (defaults to 0)

Returns: the given coords array pointer so that the method call can be used as a parameter to an OpenGL function expecting an array of float

See also: aCoords

double cryph::AffPoint::ratio	(	const AffPoint &	a,
		const AffPoint &	b,
		const AffPoint &	c
	)

static

Compute the unit vector uHat from (c-a). Then compute and return ratio(a,b,c) as defined by Farin.

Parameters

a	[INPUT ONLY] first point
b	[INPUT ONLY] middle point
c	[INPUT ONLY] last point

Returns: fabs(uHat.(c-b))>tol ? uHat.(b-a) / uHat.(c-b) : 0.0

void cryph::AffPoint::setCoincidenceTolerance ( double tol )

static

Set the current point coincidence tolerance.

Parameters

tol	[INPUT ONLY] the desired point coincidence tolerance

See also: getCoincidenceTolerance; coincidentWith

void cryph::AffPoint::swizzle ( char xyz[3] )

A method inspired by OpenGL's GLSL's swizzle operation. If the i-th character of xyz is 'X', then the x coordinate of "this" point is placed into the i-th coordinate of "this" point. If instead it is 'x', then negative of the x coordinate of "this" point is placed into the i-th coordinate of "this" point. Characters 'y', 'Y', 'z', 'Z' behave similarly. Any other character is simply ignored. Some examples:

cryph::AffPoint ap(1.0, 2.0, 3.0);
ap.swizzle("Zxy"); // ap is now (3.0, -1.0, -2.0)
ap.swizzle("dzy"); // ap is now (3.0, 2.0, 1.0)
ap.swizzle("xxY"); // ap is now (3.0, 3.0, 2.0)

Parameters

xyz	[INPUT ONLY] an array of char of length 3 interpreted as explained and illustrated above

void cryph::AffPoint::toCylindrical	(	double &	r,
		double &	theta,
		double &	z
	)		const

Compute and return the cylindrical coordinates of "this" point

Parameters

r	[OUTPUT ONLY] the output computed r coordinate
theta	[OUTPUT ONLY] the output computed theta coordinate
z	[OUTPUT ONLY] the output computed z coordinate (same is this->z).

See also: fromCylindrical

void cryph::AffPoint::toSpherical	(	double &	rho,
		double &	theta,
		double &	phi
	)		const

Compute and return the spherical coordinates of "this" point.

Parameters

rho	[OUTPUT ONLY] the output computed distance from the origin to "this" point
theta	[OUTPUT ONLY] the output computed angle in the xy-plane from the positive x-axis to the projection of the vector ("this" - origin) onto the xy-plane. Value will be: -PI <= theta <= PI.
phi	[OUTPUT ONLY] the output computed angle from the positive z-axis to the vector ("this" - origin). Value will be: 0 <= phi <= PI.

See also: fromSpherical

Member Data Documentation

const AffPoint cryph::AffPoint::origin = AffPoint(0.0 , 0.0 , 0.0)

static

the point (0,0,0)

double cryph::AffPoint::x

x coordinate

const AffPoint cryph::AffPoint::xAxisPoint = AffPoint(1.0 , 0.0 , 0.0)

static

the point (1,0,0)

double cryph::AffPoint::y

y coordinate

const AffPoint cryph::AffPoint::yAxisPoint = AffPoint(0.0 , 1.0 , 0.0)

static

the point (0,1,0)

double cryph::AffPoint::z

z coordinate

const AffPoint cryph::AffPoint::zAxisPoint = AffPoint(0.0 , 0.0 , 1.0)

static

the point (0,0,1)

The documentation for this class was generated from the following files:

AffPoint.h
AffPoint.c++

Public Member Functions

Static Public Member Functions

Public Attributes

Static Public Attributes

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation