java - जगह - भौगोलिक ग्रिड अक्षांश और देशांतर




एक्स/वाई समन्वय में देशांतर/अक्षांश को परिवर्तित करना (2)

नक्शा प्लॉटिंग के साथ बड़ा मुद्दा यह है कि पृथ्वी की गोलाकार सतह को आसानी से एक फ्लैट प्रतिनिधित्व में परिवर्तित नहीं किया जा सकता है। विभिन्न अनुमानों का एक गुच्छा है जो इसे हल करने का प्रयास करते हैं।

Mercator सबसे सरल है: यह मानता है कि बराबर अक्षांश की रेखाएं समानांतर क्षैतिज हैं, जबकि समानांतरता की रेखाएं समानांतर लंबवत हैं। यह अक्षांश के लिए मान्य है (अक्षांश की 1 डिग्री लगभग 111 किमी के बराबर होती है चाहे आप कहीं भी हों), लेकिन देशांतर के लिए मान्य नहीं है (अक्षांश की डिग्री की सतह दूरी अक्षांश के कोसाइन के समान है )।

हालांकि, जब तक आप लगभग 45 डिग्री (जो मिनेसोटा का अधिकांश हिस्सा है) से नीचे हैं, एक मर्केटर प्रक्षेपण बहुत अच्छी तरह से काम करता है, और उन रूपों को बनाता है जो अधिकांश लोग अपने ग्रेड स्कूल के नक्शे से पहचानेंगे। और यह बहुत आसान है: केवल अंक को पूर्ण निर्देशांक के रूप में मानें, और जो भी स्थान आप उन्हें आकर्षित कर रहे हैं उसे स्केल करें। कोई ट्रिगर आवश्यक नहीं है।

मैंने Google मानचित्र API का उपयोग करके एक मानचित्र बनाया जो सभी मिनेसोटा काउंटी को हाइलाइट करता है। असल में, मैंने अनुदैर्ध्य / अक्षांश निर्देशांक के एक सेट का उपयोग करके काउंटी बहुभुज बनाए। जेनरेट किए गए मानचित्र का एक स्क्रीनशॉट यहां दिया गया है: -

उपयोगकर्ता आवश्यकताओं में से एक छवि के समान नक्शा प्राप्त करने में सक्षम होना है ताकि वे इसे अपने पावरपॉइंट / कीनोट स्लाइड में एम्बेड कर सकें। मुझे कोई उपयोगी Google मैप्स एपीआई नहीं मिल सका जो मुझे अपने कस्टम मैप को जिस तरीके से है (यदि आप एक रास्ता जानते हैं, मुझे बताएं) को सहेजने की इजाजत देता है, इसलिए मुझे लगता है कि मुझे जावा में ग्राफिक्स 2 डी के साथ इसे आकर्षित करना चाहिए।

अक्षांश / अक्षांश को एक्स / वाई समन्वय में परिवर्तित करने के सूत्रों को पढ़ने के बाद, मैं निम्नलिखित कोड के साथ समाप्त होता हूं: -

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(...);
    ...
}

जेनरेट किया गया मानचित्र Google मानचित्र एपीआई द्वारा जेनरेट / अक्षांश के उसी सेट का उपयोग करके उत्पन्न होता है। हालांकि, यह थोड़ा झुका हुआ लगता है और यह थोड़ा सा दिखता है, और मुझे यकीन नहीं है कि इसे कैसे ठीक किया जाए।

मैं काउंटी के आकार को उपरोक्त Google मानचित्र API द्वारा जेनरेट किए गए जैसा दिखने के लिए कैसे बना सकता हूं?

बहुत धन्यवाद।

अंतिम समाधान

अंत में मुझे @QuantumMechanic और @Anon का समाधान धन्यवाद मिला।

मर्केटर प्रक्षेपण वास्तव में यहां चाल करता है। मैं मर्केटर प्रोजेक्शन के लिए गणना करने के लिए जावा मैप प्रोजेक्शन लाइब्रेरी का उपयोग कर रहा हूं।

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;
}

...

जेनरेटेड एक्सवाई समन्वय का उपयोग करके, नक्शा उलटा लगता है, और ऐसा इसलिए है क्योंकि मुझे लगता है कि ग्राफिक्स 2 डी का 0,0 शीर्ष बाईं ओर शुरू होता है। इसलिए, मुझे छवि ऊंचाई से मूल्य घटाकर वाई को उलटा करने की आवश्यकता है, इस तरह कुछ: -

...

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);
}

...

जेनरेट किया गया मानचित्र यहां दिया गया है: -

ये बिलकुल सही है!

अद्यतन 01-25-2013

चौड़ाई और ऊंचाई (पिक्सेल में) के आधार पर छवि मानचित्र बनाने के लिए कोड यहां दिया गया है। इस मामले में, मैं जावा मैप प्रोजेक्ट लाइब्रेरी पर भरोसा नहीं कर रहा हूं, इसके बजाय, मैंने प्रासंगिक फॉर्मूला निकाला और इसे मेरे कोड में एम्बेड किया। यह आपको उपरोक्त कोड उदाहरण की तुलना में मानचित्र निर्माण का अधिक नियंत्रण देता है जो मनमाने ढंग से स्केलिंग मान (ऊपर दिया गया उदाहरण 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 पीएक्स

परिणाम: छवि चौड़ाई = 300 पीएक्स, छवि ऊंचाई = 500 पीएक्स, छवि पैडिंग = 50 पीएक्स


पृथ्वी केंद्रित केंद्रित निर्देशांक (एक्स, वाई, जेड) में लेट / लॉन / alt (डिग्री उत्तर में लेट, डिग्री पूर्व में लोन, मीटर में alt) को परिवर्तित करने के लिए, निम्न कार्य करें:

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);




coordinate-transformation