feat!: migrate Point<double> to Offset internally

benchmark/crs.dart

@@ -1,5 +1,5 @@
 import 'dart:async';
-import 'dart:math' as math;
+import 'dart:ui';
 
 import 'package:flutter_map/src/geo/crs.dart';
 import 'package:latlong2/latlong.dart';
@@ -55,8 +55,8 @@ Future<void> main() async {
     for (int i = 0; i < N; ++i) {
       final latlng = LatLng((i % 90).toDouble(), (i % 180).toDouble());
       final p = crs.latLngToPoint(latlng, 1);
-      x += p.x;
-      y += p.y;
+      x += p.dx;
+      y += p.dy;
     }
     return x + y;
   }));
@@ -85,8 +85,8 @@ Future<void> main() async {
       for (int i = 0; i < N; ++i) {
         final latlng = LatLng((i % 90).toDouble(), (i % 180).toDouble());
         final point = crs.latLngToPoint(latlng, 1);
-        x += point.x;
-        y += point.y;
+        x += point.dx;
+        y += point.dy;
       }
       return x + y;
     }));
@@ -95,7 +95,7 @@ Future<void> main() async {
       double x = 0;
       double y = 0;
       for (int i = 0; i < N; ++i) {
-        final latlng = crs.pointToLatLng(math.Point<double>(x, y), 1);
+        final latlng = crs.pointToLatLng(Offset(x, y), 1);
         x += latlng.longitude;
         y += latlng.latitude;
       }

benchmark/point_in_polygon.dart

@@ -49,7 +49,7 @@ Future<void> main() async {
   final circle = makeCircle(1000, 1, 0);
 
   results.add(await timedRun('In circle', () {
-    const point = math.Point(0, 0);
+    const point = Offset.zero;
 
     bool yesPlease = true;
     for (int i = 0; i < N; ++i) {
@@ -61,7 +61,7 @@ Future<void> main() async {
   }));
 
   results.add(await timedRun('Not in circle', () {
-    const point = math.Point(4, 4);
+    const point = Offset(4, 4);
 
     bool noSir = false;
     for (int i = 0; i < N; ++i) {

example/lib/pages/latlng_to_screen_point.dart

@@ -1,5 +1,3 @@
-import 'dart:math';
-
 import 'package:flutter/material.dart';
 import 'package:flutter/scheduler.dart';
 import 'package:flutter_map/flutter_map.dart';
@@ -23,7 +21,7 @@ class _LatLngToScreenPointPageState extends State<LatLngToScreenPointPage> {
   final mapController = MapController();
 
   LatLng? tappedCoords;
-  Point<double>? tappedPoint;
+  Offset? tappedPoint;
 
   @override
   void initState() {
@@ -52,8 +50,8 @@ class _LatLngToScreenPointPageState extends State<LatLngToScreenPointPage> {
               ),
               onTap: (_, latLng) {
                 final point = mapController.camera
-                    .latLngToScreenPoint(tappedCoords = latLng);
-                setState(() => tappedPoint = Point(point.x, point.y));
+                    .latLngToScreenOffset(tappedCoords = latLng);
+                setState(() => tappedPoint = Offset(point.dx, point.dy));
               },
             ),
             children: [
@@ -77,8 +75,8 @@ class _LatLngToScreenPointPageState extends State<LatLngToScreenPointPage> {
           ),
           if (tappedPoint != null)
             Positioned(
-              left: tappedPoint!.x - 60 / 2,
-              top: tappedPoint!.y - 60 / 2,
+              left: tappedPoint!.dx - 60 / 2,
+              top: tappedPoint!.dy - 60 / 2,
               child: const IgnorePointer(
                 child: Icon(
                   Icons.center_focus_strong_outlined,

example/lib/pages/screen_point_to_latlng.dart

@@ -1,5 +1,3 @@
-import 'dart:math';
-
 import 'package:flutter/material.dart';
 import 'package:flutter_map/flutter_map.dart';
 import 'package:flutter_map_example/misc/tile_providers.dart';
@@ -96,7 +94,7 @@ class PointToLatlngPage extends State<ScreenPointToLatLngPage> {
   }
 
   void updatePoint(BuildContext context) => setState(() => latLng =
-      mapController.camera.pointToLatLng(Point(_getPointX(context), pointY)));
+      mapController.camera.pointToLatLng(Offset(_getPointX(context), pointY)));
 
   double _getPointX(BuildContext context) =>
       MediaQuery.sizeOf(context).width / 2;

lib/src/geo/crs.dart

@@ -1,5 +1,6 @@
 import 'dart:math' as math hide Point;
 import 'dart:math' show Point;
+import 'dart:ui';
 
 import 'package:flutter_map/src/misc/bounds.dart';
 import 'package:latlong2/latlong.dart';
@@ -51,13 +52,13 @@ abstract class Crs {
   (double, double) latLngToXY(LatLng latlng, double scale);
 
   /// Similar to [latLngToXY] but converts the XY coordinates to a [Point].
-  Point<double> latLngToPoint(LatLng latlng, double zoom) {
+  Offset latLngToPoint(LatLng latlng, double zoom) {
     final (x, y) = latLngToXY(latlng, scale(zoom));
-    return Point<double>(x, y);
+    return Offset(x, y);
   }
 
   /// Converts a map point to the sphere coordinate (at a certain zoom).
-  LatLng pointToLatLng(Point point, double zoom);
+  LatLng pointToLatLng(Offset point, double zoom);
 
   /// Zoom to Scale function.
   double scale(double zoom) => 256.0 * math.pow(2, zoom);
@@ -107,10 +108,10 @@ abstract class CrsWithStaticTransformation extends Crs {
   }
 
   @override
-  LatLng pointToLatLng(Point point, double zoom) {
+  LatLng pointToLatLng(Offset point, double zoom) {
     final (x, y) = _transformation.untransform(
-      point.x.toDouble(),
-      point.y.toDouble(),
+      point.dx,
+      point.dy,
       scale(zoom),
     );
     return projection.unprojectXY(x, y);
@@ -170,13 +171,13 @@ class Epsg3857 extends CrsWithStaticTransformation {
       );
 
   @override
-  Point<double> latLngToPoint(LatLng latlng, double zoom) {
+  Offset latLngToPoint(LatLng latlng, double zoom) {
     final (x, y) = _transformation.transform(
       SphericalMercator.projectLng(latlng.longitude),
       SphericalMercator.projectLat(latlng.latitude),
       scale(zoom),
     );
-    return Point<double>(x, y);
+    return Offset(x, y);
   }
 
   @override
@@ -281,10 +282,10 @@ class Proj4Crs extends Crs {
 
   /// Converts a map point to the sphere coordinate (at a certain zoom).
   @override
-  LatLng pointToLatLng(Point point, double zoom) {
+  LatLng pointToLatLng(Offset point, double zoom) {
     final (x, y) = _getTransformationByZoom(zoom).untransform(
-      point.x.toDouble(),
-      point.y.toDouble(),
+      point.dx,
+      point.dy,
       scale(zoom),
     );
     return projection.unprojectXY(x, y);

lib/src/gestures/map_interactive_viewer.dart

@@ -403,7 +403,7 @@ class MapInteractiveViewerState extends State<MapInteractiveViewer>
               .clamp(minZoom, maxZoom);
           // Calculate offset of mouse cursor from viewport center
           final newCenter = _camera.focusedZoomCenter(
-            pointerSignal.localPosition.toPoint(),
+            pointerSignal.localPosition,
             newZoom,
           );
           widget.controller.moveRaw(
@@ -636,7 +636,7 @@ class MapInteractiveViewerState extends State<MapInteractiveViewer>
     final zoomDifference = oldFocalPt - newFocalPt;
     final moveDifference = _rotateOffset(_focalStartLocal - _lastFocalLocal);
 
-    final newCenterPt = oldCenterPt + zoomDifference + moveDifference.toPoint();
+    final newCenterPt = oldCenterPt + zoomDifference + moveDifference;
     return _camera.unproject(newCenterPt, zoomAfterPinchZoom);
   }
 
@@ -728,9 +728,9 @@ class MapInteractiveViewerState extends State<MapInteractiveViewer>
     }
 
     final direction = details.velocity.pixelsPerSecond / magnitude;
-    final distance =
-        (Offset.zero & Size(_camera.nonRotatedSize.x, _camera.nonRotatedSize.y))
-            .shortestSide;
+    final distance = (Offset.zero &
+            Size(_camera.nonRotatedSize.dx, _camera.nonRotatedSize.dy))
+        .shortestSide;
 
     final flingOffset = _focalStartLocal - _lastFocalLocal;
     _flingAnimation = Tween<Offset>(
@@ -803,7 +803,7 @@ class MapInteractiveViewerState extends State<MapInteractiveViewer>
     if (InteractiveFlag.hasDoubleTapZoom(_interactionOptions.flags)) {
       final newZoom = _getZoomForScale(_camera.zoom, 2);
       final newCenter = _camera.focusedZoomCenter(
-        tapPosition.relative!.toPoint(),
+        tapPosition.relative!,
         newZoom,
       );
       _startDoubleTapAnimation(newZoom, newCenter);
@@ -882,19 +882,20 @@ class MapInteractiveViewerState extends State<MapInteractiveViewer>
     }
 
     final newCenterPoint = _camera.project(_mapCenterStart) +
-        _flingAnimation.value.toPoint().rotate(_camera.rotationRad);
+        _flingAnimation.value.rotate(_camera.rotationRad);
     final LatLng newCenter;
     if (!_camera.crs.replicatesWorldLongitude) {
       newCenter = _camera.unproject(newCenterPoint);
     } else {
-      final math.Point<double> bestCenterPoint;
+      final Offset bestCenterPoint;
       final double worldSize = _camera.crs.scale(_camera.zoom);
-      if (newCenterPoint.x > worldSize) {
+      // TODO there has to be an easier way to write this code...
+      if (newCenterPoint.dx > worldSize) {
         bestCenterPoint =
-            math.Point(newCenterPoint.x - worldSize, newCenterPoint.y);
-      } else if (newCenterPoint.x < 0) {
+            Offset(newCenterPoint.dx - worldSize, newCenterPoint.dy);
+      } else if (newCenterPoint.dx < 0) {
         bestCenterPoint =
-            math.Point(newCenterPoint.x + worldSize, newCenterPoint.y);
+            Offset(newCenterPoint.dx + worldSize, newCenterPoint.dy);
       } else {
         bestCenterPoint = newCenterPoint;
       }

lib/src/layer/circle_layer/circle_layer.dart

@@ -36,7 +36,7 @@ class CircleLayer<R extends Object> extends StatelessWidget {
           camera: camera,
           hitNotifier: hitNotifier,
         ),
-        size: Size(camera.size.x, camera.size.y),
+        size: Size(camera.size.dx, camera.size.dy),
         isComplex: true,
       ),
     );

lib/src/layer/circle_layer/painter.dart

@@ -20,7 +20,7 @@ base class CirclePainter<R extends Object>
   @override
   bool elementHitTest(
     CircleMarker<R> element, {
-    required Point<double> point,
+    required Offset point,
     required LatLng coordinate,
   }) {
     final circle = element; // Should be optimized out by compiler, avoids lint
@@ -33,7 +33,7 @@ base class CirclePainter<R extends Object>
             .distance
         : circle.radius;
 
-    return pow(point.x - center.dx, 2) + pow(point.y - center.dy, 2) <=
+    return pow(point.dx - center.dx, 2) + pow(point.dy - center.dy, 2) <=
         radius * radius;
   }
 

lib/src/layer/marker_layer/marker_layer.dart

@@ -60,10 +60,12 @@ class MarkerLayer extends StatelessWidget {
             // Cull if out of bounds
             if (!map.pixelBounds.containsPartialBounds(
               Bounds(
-                Point(pxPoint.x + left, pxPoint.y - bottom),
-                Point(pxPoint.x - right, pxPoint.y + top),
+                Point(pxPoint.dx + left, pxPoint.dy - bottom),
+                Point(pxPoint.dx - right, pxPoint.dy + top),
               ),
-            )) continue;
+            )) {
+              continue;
+            }
 
             // Apply map camera to marker position
             final pos = pxPoint - map.pixelOrigin;
@@ -72,8 +74,8 @@ class MarkerLayer extends StatelessWidget {
               key: m.key,
               width: m.width,
               height: m.height,
-              left: pos.x - right,
-              top: pos.y - bottom,
+              left: pos.dx - right,
+              top: pos.dy - bottom,
               child: (m.rotate ?? rotate)
                   ? Transform.rotate(
                       angle: -map.rotationRad,

lib/src/layer/overlay_image_layer/overlay_image.dart

@@ -83,8 +83,8 @@ class OverlayImage extends BaseOverlayImage {
 
     // northWest is not necessarily upperLeft depending on projection
     final bounds = Bounds<double>(
-      camera.project(this.bounds.northWest) - camera.pixelOrigin,
-      camera.project(this.bounds.southEast) - camera.pixelOrigin,
+      (camera.project(this.bounds.northWest) - camera.pixelOrigin).toPoint(),
+      (camera.project(this.bounds.southEast) - camera.pixelOrigin).toPoint(),
     );
 
     return Positioned(
@@ -145,20 +145,20 @@ class RotatedOverlayImage extends BaseOverlayImage {
     final pxTopRight = pxTopLeft - pxBottomLeft + pxBottomRight;
 
     /// update/enlarge bounds so the new corner points fit within
-    final bounds = Bounds<double>(pxTopLeft, pxBottomRight)
-        .extend(pxTopRight)
-        .extend(pxBottomLeft);
+    final bounds = Bounds<double>(pxTopLeft.toPoint(), pxBottomRight.toPoint())
+        .extend(pxTopRight.toPoint())
+        .extend(pxBottomLeft.toPoint());
 
     final vectorX = (pxTopRight - pxTopLeft) / bounds.size.x;
     final vectorY = (pxBottomLeft - pxTopLeft) / bounds.size.y;
-    final offset = pxTopLeft - bounds.topLeft;
-
-    final a = vectorX.x;
-    final b = vectorX.y;
-    final c = vectorY.x;
-    final d = vectorY.y;
-    final tx = offset.x;
-    final ty = offset.y;
+    final offset = pxTopLeft - bounds.topLeft.toOffset();
+
+    final a = vectorX.dx;
+    final b = vectorX.dy;
+    final c = vectorY.dx;
+    final d = vectorY.dy;
+    final tx = offset.dx;
+    final ty = offset.dy;
 
     return Positioned(
       left: bounds.topLeft.x,

lib/src/layer/polygon_layer/label.dart

@@ -1,7 +1,7 @@
 part of 'polygon_layer.dart';
 
 void Function(Canvas canvas)? _buildLabelTextPainter({
-  required math.Point<double> mapSize,
+  required Offset mapSize,
   required Offset placementPoint,
   required ({Offset min, Offset max}) bounds,
   required TextPainter textPainter,
@@ -18,10 +18,10 @@ void Function(Canvas canvas)? _buildLabelTextPainter({
   // Currently this is only enabled when the map isn't rotated, since the placementOffset
   // is relative to the MobileLayerTransformer rather than in actual screen coordinates.
   if (rotationRad == 0) {
-    if (dx + width / 2 < 0 || dx - width / 2 > mapSize.x) {
+    if (dx + width / 2 < 0 || dx - width / 2 > mapSize.dx) {
       return null;
     }
-    if (dy + height / 2 < 0 || dy - height / 2 > mapSize.y) {
+    if (dy + height / 2 < 0 || dy - height / 2 > mapSize.dy) {
       return null;
     }
   }
@@ -77,8 +77,8 @@ LatLng _computeCentroid(List<LatLng> points) {
 LatLng _computePolylabel(List<LatLng> points) {
   final labelPosition = polylabel(
     [
-      List<math.Point>.generate(points.length,
-          (i) => math.Point(points[i].longitude, points[i].latitude)),
+      List<Point<double>>.generate(points.length,
+          (i) => Point<double>(points[i].longitude, points[i].latitude)),
     ],
     // "precision" is a bit of a misnomer. It's a threshold for when to stop
     // dividing-and-conquering the polygon in the hopes of finding a better

lib/src/layer/polygon_layer/painter.dart

@@ -49,7 +49,7 @@ base class _PolygonPainter<R extends Object>
   @override
   bool elementHitTest(
     _ProjectedPolygon<R> projectedPolygon, {
-    required math.Point<double> point,
+    required Offset point,
     required LatLng coordinate,
   }) {
     // TODO: We should check the bounding box here, for efficiency
@@ -193,7 +193,7 @@ base class _PolygonPainter<R extends Object>
       lastHash = null;
     }
 
-    final origin = (camera.project(camera.center) - camera.size / 2).toOffset();
+    final origin = camera.project(camera.center) - camera.size / 2;
 
     // Main loop constructing batched fill and border paths from given polygons.
     for (int i = 0; i <= polygons.length - 1; i++) {