Added toWGS84 and toMercator as member functions of the coordinate types

Author: Newmanjack

lib/src/helpers.dart

@@ -46,6 +46,27 @@ enum DistanceGeometry {
 /// Earth Radius used with the Harvesine formula and approximates using a spherical (non-ellipsoid) Earth.
 const earthRadius = 6371008.8;
 
+/// Maximum extent of the Web Mercator projection in meters
+const double mercatorLimit = 20037508.34;
+
+/// Earth radius in meters used for coordinate system conversions
+const double conversionEarthRadius = 6378137.0;
+
+/// Coordinate reference systems for spatial data
+enum CoordinateSystem {
+  /// WGS84 geographic coordinates (longitude/latitude)
+  wgs84,
+  
+  /// Web Mercator projection (EPSG:3857)
+  mercator,
+}
+
+/// Coordinate system conversion constants
+const coordSystemConstants = {
+  'mercatorLimit': mercatorLimit,
+  'earthRadius': conversionEarthRadius,
+};
+
 /// Unit of measurement factors using a spherical (non-ellipsoid) earth radius.
 /// Keys are the name of the unit, values are the number of that unit in a single radian
 const factors = <Unit, num>{
@@ -180,3 +201,80 @@ num convertArea(num area,
 
   return (area / startFactor) * finalFactor;
 }
+
+
+/// Converts coordinates from one system to another
+/// Valid systems: wgs84, mercator
+/// Returns: Array of coordinates in the target system
+List<double> convertCoordinates(
+  List<num> coord, 
+  CoordinateSystem fromSystem, 
+  CoordinateSystem toSystem
+) {
+  if (fromSystem == toSystem) {
+    return coord.map((e) => e.toDouble()).toList();
+  }
+  
+  if (fromSystem == CoordinateSystem.wgs84 && toSystem == CoordinateSystem.mercator) {
+    return toMercator(coord);
+  } else if (fromSystem == CoordinateSystem.mercator && toSystem == CoordinateSystem.wgs84) {
+    return toWGS84(coord);
+  } else {
+    throw Exception("Unsupported coordinate system conversion: $fromSystem to $toSystem");
+  }
+}
+
+/// Converts a WGS84 coordinate to Web Mercator
+/// Valid inputs: Array of [longitude, latitude]
+/// Returns: Array of [x, y] coordinates in meters
+List<double> toMercator(List<num> coord) {
+  if (coord.length < 2) {
+    throw Exception("coordinates must contain at least 2 values");
+  }
+  
+  // Use the earth radius constant for consistency
+  
+  // Clamp latitude to avoid infinite values near the poles
+  final longitude = coord[0].toDouble();
+  final latitude = max(min(coord[1].toDouble(), 89.99), -89.99);
+  
+  // Convert longitude to x coordinate
+  final x = longitude * (conversionEarthRadius * pi / 180.0);
+  
+  // Convert latitude to y coordinate
+  final latRad = latitude * (pi / 180.0);
+  final y = log(tan((pi / 4) + (latRad / 2))) * conversionEarthRadius;
+  
+  // Clamp to valid Mercator bounds
+  final clampedX = max(min(x, mercatorLimit), -mercatorLimit);
+  final clampedY = max(min(y, mercatorLimit), -mercatorLimit);
+  
+  return [clampedX, clampedY];
+}
+
+/// Converts a Web Mercator coordinate to WGS84
+/// Valid inputs: Array of [x, y] in meters
+/// Returns: Array of [longitude, latitude] coordinates
+List<double> toWGS84(List<num> coord) {
+  if (coord.length < 2) {
+    throw Exception("coordinates must contain at least 2 values");
+  }
+  
+  // Use the earth radius constant for consistency
+  
+  // Clamp inputs to valid range
+  final x = max(min(coord[0].toDouble(), mercatorLimit), -mercatorLimit);
+  final y = max(min(coord[1].toDouble(), mercatorLimit), -mercatorLimit);
+  
+  // Convert x to longitude
+  final longitude = x / (conversionEarthRadius * pi / 180.0);
+  
+  // Convert y to latitude
+  final latRad = 2 * atan(exp(y / conversionEarthRadius)) - (pi / 2);
+  final latitude = latRad * (180.0 / pi);
+  
+  // Clamp latitude to valid range
+  final clampedLatitude = max(min(latitude, 90.0), -90.0);
+  
+  return [longitude, clampedLatitude];
+}

test/components/helpers_test.dart

@@ -1,6 +1,7 @@
 import 'dart:math';
 import 'package:test/test.dart';
 import 'package:turf/helpers.dart';
+import 'package:geotypes/geotypes.dart';
 
 void main() {
   test('radiansToLength', () {
@@ -77,4 +78,98 @@ void main() {
     expect(convertArea(100, Unit.meters, Unit.feet), equals(1076.3910417));
     expect(convertArea(100000, Unit.feet), equals(0.009290303999749462));
   });
+  
+  test('toMercator', () {
+    // Test with San Francisco coordinates
+    final wgs84 = [-122.4194, 37.7749];
+    final mercator = toMercator(wgs84);
+    
+    // Expected values (approximate)
+    final expectedX = -13627665.0;
+    final expectedY = 4547675.0;
+    
+    // Check conversion produces results within an acceptable range
+    expect(mercator[0], closeTo(expectedX, 50.0));
+    expect(mercator[1], closeTo(expectedY, 50.0));
+    
+    // Test with error case
+    expect(() => toMercator([]), throwsException);
+  });
+  
+  test('toWGS84', () {
+    // Test with San Francisco Mercator coordinates
+    final mercator = [-13627695.092862014, 4547675.345836067];
+    final wgs84 = toWGS84(mercator);
+    
+    // Expected values (approximate)
+    final expectedLon = -122.42;
+    final expectedLat = 37.77;
+    
+    // Check conversion produces results within an acceptable range
+    expect(wgs84[0], closeTo(expectedLon, 0.01));
+    expect(wgs84[1], closeTo(expectedLat, 0.01));
+    
+    // Test with error case
+    expect(() => toWGS84([]), throwsException);
+  });
+  
+  test('Round-trip conversion WGS84-Mercator-WGS84', () {
+    // Test coordinates for various cities
+    final cities = [
+      [-122.4194, 37.7749], // San Francisco
+      [139.6917, 35.6895],  // Tokyo
+      [151.2093, -33.8688], // Sydney
+      [-0.1278, 51.5074],   // London
+    ];
+    
+    for (final original in cities) {
+      final mercator = toMercator(original);
+      final roundTrip = toWGS84(mercator);
+      
+      // Round-trip should return to the original value within a small delta
+      expect(roundTrip[0], closeTo(original[0], 0.00001));
+      expect(roundTrip[1], closeTo(original[1], 0.00001));
+    }
+  });
+  
+  test('convertCoordinates', () {
+    // Test WGS84 to Mercator conversion
+    final wgs84 = [-122.4194, 37.7749]; // San Francisco
+    final mercator = convertCoordinates(
+      wgs84, 
+      CoordinateSystem.wgs84, 
+      CoordinateSystem.mercator
+    );
+    
+    // Should match toMercator result
+    final directMercator = toMercator(wgs84);
+    expect(mercator[0], equals(directMercator[0]));
+    expect(mercator[1], equals(directMercator[1]));
+    
+    // Test Mercator to WGS84 conversion
+    final backToWgs84 = convertCoordinates(
+      mercator, 
+      CoordinateSystem.mercator, 
+      CoordinateSystem.wgs84
+    );
+    
+    // Should match toWGS84 result and be close to original
+    expect(backToWgs84[0], closeTo(wgs84[0], 0.00001));
+    expect(backToWgs84[1], closeTo(wgs84[1], 0.00001));
+    
+    // Test same system conversion (should return same values)
+    final sameSystem = convertCoordinates(
+      wgs84, 
+      CoordinateSystem.wgs84, 
+      CoordinateSystem.wgs84
+    );
+    expect(sameSystem[0], equals(wgs84[0]));
+    expect(sameSystem[1], equals(wgs84[1]));
+    
+    // Test error case
+    expect(
+      () => convertCoordinates([], CoordinateSystem.wgs84, CoordinateSystem.mercator), 
+      throwsException
+    );
+  });
 }