Esempio n. 1
0
FlatGeoPoint
RoutePolars::ReachIntercept(const int index, const AGeoPoint& origin,
                             const RasterMap* map,
                             const TaskProjection& proj) const
{
  const bool valid = map && map->IsDefined();
  const RoughAltitude altitude = origin.altitude - GetSafetyHeight();
  const AGeoPoint m_origin((GeoPoint)origin, altitude);
  const GeoPoint dest = MSLIntercept(index, m_origin, proj);
  const GeoPoint p = valid ?
    map->Intersection(m_origin, (short)altitude, (short)altitude, dest) : dest;
  return proj.ProjectInteger(p);
}
Esempio n. 2
0
FlatGeoPoint
RoutePolars::ReachIntercept(const int index, const AFlatGeoPoint &flat_origin,
                            const GeoPoint &origin,
                            const RasterMap* map,
                            const FlatProjection &proj) const
{
  const bool valid = map && map->IsDefined();
  const int altitude = flat_origin.altitude - GetSafetyHeight();
  const FlatGeoPoint flat_dest = MSLIntercept(index, flat_origin,
                                              altitude, proj);

  if (!valid)
    return flat_dest;

  const GeoPoint dest = proj.Unproject(flat_dest);
  const GeoPoint p = map->Intersection(origin, altitude,
                                       altitude, dest, height_min_working);

  if (!p.IsValid())
    return flat_dest;

  FlatGeoPoint fp = proj.ProjectInteger(p);

  /* when there's an obstacle very nearby and our intersection is
     right next to our origin, the intersection may be deformed due to
     terrain raster rounding errors; the following code applies
     clipping to avoid degenerate polygons */
  FlatGeoPoint delta1 = flat_dest - (FlatGeoPoint)flat_origin;
  FlatGeoPoint delta2 = fp - (FlatGeoPoint)flat_origin;

  if (delta1.x * delta2.x < 0)
    /* intersection is on the wrong horizontal side */
    fp.x = flat_origin.x;

  if (delta1.y * delta2.y < 0)
    /* intersection is on the wrong vertical side */
    fp.x = flat_origin.y;

  return fp;
}