#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) + tcg::point_traits<point_type>::y(*it)) *</point_type></point_type>

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

		result += 0.5 *

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

				  (tcg::point_traits<point_type>::x(*begin) - tcg::point_traits<point_type>::x(*it));</point_type></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::value_type, iter_type>,

				  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, m_sums2_y; //!< Sums of the points coordinates' squares</double>

	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