int
main(int argc, char** argv)
{
static const char map_path[] = "tmp/map.xcm";
ZZIP_DIR *dir = zzip_dir_open(map_path, nullptr);
if (dir == nullptr) {
fprintf(stderr, "Failed to open %s\n", map_path);
return EXIT_FAILURE;
}
RasterMap map;
NullOperationEnvironment operation;
if (!LoadTerrainOverview(dir, map.GetTileCache(), operation)) {
fprintf(stderr, "failed to load map\n");
zzip_dir_close(dir);
return EXIT_FAILURE;
}
map.UpdateProjection();
SharedMutex mutex;
do {
UpdateTerrainTiles(dir, map.GetTileCache(), mutex,
map.GetProjection(),
map.GetMapCenter(), 100000);
} while (map.IsDirty());
zzip_dir_close(dir);
plan_tests(4 + NUM_SOL);
ok(test_route(28, map), "route 28", 0);
return exit_status();
}
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";
}
}
static void test_reach(const RasterMap& map, fixed mwind, fixed mc)
{
GlidePolar polar(mc);
SpeedVector wind(Angle::degrees(fixed(0)), mwind);
TerrainRoute route(polar, wind);
route.set_terrain(&map);
GeoPoint origin(map.GetMapCenter());
fixed pd = map.pixel_distance(origin, 1);
printf("# pixel size %g\n", (double)pd);
bool retval= true;
route.verbose = 2;
RoutePlannerConfig config;
config.mode = RoutePlannerConfig::rpBoth;
short horigin = map.GetHeight(origin)+1000;
AGeoPoint aorigin(origin, horigin);
retval = route.solve_reach(aorigin);
ok(retval, "reach solve", 0);
PrintHelper::print_reach_tree(route);
GeoPoint dest(origin.Longitude-Angle::degrees(fixed(0.02)),
origin.Latitude-Angle::degrees(fixed(0.02)));
{
std::ofstream fout ("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)*fixed_two-fixed_one;
fixed fy = (fixed)j/(ny-1)*fixed_two-fixed_one;
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, h);
short ha, hd;
route.find_positive_arrival(adest, ha, hd);
if ((i % 5 == 0) && (j % 5 == 0)) {
AGeoPoint ao2(x, h+1000);
route.solve_reach(ao2);
}
fout << x.Longitude.value_degrees() << " " << x.Latitude.value_degrees() << " " << h << " " << ha << "\n";
}
fout << "\n";
}
fout << "\n";
}
}
int main(int argc, char** argv) {
static const char hc_path[] = "tmp/map.xcm";
const char *map_path;
if ((argc<2) || !strlen(argv[0])) {
map_path = hc_path;
} else {
map_path = argv[0];
}
ZZIP_DIR *dir = zzip_dir_open(map_path, nullptr);
if (dir == nullptr) {
fprintf(stderr, "Failed to open %s\n", map_path);
return EXIT_FAILURE;
}
RasterMap map;
NullOperationEnvironment operation;
if (!LoadTerrainOverview(dir, map.GetTileCache(),
operation)) {
fprintf(stderr, "failed to load map\n");
zzip_dir_close(dir);
return EXIT_FAILURE;
}
map.UpdateProjection();
SharedMutex mutex;
do {
UpdateTerrainTiles(dir, map.GetTileCache(), mutex,
map.GetProjection(),
map.GetMapCenter(), 100000);
} while (map.IsDirty());
zzip_dir_close(dir);
plan_tests(16*3);
test_troute(map, 0, 0.1, 10000);
test_troute(map, 0, 0, 10000);
test_troute(map, 5.0, 1, 10000);
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);
}
