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]>
wingkwong · Sep 8, 2023 · 9bf0a10 · 9bf0a10
1 parent 6af10d5
commit 9bf0a10
Show file tree

Hide file tree

Showing 19 changed files with 480 additions and 26 deletions.
diff --git a/CHANGELOG.md b/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
diff --git a/README.md b/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).
diff --git a/doc/CLASS.md b/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);
 ```
 
 ---

diff --git a/doc/METHODS.md b/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.
diff --git a/example/example.dart b/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}');
+ }
 }
diff --git a/example/main.dart b/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}');
+ }
 }
diff --git a/lib/src/core/DistanceCalculations/equirectangular_distance.dart b/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;
+ }
+}
diff --git a/lib/src/core/geo_points.dart → ...core/DistanceCalculations/geo_points.dart b/lib/src/core/geo_points.dart → ...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);

diff --git a/lib/src/core/DistanceCalculations/spherical_law_of_cosines_distance.dart b/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;
+ }
+}