#pragma once

#ifndef TCG_POLYLINE_OPS

#define TCG_POLYLINE_OPS

// tcg includes

#include "traits.h"

#include "containers_reader.h"

#include "point.h"

#include "point_ops.h"

namespace tcg {

namespace polyline_ops {

//**************************************************************************************

//    Polyline Basic Operations

//**************************************************************************************

/*!

  Computes the length of the polyline between the specified point iterators.

  \return   The input polyline's length

*/

template <typename forit=""></typename>

double length(ForIt begin, ForIt end) {

  typedef typename std::iterator_traits<forit>::value_type point_type;</forit>

  double result = 0.0;

  for (ForIt jt = begin, it = ++jt; jt != end; it = jt, ++jt)

    result += tcg::point_ops::dist(*it, *jt);

  return result;

}

//-----------------------------------------------------------------------------

/*!

  Computes the area enclosed by the input polyline's \a closure.

  \note    The input polyline is implicitly \a connected at the endpoints

           with a straight segment. This has obviously makes no difference

           if the supplied polyline already had coincident endpoints.

  \return  The area enclosed by the polyline's \a closure.

*/

template <typename forit=""></typename>

double area(ForIt begin, ForIt end) {

  typedef typename std::iterator_traits<forit>::value_type point_type;</forit>

  double result = 0.0;

  if (begin != end) {

    ForIt jt = begin, it = jt++;

    for (; jt != end; it = jt++)

      result += 0.5 * (tcg::point_traits<point_type>::y(*jt) +</point_type>

                       tcg::point_traits<point_type>::y(*it)) *</point_type>

                (tcg::point_traits<point_type>::x(*jt) -</point_type>

                 tcg::point_traits<point_type>::x(*it));</point_type>

    result += 0.5 * (tcg::point_traits<point_type>::y(*begin) +</point_type>

                     tcg::point_traits<point_type>::y(*it)) *</point_type>

              (tcg::point_traits<point_type>::x(*begin) -</point_type>

               tcg::point_traits<point_type>::x(*it));</point_type>

  }

  return result;

}

//**************************************************************************************

//    Quadratic Conversions

//**************************************************************************************

/*!

  Standard direct conversion function used in polyline-to-quadratics conversion.

  Point a has already been inserted in the output; this function must add the

  remaining part of a sequence of quadratics approximating the triplet (a, *bt,

  c).

*/

// Note: typename iter_type::value_type == point_type

template <typename iter_type="" point_type,="" typename=""></typename>

void tripletToQuadratics(

    const point_type &a, const iter_type &bt, const point_type &c,

    tcg::sequential_reader<std::vector<point_type>> &output) {</std::vector<point_type>

  // Direct conversion

  output.addElement(*bt);

  output.addElement(c);

}

/*!

  Performs a conversion of the specified polyline into a sequence of quadratics,

then

  applies a quadratics sub-sequence optimal merging algorithm.

  A user-made local triplet-to-quadratics conversion can be supplied to

recognize corners

  or supply a tight starting approximation.

\warning Passed polylines with equal endpoints are interpreted as closed

(circular) polylines;

         in this case, the resulting endpoints of the quadratic sequence will be

displaced to

         the first segment mid-point.

*/

template <typename containers_reader,="" iter_type,="" toquadsfunc="" typename=""></typename>

void toQuadratics(

    iter_type begin, iter_type end, containers_reader &output,

    toQuadsFunc &toQuads =

        &tripletToQuadratics<typename iter_type="" iter_type::value_type,="">,</typename>

    double mergeTol = 1.0);

//**************************************************************************************

//    Standard Polyline Evaluators

//**************************************************************************************

/*!

  Calculates the (weighted) standard deviation of a polyline's sub-paths with

  respect

  to the segment connecting the endpoints.

  \warning For efficiency reasons, the returned value is the actual standard

  deviation, times the endpoints-segment length.

*/

template <typename ranit=""></typename>

class StandardDeviationEvaluator {

public:

  typedef RanIt iterator_type;

  typedef typename std::iterator_traits<ranit>::difference_type diff_type;</ranit>

  typedef typename std::iterator_traits<ranit>::value_type point_type;</ranit>

  typedef typename tcg::point_traits<point_type>::value_type value_type;</point_type>

  typedef double penalty_type;

protected:

  iterator_type m_begin, m_end;

  std::vector<double> m_sums_x, m_sums_y;  //!< Sums of the points coordinates</double>

  std::vector<double> m_sums2_x,</double>

      m_sums2_y;                  //!< Sums of the points coordinates' squares

  std::vector<double> m_sums_xy;  //!< Sums of the coordinates products</double>

public:

  StandardDeviationEvaluator(const iterator_type &begin,

                             const iterator_type &end);

  penalty_type penalty(const iterator_type &a, const iterator_type &b);

  const iterator_type &begin() const { return m_begin; }

  const iterator_type &end() const { return m_end; }

  const std::vector<double> &sums_x() const { return m_sums_x; }</double>

  const std::vector<double> &sums_y() const { return m_sums_y; }</double>

  const std::vector<double> &sums2_x() const { return m_sums2_x; }</double>

  const std::vector<double> &sums2_y() const { return m_sums2_y; }</double>

  const std::vector<double> &sums_xy() const { return m_sums_xy; }</double>

};

}

}  // namespace tcg::polyline_ops

#ifdef INCLUDE_HPP

#include "hpp/polyline_ops.hpp"

#endif

#endif  // TCG_POLYLINE_OPS