Render only visible items on the map

demo/AndroidManifest.xml

@@ -53,6 +53,7 @@
         <activity android:name=".DistanceDemoActivity"/>
         <activity android:name=".ClusteringDemoActivity"/>
         <activity android:name=".BigClusteringDemoActivity"/>
+        <activity android:name=".VisibleClusteringDemoActivity"/>
         <activity android:name=".CustomMarkerClusteringDemoActivity"/>
         <activity android:name=".TileProviderAndProjectionDemo"/>
         <activity android:name=".HeatmapsDemoActivity"/>

demo/src/com/google/maps/android/utils/demo/MainActivity.java

@@ -20,6 +20,7 @@ protected void onCreate(Bundle savedInstanceState) {
         addDemo("Clustering", ClusteringDemoActivity.class);
         addDemo("Clustering: Custom Look", CustomMarkerClusteringDemoActivity.class);
         addDemo("Clustering: 2K markers", BigClusteringDemoActivity.class);
+        addDemo("Clustering: 20k only visible markers", VisibleClusteringDemoActivity.class);
         addDemo("PolyUtil.decode", PolyDecodeDemoActivity.class);
         addDemo("IconGenerator", IconGeneratorDemoActivity.class);
         addDemo("SphericalUtil.computeDistanceBetween", DistanceDemoActivity.class);

demo/src/com/google/maps/android/utils/demo/VisibleClusteringDemoActivity.java

@@ -0,0 +1,54 @@
+package com.google.maps.android.utils.demo;
+
+import android.util.DisplayMetrics;
+import android.widget.Toast;
+
+import com.google.android.gms.maps.CameraUpdateFactory;
+import com.google.android.gms.maps.model.LatLng;
+import com.google.maps.android.clustering.ClusterManager;
+import com.google.maps.android.clustering.algo.VisibleNonHierarchicalDistanceBasedAlgorithm;
+import com.google.maps.android.utils.demo.model.MyItem;
+
+import org.json.JSONException;
+
+import java.io.InputStream;
+import java.util.List;
+
+public class VisibleClusteringDemoActivity extends BaseDemoActivity {
+    private ClusterManager<MyItem> mClusterManager;
+
+    @Override
+    protected void startDemo() {
+        DisplayMetrics metrics = new DisplayMetrics();
+        getWindowManager().getDefaultDisplay().getMetrics(metrics);
+
+        getMap().moveCamera(CameraUpdateFactory.newLatLngZoom(new LatLng(51.503186, -0.126446), 10));
+
+        mClusterManager = new ClusterManager<MyItem>(this, getMap());
+        mClusterManager.setClusterOnlyVisibleArea(true);
+        mClusterManager.setAlgorithm(new VisibleNonHierarchicalDistanceBasedAlgorithm<MyItem>(metrics.widthPixels, metrics.heightPixels));
+
+        getMap().setOnCameraChangeListener(mClusterManager);
+
+        try {
+            readItems();
+        } catch (JSONException e) {
+            Toast.makeText(this, "Problem reading list of markers.", Toast.LENGTH_LONG).show();
+        }
+    }
+
+    private void readItems() throws JSONException {
+        InputStream inputStream = getResources().openRawResource(R.raw.radar_search);
+        List<MyItem> items = new MyItemReader().read(inputStream);
+        for (int i = 0; i < 100; i++) {
+            double offset = i / 60d;
+            for (MyItem item : items) {
+                LatLng position = item.getPosition();
+                double lat = position.latitude + offset;
+                double lng = position.longitude + offset;
+                MyItem offsetItem = new MyItem(lat, lng);
+                mClusterManager.addItem(offsetItem);
+            }
+        }
+    }
+}

library/src/com/google/maps/android/clustering/ClusterManager.java

@@ -43,6 +43,7 @@ public class ClusterManager<T extends ClusterItem> implements GoogleMap.OnCamera
     private OnClusterInfoWindowClickListener<T> mOnClusterInfoWindowClickListener;
     private OnClusterItemInfoWindowClickListener<T> mOnClusterItemInfoWindowClickListener;
     private OnClusterClickListener<T> mOnClusterClickListener;
+    private boolean mShowOnlyVisibleArea;
 
     public ClusterManager(Context context, GoogleMap map) {
         this(context, map, new MarkerManager(map));
@@ -92,13 +93,23 @@ public void setAlgorithm(Algorithm<T> algorithm) {
             if (mAlgorithm != null) {
                 algorithm.addItems(mAlgorithm.getItems());
             }
-            mAlgorithm = new PreCachingAlgorithmDecorator<T>(algorithm);
+
+            mAlgorithm = algorithm;
         } finally {
             mAlgorithmLock.writeLock().unlock();
         }
+
+        if (mAlgorithm instanceof GoogleMap.OnCameraChangeListener) {
+            ((GoogleMap.OnCameraChangeListener) mAlgorithm).onCameraChange(mMap.getCameraPosition());
+        }
+
         cluster();
     }
 
+    public void setClusterOnlyVisibleArea(boolean onlyVisibleArea) {
+        mShowOnlyVisibleArea = onlyVisibleArea;
+    }
+
     public void clearItems() {
         mAlgorithmLock.writeLock().lock();
         try {
@@ -166,14 +177,18 @@ public void onCameraChange(CameraPosition cameraPosition) {
             ((GoogleMap.OnCameraChangeListener) mRenderer).onCameraChange(cameraPosition);
         }
 
-        // Don't re-compute clusters if the map has just been panned/tilted/rotated.
-        CameraPosition position = mMap.getCameraPosition();
-        if (mPreviousCameraPosition != null && mPreviousCameraPosition.zoom == position.zoom) {
-            return;
+        if (mAlgorithm instanceof GoogleMap.OnCameraChangeListener) {
+            ((GoogleMap.OnCameraChangeListener) mAlgorithm).onCameraChange(cameraPosition);
         }
-        mPreviousCameraPosition = mMap.getCameraPosition();
 
-        cluster();
+        // Don't re-compute clusters if the map has just been panned/tilted/rotated.
+        if (mShowOnlyVisibleArea) {
+            // algorithm will decide if it is need to recompute clusters
+            cluster();
+        } else if (mPreviousCameraPosition == null || mPreviousCameraPosition.zoom != cameraPosition.zoom) {
+            mPreviousCameraPosition = mMap.getCameraPosition();
+            cluster();
+        }
     }
 
     @Override

library/src/com/google/maps/android/clustering/algo/VisibleNonHierarchicalDistanceBasedAlgorithm.java

@@ -0,0 +1,224 @@
+package com.google.maps.android.clustering.algo;
+
+import com.google.android.gms.maps.GoogleMap;
+import com.google.android.gms.maps.model.CameraPosition;
+import com.google.android.gms.maps.model.LatLng;
+import com.google.maps.android.clustering.Cluster;
+import com.google.maps.android.clustering.ClusterItem;
+import com.google.maps.android.geometry.Bounds;
+import com.google.maps.android.geometry.Point;
+import com.google.maps.android.projection.SphericalMercatorProjection;
+import com.google.maps.android.quadtree.PointQuadTree;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+/**
+ * A simple clustering algorithm with O(nlog n) performance. Resulting clusters are not
+ * hierarchical. This algorithm will compute clusters only in visible area.
+ * <p/>
+ * High level algorithm:<br>
+ * 1. Iterate over items in the order they were added (candidate clusters).<br>
+ * 2. Create a cluster with the center of the item. <br>
+ * 3. Add all items that are within a certain distance to the cluster. <br>
+ * 4. Move any items out of an existing cluster if they are closer to another cluster. <br>
+ * 5. Remove those items from the list of candidate clusters.
+ * <p/>
+ * Clusters have the center of the first element (not the centroid of the items within it).
+ */
+public class VisibleNonHierarchicalDistanceBasedAlgorithm<T extends ClusterItem>
+        implements Algorithm<T>, GoogleMap.OnCameraChangeListener {
+
+    public static final int MAX_DISTANCE_AT_ZOOM = 100; // essentially 100 dp.
+
+    /**
+     * Any modifications should be synchronized on mQuadTree.
+     */
+    private final Collection<QuadItem<T>> mItems = new ArrayList<QuadItem<T>>();
+
+    /**
+     * Any modifications should be synchronized on mQuadTree.
+     */
+    private final PointQuadTree<QuadItem<T>> mQuadTree = new PointQuadTree<QuadItem<T>>(0, 1, 0, 1);
+
+    private static final SphericalMercatorProjection PROJECTION = new SphericalMercatorProjection(1);
+    private final int mScreenWidth;
+    private final int mScreenHeight;
+    private LatLng mMapCenter;
+
+    public VisibleNonHierarchicalDistanceBasedAlgorithm(int screenWidth, int screenHeight) {
+        mScreenWidth = screenWidth;
+        mScreenHeight = screenHeight;
+    }
+
+    @Override
+    public void addItem(T item) {
+        final QuadItem<T> quadItem = new QuadItem<T>(item);
+        synchronized (mQuadTree) {
+            mItems.add(quadItem);
+            mQuadTree.add(quadItem);
+        }
+    }
+
+    @Override
+    public void addItems(Collection<T> items) {
+        for (T item : items) {
+            addItem(item);
+        }
+    }
+
+    @Override
+    public void clearItems() {
+        synchronized (mQuadTree) {
+            mItems.clear();
+            mQuadTree.clear();
+        }
+    }
+
+    @Override
+    public void removeItem(T item) {
+        // TODO: delegate QuadItem#hashCode and QuadItem#equals to its item.
+        throw new UnsupportedOperationException("VisibleNonHierarchicalDistanceBasedAlgorithm.remove not implemented");
+    }
+
+    @Override
+    public Set<? extends Cluster<T>> getClusters(double zoom) {
+        final int discreteZoom = (int) zoom;
+
+        final double zoomSpecificSpan = MAX_DISTANCE_AT_ZOOM / Math.pow(2, discreteZoom) / 256;
+
+        final Set<QuadItem<T>> visitedCandidates = new HashSet<QuadItem<T>>();
+        final Set<Cluster<T>> results = new HashSet<Cluster<T>>();
+        final Map<QuadItem<T>, Double> distanceToCluster = new HashMap<QuadItem<T>, Double>();
+        final Map<QuadItem<T>, StaticCluster<T>> itemToCluster = new HashMap<QuadItem<T>, StaticCluster<T>>();
+
+        synchronized (mQuadTree) {
+
+            Bounds visibleBounds = getVisibleBounds(discreteZoom);
+
+            Collection<QuadItem<T>> items = mQuadTree.search(visibleBounds);
+
+            for (QuadItem<T> candidate : items) {
+                if (visitedCandidates.contains(candidate)) {
+                    // Candidate is already part of another cluster.
+                    continue;
+                }
+
+                Bounds searchBounds = createBoundsFromSpan(candidate.getPoint(), zoomSpecificSpan);
+                Collection<QuadItem<T>> clusterItems;
+                clusterItems = mQuadTree.search(searchBounds);
+                if (clusterItems.size() == 1) {
+                    // Only the current marker is in range. Just add the single item to the results.
+                    results.add(candidate);
+                    visitedCandidates.add(candidate);
+                    distanceToCluster.put(candidate, 0d);
+                    continue;
+                }
+                StaticCluster<T> cluster = new StaticCluster<T>(candidate.mClusterItem.getPosition());
+                results.add(cluster);
+
+                for (QuadItem<T> clusterItem : clusterItems) {
+                    Double existingDistance = distanceToCluster.get(clusterItem);
+                    double distance = distanceSquared(clusterItem.getPoint(), candidate.getPoint());
+                    if (existingDistance != null) {
+                        // Item already belongs to another cluster. Check if it's closer to this cluster.
+                        if (existingDistance < distance) {
+                            continue;
+                        }
+                        // Move item to the closer cluster.
+                        itemToCluster.get(clusterItem).remove(clusterItem.mClusterItem);
+                    }
+                    distanceToCluster.put(clusterItem, distance);
+                    cluster.add(clusterItem.mClusterItem);
+                    itemToCluster.put(clusterItem, cluster);
+                }
+                visitedCandidates.addAll(clusterItems);
+            }
+        }
+        return results;
+    }
+
+    @Override
+    public Collection<T> getItems() {
+        final List<T> items = new ArrayList<T>();
+        synchronized (mQuadTree) {
+            for (QuadItem<T> quadItem : mItems) {
+                items.add(quadItem.mClusterItem);
+            }
+        }
+        return items;
+    }
+
+    private double distanceSquared(Point a, Point b) {
+        return (a.x - b.x) * (a.x - b.x) + (a.y - b.y) * (a.y - b.y);
+    }
+
+    private Bounds createBoundsFromSpan(Point p, double span) {
+        // TODO: Use a span that takes into account the visual size of the marker, not just its
+        // LatLng.
+        double halfSpan = span / 2;
+        return new Bounds(
+                p.x - halfSpan, p.x + halfSpan,
+                p.y - halfSpan, p.y + halfSpan);
+    }
+
+    private Bounds getVisibleBounds(int zoom) {
+        if (mMapCenter == null) {
+            return new Bounds(0, 0, 0, 0);
+        }
+
+        Point p = PROJECTION.toPoint(mMapCenter);
+
+        final double halfWidthSpan = mScreenWidth / Math.pow(2, zoom) / 256 / 2;
+        final double halfHeightSpan = mScreenHeight / Math.pow(2, zoom) / 256 / 2;
+
+        return new Bounds(
+                p.x - halfWidthSpan, p.x + halfWidthSpan,
+                p.y - halfHeightSpan, p.y + halfHeightSpan);
+    }
+
+    @Override
+    public void onCameraChange(CameraPosition cameraPosition) {
+        mMapCenter = cameraPosition.target;
+    }
+
+    private static class QuadItem<T extends ClusterItem> implements PointQuadTree.Item, Cluster<T> {
+        private final T mClusterItem;
+        private final Point mPoint;
+        private final LatLng mPosition;
+        private Set<T> singletonSet;
+
+        private QuadItem(T item) {
+            mClusterItem = item;
+            mPosition = item.getPosition();
+            mPoint = PROJECTION.toPoint(mPosition);
+            singletonSet = Collections.singleton(mClusterItem);
+        }
+
+        @Override
+        public Point getPoint() {
+            return mPoint;
+        }
+
+        @Override
+        public LatLng getPosition() {
+            return mPosition;
+        }
+
+        @Override
+        public Set<T> getItems() {
+            return singletonSet;
+        }
+
+        @Override
+        public int getSize() {
+            return 1;
+        }
+    }
+}