curve.hpp

Go to the documentation of this file.

/*
  CLAW - a C++ Library Absolutely Wonderful

  CLAW is a free library without any particular aim but being useful to 
  anyone.

  Copyright (C) 2005-2011 Julien Jorge

  This library 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 2.1 of the License, or (at your option) any later version.

  This library 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
  Lesser General Public License for more details.

  You should have received a copy of the GNU Lesser General Public
  License along with this library; if not, write to the Free Software
  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  contact: julien.jorge@gamned.org
*/
#ifndef __CLAW_MATH_CURVE_HPP__
#define __CLAW_MATH_CURVE_HPP__

#include <claw/coordinate_traits.hpp>
#include <list>
#include <vector>

namespace claw
{
  namespace math
  {
    template< typename C, typename Traits = coordinate_traits<C> >
    class curve
    {
    public:
      typedef C coordinate_type;

      typedef Traits traits_type;

      typedef typename traits_type::value_type value_type;

      class control_point
      {
      public:
        typedef C coordinate_type;

      public:
        control_point();
        explicit control_point( const coordinate_type& p );
        control_point
        ( const coordinate_type& p, const coordinate_type& input_direction,
          const coordinate_type& output_direction );

        const coordinate_type& get_position() const;
        const coordinate_type& get_input_direction() const;
        const coordinate_type& get_output_direction() const;

      private:
        coordinate_type m_position;

        coordinate_type m_input_direction;

        coordinate_type m_output_direction;

      }; // class control_point

    private:
      typedef std::list<control_point> control_point_list;

    public:
      typedef typename control_point_list::iterator iterator;

      typedef typename control_point_list::const_iterator const_iterator;

      class section
      {
      public:
        typedef C coordinate_type;

        typedef Traits traits_type;

        typedef typename traits_type::value_type value_type;

        typedef const_iterator iterator_type;

        class resolved_point
        {
        public:
          typedef C coordinate_type;

        public:
          resolved_point
          ( const coordinate_type& position, const section& s, const double t );

          const coordinate_type& get_position() const;
          const section& get_section() const;
          double get_date() const;

        private:
          coordinate_type m_position;

          section m_section;

          double m_date;

        }; // class resolved_point

      public:
        section( const iterator_type& origin, const iterator_type& end );

        coordinate_type get_point_at( double t ) const;
        coordinate_type get_tangent_at( double t ) const;
        std::vector<resolved_point>
        get_point_at_x( value_type x, bool off_domain = false  ) const;

        const iterator_type& get_origin() const;

        bool empty() const;

      private:
        value_type evaluate
        ( double t, value_type origin, value_type output_direction,
          value_type input_direction, value_type end ) const;
        value_type evaluate_derived
        ( double t, value_type origin, value_type output_direction,
          value_type input_direction, value_type end ) const;

        void ensure_ends_in_points
        ( std::vector<resolved_point>& p, bool ensure_origin,
          bool ensure_end ) const;

        std::vector<resolved_point>
        extract_domain_points( const std::vector<resolved_point>& p ) const;

        std::vector<double> get_roots
        ( value_type x, value_type origin, value_type output_direction,
          value_type input_direction, value_type end ) const;

        std::vector<double> get_roots_degree_2
        ( value_type a, value_type b, value_type c ) const;
        std::vector<double> get_roots_degree_3
        ( value_type a, value_type b, value_type c, value_type d ) const;

      private:
        iterator_type m_origin;

        iterator_type m_end;

      }; // class section

    public:
      void push_back( const control_point& p );
      void push_front( const control_point& p );
      void insert( const iterator& pos, const control_point& p );

      section get_section( const const_iterator& pos ) const;
      
      std::vector<typename section::resolved_point>
      get_point_at_x( value_type x, bool off_domain = false ) const;

      iterator begin();
      iterator end();
      const_iterator begin() const;
      const_iterator end() const;

    private:
      std::vector<typename section::resolved_point>
      get_point_at_x_before_origin( value_type x ) const;
      std::vector<typename section::resolved_point>
      get_point_at_x_after_end( value_type x ) const;

    private:
      control_point_list m_points;
      
    }; // class curve

  } // namespace math
} // namespace claw

#include "claw/impl/curve.tpp"

#endif // __CLAW_MATH_CURVE_HPP__