feat(editor): the kilometrage tool leads a line through a station along the tracks chosen, the straight paths of the switches by default, from the track chosen on along them until the line meets its tracks again or on and away at a junction, kept as //$k via lines; a track beside that comes back onto the line between the stretches it runs beside it or both ways is a track of a station, not the other track of a double-track line

2026-10-31 05:20:52 +01:00 · 2026-10-22 14:16:42 +02:00
parent 5ecb6ebe00
commit 7cc8e5bb9a
10 changed files with 533 additions and 38 deletions
--- a/editor/editorKilometrage.cpp
+++ b/editor/editorKilometrage.cpp
@@ -20,6 +20,7 @@ http://mozilla.org/MPL/2.0/.

 #include <algorithm>
 #include <cmath>
+#include <iterator>
 #include <limits>
 #include <map>
 #include <set>
@@ -46,9 +47,11 @@ double const kCell{10.0}; // m, of the squares the track beside is sorted into
 double const kApart{15.0}; // m between the tracks, of a double-track line on two formations
 double const kBlend{100.0}; // m, the axis takes to go over from between the tracks to one of them
 double const kLonger{1.0}; // m, of the track beside longer than the track of the line, for the axis to follow it
+double const kDetour{20000.0}; // m, of the tracks followed each way from a via back onto the line

 std::vector<mark> g_marks;
-std::vector<mark> g_base; // as they were before the changes not yet in the undo history
+std::vector<via> g_vias;
+state g_base; // as it was before the changes not yet in the undo history
 bool g_changed{false};
 bool g_loaded{false};
 std::size_t g_edits{0};
@@ -70,18 +73,22 @@ std::string word(std::string const &Text)

 // format of the lines, coordinates in the space of the file:
 //   mark <line> <x y z> way <x z> km <km> [beyond <km>]
+//   via <line> <x y z>
 void store(scene::layer_handle const Layer)
 {
 	if (false == scene::Layers.valid(Layer))
 		return;
 	auto const &context{scene::Layers.layer(Layer).context_insert()};
 	std::vector<std::string> lines;
+	auto const heading = [&]() {
+		if (lines.empty())
+			lines.emplace_back("# kilometrage of the lines set in the track editor, the simulation skips these lines");
+	};
 	for (auto const &entry : g_marks)
 	{
 		if (entry.layer != Layer)
 			continue;
-		if (lines.empty())
-			lines.emplace_back("# kilometrage of the lines set in the track editor, the simulation skips these lines");
+		heading();
 		auto const point{context.to_local(entry.point)};
 		auto const ahead{context.to_local(entry.point + glm::dvec3{entry.way.x, 0.0, entry.way.y})};
 		auto way{plan_of(ahead - point)};
@@ -91,6 +98,14 @@ void store(scene::layer_handle const Layer)
 			text += format(" beyond %.3f", *entry.beyond);
 		lines.push_back(text);
 	}
+	for (auto const &entry : g_vias)
+	{
+		if (entry.layer != Layer)
+			continue;
+		heading();
+		auto const point{context.to_local(entry.point)};
+		lines.push_back(format("via %s %.4f %.4f %.4f", word(entry.line).c_str(), point.x, point.y, point.z));
+	}
 	scene::Layers.mark(Layer, kMark, std::move(lines));
 }

@@ -139,6 +154,79 @@ std::vector<span> once(std::vector<span> const &Spans)
 	return result;
 }

+// the route runs along the track of the via, along the path of a switch it stands on
+bool runs_by(editor_track::route const &Route, std::size_t const Via)
+{
+	int path{0};
+	auto const *track{track_near(g_vias[Via].point, kNear, path)};
+	return track != nullptr && std::any_of(Route.spans.begin(), Route.spans.end(), [&](span const &Entry) { return Entry.track == track && Entry.path == path; });
+}
+
+// the route led along the tracks of the vias: from the track of each the run along the straight paths of the switches both ways
+// back onto the route takes the place of the stretch of the route between where it comes back; where it comes back one way only,
+// as at a junction, the route goes on along it from there
+void through(editor_track::route &Route, std::vector<std::size_t> const &Vias)
+{
+	for (auto const index : Vias)
+	{
+		int path{0};
+		auto *track{track_near(g_vias[index].point, kNear, path)};
+		if (track == nullptr || runs_by(Route, index))
+			continue;
+		auto const run{editor_track::run_route(*track, kDetour, path)};
+		auto const at{index_of(run.spans, track)};
+		if (at == run.spans.size())
+			continue;
+		auto const none{Route.spans.size()};
+		auto const on = [&](std::size_t const Index) { return index_of(Route.spans, run.spans[Index].track); };
+		std::optional<std::size_t> low;
+		for (auto i = at; i-- > 0;)
+			if (on(i) != none)
+			{
+				low = i;
+				break;
+			}
+		std::optional<std::size_t> high;
+		for (auto i = at + 1; i < run.spans.size(); ++i)
+			if (on(i) != none)
+			{
+				high = i;
+				break;
+			}
+		auto const part = [&](std::size_t const From, std::size_t const To) { return std::vector<span>{run.spans.begin() + From, run.spans.begin() + To}; };
+		auto const head = [&](std::size_t const To) { return std::vector<span>{Route.spans.begin(), Route.spans.begin() + To}; };
+		auto const tail = [&](std::size_t const From) { return std::vector<span>{Route.spans.begin() + From, Route.spans.end()}; };
+		auto const joined = [](std::vector<std::vector<span>> const &Parts) {
+			std::vector<span> result;
+			for (auto const &entry : Parts)
+				result.insert(result.end(), entry.begin(), entry.end());
+			return result;
+		};
+		std::vector<span> spans;
+		if (low && high)
+		{
+			auto const from{on(*low)};
+			auto const to{on(*high)};
+			if (from == to)
+				continue;
+			spans = from < to ? joined({head(from), part(*low, *high + 1), tail(to + 1)}) : joined({head(to), flipped(part(*low, *high + 1)), tail(from + 1)});
+		}
+		else if (low)
+		{
+			auto const from{on(*low)};
+			spans = run.spans[*low].forward == Route.spans[from].forward ? joined({head(from), part(*low, run.spans.size())}) : joined({flipped(part(*low, run.spans.size())), tail(from + 1)});
+		}
+		else if (high)
+		{
+			auto const to{on(*high)};
+			spans = run.spans[*high].forward == Route.spans[to].forward ? joined({part(0, *high + 1), tail(to + 1)}) : joined({head(to), flipped(part(0, *high + 1))});
+		}
+		else
+			continue;
+		Route.spans = once(spans);
+	}
+}
+
 double plan_gap(std::vector<editor_track::route_sample> const &Samples, glm::dvec3 const &Point)
 {
 	auto best{std::numeric_limits<double>::max()};
@@ -150,18 +238,20 @@ double plan_gap(std::vector<editor_track::route_sample> const &Samples, glm::dve
 // the track beside the line: of each sample of the line the sample of it beside, where they run side by side
 struct pairing
 {
+	editor_track::route route; // of the track beside
 	std::vector<editor_track::route_sample> partner; // along the track beside, empty for none
 	std::vector<int> match; // of each sample, -1 where the track beside isn't there
 	std::vector<double> across; // to the sample beside, along the normal of the sample
 };

-pairing pair_with(std::vector<editor_track::route_sample> const &Samples, TTrack &Beside)
+pairing pair_with(std::vector<editor_track::route_sample> const &Samples, TTrack &Beside, std::vector<std::size_t> const &Vias)
 {
 	pairing result;
 	result.match.assign(Samples.size(), -1);
 	result.across.assign(Samples.size(), 0.0);
-	auto other{editor_track::run_route(Beside, kReach)};
-	result.partner = editor_track::sample_route(other, kStep);
+	result.route = editor_track::run_route(Beside, kReach);
+	through(result.route, Vias);
+	result.partner = editor_track::sample_route(result.route, kStep);
 	auto const &partner{result.partner};
 	auto const cell = [](glm::dvec3 const &Point) { return std::make_pair(static_cast<long>(std::floor(Point.x / kCell)), static_cast<long>(std::floor(Point.z / kCell))); };
 	std::map<std::pair<long, long>, std::vector<std::size_t>> grid;
@@ -195,9 +285,29 @@ pairing pair_with(std::vector<editor_track::route_sample> const &Samples, TTrack
 	return result;
 }

+// the track beside comes back onto the line between the stretches it runs beside it, or both ways, as a track of a station or a
+// passing loop does: not the other track
+bool looped(pairing const &Pairs, std::unordered_set<TTrack const *> const &Own)
+{
+	auto low{Pairs.partner.size()};
+	std::size_t high{0};
+	for (auto const match : Pairs.match)
+		if (match >= 0)
+		{
+			low = std::min(low, static_cast<std::size_t>(match));
+			high = std::max(high, static_cast<std::size_t>(match));
+		}
+	auto const on_line = [&](editor_track::route_sample const &Sample) { return Sample.span < Pairs.route.spans.size() && Own.count(Pairs.route.spans[Sample.span].track) > 0; };
+	if (low >= Pairs.partner.size())
+		return false;
+	auto const first{Pairs.partner.begin() + static_cast<std::ptrdiff_t>(low)};
+	auto const last{Pairs.partner.begin() + static_cast<std::ptrdiff_t>(high) + 1};
+	return std::any_of(first, last, on_line) || (std::any_of(Pairs.partner.begin(), first, on_line) && std::any_of(last, Pairs.partner.end(), on_line));
+}
+
 // the track beside the line, looked for by the first mark and then every 500 m along the line: a track the line doesn't run
 // through, the spacing of a double-track line away, beside it for 100 m at least
-pairing pair_up(std::vector<editor_track::route_sample> const &Samples, editor_track::route const &Route, std::size_t const Origin)
+pairing pair_up(std::vector<editor_track::route_sample> const &Samples, editor_track::route const &Route, std::size_t const Origin, std::vector<std::size_t> const &Vias)
 {
 	std::unordered_set<TTrack const *> own;
 	for (auto const &entry : Route.spans)
@@ -220,8 +330,8 @@ pairing pair_up(std::vector<editor_track::route_sample> const &Samples, editor_t
 				auto *track{track_near({probe.x, at.position.y, probe.y}, 1.6)};
 				if (track == nullptr || own.count(track) > 0 || false == tried.insert(track).second)
 					continue;
-				auto result{pair_with(Samples, *track)};
-				if (std::count_if(result.match.begin(), result.match.end(), [](int const Match) { return Match >= 0; }) * kStep >= 100.0)
+				auto result{pair_with(Samples, *track, Vias)};
+				if (std::count_if(result.match.begin(), result.match.end(), [](int const Match) { return Match >= 0; }) * kStep >= 100.0 && false == looped(result, own))
 					return result;
 			}
 		}
@@ -372,7 +482,12 @@ std::optional<axis> build(std::string const &Line)
 		return std::nullopt;
 	auto *first{*start};
 	auto const first_mark{own[static_cast<std::size_t>(start - tracks.begin())]};
+	std::vector<std::size_t> passes;
+	for (std::size_t index = 0; index < g_vias.size(); ++index)
+		if (g_vias[index].line == Line)
+			passes.push_back(index);
 	auto route{editor_track::run_route(*first, kReach)};
+	through(route, passes);
 	if (route.spans.empty())
 		return std::nullopt;
 	// the marks the main paths of the switches lead away from: the line goes their way
@@ -393,7 +508,10 @@ std::optional<axis> build(std::string const &Line)
 	for (std::size_t round = 0; round <= own.size(); ++round)
 	{
 		samples = editor_track::sample_route(route, kStep);
-		pairs = pair_up(samples, route, origin_of(samples));
+		// the track beside goes along the vias the line doesn't
+		std::vector<std::size_t> beside;
+		std::copy_if(passes.begin(), passes.end(), std::back_inserter(beside), [&](std::size_t const Via) { return false == runs_by(route, Via); });
+		pairs = pair_up(samples, route, origin_of(samples), beside);
 		std::size_t away{own.size()};
 		for (std::size_t k = 0; k < own.size() && away == own.size(); ++k)
 			if (tracks[k] != nullptr && tried.count(k) == 0 && plan_gap(samples, g_marks[own[k]].point) > kOnAxis && plan_gap(pairs.partner, g_marks[own[k]].point) > kOnAxis)
@@ -424,12 +542,22 @@ std::optional<axis> build(std::string const &Line)
 			spans.insert(spans.end(), route.spans.begin() + at + 1, route.spans.end());
 		}
 		route.spans = once(spans);
+		through(route, passes);
 	}
 	if (samples.size() < 2)
 		return std::nullopt;
 	axis result;
 	result.line = Line;
 	compose(result, samples, pairs);
+	for (auto const &entry : route.spans)
+		result.paths.emplace_back(entry.track, entry.path);
+	auto const paired{std::any_of(pairs.match.begin(), pairs.match.end(), [](int const Match) { return Match >= 0; })};
+	if (paired)
+		for (auto const &entry : pairs.route.spans)
+			result.paths.emplace_back(entry.track, entry.path);
+	for (auto const index : passes)
+		if (false == runs_by(route, index) && (false == paired || false == runs_by(pairs.route, index)))
+			result.blocked.push_back(index);
 	for (auto const index : own)
 	{
 		axis::anchor anchor;
@@ -462,7 +590,8 @@ std::optional<axis> build(std::string const &Line)
 void reset()
 {
 	g_marks.clear();
-	g_base.clear();
+	g_vias.clear();
+	g_base = {};
 	drop_axes();
 	g_changed = false;
 	g_loaded = false;
@@ -474,6 +603,7 @@ void load()
 		return;
 	g_loaded = true;
 	g_marks.clear();
+	g_vias.clear();
 	drop_axes();
 	for (auto const layer : scene::Layers.marked_layers(kMark))
 	{
@@ -487,6 +617,18 @@ void load()
 			glm::dvec3 point{0.0};
 			glm::dvec2 way{0.0, 1.0};
 			line >> keyword;
+			if (keyword == "via")
+			{
+				via entry;
+				entry.layer = layer;
+				glm::dvec3 point{0.0};
+				line >> entry.line >> point.x >> point.y >> point.z;
+				if (line.fail() || entry.line.empty())
+					continue;
+				entry.point = context.to_world(point);
+				g_vias.push_back(std::move(entry));
+				continue;
+			}
 			if (keyword != "mark")
 				continue;
 			line >> entry.line >> point.x >> point.y >> point.z >> keyword >> way.x >> way.y >> keyword >> entry.km;
@@ -505,10 +647,10 @@ void load()
 			g_marks.push_back(std::move(entry));
 		}
 	}
-	g_base = g_marks;
+	g_base = current();
 	g_changed = false;
 	if (false == g_marks.empty())
-		WriteLog("Editor: " + std::to_string(g_marks.size()) + " kilometrage mark(s) read from the scenery", logtype::generic);
+		WriteLog("Editor: " + std::to_string(g_marks.size()) + " kilometrage mark(s) and " + std::to_string(g_vias.size()) + " via(s) read from the scenery", logtype::generic);
 }

 std::vector<mark> const &marks()
@@ -517,6 +659,17 @@ std::vector<mark> const &marks()
 	return g_marks;
 }

+std::vector<via> const &vias()
+{
+	load();
+	return g_vias;
+}
+
+state current()
+{
+	return {g_marks, g_vias};
+}
+
 void put(mark Entry)
 {
 	load();
@@ -549,29 +702,56 @@ void remove(std::size_t const Index)
 	changed({layer});
 }

-std::optional<std::vector<mark>> take_changes()
+void put(via Entry)
+{
+	load();
+	int path{0};
+	auto *track{track_near(Entry.point, kNear, path)};
+	Entry.layer = track != nullptr ? alignment_store::layer_of(*track) : scene::Layers.active();
+	if (false == scene::Layers.valid(Entry.layer))
+		Entry.layer = 1;
+	auto const layer{Entry.layer};
+	g_vias.push_back(std::move(Entry));
+	changed({layer});
+}
+
+void remove_via(std::size_t const Index)
+{
+	load();
+	if (Index >= g_vias.size())
+		return;
+	auto const layer{g_vias[Index].layer};
+	g_vias.erase(g_vias.begin() + static_cast<std::ptrdiff_t>(Index));
+	changed({layer});
+}
+
+std::optional<state> take_changes()
 {
 	if (false == g_changed)
 		return std::nullopt;
 	auto before{std::move(g_base)};
-	g_base = g_marks;
+	g_base = current();
 	g_changed = false;
 	return before;
 }

 void settle()
 {
-	g_base = g_marks;
+	g_base = current();
 	g_changed = false;
 }

-void restore(std::vector<mark> Marks)
+void restore(state State)
 {
 	std::set<scene::layer_handle> layers;
-	for (auto const *list : {&g_marks, &Marks})
+	for (auto const *list : {&g_marks, &State.marks})
 		for (auto const &entry : *list)
 			layers.insert(entry.layer);
-	g_marks = std::move(Marks);
+	for (auto const *list : {&g_vias, &State.vias})
+		for (auto const &entry : *list)
+			layers.insert(entry.layer);
+	g_marks = std::move(State.marks);
+	g_vias = std::move(State.vias);
 	changed(layers);
 	settle();
 }
@@ -769,6 +949,60 @@ TTrack *track_near(glm::dvec3 const &Point, double const Reach)
 	return best;
 }

+int path_near(TTrack const &Track, glm::dvec3 const &Point, glm::dvec3 &On)
+{
+	int result{0};
+	auto nearest{std::numeric_limits<double>::max()};
+	On = Point;
+	for (int path = 0; path < static_cast<int>(Track.m_paths.size()); ++path)
+	{
+		geometry::bezier const curve{Track.m_paths[path]};
+		auto previous{curve.point(0.0)};
+		for (int i = 1; i <= 64; ++i)
+		{
+			auto const next{curve.point(i / 64.0)};
+			auto const ab{plan_of(next - previous)};
+			auto const length2{glm::dot(ab, ab)};
+			auto const t{length2 > 1e-12 ? std::clamp(glm::dot(plan_of(Point - previous), ab) / length2, 0.0, 1.0) : 0.0};
+			auto const at{glm::mix(previous, next, t)};
+			// where the paths of a switch run together, the first one
+			if (auto const distance{plan_distance(at, Point)}; distance < nearest - 1e-3)
+			{
+				nearest = distance;
+				result = path;
+				On = at;
+			}
+			previous = next;
+		}
+	}
+	return result;
+}
+
+TTrack *track_near(glm::dvec3 const &Point, double const Reach, int &Path)
+{
+	TTrack *best{nullptr};
+	auto nearest{Reach};
+	Path = 0;
+	for (auto *track : simulation::Paths.sequence())
+	{
+		if (track == nullptr || track->m_editorremoved || (track->iCategoryFlag & 1) == 0 || false == editor_track::is_supported(*track) || track->m_paths.empty())
+			continue;
+		auto const &ends{track->m_paths.front().points};
+		auto const chord{plan_distance(ends[segment_data::point::start], ends[segment_data::point::end])};
+		if (std::min(plan_distance(ends[segment_data::point::start], Point), plan_distance(ends[segment_data::point::end], Point)) > chord * 0.8 + nearest + 1.0)
+			continue;
+		glm::dvec3 on{0.0};
+		auto const path{path_near(*track, Point, on)};
+		if (auto const distance{plan_distance(on, Point)}; distance < nearest)
+		{
+			nearest = distance;
+			best = track;
+			Path = path;
+		}
+	}
+	return best;
+}
+
 std::string text(double const Km)
 {
 	auto result{format("%.3f", Km)};
--- a/editor/editorKilometrage.hpp
+++ b/editor/editorKilometrage.hpp
@@ -9,9 +9,11 @@ http://mozilla.org/MPL/2.0/.

 #pragma once

+#include <algorithm>
 #include <cstddef>
 #include <optional>
 #include <string>
+#include <utility>
 #include <vector>
 #include <glm/glm.hpp>

@@ -22,7 +24,8 @@ class TTrack;
 // the kilometrage of the railway lines, set in the track editor and kept in the scenery files as "//$k" comment lines: the
 // points of a line where its km is known, from a post or a document, and the points where it jumps, with the km on both
 // sides. the km run along the axis of a single-track line and between the tracks of a double-track one, along the longer track
-// where the tracks part on formations of their own (PKP GK-1 6.1.12), the other tracks get the km straight across from them
+// where the tracks part on formations of their own (PKP GK-1 6.1.12), the other tracks get the km straight across from them.
+// through a station the line runs along the straight paths of the switches, unless the tracks it runs along there are set
 namespace kilometrage
 {

@@ -35,20 +38,38 @@ struct mark
 	double km{0.0}; // the km the point is reached at, coming along the rising km
 	std::optional<double> beyond; // of a jump: the km on from the point
 };
+// a track a line runs along through a station, other than the one the straight paths of the switches lead it along: from it
+// the line goes on along the straight paths until it meets the rest of it again, or on and away where it doesn't
+struct via
+{
+	scene::layer_handle layer{null_handle};
+	std::string line;
+	glm::dvec3 point{0.0}; // on the axis of the track, of the path of a switch the line takes
+};
+// all of the kilometrage set, for the undo history
+struct state
+{
+	std::vector<mark> marks;
+	std::vector<via> vias;
+};

 void reset();
 void load();
 std::vector<mark> const &marks();
+std::vector<via> const &vias();
+state current();
 // a new mark, kept in the file of the layer of the track nearest to it
 void put(mark Entry);
 void change(std::size_t const Index, mark Entry);
 void remove(std::size_t const Index);
-// the marks as they were before the changes made since the last call, if there were any; the current ones become the base
-std::optional<std::vector<mark>> take_changes();
-// the current marks become the base, the changes made so far aren't a part of the undo history
+void put(via Entry);
+void remove_via(std::size_t const Index);
+// the kilometrage as it was before the changes made since the last call, if there were any; the current one becomes the base
+std::optional<state> take_changes();
+// the current kilometrage becomes the base, the changes made so far aren't a part of the undo history
 void settle();
-// puts the marks back as they were, for undo and redo
-void restore(std::vector<mark> Marks);
+// puts the kilometrage back as it was, for undo and redo
+void restore(state State);
 // the axes found are dropped when the tracks change: Edits counts the changes of the tracks made in the editor
 void follow(std::size_t const Edits);
 // counts the times the axes were dropped: what is made from them is made again when it changes
@@ -86,6 +107,9 @@ struct axis
 	std::vector<side> sides;
 	std::vector<anchor> anchors; // by the chainage
 	std::vector<std::size_t> astray; // the marks of the line away from its axis
+	std::vector<std::size_t> blocked; // the vias of the line it doesn't run along: no track of theirs, or another via led it elsewhere
+	std::vector<std::pair<TTrack const *, int>> paths; // the paths of the tracks the line runs along, of the track beside too
+	bool runs_along(TTrack const *Track, int const Path) const { return std::find(paths.begin(), paths.end(), std::make_pair(Track, Path)) != paths.end(); }
 	double length() const { return chainage.empty() ? 0.0 : chainage.back(); }
 };
 // the numbers of the lines with marks
@@ -105,6 +129,10 @@ double km_on(axis const &Axis, axis::side const &Side, double const Along);
 bool km_at(std::string const &Line, glm::dvec3 const &Point, double &Km, double const Reach = 30.0);
 // the track nearest to the point in the plan within the reach, nullptr for none
 TTrack *track_near(glm::dvec3 const &Point, double const Reach);
+// the path of the track nearest to the point in the plan, On: the point of it nearest
+int path_near(TTrack const &Track, glm::dvec3 const &Point, glm::dvec3 &On);
+// the track with a path nearest to the point within the reach, nullptr for none, Path: the path
+TTrack *track_near(glm::dvec3 const &Point, double const Reach, int &Path);
 // "100,234", as PKP PLK write the km
 std::string text(double const Km);

--- a/editor/editorTrack.cpp
+++ b/editor/editorTrack.cpp
@@ -2188,7 +2188,7 @@ bool editor_track::find_route(TTrack *From, TTrack *To, route &Route, std::strin
 	return true;
 }

-editor_track::route editor_track::run_route(TTrack &Track, double const Maximum)
+editor_track::route editor_track::run_route(TTrack &Track, double const Maximum, int const Path)
 {
 	route result;
 	if (false == is_supported(Track))
@@ -2228,7 +2228,7 @@ editor_track::route editor_track::run_route(TTrack &Track, double const Maximum)
 		}
 		return nodes;
 	};
-	auto const own{main_of(Track)};
+	auto const own{Path >= 0 && Path < static_cast<int>(Track.m_paths.size()) ? Path : main_of(Track)};
 	auto const ahead{walk({&Track, own, true})};
 	auto const behind{walk({&Track, own, false})};
 	for (auto node = behind.rbegin(); node != behind.rend(); ++node)
--- a/editor/editorTrack.hpp
+++ b/editor/editorTrack.hpp
@@ -375,8 +375,9 @@ class editor_track
 		double length{0.0};
 	};
 	static bool find_route(TTrack *From, TTrack *To, route &Route, std::string &Error);
-	// continues both ways from the path, through switches along their path 0
-	static route run_route(TTrack &Track, double const Maximum);
+	// continues both ways from the path, through switches along their path 0; Path: the path of the track to start along, -1 for its
+	// main one
+	static route run_route(TTrack &Track, double const Maximum, int const Path = -1);
 	static route route_of(chain const &Chain);
 	// the speed most of the sampled route is laid for, by the length: a few tracks set faster or slower don't set the curves of
 	// all of it. 100 where none is set