平铺投影 Google 地图：将距离转换为屏幕尺寸

Question

我在 Google 地图 Android v2 中使用 CanvasTileProvider。

我可以将经纬度点转换为屏幕像素。

但是我想创建一种将距离转换为屏幕像素的方法。这将允许我绘制一个 x 半径的圆。有人可以帮忙吗？

下面的代码是我从其他地方截取和修改的，所以要感谢原作者。

/**
 * Converts between LatLng coordinates and the pixels inside a tile.
 */
public class TileProjection {

    public int x;
    public int y;
    private int zoom;
    private int TILE_SIZE;

    private DoublePoint pixelOrigin_;
    private double pixelsPerLonDegree_;
    private double pixelsPerLonRadian_;

    TileProjection(int tileSize, int x, int y, int zoom) {
        this.TILE_SIZE = tileSize;
        this.x = x;
        this.y = y;
        this.zoom = zoom;
        pixelOrigin_ = new DoublePoint(TILE_SIZE / 2, TILE_SIZE / 2);
        pixelsPerLonDegree_ = TILE_SIZE / 360d;
        pixelsPerLonRadian_ = TILE_SIZE / (2 * Math.PI);
    }

    /**
     * Get the dimensions of the Tile in LatLng coordinates
     */
    public LatLngBounds getTileBounds() {
        DoublePoint tileSW = new DoublePoint(x * TILE_SIZE, (y + 1) * TILE_SIZE);
        DoublePoint worldSW = pixelToWorldCoordinates(tileSW);
        LatLng SW = worldCoordToLatLng(worldSW);
        DoublePoint tileNE = new DoublePoint((x + 1) * TILE_SIZE, y * TILE_SIZE);
        DoublePoint worldNE = pixelToWorldCoordinates(tileNE);
        LatLng NE = worldCoordToLatLng(worldNE);
        return new LatLngBounds(SW, NE);
    }

    /**
     * Calculate the pixel coordinates inside a tile, relative to the left upper
     * corner (origin) of the tile.
     */
    public PointF latLngToPoint(LatLng latLng) {
        DoublePoint result = new DoublePoint(1, 1);
        //  Log.d("Aero","x " + String.valueOf(x));
        // Log.d("Aero","y " + String.valueOf(y));

        latLngToWorldCoordinates(latLng, result);
        worldToPixelCoordinates(result, result);
        result.x -= x * TILE_SIZE;

        int numTiles = 1 << zoom;
        if (latLng.longitude < 0) {
            result.x = result.x + (numTiles * TILE_SIZE);
        }

        result.y -= y * TILE_SIZE;
        return new PointF((float) result.x, (float) result.y);
    }    

    private DoublePoint pixelToWorldCoordinates(DoublePoint pixelCoord) {
        int numTiles = 1 << zoom;
        DoublePoint worldCoordinate = new DoublePoint(pixelCoord.x / numTiles,
                pixelCoord.y / numTiles);
        return worldCoordinate;
    }

    /**
     * Transform the world coordinates into pixel-coordinates relative to the
     * whole tile-area. (i.e. the coordinate system that spans all tiles.)
     * <p/>
     * <p/>
     * Takes the resulting point as parameter, to avoid creation of new objects.
     */
    private void worldToPixelCoordinates(DoublePoint worldCoord, DoublePoint result) {
        int numTiles = 1 << zoom;
        result.x = worldCoord.x * numTiles;
        result.y = worldCoord.y * numTiles;
    }

    private LatLng worldCoordToLatLng(DoublePoint worldCoordinate) {
        DoublePoint origin = pixelOrigin_;
        double lng = (worldCoordinate.x - origin.x) / pixelsPerLonDegree_;
        double latRadians = (worldCoordinate.y - origin.y)
                / -pixelsPerLonRadian_;
        double lat = Math.toDegrees(2 * Math.atan(Math.exp(latRadians))
                - Math.PI / 2);
        return new LatLng(lat, lng);
    }

    /**
     * Get the coordinates in a system describing the whole globe in a
     * coordinate range from 0 to TILE_SIZE (type double).
     * <p/>
     * Takes the resulting point as parameter, to avoid creation of new objects.
     */
    private void latLngToWorldCoordinates(LatLng latLng, DoublePoint result) {
        DoublePoint origin = pixelOrigin_;

        result.x = origin.x + latLng.longitude * pixelsPerLonDegree_;


        // Truncating to 0.9999 effectively limits latitude to 89.189. This is
        // about a third of a tile past the edge of the world tile.
        double siny = bound(Math.sin(Math.toRadians(latLng.latitude)), -0.9999,
                0.9999);
        result.y = origin.y + 0.5 * Math.log((1 + siny) / (1 - siny))
                * -pixelsPerLonRadian_;
    }

    ;

    /**
     * Return value reduced to min and max if outside one of these bounds.
     */
    private double bound(double value, double min, double max) {
        value = Math.max(value, min);
        value = Math.min(value, max);
        return value;
    }

    /**
     * A Point in an x/y coordinate system with coordinates of type double
     */
    public static class DoublePoint {
        double x;
        double y;

        public DoublePoint(double x, double y) {
            this.x = x;
            this.y = y;
        }
    }

}

这就是我建议使用的：

public Double MetersToPixels(LatLng latLng, Double distance){
    double tileScale = TILE_SIZE / 256;
    double pixelsPerMeter =1 / (156543.03392 * Math.cos(latLng.latitude * Math.PI / 180) / Math.pow(2, zoom)) * tileScale;
    return  pixelsPerMeter * distance;
}

Answer 1

首先你应该知道一个事实，地球表面的圆并不完全是地图上的圆。但是如果你忽略这个不准确，你只需要在 25nm 距离内创建一个 LatLng 点，然后使用 latLngToPoint 方法来获取像素。将它们与中心的像素进行比较，即可得出半径。要在给定距离内创建 LatLng，请参阅此 SO question（方法移动）

的答案