Method Simplify

libs/map/routing_manager.cpp:1329–1392

}

void RoutingManager::DistanceAltitude::Simplify(double altitudeDeviation)
{
  class IterT
  {
    DistanceAltitude const & m_da;
    size_t m_ind = 0;

  public:
    IterT(DistanceAltitude const & da, bool isBeg) : m_da(da) { m_ind = isBeg ? 0 : m_da.GetSize(); }

    IterT(IterT const & rhs) = default;
    IterT & operator=(IterT const & rhs)
    {
      m_ind = rhs.m_ind;
      return *this;
    }

    bool operator!=(IterT const & rhs) const { return m_ind != rhs.m_ind; }

    IterT & operator++()
    {
      ++m_ind;
      return *this;
    }
    IterT operator+(size_t inc) const
    {
      IterT res = *this;
      res.m_ind += inc;
      return res;
    }
    int64_t operator-(IterT const & rhs) const { return int64_t(m_ind) - int64_t(rhs.m_ind); }

    m2::PointD operator*() const { return {m_da.m_distances[m_ind], double(m_da.m_altitudes[m_ind])}; }
  };

  std::vector<m2::PointD> out;

  // 1. Deviation from approximated altitude.
  //  double constexpr eps = 1.415; // ~sqrt(2)
  //  struct DeviationFromApproxY
  //  {
  //    double operator()(m2::PointD const & a, m2::PointD const & b, m2::PointD const & x) const
  //    {
  //      double f = (x.x - a.x) / (b.x - a.x);
  //      ASSERT(0 <= f && f <= 1, (f));  // distance is an icreasing function
  //      double const approxY = (1 - f) * a.y + f * b.y;
  //      return fabs(approxY - x.y);
  //    }
  //  } distFn;
  //  SimplifyNearOptimal(20 /* maxFalseLookAhead */, IterT(*this, true), IterT(*this, false),
  //                      eps, distFn, AccumulateSkipSmallTrg(distFn, out, eps));

  // 2. Default square distance from segment.
  SimplifyDefault(IterT(*this, true), IterT(*this, false), math::Pow2(altitudeDeviation), out);

  size_t const count = out.size();
  m_distances.resize(count);
  m_altitudes.resize(count);