una - ¿Cómo guardar coordenadas GPS en datos exif en Android?

quitar edicion de una imagen android

Question

Estoy escribiendo coordenadas de GPS en mi imagen JPEG, y las coordenadas son correctas (como lo demuestra mi salida Logcat) pero parece que se está corrompiendo de alguna manera. La lectura de los datos exif da como resultado valores nulos o, en el caso de mi GPS: 512.976698 degrees, 512.976698 degrees . ¿Alguien puede arrojar algo de luz sobre este problema?

escribiéndolo:

        try {
            ExifInterface exif = new ExifInterface(filename);
            exif.setAttribute(ExifInterface.TAG_GPS_LATITUDE, latitude);
            exif.setAttribute(ExifInterface.TAG_GPS_LONGITUDE, longitude);
            exif.saveAttributes();
            Log.e("LATITUDE: ", latitude);
            Log.e("LONGITUDE: ", longitude);


        } catch (IOException e) {
            e.printStackTrace();
        }

y leyéndolo:

        try {
            ExifInterface exif = new ExifInterface("/sdcard/globetrotter/mytags/"+ TAGS[position]);
            Log.e("LATITUDE EXTRACTED", exif.getAttribute(ExifInterface.TAG_GPS_LATITUDE));
            Log.e("LONGITUDE EXTRACTED", exif.getAttribute(ExifInterface.TAG_GPS_LONGITUDE));
        } catch (IOException e) {
            e.printStackTrace();
        }

37.715183 (por ejemplo) 37.715183 , -117.260489 y sale 33619970/65540, 14811136/3368550 , 33619970/65540, 14811136/3368550 . ¿Lo estoy haciendo mal?

EDITAR:

Entonces, el problema es que no lo estoy codificando en el formato correctamente definido, que es algo como lo que ves aquí:

¿Alguien puede explicar qué es este formato? Obviamente, el primer número es 22/1 = 22 grados, pero no puedo averiguar cómo calcular el decimal allí.

Answer 1

GPSLatitude

Indica la latitud. La latitud se expresa como tres valores RATIONAL que dan los grados, minutos y segundos, respectivamente. Si la latitud se expresa en grados, minutos y segundos, un formato típico sería dd/1,mm/1,ss/1 . Cuando se usan grados y minutos y, por ejemplo, se dan fracciones de minutos hasta dos decimales, el formato sería dd/1,mmmm/100,0/1 .

https://docs.google.com/viewer?url=http%3A%2F%2Fwww.exif.org%2FExif2-2.PDF

Los documentos de Android especifican esto sin explicación: http://developer.android.com/reference/android/media/ExifInterface.html#TAG_GPS_LATITUDE

Los datos Exif están estandarizados, y los datos GPS deben codificarse utilizando las coordenadas geográficas (minutos, segundos, etc.) descritas anteriormente en lugar de una fracción. A menos que esté codificado en ese formato en la etiqueta exif, no se pegará.

Cómo codificar: http://en.wikipedia.org/wiki/Geographic_coordinate_conversion

Cómo decodificar: http://android-er.blogspot.com/2010/01/convert-exif-gps-info-to-degree-format.html

Answer 2

Aquí hay un código que he hecho para etiquetar geográficamente mis fotos. Aún no está muy probado, pero parece estar bien (el editor de JOSM y la ubicación de lectura de exiftool). Comentarios apreciados.

ExifInterface exif = new ExifInterface(filePath.getAbsolutePath());
exif.setAttribute(ExifInterface.TAG_GPS_LATITUDE, GPS.convert(latitude));
exif.setAttribute(ExifInterface.TAG_GPS_LATITUDE_REF, GPS.latitudeRef(latitude));
exif.setAttribute(ExifInterface.TAG_GPS_LONGITUDE, GPS.convert(longitude));
exif.setAttribute(ExifInterface.TAG_GPS_LONGITUDE_REF, GPS.longitudeRef(longitude));
exif.saveAttributes();

Y la clase GPS está aquí. (El método podría ser más corto, pero al menos es legible)

/*
 * @author fabien
 */
public class GPS {
    private static StringBuilder sb = new StringBuilder(20);

    /**
     * returns ref for latitude which is S or N.
     * @param latitude
     * @return S or N
     */
    public static String latitudeRef(double latitude) {
        return latitude<0.0d?"S":"N";
    }

    /**
     * returns ref for latitude which is S or N.
     * @param latitude
     * @return S or N
     */
    public static String longitudeRef(double longitude) {
        return longitude<0.0d?"W":"E";
    }

    /**
     * convert latitude into DMS (degree minute second) format. For instance<br/>
     * -79.948862 becomes<br/>
     *  79/1,56/1,55903/1000<br/>
     * It works for latitude and longitude<br/>
     * @param latitude could be longitude.
     * @return
     */
    synchronized public static final String convert(double latitude) {
        latitude=Math.abs(latitude);
        int degree = (int) latitude;
        latitude *= 60;
        latitude -= (degree * 60.0d);
        int minute = (int) latitude;
        latitude *= 60;
        latitude -= (minute * 60.0d);
        int second = (int) (latitude*1000.0d);

        sb.setLength(0);
        sb.append(degree);
        sb.append("/1,");
        sb.append(minute);
        sb.append("/1,");
        sb.append(second);
        sb.append("/1000,");
        return sb.toString();
    }
}

Answer 3

Otras respuestas proporcionaron buena información de fondo e incluso un ejemplo. Esta no es una respuesta directa a la pregunta, pero me gustaría agregar un ejemplo aún más simple sin la necesidad de hacer ningún cálculo matemático. La clase de Location ofrece una buena función de convert :

public String getLonGeoCoordinates(Location location) {

    if (location == null) return "0/1,0/1,0/1000";
    // You can adapt this to latitude very easily by passing location.getLatitude()
    String[] degMinSec = Location.convert(location.getLongitude(), Location.FORMAT_SECONDS).split(":");
    return degMinSec[0] + "/1," + degMinSec[1] + "/1," + degMinSec[2] + "/1000";
}

Almacené el valor de retorno en mi imagen y la etiqueta se analiza bien. Puede consultar su imagen y las coordenadas geográficas aquí: http://regex.info/exif.cgi

Editar

Comentario de @ratanas traducido al código:

public boolean storeGeoCoordsToImage(File imagePath, Location location) {

    // Avoid NullPointer
    if (imagePath == null || location == null) return false;

    // If we use Location.convert(), we do not have to worry about absolute values.

    try {
        // c&p and adapted from @Fabyen (sorry for being lazy)
        ExifInterface exif = new ExifInterface(imagePath.getAbsolutePath());
        exif.setAttribute(ExifInterface.TAG_GPS_LATITUDE, getLatGeoCoordinates(location));
        exif.setAttribute(ExifInterface.TAG_GPS_LATITUDE_REF, location.getLatitude() < 0 ? "S" : "N");
        exif.setAttribute(ExifInterface.TAG_GPS_LONGITUDE, getLonGeoCoordinates(location));
        exif.setAttribute(ExifInterface.TAG_GPS_LONGITUDE_REF, location.getLongitude() < 0 ? "W" : "E");
        exif.saveAttributes();
    } catch (IOException e) {
        // do something
        return false;
    }

    // Data was likely written. For sure no NullPointer. 
    return true;
}

Aquí hay algunos buenos convertidores de latlong.net : latlong.net

Answer 4

compruebe el código fuente de Android: https://android.googlesource.com/platform/frameworks/base/+/android-4.4.2_r2/core/java/android/hardware/Camera.java

/ ** * Establece la coordenada de longitud GPS. Esto se almacenará en el encabezado JPEG EXIF ​​*. * * @param longitud GPS de longitud coordinada. * / public void setGpsLongitude (doble longitud) {set (KEY_GPS_LONGITUDE, Double.toString (longitud)); }

Así que es una impresión directa, mi registro también lo admite: ExifInterface.TAG_GPS_LONGITUDE: -121.0553966

Mi conclusión es que la configuración como impresión directa está bien.