feat(pick): Gets tile coords when picking features

felt · Apr 1, 2022 · 5fe9682 · 5fe9682
1 parent 038929d
commit 5fe9682
Show file tree

Hide file tree

Showing 6 changed files with 59 additions and 13 deletions.
diff --git a/dist/protomaps.js b/dist/protomaps.js
@@ -3468,19 +3468,29 @@ var protomaps = (() => {
         };
         for (let [layer_name, layer_arr] of entry.data.entries()) {
           for (let feature of layer_arr) {
+            let intersectedFeature;
             if (feature.geomType == 1) {
               if (pointMinDistToPoints(center, feature.geom) < brushSize) {
-                retval.push({ feature, layerName: layer_name });
+                intersectedFeature = feature;
               }
             } else if (feature.geomType == 2) {
               if (pointMinDistToLines(center, feature.geom) < brushSize) {
-                retval.push({ feature, layerName: layer_name });
+                intersectedFeature = feature;
               }
             } else {
               if (pointInPolygon(center, feature.geom)) {
-                retval.push({ feature, layerName: layer_name });
+                intersectedFeature = feature;
               }
             }
+            if (intersectedFeature) {
+              retval.push({
+                feature: intersectedFeature,
+                layerName: layer_name,
+                tileX: tile_x,
+                tileY: tile_y,
+                zoom
+              });
+            }
           }
         }
       }

diff --git a/dist/protomaps.min.js b/dist/protomaps.min.js
diff --git a/dist/protomaps.module.js b/dist/protomaps.module.js
@@ -3393,19 +3393,29 @@ var TileCache = class {
       };
       for (let [layer_name, layer_arr] of entry.data.entries()) {
         for (let feature of layer_arr) {
+          let intersectedFeature;
           if (feature.geomType == 1) {
             if (pointMinDistToPoints(center, feature.geom) < brushSize) {
-              retval.push({ feature, layerName: layer_name });
+              intersectedFeature = feature;
             }
           } else if (feature.geomType == 2) {
             if (pointMinDistToLines(center, feature.geom) < brushSize) {
-              retval.push({ feature, layerName: layer_name });
+              intersectedFeature = feature;
             }
           } else {
             if (pointInPolygon(center, feature.geom)) {
-              retval.push({ feature, layerName: layer_name });
+              intersectedFeature = feature;
             }
           }
+          if (intersectedFeature) {
+            retval.push({
+              feature: intersectedFeature,
+              layerName: layer_name,
+              tileX: tile_x,
+              tileY: tile_y,
+              zoom
+            });
+          }
         }
       }
     }

diff --git a/dist/tilecache.d.ts b/dist/tilecache.d.ts
@@ -53,6 +53,9 @@ export declare function pointMinDistToLines(point: Point, geom: Point[][]): numb
 export interface PickedFeature {
     feature: Feature;
     layerName: string;
+    tileX: number;
+    tileY: number;
+    zoom: number;
 }
 export declare class TileCache {
     source: TileSource;

diff --git a/dist/tilecache.js b/dist/tilecache.js
@@ -315,21 +315,31 @@ export class TileCache {
                     //  if ((query_bbox.maxX >= feature.bbox.minX && feature.bbox.maxX >= query_bbox.minX) &&
                     //      (query_bbox.maxY >= feature.bbox.minY && feature.bbox.maxY >= query_bbox.minY)) {
                     //  }
+                    let intersectedFeature;
                     if (feature.geomType == GeomType.Point) {
                         if (pointMinDistToPoints(center, feature.geom) < brushSize) {
-                            retval.push({ feature, layerName: layer_name });
+                            intersectedFeature = feature;
                         }
                     }
                     else if (feature.geomType == GeomType.Line) {
                         if (pointMinDistToLines(center, feature.geom) < brushSize) {
-                            retval.push({ feature, layerName: layer_name });
+                            intersectedFeature = feature;
                         }
                     }
                     else {
                         if (pointInPolygon(center, feature.geom)) {
-                            retval.push({ feature, layerName: layer_name });
+                            intersectedFeature = feature;
                         }
                     }
+                    if (intersectedFeature) {
+                        retval.push({
+                            feature: intersectedFeature,
+                            layerName: layer_name,
+                            tileX: tile_x,
+                            tileY: tile_y,
+                            zoom,
+                        });
+                    }
                 }
             }
         }

diff --git a/src/tilecache.ts b/src/tilecache.ts
@@ -339,6 +339,9 @@ export function pointMinDistToLines(point: Point, geom: Point[][]): number {
 export interface PickedFeature {
   feature: Feature;
   layerName: string;
+  tileX: number;
+  tileY: number;
+  zoom: number;
 }
 
 export class TileCache {
@@ -385,19 +388,29 @@ export class TileCache {
           //      (query_bbox.maxY >= feature.bbox.minY && feature.bbox.maxY >= query_bbox.minY)) {
           //  }
 
+          let intersectedFeature;
           if (feature.geomType == GeomType.Point) {
             if (pointMinDistToPoints(center, feature.geom) < brushSize) {
-              retval.push({ feature, layerName: layer_name });
+              intersectedFeature = feature;
             }
           } else if (feature.geomType == GeomType.Line) {
             if (pointMinDistToLines(center, feature.geom) < brushSize) {
-              retval.push({ feature, layerName: layer_name });
+              intersectedFeature = feature;
             }
           } else {
             if (pointInPolygon(center, feature.geom)) {
-              retval.push({ feature, layerName: layer_name });
+              intersectedFeature = feature;
             }
           }
+          if (intersectedFeature) {
+            retval.push({
+              feature: intersectedFeature,
+              layerName: layer_name,
+              tileX: tile_x,
+              tileY: tile_y,
+              zoom,
+            });
+          }
         }
       }
     }