Release: 0.9.0 (#36)

* feat: spherical law of cosines & equirectangular approximation (#35)

* Updated README

* Update LICENSE

* docs: CODE_OF_CONDUCT

* chore: dart format

* docs: revise README.md

* CODE & FEATURES

* Little Changes

* EquirectangularApproximation

* Spherical Law of Cosines

* GeodeticPointManipulation

* MidpointBetweenTwoPoints

* PointAlongGreatCircle

* DONE

* refactor: remove unwanted comments

* refactor: format

* fix: The line length exceeds the 80-character limit

* Vincenty DOC

---------

Co-authored-by: wingkwong <[email protected]>

* docs: format code

* docs: add 0.9.0 CHANGELOG

* chore: bump to 0.9.0

---------

Co-authored-by: Ayoub Ali <[email protected]>

Author: wingkwong

CHANGELOG.md

@@ -1,5 +1,10 @@
 # CHANGELOG
 
+## 0.9.0
+
+- Implement DistanceCalculations: EquirectangularApproximation, and SphericalLawOfCosines
+- Implement GeodeticPointManipulation: DestinationPoint, MidPointBetweenTwoPoints, and GreatCirclePoint
+
 ## 0.8.0
 
 - Implement Calculating Polygon Area With Hole
@@ -18,48 +23,59 @@
 - Add getPolygonIntersection
 
 ## 0.5.0
+
 - Add greatCircleDistanceBetweenTwoGeoPoints
 - Add getRectangleBounds
 - Add calculateBoundingBox
 
 ## 0.4.2
+
 - Removed pedantic
 - Migrated to lints package with Dart 3 compatible
 - Refactored source code
-- Revised README.md 
+- Revised README.md
 
 ## 0.4.1
+
 - Fixed isGeoPointInBoundingBox typos & logic
 
 ## 0.4.0
+
 - Added dart 3 compatible changes
 - Revised test cases
 - Bumped minimum Dart version to 3.0.
 
 ## 0.4.0-nullsafety.0
+
 - Null Safety Upgrade
 
 ## 0.3.2
+
 - Added tests
 - Added pointsInRange
 
 ## 0.3.1
+
 - Applied strict static analysis
 - Made the radius parameter optional
 
 ## 0.3.0
+
 - Added latlong package
 - Deprecated LatLng
 - Deprecated degreesToRadians & radiansToDegrees
 
 ## 0.2.0
+
 - Added intersectionByPaths
-- Added crossTrackDistanceTo 
+- Added crossTrackDistanceTo
 - Added isGeoPointInPolygon
 
 ## 0.1.1
+
 - Added example
 - Reformatted with Dart Style
 
 ## 0.1.0
+
 - Initial version, created by wingkwong

README.md

@@ -42,7 +42,7 @@ Please see the details [here](doc/CLASS.md).
 
 ## Static Methods
 
-Static methods are avilable without using Geodesy instance.
+Static methods are available without using Geodesy instance.
 
 Please see the details  [here](doc/METHODS.md).
 
@@ -186,14 +186,14 @@ final outerPolygon = [
     const LatLng(1.0, 0.0),
   ];
 
-  final hole1 = [
-    const LatLng(0.25, 0.25),
-    const LatLng(0.25, 0.75),
-    const LatLng(0.75, 0.75),
-    const LatLng(0.75, 0.25),
-  ];
+final hole1 = [
+  const LatLng(0.25, 0.25),
+  const LatLng(0.25, 0.75),
+  const LatLng(0.75, 0.75),
+  const LatLng(0.75, 0.25),
+];
 
-  final holes = [hole1];
+final holes = [hole1];
 final area = Polygon.calculatePolygonWithHolesArea(outerPolygon, holes);
 ```
 
@@ -203,4 +203,4 @@ See [here](doc/CODE_OF_CONDUCT.md).
 
 ## License
 
-See [here](./LICENSE).
+See [here](./LICENSE).

doc/CLASS.md

@@ -231,15 +231,44 @@ Returns a list of `LatLng` points representing the intersection polygon.
 ### Vincenty formula for Geodesic Distance Calculation
 
 ```dart
- final double calculatedDistance = geodesy.vincentyDistance(
-      point1.latitude, point1.longitude, point2.latitude, point2.longitude);
+final double calculatedDistance = 
+  geodesy.vincentyDistance(point1.latitude, point1.longitude, point2.latitude, point2.longitude);
 ```
 
 ### Calculate Area of Polygon with Hole
 
 ```dart
-final calculatedArea =
-        geodesy.calculatePolygonWithHolesArea(outerPolygon, holes);
+final calculatedArea = geodesy.calculatePolygonWithHolesArea(outerPolygon, holes);
+```
+
+### Equirectangular Approximation Calculation
+
+```dart
+double equirectangularDistance = geodesy.equirectangularDistance(firstPoint, secondPoint);
+```
+
+### Spherical Law Of Cosines Distance
+
+```dart
+double sLCDdistance = geodesy.sphericalLawOfCosinesDistance(bGPoint, pFPoint);
+```
+
+### Geodetic Point Manipulation - Rhumb Line Destination Formula
+
+```dart
+LatLng destinationPoints = geodesy.calculateDestinationPoint(initialPoint, bearingDegrees, distanceKm);
+```
+
+### Geodetic Point Manipulation - Midpoint between two points
+
+```dart
+LatLng midPointBetweenTwoPoints = geodesy.calculateMidpoint(bgPoint1, pFPoint2);
+```
+
+### Geodetic Point Manipulation - Calculate Point Along Great Circle
+
+```dart
+List<LatLng> arcPoints = geodesy.calculatePointsAlongGreatCircle(startPoint, endPoint, numPoints);
 ```
 
 ---

doc/METHODS.md

@@ -219,6 +219,41 @@ VincentyDistance.vincentyDistance(lat1, lon1, lat2, lon2);
 final area = Polygon.calculatePolygonWithHolesArea(outerPolygon, holes);
 ```
 
+### Equirectangular approximation Calculation
+
+```dart
+double equirectangularDistance = 
+  EquirectangularApproximation.equirectangularDistance(firstPoint,secondPoint);
+```
+
+### Spherical Law Of Cosines Distance
+
+```dart
+double sLCDdistance =
+  SphericalLawOfCosines.sphericalLawOfCosinesDistance(bGPoint, pFPoint);
+```
+
+### Geodetic Point Manipulation - Rhumb Line Destination Formula
+
+```dart
+LatLng destinationPoints = DestinationPoint.calculateDestinationPoint(
+  initialPoint, bearingDegrees, distanceKm);
+```
+
+### Geodetic Point Manipulation - Midpoint between two points
+
+```dart
+LatLng midPointBetweenTwoPoints =
+  MidPointBetweenTwoPoints.calculateMidpoint(bgPoint1, pFPoint2);
+```
+
+### Geodetic Point Manipulation - Calculate Point Along Great Circle
+
+```dart
+List<LatLng> arcPoints = GreatCirclePoint.calculatePointsAlongGreatCircle(
+  startPoint, endPoint, numPoints);
+```
+
 ---
 
 This `Geodesy` provides a comprehensive set of methods for performing various geodetic calculations and operations. You can use these methods to calculate distances, bearings, intersections, and more based on geographical coordinates.

example/example.dart

@@ -1,4 +1,7 @@
 import 'package:geodesy/geodesy.dart';
+import 'package:geodesy/src/core/GeodeticPointManipulation/calculate_destination_point.dart';
+import 'package:geodesy/src/core/GeodeticPointManipulation/calculate_points_along_great_circle.dart';
+import 'package:geodesy/src/core/GeodeticPointManipulation/mid_point_between_two_points.dart';
 import 'package:geodesy/src/core/polygon_with_hole.dart';
 
 void main() {
@@ -85,4 +88,60 @@ void main() {
 
   final area = Polygon.calculatePolygonWithHolesArea(outerPolygon, holes);
   print("Area of polygon with holes: $area");
+
+  // Equirectangular approximation Calculation
+  final firstPoint = const LatLng(52.5200, 13.4050); // Berlin, Germany
+  final secondPoint = const LatLng(48.8566, 2.3522); // Paris, France
+
+  double equirectangularDistance =
+      EquirectangularApproximation.equirectangularDistance(
+          firstPoint, secondPoint);
+  print(
+      '''Equirectangular Distance: ${equirectangularDistance.toStringAsFixed(2)} km
+      ''');
+
+  /// Calculate Spherical Law Of Cosines Distance
+  final bGPoint = const LatLng(52.5200, 13.4050); // Berlin, Germany
+  final pFPoint = const LatLng(48.8566, 2.3522); // Paris, France
+
+  double sLCDdistance =
+      SphericalLawOfCosines.sphericalLawOfCosinesDistance(bGPoint, pFPoint);
+  print(
+      '''Spherical Law of Cosines Distance: ${sLCDdistance.toStringAsFixed(2)} km
+      ''');
+
+  /// Geodetic Point Manipulation - Rhumb Line Destination Formula
+  final initialPoint = const LatLng(52.5200, 13.4050); // Berlin, Germany
+  final bearingDegrees = 45.0; // 45 degrees bearing (northeast)
+  final distanceKm = 100.0; // 100 kilometers distance
+
+  LatLng destinationPoints = DestinationPoint.calculateDestinationPoint(
+      initialPoint, bearingDegrees, distanceKm);
+
+  print('Initial Point: ${initialPoint.latitude}, ${initialPoint.longitude}');
+  print('''Destination Point: ${destinationPoints.latitude}, 
+      ${destinationPoints.longitude}''');
+
+  /// Geodetic Point Manipulation - Midpoint between two points
+  final bgPoint1 = const LatLng(52.5200, 13.4050); // Berlin, Germany
+  final pFPoint2 = const LatLng(48.8566, 2.3522); // Paris, France
+
+  LatLng midPointBetweenTwoPoints =
+      MidPointBetweenTwoPoints.calculateMidpoint(bgPoint1, pFPoint2);
+
+  print('''Midpoint: ${midPointBetweenTwoPoints.latitude}, 
+      ${midPointBetweenTwoPoints.longitude}''');
+
+  /// Geodetic Point Manipulation - Calculate Point Along Great Circle
+  final startPoint = const LatLng(52.5200, 13.4050); // Berlin, Germany
+  final endPoint = const LatLng(48.8566, 2.3522); // Paris, France
+  final numPoints = 5; // Number of points along the arc
+
+  List<LatLng> arcPoints = GreatCirclePoint.calculatePointsAlongGreatCircle(
+      startPoint, endPoint, numPoints);
+
+  print('Points along Great Circle Arc:');
+  for (var point in arcPoints) {
+    print('${point.latitude}, ${point.longitude}');
+  }
 }

example/main.dart

@@ -162,4 +162,58 @@ void main() {
 
   final area = geodesy.calculatePolygonWithHolesArea(outerPolygon, holes);
   print("Area of polygon with holes: $area");
+
+  // Equirectangular approximation Calculation
+  final firstPoint = const LatLng(52.5200, 13.4050); // Berlin, Germany
+  final secondPoint = const LatLng(48.8566, 2.3522); // Paris, France
+
+  double equirectangularDistance =
+      geodesy.equirectangularDistance(firstPoint, secondPoint);
+  print(
+      '''Equirectangular Distance: ${equirectangularDistance.toStringAsFixed(2)} km
+      ''');
+
+  /// Calculate Spherical Law Of Cosines Distance
+  final bGPoint = const LatLng(52.5200, 13.4050); // Berlin, Germany
+  final pFPoint = const LatLng(48.8566, 2.3522); // Paris, France
+
+  double sLCDdistance = geodesy.sphericalLawOfCosinesDistance(bGPoint, pFPoint);
+  print(
+      '''Spherical Law of Cosines Distance: ${sLCDdistance.toStringAsFixed(2)} km
+      ''');
+
+  /// Geodetic Point Manipulation - Rhumb Line Destination Formula
+  final initialPoint = const LatLng(52.5200, 13.4050); // Berlin, Germany
+  final bearingDegrees = 45.0; // 45 degrees bearing (northeast)
+  final distanceKm = 100.0; // 100 kilometers distance
+
+  LatLng destinationPoints = geodesy.calculateDestinationPoint(
+      initialPoint, bearingDegrees, distanceKm);
+
+  print('Initial Point: ${initialPoint.latitude}, ${initialPoint.longitude}');
+  print('''Destination Point: ${destinationPoints.latitude}, 
+      ${destinationPoints.longitude}''');
+
+  /// Geodetic Point Manipulation - Midpoint between two points
+  final bgPoint1 = const LatLng(52.5200, 13.4050); // Berlin, Germany
+  final pFPoint2 = const LatLng(48.8566, 2.3522); // Paris, France
+
+  LatLng midPointBetweenTwoPoints =
+      geodesy.calculateMidpoint(bgPoint1, pFPoint2);
+
+  print('''Midpoint: ${midPointBetweenTwoPoints.latitude}, 
+      ${midPointBetweenTwoPoints.longitude}''');
+
+  /// Geodetic Point Manipulation - Calculate Point Along Great Circle
+  final startPoint = const LatLng(52.5200, 13.4050); // Berlin, Germany
+  final endPoint = const LatLng(48.8566, 2.3522); // Paris, France
+  final numPoints = 5; // Number of points along the arc
+
+  List<LatLng> arcPoints =
+      geodesy.calculatePointsAlongGreatCircle(startPoint, endPoint, numPoints);
+
+  print('Points along Great Circle Arc:');
+  for (var point in arcPoints) {
+    print('${point.latitude}, ${point.longitude}');
+  }
 }

lib/src/core/DistanceCalculations/equirectangular_distance.dart

@@ -0,0 +1,25 @@
+import '../core.dart';
+
+/// Equirectangular approximation Calculation
+class EquirectangularApproximation {
+  /// EquirectangularDistance function takes two LatLng objects representing the
+  /// latitude and longitude coordinates of two points. It calculates the
+  /// distance between the points using the Equirectangular
+  /// approximation formula and the Earth's radius.
+  static double equirectangularDistance(LatLng point1, LatLng point2) {
+    final double radius = 6371.0; // Earth's radius in kilometers
+
+    double lat1 = point1.latitude;
+    double lon1 = point1.longitude;
+    double lat2 = point2.latitude;
+    double lon2 = point2.longitude;
+
+    double x = (lon2 - lon1) * (radius * cos((lat1 + lat2) / 2));
+    double y = (lat2 - lat1) * radius;
+
+    // Calculate distance using Pythagorean theorem
+    double distance = sqrt(x * x + y * y);
+
+    return distance;
+  }
+}

lib/src/core/geo_points.dart renamed to lib/src/core/DistanceCalculations/geo_points.dart

@@ -1,8 +1,8 @@
-import 'core.dart';
+import '../core.dart';
 
 ///
 class GeoPoints {
-  /// Calculate the distance in meters between two geo points
+  /// Calculate the Distance in meters between two geo points
   static num distanceBetweenTwoGeoPoints(LatLng l1, LatLng l2, [num? radius]) {
     final R = radius ?? 6371e3;
     final num l1LatRadians = degToRadian(l1.latitude);

lib/src/core/DistanceCalculations/spherical_law_of_cosines_distance.dart

@@ -0,0 +1,25 @@
+import '../core.dart';
+
+/// Calculate Spherical Law Of Cosines Distance
+class SphericalLawOfCosines {
+  /// This function takes two LatLng objects representing the latitude and
+  /// longitude coordinates of two points. It calculates the distance
+  /// between the points using the Spherical Law of Cosines formula
+  /// and the Earth's radius.
+  static double sphericalLawOfCosinesDistance(LatLng point1, LatLng point2) {
+    final double radius = 6371.0; // Earth's radius in kilometers
+
+    double lat1 = (point1.latitude).toRadians();
+    double lon1 = (point1.longitude).toRadians();
+    double lat2 = (point2.latitude).toRadians();
+    double lon2 = (point2.longitude).toRadians();
+
+    double deltaLon = lon2 - lon1;
+
+    double distance =
+        acos(sin(lat1) * sin(lat2) + cos(lat1) * cos(lat2) * cos(deltaLon)) *
+            radius;
+
+    return distance;
+  }
+}