int
main(int argc, char **argv)
{
Args args(argc, argv, "DRIVER FILE");
DebugReplay *replay = CreateDebugReplay(args);
if (replay == NULL)
return EXIT_FAILURE;
args.ExpectEnd();
ScreenGlobalInit screen;
boost::asio::io_service io_service;
std::unique_ptr<PCMPlayer> player(
PCMPlayerFactory::CreateInstanceForDirectAccess(io_service));
const unsigned sample_rate = 44100;
VarioSynthesiser synthesiser(sample_rate);
if (!player->Start(synthesiser)) {
fprintf(stderr, "Failed to start PCMPlayer\n");
return EXIT_FAILURE;
}
ReplayTimer timer(io_service, *replay, synthesiser);
timer.Start();
io_service.run();
return EXIT_SUCCESS;
}
int main(int argc, char **argv)
{
Args args(argc, argv, "TASKFILE REPLAYFILE");
const auto task_path = args.ExpectNextPath();
DebugReplay *replay = CreateDebugReplay(args);
if (replay == NULL)
return EXIT_FAILURE;
args.ExpectEnd();
TaskBehaviour task_behaviour;
task_behaviour.SetDefaults();
OrderedTask *task = TaskFile::GetTask(task_path, task_behaviour,
NULL, 0);
if (task == NULL) {
fprintf(stderr, "Failed to load task\n");
return EXIT_FAILURE;
}
task->UpdateGeometry();
const GlidePolar glide_polar(1);
Run(*replay, *task, glide_polar);
delete task;
delete replay;
return EXIT_SUCCESS;
}
int main(int argc, char **argv)
{
Args args(argc, argv, "DRIVER FILE");
DebugReplay *replay = CreateDebugReplay(args);
if (replay == NULL)
return EXIT_FAILURE;
args.ExpectEnd();
printf("# time quality wind_bearing (deg) wind_speed (m/s) grndspeed (m/s) tas (m/s) bearing (deg)\n");
WindEKFGlue wind_ekf;
wind_ekf.Reset();
while (replay->Next()) {
const MoreData &data = replay->Basic();
WindEKFGlue::Result result =
wind_ekf.Update(data, replay->Calculated());
if (result.quality > 0)
printf("%d %d %d %g %g %g %d\n", (int)data.time, result.quality,
(int)result.wind.bearing.Degrees(),
(double)result.wind.norm,
(double)data.ground_speed,
(double)data.true_airspeed,
(int)data.track.Degrees());
}
delete replay;
}
int main(int argc, char **argv)
{
Args args(argc, argv, "DRIVER INFILE OUTFILE");
DebugReplay *replay = CreateDebugReplay(args);
if (replay == NULL)
return EXIT_FAILURE;
const auto output_file = args.ExpectNextPath();
args.ExpectEnd();
while (!replay->Basic().time_available)
if (!replay->Next())
return 0;
const TCHAR *driver_name = _T("Unknown");
IGCWriter writer(output_file);
writer.WriteHeader(replay->Basic().date_time_utc, _T("Manfred Mustermann"),
_T("Ventus"), _T("D-1234"),
_T("MM"), "FOO", driver_name, true);
GPSClock log_clock;
while (replay->Next())
if (log_clock.CheckAdvance(replay->Basic().time, fixed(1)))
writer.LogPoint(replay->Basic());
writer.Flush();
delete replay;
return EXIT_SUCCESS;
}
int main(int argc, char **argv)
{
Args args(argc, argv, "DRIVER FILE");
std::unique_ptr<DebugReplay> replay(CreateDebugReplay(args));
if (!replay)
return EXIT_FAILURE;
args.ExpectEnd();
printf("# time wind_bearing (deg) wind_speed (m/s)\n");
Validity last_available;
last_available.Clear();
while (replay->Next()) {
const auto &basic = replay->Basic();
if (basic.external_wind_available.Modified(last_available)) {
last_available = basic.external_wind_available;
TCHAR time_buffer[32];
FormatTime(time_buffer, basic.time);
_tprintf(_T("%s %d %g\n"),
time_buffer,
(int)basic.external_wind.bearing.Degrees(),
(double)basic.external_wind.norm);
}
}
}
static void
ParseCommandLine(Args &args)
{
replay = CreateDebugReplay(args);
if (replay == nullptr)
exit(EXIT_FAILURE);
}
int
main(int argc, char **argv)
{
Args args(argc, argv, "DRIVER FILE");
DebugReplay *replay = CreateDebugReplay(args);
if (replay == NULL)
return EXIT_FAILURE;
args.ExpectEnd();
const unsigned sample_rate = 44100;
VarioSynthesiser synthesiser;
while (replay->Next()) {
fixed vario = replay->Basic().brutto_vario;
synthesiser.SetVario(sample_rate, vario);
static int16_t buffer[sample_rate];
synthesiser.Synthesise(buffer, ARRAY_SIZE(buffer));
if (write(1, buffer, sizeof(buffer)) < 0) {
perror("write");
return EXIT_FAILURE;
}
}
return EXIT_SUCCESS;
}
int main(int argc, char **argv)
{
Args args(argc, argv, "DRIVER FILE");
DebugReplay *replay = CreateDebugReplay(args);
if (replay == NULL)
return EXIT_FAILURE;
args.ExpectEnd();
Result result;
Run(*replay, result);
delete replay;
const ContestStatistics olc_plus = SolveContest(Contest::OLC_PLUS);
const ContestStatistics dmst = SolveContest(Contest::DMST);
TextWriter writer("/dev/stdout", true);
{
JSON::ObjectWriter root(writer);
WriteResult(root, result);
root.WriteElement("phases", WritePhaseList,
flight_phase_detector.GetPhases());
root.WriteElement("performance", WritePerformanceStats,
flight_phase_detector.GetTotals());
root.WriteElement("contests", WriteContests, olc_plus, dmst);
}
}
int main(int argc, char **argv)
{
Args args(argc, argv, "DRIVER FILE");
DebugReplay *replay = CreateDebugReplay(args);
if (replay == NULL)
return EXIT_FAILURE;
args.ExpectEnd();
printf("# time wind_bearing (deg) wind_speed (m/s)\n");
GlidePolar glide_polar(fixed(0));
CirclingSettings circling_settings;
WindSettings wind_settings;
wind_settings.SetDefaults();
CirclingComputer circling_computer;
circling_computer.Reset();
WindComputer wind_computer;
wind_computer.Reset();
Validity last;
last.Clear();
while (replay->Next()) {
const MoreData &basic = replay->Basic();
const DerivedInfo &calculated = replay->Calculated();
circling_computer.TurnRate(replay->SetCalculated(),
basic, calculated.flight);
circling_computer.Turning(replay->SetCalculated(),
basic,
calculated.flight,
circling_settings);
wind_computer.Compute(wind_settings, glide_polar, basic,
replay->SetCalculated());
if (calculated.estimated_wind_available.Modified(last)) {
TCHAR time_buffer[32];
FormatTime(time_buffer, replay->Basic().time);
_tprintf(_T("%s %d %g\n"),
time_buffer, (int)calculated.estimated_wind.bearing.Degrees(),
(double)calculated.estimated_wind.norm);
}
last = calculated.estimated_wind_available;
}
delete replay;
}
int main(int argc, char **argv)
{
Args args(argc, argv, "DRIVER FILE");
DebugReplay *replay = CreateDebugReplay(args);
if (replay == NULL)
return EXIT_FAILURE;
args.ExpectEnd();
int result = TestOLC(*replay);
delete replay;
return result;
}
int main(int argc, char **argv)
{
Args args(argc, argv, "DRIVER FILE");
DebugReplay *replay = CreateDebugReplay(args);
if (replay == NULL)
return EXIT_FAILURE;
args.ExpectEnd();
WaveSettings settings;
settings.SetDefaults();
settings.enabled = true;
WaveComputer wave;
wave.Reset();
WaveResult result;
result.Clear();
while (replay->Next()) {
const MoreData &basic = replay->Basic();
const DerivedInfo &calculated = replay->Calculated();
wave.Compute(basic, calculated.flight, result, settings);
}
delete replay;
for (const auto &w : result.waves) {
TCHAR time_buffer[32];
if (w.time >= 0)
FormatTime(time_buffer, w.time);
else
_tcscpy(time_buffer, _T("?"));
_tprintf(_T("wave: t=%s location=%f,%f a=%f,%f b=%f,%f location=%s normal=%f\n"),
time_buffer,
(double)w.location.longitude.Degrees(),
(double)w.location.latitude.Degrees(),
(double)w.a.longitude.Degrees(),
(double)w.a.latitude.Degrees(),
(double)w.b.longitude.Degrees(),
(double)w.b.latitude.Degrees(),
FormatGeoPoint(w.location, CoordinateFormat::DDMMSS).c_str(),
(double)w.normal.Degrees());
}
return EXIT_SUCCESS;
}
int main(int argc, char **argv)
{
Args args(argc, argv, "DRIVER FILE");
DebugReplay *replay = CreateDebugReplay(args);
if (replay == NULL)
return EXIT_FAILURE;
args.ExpectEnd();
printf("# time quality wind_bearing (deg) wind_speed (m/s)\n");
CirclingComputer circling_computer;
CirclingWind circling_wind;
while (replay->Next()) {
circling_computer.TurnRate(replay->SetCalculated(),
replay->Basic(), replay->LastBasic(),
replay->Calculated(), replay->LastCalculated());
circling_computer.Turning(replay->SetCalculated(),
replay->Basic(), replay->LastBasic(),
replay->Calculated(), replay->LastCalculated(),
replay->SettingsComputer());
if ((replay->LastCalculated().turn_mode == WAITCLIMB &&
replay->Calculated().turn_mode == CLIMB) ||
(replay->LastCalculated().turn_mode == WAITCRUISE &&
replay->Calculated().turn_mode == CRUISE))
circling_wind.slot_newFlightMode(replay->Calculated(),
negative(replay->Calculated().turn_rate_smoothed),
0);
CirclingWind::Result result = circling_wind.NewSample(replay->Basic());
if (result.quality > 0) {
fixed mag = hypot(result.wind.x, result.wind.y);
Angle bearing;
if (result.wind.y == fixed_zero && result.wind.x == fixed_zero)
bearing = Angle::zero();
else
bearing = Angle::radians(atan2(result.wind.y, result.wind.x)).as_bearing();
printf("%d %d %d %g\n",
(int)replay->Basic().time,
result.quality, (int)bearing.value_degrees(), (double)mag);
}
}
delete replay;
}
int main(int argc, char **argv)
{
Args args(argc, argv, "DRIVER FILE");
std::unique_ptr<DebugReplay> replay(CreateDebugReplay(args));
if (!replay)
return EXIT_FAILURE;
args.ExpectEnd();
printf("# time quality wind_bearing (deg) wind_speed (m/s)\n");
CirclingSettings circling_settings;
circling_settings.SetDefaults();
CirclingComputer circling_computer;
CirclingWind circling_wind;
while (replay->Next()) {
const bool last_circling = replay->Calculated().circling;
circling_computer.TurnRate(replay->SetCalculated(),
replay->Basic(),
replay->Calculated().flight);
circling_computer.Turning(replay->SetCalculated(),
replay->Basic(),
replay->Calculated().flight,
circling_settings);
if (replay->Calculated().circling != last_circling)
circling_wind.NewFlightMode(replay->Calculated());
CirclingWind::Result result = circling_wind.NewSample(replay->Basic());
if (result.quality > 0) {
fixed mag = result.wind.Magnitude();
Angle bearing;
if (result.wind.y == fixed(0) && result.wind.x == fixed(0))
bearing = Angle::Zero();
else
bearing = Angle::FromXY(result.wind.x, result.wind.y).AsBearing();
TCHAR time_buffer[32];
FormatTime(time_buffer, replay->Basic().time);
_tprintf(_T("%s %d %d %g\n"),
time_buffer, result.quality, (int)bearing.Degrees(), (double)mag);
}
}
}
int main(int argc, char **argv)
{
Args args(argc, argv, "DRIVER FILE");
DebugReplay *replay = CreateDebugReplay(args);
if (replay == NULL)
return EXIT_FAILURE;
args.ExpectEnd();
printf("# time wind_bearing (deg) wind_speed (m/s) grndspeed (m/s) tas (m/s) bearing (deg)\n");
CirclingSettings circling_settings;
circling_settings.SetDefaults();
CirclingComputer circling_computer;
circling_computer.Reset();
WindEKFGlue wind_ekf;
wind_ekf.Reset();
while (replay->Next()) {
const MoreData &data = replay->Basic();
const DerivedInfo &calculated = replay->Calculated();
circling_computer.TurnRate(replay->SetCalculated(),
data, calculated.flight);
WindEKFGlue::Result result =
wind_ekf.Update(data, replay->Calculated());
if (result.quality > 0) {
TCHAR time_buffer[32];
FormatTime(time_buffer, data.time);
_tprintf(_T("%s %d %g %g %g %d\n"), time_buffer,
(int)result.wind.bearing.Degrees(),
(double)result.wind.norm,
(double)data.ground_speed,
(double)data.true_airspeed,
(int)data.track.Degrees());
}
}
delete replay;
}
int main(int argc, char **argv)
{
Args args(argc, argv, "DRIVER FILE OUTFILE");
DebugReplay *replay = CreateDebugReplay(args);
if (replay == NULL)
return EXIT_FAILURE;
const auto path = args.ExpectNextPath();
args.ExpectEnd();
FlightLogger logger;
logger.SetPath(path);
logger.Reset();
while (replay->Next())
logger.Tick(replay->Basic(), replay->Calculated());
delete replay;
}
int main(int argc, char **argv)
{
Args args(argc, argv, "DRIVER FILE");
DebugReplay *replay = CreateDebugReplay(args);
if (replay == NULL)
return EXIT_FAILURE;
args.ExpectEnd();
Trace trace;
while (replay->Next()) {
const AircraftState state =
ToAircraftState(replay->Basic(), replay->Calculated());
trace.append(state);
}
delete replay;
}
int main(int argc, char **argv)
{
Args args(argc, argv, "DRIVER FILE");
DebugReplay *replay = CreateDebugReplay(args);
if (replay == NULL)
return EXIT_FAILURE;
args.ExpectEnd();
Trace trace;
while (replay->Next()) {
const MoreData &basic = replay->Basic();
if (basic.time_available && basic.location_available &&
basic.NavAltitudeAvailable())
trace.push_back(TracePoint(basic));
}
delete replay;
}
int
main(int argc, char *argv[])
{
Args args(argc, argv, "HOST KEY");
const char *host = args.ExpectNext();
const char *key = args.ExpectNext();
SocketAddress address;
if (!address.Lookup(host, "5597", SOCK_DGRAM)) {
fprintf(stderr, "Failed to look up: %s\n", host);
return EXIT_FAILURE;
}
#ifdef HAVE_SKYLINES_TRACKING_HANDLER
InitialiseIOThread();
#endif
SkyLinesTracking::Client client;
#ifdef HAVE_SKYLINES_TRACKING_HANDLER
client.SetIOThread(io_thread);
Handler handler;
client.SetHandler(&handler);
#endif
client.SetKey(ParseUint64(key, NULL, 16));
if (!client.Open(address)) {
fprintf(stderr, "Failed to create client\n");
return EXIT_FAILURE;
}
if (args.IsEmpty() || StringIsEqual(args.PeekNext(), "fix")) {
NMEAInfo basic;
basic.Reset();
basic.UpdateClock();
basic.time = fixed(1);
basic.time_available.Update(basic.clock);
return client.SendFix(basic) ? EXIT_SUCCESS : EXIT_FAILURE;
} else if (StringIsEqual(args.PeekNext(), "ping")) {
client.SendPing(1);
#ifdef HAVE_SKYLINES_TRACKING_HANDLER
handler.Wait();
#endif
} else if (StringIsEqual(args.PeekNext(), "traffic")) {
client.SendTrafficRequest(true, true);
#ifdef HAVE_SKYLINES_TRACKING_HANDLER
handler.Wait();
#endif
} else {
DebugReplay *replay = CreateDebugReplay(args);
if (replay == NULL)
return EXIT_FAILURE;
while (replay->Next()) {
client.SendFix(replay->Basic());
usleep(100000);
}
}
#ifdef HAVE_SKYLINES_TRACKING_HANDLER
client.Close();
DeinitialiseIOThread();
#endif
return EXIT_SUCCESS;
}
int main(int argc, char **argv)
{
unsigned full_max_points = 512,
triangle_max_points = 1024,
sprint_max_points = 64;
Args args(argc, argv,
"[options] DRIVER FILE\n"
"Options:\n"
" --full-points=512 Maximum number of full trace points (default = 512)\n"
" --triangle-points=1024 Maximum number of triangle trace points (default = 1024)\n"
" --sprint-points=64 Maximum number of sprint trace points (default = 64)");
const char *arg;
while ((arg = args.PeekNext()) != nullptr && *arg == '-') {
args.Skip();
const char *value;
if ((value = StringAfterPrefix(arg, "--full-points=")) != nullptr) {
unsigned _points = strtol(value, NULL, 10);
if (_points > 0)
full_max_points = _points;
else {
fputs("The start parameter could not be parsed correctly.\n", stderr);
args.UsageError();
}
} else if ((value = StringAfterPrefix(arg, "--triangle-points=")) != nullptr) {
unsigned _points = strtol(value, NULL, 10);
if (_points > 0)
triangle_max_points = _points;
else {
fputs("The start parameter could not be parsed correctly.\n", stderr);
args.UsageError();
}
} else if ((value = StringAfterPrefix(arg, "--sprint-points=")) != nullptr) {
unsigned _points = strtol(value, NULL, 10);
if (_points > 0)
sprint_max_points = _points;
else {
fputs("The start parameter could not be parsed correctly.\n", stderr);
args.UsageError();
}
} else {
args.UsageError();
}
}
DebugReplay *replay = CreateDebugReplay(args);
if (replay == NULL)
return EXIT_FAILURE;
args.ExpectEnd();
static Trace full_trace(0, Trace::null_time, full_max_points);
static Trace triangle_trace(0, Trace::null_time, triangle_max_points);
static Trace sprint_trace(0, 9000, sprint_max_points);
Result result;
Run(*replay, result, full_trace, triangle_trace, sprint_trace);
delete replay;
const ContestStatistics olc_plus = SolveContest(Contest::OLC_PLUS, full_trace, triangle_trace, sprint_trace);
const ContestStatistics dmst = SolveContest(Contest::DMST, full_trace, triangle_trace, sprint_trace);
TextWriter writer("/dev/stdout", true);
{
JSON::ObjectWriter root(writer);
WriteResult(root, result);
root.WriteElement("phases", WritePhaseList,
flight_phase_detector.GetPhases());
root.WriteElement("performance", WritePerformanceStats,
flight_phase_detector.GetTotals());
root.WriteElement("contests", WriteContests, olc_plus, dmst);
}
}
int WINAPI
WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance,
#ifdef _WIN32_WCE
LPWSTR lpCmdLine,
#else
LPSTR lpCmdLine2,
#endif
int nCmdShow)
#endif
{
#ifdef WIN32
Args args(GetCommandLine(), "DRIVER FILE");
#else
Args args(argc, argv, "DRIVER FILE");
#endif
DebugReplay *replay = CreateDebugReplay(args);
if (replay == NULL)
return EXIT_FAILURE;
args.ExpectEnd();
InitialiseDataPath();
Profile::SetFiles(_T(""));
Profile::Load();
const Waypoints way_points;
InterfaceBlackboard blackboard;
blackboard.SetComputerSettings().SetDefaults();
GlideComputerTaskEvents task_events;
TaskManager task_manager(way_points);
task_manager.SetTaskEvents(task_events);
Airspaces airspace_database;
AirspaceWarningManager airspace_warning(airspace_database);
ProtectedTaskManager protected_task_manager(task_manager,
blackboard.GetComputerSettings().task);
LoadFiles(airspace_database);
GlideComputer glide_computer(way_points, airspace_database,
protected_task_manager,
task_events);
glide_computer.SetTerrain(terrain);
glide_computer.Initialise();
glide_computer.ReadComputerSettings(blackboard.GetComputerSettings());
ScreenGlobalInit screen_init;
LoadReplay(replay, glide_computer, blackboard);
delete replay;
#ifdef WIN32
ResourceLoader::Init(hInstance);
#endif
Layout::Initialize(640, 480);
SingleWindow main_window;
main_window.set(_T("STATIC"), _T("RunAnalysis"),
PixelRect{0, 0, 640, 480});
Fonts::Initialize();
dialog_settings.SetDefaults();
Look *look = new Look();
look->Initialise();
look->InitialiseConfigured(blackboard.GetUISettings());
SetXMLDialogLook(look->dialog);
dialog_look = &look->dialog;
main_window.show();
dlgAnalysisShowModal(main_window, *look, blackboard, glide_computer,
&protected_task_manager,
&airspace_database,
terrain);
delete look;
Fonts::Deinitialize();
delete terrain;
DeinitialiseDataPath();
return 0;
}
int main(int argc, char **argv)
{
int start = -1, end = -1;
unsigned max_points = 1000;
Args args(argc, argv,
"[options] DRIVER FILE\n"
"Options:\n"
" --start=5000 Begin flight path at 5000 sec after UTC midnight,\n"
" if not defined takeoff time is used\n"
" --end=15000 End flight path at 15000 sec after UTC midnight,\n"
" if not defined the last timestamp in the file is used\n"
" --max-points=1000 Maximum number of trace points in output (default = 1000)");
const char *arg;
while ((arg = args.PeekNext()) != nullptr && *arg == '-') {
args.Skip();
const char *value;
if ((value = StringAfterPrefix(arg, "--max-points=")) != nullptr) {
unsigned _max_points = strtol(value, NULL, 10);
if (_max_points > 0)
max_points = _max_points;
} else if ((value = StringAfterPrefix(arg, "--start=")) != nullptr) {
char *endptr;
start = strtol(value, &endptr, 10);
if (endptr == value || *endptr != '\0' || start < 0) {
fputs("The start parameter could not be parsed correctly.\n", stderr);
args.UsageError();
}
} else if ((value = StringAfterPrefix(arg, "--end=")) != nullptr) {
char *endptr;
end = strtol(value, &endptr, 10);
if (endptr == value || *endptr != '\0' || end < 0) {
fputs("The end parameter could not be parsed correctly.\n", stderr);
args.UsageError();
}
} else {
args.UsageError();
}
}
if (start >= 0 && end >= 0 && start >= end) {
fputs("The start parameter has to be smaller than the end parameter.\n", stderr);
args.UsageError();
}
DebugReplay *replay = CreateDebugReplay(args);
if (replay == nullptr)
return EXIT_FAILURE;
args.ExpectEnd();
Trace trace(0, Trace::null_time, max_points);
bool takeoff = false;
while (replay->Next()) {
const MoreData &basic = replay->Basic();
const DerivedInfo &calculated = replay->Calculated();
if (!basic.time_available || !basic.location_available ||
!basic.NavAltitudeAvailable())
continue;
if (start >= 0 && (int)basic.time < start)
continue;
if (end >= 0 && (int)basic.time > end)
break;
trace.push_back(TracePoint(basic));
if (start < 0 && calculated.flight.flying && !takeoff) {
takeoff = true;
trace.EraseEarlierThan(calculated.flight.takeoff_time);
}
}
delete replay;
for (auto i = trace.begin(), end = trace.end(); i != end; ++i) {
const TracePoint &point = *i;
printf("%u %f %f %d %u\n",
point.GetTime(),
(double)point.GetLocation().latitude.Degrees(),
(double)point.GetLocation().longitude.Degrees(),
point.GetIntegerAltitude(),
point.GetEngineNoiseLevel());
}
}
