Points

#define COORD_DEF 0

#define COORD_ORG 1

#define COORD_3D 2

#define COORD_FRM 6

#define COORD_INF 7

#define COORD_WND 8

class SLICEO_DB Point_2D {

public:

unsigned char type ;

float x, y ;

public:

// --------------- Constructors -------------------------------

Point_2D() ;

Point_2D(unsigned char type) ;

Point_2D(unsigned char type, int vx, int vy) ;

Point_2D(unsigned char type, float vx, float vy) ;

inline void Set(unsigned char type) ;

inline void Set(int vx, int vy) ;

inline void Set(unsigned char type, int vx, int vy) ;

inline void Set(float vx, float vy) ;

inline void Set(unsigned char type, float vx, float vy) ;

inline void Set(Point_2D p) ;

// --------------- Overloads -------------------------------

inline Point_2D& operator= (float V) ;

inline Point_2D& operator= (Point_2D& V) ;

inline float& operator[] (const int i) ;

inline int operator== (Point_2D& V) ;

inline int operator!= (Point_2D& V) ;

inline Point_2D& operator+= (const float& val) ;

inline Point_2D& operator+= (const Point_2D& V) ;

inline Point_2D& operator-= (const float& val) ;

inline Point_2D& operator-= (const Point_2D& V) ;

inline Point_2D& operator*= (const float& val) ;

inline Point_2D& operator/= (const float& val) ;

inline friend Point_2D operator+ (const Point_2D&, const float&) ;

inline friend Point_2D operator+ (const float&, const Point_2D&) ;

inline friend Point_2D operator+ (const Point_2D&, const Point_2D&) ;

inline friend Point_2D operator- (const Point_2D&, const float&) ;

inline friend Point_2D operator- (const float&, const Point_2D&) ;

inline friend Point_2D operator- (const Point_2D&, const Point_2D&) ;

inline friend Point_2D operator* (const Point_2D&, const float&) ;

inline friend Point_2D operator* (const float&, const Point_2D&) ;

inline friend Point_2D operator/ (const Point_2D&, const float&) ;

} ;

class SLICEO_DB Point_3D {

public:

unsigned char type ;

float x, y, z ;

public:

// --------------- Constructors -------------------------------

Point_3D() ;

Point_3D(unsigned char type) ;

Point_3D(unsigned char type, int vx, int vy, int vz) ;

Point_3D(unsigned char type, float vx, float vy, float vz) ;

inline void Set(unsigned char type) ;

inline void Set(int vx, int vy, int vz) ;

inline void Set(unsigned char type, int vx, int vy, int vz) ;

inline void Set(float vx, float vy, float vz) ;

inline void Set(unsigned char type, float vx, float vy, float vz) ;

inline void Set(Point_3D p) ;

inline void Set(Vect p) ;

inline float Norm() const ;

inline Point_3D Normalise() ;

inline float Dist(Point_3D& V) ;

inline Point_3D Transform(Matrix M) ;

inline Point_3D& operator= (float V) ;

inline Point_3D& operator= (Point_3D& V) ;

inline Point_3D& operator= (Vect& V) ;

inline float& operator[] (const int i) ;

inline int operator== (Point_3D& V) ;

inline int operator!= (Point_3D& V) ;

inline Point_3D& operator+= (const float& val) ;

inline Point_3D& operator+= (const Point_3D& V) ;

inline Point_3D& operator-= (const float& val) ;

inline Point_3D& operator-= (const Point_3D& V) ;

inline Point_3D& operator*= (const float& val) ;

inline Point_3D& operator/= (const float& val) ;

inline Point_3D& operator*= (const Matrix& M) ;

inline friend Point_3D operator+ (const Point_3D&, const float&) ;

inline friend Point_3D operator+ (const float&, const Point_3D&) ;

inline friend Point_3D operator+ (const Point_3D&, const Point_3D&) ;

inline friend Point_3D operator- (const Point_3D&, const float&) ;

inline friend Point_3D operator- (const float&, const Point_3D&) ;

inline friend Point_3D operator- (const Point_3D&, const Point_3D&) ;

inline friend Point_3D operator* (const Point_3D&, const float&) ;

inline friend Point_3D operator* (const float&, const Point_3D&) ;

inline friend Point_3D operator* (const Point_3D&, const Matrix& M) ;

inline friend float operator* (const Point_3D&, const Point_3D&) ; // scal product

inline friend Point_3D operator/ (const Point_3D&, const float&) ;

inline friend Point_3D operator^ (const Point_3D&, const Point_3D&) ; // vect product

} ;

class SLICEO_DB Point_4D {

public:

unsigned char type ;

float x, y, z, t ;

public:

// --------------- Constructors -------------------------------

Point_4D() ;

Point_4D(unsigned char type) ;

Point_4D(unsigned char type, int vx, int vy, int vz, int vt) ;

Point_4D(unsigned char type, float vx, float vy, float vz, float vt) ;

inline void Set(unsigned char type) ;

inline void Set(int vx, int vy, int vz, int vt=0) ;

inline void Set(unsigned char type, int vx, int vy, int vz, int vt=0) ;

inline void Set(float vx, float vy, float vz, float vt=0) ;

inline void Set(unsigned char type, float vx, float vy, float vz, float vt=0) ;

inline void Set(Point_3D p, float vt=0) ;

inline void Set(Point_4D p) ;

inline void Set(Vect p) ;

inline float Norm() const ;

inline Point_4D Normalise() ;

// inline float Dist(Point_4D& V) ;

inline Point_4D Transform(Matrix M) ;

inline Point_4D& operator= (float V) ;

inline Point_4D& operator= (Point_4D& V) ;

inline Point_4D& operator= (Vect& V) ;

// inline float& operator[] (const int i) ;

inline int operator== (Point_4D& V) ;

inline int operator!= (Point_4D& V) ;

inline Point_4D& operator+= (const float& val) ;

inline Point_4D& operator+= (const Point_4D& V) ;

inline Point_4D& operator-= (const float& val) ;

inline Point_4D& operator-= (const Point_4D& V) ;

inline Point_4D& operator*= (const float& val) ;

inline Point_4D& operator/= (const float& val) ;

inline Point_4D& operator*= (const Matrix& M) ;

inline friend Point_4D operator+ (const Point_4D&, const float&) ;

inline friend Point_4D operator+ (const float&, const Point_4D&) ;

inline friend Point_4D operator+ (const Point_4D&, const Point_4D&) ;

inline friend Point_4D operator- (const Point_4D&, const float&) ;

inline friend Point_4D operator- (const float&, const Point_4D&) ;

inline friend Point_4D operator- (const Point_4D&, const Point_4D&) ;

inline friend Point_4D operator* (const Point_4D&, const float&) ;

inline friend Point_4D operator* (const float&, const Point_4D&) ;

inline friend Point_4D operator* (const Point_4D&, const Matrix& M) ;

inline friend Point_4D operator/ (const Point_4D&, const float&) ;

} ;