示例#1
0
  /**
   * Check whether this intersection should be added to, or updated in, the warning manager
   *
   * @param airspace Airspace corresponding to current intersection
   */
  void Intersection(const AbstractAirspace& airspace) {
    if (!airspace.IsActive())
      return; // ignore inactive airspaces completely

    if (!warning_manager.GetConfig().IsClassEnabled(airspace.GetType()) ||
        ExcludeAltitude(airspace))
      return;

    AirspaceWarning *warning = warning_manager.GetWarningPtr(airspace);
    if (warning == NULL || warning->IsStateAccepted(warning_state)) {

      AirspaceInterceptSolution solution;

      if (mode_inside) {
        airspace.Intercept(state, perf, solution, state.location, state.location);
      } else {
        solution = Intercept(airspace, state, perf);
      }
      if (!solution.IsValid())
        return;
      if (solution.elapsed_time > max_time)
        return;

      if (warning == NULL)
        warning = warning_manager.GetNewWarningPtr(airspace);

      warning->UpdateSolution(warning_state, solution);
      found = true;
    }
  }
AirspaceInterceptSolution 
AirspaceIntersectionVisitor::Intercept(const AbstractAirspace &as,
                                       const AircraftState &state,
                                       const AirspaceAircraftPerformance &perf) const
{
  if (intersections.empty())
    return AirspaceInterceptSolution::Invalid();

  AirspaceInterceptSolution solution;
  for (const auto &i : intersections)
    as.Intercept(state, perf, solution, i.first, i.second);

  return solution;
}
示例#3
0
 void closest(const AbstractAirspace &as) {
   GeoPoint c = as.ClosestPoint(state.location, projection);
   if (fout) {
     *fout << "# closest point\n";
     *fout << c.longitude << " " << c.latitude << " " << "\n";
     *fout << state.location.longitude << " " << state.location.latitude << " " << "\n\n";
   }
   AirspaceInterceptSolution solution;
   GeoVector vec(state.location, c);
   vec.distance = fixed(20000); // set big distance (for testing)
   if (as.Intercept(state, vec.EndPoint(state.location), projection, m_perf, solution)) {
     if (fout) {
       *fout << "# intercept in " << solution.elapsed_time << " h " << solution.altitude << "\n";
     }
   }
 }
示例#4
0
static inline SoonestAirspace
CalculateSoonestAirspace(const AircraftState &state,
                         const AirspaceAircraftPerformance &perf,
                         const double max_time,
                         const FlatProjection &projection,
                         const AbstractAirspace &airspace)
{
  const auto closest = airspace.ClosestPoint(state.location, projection);
  assert(closest.IsValid());

  const auto solution = airspace.Intercept(state, perf, closest, closest);
  if (!solution.IsValid() ||
      solution.elapsed_time > max_time)
    return SoonestAirspace();

  return SoonestAirspace(airspace, solution.elapsed_time);
}
示例#5
0
AirspaceInterceptSolution
AirspaceSoonestSort::solve_intercept(const AbstractAirspace &a,
                                     const TaskProjection &projection) const
{
  const GeoPoint loc = a.ClosestPoint(m_state.location, projection);

  AirspaceInterceptSolution sol =
    AirspaceInterceptSolution::Invalid();
  bool valid = a.Intercept(m_state, m_perf, sol, loc, loc);

  if (sol.elapsed_time > m_max_time) {
    valid = false;
  }
  if (!valid) {
    sol.elapsed_time = fixed(-1);
  }
  return sol;
}