Changeset 60 for bbtracker_common/trunk/src/org/bbtracker/UnitConverter.java

Timestamp:

08/08/07 02:46:26 (5 years ago)

Author:

saua

Message:

• Create new PlotterTile? which plottes any DataProvider?
• Refactor TrackTile? to extend PlotterTile? (with exactly the same functionality)
• Implement ElevationPlotterTile?
• Implement SpeedPlotterTile?
• Implement Changing Main Tiles in MainCanvas?

Fixes Issue #8

File:

• bbtracker_common/trunk/src/org/bbtracker/UnitConverter.java (modified) (2 diffs)

bbtracker_common/trunk/src/org/bbtracker/UnitConverter.java

@@ -28 +28 @@
         public abstract String distanceToString(final double distance);
 
-        public abstract ScaleConfiguration getScaleConfiguration(final double availableMeter);
+        public abstract ScaleConfiguration getScaleDistance(final double availableMeter);
+
+        public abstract ScaleConfiguration getScaleElevation(final int min, final int max);
+
+        public abstract ScaleConfiguration getScaleSpeed(final double maxSpeed);
 
         /**
@@ -51 +55 @@
         }
 
+        protected static ScaleConfiguration getScaleConfiguration(final String unit, final double min, final double max) {
+                final double diff = max - min;
+                if (diff == 0) {
+                        final ScaleConfiguration conf = new ScaleConfiguration();
+                        conf.unit = unit;
+                        conf.lengthInSourceUnits = diff;
+                        conf.labelLocation = new float[] { (float) min };
+                        conf.labelValue = new float[] { 0.0f };
+                        return conf;
+                }
+
+                final ScaleConfiguration conf = new ScaleConfiguration();
+                conf.unit = unit;
+                conf.lengthInSourceUnits = diff;
+
+                // calculate approximate tick size (find correct power of ten)
+                double tickSize;
+                // I wanted to use log10 to find the correct magnitude, but that's not available in CLDC 1.1
+                tickSize = 1;
+                if (tickSize > diff) {
+                        while (tickSize > diff) {
+                                tickSize /= 10;
+                        }
+                } else {
+                        while (tickSize < diff / 10) {
+                                tickSize *= 10;
+                        }
+                }
+
+                // adjust to get a reasonable number of ticks (usually between 3 and 6)
+                int ticks = (int) (diff / tickSize);
+                if (ticks > 5) {
+                        tickSize *= 2;
+                }
+
+                // might be one to big, but that's better than one to small
+                ticks = (int) (diff / tickSize) + 1;
+
+                conf.labelLocation = new float[ticks];
+                conf.labelValue = new float[ticks];
+
+                // find first tick
+                double tMin = (int) (min / tickSize) * tickSize;
+                if (tMin < min) {
+                        tMin += tickSize;
+                }
+
+                double t = tMin;
+                int i = 0;
+                do {
+                        // adding a multiple results in smaller numerical errors than adding each iteration
+                        conf.labelValue[i] = (float) t;
+                        conf.labelLocation[i] = (float) ((t - min) / diff);
+                        t = tMin + (++i) * tickSize;
+                } while (t <= max);
+
+                if (i < ticks) {
+                        conf.labelLocation[i] = Float.NaN;
+                        conf.labelValue[i] = Float.NaN;
+                }
+                return conf;
+        }
+
         public static class ScaleConfiguration {
+                ScaleConfiguration() {
+                }
+
                 public String unit;
 
-                public int lengthInUnits;
+                /**
+                 * The values for the labels.
+                 * 
+                 * Any value might be {@link Float#NaN} to indicate an unused entry (this is used to avoid unnecessary
+                 * re-allocation of a smaller array).
+                 */
+                public float[] labelValue;
 
-                public double lengthInMeter;
+                /**
+                 * The relative label positions ranging from 0 (minimum) to 1 (maximum).
+                 * 
+                 * Any value might be {@link Float#NaN} just as in {@link #labelValue}.
+                 */
+                public float[] labelLocation;
+
+                /**
+                 * The length in source units (meter for distance and elevation, m/s for speed)
+                 */
+                public double lengthInSourceUnits;
         }
 }