add map.identifyAtPoint and vectorLayer.identifyAtPoint

Author: fuzhenn

src/core/util/style.js

@@ -33,6 +33,11 @@ export function getGradientStamp(g) {
     return keys.join('_');
 }
 
+// back-compatibility alias
+export function getSymbolStamp(symbol, prefix) {
+    return getSymbolHash(symbol, prefix);
+}
+
 /**
  * Get stamp of a symbol
  * @param  {Object|Object[]} symbol symbol

src/layer/VectorLayer.js

@@ -6,6 +6,7 @@ import OverlayLayer from './OverlayLayer';
 import Painter from '../renderer/geometry/Painter';
 import CollectionPainter from '../renderer/geometry/CollectionPainter';
 import Coordinate from '../geo/Coordinate';
+import Point from '../geo/Point';
 import { LineString, Curve } from '../geometry';
 import PointExtent from '../geo/PointExtent';
 
@@ -81,23 +82,41 @@ class VectorLayer extends OverlayLayer {
      */
     identify(coordinate, options = {}) {
         const renderer = this.getRenderer();
-        // only iterate drawn geometries when onlyVisible is true.
-        if (options['onlyVisible'] && renderer && renderer.identify) {
-            return renderer.identify(coordinate, options);
-        }
         if (!(coordinate instanceof Coordinate)) {
             coordinate = new Coordinate(coordinate);
         }
-        return this._hitGeos(this._geoList, coordinate, options);
+        const cp = this.getMap().coordToContainerPoint(coordinate);
+        // only iterate drawn geometries when onlyVisible is true.
+        if (options['onlyVisible'] && renderer && renderer.identifyAtPoint) {
+            return renderer.identifyAtPoint(cp, options);
+        }
+        return this._hitGeos(this._geoList, cp, options);
+    }
+
+    /**
+     * Identify the geometries on the given container point
+     * @param  {maptalks.Point} point   - container point to identify
+     * @param  {Object} [options=null]  - options
+     * @param  {Object} [options.tolerance=0] - identify tolerance in pixel
+     * @param  {Object} [options.count=null]  - result count
+     * @return {Geometry[]} geometries identified
+     */
+    identifyAtPoint(point, options = {}) {
+        const renderer = this.getRenderer();
+        if (!(point instanceof Point)) {
+            point = new Point(point);
+        }
+        // only iterate drawn geometries when onlyVisible is true.
+        if (options['onlyVisible'] && renderer && renderer.identifyAtPoint) {
+            return renderer.identifyAtPoint(point, options);
+        }
+        return this._hitGeos(this._geoList, point, options);
     }
 
-    _hitGeos(geometries, coordinate, options = {}) {
+    _hitGeos(geometries, cp, options = {}) {
         const filter = options['filter'],
             tolerance = options['tolerance'],
             hits = [];
-        const map = this.getMap();
-        const point = map.coordToPoint(coordinate);
-        const cp = map._pointToContainerPoint(point, undefined, 0, point);
         for (let i = geometries.length - 1; i >= 0; i--) {
             const geo = geometries[i];
             if (!geo || !geo.isVisible() || !geo._getPainter() || !geo.options['interactive']) {

src/map/Map.Topo.js

@@ -1,6 +1,7 @@
 import { INTERNAL_LAYER_PREFIX } from '../core/Constants';
 import { extend, isString, isArrayHasData, pushIn } from '../core/util';
 import Coordinate from '../geo/Coordinate';
+import Point from '../geo/Point';
 import Map from './Map';
 
 /**
@@ -67,9 +68,48 @@ Map.include(/** @lends Map.prototype */ {
      *  });
      */
     identify: function (opts, callback) {
-        if (!opts) {
-            return this;
-        }
+        opts = opts || {};
+        const coordinate = new Coordinate(opts['coordinate']);
+        return this._identify(opts, callback, layer => layer.identify(coordinate, opts));
+    },
+
+    /**
+     * Identify the geometries on the given container point.
+     * @param {Object} opts - the identify options
+     * @param {Point} opts.containerPoint - container point to identify
+     * @param {Object}   opts.layers        - the layers to perform identify on.
+     * @param {Function} [opts.filter=null] - filter function of the result geometries, return false to exclude.
+     * @param {Number}   [opts.count=null]  - limit of the result count.
+     * @param {Number}   [opts.tolerance=0] - identify tolerance in pixel.
+     * @param {Boolean}  [opts.includeInternals=false] - whether to identify internal layers.
+     * @param {Boolean}  [opts.includeInvisible=false] - whether to identify invisible layers.
+     * @param {Function} callback           - the callback function using the result geometries as the parameter.
+     * @return {Map} this
+     * @example
+     * map.identifyAtPoint({
+     *      containerPoint: [200, 300],
+     *      layers: [layer]
+     *  },
+     *  geos => {
+     *      console.log(geos);
+     *  });
+     */
+    identifyAtPoint: function (opts, callback) {
+        opts = opts || {};
+        const containerPoint = new Point(opts['containerPoint']);
+        const coordinate = this.containerPointToCoord(containerPoint);
+        return this._identify(opts, callback, layer => {
+            if (layer.identifyAtPoint) {
+                return layer.identifyAtPoint(containerPoint, opts);
+            } else if (coordinate) {
+                return layer.identify(coordinate, opts);
+            } else {
+                return [];
+            }
+        });
+    },
+
+    _identify: function (opts, callback, fn) {
         const reqLayers = opts['layers'];
         if (!isArrayHasData(reqLayers)) {
             return this;
@@ -82,8 +122,7 @@ Map.include(/** @lends Map.prototype */ {
                 layers.push(reqLayers[i]);
             }
         }
-        const coordinate = new Coordinate(opts['coordinate']);
-        const options = extend({}, opts);
+
         const hits = [];
         for (let i = layers.length - 1; i >= 0; i--) {
             if (opts['count'] && hits.length >= opts['count']) {
@@ -93,7 +132,7 @@ Map.include(/** @lends Map.prototype */ {
             if (!layer || !layer.getMap() || (!opts['includeInvisible'] && !layer.isVisible()) || (!opts['includeInternals'] && layer.getId().indexOf(INTERNAL_LAYER_PREFIX) >= 0)) {
                 continue;
             }
-            const layerHits = layer.identify(coordinate, options);
+            const layerHits = fn(layer);
             if (layerHits) {
                 if (Array.isArray(layerHits)) {
                     pushIn(hits, layerHits);

src/map/handler/Map.GeometryEvents.js

@@ -228,7 +228,7 @@ class MapGeometryEventsHandler extends Handler {
                 return true;
             },
             'count': 1,
-            'coordinate': coordinate,
+            'containerPoint': containerPoint,
             'onlyVisible' : map.options['onlyVisibleGeometryEvents'],
             'layers': layers
         };
@@ -239,10 +239,10 @@ class MapGeometryEventsHandler extends Handler {
                 if (map.isInteracting()) {
                     return;
                 }
-                map.identify(identifyOptions, callback);
+                map.identifyAtPoint(identifyOptions, callback);
             });
         } else {
-            map.identify(identifyOptions, callback);
+            map.identifyAtPoint(identifyOptions, callback);
         }
 
         function fireGeometryEvent(geometries) {

src/renderer/layer/vectorlayer/VectorLayerCanvasRenderer.js

@@ -209,12 +209,12 @@ class VectorLayerRenderer extends OverlayLayerCanvasRenderer {
         this._displayExtent = extent2D;
     }
 
-    identify(coordinate, options = {}) {
+    identifyAtPoint(point, options = {}) {
         const geometries = this._geosToDraw;
         if (!geometries) {
             return [];
         }
-        return this.layer._hitGeos(geometries, coordinate, options);
+        return this.layer._hitGeos(geometries, point, options);
     }
 
     _updateMapStateCache() {