import com.google.maps.android.geometry.Point; //导入依赖的package包/类
@Override
public Set<? extends Cluster<T>> getClusters(double zoom) {
    long numCells = (long) Math.ceil(256 * Math.pow(2, zoom) / GRID_SIZE);
    SphericalMercatorProjection proj = new SphericalMercatorProjection(numCells);

    HashSet<Cluster<T>> clusters = new HashSet<Cluster<T>>();
    LongSparseArray<StaticCluster<T>> sparseArray = new LongSparseArray<StaticCluster<T>>();

    synchronized (mItems) {
        for (T item : mItems) {
            Point p = proj.toPoint(item.getPosition());

            long coord = getCoord(numCells, p.x, p.y);

            StaticCluster<T> cluster = sparseArray.get(coord);
            if (cluster == null) {
                cluster = new StaticCluster<T>(proj.toLatLng(new Point(Math.floor(p.x) + .5, Math.floor(p.y) + .5)));
                sparseArray.put(coord, cluster);
                clusters.add(cluster);
            }
            cluster.add(item);
        }
    }

    return clusters;
}
 

import com.google.maps.android.geometry.Point; //导入依赖的package包/类
@Override
public Tile getTile(int x, int y, int zoom) {
    Matrix matrix = new Matrix();
    float scale = (float) Math.pow(2, zoom) * mScale;
    matrix.postScale(scale, scale);
    matrix.postTranslate(-x * mDimension, -y * mDimension);

    Bitmap bitmap = Bitmap.createBitmap(mDimension, mDimension, Bitmap.Config.ARGB_8888);
    Canvas c = new Canvas(bitmap);
    c.setMatrix(matrix);

    for (Point p : mPoints) {
        c.drawCircle((float) p.x, (float) p.y, 1, new Paint());
    }

    ByteArrayOutputStream baos = new ByteArrayOutputStream();
    bitmap.compress(Bitmap.CompressFormat.PNG, 100, baos);
    return new Tile(mDimension, mDimension, baos.toByteArray());
}
 

import com.google.maps.android.geometry.Point; //导入依赖的package包/类
private static Point findClosestCluster(List<Point> markers, Point point) {
    if (markers == null || markers.isEmpty()) return null;

    // TODO: make this configurable.
    double minDistSquared = VisibleNonHierarchicalDistanceBasedAlgorithm.MAX_DISTANCE_AT_ZOOM * VisibleNonHierarchicalDistanceBasedAlgorithm.MAX_DISTANCE_AT_ZOOM;
    Point closest = null;
    for (Point candidate : markers) {
        double dist = distanceSquared(candidate, point);
        if (dist < minDistSquared) {
            closest = candidate;
            minDistSquared = dist;
        }
    }
    return closest;
}
 

import com.google.maps.android.geometry.Point; //导入依赖的package包/类
public List<T> search(LatLngBounds latLngBounds) {
    Point ne = PROJECTION.toPoint(latLngBounds.northeast);
    Point sw = PROJECTION.toPoint(latLngBounds.southwest);

    Bounds searchBounds = new Bounds(Math.min(ne.x, sw.x), Math.max(ne.x, sw.x), Math.min(ne.y, sw.y), Math.max(ne.y, sw.y));

    final List<T> items = new ArrayList<T>();
    synchronized (mQuadTree) {
        Collection<SpatialDataSource.QuadItem<T>> found = mQuadTree.search(searchBounds);
        for (SpatialDataSource.QuadItem<T> quadItem : found) {
            items.add(quadItem.getClusterItem());
        }
    }
    return items;
}
 

import com.google.maps.android.geometry.Point; //导入依赖的package包/类
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);
}
 

import com.google.maps.android.geometry.Point; //导入依赖的package包/类
private Bounds getVisibleBounds(int zoom) {
    if (mMapCenter == null) {
        return new Bounds(0, 0, 0, 0);
    }

    Point p = mDataSource.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);
}
 

import com.google.maps.android.geometry.Point; //导入依赖的package包/类
private static Point findClosestCluster(List<Point> markers, Point point) {
    if (markers == null || markers.isEmpty()) return null;

    // TODO: make this configurable.
    double minDistSquared = MAX_DISTANCE_AT_ZOOM * MAX_DISTANCE_AT_ZOOM;
    Point closest = null;
    for (Point candidate : markers) {
        double dist = distanceSquared(candidate, point);
        if (dist < minDistSquared) {
            closest = candidate;
            minDistSquared = dist;
        }
    }
    return closest;
}
 

import com.google.maps.android.geometry.Point; //导入依赖的package包/类
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);
}
 

import com.google.maps.android.geometry.Point; //导入依赖的package包/类
/**
 * Insert an item.
 */
public void add(T item) {
    Point point = item.getPoint();
    if (this.mBounds.contains(point.x, point.y)) {
        insert(point.x, point.y, item);
    }
}
 

import com.google.maps.android.geometry.Point; //导入依赖的package包/类
/**
 * Remove the given item from the set.
 *
 * @return whether the item was removed.
 */
public boolean remove(T item) {
    Point point = item.getPoint();
    if (this.mBounds.contains(point.x, point.y)) {
        return remove(point.x, point.y, item);
    } else {
        return false;
    }
}
 

import com.google.maps.android.geometry.Point; //导入依赖的package包/类
private static double distanceSquared(Point a, Point b) {
    return (a.x - b.x) * (a.x - b.x) + (a.y - b.y) * (a.y - b.y);
}
 

import com.google.maps.android.geometry.Point; //导入依赖的package包/类
public Point toPoint(LatLng latLng) {
    return PROJECTION.toPoint(latLng);
}
 

import com.google.maps.android.geometry.Point; //导入依赖的package包/类
@Override
public Point getPoint() {
    return mPoint;
}
 

import com.google.maps.android.geometry.Point; //导入依赖的package包/类
private double distanceSquared(Point a, Point b) {
    return (a.x - b.x) * (a.x - b.x) + (a.y - b.y) * (a.y - b.y);
}
 

import com.google.maps.android.geometry.Point; //导入依赖的package包/类
/**
 * Insert an item.
 */
public void add(T item) {
    Point point = item.getPoint();
    insert(point.x, point.y, item);
}
 

import com.google.maps.android.geometry.Point; //导入依赖的package包/类
public Point getPoint() {
    return mPoint;
}
 

import com.google.maps.android.geometry.Point; //导入依赖的package包/类
private Item(double x, double y) {
    this.mPoint = new Point(x, y);
}