tim/prune/function/compress/TrackDetails.java

   1 package tim.prune.function.compress;
   2
   3 import tim.prune.data.DataPoint;
   4 import tim.prune.data.Track;
   5
   6 /**
   7  * Class to hold details about a track
   8  * which might be useful for compression
   9  */
  10 public class TrackDetails
  11 {
  12         /** Track object */
  13         private Track _track = null;
  14         /** Range span */
  15         private double _trackSpan = -1.0;
  16         /** Markers for start of segment */
  17         private boolean[] _segmentStarts = null;
  18         /** Markers for end of segment */
  19         private boolean[] _segmentEnds = null;
  20         /** Mean distance between track points in radians */
  21         private double _meanRadians = 0.0;
  22
  23
  24         /**
  25          * Constructor
  26          * @param inTrack track object
  27          */
  28         public TrackDetails(Track inTrack)
  29         {
  30                 _track = inTrack;
  31         }
  32
  33         /**
  34          * Recalculate all details
  35          */
  36         public void initialise()
  37         {
  38                 // calculate track span
  39                 double xRange = _track.getXRange().getRange();
  40                 double yRange = _track.getYRange().getRange();
  41                 _trackSpan = (xRange > yRange ? xRange : yRange);
  42
  43                 // Calculate segment starts / ends
  44                 int numPoints = _track.getNumPoints();
  45                 _segmentStarts = new boolean[numPoints];
  46                 _segmentEnds = new boolean[numPoints];
  47                 int prevTrackPointIndex = -1;
  48                 int numDistances = 0; double totalRadians = 0.0;
  49                 // Loop over points
  50                 for (int i=0; i<numPoints; i++)
  51                 {
  52                         DataPoint point = _track.getPoint(i);
  53                         if (!point.isWaypoint())
  54                         {
  55                                 // track point, check for segment flag
  56                                 if (point.getSegmentStart())
  57                                 {
  58                                         // set start of segment and end of previous
  59                                         _segmentStarts[i] = true;
  60                                         if (prevTrackPointIndex >= 0) {
  61                                                 _segmentEnds[prevTrackPointIndex] = true;
  62                                         }
  63                                 }
  64                                 else {
  65                                         // Add up distances between points within the same track segment
  66                                         if (prevTrackPointIndex >= 0) {
  67                                                 numDistances++;
  68                                                 totalRadians += DataPoint.calculateRadiansBetween(_track.getPoint(prevTrackPointIndex), point);
  69                                         }
  70                                 }
  71                                 prevTrackPointIndex = i;
  72                         }
  73                 }
  74                 // last segment
  75                 _segmentEnds[prevTrackPointIndex] = true;
  76                 // Mean radians between points
  77                 _meanRadians = totalRadians / numDistances;
  78         }
  79
  80
  81         /**
  82          * @return the track span
  83          */
  84         public double getTrackSpan()
  85         {
  86                 if (_trackSpan < 0.0) {initialise();}
  87                 return _trackSpan;
  88         }
  89
  90         /**
  91          * @param inPointIndex index of point to check
  92          * @return true if specified point is start of segment
  93          */
  94         public boolean isSegmentStart(int inPointIndex)
  95         {
  96                 if (_segmentStarts == null ||
  97                         _segmentStarts.length != _track.getNumPoints()) {initialise();}
  98                 return _segmentStarts[inPointIndex];
  99         }
 100
 101         /**
 102          * @param inPointIndex index of point to check
 103          * @return true if specified point is end of segment
 104          */
 105         public boolean isSegmentEnd(int inPointIndex)
 106         {
 107                 if (_segmentEnds == null ||
 108                         _segmentEnds.length != _track.getNumPoints()) {initialise();}
 109                 return _segmentEnds[inPointIndex];
 110         }
 111
 112         /**
 113          * @return mean radians between adjacent track points
 114          */
 115         public double getMeanRadians()
 116         {
 117                 if (_meanRadians == 0.0) {initialise();}
 118                 return _meanRadians;
 119         }
 120 }