Changeset 19387 in josm for trunk/src/org/openstreetmap/josm/data

Timestamp:

2025-04-23T18:34:33+02:00 (13 months ago)

Author:

stoecker

Message:

see #24238 - support more EXIF data in image correlation

Location:

trunk/src/org/openstreetmap/josm/data

Files:

• ImageData.java (modified) (1 diff)
• gpx/GpxConstants.java (modified) (2 diffs)
• gpx/GpxImageCorrelation.java (modified) (10 diffs)
• gpx/GpxImageCorrelationSettings.java (modified) (4 diffs)
• gpx/GpxImageDatumSettings.java (added)
• gpx/GpxImageDirectionPositionSettings.java (modified) (4 diffs)
• gpx/GpxImageEntry.java (modified) (11 diffs)
• imagery/street_level/IImageEntry.java (modified) (3 diffs)

trunk/src/org/openstreetmap/josm/data/ImageData.java

@@ -367 +367 @@
 
     /**
+     * Update the GPS track direction of the image and trigger update.
+     * @param img the image to update
+     * @param trackDirection the new GPS track direction
+     * @since 19387
+     */
+    public void updateImageGpsTrack(ImageEntry img, double trackDirection) {
+        img.setExifGpsTrack(trackDirection);
+        afterImageUpdated(img);
+    }
+
+    /**
+     * Update the image horizontal positioning error and trigger update.
+     * @param img the image to update
+     * @param hposerr the new horizontal positionning error
+     * @since 19387
+     */
+    public void updateImageHPosErr(ImageEntry img, double hposerr) {
+        img.setExifHPosErr(hposerr);
+        afterImageUpdated(img);
+    }
+
+    /**
+     * Update the image GPS differential mode and trigger update.
+     * @param img the image to update
+     * @param gpsDiffMode the new GPS differential mode
+     * @since 19387
+     */
+    public void updateImageGpsDiffMode(ImageEntry img, Integer gpsDiffMode) {
+        img.setGpsDiffMode(gpsDiffMode);
+        afterImageUpdated(img);
+    }
+
+    /**
+     * Update the image GPS 2d/3d mode value and trigger update.
+     * @param img the image to update
+     * @param gps2d3dMode the new 2d/3d GPS mode
+     * @since 19387
+     */
+    public void updateImageGps2d3dMode(ImageEntry img, Integer gps2d3dMode) {
+        img.setGps2d3dMode(gps2d3dMode);
+        afterImageUpdated(img);
+    }
+
+    /**
+     * Update the image GPS DOP value and trigger update.
+     * @param img the image to update
+     * @param exifGpsDop the new GPS DOP value
+     * @since 19387
+     */
+    public void updateImageExifGpsDop(ImageEntry img, Double exifGpsDop) {
+        img.setExifGpsDop(exifGpsDop);
+        afterImageUpdated(img);
+    }
+
+    /**
+     * Update the image GPS datum and trigger update.
+     * @param img the image to update
+     * @param exifGpsDatum the new datum string value
+     * @since 19387
+     */
+    public void updateImageExifGpsDatum(ImageEntry img, String exifGpsDatum) {
+        img.setExifGpsDatum(exifGpsDatum);
+        afterImageUpdated(img);
+    }
+
+    /**
+     * Update the image GPS processing method and trigger update.
+     * @param img the image to update
+     * @param exifGpsProcMethod the new GPS processing method
+     * @since 19387
+     */
+    public void updateImageExifGpsProcMethod(ImageEntry img, String exifGpsProcMethod) {
+        img.setExifGpsProcMethod(exifGpsProcMethod);
+        afterImageUpdated(img);
+    }
+
+    /**
      * Manually trigger the {@link ImageDataUpdateListener#imageDataUpdated(ImageData)}
      */

trunk/src/org/openstreetmap/josm/data/gpx/GpxConstants.java

@@ -146 +146 @@
     String PT_TIME = "time";
 
+    /** True Course/Bearing angle over ground.
+     * @since 19387
+     */
+    String PT_COURSE = "course";
+
     /** Magnetic variation (in degrees) at the point. 0.0 <= value < 360.0 */
     String PT_MAGVAR = "magvar";
@@ -189 +194 @@
      */
     List<String> WPT_KEYS = Collections.unmodifiableList(Arrays.asList(PT_ELE, PT_TIME, PT_MAGVAR, PT_GEOIDHEIGHT,
-            GPX_NAME, GPX_CMT, GPX_DESC, GPX_SRC, META_LINKS, PT_SYM, PT_TYPE,
-            PT_FIX, PT_SAT, PT_HDOP, PT_VDOP, PT_PDOP, PT_AGEOFDGPSDATA, PT_DGPSID, PT_STD_HDEV, PT_STD_VDEV));
+            GPX_NAME, GPX_CMT, GPX_DESC, GPX_SRC, META_LINKS, PT_SYM, PT_TYPE, PT_FIX, PT_SAT, PT_COURSE,
+            PT_HDOP, PT_VDOP, PT_PDOP, PT_AGEOFDGPSDATA, PT_DGPSID, PT_STD_HDEV, PT_STD_VDEV));
 
     /**

trunk/src/org/openstreetmap/josm/data/gpx/GpxImageCorrelation.java

@@ -2 +2 @@
 package org.openstreetmap.josm.data.gpx;
 
+import java.util.Arrays;
 import java.util.ArrayList;
 import java.util.Collection;
@@ -73 +74 @@
 
         final GpxImageDirectionPositionSettings dirpos = settings.getDirectionPositionSettings();
+        final GpxImageDatumSettings datumSettings = settings.getDatumSettings();
         final long offset = settings.getOffset();
 
@@ -142 +144 @@
                     }
                     WayPoint nextWp = i < size - 1 ? wps.get(i + 1) : null;
-                    ret += matchPoints(images, prevWp, prevWpTime, curWp, curWpTime, offset, interpolate, tagTime, nextWp, dirpos);
+                    ret += matchPoints(images, prevWp, prevWpTime, curWp, curWpTime, offset,
+                                       interpolate, tagTime, nextWp, dirpos, datumSettings);
                     prevWp = curWp;
                     prevWpTime = curWpTime;
@@ -149 +152 @@
         }
         if (trkTag && prevWp != null) {
-            ret += matchPoints(images, prevWp, prevWpTime, prevWp, prevWpTime, offset, false, trkTagTime, null, dirpos);
+            ret += matchPoints(images, prevWp, prevWpTime, prevWp, prevWpTime, offset,
+                               false, trkTagTime, null, dirpos, datumSettings);
         }
         Logging.debug("Correlated {0} total points", ret);
@@ -210 +214 @@
     }
 
-    private static int matchPoints(List<? extends GpxImageEntry> images, WayPoint prevWp, long prevWpTime, WayPoint curWp, long curWpTime,
-            long offset, boolean interpolate, int tagTime, WayPoint nextWp, GpxImageDirectionPositionSettings dirpos) {
+    static Double getHPosErr(WayPoint wp) {
+        if (wp != null) {
+            if (wp.attr.get(GpxConstants.PT_STD_HDEV) instanceof Float) {
+                Float hposerr = (Float) wp.attr.get(GpxConstants.PT_STD_HDEV);
+                if (hposerr != null) {
+                    return hposerr.doubleValue();
+                }
+            } else if (wp.attr.get(GpxConstants.PT_STD_HDEV) instanceof Double) {               
+                Double hposerr = (Double) wp.attr.get(GpxConstants.PT_STD_HDEV);
+                if (hposerr != null) {
+                    return hposerr;
+                }
+            }
+        }
+        return null;
+    }
+
+    static Double getGpsDop(WayPoint wp) {
+        if (wp != null) {
+            if (wp.attr.get(GpxConstants.PT_PDOP) != null) {
+                if (wp.attr.get(GpxConstants.PT_PDOP) instanceof Float) {
+                    Float pdopvalue = (Float) wp.attr.get(GpxConstants.PT_PDOP);
+                    return pdopvalue.doubleValue();
+                } else if (wp.attr.get(GpxConstants.PT_PDOP) instanceof Double) {
+                    Double pdopvalue = (Double) wp.attr.get(GpxConstants.PT_PDOP);
+                    return pdopvalue.doubleValue();
+                }
+            } else if (wp.attr.get(GpxConstants.PT_HDOP) != null) {
+                if (wp.attr.get(GpxConstants.PT_HDOP) instanceof Float) {
+                    Float hdopvalue = (Float) wp.attr.get(GpxConstants.PT_HDOP);
+                    return hdopvalue.doubleValue();
+                } else if (wp.attr.get(GpxConstants.PT_HDOP) instanceof Double) {
+                    Double hdopvalue = (Double) wp.attr.get(GpxConstants.PT_HDOP);
+                    return hdopvalue.doubleValue();
+                }
+            }
+        }
+        return null;
+    }
+
+    static Double getGpsTrack(WayPoint wp) {
+        if (wp != null) {
+            String trackvalue = wp.getString(GpxConstants.PT_COURSE);
+            Logging.debug("track angle value: {0}", trackvalue);
+            if (!Utils.isEmpty(trackvalue)) {
+                try {
+                    return Double.valueOf(trackvalue);
+                } catch (NumberFormatException e) {
+                    Logging.warn(e);
+                }
+            }
+        }
+        return null;
+    }
+
+    static String getGpsProcMethod(String prevGpsFixMode, final String curGpsFixMode,
+                                    final List<String> positioningModes) {
+        String gpsProcMethod = null;
+        Integer lowestProcIndex = null;
+        int lowestGnssModeIdx = 3; // 2d or higher index in positioningModes list are Gnss methods
+        try {
+            lowestProcIndex = Math.min(positioningModes.indexOf(prevGpsFixMode), positioningModes.indexOf(curGpsFixMode));
+            if (lowestProcIndex < 0) {
+                return null;
+            }
+            gpsProcMethod = "GNSS" + " " + positioningModes.get(lowestProcIndex).toUpperCase() + " " + "CORRELATION";
+            if (lowestProcIndex < lowestGnssModeIdx) {
+                gpsProcMethod = positioningModes.get(lowestProcIndex).toUpperCase() + " " + "CORRELATION";
+            } else {
+                gpsProcMethod = "GNSS" + " " + positioningModes.get(lowestProcIndex).toUpperCase() + " " + "CORRELATION";
+            }
+            gpsProcMethod = gpsProcMethod.replace("FLOAT RTK", "RTK_FLOAT");
+            gpsProcMethod = gpsProcMethod.replace(" RTK ", " RTK_FIX ");
+        } catch (ArrayIndexOutOfBoundsException ex) {
+            Logging.warn(ex);
+        }
+        return gpsProcMethod;
+    }
+
+    static Integer getGps2d3dMode(String prevGpsFixMode, final String curGpsFixMode,
+                                final List<String> positioningModes) {
+        Integer lowestMode = null;
+        lowestMode = Math.min(positioningModes.indexOf(prevGpsFixMode), positioningModes.indexOf(curGpsFixMode));
+        if (lowestMode > 3) {
+            return 3;
+        }
+        if (lowestMode > 2) {
+            return 2;
+        }
+        return null;
+    }
+
+    // CHECKSTYLE.OFF: ParameterNumber
+    private static int matchPoints(List<? extends GpxImageEntry>
+                                        images,
+                                        WayPoint prevWp,
+                                        long prevWpTime,
+                                        WayPoint curWp,
+                                        long curWpTime,
+                                        long offset,
+                                        boolean interpolate,
+                                        int tagTime,
+                                        WayPoint nextWp,
+                                        GpxImageDirectionPositionSettings dirpos,
+                                        GpxImageDatumSettings datumSettings) {
 
         final boolean isLast = nextWp == null;
@@ -237 +344 @@
         Double speed = null;
         Double prevElevation = null;
+        Double prevHPosErr = null;
+        Double prevGpsDop = null;
+        Double prevGpsTrack = null;
+        String prevGpsFixMode = null;
+        //list of differential GPS mode
+        //TODO move these lists in Gpx.Constants?
+        final List<String> diffMode = Arrays.asList("dgps", "float rtk", "rtk");
+        final List<String> positioningModes = Arrays.asList("none", "manual", "estimated", "2d", "3d", "dgps", "float rtk", "rtk");
+
 
         if (prevWp != null && interpolate) {
@@ -245 +361 @@
             }
             prevElevation = getElevation(prevWp);
+            prevHPosErr = getHPosErr(prevWp);
+            prevGpsDop = getGpsDop(prevWp);
+            prevGpsTrack = getGpsTrack(prevWp);
+            prevGpsFixMode = prevWp.getString(GpxConstants.PT_FIX);
         }
 
         final Double curElevation = getElevation(curWp);
+        final Double curHPosErr = getHPosErr(curWp);
+        final Double curGpsDop = getGpsDop(curWp);
+        final Double curGpsTrack = getGpsTrack(curWp);
+        final String curGpsFixMode = curWp.getString(GpxConstants.PT_FIX);
 
         if (!interpolate || isLast) {
@@ -267 +391 @@
                         curTmp.setPos(curWp.getCoor());
                     }
+                    //TODO fix this, nextWp doesn't exist here
                     if (nextWp != null && dirpos.isSetImageDirection()) {
                         double direction = curWp.bearing(nextWp);
@@ -318 +443 @@
                         curTmp.setElevation(prevElevation + (curElevation - prevElevation) * timeDiff + dirpos.getElevationShift());
                     }
+
+                    // Add exif GpsHPositioningerror interpolated value
+                    if (curHPosErr != null && prevHPosErr != null) {
+                        Double interpolatedValue = prevHPosErr + (curHPosErr - prevHPosErr) * timeDiff;
+                        curTmp.setExifHPosErr(Math.round(interpolatedValue*10000)/10000.0);
+                    }
+
+                    // Add exif GpsDifferentialMode
+                    // Get previous and current waypoint differential. As no interpolation is possible,
+                    // set differential mode to 0 if any waypoint isn't in differential mode.
+                    if (prevGpsFixMode != null) {
+                        if (diffMode.contains(prevGpsFixMode) && diffMode.contains(curGpsFixMode)) {
+                            curTmp.setGpsDiffMode(1);
+                        } else {
+                            curTmp.setGpsDiffMode(0);
+                        }
+                    }
+
+                    // Add exif GpsMeasureMode
+                    if (prevGpsFixMode != null && curGpsFixMode != null) {
+                        Integer gps2d3dMode = getGps2d3dMode(prevGpsFixMode, curGpsFixMode, positioningModes);
+                        if (gps2d3dMode != null) {
+                            curTmp.setGps2d3dMode(gps2d3dMode);
+                        }
+                    }
+                    
+                    // Add exif GpsProcessingMethod. As no interpolation is possible,
+                    // set processing method to the "lowest" previous and current processing method value.
+                    if (prevGpsFixMode != null && curGpsFixMode != null) {
+                        String gpsProcMethod = getGpsProcMethod(prevGpsFixMode, curGpsFixMode, positioningModes);                       
+                        if (gpsProcMethod != null) {
+                            curTmp.setExifGpsProcMethod(gpsProcMethod);
+                        }
+                    }
+
+                    // Add Exif GpsDop with interpolated GPS DOP value
+                    if (curGpsDop != null && prevGpsDop != null) {
+                        Double interpolatedValue = prevGpsDop + (curGpsDop - prevGpsDop) * timeDiff;
+                        curTmp.setExifGpsDop(Math.round(interpolatedValue*100)/100.0);
+                    }
+
+                    // Add Exif GpsTrack tag
+                    if (dirpos.isSetGpxTrackDirection()) {
+                        if (curGpsTrack != null && prevGpsTrack != null) {
+                            curTmp.setExifGpsTrack(prevGpsTrack + (curGpsTrack - prevGpsTrack) * timeDiff);
+                        }
+                    }
+                    
+                    // Add GpsDatum tag
+                    if (datumSettings.isSetImageGpsDatum()) {
+                        if (diffMode.contains(prevGpsFixMode) && diffMode.contains(curGpsFixMode)) {
+                            curTmp.setExifGpsDatum(datumSettings.getImageGpsDatum());
+                        } else //without differential mode, datum is WGS-84
+                            curTmp.setExifGpsDatum("WGS-84");
+                    }
+
                     curTmp.setGpsTime(curImg.getExifInstant().minusMillis(offset));
                     curTmp.flagNewGpsData();
@@ -331 +512 @@
         return ret;
     }
+    // CHECKSTYLE.ON: ParameterNumber
 
     private static double computeDirection(double direction, double angleOffset) {

trunk/src/org/openstreetmap/josm/data/gpx/GpxImageCorrelationSettings.java

@@ -13 +13 @@
     private final boolean forceTags;
     private final GpxImageDirectionPositionSettings directionPositionSettings;
+    private final GpxImageDatumSettings datumSettings;
 
     /**
@@ -20 +21 @@
      */
     public GpxImageCorrelationSettings(long offset, boolean forceTags) {
-        this(offset, forceTags, new GpxImageDirectionPositionSettings(false, 0, 0, 0, 0));
+        this(offset, forceTags,
+        new GpxImageDirectionPositionSettings(false, 0, false, 0, 0, 0),
+        new GpxImageDatumSettings(false, null)
+        );
     }
 
@@ -31 +35 @@
     public GpxImageCorrelationSettings(long offset, boolean forceTags,
             GpxImageDirectionPositionSettings directionPositionSettings) {
+        this(offset, forceTags, directionPositionSettings,
+        new GpxImageDatumSettings(false, null));
+    }
+
+    /**
+     * Constructs a new {@code GpxImageCorrelationSettings}.
+     * @param offset offset in milliseconds
+     * @param forceTags force tagging of all photos, otherwise prefs are used
+     * @param directionPositionSettings direction/position settings
+     * @param datumSettings GPS datum settings
+     * @since 19387 @datumSettings was added
+     */
+    public GpxImageCorrelationSettings(long offset, boolean forceTags,
+            GpxImageDirectionPositionSettings directionPositionSettings,
+            GpxImageDatumSettings datumSettings) {
         this.offset = offset;
         this.forceTags = forceTags;
         this.directionPositionSettings = Objects.requireNonNull(directionPositionSettings);
+        this.datumSettings = Objects.requireNonNull(datumSettings);
     }
-
+    
     /**
      * Returns the offset in milliseconds.
@@ -60 +80 @@
     }
 
+    /**
+     * Returns the EXIF metadata datum settings.
+     * @return the EXIF metadata datum settings
+     * @since 19387
+     */
+    public GpxImageDatumSettings getDatumSettings() {
+        return datumSettings;
+    }
+
     @Override
     public String toString() {
         return "[offset=" + offset + ", forceTags=" + forceTags
-                + ", directionPositionSettings=" + directionPositionSettings + ']';
+                + ", directionPositionSettings=" + directionPositionSettings
+                + ", datumSettings=" + datumSettings + ']';
     }
 }

trunk/src/org/openstreetmap/josm/data/gpx/GpxImageDirectionPositionSettings.java

@@ -10 +10 @@
     private final boolean setImageDirection;
     private final double imageDirectionAngleOffset;
+    private final boolean setGpxTrackDirection;
     private final double shiftImageX;
     private final double shiftImageY;
@@ -18 +19 @@
      * @param setImageDirection determines if image direction must be set towards the next GPX waypoint
      * @param imageDirectionAngleOffset direction angle offset in degrees
+     * @param setGpxTrackDirection determines if image course direction must be set
      * @param shiftImageX image shift on X axis relative to the direction in meters
      * @param shiftImageY image shift on Y axis relative to the direction in meters
      * @param elevationShift image elevation shift in meters
+     * @since 19387 @setGpsTrackDirection was added
      */
     public GpxImageDirectionPositionSettings(
-            boolean setImageDirection, double imageDirectionAngleOffset, double shiftImageX, double shiftImageY, double elevationShift) {
+            boolean setImageDirection, double imageDirectionAngleOffset, boolean setGpxTrackDirection, 
+            double shiftImageX, double shiftImageY, double elevationShift) {
         this.setImageDirection = setImageDirection;
         this.imageDirectionAngleOffset = imageDirectionAngleOffset;
+        this.setGpxTrackDirection = setGpxTrackDirection;
         this.shiftImageX = shiftImageX;
         this.shiftImageY = shiftImageY;
@@ -45 +50 @@
     public double getImageDirectionAngleOffset() {
         return imageDirectionAngleOffset;
+    }
+
+    /**
+     * Determines if GPS course direction must be set. Angle value is from the gpx trace.
+     * @return {@code true} if image GPS course must be set
+     * @since 19387
+     */
+    public boolean isSetGpxTrackDirection() {
+        return setGpxTrackDirection;
     }
 
@@ -74 +88 @@
     public String toString() {
         return "[setImageDirection=" + setImageDirection
-                + ", imageDirectionAngleOffset=" + imageDirectionAngleOffset + ", shiftImageX=" + shiftImageX
-                + ", shiftImageY=" + shiftImageY + ", elevationShift=" + elevationShift + ']';
+                + ", imageDirectionAngleOffset=" + imageDirectionAngleOffset
+                + ", setImageGpxTrackDirection=" + setGpxTrackDirection
+                + ", shiftImageX=" + shiftImageX
+                + ", shiftImageY=" + shiftImageY
+                + ", elevationShift=" + elevationShift + ']';
     }
 }

trunk/src/org/openstreetmap/josm/data/gpx/GpxImageEntry.java

@@ -33 +33 @@
     private LatLon exifCoor;
     private Double exifImgDir;
+    private Double exifGpsTrack;
+    private Double exifHPosErr;
+    private Double exifGpsDop;
     private Instant exifTime;
     private Projections cameraProjection = Projections.UNKNOWN;
@@ -58 +61 @@
     /** Elevation (altitude) in meters */
     private Double elevation;
+    /** GPS Differential mode */
+    private Integer gpsDiffMode;
+    /** GPS Measure mode */
+    private Integer gps2d3dMode;
+    /** GPS Datum */
+    private String exifGpsDatum;
+    /** GPS processing method */
+    private String exifGpsProcMethod;
     /** The time after correlation with a gpx track */
     private Instant gpsTime;
@@ -89 +100 @@
         exifCoor = other.exifCoor;
         exifImgDir = other.exifImgDir;
+        exifGpsTrack = other.exifGpsTrack;
+        exifHPosErr = other.exifHPosErr;
+        gpsDiffMode = other.gpsDiffMode;
+        gps2d3dMode = other.gps2d3dMode;
+        exifGpsDop = other.exifGpsDop;
+        exifGpsDatum = other.exifGpsDatum;
+        exifGpsProcMethod = other.exifGpsProcMethod;
         exifTime = other.exifTime;
         isNewGpsData = other.isNewGpsData;
@@ -171 +189 @@
 
     /**
+     * Return the GPS Differential mode value. The GPS Differential mode value from the temporary
+     * copy is returned if that copy exists. 
+     * @return the differential mode value
+     * @since 19387
+     */
+    @Override
+    public Integer getGpsDiffMode() {
+        if (tmp != null)
+            return tmp.gpsDiffMode;
+        return gpsDiffMode;
+    }
+
+    /**
+     * Return the GPS 2d or 3d mode value. The GPS mode value form the temporary
+     * copy is returned if that copy exists. 
+     * @return the GPS 2d/3d mode value
+     * @since 19387
+     */
+    @Override
+    public Integer getGps2d3dMode() {
+        if (tmp != null)
+            return tmp.gps2d3dMode;
+        return gps2d3dMode;
+    }
+
+    /**
+     * Return the GPS DOP value. The GPS DOP value from the temporary
+     * copy is returned if that copy exists. 
+     * @return the DOP value
+     * @since 19387
+     */
+    @Override
+    public Double getExifGpsDop() {
+        if (tmp != null)
+            return tmp.exifGpsDop;
+        return exifGpsDop;
+    }
+
+    /**
+     * Return the exif GPS coordinates datum value.
+     * @return The datum value
+     * @since 19387
+     */
+    @Override
+    public String getExifGpsDatum() {
+        if (tmp != null)
+            return tmp.exifGpsDatum;
+        return exifGpsDatum;
+    }
+
+    /**
+     * Return the exif GPS processing method string
+     * @return the processing method string
+     * @since 19387
+     */
+    @Override
+    public String getExifGpsProcMethod() {
+        if (tmp != null)
+            return tmp.exifGpsProcMethod;
+        return exifGpsProcMethod;
+    }
+
+    /**
      * Returns the GPS time value. The GPS time value from the temporary copy
      * is returned if that copy exists.
@@ -272 +353 @@
             return tmp.exifImgDir;
         return exifImgDir;
+    }
+    
+    /**
+     * Convenient way to determine if this entry has a EXIF GPS track angle value,
+     * without the cost of building a defensive copy.
+     * @return {@code true} if this entry has a EXIF track angle value
+     * @since 19387
+     */
+    @Override
+    public Double getExifGpsTrack() {
+        if (tmp != null)
+            return tmp.exifGpsTrack;
+        return exifGpsTrack;
+    }
+
+    /**
+     * Convenient way to determine if this entry has a EXIF GPS horizontal positionning error value,
+     * without the cost of building a defensive copy.
+     * @return {@code true} if this entry has a EXIF GPS horizontal positionning error value
+     * @since 19387
+     */
+    @Override
+    public Double getExifHPosErr() {
+        if (tmp != null)
+            return tmp.exifHPosErr;
+        return exifHPosErr;
     }
 
@@ -347 +454 @@
 
     /**
+     * Sets GPS Differential mode.
+     * @param gpsDiffMode GPS Differential mode
+     * @since 19387
+     */
+    @Override
+    public void setGpsDiffMode(Integer gpsDiffMode) {
+        this.gpsDiffMode = gpsDiffMode;
+    }
+
+    /**
+     * Sets GPS 2d/3d mode.
+     * @param gps2d3dMode GPS 2d/3d mode value
+     * @since 19387
+     */
+    @Override
+    public void setGps2d3dMode(Integer gps2d3dMode) {
+        this.gps2d3dMode = gps2d3dMode;
+    }
+
+    /**
+     * Sets GPS DOP value.
+     * @param exifGpsDop GPS DOP value
+     * @since 19387
+     */
+    @Override
+    public void setExifGpsDop(Double exifGpsDop) {
+        this.exifGpsDop = exifGpsDop;
+    }
+
+    /**
+     * Sets the GPS Datum.
+     * @param exifGpsDatum GPS Datum
+     * @since 19387
+     */
+    @Override
+    public void setExifGpsDatum(String exifGpsDatum) {
+        this.exifGpsDatum = exifGpsDatum;
+    }
+
+    /**
+     * Sets the GPS Processing Method.
+     * @param exifGpsProcMethod GPS Processing Method
+     * @since 19387
+     */
+    @Override
+    public void setExifGpsProcMethod(String exifGpsProcMethod) {
+        this.exifGpsProcMethod = exifGpsProcMethod;
+    }
+
+    /**
      * Sets associated file.
      * @param file associated file
@@ -411 +568 @@
     public void setExifImgDir(Double exifDir) {
         this.exifImgDir = exifDir;
+    }
+
+    /**
+     * Sets the exif GPS track (move direction angle)
+     * @param exifGpsTrack the exif GPS track angle
+     * @since 19387
+     */
+    @Override
+    public void setExifGpsTrack(Double exifGpsTrack) {
+        this.exifGpsTrack = exifGpsTrack;
+    }
+
+    /**
+     * Sets the exif horizontal positioning error
+     * @param exifHposErr the Exif horizontal positionning error
+     * @since 19387
+     */
+    @Override
+    public void setExifHPosErr(Double exifHPosErr) {
+        this.exifHPosErr = exifHPosErr;
     }
 
@@ -508 +685 @@
     public int hashCode() {
         return Objects.hash(height, width, isNewGpsData,
-            elevation, exifCoor, exifGpsTime, exifImgDir, exifOrientation, exifTime,
-            iptcCaption, iptcHeadline, iptcKeywords, iptcObjectName,
-            file, gpsTime, pos, speed, tmp, cameraProjection);
+            elevation, exifCoor, exifGpsTime, exifImgDir, exifGpsTrack, exifHPosErr,
+            exifGpsDop, gpsDiffMode, gps2d3dMode, exifGpsDatum, exifGpsProcMethod,
+            exifOrientation, exifTime, iptcCaption, iptcHeadline, iptcKeywords,
+            iptcObjectName, file, gpsTime, pos, speed, tmp, cameraProjection);
     }
 
@@ -527 +705 @@
             && Objects.equals(exifGpsTime, other.exifGpsTime)
             && Objects.equals(exifImgDir, other.exifImgDir)
+            && Objects.equals(exifGpsTrack, other.exifGpsTrack)
+            && Objects.equals(exifHPosErr, other.exifHPosErr)
+            && Objects.equals(gpsDiffMode, other.gpsDiffMode)
+            && Objects.equals(gps2d3dMode, other.gps2d3dMode)
+            && Objects.equals(exifGpsDop, other.exifGpsDop)
+            && Objects.equals(exifGpsDatum, other.exifGpsDatum)
+            && Objects.equals(exifGpsProcMethod, other.exifGpsProcMethod)
             && Objects.equals(exifOrientation, other.exifOrientation)
             && Objects.equals(exifTime, other.exifTime)
@@ -571 +756 @@
      * temporary variable is deleted.
      * @see #discardTmp()
+     * @since 19387 exifGpsTrack, exifHPosErr, gpsDiffMode, gps2d3dMode, exifGpsDop, exifGpsDatum, exifGpsProcMethod added
      */
     public void applyTmp() {
@@ -579 +765 @@
             gpsTime = tmp.gpsTime;
             exifImgDir = tmp.exifImgDir;
+            exifGpsTrack = tmp.exifGpsTrack;
+            exifHPosErr = tmp.exifHPosErr;
+            gpsDiffMode = tmp.gpsDiffMode;
+            gps2d3dMode = tmp.gps2d3dMode;
+            exifGpsDop = tmp.exifGpsDop;
+            exifGpsDatum = tmp.exifGpsDatum;
+            exifGpsProcMethod = tmp.exifGpsProcMethod;
             isNewGpsData = isNewGpsData || tmp.isNewGpsData;
             tmp = null;

trunk/src/org/openstreetmap/josm/data/imagery/street_level/IImageEntry.java

@@ -220 +220 @@
 
     /**
+     * Return the GPS Differential mode value. The differential mode value from the temporary
+     * copy is returned if that copy exists. 
+     * @return the fix mode value
+     * @since 19387
+     */
+    Integer getGpsDiffMode();
+
+    /**
+     * Return the GPS 2d/3d mode value. The 2d/3d mode value from the temporary
+     * copy is returned if that copy exists.
+     * @return the 2d/3d mode value
+     * @since 19387
+     */
+    Integer getGps2d3dMode();
+
+    /**
+     * Return the GPS DOP value. The GPS DOP value from the temporary
+     * copy is return if that copy exists.
+     * @return the GPS DOP value
+     * @since 19387
+     */
+    Double getExifGpsDop();
+
+    /**
+     * Return the GPS datum value. The GPS datum value from the temporary
+     * copy is return if that copy exists. 
+     * @return the GPS datum value
+     * @since 19387
+     */
+    String getExifGpsDatum();
+
+    /**
+     * Return the GPS processing method. The processing method value from the temporary
+     * copy is return if that copy exists.
+     * @return the GPS processing method
+     * @since 19387
+     */
+    String getExifGpsProcMethod();
+
+    /**
      * Returns the image direction. The image direction from the temporary
      * copy is returned if that copy exists.
@@ -225 +265 @@
      */
     Double getExifImgDir();
-
+    
+    /**
+     * Returns the image GPS track direction. The GPS track direction from the temporary
+     * copy is returned if that copy exists.
+     * @return the image GPS track direction angle
+     * @since 19387
+     */
+    Double getExifGpsTrack();
+
+    /**
+     * Returns the image horizontal positionning error. The image positionning error
+     * from the temporary copy is returned if that copy exists.
+     * @return the image horizontal positionning error
+     * @since 19387
+     */
+    Double getExifHPosErr();
+    
     /**
      * Convenient way to determine if this entry has a EXIF time, without the cost of building a defensive copy.
@@ -253 +309 @@
 
     /**
+     * Returns the Exif GPS Time value. The Exif GPS time value from the temporary copy
+     * is returned if that copy exists.
+     * @return the Exif GPS time value
+     * @since 19387
+     */
+    Instant getExifGpsInstant();
+
+    /**
      * Returns the IPTC caption.
      * @return the IPTC caption