Implementieren Sie einen geografischen Entfernungsberechner mit TypeScript

Bei der Entwicklung von Bildungsspielen ist es entscheidend, genaues und sinnvolles Feedback für die Benutzerbindung bereitzustellen. In diesem Artikel werde ich teilen, wie wir ein geografisches Berechnungssystem für Flagle Explorer implementiert haben, ein Flaggenrätselspiel, das Benutzern hilft, durch interaktives Feedback die Weltgeografie zu lernen.

Die technische Herausforderung

Unsere Hauptanforderungen waren:

1. Genauigkeit bei Entfernungsberechnungen zwischen beliebigen Punkten auf der Erde
2. Prazise Richtungsberechnungen für die Orientierung
3. Normalisierte Näherungspunktzahl
4. Echtzeit-Leistung für sofortiges Feedback

Implementierungsdetails

1. Kern-Datenstruktur

Zunächst haben wir unsere grundlegende geografische Punkt-Schnittstelle definiert:

export interface GeoPoint {

  lat: number;  // Latitude in degrees

  lon: number;  // Longitude in degrees

}

2. Implementierung der Entfernungsberechnung

Wir haben die Haversine-Formel für die Berechnung von Großkreisentfernungen implementiert:

export function calculateDistance(point1: GeoPoint, point2: GeoPoint): number {

  // Early return for identical points

  if (point1.lat === point2.lat && point1.lon === point2.lon) {

    return 0;

  }

​

  const R = 6371000; // Earth's radius in meters

​

  // Convert to radians

  const dLat = (point2.lat - point1.lat) * Math.PI / 180;

  const dLon = (point2.lon - point1.lon) * Math.PI / 180;

  const lat1 = point1.lat * Math.PI / 180;

  const lat2 = point2.lat * Math.PI / 180;

​

  // Haversine formula

  const a = Math.sin(dLat/2) * Math.sin(dLat/2) +

    Math.cos(lat1) * Math.cos(lat2) *

    Math.sin(dLon/2) * Math.sin(dLon/2);

  const c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1-a));

​

  return (R * c) / 1000; // Convert to kilometers

}

3. Lagerberechnungssystem

Wir haben eine ausgeklügelte Lagerberechnung entwickelt, die komplexe Winkelmessungen in benutzerfreundliche Richtungsindikatoren umwandelt:

export function calculateOrientation(point1: GeoPoint, point2: GeoPoint): number {

  if (point1.lat === point2.lat && point1.lon === point2.lon) return 0;

​

  // Convert to radians

  const lat1 = point1.lat * Math.PI / 180;

  const lat2 = point2.lat * Math.PI / 180;

  const dLon = (point2.lon - point1.lon) * Math.PI / 180;

​

  // Calculate bearing

  const y = Math.sin(dLon) * Math.cos(lat2);

  const x = Math.cos(lat1) * Math.sin(lat2) -

           Math.sin(lat1) * Math.cos(lat2) * Math.cos(dLon);

​

  let bearing = Math.atan2(y, x) * 180 / Math.PI;

  return (bearing + 360) % 360;

}

4. Benutzerfreundliche Richtungskartierung

Um die Lagerberechnungen benutzerfreundlicher zu gestalten, ordnen wir ihnen Richtungs-Emojis zu:

export function calculateOrientationEmoji(point1: GeoPoint, point2: GeoPoint): string {

  const orientation = calculateOrientation(point1, point2);

​

  // Map angles to 8-direction compass

  if (orientation >= 337.5 || orientation < 22.5) return '⬆️';

  if (orientation >= 22.5 && orientation < 67.5) return '↗️';

  if (orientation >= 67.5 && orientation < 112.5) return '➡️';

  if (orientation >= 112.5 && orientation < 157.5) return '↘️';

  if (orientation >= 157.5 && orientation < 202.5) return '⬇️';

  if (orientation >= 202.5 && orientation < 247.5) return '↙️';

  if (orientation >= 247.5 && orientation < 292.5) return '⬅️';

  return '↖️';

}

Leistungsüberlegungen

1. Frühe Rückgaben: Wir implementieren frühe Rückgaben für identische Punkte, um unnötige Berechnungen zu vermeiden.
2. Konstantenoptimierung: Der Erdradius und Umrechnungen von Grad in Bogenmaß werden vorab berechnet.
3. Präzisionskontrolle: Zahlen werden auf geeignete Dezimalstellen gerundet, um Genauigkeit und Leistung auszugleichen.

Fehlerbehandlung und Grenzfälle

Unsere Implementierung behandelt mehrere Grenzfälle:

• Identische Punkte
• Antipodale Punkte
• Punkte an den Polen
• Berechnungen über das Datumslinie hinweg

Teststrategie

Wir haben umfassende Tests implementiert, die abdecken:

1. Bekannte Entfernungsberechnungen zwischen Großstädten
2. Grenzfälle an den Polen und der internationalen Datumsgrenze
3. Richtungsberechnungen für Haupt- und Zwischenhimmelsrichtungen
4. Leistungsbenchmark für Echtzeit-Feedback

Real-World-Anwendung

Dieses System wurde erfolgreich in Flagle Explorer implementiert und verarbeitet täglich tausende Berechnungen mit:

• Durchschnittliche Antwortzeit < 5ms
• 99,99% Genauigkeit im Vergleich zu Referenzberechnungen
• Keine berichteten berechnungsbezogenen Fehler in der Produktion

Zukünftige Optimierungen

Wir untersuchen mehrere Verbesserungen:

1. WebAssembly-Implementierung für komplexe Berechnungen
2. Cache für häufig berechnete Routen
3. Batch-Verarbeitung für Mehrpunkt-Berechnungen
4. Integration mit Geländehöhendaten

Abschluss

Der Aufbau eines geografischen Berechnungssystems erfordert sorgfältige Berücksichtigung von mathematischer Genauigkeit, Leistungsoptimierung und Benutzererfahrung. Unsere Implementierung in TypeScript balanciert erfolgreich diese Faktoren aus, während sie die Lesbarkeit und Wartbarkeit des Codes beibehält.

Möchten Sie diese Berechnungen in Aktion sehen? Sie können sie bei Flagle Explorer ausprobieren und sehen, wie die Distanz- und Richtungsanzeiger Sie durch die globale Geografie führen!

Code-Repository

Die vollständige Implementierung ist auf unserem GitHub verfügbar. Hier ist eine Schnellstartanleitung:

import { calculateDistance, calculateOrientationEmoji } from 'the-library/geo';

​

const london: GeoPoint = { lat: 51.5074, lon: -0.1278 };

const tokyo: GeoPoint = { lat: 35.6762, lon: 139.6503 };

​

const distance = calculateDistance(london, tokyo);

const direction = calculateOrientationEmoji(london, tokyo);

​

console.log(`Tokyo is ${distance}km ${direction} from London`);

Diese Implementierung hat sich in der Produktion als robust erwiesen, da sie Millionen von Berechnungen bewältigt und dabei hohe Leistungs- und Genauigkeitsstandards aufrechterhält.