NGon2D.ih

#include <cstdlib>

// IMPLEMENTATION of inline methods.

// ----------------------- Standard services ------------------------------

template <typename T>
inline
DGtal::NGon2D<T>::~NGon2D()
{
}

template <typename T>
inline
DGtal::NGon2D<T>::NGon2D(const double x0, const double y0, 
       const double radius, const unsigned int k,
       const double phi):
  myCenter(x0,y0), myRadius(radius), myK(k), myPhi(phi)
{}


template <typename T>
inline
DGtal::NGon2D<T>::NGon2D(const RealPoint2D &aPoint,
       const double radius, const unsigned int k,
       const double phi):
  myCenter(aPoint), myRadius(radius) , myK(k), myPhi(phi)
{}

template <typename T>
inline
DGtal::NGon2D<T>::NGon2D(const Point &aPoint, 
       const double radius, const unsigned int k,
       const double phi):
  myRadius(radius), myK(k), myPhi(phi)
{
  myCenter = aPoint;
}

// ------------- Implementation of 'StarShaped' services ------------------

template <typename T>
inline
double
DGtal::NGon2D<T>::parameter( const RealPoint2D & pp ) const
{
  RealPoint2D p( pp );
  p -= myCenter;

  double t = atan2( p[ 1 ], p[ 0 ] );
  return ( t < 0.0 ) ? ( t + 2.0 * M_PI ) : t;
  // double angle = 0.0;
  // if ( p[0] == 0.0 ) 
  //   {
  //     if ( p[1] >0 )
  //       angle = M_PI/2.0; 
  //     else 
  //       angle = 1.5*M_PI; 
  //   }
  // else if (  ( p[0] > 0.0 ) && (   p[1] >= 0.0 ) )
  //   angle = atan(p[1]/p[0]);
  // else if (  ( p[0] > 0.0 ) && (   p[1] <= 0.0 ) )
  //   angle = 2*M_PI + atan(p[1]/p[0]);
  // else if (  ( p[0] < 0.0 ) && (   p[1] >= 0.0 ) )
  //   angle = atan(p[1]/p[0]) + M_PI;
  // else // (  ( p[0] < 0.0 ) && (   p[1] <= 0.0 ) )
  //   angle = atan(p[1]/p[0]) + M_PI;

  // return angle;
}

template <typename T>
inline
typename DGtal::NGon2D<T>::RealPoint2D 
DGtal::NGon2D<T>::x( double t ) const
{
  double angle = t - myPhi; 
  while ( angle < 0.0 )
    angle += 2.0*M_PI;
  
  
  // seek the vertices between the point, then compute the vector from one vertex to the next one.
  
  unsigned int intervale_lower = static_cast<unsigned int>( floor( ( angle )* myK / (2.0 * M_PI ) ) );
  unsigned int intervale_upper = intervale_lower == ( myK -1 ) ? 0 : intervale_lower+1;
  double dist = myRadius*cos ( M_PI / myK );
  RealPoint2D s1 ( myRadius*cos(myPhi + intervale_lower*2.0*M_PI/myK),
       myRadius*sin(myPhi + intervale_lower*2.0*M_PI/myK) );
  RealPoint2D s2 ( myRadius*cos(myPhi + intervale_upper*2.0*M_PI/myK),
       myRadius*sin(myPhi + intervale_upper*2.0*M_PI/myK) );
  RealPoint2D s3( s2[0] - s1[0], s2[1] - s1[1]);
  
  double line_angle = atan2f( (float)s3[ 1 ], (float)s3[ 0 ]);
  
  double rho = dist/(cos (t - line_angle - 0.5*M_PI));
  
  RealPoint2D c( rho*cos(t), rho*sin(t) );
  
  c += myCenter;
  
  return c;
}


template <typename T>
inline
typename DGtal::NGon2D<T>::RealVector2D 
DGtal::NGon2D<T>::xp( const double t ) const
{
  // seek the vertices between the point, then compute the vector from one vertex to the next one.
  // TODO check if angle equals that of a vertex ?
  double angle = t - myPhi; 
  while ( angle < 0.0 )
    angle += 2.0*M_PI;
  
  unsigned int intervalle_lower = static_cast<unsigned int>( floor( angle * myK / (2.0 * M_PI ) ) );
  unsigned int intervalle_upper = intervalle_lower == ( myK -1 ) ? 0 : intervalle_lower+1;
  //float dist = myRadius*sin ( M_PI / myK );
  RealPoint2D s1 ( myRadius*cos(myPhi + intervalle_lower*2.0*M_PI/myK),
       myRadius*sin(myPhi + intervalle_lower*2.0*M_PI/myK) );
  RealPoint2D s2 ( myRadius*cos(myPhi + intervalle_upper*2.0*M_PI/myK),
       myRadius*sin(myPhi + intervalle_upper*2.0*M_PI/myK) );
  s2 -= s1;
  
  //normalize
  double norm = s2.norm();
  s2[0] /= norm;
  s2[1] /= norm;
 
  return s2;
}

template <typename T>
inline
typename DGtal::NGon2D<T>::RealVector2D
DGtal::NGon2D<T>::xpp( const double /*t*/ ) const
{
  RealVector2D c(0,0);
  return c;
}


// Interface - public :

template <typename T>
inline
void
DGtal::NGon2D<T>::selfDisplay ( std::ostream & out ) const
{
  out << "[NGon2D] center= "<<myCenter<<" radius="<<myRadius<<" number of sides="<<myK
      << " phase-shift="<<myPhi;
}

template <typename T>
inline
bool
DGtal::NGon2D<T>::isValid() const
{
    return true;
}



// Implementation of inline functions                                        //

template <typename T>
inline
std::ostream&
DGtal::operator<< ( std::ostream & out, 
      const NGon2D<T> & object )
{
  object.selfDisplay( out );
  return out;
}

//                                                                           //