curve.h

Go to the documentation of this file.

/* This software and supporting documentation are distributed by
 *     Institut Federatif de Recherche 49
 *     CEA/NeuroSpin, Batiment 145,
 *     91191 Gif-sur-Yvette cedex
 *     France
 *
 * This software is governed by the CeCILL-B license under
 * French law and abiding by the rules of distribution of free software.
 * You can  use, modify and/or redistribute the software under the
 * terms of the CeCILL-B license as circulated by CEA, CNRS
 * and INRIA at the following URL "http://www.cecill.info".
 *
 * As a counterpart to the access to the source code and  rights to copy,
 * modify and redistribute granted by the license, users are provided only
 * with a limited warranty  and the software's author,  the holder of the
 * economic rights,  and the successive licensors  have only  limited
 * liability.
 *
 * In this respect, the user's attention is drawn to the risks associated
 * with loading,  using,  modifying and/or developing or reproducing the
 * software by the user in light of its specific status of free software,
 * that may mean  that it is complicated to manipulate,  and  that  also
 * therefore means  that it is reserved for developers  and  experienced
 * professionals having in-depth computer knowledge. Users are therefore
 * encouraged to load and test the software's suitability as regards their
 * requirements in conditions enabling the security of their systems and/or
 * data to be ensured and,  more generally, to use and operate it in the
 * same conditions as regards security.
 *
 * The fact that you are presently reading this means that you have had
 * knowledge of the CeCILL-B license and that you accept its terms.
 */
 
#ifndef AIMS_CURVE_CURVE_H
#define AIMS_CURVE_CURVE_H
 
#include <aims/vector/vector.h>
#include <cartobase/smart/rcptr.h>
#include <vector>
#include <exception>
 
namespace aims
{
 
 
  //------------//
 //  Polyline  //
//------------//
 
class Polyline
{
public:
 
  typedef float Scalar_t;
  typedef AimsVector< Scalar_t, 3 > Point_t;
  typedef std::vector< Point_t >::const_iterator const_iterator;

  inline size_t size() const;
  bool push_back( const Point_t & );
  inline const_iterator begin() const;

  inline const_iterator end() const;
  inline const Point_t &operator []( size_t ) const;
  inline void reserve( size_t );
  inline void clear();

  Scalar_t length() const;

  void resample( size_t numberOfPoints, std::vector< Point_t > & );
 
private:
 
  std::vector< Point_t > _points;
};
 
 
 
  //----------------------------------//
 //  PolylinePolynomialInterpolator  //
//----------------------------------//
 
class PolylinePolynomialInterpolator
{
public:
 
  typedef Polyline::Point_t Tangent_t;
 
  inline PolylinePolynomialInterpolator( const Polyline & );
  inline PolylinePolynomialInterpolator( const Polyline &,
                                         const std::vector< Tangent_t > & );
  void reset( const Polyline & );
  void reset( const Polyline &, 
              const std::vector< Tangent_t > & );
 
  Polyline::Scalar_t length() const;
 
  class Sampler {
  public:
    bool isValid() const;
    void step( Polyline::Scalar_t );
    Polyline::Point_t point() const;
    PolylinePolynomialInterpolator::Tangent_t tangent() const;
    Polyline::Scalar_t curvature() const;
    PolylinePolynomialInterpolator::Tangent_t normal() const;
 
  private:
    friend class PolylinePolynomialInterpolator;
 
    Sampler( const PolylinePolynomialInterpolator &,
             Polyline::Scalar_t start );
 
    const PolylinePolynomialInterpolator &_interpolator;
    Polyline::Scalar_t _lengthFromStart;
    unsigned _splineIndex;
    Polyline::Scalar_t _lengthInSpline;
 
  };
 
  inline Sampler sampler( Polyline::Scalar_t start = 0 ) const;
 
 
private:
 
  struct Spline {
    Tangent_t a, b, c, d;
    Polyline::Scalar_t length;
  };
 
  friend Polyline::Scalar_t 
  splineArcLength( const Spline &si,
                   const Polyline::Scalar_t &from,
                   const Polyline::Scalar_t &to );
  friend class Sampler;
 
  std::vector< Spline > _splines;
};
 
 
 
  //------------//
 //  Polyline  //
//------------//
 
//-----------------------------------------------------------------------------
inline size_t Polyline::size() const
{
  return _points.size();
}
 
 
//-----------------------------------------------------------------------------
inline Polyline::const_iterator Polyline::begin() const
{
  return _points.begin();
}
 
 
//-----------------------------------------------------------------------------
inline Polyline::const_iterator Polyline::end() const
{
  return _points.end();
}
 
 
//-----------------------------------------------------------------------------
inline const Polyline::Point_t &Polyline::operator []( size_t index ) const
{
  return _points[ index ];
}
 
 
//-----------------------------------------------------------------------------
inline void Polyline::reserve( size_t space )
{
  return _points.reserve( space );
}
 
 
//-----------------------------------------------------------------------------
inline void Polyline::clear()
{
  return _points.clear();
}
 
 
  //----------------------------------//
 //  PolylinePolynomialInterpolator  //
//----------------------------------//
 
//-----------------------------------------------------------------------------
inline PolylinePolynomialInterpolator::PolylinePolynomialInterpolator
( const Polyline &line )
{
  reset( line );
}
 
//-----------------------------------------------------------------------------
inline PolylinePolynomialInterpolator::PolylinePolynomialInterpolator
( const Polyline &line,
  const std::vector< Tangent_t > &tangents )
{
  reset( line, tangents );
}
 
 
//-----------------------------------------------------------------------------
inline PolylinePolynomialInterpolator::Sampler
PolylinePolynomialInterpolator::sampler( Polyline::Scalar_t start ) const
{
  return Sampler( *this, start );
}
 
 
 
} // namespace aims
 
#endif // ifndef AIMS_CURVE_H