Ereignistabellen
Ein Ereignis ist eine Aussage über eine Strecke einer Route, die über ihre M-Werte angesprochen wird und keine eigene Geometrie hat: Tempolimit 50 von Kilometer 0 bis 5, Belag Schotter von 3 bis 8, Brücke bei 8,2. Die Route selbst ist die kalibrierte Polylinie der linearen Referenzierung; die Ereignisse liegen in der Datenbank des Hosts. LineEvents rechnet zwischen Ereignistabellen (ADR 0033): welche Ereignisse gleichzeitig gelten, was eine Tabelle hat und die andere nicht, welche Nachbarn sich zusammenfassen lassen. Es rechnet nur mit den Zahlen, braucht also keine Geometrie, keine Factory und keinen Datenbankzugriff; die Bibliothek liest nie eine Tabelle, Sie geben ihr die Zeilen.
Was hineingeht, was herauskommt
Ein Ereignis ist ein LineEvent<T>(From, To, Value): ein Bereich von M-Werten und ein beliebiger Wert für die Attribute (ein int für ein Tempo, ein Text, ein Record mit mehreren Feldern). Eine Tabelle ist jedes IEnumerable<LineEvent<T>>.
Zwei Tabellen einer Route:
| Von | Bis | Tempo | Von | Bis | Belag | |
|---|---|---|---|---|---|---|
| 0 | 5 000 | 50 | 0 | 3 000 | Asphalt | |
| 5 000 | 12 000 | 70 | 3 000 | 8 000 | Schotter | |
| 8 000 | 12 000 | Asphalt |
Die Frage „wo gilt welches Tempo auf welchem Belag?“ ist der Schnitt der beiden Tabellen, und das Ergebnis ist wieder eine Tabelle:
| Von | Bis | Tempo | Belag |
|---|---|---|---|
| 0 | 3 000 | 50 | Asphalt |
| 3 000 | 5 000 | 50 | Schotter |
| 5 000 | 8 000 | 70 | Schotter |
| 8 000 | 12 000 | 70 | Asphalt |
var speed = new[] { new LineEvent<int>(0, 5000, 50), new LineEvent<int>(5000, 12000, 70) };
var surface = new[]
{
new LineEvent<string>(0, 3000, "asphalt"), new LineEvent<string>(3000, 8000, "gravel"), new LineEvent<string>(8000, 12000, "asphalt"),
};
// Where do both hold? One piece per overlap, with the two values combined.
var both = LineEvents.Intersect(speed, surface, (s, b) => (Speed: s, Surface: b));
// 0-3000 (50, asphalt), 3000-5000 (50, gravel), 5000-8000 (70, gravel), 8000-12000 (70, asphalt)
// Join neighbours with the same value: the surface alone, after cutting at the speed limits.
var surfaceOnly = LineEvents.Dissolve(both.Select(e => new LineEvent<string>(e.From, e.To, e.Value.Surface)));
// 0-3000 asphalt, 3000-8000 gravel, 8000-12000 asphalt
// Which speed limit holds at a bridge at 8200?
var atBridge = LineEvents.At(speed, 8200); // one event: 5000-12000, 70
// Where is the road without a bicycle path?
var bikePath = new[] { new LineEvent<bool>(2000, 6000, true) };
var withoutPath = LineEvents.Difference(speed, bikePath); // 0-2000 (50) and 6000-12000 (70)
Die Operationen
| Operation | Frage | Ergebnis |
|---|---|---|
Intersect(a, b, combine) |
wo gelten ein Ereignis aus a und eines aus b gleichzeitig? |
ein Stück je überlappendem Paar, mit dem Wert, den combine aus beiden macht |
Union(a, b, both, onlyA, onlyB) |
die Route an jeder Grenze beider Tabellen zerlegt | ein Stück überall dort, wo mindestens eine Tabelle ein Ereignis hat, mit dem Wert von both, onlyA oder onlyB |
Difference(a, b) |
was hat a dort, wo b nichts hat? |
die Teile der Ereignisse von a, die kein Ereignis von b bedeckt, mit den Werten von a |
Dissolve(events, comparer?) |
Zusammengehöriges verbinden | Ereignisse, die sich berühren oder überlappen und denselben Wert haben, werden eins |
Clip(events, from, to) |
nur ein Abschnitt | die Ereignisse auf den Bereich zugeschnitten |
At(events, m) |
was gilt hier? | die Ereignisse, deren Bereich m enthält |
Einiges, das man wissen sollte:
Unionbenennt die Seite. Ein Stück, das nur eine Tabelle bedeckt, hat keinen Wert der anderen, und für einT, das eine Zahl oder ein Struct sein kann, gibt es kein ehrliches „leer“. Sie geben also an, was aus jedem Fall wird:Union(speed, surface, (s, b) => $"{s}, {b}", s => $"{s}, keine Angabe", b => $"kein Limit, {b}").UnionundIntersectschneiden,Dissolveverbindet. Beide schneiden an jeder Grenze beider Tabellen, benachbarte Stücke können also gleiche Werte haben; mitDissolvedanach werden sie verbunden.Dissolveverbindet auch über Ereignisse anderer Werte hinweg (einA, darin einB, einA, das weiterläuft, verbindet die beidenA) und lässt Ereignisse verschiedener Werte in Ruhe, auch wo sie überlappen.comparerbestimmt, was „derselbe Wert“ heißt; ohne ihn gilt die Standard-Gleichheit vonT, die bei einem Record alle Felder vergleicht.- Überlappungen.
Intersectnimmt Ereignisse an, die sich innerhalb einer Tabelle überlappen, und liefert für jedes überlappende Paar ein Stück.Unionnicht: Ein Stück hätte zwei Werte aus derselben Tabelle, überlappende Ereignisse innerhalb einer Tabelle sind deshalb eineArgumentException, die die Tabelle nennt.Differencesieht von der zweiten Tabelle nur die Bereiche, Überlappungen dort sind also in Ordnung. - Grenzen. Bereiche sind geschlossen, aber nur ein Bereich mit Länge zählt. Ein Ereignis mit
From == Towird ignoriert, und keine Operation liefert ein Stück ohne Länge: Zwei Nachbarn[0, 5]und[5, 9]treffen sich bei 5, ohne dass dazwischen ein Stück läge. Sichtbar wird das nur beiAt(events, 5): Beide Nachbarn enthalten 5, also kommen beide zurück. Brauchen Sie eines, entscheiden Sie nach Ihrer Regel (zum Beispiel das spätere). - Reihenfolge und vertauschte Grenzen. Die Eingabe darf in beliebiger Reihenfolge sein, und ein Ereignis mit
Fromgrößer alsTowird mit vertauschten Grenzen gelesen (M kann abwärts laufen). Die Ergebnisse sind nachFrom, dannTosortiert. - Ungültige Zahlen.
NaNoder ein unendlichesFromoderToist eineArgumentOutOfRangeException, die das Ereignis nennt.
Von der Tabelle zur Karte
Die Rechnung liefert M-Bereiche. Um sie zu zeichnen, geben Sie jeden Bereich an LocateBetween auf der kalibrierten Route: Das Ergebnis folgt der Straße mit ihren Kurven, in Richtung der Route, und hat mehrere Pfade, wenn die Route den Bereich mehrfach durchläuft (Lineare Referenzierung). Das Cookbook zeigt das als vollständiges Rezept, von den Tabellen bis zu den Längen der Stücke auf der Straße.
Ein Punktereignis (eine Brücke bei 8 200) ist ein LocateAlong von einem Punkt entfernt; ein Punkt innerhalb eines Linienereignisses ist At.
Mehrere Routen und die Datenbank
LineEvents arbeitet mit einer Route auf einmal. Eine echte Tabelle hat eine Routen-Id; gruppieren Sie selbst danach, das ist eine Zeile LINQ und hält die Bibliothek frei von Datenbankbegriffen:
// The rows come from your database; the library only gets the numbers of one route at a time.
var rows = new[]
{
(Route: "A12", From: 0.0, To: 5000.0, Speed: 50),
(Route: "A12", From: 5000.0, To: 12000.0, Speed: 70),
(Route: "B3", From: 0.0, To: 800.0, Speed: 30),
};
Dictionary<string, LineEvent<int>[]> byRoute = rows
.GroupBy(r => r.Route)
.ToDictionary(g => g.Key, g => g.Select(r => new LineEvent<int>(r.From, r.To, r.Speed)).ToArray());
Die Tabellen sind in M-Werten, nicht in Längen: Liegen Ihre Ereignisse als Meter ab Routenanfang vor, rechnen Sie sie zuerst um (oder kalibrieren die Route so, dass M diese Länge ist).
Punktereignisse und das Zeichnen einer Tabelle
Ein Ereignis bei einem einzigen M-Wert (eine Brücke, eine Schadensmeldung) ist ein PointEvent<T>(M, Value) (ADR 0040). PointEvents beantwortet die Fragen dazu, wieder allein auf den Zahlen:
var bridges = new[] { new PointEvent<string>(8200, "bridge"), new PointEvent<string>(11450, "culvert") };
var limits = new[] { new LineEvent<int>(0, 5000, 50), new LineEvent<int>(5000, 12000, 70) };
// Which speed limit holds at each? One result per pair, at the M of the point.
var withLimit = PointEvents.Within(bridges, limits, (b, kmh) => $"{b}: {kmh} km/h"); // bridge 70, culvert 70
// Which have no speed limit in a table that stops at 9000?
var uncovered = PointEvents.Outside(bridges, [new LineEvent<int>(0, 9000, 50)]); // the culvert
// Draw a table on the calibrated route: one entry per event, with its stretch.
var route = Wkt.Read<IPolyline2D>("LINESTRING M (0 0 0, 12000 0 12000)");
var drawn = route.LocateEvents(limits); // (event, shape) for 0-5000 and 5000-12000
| Operation | Frage | Ergebnis |
|---|---|---|
PointEvents.Between(points, from, to) |
welche liegen in diesem Bereich? | die Punktereignisse mit M im geschlossenen Bereich |
PointEvents.Within(points, lines, combine) |
was gilt an jedem? | ein Ergebnis je Punktereignis und Linienereignis, das es enthält (zwei auf einer Grenze) |
PointEvents.Outside(points, lines) |
welche liegen in keinem Linienereignis? | die Punktereignisse ohne eines: die Prüfung auf Lücken |
route.LocateEvents(events) |
wo auf der Karte? | ein Eintrag je Ereignis, in der Eingabereihenfolge: die Strecke eines Linienereignisses, die Punkte eines Punktereignisses; eine leere Geometrie, wenn die Route es nicht erreicht |
Bereiche sind geschlossen und Linienereignisse ohne Länge werden ignoriert, wie bei LineEvents. LocateEvents baut den Index der Route einmal für die ganze Tabelle.
Von einer Geometrie zu einem Ereignis
Die Gegenrichtung ist LocateFeature auf der Route: Ein Flurstück, eine Leitung oder eine überflutete Fläche wird zu den Bereichen von M, in denen sie liegt, und von dort zu einem Ereignis (ADR 0034):
var ranges = route.LocateFeature(parcel, tolerance: 0);
var events = ranges.Select(r => new LineEvent<string>(r.From, r.To, "parcel 123/4"));
Die Ereignisse lassen sich dann mit den anderen verrechnen, etwa mit Intersect gegen eine Tempotabelle, um zu finden, wo ein Flurstück an einer 50-km/h-Strecke liegt.
Nicht dabei
Mehrere Routen in einem Aufruf (der Host gruppiert) und eine Toleranz für „nahe“ an einem Linienereignis: Ein Punktereignis liegt genau in einem Bereich oder nicht. Ein Punkt auf der Karte wird mit ProjectToM zu einem Messwert.