AffPoint.h

Go to the documentation of this file.

#ifndef AFFPOINT_H
#define AFFPOINT_H

#include <math.h>
#include <iostream>

#include "AffVector.h"

namespace cryph
{

// indices for extracting coordinates from points

const int X = 0;
const int Y = 1;
const int Z = 2;
const int W = 3;

class AffPoint
{
public:
    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
                { return AffPoint(x + p2.x, y + p2.y, z + p2.z); }

    AffPoint operator*(double f) const
                { return AffPoint (f*x, f*y, f*z); }

    AffPoint operator/(double f) const
                { return AffPoint (x/f, y/f, z/f); }

    AffVector operator-(const AffPoint& p2) const
                { return AffVector(x-p2.x, y-p2.y, z-p2.z); }

    AffPoint operator+(const AffVector& v2) const
                { return AffPoint(x+v2[DX], y+v2[DY], z+v2[DZ]); }

    AffPoint operator-(const AffVector& v2) const
                { return AffPoint(x-v2[DX], y-v2[DY], z-v2[DZ]); }

    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( // in a plane
                // find the areal Barycentric coordinates
                // of "this" point with respect to:
                const AffPoint& P1, const AffPoint& P2, const AffPoint& P3,
                // returning them in:  (b1+b2+b3 = 1)
                double& b1, double& b2, double& b3) const;

    void barycentricCoords( // on a line
                // find the areal Barycentric coordinates of "this"
                // point with respect to:
                const AffPoint& P1, const AffPoint& P2,
                // returning them in:  (b1+b2 = 1)
                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 AffPoint centroid(const AffPoint p[], int nPoints);

    static AffPoint fromBarycentricCoords( // in a plane
                            const AffPoint& P1, const AffPoint& P2,
                            const AffPoint& P3,
                            double b1, double b2, double b3)
                        { return b1*P1 + b2*P2 + b3*P3; }

    static AffPoint fromBarycentricCoords( // on a line
                            const AffPoint& P1, const AffPoint& P2,
                            double b1, double b2)
                        { return b1*P1 + b2*P2; }

    static AffPoint fromCylindrical(double r, double theta, double z)
                        { return AffPoint( r*cos(theta), r*sin(theta), z ); }

    static AffPoint fromSpherical(double rho, double theta, double phi)
                        { return AffPoint(rho*sin(phi)*cos(theta),
                                          rho*sin(phi)*sin(theta), rho*cos(phi) ); }

    static double getCoincidenceTolerance() { return AffPoint::sCoincidenceTol; }
    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);

    // ---------- Global constants

    // Special Points
    static const AffPoint       origin; 
    static const AffPoint       xAxisPoint; 
    static const AffPoint       yAxisPoint; 
    static const AffPoint       zAxisPoint; 
    // The coordinates are public, but it is usually best to use
    // the public methods, using public access to the following only
    // for convenient overwriting of the coordinates of a specific point.
    double  x; 
    double  y; 
    double  z; 
private:
    static double   sCoincidenceTol;
};

std::ostream&       operator<<(std::ostream& os, const AffPoint& p);
std::istream&       operator>>(std::istream& is, AffPoint& p);

static AffPoint operator*(double f, const AffPoint& p)
    { return AffPoint(f*p[X], f*p[Y], f*p[Z]); }
}

#endif