Lemniscate2D.ih

/**
 *  This program is free software: you can redistribute it and/or modify
 *  it under the terms of the GNU Lesser General Public License as
 *  published by the Free Software Foundation, either version 3 of the
 *  License, or  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *
 **/
 
 /**
  * @file Lemniscate2D.ih
  * @author Chouaib Fellah, Adrien Krähenbühl (\c krahenbuhl@unistra.fr )
  * Laboratoire des sciences de l'ingénieur, de l'informatique et de l'imagerie - ICube (UMR 7357), France
  *
  * @date 2018/06/12
  *
  * Implementation of inline methods defined in Lemniscate2D.h
  *
  * This file is part of the DGtal library.
  */
 
///////////////////////////////////////////////////////////////////////////////
#include <cstdlib>
///////////////////////////////////////////////////////////////////////////////
 
#define LEMNISCATE2D_3_PI_2   (3. * M_PI / 2.)
 
///////////////////////////////////////////////////////////////////////////////
// IMPLEMENTATION of inline methods.
///////////////////////////////////////////////////////////////////////////////
 
///////////////////////////////////////////////////////////////////////////////
// ----------------------- Standard services ----------------------------------
 
template <typename T>
inline
DGtal::Lemniscate2D<T>::Lemniscate2D( const double x0, const double y0,
  const double a ) : myCenter(x0,y0), myA(fabs(a))
{}
 
template <typename T>
inline
DGtal::Lemniscate2D<T>::Lemniscate2D( const RealPoint &aPoint,
  const double a ) : myCenter(aPoint), myA(fabs(a))
{}
 
template <typename T>
inline
DGtal::Lemniscate2D<T>::Lemniscate2D(const Lemniscate2D& other ) :
  myCenter(other.myCenter), myA(other.myA)
{}
 
///////////////////////////////////////////////////////////////////////////////
// ------------- Implementation of 'StarShaped' services ----------------------
 
/**
 * @param pp any point in the plane.
 *
 * @return the angle parameter between 0 and 2*Pi corresponding to
 * this point for the shape.
 */
template <typename T>
inline
double
DGtal::Lemniscate2D<T>::parameter( const RealPoint& pp ) const
{
  const RealPoint p( pp-myCenter );
  double angle;
 
  if ( fabs(p[0]) < fabs(p[1]) )
    angle = 0.;
  else if ( isAlmostEqual(p[0],0.) )
    angle = p[1] < 0. ? M_PI : 0.;
  else if ( isAlmostEqual(p[1],0.) )
    angle = p[0] > 0. ? M_PI_2 : LEMNISCATE2D_3_PI_2;
  else
    angle = acos(p[1]/p[0]);
 
        return angle;
}
 
/**
 * @param t any angle between 0 and 2*Pi.
 *
 * @return the vector (x(t),y(t)) which is the position on the
 * shape boundary.
 */
template <typename T>
inline
typename DGtal::Lemniscate2D<T>::RealPoint
DGtal::Lemniscate2D<T>::x( const double t ) const
{
  const double cost = cos(t);
  const double sint = sin(t);
  const double cos2t = pow(cost,2);
  return RealPoint(
    myA * sint / (1. + cos2t) + myCenter[0],
    myA * sint * cost / (1. + cos2t) + myCenter[1]
  );
}
 
 
/**
 * @param t any angle between 0 and 2*Pi.
 *
 * @return the vector (x'(t),y'(t)) which is the tangent to the
 * shape boundary.
 */
template <typename T>
inline
typename DGtal::Lemniscate2D<T>::RealVector
DGtal::Lemniscate2D<T>::xp( const double t ) const
{
  const double cost  = cos(t);
  const double cos2t = pow(cost,2);
  const double sin2t = pow(sin(t),2);
 
  return RealVector(
    myA * (cost + 2*sin2t*cost+pow(cost,3)) / pow(1+cos2t,2),
    myA * (pow(cost,4) + cos2t - sin2t + sin2t * cos2t)
        / pow(1+cos2t,2) );
}
 
template <typename T>
inline
typename DGtal::Lemniscate2D<T>::RealVector
DGtal::Lemniscate2D<T>::xpp( const double t ) const
{
  const double cost = cos(t);
  const double cos2t = pow(cost,2);
  const double sint = sin(t);
  const double sin3t = pow(sint,3);
 
 return RealVector(
    myA * ( 4 * sin3t * cos2t +
            6 * sin3t * pow(cost,4) +
            3 * sint * cos2t -
            sint +
            9 * sint * pow(cost,4) +
            5 * pow(cost,6) * sint -
            2 * sin3t )
        / pow(1+cos2t,4),
 
    myA * ( -4* sin3t * pow(cost,3) -
            6 * sin3t * cost +
            2 * sin3t * pow(cost,5) -
            4 * sint * cost -
            6 * sint * pow(cost,3) +
            2 * sint * pow(cost,7) )
        / pow(1+cos2t,4)
  );
}
 
 
///////////////////////////////////////////////////////////////////////////////
// Interface - public :
 
/**
 * Writes/Displays the object on an output stream.
 * @param out the output stream where the object is written.
 */
template <typename T>
inline
void
DGtal::Lemniscate2D<T>::selfDisplay ( std::ostream & out ) const
{
  out << "[Lemniscate2D] center= " << myCenter
      << " a=" << myA;
}
 
/**
 * Checks the validity/consistency of the object.
 * @return 'true' if the object is valid, 'false' otherwise.
 */
template <typename T>
inline
bool
DGtal::Lemniscate2D<T>::isValid() const
{
  return true;
}
 
 
///////////////////////////////////////////////////////////////////////////////
// Implementation of inline functions                                        //
 
template <typename T>
inline
std::ostream&
DGtal::operator<< ( std::ostream & out,
      const Lemniscate2D<T> & object )
{
  object.selfDisplay( out );
  return out;
}
 
//                                                                           //
///////////////////////////////////////////////////////////////////////////////