18
0
mirror of https://github.com/MaSzyna-EU07/maszyna.git synced 2026-11-20 04:35:02 +01:00

Merge branch 'master' into feat/renderers-cleanup

This commit is contained in:
2026-11-16 21:44:48 +01:00
264 changed files with 41203 additions and 10041 deletions

View File

@@ -34,6 +34,7 @@ http://mozilla.org/MPL/2.0/.
#include <glm/gtc/matrix_transform.hpp>
#include <glm/gtc/type_ptr.hpp>
#include <algorithm>
#include <array>
#include "editor/editorFormat.hpp"
#include "editor/editorAlignmentStore.hpp"
#include "editor/editorSwitchStore.hpp"
@@ -45,6 +46,7 @@ http://mozilla.org/MPL/2.0/.
#include <cstring>
#include <cstdlib>
#include <fstream>
#include <iomanip>
#include <map>
#include <sstream>
#include "application/editormodeselftest.h"
@@ -159,6 +161,8 @@ editor_mode::selftest_result editor_mode::selftest_terrain(std::string const &co
m_terrain_add_count = std::clamp(static_cast<int>(value), 1, 8);
else if (key == "shape")
state.shape = value != 0.0;
else if (key == "common")
state.common = value != 0.0;
else if (key == "follow")
state.follow = value != 0.0;
else if (key == "offset")
@@ -171,6 +175,8 @@ editor_mode::selftest_result editor_mode::selftest_terrain(std::string const &co
EditorSettings.terrain_while_laying(state.grow);
EditorSettings.save();
}
else if (key == "area")
m_area_terrain.run_only = value != 0.0; // for the run only: the setting isn't touched, so no save keeps it
}
WriteLog(format("SELFTEST nmtsettings band %.0f around %d shape %d follow %d grow %d offset %+.2f fitted %d", state.band, m_terrain_add_count, state.shape ? 1 : 0, state.follow ? 1 : 0, state.grow ? 1 : 0, state.offset,
state.fitted ? 1 : 0));
@@ -323,6 +329,34 @@ editor_mode::selftest_result editor_mode::selftest_terrain(std::string const &co
WriteLog("SELFTEST nmtauto " + which + ": " + m_nmt_state.status);
return selftest_result::handled;
}
if (command == "shorttracks")
{
// how many plain tracks are short, the ballast mapped on each from its start: under 1, 3 and 6 m
std::string label;
words >> label;
std::array<int, 3> counts{};
int all{0};
for (auto const *track : simulation::Paths.sequence())
{
if (track == nullptr || track->m_editorremoved || track->m_paths.empty() || track->eType != tt_Normal)
continue;
++all;
auto const length{geometry::bezier{track->m_paths.front()}.plan_length()};
for (auto const [i, limit] : {std::pair{0, 1.0}, std::pair{1, 3.0}, std::pair{2, 6.0}})
if (length < limit)
++counts[i];
}
WriteLog(format("SELFTEST shorttracks %s: %d plain tracks, under 1 m %d, under 3 m %d, under 6 m %d", label.c_str(), all, counts[0], counts[1], counts[2]));
return selftest_result::handled;
}
if (command == "shareexplain")
{
// the next sharing of the grade lines tells in the log of the runs of the tracks named
m_nmt_state.explain = " ";
for (std::string name; words >> name;)
m_nmt_state.explain += name + " ";
return selftest_result::handled;
}
if (command == "turntables")
{
// each turntable: the height of its rails and of the model in its pit; of each track running up to it the heights out along
@@ -367,12 +401,11 @@ editor_mode::selftest_result editor_mode::selftest_terrain(std::string const &co
}
// level off the rim within a centimetre
double level{0.0};
double off{0.0};
while (off <= length && std::abs(height_at(off) - points[segment_data::point::start].y) <= 0.01)
{
level = off;
off += 0.5;
}
for (int k = 0; k * 0.5 <= length; ++k)
if (std::abs(height_at(k * 0.5) - points[segment_data::point::start].y) <= 0.01)
level = k * 0.5;
else
break;
WriteLog(format("SELFTEST turntable %s track %s: at the rim %.3f m, %+.2f per mille over its first 5 m, level within 1 cm of the table for %.1f m; out along it%s", table.table->name().c_str(), track->name().c_str(), rim.y,
1000.0 * (height_at(std::min(5.0, length)) - height_at(0.0)) / std::max(1e-6, std::min(5.0, length)), level, text.c_str()));
}
@@ -404,8 +437,8 @@ editor_mode::selftest_result editor_mode::selftest_terrain(std::string const &co
}
}
std::size_t written{0};
for (auto const layer : scene::Layers.marked_layers("//$f"))
written += scene::Layers.marked(layer, "//$f").size();
for (auto const layer : scene::Layers.marked_layers("//$t"))
written += scene::Layers.marked(layer, "//$t").size();
WriteLog(format("SELFTEST fittedstate: %zu of %zu tracks fitted, %zu marks kept, %zu lines for the files;", done, rails, m_fitted.size(), written) + names);
return selftest_result::handled;
}
@@ -788,6 +821,464 @@ editor_mode::selftest_result editor_mode::selftest_terrain(std::string const &co
WriteLog(format("SELFTEST terraincursor: %s %.2f %.2f %.2f", found ? "ground" : "none", world.x, world.y, world.z));
return selftest_result::handled;
}
if (command == "fitreport")
{
// after the tracks went onto the terrain, to a file: of each track how far its top of the ballast is off the terrain model (T),
// of each switch how far its second path is off the plane of the first (P), of each switch and track on timbers common with it,
// under 2.65 m apart, the most their rails differ in height (K)
std::string file;
words >> file;
std::ofstream stream(file);
double constexpr kTimbers{2.65};
double constexpr kStep{5.0};
struct place
{
glm::dvec3 position;
glm::dvec2 along;
TTrack const *track;
};
std::map<std::pair<int, int>, std::vector<place>> places;
auto const cell_of = [&](glm::dvec3 const &Point) { return std::pair<int, int>{static_cast<int>(std::floor(Point.x / kTimbers)), static_cast<int>(std::floor(Point.z / kTimbers))}; };
std::vector<place> all;
for (auto const *track : simulation::Paths.sequence())
{
if (track == nullptr || track->m_editorremoved || track->m_paths.empty() || (track->iCategoryFlag & 15) != 1 || track->eType == tt_Table)
continue;
auto const found{m_nmt_state.grade_lines.find(grade_line_key(*track))};
auto const line{found != m_nmt_state.grade_lines.end() ? found->second : nmt_state::grade_line_own};
double worst{0.0};
glm::dvec3 worst_at{0.0};
double sum{0.0};
int counted{0};
for (auto const &path : track->m_paths)
{
geometry::bezier const curve{path};
auto const places_on{std::max(1, static_cast<int>(geometry::chord_length(path) / kStep))};
for (int i = 0; i <= places_on; ++i)
{
auto const share{static_cast<double>(i) / places_on};
auto const point{curve.point(share)};
auto const tangent{geometry::plan_of(curve.first(share))};
place const here{point, glm::length(tangent) > 1e-9 ? glm::normalize(tangent) : glm::dvec2{1.0, 0.0}, track};
all.push_back(here);
places[cell_of(point)].push_back(here);
if (double height; m_nmt.height(point.x, point.z, height))
{
auto const off{point.y - (height + m_nmt_state.offset + track->rail_height())};
++counted;
sum += off;
if (std::abs(off) > std::abs(worst))
{
worst = off;
worst_at = point;
}
}
}
}
if (counted > 0)
stream << "T " << track->name() << ' ' << (track->eType == tt_Switch ? 's' : 'n') << ' ' << line << ' ' << worst << ' ' << sum / counted << ' ' << worst_at.x << ' ' << worst_at.z << ' ' << worst_at.y << ' ' << counted << '\n';
if (track->eType == tt_Switch && track->m_paths.size() >= 2)
{
geometry::bezier const main{track->m_paths[0]};
geometry::bezier const branch{track->m_paths[1]};
auto const direction{main.first(0.0)};
auto const grade{direction.y / std::max(1e-6, std::hypot(direction.x, direction.z))};
auto const end{branch.point(1.0)};
auto const start{branch.point(0.0)};
// against the first path as far along it, in its plane or on the vertical curve it lies on; past its end against the grade it ends with
auto const chord{geometry::plan_of(main.point(1.0) - main.point(0.0))};
auto const along{glm::dot(geometry::plan_of(end - main.point(0.0)), chord) / std::max(1e-9, glm::dot(chord, chord))};
auto const last{main.first(1.0)};
auto const on_main{main.point(std::clamp(along, 0.0, 1.0)).y + std::max(0.0, along - 1.0) * glm::length(chord) * last.y / std::max(1e-6, std::hypot(last.x, last.z))};
stream << "P " << track->name() << ' ' << line << ' ' << end.y - on_main << ' ' << grade * 1000.0 << ' ' << start.x << ' ' << start.z << '\n';
}
}
struct pair_worst
{
double difference{0.0};
glm::dvec3 at{0.0};
double apart{0.0};
};
std::map<std::pair<std::string, std::string>, pair_worst> pairs;
for (auto const &here : all)
{
auto const cell{cell_of(here.position)};
for (int dx = -1; dx <= 1; ++dx)
for (int dz = -1; dz <= 1; ++dz)
if (auto const found{places.find({cell.first + dx, cell.second + dz})}; found != places.end())
for (auto const &other : found->second)
{
if (other.track == here.track || (here.track->eType != tt_Switch && other.track->eType != tt_Switch) || here.track->name() > other.track->name())
continue;
glm::dvec2 const offset{other.position.x - here.position.x, other.position.z - here.position.z};
if (glm::length(offset) >= kTimbers || std::abs(glm::dot(offset, here.along)) > 0.6 * kStep || std::abs(other.position.y - here.position.y) > 2.0)
continue;
auto &worst{pairs[{here.track->name(), other.track->name()}]};
if (auto const difference{std::abs(other.position.y - here.position.y)}; difference >= worst.difference)
worst = {difference, here.position, glm::length(offset)};
}
}
for (auto const &[names, worst] : pairs)
stream << "K " << names.first << ' ' << names.second << ' ' << worst.difference << ' ' << worst.apart << ' ' << worst.at.x << ' ' << worst.at.z << '\n';
for (auto const &place : m_nmt_state.surface_places)
if (auto const *track{place.track}; false == track->m_editorremoved && place.path < static_cast<int>(track->m_paths.size()))
{
auto const point{geometry::bezier{track->m_paths[place.path]}.point(place.share)};
stream << "Z " << place.surface << ' ' << point.x << ' ' << point.z << ' ' << point.y << ' ' << track->name() << '\n';
}
WriteLog("SELFTEST fitreport: " + file);
return selftest_result::handled;
}
// the common grade line of the route open in the profile tool: lift <m>: its design up by that much and applied; hand: its tracks marked
// as edited by hand; off, on: the route
// taken off it and back; whole 0/1: whether the tracks beside go with it; state told in the log
if (command == "gradeline")
{
// the word after the action is its number, or the name of a track
std::string action, word;
words >> action >> word;
double const value{std::atof(word.c_str())};
auto &state{m_profile};
if (action == "part")
{
// the route cut to <value> tracks on each side of the track named
std::string name;
words >> name;
auto const &spans{state.route.spans};
auto const at{std::find_if(spans.begin(), spans.end(), [&](auto const &Span) { return Span.track->name() == name; })};
if (at != spans.end())
{
auto const index{std::distance(spans.begin(), at)};
auto *first{spans[std::max<std::ptrdiff_t>(0, index - static_cast<std::ptrdiff_t>(value))].track};
auto *last{spans[std::min<std::ptrdiff_t>(spans.size() - 1, index + static_cast<std::ptrdiff_t>(value))].track};
profile_open(first, last);
}
}
if (action == "bump")
{
// a point more in the middle of the route, up by that much, and applied
profile::pvi point;
double at{state.route.length * 0.5};
words >> at;
point.chainage = at;
point.elevation = profile::elevation(state.line, point.chainage) + value;
auto &points{state.line.points};
points.insert(std::lower_bound(points.begin(), points.end(), point.chainage, [](profile::pvi const &Point, double const Chainage) { return Point.chainage < Chainage; }), point);
profile_edited();
profile_apply(false);
WriteLog("SELFTEST gradeline bump: " + state.status + " " + state.error);
for (auto const &issue : state.issues)
if (issue.error)
WriteLog(format("SELFTEST gradeline error at %.1f: %s", issue.chainage, issue.text.c_str()));
}
if (action == "lift")
{
for (auto &point : state.line.points)
point.elevation += value;
profile_check();
profile_apply(false);
WriteLog("SELFTEST gradeline lift: " + state.status + " " + state.error);
for (auto const &issue : state.issues)
if (issue.error)
WriteLog(format("SELFTEST gradeline error at %.1f: %s", issue.chainage, issue.text.c_str()));
}
else if (action == "off" || action == "on")
grade_line_take_off(action == "off");
else if (action == "picking")
state.picking = value != 0.0;
else if (action == "move")
{
// move <name> <dx> <dz>: the track by that in the plan, its ends off the ones it met
glm::dvec3 offset{0.0};
words >> offset.x >> offset.z;
if (auto *track{simulation::Paths.find(word)}; track != nullptr)
{
std::vector<std::pair<TTrack *, editor_track::state>> states{{track, editor_track::capture(*track)}};
editor_track::translate(*track, offset);
editor_track::commit({track});
push_track_snapshot(std::move(states), {});
}
}
else if (action == "of" || action == "rename")
{
// of <name|selected>: the line of the track; rename <name> <new>: under the new name, its line going with it
auto const &name{word};
std::string renamed;
words >> renamed;
auto *track{name == "selected" ? selected_track() : simulation::Paths.find(name)};
if (track != nullptr && action == "rename" && false == renamed.empty())
editor_track::rename(*track, renamed);
grade_lines_load();
auto const found{track != nullptr ? m_nmt_state.grade_lines.find(grade_line_key(*track)) : m_nmt_state.grade_lines.end()};
WriteLog(format("SELFTEST gradeline %s %s: %s, line %d%s", action.c_str(), name.c_str(), track != nullptr ? track->name().c_str() : "-", found != m_nmt_state.grade_lines.end() ? found->second : -100,
found != m_nmt_state.grade_lines.end() && m_nmt_state.grade_lines_hand.contains(found->first) ? " by hand" : ""));
}
else if (action == "pick")
{
// pick <x> <z> [1]: the track nearest to it clicked while picking, onto the grade line of the route or off it; 1: the track only
double z{0.0};
int alone{0};
words >> z >> alone;
glm::dvec3 const point{value, 0.0, z};
TTrack *closest{nullptr};
auto nearest{10.0};
for (auto *track : simulation::Paths.sequence())
{
if (track == nullptr || track->m_editorremoved || track->m_paths.empty() || track->eType == tt_Table)
continue;
if (auto const distance{geometry::plan_distance(editor_track::point_at(*track, editor_track::nearest_parameter(*track, point)), point)}; distance < nearest)
{
nearest = distance;
closest = track;
}
}
if (closest != nullptr)
grade_line_pick(*closest, alone != 0);
auto const number{route_grade_line()};
WriteLog(format("SELFTEST gradeline pick %s: %s; the route on line %d of %zu tracks", closest != nullptr ? closest->name().c_str() : "-", state.status.c_str(), number, grade_line_members(number).size()));
}
else if (action == "whole")
state.whole_grade_line = value != 0.0;
else if (action == "hand")
{
// the tracks of the route marked as edited by hand, without an edit held up by what lies on them
std::vector<TTrack *> tracks;
for (auto const &span : state.route.spans)
tracks.push_back(span.track);
fitted_set(tracks, true);
}
grade_lines_load();
auto const found{state.route.spans.empty() ? m_nmt_state.grade_lines.end() : m_nmt_state.grade_lines.find(grade_line_key(*state.route.spans.front().track))};
WriteLog(format("SELFTEST gradeline %s: route %zu tracks, of line %d, %zu beside, whole %d, %zu tracks on lines, %zu by hand", action.c_str(), state.route.spans.size(), found != m_nmt_state.grade_lines.end() ? found->second : -100, grade_line_beside().size(), state.whole_grade_line ? 1 : 0, m_nmt_state.grade_lines.size(), m_nmt_state.grade_lines_hand.size()));
return selftest_result::handled;
}
// the heights of the ends of the paths of all the tracks to the file, for two states of the scenery to be compared, the stay of each
if (command == "trackheights")
{
std::string file;
words >> file;
std::ofstream stream{file};
stream << std::fixed << std::setprecision(4);
for (auto const *track : simulation::Paths.sequence())
if (track != nullptr && false == track->m_editorremoved)
for (auto const &path : track->m_paths)
stream << track->name() << ' ' << (grade_hand(*track) ? 'h' : grade_fitted(*track) ? 'f' : 'n') << ' ' << path.points[segment_data::point::start].y << ' ' << path.points[segment_data::point::end].y << '\n';
WriteLog("SELFTEST trackheights: " + file);
return selftest_result::handled;
}
// the route open in the profile tool, as it lies and as the grade line reads it: S chainage height grade track, P chainage height radius
if (command == "profiledump")
{
std::string file;
words >> file;
std::ofstream stream{file, std::ios::app};
stream << std::fixed << std::setprecision(4);
stream << "R " << m_profile.samples.size() << ' ' << m_profile.line.points.size() << ' ' << m_profile.departure << '\n';
for (std::size_t i = 0; i < m_profile.samples.size(); ++i)
{
auto const &sample{m_profile.samples[i]};
double model{std::numeric_limits<double>::quiet_NaN()};
if (double height; m_nmt.height(sample.position.x, sample.position.z, height))
model = height + m_nmt_state.offset + (sample.span < m_profile.route.spans.size() && m_profile.route.spans[sample.span].track != nullptr ? m_profile.route.spans[sample.span].track->rail_height() : 0.0);
stream << "S " << sample.chainage << ' ' << sample.position.y << ' ' << sample.grade << ' ' << (sample.span < m_profile.route.spans.size() && m_profile.route.spans[sample.span].track != nullptr ? m_profile.route.spans[sample.span].track->name() : std::string{"-"}) << ' ' << model << '\n';
}
for (auto const &point : m_profile.line.points)
stream << "P " << point.chainage << ' ' << point.elevation << ' ' << point.radius << '\n';
// what a fit of the line is told besides: the ends joined, the switches, the heights held, the norms
auto const &context{m_profile.context};
auto const &line{m_profile.line};
stream << "C " << context.length << ' ' << context.start_joined << ' ' << context.start_elevation << ' ' << context.start_grade << ' ' << context.end_joined << ' ' << context.end_elevation << ' ' << context.end_grade << '\n';
for (auto const &zone : context.switches)
stream << "Z " << zone.from << ' ' << zone.to << '\n';
for (auto const &zone : context.humps)
stream << "H " << zone.from << ' ' << zone.to << '\n';
for (auto const &[chainage, elevation] : context.fixed)
stream << "F " << chainage << ' ' << elevation << '\n';
stream << "L " << line.speed << ' ' << line.norms.grade_max << ' ' << line.norms.grade_switch_max << ' ' << line.norms.radius_factor << ' ' << line.norms.radius_min << ' ' << line.norms.curve_threshold << ' ' << line.norms.element_min << ' '
<< line.norms.fixed_tolerance << ' ' << line.join_start << ' ' << line.join_end << '\n';
WriteLog("SELFTEST profiledump: " + file);
return selftest_result::handled;
}
// the tracks beside the route open in the profile tool, every 5 m: T track line, B chainage height track line across height of the nearest
// nearly parallel track under 6 m on each side
if (command == "besidedump")
{
std::string file;
words >> file;
std::ofstream stream{file, std::ios::app};
stream << std::fixed << std::setprecision(3);
grade_lines_load();
auto const line_of = [&](TTrack const &Track) {
auto const found{m_nmt_state.grade_lines.find(grade_line_key(Track))};
return found != m_nmt_state.grade_lines.end() ? found->second : -100;
};
std::unordered_set<TTrack const *> route;
for (auto const &span : m_profile.route.spans)
{
route.insert(span.track);
stream << "T " << span.track->name() << ' ' << line_of(*span.track) << ' ' << (grade_hand(*span.track) ? 'h' : grade_fitted(*span.track) ? 'f' : 'n') << '\n';
}
struct spot
{
glm::dvec3 position;
glm::dvec2 along;
TTrack const *track;
};
std::vector<spot> spots;
for (auto const *track : simulation::Paths.sequence())
if (track != nullptr && false == track->m_editorremoved && false == route.contains(track))
for (auto const &path : track->m_paths)
{
geometry::bezier const curve{path};
auto const count{std::max(1, static_cast<int>(geometry::plan_distance(path.points[segment_data::point::start], path.points[segment_data::point::end]) / 1.0))};
for (int i = 0; i <= count; ++i)
{
auto const tangent{geometry::plan_of(curve.first(static_cast<double>(i) / count))};
spots.push_back({curve.point(static_cast<double>(i) / count), glm::length(tangent) > 1e-9 ? glm::normalize(tangent) : glm::dvec2{1.0, 0.0}, track});
}
}
auto const &samples{m_profile.samples};
for (std::size_t i = 0; i + 1 < samples.size(); i += 5)
{
auto const &here{samples[i]};
auto const along{glm::normalize(geometry::plan_of(samples[i + 1].position - here.position))};
std::array<spot const *, 2> sides{nullptr, nullptr};
std::array<double, 2> across{6.0, 6.0};
for (auto const &other : spots)
{
glm::dvec2 const offset{other.position.x - here.position.x, other.position.z - here.position.z};
if (std::abs(glm::dot(offset, along)) > 0.6 || std::abs(glm::dot(along, other.along)) < 0.985)
continue;
auto const side{along.x * offset.y - along.y * offset.x};
if (auto const k{side > 0.0 ? 0 : 1}; std::abs(side) < across[k])
{
across[k] = std::abs(side);
sides[k] = &other;
}
}
auto const *track{here.span < m_profile.route.spans.size() ? m_profile.route.spans[here.span].track : nullptr};
stream << "B " << here.chainage << ' ' << here.position.y << ' ' << (track != nullptr ? track->name() : std::string{"-"}) << ' ' << (track != nullptr ? line_of(*track) : -100);
for (int k = 0; k < 2; ++k)
if (sides[k] != nullptr)
stream << " | " << sides[k]->track->name() << ' ' << line_of(*sides[k]->track) << ' ' << across[k] << ' ' << sides[k]->position.y - here.position.y;
else
stream << " | -";
stream << '\n';
}
WriteLog("SELFTEST besidedump: " + file);
return selftest_result::handled;
}
if (command == "profileaudit")
{
// every design kept in the scenery opened as the profile opens it: how many have errors, how many were read from the track again
profile_library_load();
std::size_t gone{0}, failing{0}, retaken{0};
auto const count{m_profiles.size()};
for (std::size_t i = 0; i < count; ++i)
{
auto const entry{m_profiles[i]};
TTrack *from{nullptr};
TTrack *to{nullptr};
if (false == profile_stored_route(entry, &from, &to).has_value())
{
if (++gone <= 5)
{
// what the route between the ends found is against the design
std::string routes;
for (auto *track : simulation::Paths.sequence())
if (track != nullptr && false == track->m_editorremoved && editor_track::is_supported(*track))
for (auto const &path : track->m_paths)
for (auto const index : {segment_data::point::start, segment_data::point::end})
if (glm::length(glm::dvec2{path.points[index].x - entry.start.x, path.points[index].z - entry.start.z}) <= 0.1)
for (auto *other : simulation::Paths.sequence())
if (other != nullptr && other != track && false == other->m_editorremoved && editor_track::is_supported(*other))
for (auto const &end : other->m_paths)
for (auto const last : {segment_data::point::start, segment_data::point::end})
if (glm::length(glm::dvec2{end.points[last].x - entry.end.x, end.points[last].z - entry.end.z}) <= 0.1)
{
editor_track::route route;
std::string error;
if (false == editor_track::find_route(track, other, route, error))
{
routes += format(" [%s > %s: none]", track->name().c_str(), other->name().c_str());
continue;
}
auto const samples{editor_track::sample_route(route, 1.0)};
auto const middle{editor_track::sampled_position(samples, route.length * 0.5)};
routes += format(" [%s > %s: %zu spans %.1f m, start %.2f, middle %.2f]", track->name().c_str(), other->name().c_str(), route.spans.size(), route.length, glm::length(glm::dvec2{samples.front().position.x - entry.start.x, samples.front().position.z - entry.start.z}), glm::length(glm::dvec2{middle.x - entry.middle.x, middle.z - entry.middle.z}));
}
WriteLog(format("SELFTEST profileaudit: no route for the design of %.1f m from %.2f %.2f %.2f to %.2f %.2f %.2f;%s", entry.length, entry.start.x, entry.start.y, entry.start.z, entry.end.x, entry.end.y, entry.end.z, routes.c_str()));
}
continue;
}
profile_open_stored(i);
// the design leaves the track by more than what it's read again from it for
if (m_profile.departure > 0.02)
{
++retaken;
double worst{0.0};
std::size_t at{0};
for (std::size_t k = 0; k < m_profile.samples.size(); ++k)
if (auto const off{std::abs(profile::elevation(m_profile.line, m_profile.samples[k].chainage) - m_profile.samples[k].position.y)}; off > worst)
{
worst = off;
at = k;
}
std::string zone;
if (false == m_profile.samples.empty())
for (auto const &one : m_profile.context.switches)
if (m_profile.samples[at].chainage >= one.from - 5.0 && m_profile.samples[at].chainage <= one.to + 5.0)
zone += format(" [%.1f..%.1f %s]", one.from, one.to, one.name.c_str());
if (false == m_profile.samples.empty())
WriteLog(format("SELFTEST profileaudit off: %s .. %s, %.0f m, %.3f m off at %.1f on %s, kept departure %.3f;%s %s", from->name().c_str(), to->name().c_str(), m_profile.route.length, worst, m_profile.samples[at].chainage,
m_profile.route.spans[m_profile.samples[at].span].track->name().c_str(), entry.departure, zone.c_str(), m_profile.status.c_str()));
}
std::string errors;
for (auto const &issue : m_profile.issues)
if (issue.error)
errors += " | " + issue.text;
if (false == errors.empty())
{
++failing;
WriteLog(format("SELFTEST profileaudit: %s .. %s, %.0f m, departure %.3f m; %s%s", from->name().c_str(), to->name().c_str(), m_profile.route.length, m_profile.departure, m_profile.status.c_str(), errors.c_str()));
}
}
WriteLog(format("SELFTEST profileaudit: %zu designs, %zu with errors, %zu off the track by over 2 cm, %zu with no route", count, failing, retaken, gone));
return selftest_result::handled;
}
if (command == "gradelines")
{
// the shared grade lines to a file for the map of them: name, line, kind, points of the plan with the height
std::string file;
words >> file;
std::ofstream stream(file);
for (auto const *track : simulation::Paths.sequence())
{
if (track == nullptr || track->m_editorremoved || track->m_paths.empty() || (track->iCategoryFlag & 15) != 1)
continue;
auto const found{m_nmt_state.grade_lines.find(grade_line_key(*track))};
auto const line{found != m_nmt_state.grade_lines.end() ? found->second : nmt_state::grade_line_own};
for (auto const &path : track->m_paths)
{
geometry::bezier const curve{path};
stream << track->name() << ' ' << line << ' ' << (track->eType == tt_Switch ? 's' : 'n');
for (int i = 0; i <= 6; ++i)
{
auto const point{curve.point(i / 6.0)};
stream << ' ' << point.x << ' ' << point.z << ' ' << point.y;
}
stream << '\n';
}
}
WriteLog("SELFTEST gradelines: " + file);
return selftest_result::handled;
}
if (command == "nmtstate")
{
// how far the tracks going onto the terrain are
WriteLog(format("SELFTEST nmtstate stage %d, lines %zu, refused %zu, left %zu, squares waiting %zu: %s", static_cast<int>(m_nmt_state.stage), m_nmt_state.lines, m_nmt_state.refused, m_nmt_state.left.size(), m_nmt.waiting(), m_nmt_state.status.c_str()));
return selftest_result::handled;
}
if (command == "trackterrain")
{
// the terrain drawn to the named tracks, or their formations taken out of it, as the buttons of the panel of the tracks