lsa-planer

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

/ tests domain vermessung.test.ts

7,9 KB Rohdatei
tests/domain/vermessung.test.ts — 243 Zeilen
1 import { describe, expect, it } from 'vitest';
2 import {
3 REGELBREITE,
4 konfliktbereich,
5 kreuzenSich,
6 laenge,
7 linieInMeter,
8 massstabAusStrecke,
9 schneide,
10 vermesseWege,
11 type Fahrlinie,
12 } from '@/domain/geometrie/vermessung';
13 import { computeIntergreen } from '@/domain/rilsa/intergreen';
14
15 /** Waagerechte Fahrlinie nach Osten, Haltlinie bei x = start. */
16 function waagerecht(
17 id: string,
18 startX: number,
19 y: number,
20 laengeM: number,
21 breite: number,
22 ): Fahrlinie {
23 return {
24 id,
25 punkte: [
26 { x: startX, y },
27 { x: startX + laengeM, y },
28 ],
29 breite,
30 };
31 }
32
33 /** Senkrechte Fahrlinie nach Norden, Haltlinie bei y = start. */
34 function senkrecht(
35 id: string,
36 x: number,
37 startY: number,
38 laengeM: number,
39 breite: number,
40 ): Fahrlinie {
41 return {
42 id,
43 punkte: [
44 { x, y: startY },
45 { x, y: startY + laengeM },
46 ],
47 breite,
48 };
49 }
50
51 describe('Vermessung aus der Zeichnung', () => {
52 it('misst die Laenge eines Linienzugs', () => {
53 const linie: Fahrlinie = {
54 id: 'a',
55 punkte: [
56 { x: 0, y: 0 },
57 { x: 3, y: 4 },
58 { x: 3, y: 14 },
59 ],
60 breite: 3.25,
61 };
62 expect(laenge(linie)).toBeCloseTo(15, 6);
63 });
64
65 it('findet den Schnittpunkt zweier kreuzender Fahrlinien', () => {
66 // A laeuft von (0,0) nach Osten, B von (20,-10) nach Norden.
67 const a = waagerecht('a', 0, 0, 40, REGELBREITE.kfz);
68 const b = senkrecht('b', 20, -10, 40, REGELBREITE.kfz);
69
70 const schnitte = schneide(a, b);
71 expect(schnitte).toHaveLength(1);
72 expect(schnitte[0]!.punkt.x).toBeCloseTo(20, 6);
73 expect(schnitte[0]!.punkt.y).toBeCloseTo(0, 6);
74 expect(schnitte[0]!.abstandA).toBeCloseTo(20, 6);
75 expect(schnitte[0]!.abstandB).toBeCloseTo(10, 6);
76 // Rechter Winkel.
77 expect((schnitte[0]!.winkel * 180) / Math.PI).toBeCloseTo(90, 6);
78 });
79
80 it('erkennt parallele Stroeme als vertraeglich', () => {
81 const a = waagerecht('a', 0, 0, 40, REGELBREITE.kfz);
82 const b = waagerecht('b', 0, 4, 40, REGELBREITE.kfz);
83 expect(kreuzenSich(a, b)).toBe(false);
84 expect(vermesseWege(a, b)).toBeNull();
85 });
86
87 it('leitet Raeum- und Einfahrweg aus der Geometrie ab', () => {
88 const a = waagerecht('a', 0, 0, 40, REGELBREITE.kfz);
89 const b = senkrecht('b', 20, -10, 40, REGELBREITE.kfz);
90
91 const wege = vermesseWege(a, b)!;
92 expect(wege).not.toBeNull();
93
94 // Rechtwinkliger Schnitt: Der Konfliktbereich reicht um die halbe Breite
95 // des jeweils anderen Stroms ueber den Schnittpunkt hinaus.
96 // Raeumweg = 20 m + 3,25/2 = 21,625 -> 21,63
97 // Einfahrweg = 10 m − 3,25/2 = 8,375 -> 8,38
98 expect(wege.raeumweg).toBeCloseTo(21.63, 2);
99 expect(wege.einfahrweg).toBeCloseTo(8.38, 2);
100 expect(wege.winkelGrad).toBeCloseTo(90, 1);
101 });
102
103 it('verlaengert den Konfliktbereich bei schraegem Schnitt', () => {
104 // B kreuzt unter 45 Grad: Der Strom ist laenger im Konfliktbereich,
105 // der Raeumweg wird entsprechend groesser.
106 const a = waagerecht('a', 0, 0, 40, REGELBREITE.kfz);
107 const schraeg: Fahrlinie = {
108 id: 'b',
109 punkte: [
110 { x: 10, y: -10 },
111 { x: 30, y: 10 },
112 ],
113 breite: REGELBREITE.kfz,
114 };
115
116 const rechtwinklig = vermesseWege(a, senkrecht('b', 20, -10, 40, REGELBREITE.kfz))!;
117 const unter45 = vermesseWege(a, schraeg)!;
118
119 expect(unter45.winkelGrad).toBeCloseTo(45, 1);
120 // 1 / sin(45 Grad) = 1,414
121 const erwartet = 20 + REGELBREITE.kfz / 2 / Math.sin(Math.PI / 4);
122 expect(unter45.raeumweg).toBeCloseTo(erwartet, 2);
123 expect(unter45.raeumweg).toBeGreaterThan(rechtwinklig.raeumweg);
124 });
125
126 it('beruecksichtigt die Breite der Fussgaengerfurt', () => {
127 const kfz = waagerecht('k', 0, 0, 40, REGELBREITE.kfz);
128 const furt = senkrecht('f', 20, -10, 20, REGELBREITE.fuss);
129
130 const wege = vermesseWege(kfz, furt)!;
131 // Die Furt ist 4 m breit: Das Kfz durchfaehrt sie ueber 4 m.
132 expect(wege.raeumweg).toBeCloseTo(20 + REGELBREITE.fuss / 2, 2);
133 // Der Fussgaenger erreicht den Kfz-Korridor nach 10 − 3,25/2 = 8,375 m.
134 // Ausgegeben wird auf Zentimeter gerundet - feiner laesst sich ein
135 // Lageplan ohnehin nicht abgreifen.
136 expect(wege.einfahrweg).toBe(8.38);
137 });
138
139 it('bildet bei mehrfacher Kreuzung die Huellkurve', () => {
140 // Ein Abbieger, der dieselbe Furt zweimal schneidet.
141 const zickzack: Fahrlinie = {
142 id: 'a',
143 punkte: [
144 { x: 0, y: -5 },
145 { x: 20, y: 5 },
146 { x: 40, y: -5 },
147 ],
148 breite: REGELBREITE.kfz,
149 };
150 const furt = waagerecht('f', -10, 0, 60, REGELBREITE.fuss);
151
152 const bereich = konfliktbereich(zickzack, furt)!;
153 expect(bereich.schnitte).toBe(2);
154 // Der Bereich reicht vom ersten Eintritt bis zum letzten Austritt.
155 expect(bereich.bisA - bereich.vonA).toBeGreaterThan(20);
156 });
157
158 it('gibt fuer die Gegenrichtung andere Wege aus', () => {
159 // Konflikte sind gerichtet - das muss sich in den Wegen niederschlagen.
160 const a = waagerecht('a', 0, 0, 40, REGELBREITE.kfz);
161 const b = senkrecht('b', 25, -8, 40, REGELBREITE.kfz);
162
163 const hin = vermesseWege(a, b)!;
164 const zurueck = vermesseWege(b, a)!;
165
166 expect(hin.raeumweg).not.toBeCloseTo(zurueck.raeumweg, 1);
167 // 25 + 1,625 = 26,625 bzw. 8 + 1,625 = 9,625, jeweils auf Zentimeter gerundet.
168 expect(hin.raeumweg).toBe(26.63);
169 expect(zurueck.raeumweg).toBe(9.63);
170 });
171
172 it('faengt entartete Linien ab', () => {
173 const punkt: Fahrlinie = { id: 'p', punkte: [{ x: 0, y: 0 }], breite: 3 };
174 const ohneBreite: Fahrlinie = { ...waagerecht('a', 0, 0, 10, 3), breite: 0 };
175 const gut = senkrecht('b', 5, -5, 10, 3);
176
177 expect(vermesseWege(punkt, gut)).toBeNull();
178 expect(vermesseWege(ohneBreite, gut)).toBeNull();
179 expect(kreuzenSich(punkt, gut)).toBe(false);
180 });
181 });
182
183 describe('Massstab aus einer bekannten Strecke', () => {
184 it('rechnet Bildpunkte in Meter um', () => {
185 // Im Bild sind 200 Bildpunkte eine 50 m lange Strecke.
186 const massstab = massstabAusStrecke({ x: 100, y: 100 }, { x: 300, y: 100 }, 50)!;
187 expect(massstab.meterJeBildpunkt).toBeCloseTo(0.25, 6);
188
189 const linie: Fahrlinie = {
190 id: 'a',
191 punkte: [
192 { x: 0, y: 0 },
193 { x: 80, y: 0 },
194 ],
195 breite: 13,
196 };
197 expect(laenge(linieInMeter(linie, massstab))).toBeCloseTo(20, 6);
198 });
199
200 it('weist unbrauchbare Kalibrierungen ab', () => {
201 expect(massstabAusStrecke({ x: 0, y: 0 }, { x: 0, y: 0 }, 10)).toBeNull();
202 expect(massstabAusStrecke({ x: 0, y: 0 }, { x: 100, y: 0 }, 0)).toBeNull();
203 expect(massstabAusStrecke({ x: 0, y: 0 }, { x: 100, y: 0 }, Number.NaN)).toBeNull();
204 });
205 });
206
207 describe('Zusammenspiel mit der Zwischenzeitberechnung', () => {
208 it('liefert Wege, aus denen sich unmittelbar die Zwischenzeit ergibt', () => {
209 const kfz = waagerecht('k', 0, 0, 40, REGELBREITE.kfz);
210 const quer = senkrecht('q', 22, -9, 40, REGELBREITE.kfz);
211 const wege = vermesseWege(kfz, quer)!;
212
213 const ergebnis = computeIntergreen(
214 {
215 mode: 'kfz',
216 movement: 'geradeaus',
217 clearingDistance: wege.raeumweg,
218 vehicleClass: 'pkw',
219 vZul: 50,
220 },
221 { mode: 'kfz', movement: 'geradeaus', enteringDistance: wege.einfahrweg },
222 );
223
224 // sr = 23,63 + 6 m Fahrzeuglaenge = 29,63 m; vr = 10 m/s -> tr = 2,963 s
225 // se = 7,38 m; ve = 11,1 m/s -> te = 0,664 s
226 // tz = 3 + 2,963 − 0,664 = 5,299 -> 6 s
227 expect(wege.raeumweg).toBeCloseTo(23.63, 2);
228 expect(wege.einfahrweg).toBeCloseTo(7.38, 2);
229 expect(ergebnis.clearingPath).toBeCloseTo(29.63, 2);
230 expect(ergebnis.intergreen).toBe(6);
231 });
232
233 it('erkennt genau die Paare als feindlich, die sich kreuzen', () => {
234 // Zwei parallele Nord-Sued-Stroeme und ein kreuzender Ost-West-Strom.
235 const nord = senkrecht('n', 10, -20, 40, REGELBREITE.kfz);
236 const sued = senkrecht('s', 14, -20, 40, REGELBREITE.kfz);
237 const ost = waagerecht('o', -20, 0, 60, REGELBREITE.kfz);
238
239 expect(kreuzenSich(nord, sued)).toBe(false);
240 expect(kreuzenSich(nord, ost)).toBe(true);
241 expect(kreuzenSich(sued, ost)).toBe(true);
242 });
243 });