Search  

---

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

Go to the documentation of this file.

// Member function definitions for class JCircle
#include <j2k/Fred/Standard.hpp>
#include <j2k/Fred/MathCst.hpp>

// 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

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

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

struct JCircle_t {
   FType radius;                        // radius of the Circle
   FType area_cache;                    // Cached Area is valid, if > 0
};

class JCircle : public JPoint {
public:
    // Default Constructor
    inline JCircle() : JPoint()
    {
       memset( &c, 0, sizeof( JCircle_t ) );
    }

    inline JCircle( Type X ) : JPoint( X )
    {
       memset( &c, 0, sizeof( JCircle_t ) );
    }

    inline JCircle( Type X, Type Y ) : JPoint( X, Y )
    {
       memset( &c, 0, sizeof( JCircle_t ) );
    }

    inline JCircle( Type X, Type Y, FType Radius ) : JPoint( X, Y )
    {
       memset( &c, 0, sizeof( JCircle_t ) );
       c.radius = Radius;
       c.area_cache = -1;
       check();
    }

   inline JCircle( const JCircle& src ) : JPoint( (const JPoint&)src )
   {
     // memcpy( &pt, &src.pt, sizeof( JPoint_t  ) );
     memcpy( &c,  &src.c,  sizeof( JCircle_t ) );
   }

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

   inline BOOL  operator!=( const JCircle& src )
   {
     return  memcmp( &pt, &src.pt, (sizeof( Type ) * 2)  ) ||
             ( c.radius != src.c.radius);
   }

   inline const JCircle&  operator++()
   {
      JPoint::operator++();
      return *this;
   }

   inline const JCircle&  operator++( int )
   {
      JPoint::operator++( 0 );
      return *this;
   }

   inline const JCircle&  operator--()
   {
      JPoint::operator--();
      return *this;
   }

   inline const JCircle&  operator--( int )
   {
      JPoint::operator--( 0 );
      return *this;
   }

   /////////////////////////////////////////////////
   ///  JCircle related functions.               ///
   /////////////////////////////////////////////////
    
    // Set radius
    inline void setRadius( FType r )
    {
      c.radius = r;
      check();
    }

    inline void check()
    {
      if ( c.radius <= 0 ) {
        c.radius = 0;
      }
    }
    
    // Get radius
    inline FType getRadius() const
    {
      return c.radius;
    }
    
    // Set the x and y coordinates
    inline JCircle&  setCircle( Type X, Type Y, FType Radius )
    {
       JPoint::setPoint( X, Y );
       c.radius = Radius;
       check();
       return *this;
    }

    // Set the x and y coordinates
    inline JCircle&  setPoint( Type X, Type Y )
    {
       JPoint::setPoint( X, Y );
       return *this;
    }

    // Calculate area of JCircle
    inline FType area() 
    {
      if ( c.area_cache < 0 ) {
        c.area_cache = Math_PI * c.radius * c.radius;
      }
      return c.area_cache;
    }
    
    ////////////////////////////////////////////////////////////////////
    ///  JPoint related functions.                                   ///
    ////////////////////////////////////////////////////////////////////
    
    // Set coordinates (r,t)
    inline JCircle&  setPolar( FType R, FType Theta )
    {
       JPoint::setPolar( R, Theta );
       return *this;
    }
    
    inline JCircle&  setX( Type X ) {
       JPoint::setX( X );
       return *this;
    }
    
    inline JCircle&  setY( Type Y ) {
       JPoint::setY( Y );
       return *this;
    }
    
    inline JCircle&  setR( FType R ) {
       JPoint::setR( R );
       return *this;
    }
    
    inline JCircle&  setAngle( FType Theta ) {
       JPoint::setAngle( Theta );
       return *this;
    }
    
   // Output Circle information in the form:
   // Center = [x, y]; Radius = #.##
   friend ostream& operator<<( ostream &os, const JCircle &Circ )
   {
     os << "Center = " << (const JPoint&)(Circ)
        << "; Radius = "
        << setiosflags( ios::fixed | ios::showpoint )
        << setprecision( 2 ) 
        << Circ.c.radius;
     return os;                          // Enable cascaded calls
   }

protected:                               // accessible to derived classes
   struct JCircle_t c;
};

---