bool AirspaceFilterData::Match(const GeoPoint &location, const FlatProjection &projection, const AbstractAirspace &as) const { if (cls != AirspaceClass::AIRSPACECLASSCOUNT && as.GetType() != cls) return false; if (name_prefix != nullptr && !as.MatchNamePrefix(name_prefix)) return false; if (!direction.IsNegative()) { const auto closest = as.ClosestPoint(location, projection); const auto bearing = location.Bearing(closest); auto direction_error = (bearing - direction).AsDelta().AbsoluteDegrees(); if (direction_error > fixed(18)) return false; } if (!negative(distance)) { const auto closest = as.ClosestPoint(location, projection); const auto distance = location.Distance(closest); if (distance > distance) return false; } return true; }
void AddCircle(Airspaces &airspace_database) { AbstractAirspace *as = new AirspaceCircle(Center, Radius); as->set_properties(Name, Type, Base, Top); airspace_database.insert(as); }
/** * 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; } }
bool AirspacePredicateHeightRangeExcludeTwo::operator()(const AbstractAirspace& t) const { if (!check_height(t)) return false; return !t.inside(p1) && !t.inside(p2); }
void AddPolygon(Airspaces &airspace_database) { AbstractAirspace *as = new AirspacePolygon(points); as->set_properties(Name, Type, Base, Top); airspace_database.insert(as); }
bool AirspacePredicateHeightRangeExcludeTwo::condition(const AbstractAirspace& t) const { if (!check_height(t)) return false; return !t.Inside(p1) && !t.Inside(p2); }
virtual bool operator()(const AbstractAirspace &airspace) const { return CheckAirspace(airspace) && /* skip airspaces that we already entered */ !airspace.Inside(location) && /* check altitude; hard-coded margin of 50m (for now) */ (!altitude_available || (airspace.GetBase().IsBelow(altitude, fixed(50)) && airspace.GetTop().IsAbove(altitude, fixed(50)))); }
virtual void visit_general(const AbstractAirspace& as) { if (do_report) { #ifdef DO_PRINT *fout << "# Name: " << as.get_name_text() << " " << as.get_vertical_text() << "\n"; #endif } }
void AddPolygon(Airspaces &airspace_database) { AbstractAirspace *as = new AirspacePolygon(points); as->set_properties(Name, Type, Base, Top); as->set_radio(Radio); as->set_days(days_of_operation); airspace_database.insert(as); }
void AddPolygon(Airspaces &airspace_database) { AbstractAirspace *as = new AirspacePolygon(points); as->SetProperties(name, type, base, top); as->SetRadio(radio); as->SetDays(days_of_operation); airspace_database.Add(as); }
void Visit(const AbstractAirspace &as) { if (do_report) { *fout << as; *fout << "# Name: " << as.GetName() << "Base: " << as.GetBase() << " Top: " << as.GetTop() << "\n"; } }
void AddCircle(Airspaces &airspace_database) { AbstractAirspace *as = new AirspaceCircle(center, radius); as->SetProperties(std::move(name), type, base, top); as->SetRadio(radio); as->SetDays(days_of_operation); airspace_database.Add(as); }
void write_border (const AbstractAirspace& as) { const SearchPointVector& spv = as.GetPoints(); for (auto v = spv.begin(); v != spv.end(); ++v) write_point(*v, v->get_flatLocation(), "polygon"); printf("polygon\n"); write_spv(as.GetClearance()); fflush(stdout); }
void AddPolygon(Airspaces &airspace_database) { if (points.size() < 3) return; AbstractAirspace *as = new AirspacePolygon(points); as->SetProperties(std::move(name), type, base, top); as->SetRadio(radio); as->SetDays(days_of_operation); airspace_database.Add(as); }
AirspaceInterceptSolution AirspaceNearestSort::solve_intercept(const AbstractAirspace &a) const { if (a.Inside(m_location)) { return AirspaceInterceptSolution::Invalid(); } else { AirspaceInterceptSolution sol; sol.location = a.ClosestPoint(m_location); sol.distance = sol.location.Distance(m_location); return sol; } }
/** * Renders the AbstractAirspace on the canvas * @param as AbstractAirspace to render */ void Render(const AbstractAirspace& as) { int type = as.get_type(); if (type <= 0) return; // No intersections for this airspace if (m_intersections.empty()) return; // Select pens and brushes #ifdef ENABLE_SDL Color color = Graphics::GetAirspaceColour(settings.colours[type]); #ifdef ENABLE_OPENGL color = color.with_alpha(48); #endif Brush brush(color); #else const Brush &brush = Graphics::GetAirspaceBrushByClass(type, settings); canvas.set_text_color(light_color(Graphics::GetAirspaceColourByClass(type, settings))); #endif PixelRect rcd; // Calculate top and bottom coordinate rcd.top = chart.screenY(as.get_top_altitude(state)); if (as.is_base_terrain()) rcd.bottom = chart.screenY(fixed_zero); else rcd.bottom = chart.screenY(as.get_base_altitude(state)); // Iterate through the intersections for (AirspaceIntersectionVector::const_iterator it = m_intersections.begin(); it != m_intersections.end(); ++it) { const GeoPoint p_start = it->first; const GeoPoint p_end = it->second; const fixed distance_start = start.distance(p_start); const fixed distance_end = start.distance(p_end); // Determine left and right coordinate rcd.left = chart.screenX(distance_start); rcd.right = chart.screenX(distance_end); // only one edge found, next edge must be beyond screen if ((rcd.left == rcd.right) && (p_start == p_end)) { rcd.right = chart.screenX(chart.getXmax()); } // Draw the airspace RenderBox(rcd, brush, settings.black_outline, type); } }
AirspaceInterceptSolution AirspaceNearestSort::solve_intercept(const AbstractAirspace &a) const { if (a.inside(m_location)) { AirspaceInterceptSolution null_sol; return null_sol; } else { AirspaceInterceptSolution sol; sol.location = a.closest_point(m_location); sol.distance = sol.location.distance(m_location); return sol; } }
/** * Renders the AbstractAirspace on the canvas * @param as AbstractAirspace to render */ void Render(const AbstractAirspace& as) { int type = as.GetType(); if (type <= 0) return; // No intersections for this airspace if (m_intersections.empty()) return; // Select pens and brushes #ifndef USE_GDI Color color = airspace_look.colors[settings.colours[type]]; #ifdef ENABLE_OPENGL color = color.WithAlpha(48); #endif Brush brush(color); #else const Brush &brush = airspace_look.brushes[settings.brushes[type]]; canvas.SetTextColor(LightColor(airspace_look.colors[settings.colours[type]])); #endif PixelRect rcd; // Calculate top and bottom coordinate rcd.top = chart.screenY(as.GetTopAltitude(state)); if (as.IsBaseTerrain()) rcd.bottom = chart.screenY(fixed_zero); else rcd.bottom = chart.screenY(as.GetBaseAltitude(state)); // Iterate through the intersections for (auto it = m_intersections.begin(); it != m_intersections.end(); ++it) { const GeoPoint p_start = it->first; const GeoPoint p_end = it->second; const fixed distance_start = start.Distance(p_start); const fixed distance_end = start.Distance(p_end); // Determine left and right coordinate rcd.left = chart.screenX(distance_start); rcd.right = chart.screenX(distance_end); // only one edge found, next edge must be beyond screen if ((rcd.left == rcd.right) && (p_start == p_end)) { rcd.right = chart.screenX(chart.getXmax()); } // Draw the airspace RenderBox(rcd, brush, settings.black_outline, type); } }
Airspace::Airspace(AbstractAirspace& airspace, const TaskProjection& tp): FlatBoundingBox(airspace.GetBoundingBox(tp)), pimpl_airspace(&airspace) { pimpl_airspace->SetTaskProjection(tp); }
void setup_outline(const AbstractAirspace &airspace) { if (settings.black_outline) canvas.SelectBlackPen(); else canvas.Select(airspace_look.pens[airspace.GetType()]); canvas.SelectHollowBrush(); }
AirspaceInterceptSolution AirspaceSoonestSort::solve_intercept(const AbstractAirspace &a) const { const GeoPoint loc = a.closest_point(m_state.Location); AirspaceInterceptSolution sol; 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_one; } return sol; }
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"; } } }
bool operator()(const AbstractAirspace& airspace) const { // Airspace should be visible or have a warning/inside status // and airspace needs to be at specified location return (visible_predicate(airspace) || warnings.Contains(airspace)) && airspace.Inside(location); }
virtual void closest(const AbstractAirspace& as) { GeoPoint c = as.closest_point(state.Location); #ifdef DO_PRINT *fout << "# closest point\n"; *fout << c.Longitude << " " << c.Latitude << " " << "\n"; *fout << state.Location.Longitude << " " << state.Location.Latitude << " " << "\n\n"; #endif AirspaceInterceptSolution solution; GeoVector vec(state.Location, c); vec.Distance = fixed(20000); // set big distance (for testing) if (as.intercept(state, vec, m_perf, solution)) { #ifdef DO_PRINT *fout << "# intercept in " << solution.elapsed_time << " h " << solution.altitude << "\n"; #endif } }
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); }
void airspace_random_properties(AbstractAirspace& as) { AirspaceClass_t Type = (AirspaceClass_t)(rand()%15); AIRSPACE_ALT base; AIRSPACE_ALT top; base.Altitude = fixed(rand()%2000); top.Altitude = base.Altitude+fixed(rand()%3000); as.set_properties(_T("hello"), Type, base, top); }
gcc_pure static bool CheckAirspace(const AbstractAirspace &airspace) { const AirspaceWarningConfig &config = CommonInterface::GetComputerSettings().airspace.warnings; return config.IsClassEnabled(airspace.GetType()) && !IsAcked(airspace); }
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; }
void visit_abstract(const AbstractAirspace &as) { assert(!m_intersections.empty()); GeoPoint point = m_intersections[0].first; RouteLink l = rpolar.generate_intermediate(link.first, RoutePoint(proj.project(point), link.second.altitude), proj); if ((l.second.altitude< (short)as.get_base().Altitude) || (l.second.altitude> (short)as.get_top().Altitude)) return; if (negative(min_distance) || (l.d < min_distance)) { min_distance = l.d; nearest = std::make_pair(&as, l.second); } }
static void airspace_random_properties(AbstractAirspace& as) { AirspaceClass Type = (AirspaceClass)(rand()%14); AirspaceAltitude base; AirspaceAltitude top; base.altitude = fixed(rand()%4000); top.altitude = base.altitude+fixed(rand()%3000); as.SetProperties(_T("hello"), Type, base, top); }