StarShaped2D.ih

#include <cstdlib>

// IMPLEMENTATION of inline methods.

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


// ------------------------- star-shaped services -------------------------


template<typename TSpace>
inline
bool
DGtal::StarShaped2D<TSpace>::isInside( const Point & p ) const
{

  RealPoint prel(NumberTraits<typename Point::Component>::castToDouble(p[0]),
     NumberTraits<typename Point::Component>::castToDouble(p[1]));
  
  return this->isInside(prel);
}


template<typename TSpace>
inline
bool
DGtal::StarShaped2D<TSpace>::isInside( const RealPoint & p ) const
{
  double t = parameter( p );
  RealPoint x_rel = x( t );
  x_rel -= center();
  double d_x = x_rel[0]*x_rel[0] + x_rel[1]*x_rel[1];
  RealPoint p_rel( p );
  p_rel -= center();
  double d_p = p_rel[0]*p_rel[0] + p_rel[1]*p_rel[1];
   
  return d_p <= d_x;
}

template<typename TSpace>
inline
DGtal::Orientation
DGtal::StarShaped2D<TSpace>::orientation( const RealPoint & p ) const
{
  double t = parameter( p );
  RealPoint x_rel = x( t );
  x_rel -= center();
  double d_x = x_rel[0]*x_rel[0] + x_rel[1]*x_rel[1];
  RealPoint p_rel( p );
  p_rel -= center();
  double d_p = p_rel[0]*p_rel[0] + p_rel[1]*p_rel[1];

  if (d_p - d_x > 0.0)
    return OUTSIDE;
  else
    if (d_p - d_x < 0.0)
      return  INSIDE;
    else
      return ON;
}


template<typename TSpace>
inline
typename DGtal::StarShaped2D<TSpace>::RealPoint
DGtal::StarShaped2D<TSpace>::tangent( double t ) const
{
  RealPoint tgt( xp( t ) );
  double norm = tgt.norm();
  tgt /= norm;
  return tgt;
}


template<typename TSpace>
inline
typename DGtal::StarShaped2D<TSpace>::RealPoint
DGtal::StarShaped2D<TSpace>::normal( double t ) const
{
  RealPoint tgt( tangent( t ) );
  return RealPoint( -tgt[1], tgt[0]);
}


template<typename TSpace>
inline
double 
DGtal::StarShaped2D<TSpace>::curvature( double t ) const
{
  RealPoint tgt( xp( t ) );
  RealPoint dt( xpp( t ) );
  double norm = tgt.norm();
  double curv = ( dt[0] * tgt[1] - dt[1] * tgt[0] ) / ( norm * norm * norm );
  return - curv;
}
  

template<typename TSpace>
inline
double
DGtal::StarShaped2D<TSpace>::arclength( double t1, double t2, unsigned int nb ) const
{
  while ( t2 < t1 ) t2 += 2.0*M_PI;

  RealPoint x0( x( t1 ) );
  double l = 0.0;
  // JOL 2008/08/28
  for ( unsigned int i = 1; i <= nb; ++i )
    {
      double t = ( ( t2 - t1 ) * i ) / nb;
      RealPoint x1( x( t1 + t ) );
      l += sqrt( ( x1[0] - x0[0] )*( x1[0] - x0[0] )
         + ( x1[1] - x0[1] )*( x1[1] - x0[1] ) );
      x0 = x1;
    }
  return l;
}



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

// Interface - public :

template <typename T>
inline
void
DGtal::StarShaped2D<T>::selfDisplay ( std::ostream & out ) const
{
  out << "[StarShaped2D]";
}

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



// Implementation of inline functions                                        //

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

//                                                                           //