From f5895abfa814909240f587b09d48109a3d2b65ff Mon Sep 17 00:00:00 2001
From: maj00r <maj00r@host>
Date: Mon, 12 Oct 2026 03:24:23 +0200
Subject: [PATCH] feat(editor): tracks drawn without a design get digitized:
 the route design keeps the line it opens in the scenery when no design is
 kept for it, or says why it can't (straights meeting with no curve, the
 curves read leaving a path by how much), trying the other transition shape
 before giving up; Digitize all the tracks in the route design does it for
 every line of the scenery and reports the count; a kept design counts as
 departed only where no path lies along it any more, so a parallel track or a
 diverging one beside a digitized line no longer shows it as left by metres;
 self-test command digitizeall

---
 application/editormode.h           |   3 +-
 application/editormodeselftest.cpp |   7 ++
 application/editormodetrack.cpp    | 155 +++++++++++++++++++++++------
 editor/editorAlignmentStore.cpp    |  96 ++++++++++++++++--
 editor/editorAlignmentStore.hpp    |   1 +
 lang/editor_pl.po                  |  34 +++++--
 6 files changed, 250 insertions(+), 46 deletions(-)

diff --git a/application/editormode.h b/application/editormode.h
index 77df0691..9cd0c3af 100644
--- a/application/editormode.h
+++ b/application/editormode.h
@@ -836,7 +836,8 @@ class editor_mode : public application_mode, private editor_track::observer
 	void render_switch_record(TTrack const &Track) const;
 	void route_store();
 	bool digitize_drawn(std::vector<TTrack *> const &Created, bool const Alone = true);
-	bool digitize_chain(editor_track::chain const &Chain);
+	bool digitize_chain(editor_track::chain const &Chain, std::string *Reason = nullptr);
+	void digitize_all();
 	void render_route_stored();
 	void route_update()
 	{
diff --git a/application/editormodeselftest.cpp b/application/editormodeselftest.cpp
index 3f9dd817..1d07b753 100644
--- a/application/editormodeselftest.cpp
+++ b/application/editormodeselftest.cpp
@@ -1036,6 +1036,12 @@ editor_mode::selftest_result editor_mode::selftest_track(std::string const &comm
 		WriteLog("SELFTEST " + command + ": " + m_route.status + " " + m_route.error);
 		return selftest_result::handled;
 	}
+	if (command == "digitizeall")
+	{
+		digitize_all();
+		WriteLog(format("SELFTEST digitizeall: %zu alignments", alignment_store::records().size()));
+		return selftest_result::handled;
+	}
 	if (command == "alignments")
 	{
 		auto const &records{alignment_store::records()};
@@ -2471,6 +2477,7 @@ editor_mode::selftest_result editor_mode::selftest_terrain(std::string const &co
 //   routevertex <i> <R> <L in> <L out> <cant>, routearc <i> <R> <L> <share>, routeshare <i> <share>, routekm <km>
 //   routeapply, routetake                as the buttons of the route design do it
 //   alignments                           logs the alignments kept in the scenery and the element under each path
+//   digitizeall                          every line not digitized yet kept in the scenery, as the button of the route design does it
 //   splitkind <kind>, nudgekind <kind> <dx> <dz>   the first path over an element of the kind split in two, or moved
 //   switchplace <template> <x> <z> <direction> <side>   the catalogue template whose label starts so put into the straight
 //                                        nearest the point, or into the curve (switchcurve); slipplace <template> <x> <z>
diff --git a/application/editormodetrack.cpp b/application/editormodetrack.cpp
index df23b6a9..64970669 100644
--- a/application/editormodetrack.cpp
+++ b/application/editormodetrack.cpp
@@ -1661,9 +1661,22 @@ void editor_mode::route_read_stored()
 	route.origin = 0.0;
 	if (route.chain.tracks.empty())
 		return;
-	auto const &chain{route.chain};
+	auto const chain{route.chain};
 	bool reversed;
-	auto const index{alignment_store::find(chain.start, chain.end, reversed)};
+	auto index{alignment_store::find(chain.start, chain.end, reversed)};
+	route.departed = alignment_store::departed(chain.tracks, route.departure);
+	auto const loose{std::any_of(chain.tracks.begin(), chain.tracks.end(), [](TTrack const *Track) { return false == alignment_store::on_track(*Track).has_value(); })};
+	bool digitized{false};
+	std::string failure;
+	if (index < 0 && route.departed < 0 && loose && false == route.single)
+	{
+		if (digitize_chain(chain, &failure))
+		{
+			alignment_store::settle();
+			index = alignment_store::find(chain.start, chain.end, reversed);
+			digitized = true;
+		}
+	}
 	if (index >= 0 && false == reversed && false == route.single)
 	{
 		route_take_stored(index);
@@ -1675,8 +1688,13 @@ void editor_mode::route_read_stored()
 		if (further.has_value() && *further > *km)
 			route.origin = *km;
 	}
-	route.departed = alignment_store::departed(chain.tracks, route.departure);
-	if (route.designed > 0)
+	if (digitized && route.designed == 0)
+		route.status += STR_C("\nThe line is digitized now, a straight");
+	else if (digitized)
+		route.status += format(STR_C("\nThe line is digitized now, curves kept in the scenery: %d"), route.designed);
+	else if (false == failure.empty())
+		route.status += STR_C("\nThe line can't be digitized: ") + failure;
+	else if (route.designed > 0)
 		route.status += format(STR_C("\nCurves read from the design kept in the scenery: %d"), route.designed);
 	else if (false == route.design.vertices.empty())
 		route.status += STR_C("\nCurves recognized from the paths, the scenery keeps no design for them");
@@ -1712,19 +1730,12 @@ void editor_mode::render_route_stored()
 		route.origin = km * 1000.0;
 	ImGui::PopItemWidth();
 	item_tooltip("Chainage of the start of the fragment, kept with the design in the scenery; the vertical profile of these paths counts from it");
-	if (route.designed == 0 && route.departed < 0 && false == route.chain.tracks.empty())
+	if (ImGui::SmallButton(STR_C("Digitize all the tracks")))
 	{
-		if (ImGui::SmallButton(STR_C("Keep the line as it lies")))
-		{
-			auto *track{route.chain.tracks[route.chain.tracks.size() / 2]};
-			auto const kept{digitize_drawn({track}, false)};
-			alignment_store::settle();
-			route_load(*track);
-			route.status += std::string{"\n"} + (kept ? STR_C("The line is kept in the scenery with its straights, arcs and transition curves") : STR_C("The paths don't make a line of straights, arcs and transition curves, nothing kept"));
-			return;
-		}
-		item_tooltip("Keeps the line through the selected path in the scenery as its paths lie, the way the drawn tracks are kept");
+		digitize_all();
+		return;
 	}
+	item_tooltip("Every line of the scenery not digitized yet is kept in it with its straights, arcs and transition curves, the way the drawn tracks are kept; the paths stay as they are");
 	auto const &records{alignment_store::records()};
 	if (route.departed < 0 || route.departed >= static_cast<int>(records.size()))
 		return;
@@ -1775,13 +1786,69 @@ bool editor_mode::digitize_drawn(std::vector<TTrack *> const &Created, bool cons
 	return false;
 }
 
-bool editor_mode::digitize_chain(editor_track::chain const &Chain)
+void editor_mode::digitize_all()
+{
+	std::set<TTrack const *> visited;
+	int kept{0};
+	int failed{0};
+	std::string first;
+	for (auto *track : simulation::Paths.sequence())
+	{
+		if (track == nullptr || track->m_editorremoved || track->eType != tt_Normal || track->m_paths.empty() || false == editor_track::is_supported(*track) || visited.count(track) > 0)
+			continue;
+		if (alignment_store::on_track(*track).has_value())
+			continue;
+		editor_track::chain chain;
+		std::string error;
+		if (false == editor_track::find_run(*track, kDrawnReach, chain, error) || chain.tracks.empty())
+		{
+			visited.insert(track);
+			continue;
+		}
+		visited.insert(chain.tracks.begin(), chain.tracks.end());
+		std::string reason;
+		if (digitize_chain(chain, &reason))
+		{
+			++kept;
+			continue;
+		}
+		++failed;
+		if (false == reason.empty())
+		{
+			WriteLog("Editor: digitizing - " + reason, logtype::generic);
+			if (first.empty())
+				first = reason;
+		}
+	}
+	alignment_store::settle();
+	auto text{format(STR_C("Lines digitized: %d, not digitized: %d"), kept, failed)};
+	if (false == first.empty())
+		text += STR_C(", the first: ") + first;
+	WriteLog("Editor: " + text, logtype::generic);
+	ui()->set_status(text, failed > 0);
+	if (false == m_route.chain.tracks.empty())
+		route_load(*m_route.chain.tracks[m_route.chain.tracks.size() / 2]);
+}
+
+bool editor_mode::digitize_chain(editor_track::chain const &Chain, std::string *Reason)
 {
 	if (Chain.tracks.empty())
 		return false;
+	auto const name = [](TTrack const *Track) { return Track == nullptr || Track->name().empty() ? std::string{"(noname)"} : Track->name(); };
+	auto const nearest = [&](glm::dvec2 const &Point) {
+		TTrack *found{nullptr};
+		double distance{std::numeric_limits<double>::max()};
+		for (auto *track : Chain.tracks)
+			for (auto const end : {segment_data::point::start, segment_data::point::end})
+				if (auto const d{glm::distance(plan_of(track->m_paths.front().points[end]), Point)}; d < distance)
+				{
+					distance = d;
+					found = track;
+				}
+		return found;
+	};
 	alignment::design design;
 	design.norms = m_route.design.norms;
-	design.shape = m_route.design.shape;
 	design.transition_pieces = m_route.design.transition_pieces;
 	design.arc_piece_angle = m_route.design.arc_piece_angle;
 	design.speed = Chain.velocity > 0.0 ? Chain.velocity : 100.0;
@@ -1795,22 +1862,52 @@ bool editor_mode::digitize_chain(editor_track::chain const &Chain)
 	design.end_grade = grade_of(Chain.end_direction);
 	design.start_radius = Chain.start_radius;
 	design.end_radius = Chain.end_radius;
-	for (auto const &entry : editor_track::recognize_line(Chain, m_straights.tolerance, design.norms.gauge, design.shape))
+	auto const preferred{m_route.design.shape};
+	auto const other{preferred == alignment::transition_shape::clothoid ? alignment::transition_shape::cubic_parabola : alignment::transition_shape::clothoid};
+	alignment::result result;
+	double closest{std::numeric_limits<double>::max()};
+	TTrack *farthest{nullptr};
+	bool fits{false};
+	for (auto const shape : {preferred, other})
 	{
-		if (entry.kink)
-			return false;
-		auto vertex{route_vertex_of(entry.shape)};
-		vertex.position = entry.position;
-		design.vertices.push_back(vertex);
+		design.shape = shape;
+		design.vertices.clear();
+		for (auto const &entry : editor_track::recognize_line(Chain, m_straights.tolerance, design.norms.gauge, shape))
+		{
+			if (entry.kink)
+			{
+				if (Reason != nullptr)
+					*Reason = format(STR_C("the straights meet with no curve at path %s"), name(nearest(entry.position)).c_str());
+				return false;
+			}
+			auto vertex{route_vertex_of(entry.shape)};
+			vertex.position = entry.position;
+			design.vertices.push_back(vertex);
+		}
+		if (design.vertices.size() >= 2)
+		{
+			design.vertices.front().offset = std::max(0.0, glm::dot(design.vertices.front().position - plan_of(design.start), design.start_direction));
+			design.vertices.back().offset = std::max(0.0, glm::dot(plan_of(design.end) - design.vertices.back().position, design.end_direction));
+		}
+		result = alignment::compute(design);
+		if (alignment_store::follows(result, Chain.tracks))
+		{
+			fits = true;
+			break;
+		}
+		TTrack *worst{nullptr};
+		if (auto const away{alignment_store::deviation(result, Chain.tracks, worst)}; away < closest)
+		{
+			closest = away;
+			farthest = worst;
+		}
 	}
-	if (design.vertices.size() >= 2)
+	if (false == fits)
 	{
-		design.vertices.front().offset = std::max(0.0, glm::dot(design.vertices.front().position - plan_of(design.start), design.start_direction));
-		design.vertices.back().offset = std::max(0.0, glm::dot(plan_of(design.end) - design.vertices.back().position, design.end_direction));
-	}
-	auto const result{alignment::compute(design)};
-	if (false == alignment_store::follows(result, Chain.tracks))
+		if (Reason != nullptr)
+			*Reason = closest < 1000.0 ? format(STR_C("the curves read from the paths leave path %s by %.2f m"), name(farthest).c_str(), closest) : std::string{STR_C("the paths don't make a line of straights, arcs and transition curves")};
 		return false;
+	}
 	auto const &records{alignment_store::records()};
 	std::set<int> covered;
 	for (auto *track : Chain.tracks)
diff --git a/editor/editorAlignmentStore.cpp b/editor/editorAlignmentStore.cpp
index 572e1459..c07b41ea 100644
--- a/editor/editorAlignmentStore.cpp
+++ b/editor/editorAlignmentStore.cpp
@@ -13,11 +13,13 @@ http://mozilla.org/MPL/2.0/.
 #include "editor/editorGeometry.hpp"
 
 #include "world/Track.h"
+#include "simulation/simulation.h"
 #include "utilities/Logs.h"
 
 #include <algorithm>
 #include <cmath>
 #include <limits>
+#include <map>
 #include <set>
 #include <sstream>
 
@@ -475,11 +477,9 @@ std::optional<hit> project(std::size_t const Index, glm::dvec2 const &Point, dou
 	return project(g_records[Index], Index, Point, Reach);
 }
 
-bool lies_along(record const &Entry, TTrack const &Track)
+bool lies_along(record const &Entry, segment_data const &Path)
 {
-	if (Track.m_paths.empty())
-		return false;
-	geometry::bezier const curve{Track.m_paths.front()};
+	geometry::bezier const curve{Path};
 	auto const reach{tolerance + approximation(curve)};
 	for (auto const t : {0.0, 0.25, 0.5, 0.75, 1.0})
 		if (false == project(Entry, 0, plan_of(curve.point(t)), t == 0.25 || t == 0.75 ? reach : tolerance).has_value())
@@ -487,6 +487,47 @@ bool lies_along(record const &Entry, TTrack const &Track)
 	return true;
 }
 
+bool lies_along(record const &Entry, TTrack const &Track)
+{
+	return false == Track.m_paths.empty() && lies_along(Entry, Track.m_paths.front());
+}
+
+std::vector<std::pair<double, double>> bare(std::size_t const Index)
+{
+	auto const &entry{g_records[Index]};
+	auto const margin{tolerance + kStep};
+	auto const inside = [&](glm::dvec2 const &Point) { return Point.x >= entry.low.x - margin && Point.y >= entry.low.y - margin && Point.x <= entry.high.x + margin && Point.y <= entry.high.y + margin; };
+	std::vector<std::pair<double, double>> covered;
+	for (auto *track : simulation::Paths.sequence())
+	{
+		if (track == nullptr || track->m_editorremoved)
+			continue;
+		for (auto const &path : track->m_paths)
+		{
+			auto const start{plan_of(path.points[segment_data::point::start])};
+			auto const end{plan_of(path.points[segment_data::point::end])};
+			if (false == inside(start) || false == inside(end) || false == lies_along(entry, path))
+				continue;
+			auto const from{project(entry, Index, start, tolerance)};
+			auto const to{project(entry, Index, end, tolerance)};
+			if (from.has_value() && to.has_value())
+				covered.emplace_back(std::min(from->chainage, to->chainage), std::max(from->chainage, to->chainage));
+		}
+	}
+	std::sort(covered.begin(), covered.end());
+	std::vector<std::pair<double, double>> gaps;
+	double reached{0.0};
+	for (auto const &[from, to] : covered)
+	{
+		if (from - reached > 0.5)
+			gaps.emplace_back(reached, from);
+		reached = std::max(reached, to);
+	}
+	if (entry.result.length - reached > 0.5)
+		gaps.emplace_back(reached, entry.result.length);
+	return gaps;
+}
+
 record temporary(alignment::result const &Result)
 {
 	record entry;
@@ -608,24 +649,63 @@ int departed(std::vector<TTrack *> const &Tracks, double &Departure)
 	Departure = 0.0;
 	double const reach{5.0};
 	int result{-1};
+	std::map<std::size_t, std::vector<std::pair<double, double>>> gaps;
 	for (auto *track : Tracks)
 	{
 		if (track == nullptr || track->m_paths.empty() || on_track(*track).has_value())
 			continue;
 		geometry::bezier const curve{track->m_paths.front()};
 		for (auto const t : {0.0, 0.25, 0.5, 0.75, 1.0})
-		{
-			auto const found{at(curve.point(t), reach)};
-			if (found.has_value() && found->offset > tolerance && found->offset > Departure)
+			for (std::size_t r = 0; r < g_records.size(); ++r)
 			{
+				auto const found{project(r, plan_of(curve.point(t)), reach)};
+				if (false == found.has_value() || found->offset <= tolerance || found->offset <= Departure)
+					continue;
+				auto known{gaps.find(r)};
+				if (known == gaps.end())
+					known = gaps.emplace(r, bare(r)).first;
+				if (std::none_of(known->second.begin(), known->second.end(), [&](auto const &Gap) { return found->chainage >= Gap.first - tolerance && found->chainage <= Gap.second + tolerance; }))
+					continue;
 				Departure = found->offset;
 				result = found->record;
 			}
-		}
 	}
 	return result;
 }
 
+double deviation(alignment::result const &Result, std::vector<TTrack *> const &Tracks, TTrack *&Worst)
+{
+	Worst = nullptr;
+	if (false == Result.valid || Result.elements.empty())
+		return std::numeric_limits<double>::max();
+	auto const entry{temporary(Result)};
+	double largest{0.0};
+	for (auto *track : Tracks)
+	{
+		if (track == nullptr || track->m_paths.empty())
+			continue;
+		geometry::bezier const curve{track->m_paths.front()};
+		auto const allowance{approximation(curve)};
+		for (auto const t : {0.0, 0.25, 0.5, 0.75, 1.0})
+		{
+			auto const point{plan_of(curve.point(t))};
+			auto const found{project(entry, 0, point, 1000.0)};
+			auto offset{found.has_value() ? found->offset : std::numeric_limits<double>::max()};
+			if (false == found.has_value())
+				for (auto const &sample : entry.samples)
+					offset = std::min(offset, glm::distance(sample, point));
+			if (t == 0.25 || t == 0.75)
+				offset = std::max(0.0, offset - allowance);
+			if (offset > largest)
+			{
+				largest = offset;
+				Worst = track;
+			}
+		}
+	}
+	return largest;
+}
+
 bool follows(alignment::result const &Result, std::vector<TTrack *> const &Tracks)
 {
 	if (false == Result.valid || Result.elements.empty())
diff --git a/editor/editorAlignmentStore.hpp b/editor/editorAlignmentStore.hpp
index 4620a06e..b5f0b79c 100644
--- a/editor/editorAlignmentStore.hpp
+++ b/editor/editorAlignmentStore.hpp
@@ -86,6 +86,7 @@ int departed(std::vector<TTrack *> const &Tracks, double &Departure);
 // keeps the design in the file of the layer, in place of the one with the same ends
 int store(alignment::design const &Design, alignment::result const &Result, double const Origin, scene::layer_handle const Layer, std::string const &Source = "designed");
 bool follows(alignment::result const &Result, std::vector<TTrack *> const &Tracks);
+double deviation(alignment::result const &Result, std::vector<TTrack *> const &Tracks, TTrack *&Worst);
 std::optional<double> chainage_on(alignment::result const &Result, glm::dvec3 const &Point);
 void forget(int const Index);
 // the point on the line of the stored alignment, if it lies by it within the reach
diff --git a/lang/editor_pl.po b/lang/editor_pl.po
index ed3cbf36..47e2083c 100644
--- a/lang/editor_pl.po
+++ b/lang/editor_pl.po
@@ -5179,17 +5179,35 @@ msgstr "Zapisany projekt zostanie usunięty z "
 msgid "The paths stay as they are, the scenery no longer keeps a design for them"
 msgstr "Tory zostają bez zmian, sceneria przestaje przechowywać dla nich projekt"
 
-msgid "Keep the line as it lies"
-msgstr "Zachowaj linię tak, jak leży"
+msgid "Digitize all the tracks"
+msgstr "Zdigitalizuj wszystkie tory"
 
-msgid "Keeps the line through the selected path in the scenery as its paths lie, the way the drawn tracks are kept"
-msgstr "Zapisuje w scenerii linię przez wybrany tor tak, jak leżą jej tory, tak jak zapisywane są rysowane tory"
+msgid "Every line of the scenery not digitized yet is kept in it with its straights, arcs and transition curves, the way the drawn tracks are kept; the paths stay as they are"
+msgstr "Każda jeszcze niezdigitalizowana linia scenerii zostaje w niej zapisana z prostymi, łukami i krzywymi przejściowymi, tak jak rysowane tory; tory zostają tak, jak leżą"
 
-msgid "The line is kept in the scenery with its straights, arcs and transition curves"
-msgstr "Linia jest zapisana w scenerii z prostymi, łukami i krzywymi przejściowymi"
+msgid "Lines digitized: %d, not digitized: %d"
+msgstr "Zdigitalizowane linie: %d, niezdigitalizowane: %d"
 
-msgid "The paths don't make a line of straights, arcs and transition curves, nothing kept"
-msgstr "Tory nie tworzą linii z prostych, łuków i krzywych przejściowych, nic nie zapisano"
+msgid ", the first: "
+msgstr ", pierwsza: "
+
+msgid "\nThe line is digitized now, a straight"
+msgstr "\nLinia zdigitalizowana: prosta"
+
+msgid "\nThe line is digitized now, curves kept in the scenery: %d"
+msgstr "\nLinia zdigitalizowana, łuki zapisane w scenerii: %d"
+
+msgid "\nThe line can't be digitized: "
+msgstr "\nNie da się zdigitalizować linii: "
+
+msgid "the straights meet with no curve at path %s"
+msgstr "proste schodzą się bez łuku przy torze %s"
+
+msgid "the curves read from the paths leave path %s by %.2f m"
+msgstr "łuki odczytane z torów odchodzą od toru %s o %.2f m"
+
+msgid "the paths don't make a line of straights, arcs and transition curves"
+msgstr "tory nie tworzą linii z prostych, łuków i krzywych przejściowych"
 
 msgid "The scenery keeps no type for this switch, it's read from its shape"
 msgstr "Sceneria nie przechowuje typu tego rozjazdu, jest odczytywany z jego kształtu"