C++ TracePoint类代码示例

 /**
  * Calculate error distance, between last through this to next,
  * if this node is removed.  This metric provides for Douglas-Peuker
  * thinning.
  *
  * @param last Point previous in time to this node
  * @param node This node
  * @param next Point succeeding this node
  *
  * @return Distance error if this node is thinned
  */
 static unsigned distance_metric(const TracePoint& last,
                                 const TracePoint& node,
                                 const TracePoint& next) {
     const int d_this = last.flat_distance(node) + node.flat_distance(next);
     const int d_rem = last.flat_distance(next);
     return abs(d_this - d_rem);
 }

bool
AbstractContest::IsFinishAltitudeValid(const TracePoint& start,
                                       const TracePoint& finish) const
{
    return finish.GetIntegerAltitude() + (int)finish_alt_diff >=
           start.GetIntegerAltitude();
}

 /**
  * Calculate error distance, between last through this to next,
  * if this node is removed.  This metric provides for Douglas-Peuker
  * thinning.
  *
  * @param last Point previous in time to this node
  * @param node This node
  * @param next Point succeeding this node
  *
  * @return Distance error if this node is thinned
  */
 static unsigned DistanceMetric(const TracePoint &last,
                                const TracePoint &node,
                                const TracePoint &next) {
   const int d_this = last.FlatDistanceTo(node) + node.FlatDistanceTo(next);
   const int d_rem = last.FlatDistanceTo(next);
   return abs(d_this - d_rem);
 }

 gcc_const
 static TracePoint Invalid() {
   TracePoint point;
   point.Clear();
   ((SearchPoint &)point).SetInvalid();
   return point;
 }

 /**
  * Retrieve coordinate value from object given coordinate index
  * @param d WaypointEnvelope object
  * @param k index of coordinate
  *
  * @return Coordinate value
  */
 int operator() ( const TracePoint &d, const unsigned k) const {
   switch(k) {
   case 0:
     return d.get_flatLocation().Longitude;
   case 1:
     return d.get_flatLocation().Latitude;
   };
   return 0; 
 };

static void
PrintTracePoint(const TracePoint &point, std::ofstream& fs)
{
  fs << point.GetTime()
     << " " << point.GetLocation().longitude
     << " " << point.GetLocation().latitude
     << " " << point.GetAltitude()
     << " " << point.GetVario()
     << "\n";
}

 TraceDelta(const TracePoint &p_last, const TracePoint &p,
            const TracePoint &p_next)
     :point(p),
      elim_time(time_metric(p_last, p, p_next)),
      elim_distance(distance_metric(p_last, p, p_next)),
      delta_distance(p.flat_distance(p_last))
 {
     assert(elim_distance != null_delta);
 }

 TraceDelta(const TracePoint &p_last, const TracePoint &p,
            const TracePoint &p_next)
   :point(p),
    elim_time(TimeMetric(p_last, p, p_next)),
    elim_distance(DistanceMetric(p_last, p, p_next)),
    delta_distance(p.FlatDistanceTo(p_last))
 {
   assert(elim_distance != null_delta);
 }

 gcc_pure
 int GetMinimumFinishAltitude(const TracePoint &start) const {
   return start.GetIntegerAltitude() - finish_alt_diff;
 }

 gcc_pure
 int GetMaximumStartAltitude(const TracePoint &finish) const {
   return finish.GetIntegerAltitude() + finish_alt_diff;
 }

 void update(const TracePoint &p_last, const TracePoint &p_next) {
     elim_time = time_metric(p_last, point, p_next);
     elim_distance = distance_metric(p_last, point, p_next);
     delta_distance = point.flat_distance(p_last);
 }

 /** 
  * Calculate approximate squared (flat projected) distance between this point
  * and another
  * 
  * @param tp Point to calculate distance to
  * 
  * @return Approximate squared distance
  */
 gcc_pure
 unsigned approx_sq_dist(const TracePoint& tp) const {
   return dsqr(get_flatLocation().Longitude-tp.get_flatLocation().Longitude)+
     dsqr(get_flatLocation().Latitude-tp.get_flatLocation().Latitude);
 }

 /**
  * Calculate error time, between last through this to next,
  * if this node is removed.  This metric provides for fair thinning
  * (tendency to to result in equal time steps)
  *
  * @param last Point previous in time to this node
  * @param node This node
  * @param next Point succeeding this node
  *
  * @return Time delta if this node is thinned
  */
 static unsigned TimeMetric(const TracePoint &last, const TracePoint &node,
                            const TracePoint &next) {
   return next.DeltaTime(last)
     - std::min(next.DeltaTime(node), node.DeltaTime(last));
 }

 void Update(const TracePoint &p_last, const TracePoint &p_next) {
   elim_time = TimeMetric(p_last, point, p_next);
   elim_distance = DistanceMetric(p_last, point, p_next);
   delta_distance = point.FlatDistanceTo(p_last);
 }

 TriangleSecondLeg(bool _fai, const TracePoint &_a, const TracePoint &_b)
   :is_fai(_fai), a(_a), b(_b), df_1(a.flat_distance(b)) {}