static void
test_glide_alt(const fixed h, const fixed W, const fixed Wangle,
std::ostream &hfile)
{
GlideSettings settings;
settings.SetDefaults();
GlidePolar polar(fixed(0));
polar.SetMC(fixed(1));
AircraftState ac;
ac.wind.norm = fabs(W);
if (negative(W)) {
ac.wind.bearing = Angle::Degrees(fixed(180)+Wangle);
} else {
ac.wind.bearing = Angle::Degrees(Wangle);
}
ac.altitude = h;
GeoVector vect(fixed(400.0), Angle::Zero());
GlideState gs(vect, fixed(0), ac.altitude, ac.wind);
GlideResult gr = MacCready::Solve(settings, polar, gs);
hfile << (double)h << " "
<< (double)gr.altitude_difference << " "
<< (double)gr.time_elapsed << " "
<< (double)gr.v_opt << " "
<< (double)W << " "
<< (double)Wangle << " "
<< "\n";
}
static void
test_glide_cb(const fixed h, const fixed W, const fixed Wangle,
std::ostream &hfile)
{
GlideSettings settings;
settings.SetDefaults();
GlidePolar polar(fixed(1));
AircraftState ac;
ac.wind.norm = fabs(W);
if (negative(W)) {
ac.wind.bearing = Angle::Degrees(fixed(180)+Wangle);
} else {
ac.wind.bearing = Angle::Degrees(Wangle);
}
ac.altitude = h;
GeoVector vect(fixed(400.0), Angle::Zero());
GlideState gs (vect, fixed(0), ac.altitude, ac.wind);
GlideResult gr = MacCready::Solve(settings, polar, gs);
gr.CalcDeferred();
hfile << (double)W << " "
<< (double)Wangle << " "
<< (double)gr.vector.bearing.Degrees() << " "
<< (double)gr.cruise_track_bearing.Degrees() << " "
<< "\n";
}
static void test_reach(const RasterMap& map, fixed mwind, fixed mc)
{
GlideSettings settings;
settings.SetDefaults();
GlidePolar polar(mc);
SpeedVector wind(Angle::Degrees(0), mwind);
TerrainRoute route;
route.UpdatePolar(settings, polar, polar, wind);
route.SetTerrain(&map);
GeoPoint origin(map.GetMapCenter());
fixed pd = map.PixelDistance(origin, 1);
printf("# pixel size %g\n", (double)pd);
bool retval= true;
short horigin = map.GetHeight(origin)+1000;
AGeoPoint aorigin(origin, RoughAltitude(horigin));
RoutePlannerConfig config;
config.SetDefaults();
retval = route.SolveReach(aorigin, config, RoughAltitude::Max());
ok(retval, "reach solve", 0);
PrintHelper::print_reach_tree(route);
GeoPoint dest(origin.longitude-Angle::Degrees(0.02),
origin.latitude-Angle::Degrees(0.02));
{
Directory::Create(_T("output/results"));
std::ofstream fout("output/results/terrain.txt");
unsigned nx = 100;
unsigned ny = 100;
for (unsigned i=0; i< nx; ++i) {
for (unsigned j=0; j< ny; ++j) {
fixed fx = (fixed)i / (nx - 1) * 2 - fixed(1);
fixed fy = (fixed)j / (ny - 1) * 2 - fixed(1);
GeoPoint x(origin.longitude + Angle::Degrees(fixed(0.6) * fx),
origin.latitude + Angle::Degrees(fixed(0.6) * fy));
short h = map.GetInterpolatedHeight(x);
AGeoPoint adest(x, RoughAltitude(h));
ReachResult reach;
route.FindPositiveArrival(adest, reach);
if ((i % 5 == 0) && (j % 5 == 0)) {
AGeoPoint ao2(x, RoughAltitude(h + 1000));
route.SolveReach(ao2, config, RoughAltitude::Max());
}
fout << x.longitude.Degrees() << " "
<< x.latitude.Degrees() << " "
<< h << " " << (int)reach.terrain << "\n";
}
fout << "\n";
}
fout << "\n";
}
}
int main(int argc, char **argv)
{
plan_tests(2095);
glide_settings.SetDefaults();
TestAll();
glide_polar.SetMC(fixed(0.1));
TestAll();
glide_polar.SetMC(fixed(1));
TestAll();
glide_polar.SetMC(fixed(4));
TestAll();
glide_polar.SetMC(fixed(10));
TestAll();
return exit_status();
}
static bool
test_route(const unsigned n_airspaces, const RasterMap& map)
{
Airspaces airspaces;
setup_airspaces(airspaces, map.GetMapCenter(), n_airspaces);
{
std::ofstream fout("results/terrain.txt");
unsigned nx = 100;
unsigned ny = 100;
GeoPoint origin(map.GetMapCenter());
for (unsigned i = 0; i < nx; ++i) {
for (unsigned j = 0; j < ny; ++j) {
fixed fx = (fixed)i / (nx - 1) * fixed(2.0) - fixed_one;
fixed fy = (fixed)j / (ny - 1) * fixed(2.0) - fixed_one;
GeoPoint x(origin.longitude + Angle::Degrees(fixed(0.2) + fixed(0.7) * fx),
origin.latitude + Angle::Degrees(fixed(0.9) * fy));
short h = map.GetInterpolatedHeight(x);
fout << x.longitude.Degrees() << " " << x.latitude.Degrees()
<< " " << h << "\n";
}
fout << "\n";
}
fout << "\n";
}
{
// local scope, see what happens when we go out of scope
GeoPoint p_start(Angle::Degrees(fixed(-0.3)), Angle::Degrees(fixed(0.0)));
p_start += map.GetMapCenter();
GeoPoint p_dest(Angle::Degrees(fixed(0.8)), Angle::Degrees(fixed(-0.7)));
p_dest += map.GetMapCenter();
AGeoPoint loc_start(p_start, RoughAltitude(map.GetHeight(p_start) + 100));
AGeoPoint loc_end(p_dest, RoughAltitude(map.GetHeight(p_dest) + 100));
AircraftState state;
GlidePolar glide_polar(fixed(0.1));
AirspaceAircraftPerformanceGlide perf(glide_polar);
GeoVector vec(loc_start, loc_end);
fixed range = fixed(10000) + vec.distance / 2;
state.location = loc_start;
state.altitude = loc_start.altitude;
{
Airspaces as_route(airspaces, false);
// dummy
// real one, see if items changed
as_route.synchronise_in_range(airspaces, vec.MidPoint(loc_start), range);
int size_1 = as_route.size();
if (verbose)
printf("# route airspace size %d\n", size_1);
as_route.synchronise_in_range(airspaces, vec.MidPoint(loc_start), fixed_one);
int size_2 = as_route.size();
if (verbose)
printf("# route airspace size %d\n", size_2);
ok(size_2 < size_1, "shrink as", 0);
// go back
as_route.synchronise_in_range(airspaces, vec.MidPoint(loc_end), range);
int size_3 = as_route.size();
if (verbose)
printf("# route airspace size %d\n", size_3);
ok(size_3 >= size_2, "grow as", 0);
// and again
as_route.synchronise_in_range(airspaces, vec.MidPoint(loc_start), range);
int size_4 = as_route.size();
if (verbose)
printf("# route airspace size %d\n", size_4);
ok(size_4 >= size_3, "grow as", 0);
scan_airspaces(state, as_route, perf, true, loc_end);
}
// try the solver
SpeedVector wind(Angle::Degrees(fixed(0)), fixed(0.0));
GlidePolar polar(fixed_one);
GlideSettings settings;
settings.SetDefaults();
AirspaceRoute route(airspaces);
route.UpdatePolar(settings, polar, polar, wind);
route.SetTerrain(&map);
RoutePlannerConfig config;
config.mode = RoutePlannerConfig::Mode::BOTH;
bool sol = false;
for (int i = 0; i < NUM_SOL; i++) {
loc_end.latitude += Angle::Degrees(fixed(0.1));
loc_end.altitude = map.GetHeight(loc_end) + 100;
route.Synchronise(airspaces, loc_start, loc_end);
if (route.Solve(loc_start, loc_end, config)) {
sol = true;
if (verbose) {
PrintHelper::print_route(route);
}
} else {
if (verbose) {
printf("# fail\n");
}
sol = false;
}
char buffer[80];
sprintf(buffer, "route %d solution", i);
ok(sol, buffer, 0);
}
}
return true;
}
static void
test_troute(const RasterMap& map, fixed mwind, fixed mc, RoughAltitude ceiling)
{
GlideSettings settings;
settings.SetDefaults();
GlidePolar polar(mc);
SpeedVector wind(Angle::Degrees(0), mwind);
TerrainRoute route;
route.UpdatePolar(settings, polar, polar, wind);
route.SetTerrain(&map);
GeoPoint origin(map.GetMapCenter());
fixed pd = map.PixelDistance(origin, 1);
printf("# pixel size %g\n", (double)pd);
bool retval= true;
{
Directory::Create(_T("output/results"));
std::ofstream fout ("output/results/terrain.txt");
unsigned nx = 100;
unsigned ny = 100;
for (unsigned i=0; i< nx; ++i) {
for (unsigned j=0; j< ny; ++j) {
fixed fx = (fixed)i / (nx - 1) * 2 - fixed(1);
fixed fy = (fixed)j / (ny - 1) * 2 - fixed(1);
GeoPoint x(origin.longitude + Angle::Degrees(fixed(0.6) * fx),
origin.latitude + Angle::Degrees(fixed(0.4) * fy));
short h = map.GetInterpolatedHeight(x);
fout << x.longitude.Degrees() << " " << x.latitude.Degrees() << " " << h << "\n";
}
fout << "\n";
}
fout << "\n";
}
RoutePlannerConfig config;
config.mode = RoutePlannerConfig::Mode::BOTH;
unsigned i=0;
for (fixed ang = fixed(0); ang < fixed_two_pi; ang += fixed(M_PI / 8)) {
GeoPoint dest = GeoVector(fixed(40000.0), Angle::Radians(ang)).EndPoint(origin);
short hdest = map.GetHeight(dest)+100;
retval = route.Solve(AGeoPoint(origin,
RoughAltitude(map.GetHeight(origin) + 100)),
AGeoPoint(dest,
RoughAltitude(positive(mc)
? hdest
: std::max(hdest, (short)3200))),
config, ceiling);
char buffer[80];
sprintf(buffer,"terrain route solve, dir=%g, wind=%g, mc=%g ceiling=%d",
(double)ang, (double)mwind, (double)mc, (int)ceiling);
ok(retval, buffer, 0);
PrintHelper::print_route(route);
i++;
}
// polar.SetMC(fixed(0));
// route.UpdatePolar(polar, wind);
}
static void
test_troute(const RasterMap &map, double mwind, double mc, int ceiling)
{
GlideSettings settings;
settings.SetDefaults();
RoutePlannerConfig config;
config.mode = RoutePlannerConfig::Mode::BOTH;
GlidePolar polar(mc);
SpeedVector wind(Angle::Degrees(0), mwind);
TerrainRoute route;
route.UpdatePolar(settings, config, polar, polar, wind);
route.SetTerrain(&map);
GeoPoint origin(map.GetMapCenter());
auto pd = map.PixelDistance(origin, 1);
printf("# pixel size %g\n", (double)pd);
bool retval= true;
{
Directory::Create(Path(_T("output/results")));
std::ofstream fout ("output/results/terrain.txt");
unsigned nx = 100;
unsigned ny = 100;
for (unsigned i=0; i< nx; ++i) {
for (unsigned j=0; j< ny; ++j) {
auto fx = (double)i / (nx - 1) * 2 - 1;
auto fy = (double)j / (ny - 1) * 2 - 1;
GeoPoint x(origin.longitude + Angle::Degrees(0.6 * fx),
origin.latitude + Angle::Degrees(0.4 * fy));
TerrainHeight h = map.GetInterpolatedHeight(x);
fout << x.longitude.Degrees() << " " << x.latitude.Degrees()
<< " " << h.GetValue() << "\n";
}
fout << "\n";
}
fout << "\n";
}
unsigned i=0;
for (double ang = 0; ang < M_2PI; ang += M_PI / 8) {
GeoPoint dest = GeoVector(40000.0, Angle::Radians(ang)).EndPoint(origin);
int hdest = map.GetHeight(dest).GetValueOr0() + 100;
retval = route.Solve(AGeoPoint(origin,
map.GetHeight(origin).GetValueOr0() + 100),
AGeoPoint(dest,
mc > 0
? hdest
: std::max(hdest, 3200)),
config, ceiling);
char buffer[80];
sprintf(buffer,"terrain route solve, dir=%g, wind=%g, mc=%g ceiling=%d",
(double)ang, (double)mwind, (double)mc, (int)ceiling);
ok(retval, buffer, 0);
PrintHelper::print_route(route);
i++;
}
// polar.SetMC(0);
// route.UpdatePolar(polar, wind);
}
