163 lines
5.2 KiB
C++
163 lines
5.2 KiB
C++
|
|
|
|
#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>
|
|
double length(ForIt begin, ForIt end)
|
|
{
|
|
typedef typename std::iterator_traits<ForIt>::value_type point_type;
|
|
|
|
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>
|
|
double area(ForIt begin, ForIt end)
|
|
{
|
|
typedef typename std::iterator_traits<ForIt>::value_type point_type;
|
|
|
|
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)) *
|
|
(tcg::point_traits<point_type>::x(*jt) - tcg::point_traits<point_type>::x(*it));
|
|
|
|
result += 0.5 *
|
|
(tcg::point_traits<point_type>::y(*begin) + tcg::point_traits<point_type>::y(*it)) *
|
|
(tcg::point_traits<point_type>::x(*begin) - tcg::point_traits<point_type>::x(*it));
|
|
}
|
|
|
|
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 point_type, typename iter_type>
|
|
void tripletToQuadratics(const point_type &a, const iter_type &bt, const point_type &c,
|
|
tcg::sequential_reader<std::vector<point_type>> &output)
|
|
{
|
|
//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 iter_type, typename containers_reader, typename toQuadsFunc>
|
|
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>
|
|
class StandardDeviationEvaluator
|
|
{
|
|
public:
|
|
typedef RanIt iterator_type;
|
|
typedef typename std::iterator_traits<RanIt>::difference_type diff_type;
|
|
typedef typename std::iterator_traits<RanIt>::value_type point_type;
|
|
typedef typename tcg::point_traits<point_type>::value_type value_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
|
|
std::vector<double> m_sums2_x, m_sums2_y; //!< Sums of the points coordinates' squares
|
|
std::vector<double> m_sums_xy; //!< Sums of the coordinates products
|
|
|
|
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; }
|
|
const std::vector<double> &sums_y() const { return m_sums_y; }
|
|
const std::vector<double> &sums2_x() const { return m_sums2_x; }
|
|
const std::vector<double> &sums2_y() const { return m_sums2_y; }
|
|
const std::vector<double> &sums_xy() const { return m_sums_xy; }
|
|
};
|
|
}
|
|
} //namespace tcg::polyline_ops
|
|
|
|
#ifdef INCLUDE_HPP
|
|
#include "hpp/polyline_ops.hpp"
|
|
#endif
|
|
|
|
#endif //TCG_POLYLINE_OPS
|