--- /dev/null
+package tim.prune.function.sew;
+
+import java.util.TreeSet;
+
+import tim.prune.App;
+import tim.prune.GenericFunction;
+import tim.prune.I18nManager;
+import tim.prune.UpdateMessageBroker;
+import tim.prune.data.DataPoint;
+import tim.prune.data.Track;
+import tim.prune.function.Cancellable;
+import tim.prune.gui.GenericProgressDialog;
+import tim.prune.undo.UndoException;
+import tim.prune.undo.UndoSewSegments;
+
+/**
+ * Function to sew the track segments together if possible,
+ * reversing and moving as required
+ */
+public class SewTrackSegmentsFunction extends GenericFunction implements Runnable, Cancellable
+{
+ /** Set of sorted segment endpoints */
+ private TreeSet<SegmentEnd> _nodes = null;
+ /** Cancel flag */
+ private boolean _cancelled = false;
+
+
+ /** Constructor */
+ public SewTrackSegmentsFunction(App inApp) {
+ super(inApp);
+ }
+
+ /** @return name key */
+ public String getNameKey() {
+ return "function.sewsegments";
+ }
+
+ /**
+ * Execute the function
+ */
+ public void begin()
+ {
+ // Run in separate thread, with progress bar
+ new Thread(this).start();
+ }
+
+ /**
+ * Run the function in a separate thread
+ */
+ public void run()
+ {
+ // Make a progress bar
+ GenericProgressDialog progressDialog = new GenericProgressDialog(getNameKey(), null, _parentFrame, this);
+ progressDialog.show();
+ // Make an undo object to store the current points and sequence
+ UndoSewSegments undo = new UndoSewSegments(_app.getTrackInfo().getTrack());
+
+ // Make list of all the segment ends
+ _nodes = buildNodeList(_app.getTrackInfo().getTrack());
+ final int numNodes = (_nodes == null ? 0 : _nodes.size());
+ if (numNodes < 4)
+ {
+ System.out.println("Can't do anything with this, not enough segments");
+ progressDialog.close();
+ }
+ else
+ {
+ progressDialog.showProgress(10, 100); // Say 10% for building the nodes
+
+ // Disable messaging because we're probably doing a lot of reverses and moves
+ UpdateMessageBroker.enableMessaging(false);
+ // Set now contains all pairs of segment ends, ends at the same location are adjacent
+ // Now we're just interested in pairs of nodes, not three or more at the same location
+ SegmentEnd firstNode = null, secondNode = null;
+ int numJoins = 0, currNode = 0;
+ for (SegmentEnd node : _nodes)
+ {
+ if (!node.isActive()) {continue;}
+ if (firstNode == null)
+ {
+ firstNode = node;
+ }
+ else if (secondNode == null)
+ {
+ if (node.atSamePointAs(firstNode)) {
+ secondNode = node;
+ }
+ else {
+ firstNode = node;
+ }
+ }
+ else if (node.atSamePointAs(secondNode))
+ {
+ // Found three colocated nodes, not interested
+ firstNode = secondNode = null;
+ }
+ else
+ {
+ // Found a pair
+ joinSegments(firstNode, secondNode);
+ numJoins++;
+ firstNode = node; secondNode = null;
+ }
+ if (_cancelled) {break;}
+ final double fractionDone = 1.0 * currNode / numNodes;
+ progressDialog.showProgress(10 + (int) (fractionDone * 80), 100);
+ currNode++;
+ }
+ if (firstNode != null && secondNode != null)
+ {
+ joinSegments(firstNode, secondNode);
+ numJoins++;
+ }
+
+ progressDialog.showProgress(90, 100); // Say 90%, only duplicate point deletion left
+
+ // Delete the duplicate points
+ final int numDeleted = _cancelled ? 0 : deleteSegmentStartPoints(_app.getTrackInfo().getTrack());
+
+ progressDialog.close();
+ // Enable the messaging again
+ UpdateMessageBroker.enableMessaging(true);
+ if (_cancelled) // TODO: Also revert if any of the operations failed
+ {
+ // try to restore using undo object
+ try {
+ undo.performUndo(_app.getTrackInfo());
+ }
+ catch (UndoException ue) {
+ _app.showErrorMessage("oops", "CANNOT UNDO");
+ }
+ }
+ else if (numJoins > 0 || numDeleted > 0)
+ {
+ // Give Undo object back to App to confirm
+ final String confirmMessage = (numJoins > 0 ? I18nManager.getTextWithNumber("confirm.sewsegments", numJoins)
+ : "" + numDeleted + " " + I18nManager.getText("confirm.deletepoint.multi"));
+ _app.completeFunction(undo, confirmMessage);
+ UpdateMessageBroker.informSubscribers();
+ }
+ else
+ {
+ // Nothing done
+ _app.showErrorMessageNoLookup(getNameKey(), I18nManager.getTextWithNumber("error.sewsegments.nothingdone", numNodes/2));
+ }
+ }
+ }
+
+ /**
+ * Build a sorted list of all the segment start points and end points
+ * Creates a TreeSet containing two SegmentEnd objects for each segment
+ * @param inTrack track object
+ * @return sorted list of segment ends
+ */
+ private static TreeSet<SegmentEnd> buildNodeList(Track inTrack)
+ {
+ TreeSet<SegmentEnd> nodes = new TreeSet<SegmentEnd>();
+ final int numPoints = inTrack.getNumPoints();
+ DataPoint prevTrackPoint = null;
+ int prevTrackPointIndex = -1;
+ SegmentEnd segmentStart = null;
+ for (int i=0; i<numPoints; i++)
+ {
+ DataPoint point = inTrack.getPoint(i);
+ if (!point.isWaypoint() && !point.hasMedia())
+ {
+ if (point.getSegmentStart())
+ {
+ // Start of new segment - does previous one need to be saved?
+ if (segmentStart != null && prevTrackPointIndex > 0 && prevTrackPointIndex != segmentStart.getPointIndex())
+ {
+ // Finish previous segment and store in list
+ SegmentEnd segmentEnd = new SegmentEnd(prevTrackPoint, prevTrackPointIndex);
+ segmentStart.setOtherEnd(segmentEnd);
+ segmentEnd.setOtherEnd(segmentStart);
+ // Don't add closed loops
+ if (!segmentStart.atSamePointAs(segmentEnd))
+ {
+ nodes.add(segmentStart);
+ nodes.add(segmentEnd);
+ }
+ }
+ // Remember segment start
+ segmentStart = new SegmentEnd(point, i);
+ }
+ prevTrackPoint = point;
+ prevTrackPointIndex = i;
+ }
+ }
+ // Probably need to deal with segmentStart and prevTrackPoint, prevTrackPointIndex
+ if (segmentStart != null && prevTrackPointIndex > 0 && prevTrackPointIndex != segmentStart.getPointIndex())
+ {
+ // Finish last segment and store in list
+ SegmentEnd segmentEnd = new SegmentEnd(prevTrackPoint, prevTrackPointIndex);
+ segmentStart.setOtherEnd(segmentEnd);
+ segmentEnd.setOtherEnd(segmentStart);
+ // Don't add closed loops
+ if (!segmentStart.atSamePointAs(segmentEnd))
+ {
+ nodes.add(segmentStart);
+ nodes.add(segmentEnd);
+ }
+ }
+ return nodes;
+ }
+
+ /**
+ * Join the two segments together represented by the given nodes
+ * @param inFirstNode first node (order doesn't matter)
+ * @param inSecondNode other node
+ */
+ private void joinSegments(SegmentEnd inFirstNode, SegmentEnd inSecondNode)
+ {
+ final Track track = _app.getTrackInfo().getTrack();
+ // System.out.println("Join: (" + inFirstNode.getPointIndex() + "-" + inFirstNode.getOtherPointIndex() + ") with ("
+ // + inSecondNode.getPointIndex() + "-" + inSecondNode.getOtherPointIndex() + ")");
+ // System.out.println(" : " + (inFirstNode.isStart() ? "start" : "end") + " to " + (inSecondNode.isStart() ? "start" : "end"));
+ final boolean moveSecondBeforeFirst = inFirstNode.isStart();
+ if (inFirstNode.isStart() == inSecondNode.isStart())
+ {
+ if (track.reverseRange(inSecondNode.getEarlierIndex(), inSecondNode.getLaterIndex()))
+ {
+ inSecondNode.reverseSegment();
+ // System.out.println(" : Reverse segment: " + inSecondNode.getEarlierIndex() + " - " + inSecondNode.getLaterIndex());
+ }
+ else {
+ System.err.println("Oops, reverse range didn't work");
+ // TODO: Abort?
+ }
+ }
+ if (moveSecondBeforeFirst)
+ {
+ if ((inSecondNode.getLaterIndex()+1) != inFirstNode.getPointIndex())
+ {
+ // System.out.println(" : Move second segment before first");
+ cutAndMoveSegment(inSecondNode.getEarlierIndex(), inSecondNode.getLaterIndex(), inFirstNode.getPointIndex());
+ }
+ }
+ else if ((inFirstNode.getLaterIndex()+1) != inSecondNode.getPointIndex())
+ {
+ // System.out.println(" : Move first segment before second (because " + (inFirstNode.getLaterIndex()+1) + " isn't " + inSecondNode.getPointIndex() + ")");
+ cutAndMoveSegment(inFirstNode.getEarlierIndex(), inFirstNode.getLaterIndex(), inSecondNode.getPointIndex());
+ }
+ // Now merge the SegmentEnds so that they're not split up again
+ if (inSecondNode.getEarlierIndex() == (inFirstNode.getLaterIndex()+1)) {
+ // System.out.println("second node is now directly after the first node");
+ }
+ else if (inFirstNode.getEarlierIndex() == (inSecondNode.getLaterIndex()+1)) {
+ //System.out.println("first node is now directly after the second node");
+ }
+ else {
+ System.err.println("Why aren't the segments directly consecutive after the join?");
+ }
+ // Find the earliest and latest ends of these two segments
+ SegmentEnd earlierSegmentEnd = (inFirstNode.getEarlierIndex() < inSecondNode.getEarlierIndex() ? inFirstNode : inSecondNode).getEarlierEnd();
+ SegmentEnd laterSegmentEnd = (inFirstNode.getLaterIndex() > inSecondNode.getLaterIndex() ? inFirstNode : inSecondNode).getLaterEnd();
+ // Get rid of the inner two segment ends, join the earliest and latest together
+ earlierSegmentEnd.getOtherEnd().deactivate();
+ laterSegmentEnd.getOtherEnd().deactivate();
+ earlierSegmentEnd.setOtherEnd(laterSegmentEnd);
+ laterSegmentEnd.setOtherEnd(earlierSegmentEnd);
+ }
+
+ /**
+ * Cut and move the segment to a different position
+ * @param inSegmentStart start index of segment
+ * @param inSegmentEnd end index of segment
+ * @param inMoveToPos index before which the segment should be moved
+ */
+ private void cutAndMoveSegment(int inSegmentStart, int inSegmentEnd, int inMoveToPos)
+ {
+ if (!_app.getTrackInfo().getTrack().cutAndMoveSection(inSegmentStart, inSegmentEnd, inMoveToPos))
+ {
+ System.err.println(" Oops, cut and move didn't work");
+ // TODO: Throw exception? Return false?
+ }
+ else
+ {
+ // Loop over each node to inform it of the index changes
+ for (SegmentEnd node : _nodes) {
+ node.adjustPointIndex(inSegmentStart, inSegmentEnd, inMoveToPos);
+ }
+ }
+ }
+
+ /**
+ * The final step of the sewing, removing the duplicate points at the start of each segment
+ * @param inTrack track object
+ * @return number of points deleted
+ */
+ private static int deleteSegmentStartPoints(Track inTrack)
+ {
+ final int numPoints = inTrack.getNumPoints();
+ boolean[] deleteFlags = new boolean[numPoints];
+ // Loop over points in track, setting delete flags
+ int numToDelete = 0;
+ DataPoint prevPoint = null;
+ for (int i=0; i<numPoints; i++)
+ {
+ DataPoint point = inTrack.getPoint(i);
+ if (!point.isWaypoint())
+ {
+ if (prevPoint != null && point.getSegmentStart() && point.isDuplicate(prevPoint))
+ {
+ deleteFlags[i] = true;
+ numToDelete++;
+ }
+ prevPoint = point;
+ }
+ }
+ // Make new datapoint array of the right size
+ DataPoint[] pointCopies = new DataPoint[numPoints - numToDelete];
+ // Loop over points again, keeping the ones we want
+ int copyIndex = 0;
+ for (int i=0; i<numPoints; i++)
+ {
+ if (!deleteFlags[i]) {
+ pointCopies[copyIndex] = inTrack.getPoint(i);
+ copyIndex++;
+ }
+ }
+ // Finally, replace the copied points in the track
+ inTrack.replaceContents(pointCopies);
+ return numToDelete;
+ }
+
+ /** Function cancelled by progress dialog */
+ public void cancel() {
+ _cancelled = true;
+ }
+}
projects / GpsPrune.git / blobdiff