public void ensureIncreasingTime() {
if (getPositionCount() < 2) return;
long completeTime = getTime(); // ms
double completeDistance = getDistance(); // m
double averageSpeed = completeTime > 0 ? completeDistance / completeTime * 1000 : 1.0; // m/s
List<P> positions = getPositions();
P first = positions.get(0);
if (!first.hasTime()) first.setTime(fromCalendar(Calendar.getInstance(UTC)));
P previous = first;
for (int i = 1; i < positions.size(); i++) {
P next = positions.get(i);
CompactCalendar time = next.getTime();
if (time == null || time.equals(previous.getTime())) {
Double distance = next.calculateDistance(previous);
Long millis = distance != null ? (long) (distance / averageSpeed * 1000) : null;
if (millis == null || millis < 1000) millis = 1000L;
next.setTime(
fromMillisAndTimeZone(
previous.getTime().getTimeInMillis() + millis, previous.getTime().getTimeZoneId()));
}
previous = next;
}
}
private void move(int index, int upOrDown) {
List<P> positions = getPositions();
P move = positions.get(index);
P replace = positions.get(index + upOrDown);
positions.set(index + upOrDown, move);
positions.set(index, replace);
}
public void sort(Comparator<P> comparator) {
List<P> positions = getPositions();
@SuppressWarnings({"SuspiciousToArrayCall", "unchecked"})
P[] sorted = (P[]) positions.toArray(new BaseNavigationPosition[positions.size()]);
Arrays.sort(sorted, comparator);
//noinspection unchecked
order(asList(sorted));
}
public int[] getContainedPositions(BoundingBox boundingBox) {
List<Integer> result = new ArrayList<>();
List<P> positions = getPositions();
for (int i = 0; i < positions.size(); i++) {
P position = positions.get(i);
if (position.hasCoordinates() && boundingBox.contains(position)) result.add(i);
}
return toArray(result);
}
@SuppressWarnings("UnusedDeclaration")
public ViaMichelinRoute asViaMichelinFormat() {
if (getFormat() instanceof ViaMichelinFormat) return (ViaMichelinRoute) this;
List<Wgs84Position> wgs84Positions = new ArrayList<>();
for (P position : getPositions()) {
wgs84Positions.add(position.asWgs84Position());
}
return new ViaMichelinRoute(getName(), wgs84Positions);
}
@SuppressWarnings("UnusedDeclaration")
public GarminFlightPlanRoute asGarminFlightPlanFormat() {
if (getFormat() instanceof GarminFlightPlanFormat) return (GarminFlightPlanRoute) this;
List<GarminFlightPlanPosition> flightPlanPositions = new ArrayList<>();
for (P position : getPositions()) {
flightPlanPositions.add(position.asGarminFlightPlanPosition());
}
return new GarminFlightPlanRoute(getName(), getDescription(), flightPlanPositions);
}
@SuppressWarnings("UnusedDeclaration")
public MagicMapsIktRoute asMagicMapsIktFormat() {
if (getFormat() instanceof MagicMapsIktFormat) return (MagicMapsIktRoute) this;
List<Wgs84Position> wgs84Positions = new ArrayList<>();
for (P position : getPositions()) {
wgs84Positions.add(position.asWgs84Position());
}
return new MagicMapsIktRoute(getName(), getDescription(), wgs84Positions);
}
public double getElevationDelta(int index) {
List<P> positions = getPositions();
NavigationPosition previous = index > 0 ? positions.get(index - 1) : null;
NavigationPosition current = index < positions.size() ? positions.get(index) : null;
if (previous != null && current != null) {
Double elevation = previous.calculateElevation(current);
if (elevation != null) return elevation;
}
return 0;
}
@SuppressWarnings("UnusedDeclaration")
public OvlRoute asOvlFormat() {
if (getFormat() instanceof OvlFormat) return (OvlRoute) this;
List<Wgs84Position> ovlPositions = new ArrayList<>();
for (P position : getPositions()) {
ovlPositions.add(position.asOvlPosition());
}
return new OvlRoute(getCharacteristics(), getName(), ovlPositions);
}
@SuppressWarnings("UnusedDeclaration")
public TourRoute asTourFormat() {
if (getFormat() instanceof TourFormat) return (TourRoute) this;
List<TourPosition> tourPositions = new ArrayList<>();
for (P position : getPositions()) {
tourPositions.add(position.asTourPosition());
}
return new TourRoute(getName(), tourPositions);
}
@SuppressWarnings("UnusedDeclaration")
public MagicMapsPthRoute asMagicMapsPthFormat() {
if (getFormat() instanceof MagicMapsPthFormat) return (MagicMapsPthRoute) this;
List<GkPosition> gkPositions = new ArrayList<>();
for (P position : getPositions()) {
gkPositions.add(position.asGkPosition());
}
return new MagicMapsPthRoute(getCharacteristics(), gkPositions);
}
@SuppressWarnings("UnusedDeclaration")
public NokiaLandmarkExchangeRoute asNokiaLandmarkExchangeFormat() {
if (getFormat() instanceof NokiaLandmarkExchangeFormat)
return (NokiaLandmarkExchangeRoute) this;
List<Wgs84Position> wgs84Positions = new ArrayList<>();
for (P position : getPositions()) {
wgs84Positions.add(position.asWgs84Position());
}
return new NokiaLandmarkExchangeRoute(getName(), getDescription(), wgs84Positions);
}
/**
* Removes duplicate adjacent {@link #getPositions() positions} from this route, leaving only
* distinct neighbours
*/
public void removeDuplicates() {
List<P> positions = getPositions();
P previous = null;
int index = 0;
while (index < positions.size()) {
P next = positions.get(index);
if (previous != null && (!next.hasCoordinates() || next.calculateDistance(previous) <= 0.0)) {
positions.remove(index);
} else index++;
previous = next;
}
}
public double getDistance(int startIndex, int endIndex) {
double result = 0;
List<P> positions = getPositions();
NavigationPosition previous = null;
for (int i = startIndex; i <= endIndex; i++) {
NavigationPosition next = positions.get(i);
if (previous != null) {
Double distance = previous.calculateDistance(next);
if (distance != null) result += distance;
}
previous = next;
}
return result;
}
public double getElevationDescend(int startIndex, int endIndex) {
double result = 0;
List<P> positions = getPositions();
NavigationPosition previous = null;
for (int i = startIndex; i <= endIndex; i++) {
NavigationPosition next = positions.get(i);
if (previous != null) {
Double elevation = previous.calculateElevation(next);
if (elevation != null && elevation < 0) result += abs(elevation);
}
previous = next;
}
return result;
}
public void revert() {
List<P> positions = getPositions();
List<P> reverted = new ArrayList<>();
for (P position : positions) {
reverted.add(0, position);
}
order(reverted);
String routeName = getName();
if (!routeName.endsWith(REVERSE_ROUTE_NAME_POSTFIX))
routeName = routeName + REVERSE_ROUTE_NAME_POSTFIX;
else
routeName = routeName.substring(0, routeName.length() - REVERSE_ROUTE_NAME_POSTFIX.length());
setName(routeName);
}
public int getClosestPosition(double longitude, double latitude, double threshold) {
int closestIndex = -1;
double closestDistance = MAX_VALUE;
List<P> positions = getPositions();
for (int i = 0; i < positions.size(); ++i) {
P point = positions.get(i);
Double distance = point.calculateDistance(longitude, latitude);
if (distance != null && distance < closestDistance && distance < threshold) {
closestDistance = distance;
closestIndex = i;
}
}
return closestIndex;
}
public double[] getDistancesFromStart(int startIndex, int endIndex) {
double[] result = new double[endIndex - startIndex + 1];
List<P> positions = getPositions();
int index = 0;
double distance = 0.0;
NavigationPosition previous = positions.size() > 0 ? positions.get(0) : null;
while (index <= endIndex) {
NavigationPosition next = positions.get(index);
if (previous != null) {
Double delta = previous.calculateDistance(next);
if (delta != null) distance += delta;
if (index >= startIndex) result[index - startIndex] = distance;
}
index++;
previous = next;
}
return result;
}
public int[] getPositionsWithinDistanceToPredecessor(double distance) {
List<Integer> result = new ArrayList<>();
List<P> positions = getPositions();
if (positions.size() <= 2) return new int[0];
P previous = positions.get(0);
for (int i = 1; i < positions.size() - 1; i++) {
P next = positions.get(i);
if (!next.hasCoordinates() || next.calculateDistance(previous) <= distance) result.add(i);
else previous = next;
}
return toArray(result);
}
public double[] getDistancesFromStart(int[] indices) {
double[] result = new double[indices.length];
if (indices.length > 0 && getPositionCount() > 0) {
Arrays.sort(indices);
int endIndex = min(indices[indices.length - 1], getPositionCount() - 1);
int index = 0;
double distance = 0.0;
List<P> positions = getPositions();
NavigationPosition previous = positions.get(0);
while (index <= endIndex) {
NavigationPosition next = positions.get(index);
if (previous != null) {
Double delta = previous.calculateDistance(next);
if (delta != null) distance += delta;
int indexInIndices = binarySearch(indices, index);
if (indexInIndices >= 0) result[indexInIndices] = distance;
}
index++;
previous = next;
}
}
return result;
}
public void order(List<P> positions) {
List<P> existing = getPositions();
for (int i = 0; i < positions.size(); i++) {
existing.set(i, positions.get(i));
}
}
public P getSuccessor(P position) {
List<P> positions = getPositions();
int index = positions.indexOf(position);
return index != -1 && index < positions.size() - 1 ? positions.get(index + 1) : null;
}
public P remove(int index) {
List<P> positions = getPositions();
return positions.remove(index);
}
