Implementeer een geografische afstandsberekenaar met TypeScript

Bij het ontwikkelen van educatieve spellen is het bieden van nauwkeurige en zinvolle feedback essentieel voor gebruikersbetrokkenheid. In dit artikel zal ik delen hoe we een geografisch berekeningssysteem hebben geïmplementeerd voor Flagle Explorer, een vlaggenraadspel dat gebruikers helpt om de wereldgeografie te leren door middel van interactieve feedback.

De Technische Uitdaging

Onze belangrijkste vereisten waren:

1. Nauwkeurige afstandsberekeningen tussen elk twee punten op aarde
2. Precieze peilingberekeningen voor richtingaanwijzing
3. Gestandaardiseerde nabijheidsscore
4. Real-time prestaties voor directe feedback

Implementatiedetails

1. Kerngegevensstructuur

Ten eerste hebben we onze basisinterface voor geografische punten gedefinieerd:

export interface GeoPoint {

  lat: number;  // Latitude in degrees

  lon: number;  // Longitude in degrees

}

2. Implementatie van Afstandsberekening

We hebben de Haversine-formule geïmplementeerd voor het berekenen van grote cirkelafstanden:

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. Berekingscalculatiesysteem

We hebben een geavanceerd berekingssysteem ontwikkeld dat complexe hoekenwiskunde omzet in gebruiksvriendelijke richtingindicatoren:

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. Gebruiksvriendelijke richtingsmapping

Om de berekeningen gebruiksvriendelijker te maken, koppelen we ze aan richtingsemoji’s:

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 '↖️';

}

Prestatieoverwegingen

1. Vroegtijdige retouren: We implementeren vroegtijdige retouren voor identieke punten om onnodige berekeningen te vermijden.
2. Continue optimalisatie: De straal van de aarde en de conversies van graden naar radialen worden vooraf berekend.
3. Precisiecontrole: Getallen worden afgerond op de juiste decimalen om een balans te vinden tussen nauwkeurigheid en prestaties.

Foutafhandeling en randgevallen

Onze implementatie behandelt verschillende randgevallen:

• Identieke punten
• Antipodale punten
• Punten op de polen
• Berekeningen over de datalijn

Teststrategie

We hebben uitgebreide tests geïmplementeerd die het volgende omvatten:

1. Bekende afstandsberekeningen tussen grote steden
2. Grenssituaties bij de polen en de internationale datumgrens
3. Richtingsberekeningen voor kardinale en interkardinale punten
4. Prestatiebenchmarks voor realtime feedback

Praktische toepassing

Dit systeem is succesvol geïmplementeerd in Flagle Explorer, waarbij dagelijks duizenden berekeningen worden verwerkt met:

• Gemiddelde responstijd < 5ms
• 99,99% nauwkeurigheid in vergelijking met referentieberekeningen
• Geen gemelde berekeningsgerelateerde bugs in productie

Toekomstige optimalisaties

We onderzoeken verschillende verbeteringen:

1. WebAssembly-implementatie voor complexe berekeningen
2. Caching van vaak berekende routes
3. Batchverwerking voor meer-puntsberekeningen
4. Integratie met terreinhoogtegegevens

Conclusie

Het bouwen van een geografisch berekeningssysteem vereist nauwkeurige aandacht voor wiskundige nauwkeurigheid, prestatieoptimalisatie en gebruikerservaring. Onze implementatie in TypeScript balanceert deze factoren succesvol, terwijl de code leesbaarheid en onderhoudbaarheid behoudt.

Wil je deze berekeningen in actie zien? Je kunt ze uitproberen op Flagle Explorer en zien hoe de afstands- en richtingsaanwijzers je door de wereldwijde geografie leiden!

Code Repository

De volledige implementatie is beschikbaar op onze GitHub. Hier is een snelstartgids:

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`);

Deze implementatie heeft zich in de praktijk bewezen, met het verwerken van miljoenen berekeningen met behoud van hoge prestatie- en nauwkeurigheidsnormen.