+++ /dev/null
-package tim.prune.data;
-
-import java.util.List;
-
-import tim.prune.UpdateMessageBroker;
-import tim.prune.function.edit.FieldEdit;
-import tim.prune.function.edit.FieldEditList;
-import tim.prune.gui.map.MapUtils;
-
-
-/**
- * Class to hold all track information,
- * including track points and waypoints
- */
-public class Track
-{
- // Data points
- private DataPoint[] _dataPoints = null;
- // Scaled x, y values
- private double[] _xValues = null;
- private double[] _yValues = null;
- private boolean _scaled = false;
- private int _numPoints = 0;
- private boolean _hasTrackpoint = false;
- private boolean _hasWaypoint = false;
- // Master field list
- private FieldList _masterFieldList = null;
- // variable ranges
- private DoubleRange _latRange = null, _longRange = null;
- private DoubleRange _xRange = null, _yRange = null;
-
-
- /**
- * Constructor for empty track
- */
- public Track()
- {
- // create field list
- _masterFieldList = new FieldList(null);
- // make empty DataPoint array
- _dataPoints = new DataPoint[0];
- _numPoints = 0;
- // needs to be scaled
- _scaled = false;
- }
-
- /**
- * Constructor using fields and points from another Track
- * @param inFieldList Field list from another Track object
- * @param inPoints (edited) point array
- */
- public Track(FieldList inFieldList, DataPoint[] inPoints)
- {
- _masterFieldList = inFieldList;
- _dataPoints = inPoints;
- if (_dataPoints == null) _dataPoints = new DataPoint[0];
- _numPoints = _dataPoints.length;
- _scaled = false;
- }
-
- /**
- * Load method, for initialising and reinitialising data
- * @param inFieldArray array of Field objects describing fields
- * @param inPointArray 2d object array containing data
- * @param inOptions load options such as units
- */
- public void load(Field[] inFieldArray, Object[][] inPointArray, PointCreateOptions inOptions)
- {
- if (inFieldArray == null || inPointArray == null)
- {
- _numPoints = 0;
- return;
- }
- // copy field list
- _masterFieldList = new FieldList(inFieldArray);
- // make DataPoint object from each point in inPointList
- _dataPoints = new DataPoint[inPointArray.length];
- String[] dataArray = null;
- int pointIndex = 0;
- for (int p=0; p < inPointArray.length; p++)
- {
- dataArray = (String[]) inPointArray[p];
- // Convert to DataPoint objects
- DataPoint point = new DataPoint(dataArray, _masterFieldList, inOptions);
- if (point.isValid())
- {
- _dataPoints[pointIndex] = point;
- pointIndex++;
- }
- else
- {
- // TODO: Maybe report this somehow?
- // System.out.println("point is not valid!");
- }
- }
- _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;
- }
-
-
- /**
- * Load the track by transferring the contents from a loaded Track object
- * @param inOther Track object containing loaded data
- */
- public void load(Track inOther)
- {
- _numPoints = inOther._numPoints;
- _masterFieldList = inOther._masterFieldList;
- _dataPoints = inOther._dataPoints;
- // needs to be scaled
- _scaled = false;
- }
-
- /**
- * Request that a rescale be done to recalculate derived values
- */
- public void requestRescale()
- {
- _scaled = false;
- }
-
- /**
- * Extend the track's field list with the given additional fields
- * @param inFieldList list of fields to be added
- */
- public void extendFieldList(FieldList inFieldList)
- {
- _masterFieldList = _masterFieldList.merge(inFieldList);
- }
-
- ////////////////// Modification methods //////////////////////
-
-
- /**
- * Combine this Track with new data
- * @param inOtherTrack other track to combine
- */
- public void combine(Track inOtherTrack)
- {
- // merge field list
- _masterFieldList = _masterFieldList.merge(inOtherTrack._masterFieldList);
- // expand data array and add other track's data points
- int totalPoints = getNumPoints() + inOtherTrack.getNumPoints();
- DataPoint[] mergedPoints = new DataPoint[totalPoints];
- System.arraycopy(_dataPoints, 0, mergedPoints, 0, getNumPoints());
- System.arraycopy(inOtherTrack._dataPoints, 0, mergedPoints, getNumPoints(), inOtherTrack.getNumPoints());
- _dataPoints = mergedPoints;
- // combine point count
- _numPoints = totalPoints;
- // needs to be scaled again
- _scaled = false;
- // inform listeners
- UpdateMessageBroker.informSubscribers();
- }
-
-
- /**
- * Crop the track to the given size - subsequent points are not (yet) deleted
- * @param inNewSize new number of points in track
- */
- public void cropTo(int inNewSize)
- {
- if (inNewSize >= 0 && inNewSize < getNumPoints())
- {
- _numPoints = inNewSize;
- // needs to be scaled again
- _scaled = false;
- UpdateMessageBroker.informSubscribers();
- }
- }
-
-
- /**
- * Delete the points marked for deletion
- * @param inSplitSegments true to split segments at deleted points
- * @return number of points deleted
- */
- public int deleteMarkedPoints(boolean inSplitSegments)
- {
- int numCopied = 0;
- // Copy selected points into a new point array
- DataPoint[] newPointArray = new DataPoint[_numPoints];
- boolean prevPointDeleted = false;
- for (int i=0; i<_numPoints; i++)
- {
- DataPoint point = _dataPoints[i];
- // Don't delete photo points
- if (point.hasMedia() || !point.getDeleteFlag())
- {
- if (prevPointDeleted && inSplitSegments) {
- point.setSegmentStart(true);
- }
- newPointArray[numCopied] = point;
- numCopied++;
- prevPointDeleted = false;
- }
- else {
- prevPointDeleted = true;
- }
- }
-
- // Copy array references
- int numDeleted = _numPoints - numCopied;
- if (numDeleted > 0)
- {
- _dataPoints = new DataPoint[numCopied];
- System.arraycopy(newPointArray, 0, _dataPoints, 0, numCopied);
- _numPoints = _dataPoints.length;
- _scaled = false;
- }
- return numDeleted;
- }
-
-
- /**
- * Delete the specified point
- * @param inIndex point index
- * @return true if successful
- */
- public boolean deletePoint(int inIndex)
- {
- boolean answer = deleteRange(inIndex, inIndex);
- return answer;
- }
-
-
- /**
- * Delete the specified range of points from the Track
- * @param inStart start of range (inclusive)
- * @param inEnd end of range (inclusive)
- * @return true if successful
- */
- public boolean deleteRange(int inStart, int inEnd)
- {
- if (inStart < 0 || inEnd < 0 || inEnd < inStart)
- {
- // 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];
- // Copy points before the selected range
- if (inStart > 0)
- {
- System.arraycopy(_dataPoints, 0, newPointArray, 0, inStart);
- }
- // Copy points after the deleted one(s)
- if (inEnd < (_numPoints - 1))
- {
- System.arraycopy(_dataPoints, inEnd + 1, newPointArray, inStart,
- _numPoints - inEnd - 1);
- }
- // Copy points over original array
- _dataPoints = newPointArray;
- _numPoints -= numToDelete;
- // needs to be scaled again
- _scaled = false;
- return true;
- }
-
-
- /**
- * Reverse the specified range of points
- * @param inStart start index
- * @param inEnd end index
- * @return true if successful, false otherwise
- */
- public boolean reverseRange(int inStart, int inEnd)
- {
- if (inStart < 0 || inEnd < 0 || inStart >= inEnd || inEnd >= _numPoints)
- {
- return false;
- }
- // calculate how many point swaps are required
- int numPointsToReverse = (inEnd - inStart + 1) / 2;
- DataPoint p = null;
- for (int i=0; i<numPointsToReverse; i++)
- {
- // swap pairs of points
- p = _dataPoints[inStart + i];
- _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;
- UpdateMessageBroker.informSubscribers();
- return true;
- }
-
-
- /**
- * Add the given time offset to the specified range
- * @param inStart start of range
- * @param inEnd end of range
- * @param inOffset offset to add (-ve to subtract)
- * @param inUndo true for undo operation
- * @return true on success
- */
- public boolean addTimeOffsetSeconds(int inStart, int inEnd, long inOffset, boolean inUndo)
- {
- // sanity check
- if (inStart < 0 || inEnd < 0 || inStart >= inEnd || inEnd >= _numPoints) {
- return false;
- }
- boolean foundTimestamp = false;
- // Loop over all points within range
- for (int i=inStart; i<=inEnd; i++)
- {
- DataPoint p = _dataPoints[i];
- if (p != null && p.hasTimestamp())
- {
- // This point has a timestamp so add the offset to it
- foundTimestamp = true;
- p.addTimeOffsetSeconds(inOffset);
- p.setModified(inUndo);
- }
- }
- return foundTimestamp;
- }
-
- /**
- * Add the given altitude offset to the specified range
- * @param inStart start of range
- * @param inEnd end of range
- * @param inOffset offset to add (-ve to subtract)
- * @param inUnit altitude unit of offset
- * @param inDecimals number of decimal places in offset
- * @return true on success
- */
- public boolean addAltitudeOffset(int inStart, int inEnd, double inOffset,
- Unit inUnit, int inDecimals)
- {
- // sanity check
- if (inStart < 0 || inEnd < 0 || inStart >= inEnd || inEnd >= _numPoints) {
- return false;
- }
- boolean foundAlt = false;
- // Loop over all points within range
- for (int i=inStart; i<=inEnd; i++)
- {
- DataPoint p = _dataPoints[i];
- if (p != null && p.hasAltitude())
- {
- // This point has an altitude so add the offset to it
- foundAlt = true;
- p.addAltitudeOffset(inOffset, inUnit, inDecimals);
- p.setModified(false);
- }
- }
- // needs to be scaled again
- _scaled = false;
- return foundAlt;
- }
-
-
- /**
- * Interleave all waypoints by each nearest track point
- * @return true if successful, false if no change
- */
- public boolean interleaveWaypoints()
- {
- // Separate waypoints and find nearest track point
- int numWaypoints = 0;
- DataPoint[] waypoints = new DataPoint[_numPoints];
- int[] pointIndices = new int[_numPoints];
- DataPoint point = null;
- int i = 0;
- for (i=0; i<_numPoints; i++)
- {
- point = _dataPoints[i];
- if (point.isWaypoint())
- {
- waypoints[numWaypoints] = point;
- pointIndices[numWaypoints] = getNearestPointIndex(
- _xValues[i], _yValues[i], -1.0, true);
- numWaypoints++;
- }
- }
- // Exit if data not mixed
- if (numWaypoints == 0 || numWaypoints == _numPoints)
- return false;
-
- // Loop round points copying to correct order
- DataPoint[] dataCopy = new DataPoint[_numPoints];
- int copyIndex = 0;
- for (i=0; i<_numPoints; i++)
- {
- point = _dataPoints[i];
- // if it's a track point, copy it
- if (!point.isWaypoint())
- {
- dataCopy[copyIndex] = point;
- copyIndex++;
- }
- // check for waypoints with this index
- for (int j=0; j<numWaypoints; j++)
- {
- if (pointIndices[j] == i)
- {
- dataCopy[copyIndex] = waypoints[j];
- copyIndex++;
- }
- }
- }
- // Copy data back to track
- _dataPoints = dataCopy;
- // needs to be scaled again to recalc x, y
- _scaled = false;
- UpdateMessageBroker.informSubscribers();
- return true;
- }
-
-
- /**
- * Cut and move the specified section
- * @param inSectionStart start index of section
- * @param inSectionEnd end index of section
- * @param inMoveTo index of move to point
- * @return true if move successful
- */
- public boolean cutAndMoveSection(int inSectionStart, int inSectionEnd, int inMoveTo)
- {
- // TODO: Move cut/move into separate function?
- // Check that indices make sense
- if (inSectionStart >= 0 && inSectionEnd > inSectionStart && inMoveTo >= 0
- && (inMoveTo < inSectionStart || inMoveTo > (inSectionEnd+1)))
- {
- // do the cut and move
- DataPoint[] newPointArray = new DataPoint[_numPoints];
- // System.out.println("Cut/move section (" + inSectionStart + " - " + inSectionEnd + ") to before point " + inMoveTo);
- // Is it a forward copy or a backward copy?
- if (inSectionStart > inMoveTo)
- {
- int sectionLength = inSectionEnd - inSectionStart + 1;
- // move section to earlier point
- if (inMoveTo > 0) {
- System.arraycopy(_dataPoints, 0, newPointArray, 0, inMoveTo); // unchanged points before
- }
- System.arraycopy(_dataPoints, inSectionStart, newPointArray, inMoveTo, sectionLength); // moved bit
- // after insertion point, before moved bit
- System.arraycopy(_dataPoints, inMoveTo, newPointArray, inMoveTo + sectionLength, inSectionStart - inMoveTo);
- // after moved bit
- if (inSectionEnd < (_numPoints - 1)) {
- System.arraycopy(_dataPoints, inSectionEnd+1, newPointArray, inSectionEnd+1, _numPoints - inSectionEnd - 1);
- }
- }
- else
- {
- // Move section to later point
- if (inSectionStart > 0) {
- System.arraycopy(_dataPoints, 0, newPointArray, 0, inSectionStart); // unchanged points before
- }
- // from end of section to move to point
- if (inMoveTo > (inSectionEnd + 1)) {
- System.arraycopy(_dataPoints, inSectionEnd+1, newPointArray, inSectionStart, inMoveTo - inSectionEnd - 1);
- }
- // moved bit
- System.arraycopy(_dataPoints, inSectionStart, newPointArray, inSectionStart + inMoveTo - inSectionEnd - 1,
- inSectionEnd - inSectionStart + 1);
- // unchanged bit after
- if (inSectionEnd < (_numPoints - 1)) {
- System.arraycopy(_dataPoints, inMoveTo, newPointArray, inMoveTo, _numPoints - inMoveTo);
- }
- }
- // Copy array references
- _dataPoints = newPointArray;
- _scaled = false;
- return true;
- }
- return false;
- }
-
-
- /**
- * Interpolate extra points between two selected ones
- * @param inStartIndex start index of interpolation
- * @param inNumPoints num points to insert
- * @return true if successful
- */
- public boolean interpolate(int inStartIndex, int inNumPoints)
- {
- // check parameters
- if (inStartIndex < 0 || inStartIndex >= _numPoints || inNumPoints <= 0)
- return false;
-
- // get start and end points
- DataPoint startPoint = getPoint(inStartIndex);
- DataPoint endPoint = getPoint(inStartIndex + 1);
-
- // Make array of points to insert
- DataPoint[] insertedPoints = startPoint.interpolate(endPoint, inNumPoints);
-
- // Insert points into track
- return insertRange(insertedPoints, inStartIndex + 1);
- }
-
-
- /**
- * Average selected points
- * @param inStartIndex start index of selection
- * @param inEndIndex end index of selection
- * @return true if successful
- */
- public boolean average(int inStartIndex, int inEndIndex)
- {
- // check parameters
- if (inStartIndex < 0 || inStartIndex >= _numPoints || inEndIndex <= inStartIndex)
- return false;
-
- DataPoint startPoint = getPoint(inStartIndex);
- double firstLatitude = startPoint.getLatitude().getDouble();
- double firstLongitude = startPoint.getLongitude().getDouble();
- double latitudeDiff = 0.0, longitudeDiff = 0.0;
- double totalAltitude = 0;
- int numAltitudes = 0;
- Unit altUnit = null;
- // loop between start and end points
- for (int i=inStartIndex; i<= inEndIndex; i++)
- {
- DataPoint currPoint = getPoint(i);
- latitudeDiff += (currPoint.getLatitude().getDouble() - firstLatitude);
- longitudeDiff += (currPoint.getLongitude().getDouble() - firstLongitude);
- if (currPoint.hasAltitude())
- {
- totalAltitude += currPoint.getAltitude().getValue(altUnit);
- // Use altitude format of first valid altitude
- if (altUnit == null)
- altUnit = currPoint.getAltitude().getUnit();
- numAltitudes++;
- }
- }
- int numPoints = inEndIndex - inStartIndex + 1;
- double meanLatitude = firstLatitude + (latitudeDiff / numPoints);
- double meanLongitude = firstLongitude + (longitudeDiff / numPoints);
- Altitude meanAltitude = null;
- if (numAltitudes > 0) {
- meanAltitude = new Altitude((int) (totalAltitude / numAltitudes), altUnit);
- }
-
- DataPoint insertedPoint = new DataPoint(new Latitude(meanLatitude, Coordinate.FORMAT_DECIMAL_FORCE_POINT),
- new Longitude(meanLongitude, Coordinate.FORMAT_DECIMAL_FORCE_POINT), meanAltitude);
- // Make into singleton
- insertedPoint.setSegmentStart(true);
- DataPoint nextPoint = getNextTrackPoint(inEndIndex+1);
- if (nextPoint != null) {nextPoint.setSegmentStart(true);}
- // Insert points into track
- return insertRange(new DataPoint[] {insertedPoint}, inEndIndex + 1);
- }
-
-
- /**
- * Append the specified points to the end of the track
- * @param inPoints DataPoint objects to add
- */
- public void appendPoints(DataPoint[] inPoints)
- {
- // Insert points into track
- if (inPoints != null && inPoints.length > 0)
- {
- insertRange(inPoints, _numPoints);
- }
- // needs to be scaled again to recalc x, y
- _scaled = false;
- UpdateMessageBroker.informSubscribers();
- }
-
-
- //////// information methods /////////////
-
-
- /**
- * Get the point at the given index
- * @param inPointNum index number, starting at 0
- * @return DataPoint object, or null if out of range
- */
- public DataPoint getPoint(int inPointNum)
- {
- if (inPointNum > -1 && inPointNum < getNumPoints())
- {
- return _dataPoints[inPointNum];
- }
- return null;
- }
-
- /**
- * @return the number of (valid) points in the track
- */
- public int getNumPoints()
- {
- return _numPoints;
- }
-
- /**
- * @return The range of x values as a DoubleRange object
- */
- public DoubleRange getXRange()
- {
- if (!_scaled) {scalePoints();}
- return _xRange;
- }
-
- /**
- * @return The range of y values as a DoubleRange object
- */
- public DoubleRange getYRange()
- {
- if (!_scaled) {scalePoints();}
- return _yRange;
- }
-
- /**
- * @return The range of lat values as a DoubleRange object
- */
- public DoubleRange getLatRange()
- {
- if (!_scaled) {scalePoints();}
- return _latRange;
- }
- /**
- * @return The range of lon values as a DoubleRange object
- */
- public DoubleRange getLonRange()
- {
- if (!_scaled) {scalePoints();}
- return _longRange;
- }
-
- /**
- * @param inPointNum point index, starting at 0
- * @return scaled x value of specified point
- */
- public double getX(int inPointNum)
- {
- if (!_scaled) {scalePoints();}
- return _xValues[inPointNum];
- }
-
- /**
- * @param inPointNum point index, starting at 0
- * @return scaled y value of specified point
- */
- public double getY(int inPointNum)
- {
- if (!_scaled) {scalePoints();}
- return _yValues[inPointNum];
- }
-
- /**
- * @return the master field list
- */
- public FieldList getFieldList()
- {
- return _masterFieldList;
- }
-
-
- /**
- * Checks if any data exists for the specified field
- * @param inField Field to examine
- * @return true if data exists for this field
- */
- public boolean hasData(Field inField)
- {
- // Don't use this method for altitudes
- if (inField.equals(Field.ALTITUDE)) {return hasAltitudeData();}
- return hasData(inField, 0, _numPoints-1);
- }
-
-
- /**
- * Checks if any data exists for the specified field in the specified range
- * @param inField Field to examine
- * @param inStart start of range to check
- * @param inEnd end of range to check (inclusive)
- * @return true if data exists for this field
- */
- public boolean hasData(Field inField, int inStart, int inEnd)
- {
- // Loop over selected point range
- for (int i=inStart; i<=inEnd; i++)
- {
- if (_dataPoints[i].getFieldValue(inField) != null)
- {
- // Check altitudes and timestamps
- if ((inField != Field.ALTITUDE || _dataPoints[i].getAltitude().isValid())
- && (inField != Field.TIMESTAMP || _dataPoints[i].getTimestamp().isValid()))
- {
- return true;
- }
- }
- }
- return false;
- }
-
- /**
- * @return true if track has altitude data
- */
- public boolean hasAltitudeData()
- {
- for (int i=0; i<_numPoints; i++) {
- if (_dataPoints[i].hasAltitude()) {return true;}
- }
- return false;
- }
-
- /**
- * @return true if track contains at least one trackpoint
- */
- public boolean hasTrackPoints()
- {
- if (!_scaled) {scalePoints();}
- return _hasTrackpoint;
- }
-
- /**
- * @return true if track contains waypoints
- */
- public boolean hasWaypoints()
- {
- if (!_scaled) {scalePoints();}
- return _hasWaypoint;
- }
-
- /**
- * @return true if track contains any points marked for deletion
- */
- public boolean hasMarkedPoints()
- {
- if (_numPoints < 1) {
- return false;
- }
- // Loop over points looking for any marked for deletion
- for (int i=0; i<=_numPoints-1; i++)
- {
- if (_dataPoints[i] != null && _dataPoints[i].getDeleteFlag()) {
- return true;
- }
- }
- // None found
- return false;
- }
-
- /**
- * Clear all the deletion markers
- */
- public void clearDeletionMarkers()
- {
- for (int i=0; i<_numPoints; i++)
- {
- _dataPoints[i].setMarkedForDeletion(false);
- }
- }
-
- /**
- * Collect all the waypoints into the given List
- * @param inList List to fill with waypoints
- */
- public void getWaypoints(List<DataPoint> inList)
- {
- // clear list
- inList.clear();
- // loop over points and copy all waypoints into list
- for (int i=0; i<=_numPoints-1; i++)
- {
- if (_dataPoints[i] != null && _dataPoints[i].isWaypoint())
- {
- inList.add(_dataPoints[i]);
- }
- }
- }
-
-
- /**
- * Search for the given Point in the track and return the index
- * @param inPoint Point to look for
- * @return index of Point, if any or -1 if not found
- */
- public int getPointIndex(DataPoint inPoint)
- {
- if (inPoint != null)
- {
- // Loop over points in track
- for (int i=0; i<=_numPoints-1; i++)
- {
- if (_dataPoints[i] == inPoint)
- {
- return i;
- }
- }
- }
- // not found
- return -1;
- }
-
-
- ///////// Internal processing methods ////////////////
-
-
- /**
- * Scale all the points in the track to gain x and y values
- * ready for plotting
- */
- private synchronized void scalePoints()
- {
- // Loop through all points in track, to see limits of lat, long
- _longRange = new DoubleRange();
- _latRange = new DoubleRange();
- int p;
- _hasWaypoint = false; _hasTrackpoint = false;
- for (p=0; p < getNumPoints(); p++)
- {
- DataPoint point = getPoint(p);
- if (point != null && point.isValid())
- {
- _longRange.addValue(point.getLongitude().getDouble());
- _latRange.addValue(point.getLatitude().getDouble());
- if (point.isWaypoint())
- _hasWaypoint = true;
- else
- _hasTrackpoint = true;
- }
- }
-
- // Loop over points and calculate scales
- _xValues = new double[getNumPoints()];
- _yValues = new double[getNumPoints()];
- _xRange = new DoubleRange();
- _yRange = new DoubleRange();
- for (p=0; p < getNumPoints(); p++)
- {
- DataPoint point = getPoint(p);
- if (point != null)
- {
- _xValues[p] = MapUtils.getXFromLongitude(point.getLongitude().getDouble());
- _xRange.addValue(_xValues[p]);
- _yValues[p] = MapUtils.getYFromLatitude(point.getLatitude().getDouble());
- _yRange.addValue(_yValues[p]);
- }
- }
- _scaled = true;
- }
-
-
- /**
- * Find the nearest point to the specified x and y coordinates
- * or -1 if no point is within the specified max distance
- * @param inX x coordinate
- * @param inY y coordinate
- * @param inMaxDist maximum distance from selected coordinates
- * @param inJustTrackPoints true if waypoints should be ignored
- * @return index of nearest point or -1 if not found
- */
- public int getNearestPointIndex(double inX, double inY, double inMaxDist, boolean inJustTrackPoints)
- {
- int nearestPoint = 0;
- double nearestDist = -1.0;
- double mDist, yDist;
- for (int i=0; i < getNumPoints(); i++)
- {
- if (!inJustTrackPoints || !_dataPoints[i].isWaypoint())
- {
- yDist = Math.abs(_yValues[i] - inY);
- if (yDist < nearestDist || nearestDist < 0.0)
- {
- // y dist is within range, so check x too
- mDist = yDist + getMinXDist(_xValues[i] - inX);
- if (mDist < nearestDist || nearestDist < 0.0)
- {
- nearestPoint = i;
- nearestDist = mDist;
- }
- }
- }
- }
- // Check whether it's within required distance
- if (nearestDist > inMaxDist && inMaxDist > 0.0)
- {
- return -1;
- }
- return nearestPoint;
- }
-
- /**
- * @param inX x value of point
- * @return minimum wrapped value
- */
- private static final double getMinXDist(double inX)
- {
- // TODO: Should be abs(mod(inX-0.5,1)-0.5) - means two adds, one mod, one abs instead of two adds, 3 abss and two compares
- return Math.min(Math.min(Math.abs(inX), Math.abs(inX-1.0)), Math.abs(inX+1.0));
- }
-
- /**
- * 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, _numPoints, true);
- }
-
- /**
- * Get the next track point in the given range
- * @param inStartIndex index to start looking from
- * @param inEndIndex index to stop looking
- * @return next track point, or null if end of data reached
- */
- public DataPoint getNextTrackPoint(int inStartIndex, int inEndIndex)
- {
- return getNextTrackPoint(inStartIndex, inEndIndex, true);
- }
-
- /**
- * 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)
- {
- // end index is given as _numPoints but actually it just counts down to -1
- return getNextTrackPoint(inStartIndex, _numPoints, false);
- }
-
- /**
- * Get the next track point starting from the given index
- * @param inStartIndex index to start looking from
- * @param inEndIndex index to stop looking (inclusive)
- * @param inCountUp true for next, false for previous
- * @return next track point, or null if end of data reached
- */
- private DataPoint getNextTrackPoint(int inStartIndex, int inEndIndex, boolean inCountUp)
- {
- // Loop forever over points
- int increment = inCountUp?1:-1;
- for (int i=inStartIndex; i<=inEndIndex; i+=increment)
- {
- 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;
- }
- }
- return null;
- }
-
- /**
- * 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 ///////////////////
-
- /**
- * Clone the array of DataPoints
- * @return shallow copy of DataPoint objects
- */
- public DataPoint[] cloneContents()
- {
- DataPoint[] clone = new DataPoint[getNumPoints()];
- System.arraycopy(_dataPoints, 0, clone, 0, getNumPoints());
- return clone;
- }
-
-
- /**
- * Clone the specified range of data points
- * @param inStart start index (inclusive)
- * @param inEnd end index (inclusive)
- * @return shallow copy of DataPoint objects
- */
- public DataPoint[] cloneRange(int inStart, int inEnd)
- {
- int numSelected = 0;
- if (inEnd >= 0 && inEnd >= inStart)
- {
- numSelected = inEnd - inStart + 1;
- }
- DataPoint[] result = new DataPoint[numSelected>0?numSelected:0];
- if (numSelected > 0)
- {
- System.arraycopy(_dataPoints, inStart, result, 0, numSelected);
- }
- return result;
- }
-
-
- /**
- * Re-insert the specified point at the given index
- * @param inPoint point to insert
- * @param inIndex index at which to insert the point
- * @return true if it worked, false otherwise
- */
- public boolean insertPoint(DataPoint inPoint, int inIndex)
- {
- if (inIndex > _numPoints || inPoint == null)
- {
- return false;
- }
- // Make new array to copy points over to
- DataPoint[] newPointArray = new DataPoint[_numPoints + 1];
- if (inIndex > 0)
- {
- System.arraycopy(_dataPoints, 0, newPointArray, 0, inIndex);
- }
- newPointArray[inIndex] = inPoint;
- if (inIndex < _numPoints)
- {
- System.arraycopy(_dataPoints, inIndex, newPointArray, inIndex+1, _numPoints - inIndex);
- }
- // Change over to new array
- _dataPoints = newPointArray;
- _numPoints++;
- // needs to be scaled again
- _scaled = false;
- UpdateMessageBroker.informSubscribers();
- return true;
- }
-
-
- /**
- * Re-insert the specified point range at the given index
- * @param inPoints point array to insert
- * @param inIndex index at which to insert the points
- * @return true if it worked, false otherwise
- */
- public boolean insertRange(DataPoint[] inPoints, int inIndex)
- {
- if (inIndex > _numPoints || inPoints == null)
- {
- return false;
- }
- // Make new array to copy points over to
- DataPoint[] newPointArray = new DataPoint[_numPoints + inPoints.length];
- if (inIndex > 0)
- {
- System.arraycopy(_dataPoints, 0, newPointArray, 0, inIndex);
- }
- System.arraycopy(inPoints, 0, newPointArray, inIndex, inPoints.length);
- if (inIndex < _numPoints)
- {
- System.arraycopy(_dataPoints, inIndex, newPointArray, inIndex+inPoints.length, _numPoints - inIndex);
- }
- // Change over to new array
- _dataPoints = newPointArray;
- _numPoints += inPoints.length;
- // needs to be scaled again
- _scaled = false;
- UpdateMessageBroker.informSubscribers();
- return true;
- }
-
-
- /**
- * Replace the track contents with the given point array
- * @param inContents array of DataPoint objects
- * @return true on success
- */
- public boolean replaceContents(DataPoint[] inContents)
- {
- // master field array stays the same
- // (would need to store field array too if we wanted to redo a load)
- // replace data array
- _dataPoints = inContents;
- _numPoints = _dataPoints.length;
- _scaled = false;
- UpdateMessageBroker.informSubscribers();
- return true;
- }
-
-
- /**
- * Edit the specified point
- * @param inPoint point to edit
- * @param inEditList list of edits to make
- * @param inUndo true if undo operation, false otherwise
- * @return true if successful
- */
- public boolean editPoint(DataPoint inPoint, FieldEditList inEditList, boolean inUndo)
- {
- if (inPoint != null && inEditList != null && inEditList.getNumEdits() > 0)
- {
- // remember if coordinates have changed
- boolean coordsChanged = false;
- // go through edits one by one
- int numEdits = inEditList.getNumEdits();
- for (int i=0; i<numEdits; i++)
- {
- FieldEdit edit = inEditList.getEdit(i);
- Field editField = edit.getField();
- inPoint.setFieldValue(editField, edit.getValue(), inUndo);
- // Check that master field list has this field already (maybe point name has been added)
- if (!_masterFieldList.contains(editField)) {
- _masterFieldList.extendList(editField);
- }
- // check coordinates
- coordsChanged |= (editField.equals(Field.LATITUDE)
- || editField.equals(Field.LONGITUDE) || editField.equals(Field.ALTITUDE));
- }
- // set photo status if coordinates have changed
- if (inPoint.getPhoto() != null && coordsChanged)
- {
- inPoint.getPhoto().setCurrentStatus(Photo.Status.CONNECTED);
- }
- // point possibly needs to be scaled again
- _scaled = false;
- // trigger listeners
- UpdateMessageBroker.informSubscribers();
- return true;
- }
- return false;
- }
-
- /**
- * @param inPoint point to check
- * @return true if this track contains the given point
- */
- public boolean containsPoint(DataPoint inPoint)
- {
- if (inPoint == null) return false;
- for (int i=0; i < getNumPoints(); i++)
- {
- if (getPoint(i) == inPoint) return true;
- }
- return false; // not found
- }
-}
projects / GpsPrune.git / blobdiff