Index: trunk/test/data/ImageCorrelationTest.gpx
===================================================================
--- trunk/test/data/ImageCorrelationTest.gpx (revision 14205)
+++ trunk/test/data/ImageCorrelationTest.gpx (revision 14205)
@@ -0,0 +1,1354 @@
+
+
+
+
+
+
+
+
+ 471.86000000000001
+
+
+
+ 471.43000000000001
+
+
+
+ 470.69
+
+
+
+ 470.94
+
+
+
+ 471.5
+
+
+
+ 471.67000000000002
+
+
+
+ 471.58999999999997
+
+
+
+ 472.44999999999999
+
+
+
+ 472.54000000000002
+
+
+
+ 472.45999999999998
+
+
+
+ 471.38
+
+
+
+ 471.26999999999998
+
+
+
+ 471.36000000000001
+
+
+
+ 473.19999999999999
+
+
+
+ 475.06
+
+
+
+ 474.75
+
+
+
+ 474.62
+
+
+
+ 474.74000000000001
+
+
+
+ 474.06
+
+
+
+ 474
+
+
+
+ 474.58999999999997
+
+
+
+ 474.81999999999999
+
+
+
+ 476.29000000000002
+
+
+
+ 478.48000000000002
+
+
+
+ 481.02999999999997
+
+
+
+ 480
+
+
+
+ 479.58999999999997
+
+
+
+ 478.99000000000001
+
+
+
+ 479.58999999999997
+
+
+
+ 481.18000000000001
+
+
+
+ 481.88
+
+
+
+ 483.11000000000001
+
+
+
+ 484.49000000000001
+
+
+
+ 486.88
+
+
+
+ 488.05000000000001
+
+
+
+ 487.76999999999998
+
+
+
+ 488.95999999999998
+
+
+
+ 488.36000000000001
+
+
+
+ 488.35000000000002
+
+
+
+ 487.19
+
+
+
+ 487.63999999999999
+
+
+
+ 487.55000000000001
+
+
+
+ 488.39999999999998
+
+
+
+ 489.18000000000001
+
+
+
+ 490.73000000000002
+
+
+
+ 491.24000000000001
+
+
+
+ 490.25
+
+
+
+ 490.00999999999999
+
+
+
+ 489.54000000000002
+
+
+
+ 489.66000000000003
+
+
+
+ 489.06
+
+
+
+ 490.08999999999997
+
+
+
+ 489.41000000000003
+
+
+
+ 489.17000000000002
+
+
+
+ 488.87
+
+
+
+ 489.37
+
+
+
+ 488.94999999999999
+
+
+
+ 488.93000000000001
+
+
+
+ 488.88999999999999
+
+
+
+ 488.86000000000001
+
+
+
+ 489.19999999999999
+
+
+
+ 489.29000000000002
+
+
+
+ 488.95999999999998
+
+
+
+ 489.10000000000002
+
+
+
+ 492.19
+
+
+
+ 492.12
+
+
+
+ 493.06999999999999
+
+
+
+ 492.58999999999997
+
+
+
+ 492.38999999999999
+
+
+
+ 492.94
+
+
+
+ 492.47000000000003
+
+
+
+ 492.50999999999999
+
+
+
+ 492.73000000000002
+
+
+
+ 492.63
+
+
+
+ 493
+
+
+
+ 493.00999999999999
+
+
+
+ 493.19999999999999
+
+
+
+ 493.18000000000001
+
+
+
+ 493
+
+
+
+ 493.20999999999998
+
+
+
+ 493.11000000000001
+
+
+
+ 493.30000000000001
+
+
+
+ 493.50999999999999
+
+
+
+ 493
+
+
+
+ 492.37
+
+
+
+ 492.30000000000001
+
+
+
+ 492.04000000000002
+
+
+
+ 491.37
+
+
+
+ 491.06999999999999
+
+
+
+ 490.39999999999998
+
+
+
+ 489.75
+
+
+
+ 489.87
+
+
+
+ 488.95999999999998
+
+
+
+ 485.85000000000002
+
+
+
+ 482.81
+
+
+
+ 481.99000000000001
+
+
+
+ 478.92
+
+
+ 476
+
+
+ 474.38
+
+
+
+ 474.35000000000002
+
+
+
+ 474.12
+
+
+
+ 472.52999999999997
+
+
+
+ 472.75
+
+
+
+ 472.19
+
+
+
+ 471.92000000000002
+
+
+
+ 471.98000000000002
+
+
+
+ 473.49000000000001
+
+
+
+ 473.44999999999999
+
+
+
+ 473.45999999999998
+
+
+
+ 470.27999999999997
+
+
+
+ 467.20999999999998
+
+
+
+ 466.89999999999998
+
+
+
+ 466.76999999999998
+
+
+
+ 466.25
+
+
+
+ 465.23000000000002
+
+
+
+ 464.12
+
+
+
+ 463.68000000000001
+
+
+
+ 462.5
+
+
+
+ 462.45999999999998
+
+
+
+ 461.56999999999999
+
+
+
+ 461.14999999999998
+
+
+
+ 460.19
+
+
+
+ 459.83999999999997
+
+
+
+ 460.49000000000001
+
+
+
+ 460.23000000000002
+
+
+
+ 460.56999999999999
+
+
+
+ 457.79000000000002
+
+
+
+ 454.66000000000003
+
+
+
+
+
+
+
+ 624.7421875
+
+
+ 626.015625
+
+
+ 627.0625
+
+
+ 627.3671875
+
+
+ 626.90234375
+
+
+ 626.11328125
+
+
+ 625.33203125
+
+
+ 623.90625
+
+
+ 623.66796875
+
+
+ 623.71484375
+
+
+ 623.75
+
+
+ 623.9375
+
+
+ 624.1640625
+
+
+ 625.234375
+
+
+ 626
+
+
+ 626.3515625
+
+
+ 626.14453125
+
+
+ 625.6640625
+
+
+ 624.7890625
+
+
+ 623.23046875
+
+
+ 622.09375
+
+
+ 620.9765625
+
+
+ 620.23828125
+
+
+ 619.42578125
+
+
+ 617.7734375
+
+
+ 616.8671875
+
+
+ 616.09765625
+
+
+ 615.87890625
+
+
+ 615.3984375
+
+
+ 614.76953125
+
+
+ 613.47265625
+
+
+ 612.72265625
+
+
+ 612.4609375
+
+
+ 611.85546875
+
+
+ 611.90625
+
+
+ 612.27734375
+
+
+ 613.66796875
+
+
+ 614.62890625
+
+
+ 615.0703125
+
+
+ 614.72265625
+
+
+ 614.26171875
+
+
+ 612.06640625
+
+
+ 609.6875
+
+
+ 606.83984375
+
+
+ 604.671875
+
+
+ 602.52734375
+
+
+ 600.78515625
+
+
+ 598.078125
+
+
+ 597.1953125
+
+
+ 596.5234375
+
+
+ 595.74609375
+
+
+ 594.82421875
+
+
+ 594.10546875
+
+
+ 593.2109375
+
+
+ 592.6875
+
+
+ 592.5390625
+
+
+ 592.7578125
+
+
+ 592.77734375
+
+
+ 592.63671875
+
+
+ 592.06640625
+
+
+ 591.2578125
+
+
+ 590.46875
+
+
+ 589.7578125
+
+
+ 589.359375
+
+
+ 589.05859375
+
+
+ 589.21875
+
+
+ 589.59375
+
+
+ 589.98046875
+
+
+ 589.51953125
+
+
+ 588.796875
+
+
+ 587.4375
+
+
+ 585.70703125
+
+
+ 584.48046875
+
+
+ 583.328125
+
+
+ 582.69921875
+
+
+ 581.96875
+
+
+ 581.3359375
+
+
+ 580.6796875
+
+
+ 580.33984375
+
+
+ 580.0234375
+
+
+ 579.5078125
+
+
+ 578.890625
+
+
+ 578.34375
+
+
+ 577.984375
+
+
+ 577.90234375
+
+
+ 577.50390625
+
+
+ 577.20703125
+
+
+ 576.6171875
+
+
+ 575.82421875
+
+
+ 575.125
+
+
+ 575.0546875
+
+
+ 574.89453125
+
+
+ 574.75
+
+
+ 574.6484375
+
+
+ 574.26953125
+
+
+ 573.72265625
+
+
+ 572.4296875
+
+
+ 570.828125
+
+
+ 570.1015625
+
+
+ 568.7734375
+
+
+ 567.8125
+
+
+ 567.25390625
+
+
+ 567.09765625
+
+
+ 567.1640625
+
+
+ 567.546875
+
+
+ 567.86328125
+
+
+ 568.2890625
+
+
+ 568.49609375
+
+
+ 568.33203125
+
+
+ 566.84765625
+
+
+ 566.609375
+
+
+ 566.94140625
+
+
+ 566.88671875
+
+
+ 566.27734375
+
+
+ 565.48046875
+
+
+ 563.5
+
+
+ 562.51953125
+
+
+ 561.9453125
+
+
+ 561.85546875
+
+
+ 561.7578125
+
+
+ 561.765625
+
+
+ 561.453125
+
+
+ 560.6015625
+
+
+ 559.65234375
+
+
+ 558.7578125
+
+
+ 557.66015625
+
+
+ 556.35546875
+
+
+ 555.2265625
+
+
+ 553.53125
+
+
+ 551.265625
+
+
+ 549.92578125
+
+
+ 549.140625
+
+
+ 548.48828125
+
+
+ 548.0078125
+
+
+ 547.39453125
+
+
+ 547.15234375
+
+
+ 547.08203125
+
+
+ 547.55078125
+
+
+ 548.69921875
+
+
+ 548.76953125
+
+
+ 548.51953125
+
+
+ 547.88671875
+
+
+ 546.7265625
+
+
+ 545.3984375
+
+
+ 543.87890625
+
+
+ 540.6484375
+
+
+ 536.4296875
+
+
+ 536.046875
+
+
+ 535.765625
+
+
+ 535.71875
+
+
+ 535.55859375
+
+
+ 535.359375
+
+
+ 534.5234375
+
+
+ 534.2578125
+
+
+ 535.1328125
+
+
+ 535.46875
+
+
+ 535.04296875
+
+
+ 534.04296875
+
+
+ 532.234375
+
+
+ 530.2109375
+
+
+ 528.7890625
+
+
+ 527.69140625
+
+
+ 526.76171875
+
+
+ 526.1171875
+
+
+ 525.83984375
+
+
+ 525.51171875
+
+
+ 525.34375
+
+
+ 525.18359375
+
+
+ 524.3515625
+
+
+ 524.41015625
+
+
+ 524.47265625
+
+
+ 524.02734375
+
+
+ 523.09375
+
+
+ 521.92578125
+
+
+ 520.87109375
+
+
+ 520.51953125
+
+
+ 520.2578125
+
+
+ 519.6640625
+
+
+ 518.5703125
+
+
+ 517.04296875
+
+
+ 513.03125
+
+
+ 510.19921875
+
+
+ 508.5
+
+
+ 507.8828125
+
+
+ 506.71875
+
+
+ 506.03125
+
+
+ 505.5390625
+
+
+ 504.96875
+
+
+ 504.28125
+
+
+ 503.6640625
+
+
+ 502.578125
+
+
+ 500.921875
+
+
+ 499.85546875
+
+
+ 499.40234375
+
+
+ 498.96875
+
+
+ 497.8828125
+
+
+ 496.2265625
+
+
+ 494.9609375
+
+
+ 494.13671875
+
+
+ 493.6015625
+
+
+ 492.828125
+
+
+ 492.1015625
+
+
+ 491.76953125
+
+
+ 490.83984375
+
+
+ 490.23828125
+
+
+ 489.96484375
+
+
+ 489.703125
+
+
+ 484.7109375
+
+
+ 482.328125
+
+
+ 481.04296875
+
+
+ 480.3046875
+
+
+ 479.70703125
+
+
+ 478.984375
+
+
+ 478.4609375
+
+
+ 479.1015625
+
+
+ 480.359375
+
+
+ 481.19140625
+
+
+ 482.2890625
+
+
+ 483.28125
+
+
+ 483.69921875
+
+
+ 483.4609375
+
+
+ 483.0390625
+
+
+ 481.9140625
+
+
+ 480.515625
+
+
+ 479.16796875
+
+
+ 476.74609375
+
+
+ 474.3515625
+
+
+ 473.28515625
+
+
+ 472.39453125
+
+
+ 471.3671875
+
+
+ 470.0390625
+
+
+ 468.76171875
+
+
+ 467.3671875
+
+
+ 466.60546875
+
+
+ 464.65625
+
+
+ 463.62109375
+
+
+ 462.84375
+
+
+ 462.84765625
+
+
+
+
+
+
+ 647.81640625
+
+
+ 646.87109375
+
+
+ 646.1953125
+
+
+ 645.5859375
+
+
+ 644.8203125
+
+
+ 642.9765625
+
+
+ 641.796875
+
+
+ 639.4296875
+
+
+ 636.4921875
+
+
+ 634.1328125
+
+
+ 629.55859375
+
+
+ 627.55078125
+
+
+ 624.0234375
+
+
+
+
+
+
+ 663.90234375
+
+
+ 662.74609375
+
+
+ 662.1328125
+
+
+ 661.39453125
+
+
+ 658.98828125
+
+
+ 657.47265625
+
+
+ 654.22265625
+
+
+ 650.0703125
+
+
+ 647.890625
+
+
+
+
+
+
+ 421.52999999999997
+
+
+
+ 423.57999999999998
+
+
+
+ 423
+
+
+
+ 423.07999999999998
+
+
+
+ 423.02999999999997
+
+
+
+ 422.26999999999998
+
+
+
+ 421.35000000000002
+
+
+
+ 421.75
+
+
+
+ 421.48000000000002
+
+
+
+
+
Index: trunk/test/unit/org/openstreetmap/josm/data/gpx/GpxImageCorrelationTest.java
===================================================================
--- trunk/test/unit/org/openstreetmap/josm/data/gpx/GpxImageCorrelationTest.java (revision 14205)
+++ trunk/test/unit/org/openstreetmap/josm/data/gpx/GpxImageCorrelationTest.java (revision 14205)
@@ -0,0 +1,269 @@
+// License: GPL. For details, see LICENSE file.
+package org.openstreetmap.josm.data.gpx;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
+import java.util.Arrays;
+import java.util.List;
+
+import org.junit.BeforeClass;
+import org.junit.Rule;
+import org.junit.Test;
+import org.openstreetmap.josm.TestUtils;
+import org.openstreetmap.josm.data.coor.CachedLatLon;
+import org.openstreetmap.josm.io.GpxReaderTest;
+import org.openstreetmap.josm.spi.preferences.Config;
+import org.openstreetmap.josm.spi.preferences.IPreferences;
+import org.openstreetmap.josm.testutils.JOSMTestRules;
+import org.openstreetmap.josm.tools.date.DateUtils;
+import org.openstreetmap.josm.tools.date.DateUtilsTest;
+
+import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
+
+/**
+ * Unit tests of {@link GpxImageCorrelation} class.
+ */
+public class GpxImageCorrelationTest {
+
+ /**
+ * Setup test.
+ */
+ @Rule
+ @SuppressFBWarnings(value = "URF_UNREAD_PUBLIC_OR_PROTECTED_FIELD")
+ public JOSMTestRules test = new JOSMTestRules();
+
+ /**
+ * Setup test.
+ */
+ @BeforeClass
+ public static void setUp() {
+ DateUtilsTest.setTimeZone(DateUtils.UTC);
+ }
+
+ /**
+ * Tests matching of images to a GPX track.
+ * @throws Exception if the track cannot be parsed
+ */
+ @Test
+ public void testMatchGpxTrack() throws Exception {
+ IPreferences s = Config.getPref();
+ final GpxData gpx = GpxReaderTest.parseGpxData(TestUtils.getTestDataRoot() + "ImageCorrelationTest.gpx");
+ assertEquals(5, gpx.tracks.size());
+ assertEquals(1, gpx.tracks.iterator().next().getSegments().size());
+ assertEquals(128, gpx.tracks.iterator().next().getSegments().iterator().next().getWayPoints().size());
+
+ final GpxImageEntry ib = new GpxImageEntry();
+ ib.setExifTime(DateUtils.fromString("2016:01:03 11:54:58")); // 5 minutes before start of GPX
+ ib.createTmp();
+ final GpxImageEntry i0 = new GpxImageEntry();
+ i0.setExifTime(DateUtils.fromString("2016:01:03 11:59:54")); // 4 sec before start of GPX
+ i0.createTmp();
+ final GpxImageEntry i1 = new GpxImageEntry();
+ i1.setExifTime(DateUtils.fromString("2016:01:03 12:04:01"));
+ i1.createTmp();
+ final GpxImageEntry i2 = new GpxImageEntry();
+ i2.setExifTime(DateUtils.fromString("2016:01:03 12:04:57"));
+ i2.createTmp();
+ final GpxImageEntry i3 = new GpxImageEntry();
+ i3.setExifTime(DateUtils.fromString("2016:01:03 12:05:05"));
+ i3.createTmp();
+ final GpxImageEntry i4 = new GpxImageEntry(); //Image close to two points with elevation, but without time
+ i4.setExifTime(DateUtils.fromString("2016:01:03 12:05:20"));
+ i4.createTmp();
+ final GpxImageEntry i5 = new GpxImageEntry(); //between two tracks, closer to first
+ i5.setExifTime(DateUtils.fromString("2016:01:03 12:07:00"));
+ i5.createTmp();
+ final GpxImageEntry i6 = new GpxImageEntry(); //between two tracks, closer to second (more than 1 minute from any track)
+ i6.setExifTime(DateUtils.fromString("2016:01:03 12:07:45"));
+ i6.createTmp();
+
+ List images = Arrays.asList(ib, i0, i1, i2, i3, i4, i5, i6);
+
+ // TEST #1: default settings
+ // tag images within 2 minutes to tracks/segments, interpolate between segments only
+ assertEquals(7, GpxImageCorrelation.matchGpxTrack(images, gpx, 0, false));
+ assertEquals(null, ib.getPos());
+ assertEquals(new CachedLatLon(47.19286847859621, 8.79732714034617), i0.getPos()); // start of track
+ assertEquals(new CachedLatLon(47.196979885920882, 8.79541271366179), i1.getPos()); // exact match
+ assertEquals(new CachedLatLon(47.197319911792874, 8.792139580473304), i3.getPos()); // exact match
+ assertEquals(new CachedLatLon((47.197131179273129 + 47.197186248376966) / 2, (8.792974585667253 + 8.792809881269932) / 2),
+ i2.getPos()); // interpolated
+ assertEquals(new CachedLatLon(47.197568312311816, 8.790292849679897),
+ i4.getPos()); // interpolated between points without timestamp
+ assertEquals(new CachedLatLon(47.19819249585271, 8.78536943346262),
+ i5.getPos()); // tagged to last WP of first track, because closer and within 2 min (default setting)
+ assertEquals(new CachedLatLon(47.20138901844621, 8.774476982653141),
+ i6.getPos()); // tagged to first WP of second track, because closer and within 2 min (default setting)
+ assertFalse(ib.hasNewGpsData());
+ assertTrue(i0.hasNewGpsData() && i1.hasNewGpsData() && i2.hasNewGpsData() && i3.hasNewGpsData()
+ && i4.hasNewGpsData() && i5.hasNewGpsData() && i6.hasNewGpsData());
+ // First waypoint has no speed in matchGpxTrack(). Speed is calculated
+ // and not taken from GPX track.
+ assertEquals(null, ib.getSpeed());
+ assertEquals(null, i0.getSpeed());
+ assertEquals(Double.valueOf(11.675317966018756), i1.getSpeed(), 0.000001);
+ assertEquals(Double.valueOf(24.992418392716967), i2.getSpeed(), 0.000001);
+ assertEquals(Double.valueOf(27.307968754679223), i3.getSpeed(), 0.000001);
+ assertEquals(null, ib.getElevation());
+ assertEquals(null, i0.getElevation());
+ assertEquals(Double.valueOf(489.29), i1.getElevation(), 0.000001);
+ assertEquals(Double.valueOf((490.40 + 489.75) / 2), i2.getElevation(), 0.000001);
+ assertEquals(Double.valueOf(486.368333333), i3.getElevation(), 0.000001);
+ // interpolated elevation between trackpoints with interpolated timestamps
+ assertEquals(Double.valueOf(475.393978719), i4.getElevation(), 0.000001);
+ assertEquals(null, i5.getElevation());
+ assertEquals(null, i6.getElevation());
+
+ assertEquals(null, ib.getGpsTime());
+ assertEquals(DateUtils.fromString("2016:01:03 11:59:54"), i0.getGpsTime()); // original time is kept
+ assertEquals(DateUtils.fromString("2016:01:03 12:04:01"), i1.getGpsTime());
+ assertEquals(DateUtils.fromString("2016:01:03 12:04:57"), i2.getGpsTime());
+ assertEquals(DateUtils.fromString("2016:01:03 12:05:05"), i3.getGpsTime());
+
+ clearTmp(images);
+
+ // TEST #2: Disable all interpolation and tagging close to tracks. Only i1-i4 are tagged
+
+ s.putBoolean("geoimage.trk.tag", false);
+ s.putBoolean("geoimage.trk.int", false);
+ s.putBoolean("geoimage.seg.tag", false);
+ s.putBoolean("geoimage.seg.int", false);
+
+ assertEquals(4, GpxImageCorrelation.matchGpxTrack(images, gpx, 0, false));
+ assertEquals(null, ib.getPos());
+ assertEquals(null, i0.getPos());
+ assertEquals(new CachedLatLon(47.196979885920882, 8.79541271366179), i1.getPos());
+ assertEquals(new CachedLatLon((47.197131179273129 + 47.197186248376966) / 2, (8.792974585667253 + 8.792809881269932) / 2), i2.getPos());
+ assertEquals(new CachedLatLon(47.197319911792874, 8.792139580473304), i3.getPos());
+ assertEquals(new CachedLatLon(47.197568312311816, 8.790292849679897), i4.getPos());
+ assertEquals(null, i5.getPos());
+ assertEquals(null, i6.getPos());
+
+ clearTmp(images);
+
+ // TEST #3: Disable all interpolation and allow tagging within 1 minute of a track. i0-i5 are tagged.
+ // i6 will not be tagged, because it's 68 seconds away from the next waypoint in either direction
+
+ s.putBoolean("geoimage.trk.tag", true);
+ s.putBoolean("geoimage.trk.tag.time", true);
+ s.putInt("geoimage.trk.tag.time.val", 1);
+
+ s.putBoolean("geoimage.trk.int", false);
+ s.putBoolean("geoimage.seg.tag", false);
+ s.putBoolean("geoimage.seg.int", false);
+
+ assertEquals(6, GpxImageCorrelation.matchGpxTrack(images, gpx, 0, false));
+ assertEquals(null, ib.getPos());
+ assertEquals(new CachedLatLon(47.19286847859621, 8.79732714034617), i0.getPos());
+ assertEquals(new CachedLatLon(47.196979885920882, 8.79541271366179), i1.getPos());
+ assertEquals(new CachedLatLon((47.197131179273129 + 47.197186248376966) / 2, (8.792974585667253 + 8.792809881269932) / 2), i2.getPos());
+ assertEquals(new CachedLatLon(47.197319911792874, 8.792139580473304), i3.getPos());
+ assertEquals(new CachedLatLon(47.197568312311816, 8.790292849679897), i4.getPos());
+ assertEquals(new CachedLatLon(47.19819249585271, 8.78536943346262), i5.getPos());
+ assertEquals(null, i6.getPos());
+
+ clearTmp(images);
+
+ // TEST #4: Force tagging (parameter forceTags=true, no change of configuration). All images will be tagged
+ // i5-i6 will now be interpolated, therefore it will have an elevation and different coordinates than in tests above
+
+ assertEquals(8, GpxImageCorrelation.matchGpxTrack(images, gpx, 0, true));
+ assertEquals(new CachedLatLon(47.19286847859621, 8.79732714034617), ib.getPos());
+ assertEquals(new CachedLatLon(47.19286847859621, 8.79732714034617), i0.getPos());
+ assertEquals(new CachedLatLon(47.196979885920882, 8.79541271366179), i1.getPos());
+ assertEquals(new CachedLatLon((47.197131179273129 + 47.197186248376966) / 2, (8.792974585667253 + 8.792809881269932) / 2), i2.getPos());
+ assertEquals(new CachedLatLon(47.197319911792874, 8.792139580473304), i3.getPos());
+ assertEquals(new CachedLatLon(47.197568312311816, 8.790292849679897), i4.getPos());
+ assertEquals(new CachedLatLon(47.198845306804905, 8.783144918860685), i5.getPos()); // interpolated between tracks
+ assertEquals(new CachedLatLon(47.19985828931693, 8.77969308585768), i6.getPos()); // different values than in tests #1 and #3!
+
+ assertEquals(Double.valueOf(447.894014085), i5.getElevation(), 0.000001);
+ assertEquals(Double.valueOf(437.395070423), i6.getElevation(), 0.000001);
+
+ clearTmp(images);
+
+ // TEST #5: Force tagging (parameter forceTags=false, but configuration changed).
+ // Results same as #4
+
+ s.putBoolean("geoimage.trk.tag", true);
+ s.putBoolean("geoimage.trk.tag.time", false);
+ s.putBoolean("geoimage.trk.int", true);
+ s.putBoolean("geoimage.trk.int.time", false);
+ s.putBoolean("geoimage.trk.int.dist", false);
+ s.putBoolean("geoimage.seg.tag", false);
+ s.putBoolean("geoimage.seg.int", false);
+ s.putBoolean("geoimage.seg.tag.time", false);
+ s.putBoolean("geoimage.seg.int", true);
+ s.putBoolean("geoimage.seg.int.time", false);
+ s.putBoolean("geoimage.seg.int.dist", false);
+
+ assertEquals(8, GpxImageCorrelation.matchGpxTrack(images, gpx, 0, false));
+ assertEquals(new CachedLatLon(47.19286847859621, 8.79732714034617), ib.getPos());
+ assertEquals(new CachedLatLon(47.19286847859621, 8.79732714034617), i0.getPos());
+ assertEquals(new CachedLatLon(47.196979885920882, 8.79541271366179), i1.getPos());
+ assertEquals(new CachedLatLon((47.197131179273129 + 47.197186248376966) / 2, (8.792974585667253 + 8.792809881269932) / 2), i2.getPos());
+ assertEquals(new CachedLatLon(47.197319911792874, 8.792139580473304), i3.getPos());
+ assertEquals(new CachedLatLon(47.197568312311816, 8.790292849679897), i4.getPos());
+ assertEquals(new CachedLatLon(47.198845306804905, 8.783144918860685), i5.getPos());
+ assertEquals(new CachedLatLon(47.19985828931693, 8.77969308585768), i6.getPos());
+
+ assertEquals(Double.valueOf(447.894014085), i5.getElevation(), 0.000001);
+ assertEquals(Double.valueOf(437.395070423), i6.getElevation(), 0.000001);
+
+ clearTmp(images);
+
+ // TEST #6: Disable tagging but allow interpolation when tracks are less than 500m apart. i0-i4 are tagged.
+ // i5-i6 will not be tagged, because the tracks are 897m apart.
+ // not checking all the coordinates again, did that 5 times already, just the number of matched images
+
+ s.putBoolean("geoimage.trk.tag", false);
+ s.putBoolean("geoimage.trk.int", true);
+ s.putBoolean("geoimage.trk.int.time", false);
+ s.putBoolean("geoimage.trk.int.dist", true);
+ s.putInt("geoimage.trk.int.dist.val", 500);
+ s.putBoolean("geoimage.seg.tag", false);
+ s.putBoolean("geoimage.seg.int", false);
+
+ assertEquals(4, GpxImageCorrelation.matchGpxTrack(images, gpx, 0, false));
+ clearTmp(images);
+
+ // TEST #7: Disable tagging but allow interpolation when tracks are less than 1000m apart. i0-i6 are tagged.
+ // i5-i6 will be tagged, because the tracks are 897m apart.
+
+ s.putInt("geoimage.trk.int.dist.val", 1000);
+
+ assertEquals(6, GpxImageCorrelation.matchGpxTrack(images, gpx, 0, false));
+ clearTmp(images);
+
+ // TEST #8: Disable tagging but allow interpolation when tracks are less than 2 min apart. i0-i4 are tagged.
+ // i5-i6 will not be tagged, because the tracks are 2.5min apart.
+
+ s.putBoolean("geoimage.trk.tag", false);
+ s.putBoolean("geoimage.trk.int", true);
+ s.putBoolean("geoimage.trk.int.time", true);
+ s.putInt("geoimage.trk.int.time.val", 2);
+ s.putBoolean("geoimage.trk.int.dist", false);
+ s.putBoolean("geoimage.seg.tag", false);
+ s.putBoolean("geoimage.seg.int", false);
+
+ assertEquals(4, GpxImageCorrelation.matchGpxTrack(images, gpx, 0, false));
+ clearTmp(images);
+
+ // TEST #9: Disable tagging but allow interpolation when tracks are less than 3 min apart. i0-i6 are tagged.
+ // i5-i6 will be tagged, because the tracks are 2.5min apart.
+
+ s.putInt("geoimage.trk.int.time.val", 3);
+
+ assertEquals(6, GpxImageCorrelation.matchGpxTrack(images, gpx, 0, false));
+
+ }
+
+ private void clearTmp(List imgs) {
+ for (GpxImageEntry i : imgs) {
+ i.discardTmp();
+ i.createTmp();
+ }
+ }
+}
Index: trunk/test/unit/org/openstreetmap/josm/data/gpx/GpxOffsetTest.java
===================================================================
--- trunk/test/unit/org/openstreetmap/josm/data/gpx/GpxOffsetTest.java (revision 14205)
+++ trunk/test/unit/org/openstreetmap/josm/data/gpx/GpxOffsetTest.java (revision 14205)
@@ -0,0 +1,84 @@
+// License: GPL. For details, see LICENSE file.
+package org.openstreetmap.josm.data.gpx;
+
+import static org.junit.Assert.assertEquals;
+
+import java.text.ParseException;
+
+import org.junit.BeforeClass;
+import org.junit.Rule;
+import org.junit.Test;
+import org.openstreetmap.josm.testutils.JOSMTestRules;
+import org.openstreetmap.josm.tools.date.DateUtils;
+import org.openstreetmap.josm.tools.date.DateUtilsTest;
+
+import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
+
+/**
+ * Unit tests of {@link GpxTimeOffset} class.
+ */
+public class GpxOffsetTest {
+
+ /**
+ * Setup test.
+ */
+ @Rule
+ @SuppressFBWarnings(value = "URF_UNREAD_PUBLIC_OR_PROTECTED_FIELD")
+ public JOSMTestRules test = new JOSMTestRules();
+
+ /**
+ * Setup test.
+ */
+ @BeforeClass
+ public static void setUp() {
+ DateUtilsTest.setTimeZone(DateUtils.UTC);
+ }
+
+ /**
+ * Unit test of {@link GpxTimeOffset#formatOffset}.
+ */
+ @Test
+ public void testFormatOffset() {
+ assertEquals("0", GpxTimeOffset.seconds(0).formatOffset());
+ assertEquals("123", GpxTimeOffset.seconds(123).formatOffset());
+ assertEquals("-4242", GpxTimeOffset.seconds(-4242).formatOffset());
+ assertEquals("0.1", GpxTimeOffset.milliseconds(100).formatOffset());
+ assertEquals("0.120", GpxTimeOffset.milliseconds(120).formatOffset());
+ assertEquals("0.123", GpxTimeOffset.milliseconds(123).formatOffset());
+ assertEquals("1.2", GpxTimeOffset.milliseconds(1200).formatOffset());
+ assertEquals("1.234", GpxTimeOffset.milliseconds(1234).formatOffset());
+ }
+
+ /**
+ * Unit test of {@link GpxTimeOffset#parseOffset}.
+ * @throws ParseException in case of parsing error
+ */
+ @Test
+ public void testParseOffest() throws ParseException {
+ assertEquals(0, GpxTimeOffset.parseOffset("0").getSeconds());
+ assertEquals(4242L, GpxTimeOffset.parseOffset("4242").getSeconds());
+ assertEquals(-4242L, GpxTimeOffset.parseOffset("-4242").getSeconds());
+ assertEquals(0L, GpxTimeOffset.parseOffset("-0").getSeconds());
+ assertEquals(100L, GpxTimeOffset.parseOffset("0.1").getMilliseconds());
+ assertEquals(123L, GpxTimeOffset.parseOffset("0.123").getMilliseconds());
+ assertEquals(-42420L, GpxTimeOffset.parseOffset("-42.42").getMilliseconds());
+ }
+
+ /**
+ * Unit test of {@link GpxTimeOffset#splitOutTimezone}.
+ */
+ @Test
+ public void testSplitOutTimezone() {
+ assertEquals("+1:00", GpxTimeOffset.seconds(3602).splitOutTimezone().a.formatTimezone());
+ assertEquals("2", GpxTimeOffset.seconds(3602).splitOutTimezone().b.formatOffset());
+ assertEquals("-7:00", GpxTimeOffset.seconds(-7 * 3600 + 123).splitOutTimezone().a.formatTimezone());
+ assertEquals("123", GpxTimeOffset.seconds(-7 * 3600 + 123).splitOutTimezone().b.formatOffset());
+ assertEquals(1, GpxTimeOffset.seconds(35 * 3600 + 421).getDayOffset());
+ assertEquals(11 * 3600 + 421, GpxTimeOffset.seconds(35 * 3600 + 421).withoutDayOffset().getSeconds());
+ assertEquals("+11:00", GpxTimeOffset.seconds(35 * 3600 + 421).splitOutTimezone().a.formatTimezone());
+ assertEquals(86400 + 421, GpxTimeOffset.seconds(35 * 3600 + 421).splitOutTimezone().b.getSeconds());
+ assertEquals(421, GpxTimeOffset.seconds(35 * 3600 + 421).withoutDayOffset().splitOutTimezone().b.getSeconds());
+ assertEquals("+1:00", GpxTimeOffset.milliseconds(3602987).splitOutTimezone().a.formatTimezone());
+ assertEquals("2.987", GpxTimeOffset.milliseconds(3602987).splitOutTimezone().b.formatOffset());
+ }
+}
Index: trunk/test/unit/org/openstreetmap/josm/data/gpx/GpxTimezoneTest.java
===================================================================
--- trunk/test/unit/org/openstreetmap/josm/data/gpx/GpxTimezoneTest.java (revision 14205)
+++ trunk/test/unit/org/openstreetmap/josm/data/gpx/GpxTimezoneTest.java (revision 14205)
@@ -0,0 +1,61 @@
+// License: GPL. For details, see LICENSE file.
+package org.openstreetmap.josm.data.gpx;
+
+import static org.junit.Assert.assertEquals;
+
+import java.text.ParseException;
+
+import org.junit.BeforeClass;
+import org.junit.Rule;
+import org.junit.Test;
+import org.openstreetmap.josm.testutils.JOSMTestRules;
+import org.openstreetmap.josm.tools.date.DateUtils;
+import org.openstreetmap.josm.tools.date.DateUtilsTest;
+
+import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
+
+/**
+ * Unit tests of {@link GpxTimezone} class.
+ */
+public class GpxTimezoneTest {
+
+ /**
+ * Setup test.
+ */
+ @Rule
+ @SuppressFBWarnings(value = "URF_UNREAD_PUBLIC_OR_PROTECTED_FIELD")
+ public JOSMTestRules test = new JOSMTestRules();
+
+ /**
+ * Setup test.
+ */
+ @BeforeClass
+ public static void setUp() {
+ DateUtilsTest.setTimeZone(DateUtils.UTC);
+ }
+
+ /**
+ * Unit test of {@link GpxTimezone#formatTimezone}.
+ */
+ @Test
+ public void testFormatTimezone() {
+ assertEquals("+1:00", new GpxTimezone(1).formatTimezone());
+ assertEquals("+6:30", new GpxTimezone(6.5).formatTimezone());
+ assertEquals("-6:30", new GpxTimezone(-6.5).formatTimezone());
+ assertEquals("+3:08", new GpxTimezone(Math.PI).formatTimezone());
+ assertEquals("+2:43", new GpxTimezone(Math.E).formatTimezone());
+ }
+
+ /**
+ * Unit test of {@link GpxTimezone#parseTimezone}.
+ * @throws ParseException in case of parsing error
+ */
+ @Test
+ public void testParseTimezone() throws ParseException {
+ assertEquals(1, GpxTimezone.parseTimezone("+01:00").getHours(), 1e-3);
+ assertEquals(1, GpxTimezone.parseTimezone("+1:00").getHours(), 1e-3);
+ assertEquals(1.5, GpxTimezone.parseTimezone("+01:30").getHours(), 1e-3);
+ assertEquals(11.5, GpxTimezone.parseTimezone("+11:30").getHours(), 1e-3);
+ assertEquals(-11.5, GpxTimezone.parseTimezone("-11:30").getHours(), 1e-3);
+ }
+}
Index: trunk/test/unit/org/openstreetmap/josm/gui/layer/geoimage/CorrelateGpxWithImagesTest.java
===================================================================
--- trunk/test/unit/org/openstreetmap/josm/gui/layer/geoimage/CorrelateGpxWithImagesTest.java (revision 14202)
+++ trunk/test/unit/org/openstreetmap/josm/gui/layer/geoimage/CorrelateGpxWithImagesTest.java (revision 14205)
@@ -3,8 +3,5 @@
import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertTrue;
-import java.util.Arrays;
import java.util.Collections;
@@ -12,6 +9,7 @@
import org.junit.Rule;
import org.junit.Test;
-import org.openstreetmap.josm.data.coor.CachedLatLon;
import org.openstreetmap.josm.data.gpx.GpxData;
+import org.openstreetmap.josm.data.gpx.GpxTimeOffset;
+import org.openstreetmap.josm.data.gpx.GpxTimezone;
import org.openstreetmap.josm.io.GpxReaderTest;
import org.openstreetmap.josm.testutils.JOSMTestRules;
@@ -43,61 +41,4 @@
/**
- * Tests matching of images to a GPX track.
- * @throws Exception if the track cannot be parsed
- */
- @Test
- public void testMatchGpxTrack() throws Exception {
- final GpxData gpx = GpxReaderTest.parseGpxData("data_nodist/2094047.gpx");
- assertEquals(4, gpx.tracks.size());
- assertEquals(1, gpx.tracks.iterator().next().getSegments().size());
- assertEquals(185, gpx.tracks.iterator().next().getSegments().iterator().next().getWayPoints().size());
-
- final ImageEntry ib = new ImageEntry();
- ib.setExifTime(DateUtils.fromString("2016:01:03 11:54:58")); // 5 minutes before start of GPX
- ib.createTmp();
- final ImageEntry i0 = new ImageEntry();
- i0.setExifTime(DateUtils.fromString("2016:01:03 11:59:54")); // 4 sec before start of GPX
- i0.createTmp();
- final ImageEntry i1 = new ImageEntry();
- i1.setExifTime(DateUtils.fromString("2016:01:03 12:04:01"));
- i1.createTmp();
- final ImageEntry i2 = new ImageEntry();
- i2.setExifTime(DateUtils.fromString("2016:01:03 12:04:57"));
- i2.createTmp();
- final ImageEntry i3 = new ImageEntry();
- i3.setExifTime(DateUtils.fromString("2016:01:03 12:05:05"));
- i3.createTmp();
-
- assertEquals(4, CorrelateGpxWithImages.matchGpxTrack(Arrays.asList(ib, i0, i1, i2, i3), gpx, 0));
- assertEquals(new CachedLatLon(47.19286847859621, 8.79732714034617), i0.getPos()); // start of track
- assertEquals(new CachedLatLon(47.196979885920882, 8.79541271366179), i1.getPos()); // exact match
- assertEquals(new CachedLatLon(47.197319911792874, 8.792139580473304), i3.getPos()); // exact match
- assertEquals(new CachedLatLon((47.197131179273129 + 47.197186248376966) / 2, (8.792974585667253 + 8.792809881269932) / 2),
- i2.getPos()); // interpolated
- assertFalse(ib.hasNewGpsData());
- assertTrue(i0.hasNewGpsData());
- assertTrue(i1.hasNewGpsData());
- assertTrue(i2.hasNewGpsData());
- assertTrue(i3.hasNewGpsData());
- // First waypoint has no speed in matchGpxTrack(). Speed is calculated
- // and not taken from GPX track.
- assertEquals(null, ib.getSpeed());
- assertEquals(null, i0.getSpeed());
- assertEquals(Double.valueOf(11.675317966018756), i1.getSpeed(), 0.000001);
- assertEquals(Double.valueOf(24.992418392716967), i2.getSpeed(), 0.000001);
- assertEquals(Double.valueOf(27.307968754679223), i3.getSpeed(), 0.000001);
- assertEquals(null, ib.getElevation());
- assertEquals(Double.valueOf(471.86), i0.getElevation(), 0.000001);
- assertEquals(Double.valueOf(489.29), i1.getElevation(), 0.000001);
- assertEquals(Double.valueOf((490.40 + 489.75) / 2), i2.getElevation(), 0.000001);
- assertEquals(Double.valueOf(486.368333333), i3.getElevation(), 0.000001);
- assertEquals(null, ib.getGpsTime());
- assertEquals(DateUtils.fromString("2016:01:03 11:59:54"), i0.getGpsTime()); // original time is kept
- assertEquals(DateUtils.fromString("2016:01:03 12:04:01"), i1.getGpsTime());
- assertEquals(DateUtils.fromString("2016:01:03 12:04:57"), i2.getGpsTime());
- assertEquals(DateUtils.fromString("2016:01:03 12:05:05"), i3.getGpsTime());
- }
-
- /**
* Tests automatic guessing of timezone/offset
* @throws Exception if an error occurs
@@ -109,5 +50,5 @@
i0.setExifTime(DateUtils.fromString("2016:01:03 11:59:54")); // 4 sec before start of GPX
i0.createTmp();
- assertEquals(Pair.create(Timezone.ZERO, Offset.seconds(-4)),
+ assertEquals(Pair.create(GpxTimezone.ZERO, GpxTimeOffset.seconds(-4)),
CorrelateGpxWithImages.autoGuess(Collections.singletonList(i0), gpx));
}
Index: trunk/test/unit/org/openstreetmap/josm/gui/layer/geoimage/OffsetTest.java
===================================================================
--- trunk/test/unit/org/openstreetmap/josm/gui/layer/geoimage/OffsetTest.java (revision 14202)
+++ (revision )
@@ -1,84 +1,0 @@
-// License: GPL. For details, see LICENSE file.
-package org.openstreetmap.josm.gui.layer.geoimage;
-
-import static org.junit.Assert.assertEquals;
-
-import java.text.ParseException;
-
-import org.junit.BeforeClass;
-import org.junit.Rule;
-import org.junit.Test;
-import org.openstreetmap.josm.testutils.JOSMTestRules;
-import org.openstreetmap.josm.tools.date.DateUtils;
-import org.openstreetmap.josm.tools.date.DateUtilsTest;
-
-import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
-
-/**
- * Unit tests of {@link Offset} class.
- */
-public class OffsetTest {
-
- /**
- * Setup test.
- */
- @Rule
- @SuppressFBWarnings(value = "URF_UNREAD_PUBLIC_OR_PROTECTED_FIELD")
- public JOSMTestRules test = new JOSMTestRules();
-
- /**
- * Setup test.
- */
- @BeforeClass
- public static void setUp() {
- DateUtilsTest.setTimeZone(DateUtils.UTC);
- }
-
- /**
- * Unit test of {@link Offset#formatOffset}.
- */
- @Test
- public void testFormatOffset() {
- assertEquals("0", Offset.seconds(0).formatOffset());
- assertEquals("123", Offset.seconds(123).formatOffset());
- assertEquals("-4242", Offset.seconds(-4242).formatOffset());
- assertEquals("0.1", Offset.milliseconds(100).formatOffset());
- assertEquals("0.120", Offset.milliseconds(120).formatOffset());
- assertEquals("0.123", Offset.milliseconds(123).formatOffset());
- assertEquals("1.2", Offset.milliseconds(1200).formatOffset());
- assertEquals("1.234", Offset.milliseconds(1234).formatOffset());
- }
-
- /**
- * Unit test of {@link Offset#parseOffset}.
- * @throws ParseException in case of parsing error
- */
- @Test
- public void testParseOffest() throws ParseException {
- assertEquals(0, Offset.parseOffset("0").getSeconds());
- assertEquals(4242L, Offset.parseOffset("4242").getSeconds());
- assertEquals(-4242L, Offset.parseOffset("-4242").getSeconds());
- assertEquals(0L, Offset.parseOffset("-0").getSeconds());
- assertEquals(100L, Offset.parseOffset("0.1").getMilliseconds());
- assertEquals(123L, Offset.parseOffset("0.123").getMilliseconds());
- assertEquals(-42420L, Offset.parseOffset("-42.42").getMilliseconds());
- }
-
- /**
- * Unit test of {@link Offset#splitOutTimezone}.
- */
- @Test
- public void testSplitOutTimezone() {
- assertEquals("+1:00", Offset.seconds(3602).splitOutTimezone().a.formatTimezone());
- assertEquals("2", Offset.seconds(3602).splitOutTimezone().b.formatOffset());
- assertEquals("-7:00", Offset.seconds(-7 * 3600 + 123).splitOutTimezone().a.formatTimezone());
- assertEquals("123", Offset.seconds(-7 * 3600 + 123).splitOutTimezone().b.formatOffset());
- assertEquals(1, Offset.seconds(35 * 3600 + 421).getDayOffset());
- assertEquals(11 * 3600 + 421, Offset.seconds(35 * 3600 + 421).withoutDayOffset().getSeconds());
- assertEquals("+11:00", Offset.seconds(35 * 3600 + 421).splitOutTimezone().a.formatTimezone());
- assertEquals(86400 + 421, Offset.seconds(35 * 3600 + 421).splitOutTimezone().b.getSeconds());
- assertEquals(421, Offset.seconds(35 * 3600 + 421).withoutDayOffset().splitOutTimezone().b.getSeconds());
- assertEquals("+1:00", Offset.milliseconds(3602987).splitOutTimezone().a.formatTimezone());
- assertEquals("2.987", Offset.milliseconds(3602987).splitOutTimezone().b.formatOffset());
- }
-}
Index: trunk/test/unit/org/openstreetmap/josm/gui/layer/geoimage/TimezoneTest.java
===================================================================
--- trunk/test/unit/org/openstreetmap/josm/gui/layer/geoimage/TimezoneTest.java (revision 14202)
+++ (revision )
@@ -1,60 +1,0 @@
-// License: GPL. For details, see LICENSE file.
-package org.openstreetmap.josm.gui.layer.geoimage;
-
-import static org.junit.Assert.assertEquals;
-
-import java.text.ParseException;
-
-import org.junit.BeforeClass;
-import org.junit.Rule;
-import org.junit.Test;
-import org.openstreetmap.josm.testutils.JOSMTestRules;
-import org.openstreetmap.josm.tools.date.DateUtils;
-import org.openstreetmap.josm.tools.date.DateUtilsTest;
-
-import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
-
-/**
- * Unit tests of {@link Timezone} class.
- */
-public class TimezoneTest {
-
- /**
- * Setup test.
- */
- @Rule
- @SuppressFBWarnings(value = "URF_UNREAD_PUBLIC_OR_PROTECTED_FIELD")
- public JOSMTestRules test = new JOSMTestRules();
-
- /**
- * Setup test.
- */
- @BeforeClass
- public static void setUp() {
- DateUtilsTest.setTimeZone(DateUtils.UTC);
- }
-
- /**
- * Unit test of {@link Timezone#formatTimezone}.
- */
- @Test
- public void testFormatTimezone() {
- assertEquals("+1:00", new Timezone(1).formatTimezone());
- assertEquals("+6:30", new Timezone(6.5).formatTimezone());
- assertEquals("-6:30", new Timezone(-6.5).formatTimezone());
- assertEquals("+3:08", new Timezone(Math.PI).formatTimezone());
- assertEquals("+2:43", new Timezone(Math.E).formatTimezone());
- }
-
- /**
- * Unit test of {@link Timezone#parseTimezone}.
- * @throws ParseException in case of parsing error
- */
- @Test
- public void testParseTimezone() throws ParseException {
- assertEquals(1, Timezone.parseTimezone("+01:00").getHours(), 1e-3);
- assertEquals(1, Timezone.parseTimezone("+1:00").getHours(), 1e-3);
- assertEquals(1.5, Timezone.parseTimezone("+01:30").getHours(), 1e-3);
- assertEquals(11.5, Timezone.parseTimezone("+11:30").getHours(), 1e-3);
- }
-}