allow annotation bounds filtering by type

mapbox · Jun 1, 2015 · da01318 · da01318
1 parent b51f5e8
commit da01318
Show file tree

Hide file tree

Showing 5 changed files with 40 additions and 14 deletions.
diff --git a/include/mbgl/map/map.hpp b/include/mbgl/map/map.hpp
@@ -28,6 +28,12 @@ namespace util {
 template <class T> class Thread;
 }
 
+enum class AnnotationType : uint8_t {
+    Any   = 0,
+    Point = 1 << 0,
+    Shape = 1 << 1,
+};
+
 using AnnotationIDs = std::vector<uint32_t>;
 using AnnotationSegment = std::vector<LatLng>;
 using AnnotationSegments = std::vector<AnnotationSegment>;
@@ -130,7 +136,7 @@ class Map : private util::noncopyable {
                                       const std::vector<StyleProperties>&);
     void removeAnnotation(uint32_t);
     void removeAnnotations(const AnnotationIDs&);
-    AnnotationIDs getAnnotationsInBounds(const LatLngBounds&);
+    AnnotationIDs getAnnotationsInBounds(const LatLngBounds&, const AnnotationType& = AnnotationType::Any);
     LatLngBounds getBoundsForAnnotations(const AnnotationIDs&);
 
     // Memory

diff --git a/platform/ios/MGLMapView.mm b/platform/ios/MGLMapView.mm
@@ -1011,7 +1011,7 @@ - (void)handleSingleTapGesture:(UITapGestureRecognizer *)singleTap
         tapBounds.extend(coordinateToLatLng(coordinate));
 
         // query for nearby annotations
-        std::vector<uint32_t> nearbyAnnotations = _mbglMap->getAnnotationsInBounds(tapBounds);
+        std::vector<uint32_t> nearbyAnnotations = _mbglMap->getAnnotationsInBounds(tapBounds, mbgl::AnnotationType::Point);
 
         int32_t newSelectedAnnotationID = -1;
 

diff --git a/src/mbgl/map/annotation.cpp b/src/mbgl/map/annotation.cpp
@@ -20,6 +20,7 @@ Annotation::Annotation(AnnotationType type_,
       geometry(geometry_),
       bounds([this] {
           LatLngBounds bounds_;
+          assert(type != AnnotationType::Any);
           if (type == AnnotationType::Point) {
               bounds_ = { getPoint(), getPoint() };
           } else {
@@ -85,6 +86,8 @@ AnnotationManager::addAnnotations(const AnnotationType type,
                                   const MapData& data) {
     std::lock_guard<std::mutex> lock(mtx);
 
+    assert(type != AnnotationType::Any);
+
     // We pre-generate tiles to contain each annotation up to the map's max zoom.
     // We do this for fast rendering without projection conversions on the fly, as well as
     // to simplify bounding box queries of annotations later. Tiles get invalidated when
@@ -186,6 +189,8 @@ AnnotationManager::addTileFeature(const uint32_t annotationID,
                                   const std::unordered_map<std::string, std::string>& featureProperties,
                                   const uint8_t maxZoom) {
 
+    assert(type != AnnotationType::Any);
+
     // track the annotation global ID and its original geometry
     auto anno_it = annotations.emplace(annotationID,
         util::make_unique<Annotation>(type, segments, styleProperties));
@@ -394,7 +399,8 @@ const std::unique_ptr<Annotation>& AnnotationManager::getAnnotationWithID(uint32
 }
 
 AnnotationIDs AnnotationManager::getAnnotationsInBounds(const LatLngBounds& queryBounds,
-                                                        const MapData& data) const {
+                                                        const MapData& data,
+                                                        const AnnotationType& type) const {
     std::lock_guard<std::mutex> lock(mtx);
 
     const uint8_t z = data.transform.getMaxZoom();
@@ -414,9 +420,22 @@ AnnotationIDs AnnotationManager::getAnnotationsInBounds(const LatLngBounds& quer
             if (id.x >= nwTile.x && id.x <= seTile.x && id.y >= nwTile.y && id.y <= seTile.y) {
                 if (id.x > nwTile.x && id.x < seTile.x && id.y > nwTile.y && id.y < seTile.y) {
                     // Trivial accept; this tile is completely inside the query bounds, so
-                    // we'll return all of its annotations.
-                    std::copy(tile.second.first.begin(), tile.second.first.end(),
-                              std::inserter(matchingAnnotations, matchingAnnotations.begin()));
+                    // we'll return all of its annotations that match type (if specified).
+                    if (type != AnnotationType::Any) {
+                        std::copy_if(tile.second.first.begin(), tile.second.first.end(),
+                                     std::inserter(matchingAnnotations, matchingAnnotations.begin()),
+                                     [&](const uint32_t annotationID) -> bool {
+                            const auto it = annotations.find(annotationID);
+                            if (it != annotations.end()) {
+                                return (it->second->type == type);
+                            } else {
+                                return false;
+                            }
+                        });
+                    } else {
+                        std::copy(tile.second.first.begin(), tile.second.first.end(),
+                                  std::inserter(matchingAnnotations, matchingAnnotations.begin()));
+                    }
                 } else {
                     // This tile is intersected by the query bounds. We need to check the
                     // tile's annotations' bounding boxes individually.
@@ -425,6 +444,12 @@ AnnotationIDs AnnotationManager::getAnnotationsInBounds(const LatLngBounds& quer
                                  [&](const uint32_t annotationID) -> bool {
                         const auto it = annotations.find(annotationID);
                         if (it != annotations.end()) {
+                            // check type
+                            if (type != AnnotationType::Any && it->second->type != type) {
+                                return false;
+                            }
+
+                            // check bounds
                             const LatLngBounds annoBounds = it->second->getBounds();
                             return (annoBounds.sw.latitude >= queryBounds.sw.latitude &&
                                     annoBounds.ne.latitude <= queryBounds.ne.latitude &&

diff --git a/src/mbgl/map/annotation.hpp b/src/mbgl/map/annotation.hpp
@@ -28,11 +28,6 @@ class MapData;
 
 using AnnotationsProperties = std::unordered_map<std::string, std::vector<std::string>>;
 
-enum class AnnotationType : uint8_t {
-    Point,
-    Shape
-};
-
 class Annotation : private util::noncopyable {
     friend class AnnotationManager;
 public:
@@ -73,7 +68,7 @@ class AnnotationManager : private util::noncopyable {
     std::unordered_set<TileID, TileID::Hash> removeAnnotations(const AnnotationIDs&, const MapData&);
     AnnotationIDs getOrderedShapeAnnotations() const { return orderedShapeAnnotations; }
     const std::unique_ptr<Annotation>& getAnnotationWithID(uint32_t) const;
-    AnnotationIDs getAnnotationsInBounds(const LatLngBounds&, const MapData&) const;
+    AnnotationIDs getAnnotationsInBounds(const LatLngBounds&, const MapData&, const AnnotationType& = AnnotationType::Any) const;
     LatLngBounds getBoundsForAnnotations(const AnnotationIDs&) const;
 
     const LiveTile* getTile(const TileID& id);

diff --git a/src/mbgl/map/map.cpp b/src/mbgl/map/map.cpp
@@ -281,8 +281,8 @@ void Map::removeAnnotations(const std::vector<uint32_t>& annotations) {
     context->invoke(&MapContext::updateAnnotationTiles, result);
 }
 
-std::vector<uint32_t> Map::getAnnotationsInBounds(const LatLngBounds& bounds) {
-    return data->annotationManager.getAnnotationsInBounds(bounds, *data);
+std::vector<uint32_t> Map::getAnnotationsInBounds(const LatLngBounds& bounds, const AnnotationType& type) {
+    return data->annotationManager.getAnnotationsInBounds(bounds, *data, type);
 }
 
 LatLngBounds Map::getBoundsForAnnotations(const std::vector<uint32_t>& annotations) {