Conversion de Latitude/Longtitude en coordonnées d'image (coordonnées Pixel) sur une simple projection cylindrique

Question

J'ai pris une image de Google Earth, dont la latitude/longitude des 4 coins est connue. Je capture la latitude/longitudes en utilisant un capteur GPS. Je dois convertir ces latitude/longitudes capturées en coordonnées d'image (coordonnées de pixel) en utilisant java. J'utiliserai les coordonnées de l'image pour simuler comme si un véhicule se déplaçait sur une carte statique (image tirée de Google Earth).

Je trouve cette formule et a essayé de le mettre en œuvre

1. Déterminer la gauche plus la longitude de votre image 1653x1012 (X)
2. Déterminer l'est-plus la longitude de votre image 1653x1012 (Y)
3. Déterminer Longitude-Diff (Z = Y - X)
4. Déterminer le nord-plus de latitude dans votre image 1653x1012 (A)
5. Déterminer le sud le plus de latitude dans votre image 1653x1012 (B)
6. déterminer la latitude-Diff (C = A - B) Etant donné une latitude et longitude, pour déterminer quels pixels ont cliqué sur:

J = Entrée Longitude K = Latitude entrée

Calculer X- pixel

XPixel = CInt(((Y - J)/CDbl(Z)) * 1653) 

Calculer Y-pixel

YPixel = CInt(((A - K)/CDbl(C)) * 1012) 

C'est le code que j'ai utilisé.

import java.awt.geom.Point2D; 
    import java.io.BufferedReader; 
    import java.io.File; 
    import java.io.FileReader; 
    import java.util.ArrayList; 
    import java.util.List; 

    public class LatLongService { 
     private static LatLongService latLangService; 
     private BufferedReader reader = null; 
     private String st; 

     private LatLongService() { 
      try { 
       reader = new BufferedReader(new FileReader(new File(
         "resources/GPS_lat_long_2.txt"))); 
      } catch (Exception e) { 
       e.printStackTrace(); 
      } 
     } 

     public static LatLongService getInstance() { 
      if (latLangService == null) 
       latLangService = new LatLongService(); 
      return latLangService; 
     } 

     public List<Point2D> readLatLongList() { 
      List<Point2D> pointList = new ArrayList<Point2D>(); 
      StringBuffer xStr; 
      StringBuffer yStr = new StringBuffer(); 
      try { 
       while ((st = reader.readLine()) != null) { 
        xStr = new StringBuffer(st.substring(0, st.indexOf(','))); 
        yStr = new StringBuffer(st.substring(st.indexOf(',') + 2, 
          st.length())); 
        Point2D pt = new Point2D.Double(
          new Double(xStr.toString()).doubleValue(), new Double(
            yStr.toString()).doubleValue()); 
        pointList.add(pt); 
       } 
      } catch (Exception e) { 
       e.printStackTrace(); 
       try { 
        reader.close(); 
       } catch (Exception e2) { 
        e.printStackTrace(); 
       } 
      } 
      return pointList; 
     } 


    public List<Point2D> convertLatLongToCoord(List<Point2D> coordinate) { 
      List<Point2D> latLong = new ArrayList<Point2D>(); 
      double westMostLong = -79.974642; 
      double eastMostLong = -79.971244; 
      double longDiff = eastMostLong - westMostLong; // (rightmost_longitude - 
                  // leftmost_longitude) 

      double northMostLat = 39.647556; 
      double southMostLat = 39.644675; 
      double latDiff = northMostLat - southMostLat; // (topmost_latitude - 
                  // bottommost_latitude) 
      for (Point2D coord : coordinate) { 
       double j = coord.getY(); 
       double k = coord.getX(); 

       double XPixel = (((eastMostLong - j)/longDiff) * 1653); 
       double YPixel = (((northMostLat - k)/latDiff) * 1012); 

       Point2D actualCoord = new Point2D.Double(XPixel, YPixel); 
       latLong.add(actualCoord); 
      } 
      return latLong; 
     } 
    } 

Certains des GPS lat/long je suis arrivé des capteurs GPS

Latitude Longitude Entrée Entrée (39,64581, -79,97168) (39,64651, -79,97275) (39,646915, -79,97342) (39.646538, -79,97279)

[IMG] http://i59.tinypic.com/nbqkk3.png[/IMG]

la ligne rouge dans l'image montre le chemin suivi lorsque des coordonnées GPS ont été prises par capteur. Cependant, lorsque j'utilise cette formule pour convertir les coordonnées Lat/Long en coordonnées de pixels. Le pixel coordonne après la conversion ne sont pas compatibles, comme vous pouvez voir le résultat ci-dessous:

image X image Y (212,0977045, 613,3120444) (732,6127134, 367,4251996) (1058,542672, 225,1620965) (752,0712184, 357,5897258)

La variation des coordonnées X, Y (pixels) est trop importante. Donc, lorsque j'essaie de déplacer un véhicule en fonction des coordonnées des pixels, le véhicule ne suit pas la ligne rouge ou au moins près de celle-ci.

Le véhicule se déplace au-dessus de la ligne rouge ou au-dessous de la ligne, mais pas sur la ligne.

Pour un mouvement régulier du véhicule sur la base des coordonnées en pixels, idéalement, j'attends la conversion de lat/long à l'image des coordonnées pour être quelque chose comme ceci:

image requise X image requise Y (1290, 409) (1289, 409) (1288, 409) (1287, 409)

Mais je reçois ce

image X image Y (212,0977045, 613,3120444) (732.6127134, 367.4251996) (1058,542672, 225,1620965) (752,0712184, 357,5897258)

J'espère que je suis en mesure de transmettre mon problème.

Answer 1

Voici un code qui compile et répond à votre question

[1] (39.64581,-79.97168) -> 102,363 
[2] (39.64651,-79.97275) -> 354,217 
[3] (39.646915,-79.97342) -> 512,133 
[4] (39.646538,-79.97279) -> 363,212 
[5] (39.646458,-79.97264) -> 328,228 

Vous pourriez avoir les coordonnées interchangés x-y. Dans ce cas, x == longitude, y == latitude.

import java.util.*; 
import java.awt.geom.*; 

public class LatLong { 

     private int imageW, imageH; 
     private final static double west = -79.974642,  north = 39.647556, 
             east = -79.971244,  south = 39.644675; 

     public LatLong (int w, int h) { 
       imageW = w; 
       imageH = h; 
     } 

     public List<Point2D> convertLatLongToCoord (List<Point2D> coordinate) { 
      List<Point2D> latLong = new ArrayList<Point2D>(); 
      for (Point2D coord : coordinate) { 
       double x = coord.getY(),  px = imageW * (x-east)/(west-east), 
         y = coord.getX(),  py = imageH * (y-north)/(south-north); 
       latLong.add (new Point2D.Double(px,py)); 
      } 
      return latLong; 
     } 

     public static void main (String[] args) { 
       double[] latit = {39.64581, 39.64651, 39.646915, 39.646538, 39.646458}, 
         longit = {-79.97168, -79.97275, -79.97342, -79.97279, -79.97264}; 

       List<Point2D> pointList = new ArrayList<Point2D>(); 
       for (int i = 0 ; i < latit.length ; i++) 
         pointList.add (new Point2D.Double(latit[i], longit[i])); 

       List<Point2D> pixels = new LatLong (800,600).convertLatLongToCoord (pointList); 

       for (int i = 0 ; i < latit.length ; i++) 
         System.out.println ("[" + (i+1) + "]\t(" + latit[i] + "," + longit[i] + ") -> " + 
           (int) (pixels.get(i).getX()) + "," + (int) (pixels.get(i).getY())); 
}} 

Answer 2

La latitude et la longitude ne sont pas des distances.

http://geography.about.com/cs/latitudelongitude/a/latlong.htm

J'ai récemment travaillé sur un projet Arduino qui utilisait GPS. J'ai suivi l'approche API de minigeo qui convertissait la latitude et la longitude en nord et est (UTM).

Utilisation de la bibliothèque dans le lien que vous pouvez le faire convertion: http://www.ibm.com/developerworks/library/j-coordconvert/

que d'obtenir un maximum Abscisse et Ordonnée et calculer l'échelle

private synchronized void scale() { 
     int w = 800; 
     int h = 600; 

     this.scale = Math.min(
       w/(maxEasting - minEasting), 
       h/(maxNorthing - minNorthing)); 

     oEasting = minEasting; 
     oNorthing = minNorthing; 
    } 

que de convertir à X et Y

private int applyScale(double km) { 
     return (int) (km * scale); 
    } 

    private int convertX(double easting) { 
     return applyScale(easting - oEasting); 
    } 

    private int convertY(double northing, int height) { 
     return 600/*height*/ - applyScale(northing - oNorthing); 
    } 

Source: Minigeo