feat: refactored to create ContinuousZoomEuclideanCentroidAlgorithm.java

Author: kikoso

library/src/main/java/com/google/maps/android/clustering/algo/ContinuousZoomEuclideanAlgorithm.java

@@ -0,0 +1,68 @@
+/*
+ * Copyright 2025 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.google.maps.android.clustering.algo;
+
+import com.google.maps.android.clustering.ClusterItem;
+import com.google.maps.android.geometry.Bounds;
+import com.google.maps.android.quadtree.PointQuadTree;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.HashSet;
+import java.util.Set;
+
+/**
+ * A variant of {@link CentroidNonHierarchicalDistanceBasedAlgorithm} that uses
+ * continuous zoom scaling and Euclidean distance for clustering.
+ *
+ * <p>This class overrides {@link #getClusteringItems(PointQuadTree, float)} to compute
+ * clusters with a zoom-dependent radius, while keeping the centroid-based cluster positions.</p>
+ *
+ * @param <T> the type of cluster item
+ */
+public class ContinuousZoomEuclideanCentroidAlgorithm<T extends ClusterItem>
+        extends CentroidNonHierarchicalDistanceBasedAlgorithm<T> {
+
+    @Override
+    protected Collection<QuadItem<T>> getClusteringItems(PointQuadTree<QuadItem<T>> quadTree, float zoom) {
+        // Continuous zoom — no casting to int
+        final double zoomSpecificSpan = getMaxDistanceBetweenClusteredItems() / Math.pow(2, zoom) / 256;
+
+        final Set<QuadItem<T>> visitedCandidates = new HashSet<>();
+        final Collection<QuadItem<T>> result = new ArrayList<>();
+        synchronized (mQuadTree) {
+            for (QuadItem<T> candidate : mItems) {
+                if (visitedCandidates.contains(candidate)) continue;
+
+                Bounds searchBounds = createBoundsFromSpan(candidate.getPoint(), zoomSpecificSpan);
+                Collection<QuadItem<T>> clusterItems = new ArrayList<>();
+                for (QuadItem<T> clusterItem : mQuadTree.search(searchBounds)) {
+                    double distance = distanceSquared(clusterItem.getPoint(), candidate.getPoint());
+                    double radiusSquared = Math.pow(zoomSpecificSpan / 2, 2);
+                    if (distance < radiusSquared) {
+                        clusterItems.add(clusterItem);
+                    }
+                }
+
+                visitedCandidates.addAll(clusterItems);
+                result.add(candidate);
+            }
+        }
+        return result;
+    }
+
+}

library/src/main/java/com/google/maps/android/clustering/algo/ContinuousZoomEuclideanCentroidAlgorithm.java

@@ -54,7 +54,7 @@ public class NonHierarchicalDistanceBasedAlgorithm<T extends ClusterItem> extend
     /**
      * Any modifications should be synchronized on mQuadTree.
      */
-    private final Collection<QuadItem<T>> mItems = new LinkedHashSet<>();
+    protected final Collection<QuadItem<T>> mItems = new LinkedHashSet<>();
 
     /**
      * Any modifications should be synchronized on mQuadTree.

library/src/main/java/com/google/maps/android/clustering/algo/NonHierarchicalDistanceBasedAlgorithm.java

@@ -13,7 +13,6 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-
 package com.google.maps.android.clustering.algo;
 
 import androidx.annotation.NonNull;
@@ -31,7 +30,7 @@
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertTrue;
 
-public class ContinuousZoomEuclideanAlgorithmTest {
+public class ContinuousZoomEuclideanCentroidAlgorithmTest {
 
     static class TestClusterItem implements ClusterItem {
         private final LatLng position;
@@ -64,8 +63,8 @@ public Float getZIndex() {
 
     @Test
     public void testContinuousZoomMergesClosePairAtLowZoomAndSeparatesAtHighZoom() {
-        ContinuousZoomEuclideanAlgorithm<TestClusterItem> algo =
-                new ContinuousZoomEuclideanAlgorithm<>();
+        ContinuousZoomEuclideanCentroidAlgorithm<TestClusterItem> algo =
+                new ContinuousZoomEuclideanCentroidAlgorithm<>();
 
         Collection<TestClusterItem> items = Arrays.asList(
                 new TestClusterItem(10.0, 10.0),
@@ -83,10 +82,36 @@ public void testContinuousZoomMergesClosePairAtLowZoomAndSeparatesAtHighZoom() {
         Set<? extends Cluster<TestClusterItem>> lowZoom = algo.getClusters(5.0f);
         assertTrue(lowZoom.size() < 3);
 
-        // And specifically, we expect one cluster of size 2 and one singleton
+        // Specifically, we expect one cluster of size 2 and one singleton
         boolean hasClusterOfTwo = lowZoom.stream().anyMatch(c -> c.getItems().size() == 2);
         boolean hasClusterOfOne = lowZoom.stream().anyMatch(c -> c.getItems().size() == 1);
         assertTrue(hasClusterOfTwo);
         assertTrue(hasClusterOfOne);
     }
+
+    @Test
+    public void testClusterPositionsAreCentroids() {
+        ContinuousZoomEuclideanCentroidAlgorithm<TestClusterItem> algo =
+                new ContinuousZoomEuclideanCentroidAlgorithm<>();
+
+        Collection<TestClusterItem> items = Arrays.asList(
+                new TestClusterItem(0.0, 0.0),
+                new TestClusterItem(0.0, 2.0),
+                new TestClusterItem(2.0, 0.0)
+        );
+
+        algo.addItems(items);
+
+        Set<? extends Cluster<TestClusterItem>> clusters = algo.getClusters(1.0f);
+
+        // Expect all items clustered into one
+        assertEquals(1, clusters.size());
+
+        Cluster<TestClusterItem> cluster = clusters.iterator().next();
+
+        // The centroid should be approximately (0.6667, 0.6667)
+        LatLng centroid = cluster.getPosition();
+        assertEquals(0.6667, centroid.latitude, 0.0001);
+        assertEquals(0.6667, centroid.longitude, 0.0001);
+    }
 }