lsa-planer

LSA-Planer Professional – Planungssoftware für Lichtsignalanlagen nach RiLSA 2015 und § 45 StVO. EUPL-1.2.

/ tests domain massketten.test.ts

7,5 KB Rohdatei
tests/domain/massketten.test.ts — 212 Zeilen
1 import { describe, expect, it } from 'vitest';
2 import { massketten } from '@/domain/geometrie/masskette';
3 import { planblatt } from '@/domain/geometrie/planblatt';
4 import type { Lageplan } from '@/domain/geometrie/lageplan';
5
6 /*
7 * STUFE 2 DES SIGNALLAGEPLAN-ENTWURFS: DAS BLATT WIRD NACHMESSBAR, OHNE EINE
8 * ZWEITE RECHNUNG ZU BEKOMMEN.
9 *
10 * Das Lageplanblatt traegt seit 5.32.0 einen Massstabsbalken - wer eine Laenge
11 * wissen will, greift sie ab. Die Masskette nennt die Zahl stattdessen, und
12 * zwar DIESELBE, die das Programm kennt.
13 *
14 * DIE GEFAHR IST NICHT DIE FEHLENDE KETTE, SONDERN DIE FALSCHE. Eine Masszahl
15 * auf dem Blatt sieht aus wie ein Ergebnis; wer sie liest, misst nicht nach.
16 * Deshalb prueft diese Datei dreierlei: dass die Zahl aus der Vermessung
17 * stammt und nicht aus der Blattgeometrie, dass sie sich mit der Blattgroesse
18 * NICHT aendert, und dass die beiden Groessen, die das Programm bewusst
19 * offenlaesst, auch keine Kette bekommen.
20 */
21
22 /** 10 Bildpunkte je Meter - eine glatte Kalibrierung fuer nachrechenbare Zahlen. */
23 function lageplanMit(teile: Partial<Lageplan> = {}): Lageplan {
24 return {
25 bild: {
26 datenUrl: 'data:image/png;base64,AA',
27 breite: 1000,
28 hoehe: 1000,
29 herkunft: 'pruefstueck.png',
30 geladenAm: '2026-09-12T09:00:00.000Z',
31 },
32 kalibrierung: {
33 von: { x: 0, y: 0 },
34 bis: { x: 100, y: 0 },
35 laengeMeter: 10,
36 herkunft: 'gemessen',
37 },
38 haltlinien: [],
39 linien: [],
40 arbeitsbereiche: [],
41 signalgeber: [],
42 ...teile,
43 };
44 }
45
46 const HALTLINIE = {
47 id: 'h1',
48 name: 'H1',
49 art: 'zufahrt' as const,
50 armId: null,
51 von: { x: 100, y: 100 },
52 // 60 Bildpunkte bei 10 Bildpunkten je Meter sind 6,0 m.
53 bis: { x: 100, y: 160 },
54 };
55
56 const FAHRLINIE = {
57 id: 'l1',
58 name: 'A1',
59 mode: 'kfz' as const,
60 movement: 'geradeaus' as const,
61 breiteMeter: 3.25,
62 punkte: [
63 { x: 100, y: 130 },
64 { x: 400, y: 130 },
65 ],
66 haltlinieId: 'h1',
67 startT: 0.5,
68 signalGroupId: null,
69 };
70
71 const ARBEITSBEREICH = {
72 id: 'b1',
73 name: 'Arbeitsstelle',
74 breiteMeter: 4,
75 // 200 Bildpunkte sind 20,0 m.
76 punkte: [
77 { x: 200, y: 300 },
78 { x: 400, y: 300 },
79 ],
80 };
81
82 function ketten(lageplan: Lageplan, breite = 600, hoehe = 300) {
83 const blatt = planblatt(lageplan, breite, hoehe);
84 expect(blatt, 'kein Blatt').not.toBeNull();
85 return massketten(lageplan, blatt!);
86 }
87
88 describe('Massketten des Lageplanblatts', () => {
89 it('bemasst die Haltlinie NICHT', () => {
90 /*
91 * DIE BERICHTIGUNG VON 5.42.1, aus dem Betrieb gemeldet.
92 *
93 * Die Kette stand hier zuerst, mit der Begruendung, die Laenge sei
94 * eindeutig messbar. Eindeutig messbar heisst aber nicht gedeckt:
95 *
96 * - Eine Haltlinie quert die Fahrbahn; ihre Laenge liest sich als
97 * FAHRBAHNBREITE. Die Breite, die wirklich rechnet, steht anderswo -
98 * `SignalGroup.fahrstreifenbreite`, unterhalb von 3,00 m ueber den
99 * Faktor fb im Zeitbedarfswert. Zwei Zahlen fuer dasselbe, verschieden
100 * gebildet, und die gezeichnete sah nach Messung aus.
101 * - An einer Arbeitsstelle ist die verbleibende Fahrbahnbreite ein
102 * Anordnungskriterium. Wer "2,6 m" an einer Haltlinie liest, zieht
103 * daraus einen Schluss, den dieses Programm nicht decken kann.
104 * - Die Laenge kam im ganzen Programm sonst NICHT vor: keine Spalte, kein
105 * Fenster, keine Ansage. Der Bearbeiter zeichnete nach Augenmass und
106 * erfuhr die Zahl erst im Ausdruck.
107 *
108 * Sie steht seit 5.42.1 in der Haltlinientabelle und im Anlegefenster -
109 * als Auskunft beim Zeichnen, nicht als Zusicherung in einer Unterlage.
110 */
111 const gefunden = ketten(lageplanMit({ haltlinien: [HALTLINIE], linien: [FAHRLINIE] }));
112 expect(gefunden, 'die Haltlinie hat wieder eine Kette').toEqual([]);
113 });
114
115 it('schreibt Laenge und Breite des Arbeitsbereichs an', () => {
116 const gefunden = ketten(
117 lageplanMit({
118 haltlinien: [HALTLINIE],
119 linien: [FAHRLINIE],
120 arbeitsbereiche: [ARBEITSBEREICH],
121 }),
122 );
123 expect(gefunden.find((k) => k.art === 'bereich-laenge')?.meter).toBe(20);
124 expect(gefunden.find((k) => k.art === 'bereich-breite')?.meter).toBe(4);
125 });
126
127 it('nennt dieselbe Zahl, gleich wie gross das Blatt ist', () => {
128 /*
129 * DER KERN DER SACHE. Die Kette liegt in Blattkoordinaten, die Zahl kommt
130 * aus den Bildpunkten. Waere sie aus der Blattgeometrie gebildet, stuende
131 * auf einem kleineren Blatt eine kleinere Laenge - und die Zeichnung
132 * widerspraeche der Tabelle daneben.
133 */
134 const plan = lageplanMit({
135 haltlinien: [HALTLINIE],
136 linien: [FAHRLINIE],
137 arbeitsbereiche: [ARBEITSBEREICH],
138 });
139 const klein = ketten(plan, 300, 150).find((k) => k.art === 'bereich-laenge');
140 const gross = ketten(plan, 900, 450).find((k) => k.art === 'bereich-laenge');
141 expect(klein!.meter).toBe(gross!.meter);
142 // Die Zeichnung selbst faellt dagegen sehr wohl verschieden aus.
143 expect(klein!.punkte[0]).not.toEqual(gross!.punkte[0]);
144 });
145
146 it('bemasst weder den Abstand zweier Haltlinien noch den zum Arbeitsbereich', () => {
147 /*
148 * Beide Groessen gibt es, und beide bleiben ohne Kette:
149 *
150 * - Der Abstand zweier Haltlinien IST an der Engstelle die
151 * Engstellenlaenge, und die ist in diesem Programm der groesste
152 * erfasste Raeumweg. Zwei Wege zu derselben Zahl, und der Pruefer
153 * glaubte der gezeichneten.
154 * - Der Abstand zum Arbeitsbereich steht in der Tabelle, nennt aber
155 * bewusst nicht, zu WELCHEM Ende er misst (arbeitsbereich.ts). Eine
156 * Kette zeigte auf eines und entschiede damit, was die Auskunft
157 * offenlaesst.
158 */
159 const zweite = {
160 ...HALTLINIE,
161 id: 'h2',
162 name: 'H2',
163 von: { x: 500, y: 100 },
164 bis: { x: 500, y: 160 },
165 };
166 const gefunden = ketten(
167 lageplanMit({
168 haltlinien: [HALTLINIE, zweite],
169 linien: [FAHRLINIE],
170 arbeitsbereiche: [ARBEITSBEREICH],
171 }),
172 );
173 const arten = gefunden.map((k) => k.art);
174 expect(arten).not.toContain('haltlinien-abstand');
175 expect(arten).not.toContain('bereich-abstand');
176 // 40,0 m waere der Abstand der beiden Haltlinien - er darf nirgends stehen.
177 expect(gefunden.map((k) => k.meter)).not.toContain(40);
178 });
179
180 it('setzt die Beschriftung auf halbe Zuglaenge und nicht zwischen die Enden', () => {
181 // Bei einem geknickten Band laege die Mitte zwischen Anfang und Ende
182 // NEBEN dem Band - die Zahl stuende dann auf der Fahrbahn.
183 const geknickt = {
184 ...ARBEITSBEREICH,
185 punkte: [
186 { x: 200, y: 300 },
187 { x: 300, y: 300 },
188 { x: 300, y: 400 },
189 ],
190 };
191 const kette = ketten(
192 lageplanMit({ haltlinien: [HALTLINIE], linien: [FAHRLINIE], arbeitsbereiche: [geknickt] }),
193 ).find((k) => k.art === 'bereich-laenge');
194 expect(kette!.meter).toBe(20);
195 const mittePunkt = kette!.beschriftung;
196 const zwischenEnden = {
197 x: (kette!.punkte[0]!.x + kette!.punkte[2]!.x) / 2,
198 y: (kette!.punkte[0]!.y + kette!.punkte[2]!.y) / 2,
199 };
200 expect(
201 Math.hypot(mittePunkt.x - zwischenEnden.x, mittePunkt.y - zwischenEnden.y),
202 ).toBeGreaterThan(1);
203 });
204
205 it('liefert ohne Kalibrierung keine einzige Kette', () => {
206 // Ohne Massstab gibt es keine Meter - und eine Kette ohne Zahl waere ein
207 // Strich, der so aussieht, als stuende etwas dran.
208 const ohne = lageplanMit({ haltlinien: [HALTLINIE], linien: [FAHRLINIE] });
209 const blatt = planblatt(ohne, 600, 300);
210 expect(massketten({ ...ohne, kalibrierung: null }, blatt!)).toEqual([]);
211 });
212 });