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"