--- /dev/null
+package tim.prune.data;
+
+import tim.prune.UpdateMessageBroker;
+
+/**
+ * Class to represent a selected portion of a Track
+ * and its properties
+ */
+public class Selection
+{
+ private Track _track = null;
+ private UpdateMessageBroker _broker = null;
+ private int _currentPoint = -1;
+ private boolean _valid = false;
+ private int _startIndex = -1, _endIndex = -1;
+ private IntegerRange _altitudeRange = null;
+ private int _climb = -1, _descent = -1;
+ private int _altitudeFormat = Altitude.FORMAT_NONE;
+ private long _seconds = 0L;
+ private double _angDistance = -1.0; //, _averageSpeed = -1.0;
+
+
+ /**
+ * Constructor
+ * @param inTrack track object
+ * @param inBroker broker object
+ */
+ public Selection(Track inTrack, UpdateMessageBroker inBroker)
+ {
+ _track = inTrack;
+ _broker = inBroker;
+ }
+
+
+ /**
+ * Reset selection to be recalculated
+ */
+ private void reset()
+ {
+ _valid = false;
+ }
+
+
+ /**
+ * Select the point at the given index
+ * @param inIndex index number of selected point
+ */
+ public void selectPoint(int inIndex)
+ {
+ if (inIndex >= -1)
+ {
+ _currentPoint = inIndex;
+ check();
+ }
+ }
+
+ /**
+ * Select the specified point and range in one go
+ * @param inPointIndex point selection
+ * @param inStart range start
+ * @param inEnd range end
+ */
+ public void select(int inPointIndex, int inStart, int inEnd)
+ {
+ _currentPoint = inPointIndex;
+ _startIndex = inStart;
+ _endIndex = inEnd;
+ reset();
+ check();
+ }
+
+
+ /**
+ * Select the previous point
+ */
+ public void selectPreviousPoint()
+ {
+ if (_currentPoint > 0)
+ selectPoint(_currentPoint - 1);
+ }
+
+ /**
+ * Select the next point
+ */
+ public void selectNextPoint()
+ {
+ selectPoint(_currentPoint + 1);
+ }
+
+ /**
+ * @return the current point index
+ */
+ public int getCurrentPointIndex()
+ {
+ return _currentPoint;
+ }
+
+
+ /**
+ * @return true if range is selected
+ */
+ public boolean hasRangeSelected()
+ {
+ return _startIndex >= 0 && _endIndex > _startIndex;
+ }
+
+
+ /**
+ * Recalculate all selection details
+ */
+ private void recalculate()
+ {
+ _altitudeFormat = Altitude.FORMAT_NONE;
+ if (_track.getNumPoints() > 0 && hasRangeSelected())
+ {
+ _altitudeRange = new IntegerRange();
+ _climb = 0;
+ _descent = 0;
+ Altitude altitude = null;
+ Timestamp time = null, startTime = null, endTime = null;
+ DataPoint lastPoint = null, currPoint = null;
+ _angDistance = 0.0;
+ int altValue = 0;
+ int lastAltValue = 0;
+ boolean foundAlt = false;
+ for (int i=_startIndex; i<=_endIndex; i++)
+ {
+ currPoint = _track.getPoint(i);
+ altitude = currPoint.getAltitude();
+ // Ignore waypoints in altitude calculations
+ if (!currPoint.isWaypoint() && altitude.isValid())
+ {
+ altValue = altitude.getValue(_altitudeFormat);
+ if (_altitudeFormat == Altitude.FORMAT_NONE)
+ _altitudeFormat = altitude.getFormat();
+ _altitudeRange.addValue(altValue);
+ if (foundAlt)
+ {
+ if (altValue > lastAltValue)
+ _climb += (altValue - lastAltValue);
+ else
+ _descent += (lastAltValue - altValue);
+ }
+ lastAltValue = altValue;
+ foundAlt = true;
+ }
+ // Store the first and last timestamp in the range
+ time = currPoint.getTimestamp();
+ if (time.isValid())
+ {
+ if (startTime == null) startTime = time;
+ endTime = time;
+ }
+ // Calculate distances, again ignoring waypoints
+ if (!currPoint.isWaypoint())
+ {
+ if (lastPoint != null)
+ {
+ _angDistance += DataPoint.calculateRadiansBetween(lastPoint, currPoint);
+ }
+ lastPoint = currPoint;
+ }
+ }
+ if (endTime != null)
+ {
+ _seconds = endTime.getSecondsSince(startTime);
+ }
+ else
+ {
+ _seconds = 0L;
+ }
+ }
+ _valid = true;
+ }
+
+
+ /**
+ * @return start index
+ */
+ public int getStart()
+ {
+ if (!_valid) recalculate();
+ return _startIndex;
+ }
+
+
+ /**
+ * @return end index
+ */
+ public int getEnd()
+ {
+ if (!_valid) recalculate();
+ return _endIndex;
+ }
+
+
+ /**
+ * @return the altitude format, ie feet or metres
+ */
+ public int getAltitudeFormat()
+ {
+ return _altitudeFormat;
+ }
+
+ /**
+ * @return altitude range
+ */
+ public IntegerRange getAltitudeRange()
+ {
+ if (!_valid) recalculate();
+ return _altitudeRange;
+ }
+
+
+ /**
+ * @return climb
+ */
+ public int getClimb()
+ {
+ if (!_valid) recalculate();
+ return _climb;
+ }
+
+ /**
+ * @return descent
+ */
+ public int getDescent()
+ {
+ if (!_valid) recalculate();
+ return _descent;
+ }
+
+
+ /**
+ * @return number of seconds spanned by selection
+ */
+ public long getNumSeconds()
+ {
+ if (!_valid) recalculate();
+ return _seconds;
+ }
+
+
+ /**
+ * @param inFormat distance units to use, from class Distance
+ * @return distance of Selection in specified units
+ */
+ public double getDistance(int inUnits)
+ {
+ return Distance.convertRadians(_angDistance, inUnits);
+ }
+
+
+ /**
+ * Clear selected point and range
+ */
+ public void clearAll()
+ {
+ _currentPoint = -1;
+ deselectRange();
+ }
+
+
+ /**
+ * Deselect range
+ */
+ public void deselectRange()
+ {
+ _startIndex = _endIndex = -1;
+ reset();
+ check();
+ }
+
+
+ /**
+ * Select the range from the current point
+ */
+ public void selectRangeStart()
+ {
+ selectRangeStart(_currentPoint);
+ }
+
+
+ /**
+ * Set the index for the start of the range selection
+ * @param inStartIndex start index
+ */
+ public void selectRangeStart(int inStartIndex)
+ {
+ if (inStartIndex < 0)
+ {
+ _startIndex = _endIndex = -1;
+ }
+ else
+ {
+ _startIndex = inStartIndex;
+ // Move end of selection to max if necessary
+ if (_endIndex <= _startIndex)
+ {
+ _endIndex = _track.getNumPoints() - 1;
+ }
+ }
+ reset();
+ _broker.informSubscribers();
+ }
+
+
+ /**
+ * Select the range up to the current point
+ */
+ public void selectRangeEnd()
+ {
+ selectRangeEnd(_currentPoint);
+ }
+
+
+ /**
+ * Set the index for the end of the range selection
+ * @param inEndIndex end index
+ */
+ public void selectRangeEnd(int inEndIndex)
+ {
+ if (inEndIndex < 0)
+ {
+ _startIndex = _endIndex = -1;
+ }
+ else
+ {
+ _endIndex = inEndIndex;
+ // Move start of selection to min if necessary
+ if (_startIndex > _endIndex || _startIndex < 0)
+ {
+ _startIndex = 0;
+ }
+ }
+ reset();
+ _broker.informSubscribers();
+ }
+
+
+ /**
+ * Modify the selection given that the selected range has been deleted
+ */
+ public void modifyRangeDeleted()
+ {
+ // Modify current point, if any
+ if (_currentPoint > _endIndex)
+ {
+ _currentPoint -= (_endIndex - _startIndex);
+ }
+ else if (_currentPoint > _startIndex)
+ {
+ _currentPoint = _startIndex;
+ }
+ // Clear selected range
+ _startIndex = _endIndex = -1;
+ // Check for consistency and fire update
+ check();
+ }
+
+
+ /**
+ * Modify the selection when a point is deleted
+ */
+ public void modifyPointDeleted()
+ {
+ // current point index doesn't change, just gets checked
+ // range needs to get altered if deleted point is inside or before
+ if (hasRangeSelected() && _currentPoint <= _endIndex)
+ {
+ _endIndex--;
+ if (_currentPoint < _startIndex)
+ _startIndex--;
+ reset();
+ }
+ check();
+ }
+
+
+ /**
+ * Check that the selection still makes sense
+ * and fire update message to listeners
+ */
+ private void check()
+ {
+ if (_track != null && _track.getNumPoints() > 0)
+ {
+ int maxIndex = _track.getNumPoints() - 1;
+ if (_currentPoint > maxIndex)
+ {
+ _currentPoint = maxIndex;
+ }
+ if (_endIndex > maxIndex)
+ {
+ _endIndex = maxIndex;
+ }
+ if (_startIndex > maxIndex)
+ {
+ _startIndex = maxIndex;
+ }
+ }
+ _broker.informSubscribers();
+ }
+}
projects / GpsPrune.git / blobdiff