test/src/test_troute.cpp

   1 /* Copyright_License {
   2
   3   XCSoar Glide Computer - http://www.xcsoar.org/
   4   Copyright (C) 2000-2013 The XCSoar Project
   5   A detailed list of copyright holders can be found in the file "AUTHORS".
   6
   7   This program is free software; you can redistribute it and/or
   8   modify it under the terms of the GNU General Public License
   9   as published by the Free Software Foundation; either version 2
  10   of the License, or (at your option) any later version.
  11
  12   This program is distributed in the hope that it will be useful,
  13   but WITHOUT ANY WARRANTY; without even the implied warranty of
  14   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15   GNU General Public License for more details.
  16
  17   You should have received a copy of the GNU General Public License
  18   along with this program; if not, write to the Free Software
  19   Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  20 }
  21 */
  22 #include <iostream>
  23 #include <fstream>
  24 #include "Printing.hpp"
  25 #define DO_PRINT
  26 #include "TestUtil.hpp"
  27 #include "Route/TerrainRoute.hpp"
  28 #include "Terrain/RasterMap.hpp"
  29 #include "OS/ConvertPathName.hpp"
  30 #include "Compatibility/path.h"
  31 #include "GlideSolvers/GlideSettings.hpp"
  32 #include "GlideSolvers/GlidePolar.hpp"
  33 #include "Geo/SpeedVector.hpp"
  34 #include "Geo/GeoVector.hpp"
  35 #include "Operation/Operation.hpp"
  36 #include "OS/FileUtil.hpp"
  37
  38 #include <string.h>
  39
  40 static void
  41 test_troute(const RasterMap& map, fixed mwind, fixed mc, RoughAltitude ceiling)
  42 {
  43   GlideSettings settings;
  44   settings.SetDefaults();
  45   GlidePolar polar(mc);
  46   SpeedVector wind(Angle::Degrees(0), mwind);
  47   TerrainRoute route;
  48   route.UpdatePolar(settings, polar, polar, wind);
  49   route.SetTerrain(&map);
  50
  51   GeoPoint origin(map.GetMapCenter());
  52
  53   fixed pd = map.PixelDistance(origin, 1);
  54   printf("# pixel size %g\n", (double)pd);
  55
  56   bool retval= true;
  57
  58   {
  59     Directory::Create(_T("output/results"));
  60     std::ofstream fout ("output/results/terrain.txt");
  61     unsigned nx = 100;
  62     unsigned ny = 100;
  63     for (unsigned i=0; i< nx; ++i) {
  64       for (unsigned j=0; j< ny; ++j) {
  65         fixed fx = (fixed)i / (nx - 1) * 2 - fixed(1);
  66         fixed fy = (fixed)j / (ny - 1) * 2 - fixed(1);
  67         GeoPoint x(origin.longitude + Angle::Degrees(fixed(0.6) * fx),
  68                    origin.latitude + Angle::Degrees(fixed(0.4) * fy));
  69         short h = map.GetInterpolatedHeight(x);
  70         fout << x.longitude.Degrees() << " " << x.latitude.Degrees() << " " << h << "\n";
  71       }
  72       fout << "\n";
  73     }
  74     fout << "\n";
  75   }
  76
  77   RoutePlannerConfig config;
  78   config.mode = RoutePlannerConfig::Mode::BOTH;
  79
  80   unsigned i=0;
  81   for (fixed ang = fixed(0); ang < fixed_two_pi; ang += fixed(M_PI / 8)) {
  82     GeoPoint dest = GeoVector(fixed(40000.0), Angle::Radians(ang)).EndPoint(origin);
  83
  84     short hdest = map.GetHeight(dest)+100;
  85
  86     retval = route.Solve(AGeoPoint(origin,
  87                                    RoughAltitude(map.GetHeight(origin) + 100)),
  88                          AGeoPoint(dest,
  89                                    RoughAltitude(positive(mc)
  90                                                  ? hdest
  91                                                  : std::max(hdest, (short)3200))),
  92                          config, ceiling);
  93     char buffer[80];
  94     sprintf(buffer,"terrain route solve, dir=%g, wind=%g, mc=%g ceiling=%d",
  95             (double)ang, (double)mwind, (double)mc, (int)ceiling);
  96     ok(retval, buffer, 0);
  97     PrintHelper::print_route(route);
  98     i++;
  99   }
 100
 101   // polar.SetMC(fixed(0));
 102   // route.UpdatePolar(polar, wind);
 103 }
 104
 105 int main(int argc, char** argv) {
 106
 107   const char hc_path[] = "tmp/terrain";
 108   const char *map_path;
 109   if ((argc<2) || !strlen(argv[0])) {
 110     map_path = hc_path;
 111   } else {
 112     map_path = argv[0];
 113   }
 114
 115   TCHAR jp2_path[4096];
 116   _tcscpy(jp2_path, PathName(map_path));
 117   _tcscat(jp2_path, _T(DIR_SEPARATOR_S) _T("terrain.jp2"));
 118
 119   TCHAR j2w_path[4096];
 120   _tcscpy(j2w_path, PathName(map_path));
 121   _tcscat(j2w_path, _T(DIR_SEPARATOR_S) _T("terrain.j2w"));
 122
 123   NullOperationEnvironment operation;
 124   RasterMap map(jp2_path, j2w_path, NULL, operation);
 125   do {
 126     map.SetViewCenter(map.GetMapCenter(), fixed(100000));
 127   } while (map.IsDirty());
 128
 129   plan_tests(16*3);
 130   test_troute(map, fixed(0), fixed(0.1), RoughAltitude(10000));
 131   test_troute(map, fixed(0), fixed(0), RoughAltitude(10000));
 132   test_troute(map, fixed(5.0), fixed(1), RoughAltitude(10000));
 133
 134   return exit_status();
 135 }
 136