Search  

---

C:/temp/src/j2k/Beta/Geometry/JPoint.hpp

Go to the documentation of this file.

#include <j2k/Fred/Standard.hpp>
#include <j2k/Fred/MathCst.hpp>
#include <math.h>

// Check if the parameters are defined...
#ifndef Type
  #error "Type is not defined."
#endif

#ifndef  FType 
  #error "FType is not defined."
#endif

#ifndef JPoint  
  #error "JPoint is not defined."
#endif

#ifndef JPoint_t
  #error "JPoint_t is not defined."
#endif

struct JPoint_t {
  Type  x;                                // coordinates of the JPoint
  Type  y;                                // ( x, y )

  BOOL  PolarCache;                       // Does Polar are still valid ?
  FType r;                                // Polar Coordinates
  FType theta;                            // ( r, t )
};

class JPoint {
public:
   // Default Constructor
   inline JPoint() {
     memset( &pt, 0, sizeof( JPoint_t ) );
   }

   inline JPoint( Type X ) {
     memset( &pt, 0, sizeof( JPoint_t ) );
     pt.x = X;
   }

   inline JPoint( Type X, Type Y ) {
     memset( &pt, 0, sizeof( JPoint_t ) );
     pt.x = X;
     pt.y = Y;
   }

   inline JPoint( const JPoint& p ) {
     memcpy( &pt, &p.pt, sizeof( JPoint_t ) );
   }

   inline const JPoint&  operator=( const JPoint& p ) {
     memcpy( &pt, &p.pt, sizeof( JPoint_t ) );
     return *this;
   }
   
   // Compare only XY
   inline BOOL  operator==( const JPoint& p ) {
     return !memcmp( &pt, &p.pt, (sizeof( Type ) * 2)  );
   }

   inline BOOL  operator!=( const JPoint& p ) {
     return  memcmp( &pt, &p.pt, (sizeof( Type ) * 2)  );
   }

   inline const JPoint&  operator++() {
      if ( !pt.PolarCache ) getPolarfromXY();
      pt.r++;
      getXYfromPolar();
      return *this;
   }

   inline const JPoint&  operator++( int ) {
      if ( !pt.PolarCache ) getPolarfromXY();
      pt.r++;
      getXYfromPolar();
      return *this;
   }

   inline const JPoint&  operator--() {
      if ( !pt.PolarCache ) getPolarfromXY();
      pt.r--;
      getXYfromPolar();
      return *this;
   }

   inline const JPoint&  operator--( int ) {
      if ( !pt.PolarCache ) getPolarfromXY();
      pt.r--;
      getXYfromPolar();
      return *this;
   }

   // Set the x and y coordinates
   inline const JPoint&  setPoint( Type X, Type Y ) {
      pt.x = X;
      pt.y = Y;
      pt.PolarCache = FALSE;
      return *this;
   }

   // Set coordinates (r,t)
   inline const JPoint&  setPolar( FType R, FType Theta ) {
      pt.r = R;
      pt.theta = Theta;
      getXYfromPolar();
      return *this;
   }

   inline const JPoint& setX( FType X ) {
      pt.x = X;
      pt.PolarCache = FALSE;
      return *this;
   }
   
   inline const JPoint& setY( FType Y ) {
      pt.y = Y;
      pt.PolarCache = FALSE;
      return *this;
   }
   
   inline const JPoint& setR( FType R ) {
      pt.r = R;
      getXYfromPolar();
      return *this;
   }
   
   inline const JPoint& setAngle( FType Theta ) {
      pt.theta = Theta;
      getXYfromPolar();
      return *this;
   }

   inline Type getX() const {                 // get x coordinate
      return pt.x;
   }

   inline Type getY() const {                 // get y coordinate
      return pt.y;
   }

   inline FType getR() {                      // get r coordinate
      if ( !pt.PolarCache ) 
        getPolarfromXY();
      return pt.r;
   }

   inline FType getAngle() {                  // get angle
      if ( !pt.PolarCache ) 
        getPolarfromXY();
      return pt.theta;
   }

   // Output the JPoint
   inline friend ostream& operator << ( ostream& os, const JPoint& p )
   {
     os << '(' << p.pt.x << ", " << p.pt.y << ')';
     return os;
   }

protected:                              // accessible to derived classes
   struct JPoint_t pt;

   // ( r, t ) => ( x, y )
   void getXYfromPolar() {
      pt.PolarCache = TRUE;
      pt.x = pt.r * cos( pt.theta );
      pt.y = pt.r * sin( pt.theta );
   }

   // ( x, y ) => ( r, t )
   void getPolarfromXY() {
     pt.r = sqrt( pt.x * pt.x  +  pt.y * pt.y );
     pt.theta = atan2( pt.y, pt.x );
     pt.PolarCache = TRUE;
   }
};

---