*/
public class Track
{
- // Broker object
- UpdateMessageBroker _broker = null;
// Data points
private DataPoint[] _dataPoints = null;
// Scaled x, y values
/**
* Constructor for empty track
- * @param inBroker message broker object
*/
- public Track(UpdateMessageBroker inBroker)
+ public Track()
{
- _broker = inBroker;
// create field list
_masterFieldList = new FieldList(null);
// make empty DataPoint array
}
}
_numPoints = pointIndex;
+ // Set first track point to be start of segment
+ DataPoint firstTrackPoint = getNextTrackPoint(0);
+ if (firstTrackPoint != null) {
+ firstTrackPoint.setSegmentStart(true);
+ }
// needs to be scaled
_scaled = false;
}
/**
* Combine this Track with new data
- * @param inOtherTrack
+ * @param inOtherTrack other track to combine
*/
public void combine(Track inOtherTrack)
{
// needs to be scaled again
_scaled = false;
// inform listeners
- _broker.informSubscribers();
+ UpdateMessageBroker.informSubscribers();
}
_numPoints = inNewSize;
// needs to be scaled again
_scaled = false;
- _broker.informSubscribers();
+ UpdateMessageBroker.informSubscribers();
}
}
if (yscale > wholeScale) wholeScale = yscale;
double minDist = wholeScale / inResolution;
+ // Keep track of segment start flags of the deleted points
+ boolean setSegment = false;
// Copy selected points
DataPoint[] newPointArray = new DataPoint[_numPoints];
int[] pointIndices = new int[_numPoints];
for (int i=0; i<_numPoints; i++)
{
+ DataPoint point = _dataPoints[i];
boolean keepPoint = true;
// Don't delete waypoints or photo points
- if (!_dataPoints[i].isWaypoint() && _dataPoints[i].getPhoto() == null)
+ if (!point.isWaypoint() && point.getPhoto() == null)
{
// go through newPointArray to check for range
for (int j=0; j<numCopied && keepPoint; j++)
}
if (keepPoint)
{
- newPointArray[numCopied] = _dataPoints[i];
+ newPointArray[numCopied] = point;
pointIndices[numCopied] = i;
numCopied++;
+ // set segment flag if it's the first track point
+ if (setSegment && !point.isWaypoint())
+ {
+ point.setSegmentStart(true);
+ setSegment = false;
+ }
+ }
+ else
+ {
+ // point will be removed, so check segment flag
+ if (point.getSegmentStart()) {setSegment = true;}
}
}
_dataPoints = newPointArray;
_numPoints = _dataPoints.length;
_scaled = false;
- _broker.informSubscribers();
+ UpdateMessageBroker.informSubscribers();
return numDeleted;
}
// no valid range selected so can't delete
return false;
}
+ // check through range to be deleted, and see if any new segment flags present
+ boolean hasSegmentStart = false;
+ DataPoint nextTrackPoint = getNextTrackPoint(inEnd+1);
+ if (nextTrackPoint != null) {
+ for (int i=inStart; i<=inEnd && !hasSegmentStart; i++) {
+ hasSegmentStart |= _dataPoints[i].getSegmentStart();
+ }
+ // If segment break found, make sure next trackpoint also has break
+ if (hasSegmentStart) {nextTrackPoint.setSegmentStart(true);}
+ }
// valid range, let's delete it
int numToDelete = inEnd - inStart + 1;
DataPoint[] newPointArray = new DataPoint[_numPoints - numToDelete];
_dataPoints[inStart + i] = _dataPoints[inEnd - i];
_dataPoints[inEnd - i] = p;
}
+ // adjust segment starts
+ shiftSegmentStarts(inStart, inEnd);
+ // Find first track point and following track point, and set segment starts to true
+ DataPoint firstTrackPoint = getNextTrackPoint(inStart);
+ if (firstTrackPoint != null) {firstTrackPoint.setSegmentStart(true);}
+ DataPoint nextTrackPoint = getNextTrackPoint(inEnd+1);
+ if (nextTrackPoint != null) {nextTrackPoint.setSegmentStart(true);}
// needs to be scaled again
_scaled = false;
- _broker.informSubscribers();
+ UpdateMessageBroker.informSubscribers();
return true;
}
+ /**
+ * Merge the track segments within the given range
+ * @param inStart start index
+ * @param inEnd end index
+ * @return true if successful
+ */
+ public boolean mergeTrackSegments(int inStart, int inEnd)
+ {
+ boolean firstTrackPoint = true;
+ // Loop between start and end
+ for (int i=inStart; i<=inEnd; i++) {
+ DataPoint point = getPoint(i);
+ // Set all segments to false apart from first track point
+ if (point != null && !point.isWaypoint()) {
+ point.setSegmentStart(firstTrackPoint);
+ firstTrackPoint = false;
+ }
+ }
+ // Find following track point, if any
+ DataPoint nextPoint = getNextTrackPoint(inEnd+1);
+ if (nextPoint != null) {nextPoint.setSegmentStart(true);}
+ UpdateMessageBroker.informSubscribers();
+ return true;
+ }
+
/**
* Collect all waypoints to the start or end of the track
* @param inAtStart true to collect at start, false for end
}
// needs to be scaled again
_scaled = false;
- _broker.informSubscribers();
+ UpdateMessageBroker.informSubscribers();
return true;
}
_dataPoints = dataCopy;
// needs to be scaled again to recalc x, y
_scaled = false;
- _broker.informSubscribers();
+ UpdateMessageBroker.informSubscribers();
return true;
}
}
// needs to be scaled again to recalc x, y
_scaled = false;
- _broker.informSubscribers();
+ UpdateMessageBroker.informSubscribers();
}
}
+ /**
+ * Get the next track point starting from the given index
+ * @param inStartIndex index to start looking from
+ * @return next track point, or null if end of data reached
+ */
+ public DataPoint getNextTrackPoint(int inStartIndex)
+ {
+ return getNextTrackPoint(inStartIndex, 1);
+ }
+
+ /**
+ * Get the previous track point starting from the given index
+ * @param inStartIndex index to start looking from
+ * @return next track point, or null if end of data reached
+ */
+ public DataPoint getPreviousTrackPoint(int inStartIndex)
+ {
+ return getNextTrackPoint(inStartIndex, -1);
+ }
+
+ /**
+ * Get the next track point starting from the given index
+ * @param inStartIndex index to start looking from
+ * @param inIncrement increment to add to point index, +1 for next, -1 for previous
+ * @return next track point, or null if end of data reached
+ */
+ private DataPoint getNextTrackPoint(int inStartIndex, int inIncrement)
+ {
+ // Loop forever over points
+ for (int i=inStartIndex; ; i+=inIncrement)
+ {
+ DataPoint point = getPoint(i);
+ // Exit if end of data reached - there wasn't a track point
+ if (point == null) {return null;}
+ if (point.isValid() && !point.isWaypoint()) {
+ // next track point found
+ return point;
+ }
+ }
+ }
+
+ /**
+ * Shift all the segment start flags in the given range by 1
+ * Method used by reverse range and its undo
+ * @param inStartIndex start of range, inclusive
+ * @param inEndIndex end of range, inclusive
+ */
+ public void shiftSegmentStarts(int inStartIndex, int inEndIndex)
+ {
+ boolean prevFlag = true;
+ boolean currFlag = true;
+ for (int i=inStartIndex; i<= inEndIndex; i++)
+ {
+ DataPoint point = getPoint(i);
+ if (point != null && !point.isWaypoint())
+ {
+ // remember flag
+ currFlag = point.getSegmentStart();
+ // shift flag by 1
+ point.setSegmentStart(prevFlag);
+ prevFlag = currFlag;
+ }
+ }
+ }
+
////////////////// Cloning and replacing ///////////////////
/**
_numPoints++;
// needs to be scaled again
_scaled = false;
- _broker.informSubscribers();
+ UpdateMessageBroker.informSubscribers();
return true;
}
_numPoints += inPoints.length;
// needs to be scaled again
_scaled = false;
- _broker.informSubscribers();
+ UpdateMessageBroker.informSubscribers();
return true;
}
_dataPoints = inContents;
_numPoints = _dataPoints.length;
_scaled = false;
- _broker.informSubscribers();
+ UpdateMessageBroker.informSubscribers();
return true;
}
// point possibly needs to be scaled again
_scaled = false;
// trigger listeners
- _broker.informSubscribers();
+ UpdateMessageBroker.informSubscribers();
return true;
}
return false;
projects / GpsPrune.git / blobdiff