static bool
TestTracking(int argc, char *argv[])
{
Args args(argc, argv, "[DRIVER] FILE [USERNAME [PASSWORD]]");
DebugReplay *replay = CreateDebugReplay(args);
if (replay == NULL)
return false;
ConsoleOperationEnvironment env;
bool has_user_id;
UserID user_id;
tstring username, password;
if (args.IsEmpty()) {
username = _T("");
password = _T("");
has_user_id = false;
} else {
username = args.ExpectNextT();
password = args.IsEmpty() ? _T("") : args.ExpectNextT();
user_id = LiveTrack24::GetUserID(username.c_str(), password.c_str(), env);
has_user_id = (user_id != 0);
}
SessionID session = has_user_id ?
GenerateSessionID(user_id) : GenerateSessionID();
printf("Generated session id: %u\n", session);
printf("Starting tracking ... ");
bool result = StartTracking(session, username.c_str(), password.c_str(), 10,
VehicleType::GLIDER, _T("Hornet"),
env);
printf(result ? "done\n" : "failed\n");
if (!result)
return false;
BrokenDate now = BrokenDate::TodayUTC();
printf("Sending positions ");
unsigned package_id = 2;
while (replay->Next()) {
if (package_id % 10 == 0) {
putchar('.');
fflush(stdout);
}
const MoreData &basic = replay->Basic();
const BrokenTime time = basic.date_time_utc;
BrokenDateTime datetime(now.year, now.month, now.day, time.hour,
time.minute, time.second);
result = SendPosition(
session, package_id, basic.location, (unsigned)basic.nav_altitude,
(unsigned)Units::ToUserUnit(basic.ground_speed, Unit::KILOMETER_PER_HOUR),
basic.track, datetime.ToUnixTimeUTC(),
env);
if (!result)
break;
package_id++;
}
printf(result ? "done\n" : "failed\n");
printf("Stopping tracking ... ");
result = EndTracking(session, package_id, env);
printf(result ? "done\n" : "failed\n");
return true;
}
void
Run(DebugReplay &replay, FlightPhaseDetector &flight_phase_detector,
WindList &wind_list,
const BrokenDateTime &takeoff_time,
const BrokenDateTime &scoring_start_time,
const BrokenDateTime &scoring_end_time,
const BrokenDateTime &landing_time,
Trace &full_trace, Trace &triangle_trace, Trace &sprint_trace,
ComputerSettings &computer_settings)
{
GeoPoint last_location = GeoPoint::Invalid();
constexpr Angle max_longitude_change = Angle::Degrees(30);
constexpr Angle max_latitude_change = Angle::Degrees(1);
CirclingSettings circling_settings;
circling_settings.SetDefaults();
CirclingComputer circling_computer;
GlidePolar glide_polar(fixed(0));
WindSettings wind_settings;
wind_settings.SetDefaults();
WindComputer wind_computer;
wind_computer.Reset();
Validity last_wind;
last_wind.Clear();
const Waypoints waypoints;
AutoQNH auto_qnh(5);
auto_qnh.Reset();
const int64_t takeoff_unix = takeoff_time.ToUnixTimeUTC();
const int64_t landing_unix = landing_time.ToUnixTimeUTC();
int64_t scoring_start_unix, scoring_end_unix;
if (scoring_start_time.IsPlausible())
scoring_start_unix = scoring_start_time.ToUnixTimeUTC();
else
scoring_start_unix = std::numeric_limits<int64_t>::max();
if (scoring_end_time.IsPlausible())
scoring_end_unix = scoring_end_time.ToUnixTimeUTC();
else
scoring_end_unix = 0;
while (replay.Next()) {
const MoreData &basic = replay.Basic();
const int64_t date_time_utc = basic.date_time_utc.ToUnixTimeUTC();
if (date_time_utc < takeoff_unix)
continue;
if (date_time_utc > landing_unix)
break;
circling_computer.TurnRate(replay.SetCalculated(),
replay.Basic(),
replay.Calculated().flight);
circling_computer.Turning(replay.SetCalculated(),
replay.Basic(),
replay.Calculated().flight,
circling_settings);
flight_phase_detector.Update(replay.Basic(), replay.Calculated());
wind_computer.Compute(wind_settings, glide_polar, basic,
replay.SetCalculated());
if (replay.Calculated().estimated_wind_available.Modified(last_wind)) {
wind_list.push_back(WindListItem(basic.date_time_utc, basic.gps_altitude,
replay.Calculated().estimated_wind));
}
last_wind = replay.Calculated().estimated_wind_available;
auto_qnh.Process(basic, replay.SetCalculated(), computer_settings, waypoints);
if (!computer_settings.pressure_available && replay.Calculated().pressure_available) {
computer_settings.pressure = replay.Calculated().pressure;
computer_settings.pressure_available = replay.Calculated().pressure_available;
}
if (!basic.time_available || !basic.location_available ||
!basic.NavAltitudeAvailable())
continue;
if (last_location.IsValid() &&
((last_location.latitude - basic.location.latitude).Absolute() > max_latitude_change ||
(last_location.longitude - basic.location.longitude).Absolute() > max_longitude_change))
/* there was an implausible warp, which is usually triggered by
an invalid point declared "valid" by a bugged logger; if that
happens, we stop the analysis, because the IGC file is
obviously broken */
break;
last_location = basic.location;
if (date_time_utc >= scoring_start_unix && date_time_utc <= scoring_end_unix) {
const TracePoint point(basic);
full_trace.push_back(point);
triangle_trace.push_back(point);
sprint_trace.push_back(point);
}
}
flight_phase_detector.Finish();
}
PyObject* xcsoar_Airspaces_findIntrusions(Pyxcsoar_Airspaces *self, PyObject *args) {
PyObject *py_flight = nullptr;
if (!PyArg_ParseTuple(args, "O", &py_flight)) {
return nullptr;
}
DebugReplay *replay = ((Pyxcsoar_Flight*)py_flight)->flight->Replay();
if (replay == nullptr) {
PyErr_SetString(PyExc_IOError, "Can't start replay - file not found.");
return nullptr;
}
PyObject *py_result = PyDict_New();
Airspaces::AirspaceVector last_airspaces;
while (replay->Next()) {
const MoreData &basic = replay->Basic();
if (!basic.time_available || !basic.location_available ||
!basic.NavAltitudeAvailable())
continue;
const auto range =
self->airspace_database->QueryInside(ToAircraftState(basic,
replay->Calculated()));
Airspaces::AirspaceVector airspaces(range.begin(), range.end());
for (auto it = airspaces.begin(); it != airspaces.end(); it++) {
PyObject *py_name = PyUnicode_FromString((*it).GetAirspace().GetName());
PyObject *py_airspace = nullptr,
*py_period = nullptr;
if (PyDict_Contains(py_result, py_name) == 0) {
// this is the first fix inside this airspace
py_airspace = PyList_New(0);
PyDict_SetItem(py_result, py_name, py_airspace);
py_period = PyList_New(0);
PyList_Append(py_airspace, py_period);
Py_DECREF(py_period);
} else {
// this airspace was hit some time before...
py_airspace = PyDict_GetItem(py_result, py_name);
// check if the last fix was already inside this airspace
auto in_last = std::find(last_airspaces.begin(), last_airspaces.end(), *it);
if (in_last == last_airspaces.end()) {
// create a new period
py_period = PyList_New(0);
PyList_Append(py_airspace, py_period);
Py_DECREF(py_period);
} else {
py_period = PyList_GET_ITEM(py_airspace, PyList_GET_SIZE(py_airspace) - 1);
}
}
PyList_Append(py_period, Py_BuildValue("{s:N,s:N}",
"time", Python::BrokenDateTimeToPy(basic.date_time_utc),
"location", Python::WriteLonLat(basic.location)));
}
last_airspaces = std::move(airspaces);
}
delete replay;
return py_result;
}
static int
TestOLC(DebugReplay &replay)
{
bool released = false;
for (int i = 1; replay.Next(); i++) {
if (i % 500 == 0) {
putchar('.');
fflush(stdout);
}
const MoreData &basic = replay.Basic();
if (!basic.time_available || !basic.location_available ||
!basic.NavAltitudeAvailable())
continue;
if (!released && !negative(replay.Calculated().flight.release_time)) {
released = true;
full_trace.EraseEarlierThan(replay.Calculated().flight.release_time);
sprint_trace.EraseEarlierThan(replay.Calculated().flight.release_time);
}
const TracePoint point(basic);
full_trace.push_back(point);
sprint_trace.push_back(point);
olc_sprint.UpdateIdle();
olc_league.UpdateIdle();
}
olc_classic.SolveExhaustive();
olc_fai.SolveExhaustive();
olc_league.SolveExhaustive();
olc_plus.SolveExhaustive();
dmst.SolveExhaustive();
xcontest.SolveExhaustive();
sis_at.SolveExhaustive();
olc_netcoupe.SolveExhaustive();
putchar('\n');
std::cout << "classic\n";
PrintHelper::print(olc_classic.GetStats().GetResult());
std::cout << "league\n";
std::cout << "# league\n";
PrintHelper::print(olc_league.GetStats().GetResult(0));
std::cout << "# classic\n";
PrintHelper::print(olc_league.GetStats().GetResult(1));
std::cout << "fai\n";
PrintHelper::print(olc_fai.GetStats().GetResult());
std::cout << "sprint\n";
PrintHelper::print(olc_sprint.GetStats().GetResult());
std::cout << "plus\n";
std::cout << "# classic\n";
PrintHelper::print(olc_plus.GetStats().GetResult(0));
std::cout << "# triangle\n";
PrintHelper::print(olc_plus.GetStats().GetResult(1));
std::cout << "# plus\n";
PrintHelper::print(olc_plus.GetStats().GetResult(2));
std::cout << "dmst\n";
PrintHelper::print(dmst.GetStats().GetResult());
std::cout << "xcontest\n";
std::cout << "# free\n";
PrintHelper::print(xcontest.GetStats().GetResult(0));
std::cout << "# triangle\n";
PrintHelper::print(xcontest.GetStats().GetResult(1));
std::cout << "sis_at\n";
PrintHelper::print(sis_at.GetStats().GetResult(0));
std::cout << "netcoupe\n";
PrintHelper::print(olc_netcoupe.GetStats().GetResult());
olc_classic.Reset();
olc_fai.Reset();
olc_sprint.Reset();
olc_league.Reset();
olc_plus.Reset();
dmst.Reset();
olc_netcoupe.Reset();
full_trace.clear();
sprint_trace.clear();
return 0;
}
