GeoTrackPoints.java

Go to the documentation of this file.

/*
 * Sleuth Kit Data Model
 *
 * Copyright 2020 Basis Technology Corp.
 * Contact: carrier <at> sleuthkit <dot> org
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *       http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.sleuthkit.datamodel.blackboardutils.attributes;
 
import com.google.gson.annotations.SerializedName;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.stream.Collectors;

public class GeoTrackPoints implements Iterable<GeoTrackPoints.TrackPoint> {
 
        private final List<TrackPoint> pointList;

        public GeoTrackPoints() {
                pointList = new ArrayList<>();
        }

        public void addPoint(TrackPoint trackPoint) {
                if (trackPoint == null) {
                        throw new IllegalArgumentException("addPoint was passed a null track point");
                }
 
                pointList.add(trackPoint);
        }
 
        @Override
        public Iterator<TrackPoint> iterator() {
                return pointList.iterator();
        }

        public boolean isEmpty() {
                return pointList.isEmpty();
        }

        public Long getStartTime() {
                List<TrackPoint> orderedPoints = getTimeOrderedPoints();
                if (orderedPoints != null) {
                        for (TrackPoint point : orderedPoints) {
                                if (point.getTimeStamp() != null) {
                                        return point.getTimeStamp();
                                }
                        }
                }
                return null;
        }

        public Long getEndTime() {
                List<TrackPoint> orderedPoints = getTimeOrderedPoints();
                if (orderedPoints != null) {
                        for (int index = orderedPoints.size() - 1; index >= 0; index--) {
                                TrackPoint point = orderedPoints.get(index);
                                if (point.getTimeStamp() != null) {
                                        return point.getTimeStamp();
                                }
                        }
                }
                return null;
        }

        private List<TrackPoint> getTimeOrderedPoints() {
                return pointList.stream().sorted().collect(Collectors.toCollection(ArrayList::new));
        }

        public final static class TrackPoint extends GeoWaypoints.Waypoint implements Comparable<TrackPoint> {
 
                @SerializedName("TSK_GEO_VELOCITY")
                private final Double velocity;
                @SerializedName("TSK_DISTANCE_FROM_HOMEPOINT")
                private final Double distanceFromHomePoint;
                @SerializedName("TSK_DISTANCE_TRAVELED")
                private final Double distanceTraveled;
                @SerializedName("TSK_DATETIME")
                private final Long timestamp;

                public TrackPoint(Double latitude,
                                Double longitude,
                                Double altitude,
                                String name,
                                Double velocity,
                                Double distanceFromHomePoint,
                                Double distanceTraveled,
                                Long timestamp) {
                        super(latitude, longitude, altitude, name);
                        this.velocity = velocity;
                        this.distanceFromHomePoint = distanceFromHomePoint;
                        this.distanceTraveled = distanceTraveled;
                        this.timestamp = timestamp;
                }

                public Double getVelocity() {
                        return velocity;
                }

                public Double getDistanceFromHomePoint() {
                        return distanceFromHomePoint;
                }

                public Double getDistanceTraveled() {
                        return distanceTraveled;
                }

                public Long getTimeStamp() {
                        return timestamp;
                }
 
                @Override
                public int compareTo(TrackPoint otherTP) {
                        Long otherTimeStamp = otherTP.getTimeStamp();
 
                        if (timestamp == null) {
                                if (otherTimeStamp != null) {
                                        return -1;
                                } else {
                                        return 0;
                                }
                        } else if (timestamp != null && otherTimeStamp == null) {
                                return 1;
                        } else {
                                return timestamp.compareTo(otherTP.getTimeStamp());
                        }
                }
        }
 
}