Подтвердить что ты не робот

Преобразование долготы/широты в координату X/Y

Я создал карту с помощью API Карт Google, которая выделяет все округа Миннесоты. В принципе, я создал графские полигоны, используя набор координат долготы/широт. Здесь снимок экрана сгенерированной карты: -

enter image description here

Одним из требований пользователя является возможность иметь похожую карту в качестве изображения, чтобы они могли встроить ее в слайды PowerPoint/keynote. Я не мог найти полезный API Карт Google, который позволяет мне сохранять свою пользовательскую карту так, как она есть (если вы знаете способ, дайте мне знать), поэтому я полагаю, что я должен просто рисовать его с помощью Graphics2D на Java.

После прочтения формул для преобразования долготы/широты в координату X/Y, я получаю следующий код: -

private static final int    EARTH_RADIUS    = 6371;
private static final double FOCAL_LENGTH    = 500;

...

BufferedImage bi = new BufferedImage(WIDTH, HEIGHT, BufferedImage.TYPE_INT_RGB);
Graphics2D g = bi.createGraphics();

for (Coordinate coordinate : coordinates) {
    double latitude = Double.valueOf(coordinate.getLatitude());
    double longitude = Double.valueOf(coordinate.getLongitude());

    latitude = latitude * Math.PI / 180;
    longitude = longitude * Math.PI / 180;

    double x = EARTH_RADIUS * Math.sin(latitude) * Math.cos(longitude);
    double y = EARTH_RADIUS * Math.sin(latitude) * Math.sin(longitude);
    double z = EARTH_RADIUS * Math.cos(latitude);

    double projectedX = x * FOCAL_LENGTH / (FOCAL_LENGTH + z);
    double projectedY = y * FOCAL_LENGTH / (FOCAL_LENGTH + z);

    // scale the map bigger
    int magnifiedX = (int) Math.round(projectedX * 5);
    int magnifiedY = (int) Math.round(projectedY * 5);

    ...
    g.drawPolygon(...);
    ...
}

Сгенерированная карта похожа на ту, сгенерированную API Карт Google, с использованием того же набора долгот/широт. Тем не менее, он немного наклонен, и он немного выглядит, и я не уверен, как это исправить.

enter image description here

Как сделать форму округов похожими на форму, созданную API Карт Google выше?

Большое спасибо.

ЗАКЛЮЧИТЕЛЬНОЕ РЕШЕНИЕ

Наконец-то я нашел решение благодаря @QuantumMechanic и @Anon.

Прогноз Меркатора действительно делает трюк. Я использую Java Map Projection Library для выполнения расчета для проекции Меркатора.

private static final int    IMAGE_WIDTH     = 1000;
private static final int    IMAGE_HEIGHT    = 1000;
private static final int    IMAGE_PADDING   = 50;

...

private List<Point2D.Double> convertToXY(List<Coordinate> coordinates) {
    List<Point2D.Double> xys = new ArrayList<Point2D.Double>();

    MercatorProjection projection = new MercatorProjection();

    for (Coordinate coordinate : coordinates) {
        double latitude = Double.valueOf(coordinate.getLatitude());
        double longitude = Double.valueOf(coordinate.getLongitude());

        // convert to radian
        latitude = latitude * Math.PI / 180;
        longitude = longitude * Math.PI / 180;

        Point2D.Double d = projection.project(longitude, latitude, new Point2D.Double());

        // shift by 10 to remove negative Xs and Ys
        // scaling by 6000 to make the map bigger
        int magnifiedX = (int) Math.round((10 + d.x) * 6000);
        int magnifiedY = (int) Math.round((10 + d.y) * 6000);

        minX = (minX == -1) ? magnifiedX : Math.min(minX, magnifiedX);
        minY = (minY == -1) ? magnifiedY : Math.min(minY, magnifiedY);

        xys.add(new Point2D.Double(magnifiedX, magnifiedY));
    }

    return xys;
}

...

Используя сгенерированную координату XY, карта кажется инвертированной, и потому, что я считаю, что graphics2D 0,0 начинается в левом верхнем углу. Итак, мне нужно инвертировать Y, вычитая значение из высоты изображения, примерно так: -

...

Polygon polygon = new Polygon();

for (Point2D.Double point : xys) {
    int adjustedX = (int) (IMAGE_PADDING + (point.getX() - minX));

    // need to invert the Y since 0,0 starts at top left
    int adjustedY = (int) (IMAGE_HEIGHT - IMAGE_PADDING - (point.getY() - minY));

    polygon.addPoint(adjustedX, adjustedY);
}

...

Здесь сгенерированное отображение: -

enter image description here

СОВЕРШЕННО!

ОБНОВЛЕНИЕ 01-25-2013

Здесь приведен код для создания карты изображения на основе ширины и высоты (в пикселях). В этом случае я не полагаюсь на библиотеку проектов Java Map Project, вместо этого я извлек соответствующую формулу и встроил ее в свой код. Это дает вам больший контроль над созданием карты по сравнению с приведенным выше примером кода, который зависит от произвольного значения масштабирования (в приведенном выше примере используется 6000).

public class MapService {
    // CHANGE THIS: the output path of the image to be created
    private static final String IMAGE_FILE_PATH = "/some/user/path/map.png";

    // CHANGE THIS: image width in pixel
    private static final int IMAGE_WIDTH_IN_PX = 300;

    // CHANGE THIS: image height in pixel
    private static final int IMAGE_HEIGHT_IN_PX = 500;

    // CHANGE THIS: minimum padding in pixel
    private static final int MINIMUM_IMAGE_PADDING_IN_PX = 50;

    // formula for quarter PI
    private final static double QUARTERPI = Math.PI / 4.0;

    // some service that provides the county boundaries data in longitude and latitude
    private CountyService countyService;

    public void run() throws Exception {
        // configuring the buffered image and graphics to draw the map
        BufferedImage bufferedImage = new BufferedImage(IMAGE_WIDTH_IN_PX,
                                                        IMAGE_HEIGHT_IN_PX,
                                                        BufferedImage.TYPE_INT_RGB);

        Graphics2D g = bufferedImage.createGraphics();
        Map<RenderingHints.Key, Object> map = new HashMap<RenderingHints.Key, Object>();
        map.put(RenderingHints.KEY_INTERPOLATION, RenderingHints.VALUE_INTERPOLATION_BICUBIC);
        map.put(RenderingHints.KEY_RENDERING, RenderingHints.VALUE_RENDER_QUALITY);
        map.put(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
        RenderingHints renderHints = new RenderingHints(map);
        g.setRenderingHints(renderHints);

        // min and max coordinates, used in the computation below
        Point2D.Double minXY = new Point2D.Double(-1, -1);
        Point2D.Double maxXY = new Point2D.Double(-1, -1);

        // a list of counties where each county contains a list of coordinates that form the county boundary
        Collection<Collection<Point2D.Double>> countyBoundaries = new ArrayList<Collection<Point2D.Double>>();

        // for every county, convert the longitude/latitude to X/Y using Mercator projection formula
        for (County county : countyService.getAllCounties()) {
            Collection<Point2D.Double> lonLat = new ArrayList<Point2D.Double>();

            for (CountyBoundary countyBoundary : county.getCountyBoundaries()) {
                // convert to radian
                double longitude = countyBoundary.getLongitude() * Math.PI / 180;
                double latitude = countyBoundary.getLatitude() * Math.PI / 180;

                Point2D.Double xy = new Point2D.Double();
                xy.x = longitude;
                xy.y = Math.log(Math.tan(QUARTERPI + 0.5 * latitude));

                // The reason we need to determine the min X and Y values is because in order to draw the map,
                // we need to offset the position so that there will be no negative X and Y values
                minXY.x = (minXY.x == -1) ? xy.x : Math.min(minXY.x, xy.x);
                minXY.y = (minXY.y == -1) ? xy.y : Math.min(minXY.y, xy.y);

                lonLat.add(xy);
            }

            countyBoundaries.add(lonLat);
        }

        // readjust coordinate to ensure there are no negative values
        for (Collection<Point2D.Double> points : countyBoundaries) {
            for (Point2D.Double point : points) {
                point.x = point.x - minXY.x;
                point.y = point.y - minXY.y;

                // now, we need to keep track the max X and Y values
                maxXY.x = (maxXY.x == -1) ? point.x : Math.max(maxXY.x, point.x);
                maxXY.y = (maxXY.y == -1) ? point.y : Math.max(maxXY.y, point.y);
            }
        }

        int paddingBothSides = MINIMUM_IMAGE_PADDING_IN_PX * 2;

        // the actual drawing space for the map on the image
        int mapWidth = IMAGE_WIDTH_IN_PX - paddingBothSides;
        int mapHeight = IMAGE_HEIGHT_IN_PX - paddingBothSides;

        // determine the width and height ratio because we need to magnify the map to fit into the given image dimension
        double mapWidthRatio = mapWidth / maxXY.x;
        double mapHeightRatio = mapHeight / maxXY.y;

        // using different ratios for width and height will cause the map to be stretched. So, we have to determine
        // the global ratio that will perfectly fit into the given image dimension
        double globalRatio = Math.min(mapWidthRatio, mapHeightRatio);

        // now we need to readjust the padding to ensure the map is always drawn on the center of the given image dimension
        double heightPadding = (IMAGE_HEIGHT_IN_PX - (globalRatio * maxXY.y)) / 2;
        double widthPadding = (IMAGE_WIDTH_IN_PX - (globalRatio * maxXY.x)) / 2;

        // for each country, draw the boundary using polygon
        for (Collection<Point2D.Double> points : countyBoundaries) {
            Polygon polygon = new Polygon();

            for (Point2D.Double point : points) {
                int adjustedX = (int) (widthPadding + (point.getX() * globalRatio));

                // need to invert the Y since 0,0 starts at top left
                int adjustedY = (int) (IMAGE_HEIGHT_IN_PX - heightPadding - (point.getY() * globalRatio));

                polygon.addPoint(adjustedX, adjustedY);
            }

            g.drawPolygon(polygon);
        }

        // create the image file
        ImageIO.write(bufferedImage, "PNG", new File(IMAGE_FILE_PATH));
    }
}

РЕЗУЛЬТАТ: ширина изображения = 600 пикселей, высота изображения = 600 пикселей, заполнение изображения = 50 пикселей

enter image description here

РЕЗУЛЬТАТ: ширина изображения = 300 пикселей, высота изображения = 500 пикселей, заполнение изображения = 50 пикселей

enter image description here

4b9b3361

Ответ 1

Большая проблема с построением карт заключается в том, что сферическая поверхность Земли не может быть удобно преобразована в плоское представление. Существует множество различных прогнозов, которые пытаются решить эту проблему.

Mercator является одним из самых простых: предполагается, что линии равной широты являются параллельными горизонталями, а линии с равной долготой - параллельными вертикалями, Это справедливо для широты (1 градус широты приблизительно равна 111 км независимо от того, где вы находитесь), но недействительна для долготы (поверхностное расстояние градуса долготы пропорционально косинусу latitutude).

Однако, пока вы стоите ниже 45 градусов (большинство из них находится в штате Миннесота), проекция Меркатора работает очень хорошо и создает формы, которые большинство людей узнает из карт их школьной школы. И это очень просто: просто обрабатывайте точки как абсолютные координаты и масштабируйте любое место, в которое вы их вставляете. Не требуется триггеров.

Ответ 2

Помните, что способ отображения карты - это функция проекции, используемой для отображения карты. Карты Google, похоже, используют проекцию Меркатора (или что-то очень похожее на нее). Какая проекция соответствует вашему алгоритму? Если вы хотите, чтобы ваше 2D-представление выглядело так же, как Google, вам нужно использовать идентичную проекцию.

Ответ 3

Чтобы преобразовать lat/lon/alt (лат в градусах по северу, lon в градусах по восточному, в метрах), к фиксированным координатам с координатами (x, y, z) с центром в центре, выполните следующее:

double Re = 6378137;
double Rp = 6356752.31424518;

double latrad = lat/180.0*Math.PI;
double lonrad = lon/180.0*Math.PI;

double coslat = Math.cos(latrad);
double sinlat = Math.sin(latrad);
double coslon = Math.cos(lonrad);
double sinlon = Math.sin(lonrad);

double term1 = (Re*Re*coslat)/
  Math.sqrt(Re*Re*coslat*coslat + Rp*Rp*sinlat*sinlat);

double term2 = alt*coslat + term1;

double x=coslon*term2;
double y=sinlon*term2;
double z = alt*sinlat + (Rp*Rp*sinlat)/
  Math.sqrt(Re*Re*coslat*coslat + Rp*Rp*sinlat*sinlat);