Version 16, February 2014

[GpsPrune.git] / tim / prune / data / PointScaler.java

diff --git a/tim/prune/data/PointScaler.java b/tim/prune/data/PointScaler.java
index a1338857e0c509acc6a3d6227f4044080e3f2914..446c0a204758b0b9c940d6462b8f686aad6030ee 100644 (file)
--- a/tim/prune/data/PointScaler.java
+++ b/tim/prune/data/PointScaler.java
@@ -5,14 +5,23 @@ package tim.prune.data;
  */
 public class PointScaler
 {
-       // Original data
+       /** Original data */
        private Track _track = null;
-       // Scaled values
+       /** Secondary data for terrain grid */
+       private Track _terrainTrack = null;
+       // Scaled values for data track
        private double[] _xValues = null;
        private double[] _yValues = null;
        private double[] _altValues = null;
+       // Scaled values for terrain track, if any
+       private double[] _terrainxValues = null;
+       private double[] _terrainyValues = null;
+       private double[] _terrainAltValues = null;
        // Altitude range
        private double _altitudeRange = 0.0;
+       private double _minAltitudeMetres = 0.0;
+       // Horizontal distance
+       private double _horizDistanceMetres = 0.0;
 
 
        /**
@@ -24,6 +33,13 @@ public class PointScaler
                _track = inTrack;
        }
 
+       /**
+        * @param inTrack terrain track to add
+        */
+       public void addTerrain(Track inTrack)
+       {
+               _terrainTrack = inTrack;
+       }
 
        /**
         * Scale the points
@@ -33,12 +49,16 @@ public class PointScaler
                // Work out extents
                TrackExtents extents = new TrackExtents(_track);
                extents.applySquareBorder();
-               final double horizDistance = Math.max(extents.getHorizontalDistanceMetres(), 1.0);
+               _horizDistanceMetres = Math.max(extents.getHorizontalDistanceMetres(), 1.0);
                final int numPoints = _track.getNumPoints();
 
-               // Find altitude range
-               _altitudeRange = extents.getAltitudeRange().getRange() / horizDistance;
-               final double minAltitude = extents.getAltitudeRange().getMinimum();
+               // Find altitude range (including terrain)
+               DoubleRange altRangeMetres = extents.getAltitudeRange();
+               if (_terrainTrack != null) {
+                       altRangeMetres.combine(new TrackExtents(_terrainTrack).getAltitudeRange());
+               }
+               _altitudeRange = altRangeMetres.getRange() / _horizDistanceMetres;
+               _minAltitudeMetres = altRangeMetres.getMinimum();
 
                // create new arrays for scaled values
                if (_xValues == null || _xValues.length != numPoints)
@@ -46,6 +66,12 @@ public class PointScaler
                        _xValues = new double[numPoints];
                        _yValues = new double[numPoints];
                        _altValues = new double[numPoints];
+                       if (_terrainTrack != null)
+                       {
+                               _terrainxValues = new double[_terrainTrack.getNumPoints()];
+                               _terrainyValues = new double[_terrainTrack.getNumPoints()];
+                               _terrainAltValues = new double[_terrainTrack.getNumPoints()];
+                       }
                }
 
                final double midXvalue = extents.getXRange().getMidValue();
@@ -60,7 +86,16 @@ public class PointScaler
                        {
                                _xValues[p] = (_track.getX(p) - midXvalue) / xyRange;
                                _yValues[p] = (midYvalue - _track.getY(p)) / xyRange; // y values have to be inverted
-                               _altValues[p] = (point.getAltitude().getMetricValue() - minAltitude) / horizDistance;
+                               _altValues[p] = (point.getAltitude().getMetricValue() - _minAltitudeMetres) / _horizDistanceMetres;
+                       }
+               }
+               if (_terrainTrack != null)
+               {
+                       for (int p=0; p<_terrainTrack.getNumPoints(); p++)
+                       {
+                               _terrainxValues[p] = (_terrainTrack.getX(p) - midXvalue) / xyRange;
+                               _terrainyValues[p] = (midYvalue - _terrainTrack.getY(p)) / xyRange; // y values have to be inverted
+                               _terrainAltValues[p] = (_terrainTrack.getPoint(p).getAltitude().getMetricValue() - _minAltitudeMetres) / _horizDistanceMetres;
                        }
                }
        }
@@ -98,10 +133,42 @@ public class PointScaler
        }
 
        /**
-        * @return altitude range, in metres
+        * @return altitude range as fraction of horizontal range
         */
        public double getAltitudeRange()
        {
                return _altitudeRange;
        }
+
+       /**
+        * Get the horizontal value for the specified point
+        * @param inIndex index of point, starting at 0
+        * @return scaled horizontal value
+        */
+       public double getTerrainHorizValue(int inIndex)
+       {
+               return _terrainxValues[inIndex];
+       }
+
+       /**
+        * Get the vertical value for the specified point
+        * @param inIndex index of point, starting at 0
+        * @return scaled vertical value
+        */
+       public double getTerrainVertValue(int inIndex)
+       {
+               return _terrainyValues[inIndex];
+       }
+
+       /**
+        * @param inIndex index of point in terrain track
+        * @return scaled altitude value for the specified terrain point
+        */
+       public double getTerrainAltValue(int inIndex)
+       {
+               if (_terrainAltValues != null) {
+                       return _terrainAltValues[inIndex];
+               }
+               return 0.0;
+       }
 }