test/src/RunAnalysis.cpp

   1 /*
   2 Copyright_License {
   3
   4   XCSoar Glide Computer - http://www.xcsoar.org/
   5   Copyright (C) 2000-2013 The XCSoar Project
   6   A detailed list of copyright holders can be found in the file "AUTHORS".
   7
   8   This program is free software; you can redistribute it and/or
   9   modify it under the terms of the GNU General Public License
  10   as published by the Free Software Foundation; either version 2
  11   of the License, or (at your option) any later version.
  12
  13   This program is distributed in the hope that it will be useful,
  14   but WITHOUT ANY WARRANTY; without even the implied warranty of
  15   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16   GNU General Public License for more details.
  17
  18   You should have received a copy of the GNU General Public License
  19   along with this program; if not, write to the Free Software
  20   Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  21 }
  22 */
  23
  24 #define ENABLE_LOOK
  25 #define ENABLE_XML_DIALOG
  26 #define ENABLE_CMDLINE
  27 #define ENABLE_PROFILE
  28 #define USAGE "DRIVER FILE"
  29
  30 #include "Main.hpp"
  31 #include "Screen/SingleWindow.hpp"
  32 #include "Screen/Blank.hpp"
  33 #include "Screen/BufferCanvas.hpp"
  34 #include "InfoBoxes/InfoBoxLayout.hpp"
  35 #include "Logger/Logger.hpp"
  36 #include "Terrain/RasterWeather.hpp"
  37 #include "Terrain/RasterTerrain.hpp"
  38 #include "Waypoint/WaypointGlue.hpp"
  39 #include "Dialogs/XML.hpp"
  40 #include "Dialogs/dlgAnalysis.hpp"
  41 #include "Dialogs/Task/TaskDialogs.hpp"
  42 #include "Dialogs/Dialogs.h"
  43 #include "Dialogs/Airspace/AirspaceWarningDialog.hpp"
  44 #include "Dialogs/DialogSettings.hpp"
  45 #include "UIGlobals.hpp"
  46 #include "Airspace/AirspaceParser.hpp"
  47 #include "Airspace/AirspaceGlue.hpp"
  48 #include "Engine/Waypoint/Waypoints.hpp"
  49 #include "Engine/Airspace/Airspaces.hpp"
  50 #include "Engine/Task/TaskManager.hpp"
  51 #include "Engine/Task/TaskEvents.hpp"
  52 #include "Engine/Task/Ordered/OrderedTask.hpp"
  53 #include "Computer/BasicComputer.hpp"
  54 #include "Computer/GlideComputer.hpp"
  55 #include "Computer/GlideComputerInterface.hpp"
  56 #include "Task/ProtectedTaskManager.hpp"
  57 #include "Task/ProtectedRoutePlanner.hpp"
  58 #include "Task/TaskFile.hpp"
  59 #include "LocalPath.hpp"
  60 #include "Blackboard/InterfaceBlackboard.hpp"
  61 #include "DebugReplay.hpp"
  62 #include "IO/FileLineReader.hpp"
  63 #include "Operation/Operation.hpp"
  64 #include "Look/Look.hpp"
  65 #include "Look/Fonts.hpp"
  66 #include "OS/Args.hpp"
  67
  68 #ifdef WIN32
  69 #include <shellapi.h>
  70 #endif
  71
  72 /* fake symbols: */
  73
  74 #include "Computer/ConditionMonitor/ConditionMonitors.hpp"
  75 #include "Input/InputQueue.hpp"
  76 #include "Logger/Logger.hpp"
  77
  78 void dlgBasicSettingsShowModal() {}
  79 void ShowWindSettingsDialog() {}
  80
  81 void
  82 dlgAirspaceWarningsShowModal(SingleWindow &parent,
  83                              ProtectedAirspaceWarningManager &warnings,
  84                              bool auto_close)
  85 {
  86 }
  87
  88 void dlgTaskManagerShowModal(SingleWindow &parent) {}
  89
  90 void
  91 ConditionMonitorsUpdate(const NMEAInfo &basic, const DerivedInfo &calculated,
  92                         const ComputerSettings &settings)
  93 {
  94 }
  95
  96 bool InputEvents::processGlideComputer(unsigned) { return false; }
  97
  98 void Logger::LogStartEvent(const NMEAInfo &gps_info) {}
  99 void Logger::LogFinishEvent(const NMEAInfo &gps_info) {}
 100 void Logger::LogPoint(const NMEAInfo &gps_info) {}
 101
 102 /* done with fake symbols. */
 103
 104 static RasterTerrain *terrain;
 105
 106 static void
 107 LoadFiles(Airspaces &airspace_database)
 108 {
 109   NullOperationEnvironment operation;
 110
 111   terrain = RasterTerrain::OpenTerrain(NULL, operation);
 112
 113   const AtmosphericPressure pressure = AtmosphericPressure::Standard();
 114   ReadAirspace(airspace_database, terrain, pressure, operation);
 115 }
 116
 117 static void
 118 LoadReplay(DebugReplay *replay, GlideComputer &glide_computer,
 119            InterfaceBlackboard &blackboard)
 120 {
 121   unsigned i = 0;
 122   while (replay->Next()) {
 123     const MoreData &basic = replay->Basic();
 124
 125     glide_computer.ReadBlackboard(basic);
 126     glide_computer.ProcessGPS();
 127
 128     if (++i == 8) {
 129       i = 0;
 130       glide_computer.ProcessIdle();
 131     }
 132   }
 133
 134   glide_computer.ProcessExhaustive();
 135
 136   blackboard.ReadBlackboardBasic(glide_computer.Basic());
 137   blackboard.ReadBlackboardCalculated(glide_computer.Calculated());
 138 }
 139
 140 static DebugReplay *replay;
 141
 142 static void
 143 ParseCommandLine(Args &args)
 144 {
 145   replay = CreateDebugReplay(args);
 146   if (replay == nullptr)
 147     exit(EXIT_FAILURE);
 148 }
 149
 150 static void
 151 Main()
 152 {
 153   const Waypoints way_points;
 154
 155   InterfaceBlackboard blackboard;
 156   blackboard.SetComputerSettings().SetDefaults();
 157   blackboard.SetComputerSettings().polar.glide_polar_task = GlidePolar(fixed(1));
 158   blackboard.SetUISettings().SetDefaults();
 159
 160   TaskBehaviour task_behaviour;
 161   task_behaviour.SetDefaults();
 162
 163   TaskManager task_manager(task_behaviour, way_points);
 164   task_manager.SetGlidePolar(blackboard.GetComputerSettings().polar.glide_polar_task);
 165
 166   GlideComputerTaskEvents task_events;
 167   task_manager.SetTaskEvents(task_events);
 168
 169   Airspaces airspace_database;
 170
 171   ProtectedTaskManager protected_task_manager(task_manager,
 172                                               blackboard.GetComputerSettings().task);
 173
 174   LoadFiles(airspace_database);
 175
 176   const TaskFactoryType task_type_default =
 177     blackboard.GetComputerSettings().task.task_type_default;
 178   OrderedTask *task =
 179     protected_task_manager.TaskCreateDefault(&way_points, task_type_default);
 180   if (task != nullptr) {
 181     task->FillMatPoints(way_points);
 182     protected_task_manager.TaskCommit(*task);
 183     delete task;
 184   }
 185
 186   GlideComputer glide_computer(way_points, airspace_database,
 187                                protected_task_manager,
 188                                task_events);
 189   glide_computer.ReadComputerSettings(blackboard.GetComputerSettings());
 190   glide_computer.SetTerrain(terrain);
 191   glide_computer.Initialise();
 192
 193   LoadReplay(replay, glide_computer, blackboard);
 194   delete replay;
 195
 196   SingleWindow main_window;
 197   main_window.Create(_T("RunAnalysis"),
 198                      {640, 480});
 199
 200   dlgAnalysisShowModal(main_window, *look, blackboard, glide_computer,
 201                        &protected_task_manager,
 202                        &airspace_database,
 203                        terrain);
 204
 205   delete terrain;
 206 }