DebugReplay *
CreateDebugReplay(Args &args)
{
if (!args.IsEmpty() && MatchesExtension(args.PeekNext(), ".igc")) {
const char *input_file = args.ExpectNext();
FileLineReaderA *reader = new FileLineReaderA(input_file);
if (reader->error()) {
delete reader;
fprintf(stderr, "Failed to open %s\n", input_file);
return NULL;
}
return new DebugReplayIGC(reader);
}
const tstring driver_name = args.ExpectNextT();
const struct DeviceRegister *driver = FindDriverByName(driver_name.c_str());
if (driver == NULL) {
_ftprintf(stderr, _T("No such driver: %s\n"), driver_name.c_str());
return NULL;
}
const char *input_file = args.ExpectNext();
FileLineReaderA *reader = new FileLineReaderA(input_file);
if (reader->error()) {
delete reader;
fprintf(stderr, "Failed to open %s\n", input_file);
return NULL;
}
return new DebugReplayNMEA(reader, driver);
}
DebugReplay*
DebugReplayIGC::Create(const char *input_file) {
FileLineReaderA *reader = new FileLineReaderA(input_file);
if (reader->error()) {
delete reader;
fprintf(stderr, "Failed to open %s\n", input_file);
return nullptr;
}
return new DebugReplayIGC(reader);
}
bool
PolarGlue::LoadFromFile(PolarInfo &polar, const TCHAR *path, Error &error)
{
FileLineReaderA *reader = new FileLineReaderA(path, error);
if (reader->error()) {
delete reader;
return false;
}
LoadFromFile(polar, *reader);
delete reader;
return true;
}
NLineReader *
OpenDataTextFileA(const TCHAR *name, Error &error)
{
assert(name != nullptr);
assert(!StringIsEmpty(name));
const auto path = LocalPath(name);
FileLineReaderA *reader = new FileLineReaderA(path, error);
if (reader->error()) {
delete reader;
return nullptr;
}
return reader;
}
NLineReader *
OpenConfiguredTextFileA(const char *profile_key)
{
assert(profile_key != nullptr);
TCHAR path[MAX_PATH];
if (!Profile::GetPath(profile_key, path))
return nullptr;
FileLineReaderA *reader = new FileLineReaderA(path);
if (reader->error()) {
delete reader;
return nullptr;
}
return reader;
}
DebugReplay*
DebugReplayNMEA::Create(Path input_file, const tstring &driver_name)
{
const struct DeviceRegister *driver = FindDriverByName(driver_name.c_str());
if (driver == NULL) {
_ftprintf(stderr, _T("No such driver: %s\n"), driver_name.c_str());
return nullptr;
}
Error error;
FileLineReaderA *reader = new FileLineReaderA(input_file, error);
if (reader->error()) {
delete reader;
fprintf(stderr, "%s\n", error.GetMessage());
return nullptr;
}
return new DebugReplayNMEA(reader, driver);
}
NLineReader *
OpenConfiguredTextFileA(const char *profile_key)
{
assert(profile_key != nullptr);
const auto path = Profile::GetPath(profile_key);
if (path.IsNull())
return nullptr;
Error error;
FileLineReaderA *reader = new FileLineReaderA(path, error);
if (reader->error()) {
delete reader;
LogError(error);
return nullptr;
}
return reader;
}
NLineReader *
OpenDataTextFileA(const TCHAR *name)
{
assert(name != NULL);
assert(!StringIsEmpty(name));
TCHAR path[MAX_PATH];
LocalPath(path, name);
FileLineReaderA *reader = new FileLineReaderA(path);
if (reader == NULL)
return NULL;
if (reader->error()) {
delete reader;
return NULL;
}
return reader;
}
static bool
test_replay()
{
Directory::Create(Path(_T("output/results")));
std::ofstream f("output/results/res-sample.txt");
GlidePolar glide_polar(4.0);
Waypoints waypoints;
AircraftState state_last;
TaskBehaviour task_behaviour;
task_behaviour.SetDefaults();
task_behaviour.auto_mc = true;
TaskManager task_manager(task_behaviour, waypoints);
TaskEventsPrint default_events(verbose);
task_manager.SetTaskEvents(default_events);
glide_polar.SetBallast(1.0);
task_manager.SetGlidePolar(glide_polar);
OrderedTask* t = task_load(task_behaviour);
if (t) {
task_manager.Commit(*t);
delete t;
task_manager.Resume();
} else {
return false;
}
// task_manager.get_task_advance().get_advance_state() = TaskAdvance::AUTO;
Error error;
FileLineReaderA *reader = new FileLineReaderA(replay_file, error);
if (reader->error()) {
delete reader;
fprintf(stderr, "%s\n", error.GetMessage());
return false;
}
ReplayLoggerSim sim(reader);
sim.state.netto_vario = 0;
bool do_print = verbose;
unsigned print_counter=0;
NMEAInfo basic;
basic.Reset();
while (sim.Update(basic) && !sim.started) {
}
state_last = sim.state;
sim.state.wind.norm = 7;
sim.state.wind.bearing = Angle::Degrees(330);
auto time_last = sim.state.time;
// uncomment this to manually go to first tp
// task_manager.incrementActiveTaskPoint(1);
FlyingComputer flying_computer;
flying_computer.Reset();
FlyingState flying_state;
flying_state.Reset();
while (sim.Update(basic)) {
if (sim.state.time>time_last) {
n_samples++;
flying_computer.Compute(glide_polar.GetVTakeoff(),
sim.state, sim.state.time - time_last,
flying_state);
sim.state.flying = flying_state.flying;
task_manager.Update(sim.state, state_last);
task_manager.UpdateIdle(sim.state);
task_manager.UpdateAutoMC(sim.state, 0);
task_manager.SetTaskAdvance().SetArmed(true);
state_last = sim.state;
if (verbose>1) {
sim.print(f);
f.flush();
}
if (do_print) {
PrintHelper::taskmanager_print(task_manager, sim.state);
}
do_print = (++print_counter % output_skip ==0) && verbose;
}
time_last = sim.state.time;
};
if (verbose) {
PrintDistanceCounts();
printf("# task elapsed %d (s)\n", (int)task_manager.GetStats().total.time_elapsed);
printf("# task speed %3.1f (kph)\n", (int)task_manager.GetStats().total.travelled.GetSpeed()*3.6);
printf("# travelled distance %4.1f (km)\n",
(double)task_manager.GetStats().total.travelled.GetDistance()/1000.0);
printf("# scored distance %4.1f (km)\n",
(double)task_manager.GetStats().distance_scored/1000.0);
if (task_manager.GetStats().total.time_elapsed > 0) {
printf("# scored speed %3.1f (kph)\n",
(double)task_manager.GetStats().distance_scored/(double)task_manager.GetStats().total.time_elapsed*3.6);
}
}
return true;
}
static bool
test_replay(const Contest olc_type,
const ContestResult &official_score)
{
Directory::Create(_T("output/results"));
std::ofstream f("output/results/res-sample.txt");
GlidePolar glide_polar(fixed(2));
Error error;
FileLineReaderA *reader = new FileLineReaderA(replay_file.c_str(), error);
if (reader->error()) {
delete reader;
fprintf(stderr, "%s\n", error.GetMessage());
return false;
}
ReplayLoggerSim sim(reader);
ComputerSettings settings_computer;
settings_computer.SetDefaults();
settings_computer.contest.enable = true;
load_scores(settings_computer.contest.handicap);
if (verbose) {
switch (olc_type) {
case Contest::OLC_LEAGUE:
std::cout << "# OLC-League\n";
break;
case Contest::OLC_SPRINT:
std::cout << "# OLC-Sprint\n";
break;
case Contest::OLC_FAI:
std::cout << "# OLC-FAI\n";
break;
case Contest::OLC_CLASSIC:
std::cout << "# OLC-Classic\n";
break;
case Contest::OLC_PLUS:
std::cout << "# OLC-Plus\n";
break;
default:
std::cout << "# Unknown!\n";
break;
}
}
bool do_print = verbose;
unsigned print_counter=0;
MoreData basic;
basic.Reset();
FlyingComputer flying_computer;
flying_computer.Reset();
FlyingState flying_state;
flying_state.Reset();
TraceComputer trace_computer;
ContestManager contest_manager(olc_type,
trace_computer.GetFull(),
trace_computer.GetFull(),
trace_computer.GetSprint());
contest_manager.SetHandicap(settings_computer.contest.handicap);
DerivedInfo calculated;
while (sim.Update(basic)) {
n_samples++;
flying_computer.Compute(glide_polar.GetVTakeoff(),
basic, calculated,
flying_state);
calculated.flight.flying = true;
trace_computer.Update(settings_computer, basic, calculated);
contest_manager.UpdateIdle();
if (verbose>1) {
sim.print(f, basic);
f.flush();
}
if (do_print) {
PrintHelper::trace_print(trace_computer.GetFull(), basic.location);
}
do_print = (++print_counter % output_skip ==0) && verbose;
};
contest_manager.SolveExhaustive();
if (verbose) {
PrintDistanceCounts();
}
return compare_scores(official_score,
contest_manager.GetStats().GetResult(0));
}
long Tell() const {
return reader->Tell();
}
long Size() const {
return reader->GetSize();
}
static bool
test_replay_retrospective()
{
Directory::Create(_T("output/results"));
std::ofstream f("output/results/res-sample.txt");
Waypoints waypoints;
WaypointReader w(waypoint_file.c_str(), 0);
if (!ok1(!w.Error())) {
printf("# waypoint file %s\n", waypoint_file.c_str());
skip(2, 0, "opening waypoint file failed");
return false;
}
NullOperationEnvironment operation;
if(!ok1(w.Parse(waypoints, operation))) {
skip(1, 0, "parsing waypoint file failed");
return false;
}
waypoints.Optimise();
ok1(!waypoints.IsEmpty());
Retrospective retro(waypoints);
retro.search_range = range_threshold;
retro.angle_tolerance = Angle::Degrees(autopilot_parms.bearing_noise);
FileLineReaderA *reader = new FileLineReaderA(replay_file.c_str());
if (reader->error()) {
delete reader;
return false;
}
waypoints.Optimise();
IgcReplay sim(reader);
NMEAInfo basic;
basic.Reset();
while (sim.Update(basic)) {
n_samples++;
if (retro.UpdateSample(basic.location)) {
std::ofstream g("output/results/res-retro.txt");
// report task
auto candidate_list = retro.getNearWaypointList();
for (auto it = candidate_list.begin(); it != candidate_list.end(); ++it) {
const Waypoint& wp = it->waypoint;
g << (double)wp.location.longitude.Degrees() << " "
<< (double)wp.location.latitude.Degrees() << " "
<< "\"" << wp.name << "\"\n";
}
}
f << (double)basic.time << " "
<< (double)basic.location.longitude.Degrees() << " "
<< (double)basic.location.latitude.Degrees() << "\n";
f.flush();
};
double d_ach, d_can;
retro.CalcDistances(d_ach, d_can);
printf("# distances %f %f\n", (double)d_ach, (double)d_can);
printf("# size %d\n", retro.getNearWaypointList().size());
return true;
}
static bool
test_replay(const Contests olc_type,
const ContestResult &official_score)
{
std::ofstream f("results/res-sample.txt");
GlidePolar glide_polar(fixed_two);
AircraftState state_last;
FileLineReaderA *reader = new FileLineReaderA(replay_file.c_str());
if (reader->error()) {
delete reader;
return false;
}
ReplayLoggerSim sim(reader);
ComputerSettings settings_computer;
settings_computer.SetDefaults();
settings_computer.task.enable_olc = true;
load_scores(settings_computer.task.contest_handicap);
if (verbose) {
switch (olc_type) {
case OLC_League:
std::cout << "# OLC-League\n";
break;
case OLC_Sprint:
std::cout << "# OLC-Sprint\n";
break;
case OLC_FAI:
std::cout << "# OLC-FAI\n";
break;
case OLC_Classic:
std::cout << "# OLC-Classic\n";
break;
case OLC_Plus:
std::cout << "# OLC-Plus\n";
break;
default:
std::cout << "# Unknown!\n";
break;
}
}
bool do_print = verbose;
unsigned print_counter=0;
MoreData basic;
basic.Reset();
while (sim.Update(basic, fixed_one) && !sim.started) {
}
state_last = sim.state;
fixed time_last = sim.state.time;
FlyingComputer flying_computer;
flying_computer.Reset();
FlyingState flying_state;
flying_state.Reset();
TraceComputer trace_computer;
ContestManager contest_manager(olc_type,
trace_computer.GetFull(),
trace_computer.GetSprint());
contest_manager.SetHandicap(settings_computer.task.contest_handicap);
DerivedInfo calculated;
while (sim.Update(basic, fixed_one)) {
if (sim.state.time>time_last) {
n_samples++;
flying_computer.Compute(glide_polar.GetVTakeoff(),
sim.state, flying_state);
calculated.flight.flying = flying_state.flying;
trace_computer.Update(settings_computer, basic, calculated);
contest_manager.UpdateIdle();
state_last = sim.state;
if (verbose>1) {
sim.print(f);
f.flush();
}
if (do_print) {
PrintHelper::trace_print(trace_computer.GetFull(), sim.state.location);
}
do_print = (++print_counter % output_skip ==0) && verbose;
}
time_last = sim.state.time;
};
contest_manager.SolveExhaustive();
if (verbose) {
PrintDistanceCounts();
}
return compare_scores(official_score,
contest_manager.GetStats().GetResult(0));
}
