Changeset 14338 in josm

Timestamp:

2018-10-16T00:32:46+02:00 (6 years ago)

Author:

Don-vip

Message:

fix #16755 - Cut overlapping GPX layers when merging (patch by Bjoeni, modified)

Location:

trunk

Files:

• src/org/openstreetmap/josm/actions/AbstractMergeAction.java (modified) (6 diffs)
• src/org/openstreetmap/josm/actions/MergeLayerAction.java (modified) (3 diffs)
• src/org/openstreetmap/josm/data/gpx/GpxData.java (modified) (4 diffs)
• src/org/openstreetmap/josm/gui/dialogs/layer/MergeGpxLayerDialog.java (added)
• src/org/openstreetmap/josm/gui/layer/GpxLayer.java (modified) (1 diff)
• test/data/mergelayers (added)
• test/data/mergelayers/Layer1.gpx (added)
• test/data/mergelayers/Layer2.gpx (added)
• test/data/mergelayers/Merged-all.gpx (added)
• test/data/mergelayers/Merged-cut-connect.gpx (added)
• test/data/mergelayers/Merged-cut.gpx (added)
• test/unit/org/openstreetmap/josm/data/gpx/GpxDataTest.java (modified) (5 diffs)

trunk/src/org/openstreetmap/josm/actions/AbstractMergeAction.java

@@ -9 +9 @@
 
 import javax.swing.DefaultListCellRenderer;
+import javax.swing.JCheckBox;
 import javax.swing.JLabel;
 import javax.swing.JList;
@@ -40 +41 @@
             label.setToolTipText(layer.getToolTipText());
             return label;
+        }
+    }
+
+    /**
+     * <code>TargetLayerDialogResult</code> returned by {@link #askTargetLayer(List, String, boolean)}
+     * containing the selectedTargetLayer and whether the checkbox is ticked
+     * @param <T> type of layer
+     * @since 14338
+     */
+    public static class TargetLayerDialogResult<T extends Layer> {
+        /**
+         * The selected target layer of type T
+         */
+        public T selectedTargetLayer;
+        /**
+         * Whether the checkbox is ticked
+         */
+        public boolean checkboxTicked = false;
+
+        /**
+         * Constructs a new {@link TargetLayerDialogResult}
+         */
+        public TargetLayerDialogResult() {
+        }
+
+        /**
+         * Constructs a new {@link TargetLayerDialogResult}
+         * @param sel the selected target layer of type T
+         */
+        public TargetLayerDialogResult(T sel) {
+            selectedTargetLayer = sel;
+        }
+
+        /**
+         * Constructs a new {@link TargetLayerDialogResult}
+         * @param sel the selected target layer of type T
+         * @param ch whether the checkbox was ticked
+         */
+        public TargetLayerDialogResult(T sel, boolean ch) {
+            selectedTargetLayer = sel;
+            checkboxTicked = ch;
         }
     }
@@ -84 +126 @@
      */
     protected static Layer askTargetLayer(List<Layer> targetLayers) {
+        return askTargetLayer(targetLayers, false, null, false).selectedTargetLayer;
+    }
+
+    /**
+     * Ask user to choose the target layer and shows a checkbox.
+     * @param targetLayers list of candidate target layers.
+     * @param checkbox The text of the checkbox shown to the user.
+     * @param checkboxDefault whether the checkbox is ticked by default
+     * @return The {@link TargetLayerDialogResult} containing the chosen target layer and the state of the checkbox
+     */
+    protected static TargetLayerDialogResult<Layer> askTargetLayer(List<Layer> targetLayers, String checkbox, boolean checkboxDefault) {
+        return askTargetLayer(targetLayers, true, checkbox, checkboxDefault);
+    }
+
+    /**
+     * Ask user to choose the target layer and shows a checkbox.
+     * @param targetLayers list of candidate target layers.
+     * @param showCheckbox whether the checkbox is shown
+     * @param checkbox The text of the checkbox shown to the user.
+     * @param checkboxDefault whether the checkbox is ticked by default
+     * @return The {@link TargetLayerDialogResult} containing the chosen target layer and the state of the checkbox
+     */
+    protected static TargetLayerDialogResult<Layer> askTargetLayer(List<Layer> targetLayers, boolean showCheckbox,
+            String checkbox, boolean checkboxDefault) {
         return askTargetLayer(targetLayers.toArray(new Layer[0]),
-                tr("Please select the target layer."),
+                tr("Please select the target layer."), checkbox,
                 tr("Select target layer"),
-                tr("Merge"), "dialogs/mergedown");
-    }
-
-    /**
-     * Asks a target layer.
+                tr("Merge"), "dialogs/mergedown", showCheckbox, checkboxDefault);
+    }
+
+    /**
+     * Ask user to choose the target layer.
      * @param <T> type of layer
      * @param targetLayers array of proposed target layers
@@ -100 +166 @@
      * @return chosen target layer
      */
+    public static <T extends Layer> T askTargetLayer(T[] targetLayers, String label, String title, String buttonText, String buttonIcon) {
+        return askTargetLayer(targetLayers, label, null, title, buttonText, buttonIcon, false, false).selectedTargetLayer;
+    }
+
+    /**
+     * Ask user to choose the target layer. Can show a checkbox.
+     * @param <T> type of layer
+     * @param targetLayers array of proposed target layers
+     * @param label label displayed in dialog
+     * @param checkbox text of the checkbox displayed
+     * @param title title of dialog
+     * @param buttonText text of button used to select target layer
+     * @param buttonIcon icon name of button used to select target layer
+     * @param showCheckbox whether the checkbox is shown
+     * @param checkboxDefault whether the checkbox is ticked by default
+     * @return The {@link TargetLayerDialogResult} containing the chosen target layer and the state of the checkbox
+     * @since 14338
+     */
     @SuppressWarnings("unchecked")
-    public static <T extends Layer> T askTargetLayer(T[] targetLayers, String label, String title, String buttonText, String buttonIcon) {
+    public static <T extends Layer> TargetLayerDialogResult<T> askTargetLayer(T[] targetLayers, String label, String checkbox, String title,
+            String buttonText, String buttonIcon, boolean showCheckbox, boolean checkboxDefault) {
         JosmComboBox<T> layerList = new JosmComboBox<>(targetLayers);
         layerList.setRenderer(new LayerListCellRenderer());
@@ -109 +194 @@
         pnl.add(new JLabel(label), GBC.eol());
         pnl.add(layerList, GBC.eol().fill(GBC.HORIZONTAL));
+
+        JCheckBox cb = null;
+        if (showCheckbox) {
+            cb = new JCheckBox(checkbox);
+            cb.setSelected(checkboxDefault);
+            pnl.add(cb, GBC.eol());
+        }
 
         ExtendedDialog ed = new ExtendedDialog(MainApplication.getMainFrame(), title, buttonText, tr("Cancel"));
@@ -115 +207 @@
         ed.showDialog();
         if (ed.getValue() != 1) {
-            return null;
-        }
-        return (T) layerList.getSelectedItem();
+            return new TargetLayerDialogResult<>();
+        }
+        return new TargetLayerDialogResult<>((T) layerList.getSelectedItem(), cb != null && cb.isSelected());
     }
 

trunk/src/org/openstreetmap/josm/actions/MergeLayerAction.java

@@ -7 +7 @@
 import java.awt.event.ActionEvent;
 import java.awt.event.KeyEvent;
+import java.util.ArrayList;
 import java.util.Collection;
 import java.util.Collections;
@@ -14 +15 @@
 import org.openstreetmap.josm.gui.MainApplication;
 import org.openstreetmap.josm.gui.dialogs.LayerListDialog;
+import org.openstreetmap.josm.gui.dialogs.layer.MergeGpxLayerDialog;
+import org.openstreetmap.josm.gui.layer.GpxLayer;
 import org.openstreetmap.josm.gui.layer.Layer;
 import org.openstreetmap.josm.gui.layer.OsmDataLayer;
 import org.openstreetmap.josm.gui.util.GuiHelper;
+import org.openstreetmap.josm.spi.preferences.Config;
 import org.openstreetmap.josm.tools.ImageProvider;
 import org.openstreetmap.josm.tools.Logging;
@@ -48 +52 @@
      */
     protected Future<?> doMerge(List<Layer> targetLayers, final Collection<Layer> sourceLayers) {
-        final Layer targetLayer = askTargetLayer(targetLayers);
+        final boolean onlygpx = targetLayers.stream().noneMatch(l -> !(l instanceof GpxLayer));
+        final TargetLayerDialogResult<Layer> res = askTargetLayer(targetLayers, onlygpx,
+                tr("Cut timewise overlapping parts of tracks"),
+                onlygpx && Config.getPref().getBoolean("mergelayer.gpx.cut", false));
+        final Layer targetLayer = res.selectedTargetLayer;
         if (targetLayer == null)
             return null;
+
+        if (onlygpx) {
+            Config.getPref().putBoolean("mergelayer.gpx.cut", res.checkboxTicked);
+        }
+
         final Object actionName = getValue(NAME);
+        if (onlygpx && res.checkboxTicked) {
+            List<GpxLayer> layers = new ArrayList<>();
+            layers.add((GpxLayer) targetLayer);
+            for (Layer sl : sourceLayers) {
+                if (sl != null && !sl.equals(targetLayer)) {
+                    layers.add((GpxLayer) sl);
+                }
+            }
+            final MergeGpxLayerDialog d = new MergeGpxLayerDialog(MainApplication.getMainFrame(), layers);
+
+            if (d.showDialog().getValue() == 1) {
+
+                final boolean connect = d.connectCuts();
+                final List<GpxLayer> sortedLayers = d.getSortedLayers();
+
+                return MainApplication.worker.submit(() -> {
+                    final long start = System.currentTimeMillis();
+
+                    for (int i = sortedLayers.size() - 2; i >= 0; i--) {
+                        final GpxLayer lower = sortedLayers.get(i + 1);
+                        sortedLayers.get(i).mergeFrom(lower, true, connect);
+                        GuiHelper.runInEDTAndWait(() -> getLayerManager().removeLayer(lower));
+                    }
+
+                    Logging.info(tr("{0} completed in {1}", actionName, Utils.getDurationString(System.currentTimeMillis() - start)));
+                });
+            }
+        }
+
         return MainApplication.worker.submit(() -> {
-                final long start = System.currentTimeMillis();
-                boolean layerMerged = false;
-                for (final Layer sourceLayer: sourceLayers) {
-                    if (sourceLayer != null && !sourceLayer.equals(targetLayer)) {
-                        if (sourceLayer instanceof OsmDataLayer && targetLayer instanceof OsmDataLayer
-                                && ((OsmDataLayer) sourceLayer).isUploadDiscouraged() != ((OsmDataLayer) targetLayer).isUploadDiscouraged()
-                                && Boolean.TRUE.equals(GuiHelper.runInEDTAndWaitAndReturn(() ->
-                                    warnMergingUploadDiscouragedLayers(sourceLayer, targetLayer)))) {
-                            break;
-                        }
-                        targetLayer.mergeFrom(sourceLayer);
-                        GuiHelper.runInEDTAndWait(() -> getLayerManager().removeLayer(sourceLayer));
-                        layerMerged = true;
+            final long start = System.currentTimeMillis();
+            boolean layerMerged = false;
+            for (final Layer sourceLayer: sourceLayers) {
+                if (sourceLayer != null && !sourceLayer.equals(targetLayer)) {
+                    if (sourceLayer instanceof OsmDataLayer && targetLayer instanceof OsmDataLayer
+                            && ((OsmDataLayer) sourceLayer).isUploadDiscouraged() != ((OsmDataLayer) targetLayer).isUploadDiscouraged()
+                            && Boolean.TRUE.equals(GuiHelper.runInEDTAndWaitAndReturn(() ->
+                            warnMergingUploadDiscouragedLayers(sourceLayer, targetLayer)))) {
+                        break;
                     }
+                    targetLayer.mergeFrom(sourceLayer);
+                    GuiHelper.runInEDTAndWait(() -> getLayerManager().removeLayer(sourceLayer));
+                    layerMerged = true;
                 }
-                if (layerMerged) {
-                    getLayerManager().setActiveLayer(targetLayer);
-                    Logging.info(tr("{0} completed in {1}", actionName, Utils.getDurationString(System.currentTimeMillis() - start)));
-                }
+            }
+
+            if (layerMerged) {
+                getLayerManager().setActiveLayer(targetLayer);
+                Logging.info(tr("{0} completed in {1}", actionName, Utils.getDurationString(System.currentTimeMillis() - start)));
+            }
         });
     }

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

@@ -59 +59 @@
     private final ArrayList<GpxTrack> privateTracks = new ArrayList<>();
     /**
-     * GXP routes in this file
+     * GPX routes in this file
      */
     private final ArrayList<GpxRoute> privateRoutes = new ArrayList<>();
@@ -109 +109 @@
     private final ListenerList<GpxDataChangeListener> listeners = ListenerList.create();
 
+    static class TimestampConfictException extends Exception {}
+
+    private List<GpxTrackSegmentSpan> segSpans;
+
     /**
      * Merges data from another object.
@@ -114 +118 @@
      */
     public synchronized void mergeFrom(GpxData other) {
+        mergeFrom(other, false, false);
+    }
+
+    /**
+     * Merges data from another object.
+     * @param other existing GPX data
+     * @param cutOverlapping whether overlapping parts of the given track should be removed
+     * @param connect whether the tracks should be connected on cuts
+     * @since 14338
+     */
+    public synchronized void mergeFrom(GpxData other, boolean cutOverlapping, boolean connect) {
         if (storageFile == null && other.storageFile != null) {
             storageFile = other.storageFile;
@@ -131 +146 @@
             }
         }
-        other.privateTracks.forEach(this::addTrack);
+
+        if (cutOverlapping) {
+            for (GpxTrack trk : other.privateTracks) {
+                cutOverlapping(trk, connect);
+            }
+        } else {
+            other.privateTracks.forEach(this::addTrack);
+        }
         other.privateRoutes.forEach(this::addRoute);
         other.privateWaypoints.forEach(this::addWaypoint);
         dataSources.addAll(other.dataSources);
         fireInvalidate();
+    }
+
+    private void cutOverlapping(GpxTrack trk, boolean connect) {
+        List<GpxTrackSegment> segsOld = new ArrayList<>(trk.getSegments());
+        List<GpxTrackSegment> segsNew = new ArrayList<>();
+        for (GpxTrackSegment seg : segsOld) {
+            GpxTrackSegmentSpan s = GpxTrackSegmentSpan.tryGetFromSegment(seg);
+            if (s != null && anySegmentOverlapsWith(s)) {
+                List<WayPoint> wpsNew = new ArrayList<>();
+                List<WayPoint> wpsOld = new ArrayList<>(seg.getWayPoints());
+                if (s.isInverted()) {
+                    Collections.reverse(wpsOld);
+                }
+                boolean split = false;
+                WayPoint prevLastOwnWp = null;
+                Date prevWpTime = null;
+                for (WayPoint wp : wpsOld) {
+                    Date wpTime = wp.setTimeFromAttribute();
+                    boolean overlap = false;
+                    if (wpTime != null) {
+                        for (GpxTrackSegmentSpan ownspan : getSegmentSpans()) {
+                            if (wpTime.after(ownspan.firstTime) && wpTime.before(ownspan.lastTime)) {
+                                overlap = true;
+                                if (connect) {
+                                    if (!split) {
+                                        wpsNew.add(ownspan.getFirstWp());
+                                    } else {
+                                        connectTracks(prevLastOwnWp, ownspan, trk.getAttributes());
+                                    }
+                                    prevLastOwnWp = ownspan.getLastWp();
+                                }
+                                split = true;
+                                break;
+                            } else if (connect && prevWpTime != null
+                                    && prevWpTime.before(ownspan.firstTime)
+                                    && wpTime.after(ownspan.lastTime)) {
+                                // the overlapping high priority track is shorter than the distance
+                                // between two waypoints of the low priority track
+                                if (split) {
+                                    connectTracks(prevLastOwnWp, ownspan, trk.getAttributes());
+                                    prevLastOwnWp = ownspan.getLastWp();
+                                } else {
+                                    wpsNew.add(ownspan.getFirstWp());
+                                    // splitting needs to be handled here,
+                                    // because other high priority tracks between the same waypoints could follow
+                                    if (!wpsNew.isEmpty()) {
+                                        segsNew.add(new ImmutableGpxTrackSegment(wpsNew));
+                                    }
+                                    if (!segsNew.isEmpty()) {
+                                        privateTracks.add(new ImmutableGpxTrack(segsNew, trk.getAttributes()));
+                                    }
+                                    segsNew = new ArrayList<>();
+                                    wpsNew = new ArrayList<>();
+                                    wpsNew.add(ownspan.getLastWp());
+                                    // therefore no break, because another segment could overlap, see above
+                                }
+                            }
+                        }
+                        prevWpTime = wpTime;
+                    }
+                    if (!overlap) {
+                        if (split) {
+                            //track has to be split, because we have an overlapping short track in the middle
+                            if (!wpsNew.isEmpty()) {
+                                segsNew.add(new ImmutableGpxTrackSegment(wpsNew));
+                            }
+                            if (!segsNew.isEmpty()) {
+                                privateTracks.add(new ImmutableGpxTrack(segsNew, trk.getAttributes()));
+                            }
+                            segsNew = new ArrayList<>();
+                            wpsNew = new ArrayList<>();
+                            if (connect && prevLastOwnWp != null) {
+                                wpsNew.add(new WayPoint(prevLastOwnWp));
+                            }
+                            prevLastOwnWp = null;
+                            split = false;
+                        }
+                        wpsNew.add(new WayPoint(wp));
+                    }
+                }
+                if (!wpsNew.isEmpty()) {
+                    segsNew.add(new ImmutableGpxTrackSegment(wpsNew));
+                }
+            } else {
+                segsNew.add(seg);
+            }
+        }
+        if (segsNew.equals(segsOld)) {
+            privateTracks.add(trk);
+        } else if (!segsNew.isEmpty()) {
+            privateTracks.add(new ImmutableGpxTrack(segsNew, trk.getAttributes()));
+        }
+    }
+
+    private void connectTracks(WayPoint prevWp, GpxTrackSegmentSpan span, Map<String, Object> attr) {
+        if (prevWp != null && !span.lastEquals(prevWp)) {
+            privateTracks.add(new ImmutableGpxTrack(Arrays.asList(Arrays.asList(new WayPoint(prevWp), span.getFirstWp())), attr));
+        }
+    }
+
+    static class GpxTrackSegmentSpan {
+
+        public final Date firstTime;
+        public final Date lastTime;
+        private final boolean inv;
+        private final WayPoint firstWp;
+        private final WayPoint lastWp;
+
+        GpxTrackSegmentSpan(WayPoint a, WayPoint b) {
+            Date at = a.getTime();
+            Date bt = b.getTime();
+            inv = bt.before(at);
+            if (inv) {
+                firstWp = b;
+                firstTime = bt;
+                lastWp = a;
+                lastTime = at;
+            } else {
+                firstWp = a;
+                firstTime = at;
+                lastWp = b;
+                lastTime = bt;
+            }
+        }
+
+        public WayPoint getFirstWp() {
+            return new WayPoint(firstWp);
+        }
+
+        public WayPoint getLastWp() {
+            return new WayPoint(lastWp);
+        }
+
+        // no new instances needed, therefore own methods for that
+
+        public boolean firstEquals(Object other) {
+            return firstWp.equals(other);
+        }
+
+        public boolean lastEquals(Object other) {
+            return lastWp.equals(other);
+        }
+
+        public boolean isInverted() {
+            return inv;
+        }
+
+        public boolean overlapsWith(GpxTrackSegmentSpan other) {
+            return (firstTime.before(other.lastTime) && other.firstTime.before(lastTime))
+                || (other.firstTime.before(lastTime) && firstTime.before(other.lastTime));
+        }
+
+        public static GpxTrackSegmentSpan tryGetFromSegment(GpxTrackSegment seg) {
+            WayPoint b = getNextWpWithTime(seg, true);
+            if (b != null) {
+                WayPoint e = getNextWpWithTime(seg, false);
+                if (e != null) {
+                    return new GpxTrackSegmentSpan(b, e);
+                }
+            }
+            return null;
+        }
+
+        private static WayPoint getNextWpWithTime(GpxTrackSegment seg, boolean forward) {
+            List<WayPoint> wps = new ArrayList<>(seg.getWayPoints());
+            for (int i = forward ? 0 : wps.size() - 1; i >= 0 && i < wps.size(); i += forward ? 1 : -1) {
+                if (wps.get(i).setTimeFromAttribute() != null) {
+                    return wps.get(i);
+                }
+            }
+            return null;
+        }
+    }
+
+    /**
+     * Get a list of SegmentSpans containing the beginning and end of each segment
+     * @return the list of SegmentSpans
+     * @since 14338
+     */
+    public synchronized List<GpxTrackSegmentSpan> getSegmentSpans() {
+        if (segSpans == null) {
+            segSpans = new ArrayList<>();
+            for (GpxTrack trk : privateTracks) {
+                for (GpxTrackSegment seg : trk.getSegments()) {
+                    GpxTrackSegmentSpan s = GpxTrackSegmentSpan.tryGetFromSegment(seg);
+                    if (s != null) {
+                        segSpans.add(s);
+                    }
+                }
+            }
+            segSpans.sort((o1, o2) -> {
+                return o1.firstTime.compareTo(o2.firstTime);
+            });
+        }
+        return segSpans;
+    }
+
+    private boolean anySegmentOverlapsWith(GpxTrackSegmentSpan other) {
+        for (GpxTrackSegmentSpan s : getSegmentSpans()) {
+            if (s.overlapsWith(other)) {
+                return true;
+            }
+        }
+        return false;
     }
 

trunk/src/org/openstreetmap/josm/gui/layer/GpxLayer.java

@@ -307 +307 @@
         if (!(from instanceof GpxLayer))
             throw new IllegalArgumentException("not a GpxLayer: " + from);
-        data.mergeFrom(((GpxLayer) from).data);
+        mergeFrom((GpxLayer) from, false, false);
+    }
+
+    /**
+     * Merges the given GpxLayer into this layer and can remove timewise overlapping parts of the given track
+     * @param from The GpxLayer that gets merged into this one
+     * @param cutOverlapping whether overlapping parts of the given track should be removed
+     * @param connect whether the tracks should be connected on cuts
+     * @since 14338
+     */
+    public void mergeFrom(GpxLayer from, boolean cutOverlapping, boolean connect) {
+        data.mergeFrom(from.data, cutOverlapping, connect);
         invalidate();
     }

trunk/test/unit/org/openstreetmap/josm/data/gpx/GpxDataTest.java

@@ -8 +8 @@
 import static org.junit.Assert.assertTrue;
 
+import java.io.IOException;
 import java.util.ArrayList;
 import java.util.Arrays;
@@ -28 +29 @@
 import org.openstreetmap.josm.data.gpx.GpxData.GpxDataChangeListener;
 import org.openstreetmap.josm.data.projection.ProjectionRegistry;
+import org.openstreetmap.josm.io.GpxReaderTest;
 import org.openstreetmap.josm.testutils.JOSMTestRules;
 import org.openstreetmap.josm.tools.ListenerList;
+import org.xml.sax.SAXException;
 
 import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
@@ -55 +58 @@
         data = new GpxData();
     }
-
 
     /**
@@ -83 +85 @@
         assertTrue(data.getWaypoints().contains(newWP));
         assertTrue(data.getWaypoints().contains(existingWP));
+    }
+
+    /**
+     * Test method for {@link GpxData#mergeFrom(GpxData, boolean, boolean)} including cutting/connecting tracks using actual files.
+     * @throws Exception if the track cannot be parsed
+     */
+    @Test
+    public void testMergeFromFiles() throws Exception {
+        testMerge(false, false, "Merged-all"); // regular merging
+        testMerge(true, false, "Merged-cut"); // cut overlapping tracks, but do not connect them
+        testMerge(true, true, "Merged-cut-connect"); // cut overlapping tracks and connect them
+    }
+
+    private static void testMerge(boolean cut, boolean connect, String exp) throws IOException, SAXException {
+        final GpxData own = getGpx("Layer1");
+        final GpxData other = getGpx("Layer2");
+        final GpxData expected = getGpx(exp);
+        own.mergeFrom(other, cut, connect);
+        assertEquals(expected, own);
+    }
+
+    private static GpxData getGpx(String file) throws IOException, SAXException {
+        return GpxReaderTest.parseGpxData(TestUtils.getTestDataRoot() + "mergelayers/" + file + ".gpx");
     }
 
@@ -449 +474 @@
         TestUtils.assumeWorkingEqualsVerifier();
         EqualsVerifier.forClass(GpxData.class).usingGetClass()
-            .withIgnoredFields("attr", "creator", "fromServer", "storageFile", "listeners", "tracks", "routes", "waypoints", "proxy")
+            .withIgnoredFields("attr", "creator", "fromServer", "storageFile", "listeners", "tracks", "routes", "waypoints", "proxy", "segSpans")
             .withPrefabValues(WayPoint.class, new WayPoint(LatLon.NORTH_POLE), new WayPoint(LatLon.SOUTH_POLE))
             .withPrefabValues(ListenerList.class, ListenerList.create(), ListenerList.create())