src/tim/prune/function/srtm/LookupSrtmFunction.java

   1 package tim.prune.function.srtm;
   2
   3 import java.util.ArrayList;
   4
   5 import javax.swing.JOptionPane;
   6
   7 import tim.prune.App;
   8 import tim.prune.DataSubscriber;
   9 import tim.prune.GenericFunction;
  10 import tim.prune.I18nManager;
  11 import tim.prune.UpdateMessageBroker;
  12 import tim.prune.data.Altitude;
  13 import tim.prune.data.DataPoint;
  14 import tim.prune.data.Field;
  15 import tim.prune.data.Track;
  16 import tim.prune.data.UnitSetLibrary;
  17 import tim.prune.gui.ProgressDialog;
  18 import tim.prune.undo.UndoLookupSrtm;
  19
  20 /**
  21  * Class to provide a lookup function for point altitudes using the Space
  22  * Shuttle's SRTM data files. HGT files are downloaded into memory via HTTP and
  23  * point altitudes can then be interpolated from the 3m grid data.
  24  */
  25 public class LookupSrtmFunction extends GenericFunction implements Runnable
  26 {
  27         /** Progress dialog */
  28         private ProgressDialog _progress = null;
  29         /** Track to process */
  30         private Track _track = null;
  31         /** Flag for whether this is a real track or a terrain one */
  32         private boolean _normalTrack = true;
  33         /** Flag to check whether this function is currently running or not */
  34         private boolean _running = false;
  35
  36         /** Altitude below which is considered void */
  37         private static final int VOID_VAL = -32768;
  38
  39         /**
  40          * Constructor
  41          * @param inApp  App object
  42          */
  43         public LookupSrtmFunction(App inApp) {
  44                 super(inApp);
  45         }
  46
  47         /** @return name key */
  48         public String getNameKey() {
  49                 return "function.lookupsrtm";
  50         }
  51
  52         /**
  53          * Begin the lookup using the normal track
  54          */
  55         public void begin() {
  56                 begin(_app.getTrackInfo().getTrack(), true);
  57         }
  58
  59         /**
  60          * Begin the lookup with an alternative track
  61          * @param inAlternativeTrack
  62          */
  63         public void begin(Track inAlternativeTrack) {
  64                 begin(inAlternativeTrack, false);
  65         }
  66
  67         /**
  68          * Begin the function with the given parameters
  69          * @param inTrack track to process
  70          * @param inNormalTrack true if this is a "normal" track, false for an artificially constructed one such as for terrain
  71          */
  72         private void begin(Track inTrack, boolean inNormalTrack)
  73         {
  74                 _running = true;
  75                 if (! SrtmDiskCache.ensureCacheIsUsable())
  76                 {
  77                         _app.showErrorMessage(getNameKey(), "error.cache.notthere");
  78                 }
  79                 if (_progress == null) {
  80                         _progress = new ProgressDialog(_parentFrame, getNameKey());
  81                 }
  82                 _progress.show();
  83                 _track = inTrack;
  84                 _normalTrack = inNormalTrack;
  85                 // start new thread for time-consuming part
  86                 new Thread(this).start();
  87         }
  88
  89         /**
  90          * Run method using separate thread
  91          */
  92         public void run()
  93         {
  94                 // Compile list of tiles to get
  95                 ArrayList<SrtmTile> tileList = new ArrayList<SrtmTile>();
  96                 boolean hasZeroAltitudePoints = false;
  97                 boolean hasNonZeroAltitudePoints = false;
  98                 // First, loop to see what kind of points we have
  99                 for (int i = 0; i < _track.getNumPoints(); i++)
 100                 {
 101                         if (_track.getPoint(i).hasAltitude())
 102                         {
 103                                 if (_track.getPoint(i).getAltitude().getValue() == 0) {
 104                                         hasZeroAltitudePoints = true;
 105                                 }
 106                                 else {
 107                                         hasNonZeroAltitudePoints = true;
 108                                 }
 109                         }
 110                 }
 111                 // Should we overwrite the zero altitude values?
 112                 boolean overwriteZeros = hasZeroAltitudePoints && !hasNonZeroAltitudePoints;
 113                 // If non-zero values present as well, ask user whether to overwrite the zeros or not
 114                 if (hasNonZeroAltitudePoints && hasZeroAltitudePoints && JOptionPane.showConfirmDialog(_parentFrame,
 115                         I18nManager.getText("dialog.lookupsrtm.overwritezeros"), I18nManager.getText(getNameKey()),
 116                         JOptionPane.YES_NO_OPTION) == JOptionPane.YES_OPTION)
 117                 {
 118                         overwriteZeros = true;
 119                 }
 120
 121                 // Now loop again to extract the required tiles
 122                 for (int i = 0; i < _track.getNumPoints(); i++)
 123                 {
 124                         // Consider points which don't have altitudes or have zero values
 125                         if (needsAltitude(_track.getPoint(i), overwriteZeros))
 126                         {
 127                                 SrtmTile tile = new SrtmTile(_track.getPoint(i));
 128                                 boolean alreadyGot = false;
 129                                 for (int t = 0; t < tileList.size(); t++)
 130                                 {
 131                                         if (tileList.get(t).equals(tile)) {
 132                                                 alreadyGot = true;
 133                                         }
 134                                 }
 135                                 if (!alreadyGot) {tileList.add(tile);}
 136                         }
 137                 }
 138                 lookupValues(tileList, overwriteZeros);
 139                 // Finished
 140                 _running = false;
 141         }
 142
 143         /**
 144          * true if we need to set the altitude of this point
 145          */
 146         private boolean needsAltitude(DataPoint point, boolean overwriteZeros)
 147         {
 148                 if (!point.hasAltitude())
 149                 {
 150                         return true;
 151                 }
 152                 if (overwriteZeros && point.getAltitude().getValue() == 0)
 153                 {
 154                         return true;
 155                 }
 156                 return false;
 157         }
 158
 159         /**
 160          * Lookup the values from SRTM data
 161          * @param inTileList list of tiles to get
 162          * @param inOverwriteZeros true to overwrite zero altitude values
 163          */
 164         private void lookupValues(ArrayList<SrtmTile> inTileList, boolean inOverwriteZeros)
 165         {
 166                 UndoLookupSrtm undo = new UndoLookupSrtm(_app.getTrackInfo());
 167                 int numAltitudesFound = 0;
 168                 // Update progress bar
 169                 if (_progress != null)
 170                 {
 171                         _progress.setMaximum(inTileList.size());
 172                         _progress.setValue(0);
 173                 }
 174                 String errorMessage = "";
 175                 for (int t=0; t<inTileList.size() && !_progress.isCancelled(); t++)
 176                 {
 177                         SrtmTile tile = inTileList.get(t);
 178                         SrtmSource srtmSource = tile.findBestCachedSource();
 179
 180                         if (srtmSource == null)
 181                         {
 182                                 errorMessage += "Tile "+tile.getTileName()+" not in cache!\n";
 183                                 continue;
 184                         }
 185
 186                         // Set progress
 187                         _progress.setValue(t);
 188
 189                         int[] heights;
 190                         try {
 191                                 heights = srtmSource.getTileHeights(tile);
 192                         }
 193                         catch (SrtmSourceException e)
 194                         {
 195                                 errorMessage += e.getMessage();
 196                                 e.printStackTrace();
 197                                 continue;
 198                         }
 199                         int rowSize = srtmSource.getRowSize(tile);
 200                         if (rowSize <= 0)
 201                         {
 202                                 errorMessage += "Tile "+tile.getTileName()+" is corrupted";
 203                         }
 204
 205                         try {
 206                                 numAltitudesFound += applySrtmTileToWholeTrack(tile, heights, rowSize, inOverwriteZeros);
 207                         }
 208                         catch (SrtmSourceException e)
 209                         {
 210                                 errorMessage += e.getMessage();
 211                                 continue;
 212                         }
 213                 }
 214
 215                 _progress.dispose();
 216                 if (_progress.isCancelled()) {
 217                         return;
 218                 }
 219
 220                 if (! errorMessage.equals("")) {
 221                         _app.showErrorMessageNoLookup(getNameKey(), errorMessage);
 222                         return;
 223                 }
 224                 if (numAltitudesFound > 0)
 225                 {
 226                         // Inform app including undo information
 227                         _track.requestRescale();
 228                         UpdateMessageBroker.informSubscribers(DataSubscriber.DATA_ADDED_OR_REMOVED);
 229                         // Don't update app if we're doing another track
 230                         if (_normalTrack)
 231                         {
 232                                 _app.completeFunction(undo,
 233                                         I18nManager.getTextWithNumber("confirm.lookupsrtm", numAltitudesFound));
 234                         }
 235                 }
 236                 else if (inTileList.size() > 0) {
 237                         _app.showErrorMessage(getNameKey(), "error.lookupsrtm.nonefound");
 238                 }
 239                 else {
 240                         _app.showErrorMessage(getNameKey(), "error.lookupsrtm.nonerequired");
 241                 }
 242         }
 243
 244         /**
 245          * Given the height data read in from file, apply the given tile to all points
 246          * in the track with missing altitude
 247          * @param inTile tile being applied
 248          * @param inHeights height data read in from file
 249          * @param inOverwriteZeros true to overwrite zero altitude values
 250          * @return number of altitudes found
 251          */
 252         private int applySrtmTileToWholeTrack(SrtmTile inTile, int[] inHeights, int inRowSize, boolean inOverwriteZeros)
 253                 throws SrtmSourceException
 254         {
 255                 int numAltitudesFound = 0;
 256                 // Loop over all points in track, try to apply altitude from array
 257                 for (int p = 0; p < _track.getNumPoints(); p++)
 258                 {
 259                         DataPoint point = _track.getPoint(p);
 260                         if (needsAltitude(point, inOverwriteZeros))
 261                         {
 262                                 if (new SrtmTile(point).equals(inTile))
 263                                 {
 264                                         double x = (point.getLongitude().getDouble() - inTile.getLongitude()) * (inRowSize - 1);
 265                                         double y = inRowSize - (point.getLatitude().getDouble() - inTile.getLatitude()) * (inRowSize - 1);
 266                                         int idx1 = ((int)y)*inRowSize + (int)x;
 267                                         try
 268                                         {
 269                                                 int[] fouralts = {inHeights[idx1], inHeights[idx1+1], inHeights[idx1-inRowSize], inHeights[idx1-inRowSize+1]};
 270                                                 int numVoids = (fouralts[0]==VOID_VAL?1:0) + (fouralts[1]==VOID_VAL?1:0)
 271                                                         + (fouralts[2]==VOID_VAL?1:0) + (fouralts[3]==VOID_VAL?1:0);
 272                                                 // if (numVoids > 0) System.out.println(numVoids + " voids found");
 273                                                 double altitude = 0.0;
 274                                                 switch (numVoids)
 275                                                 {
 276                                                 case 0: altitude = bilinearInterpolate(fouralts, x, y); break;
 277                                                 case 1: altitude = bilinearInterpolate(fixVoid(fouralts), x, y); break;
 278                                                 case 2:
 279                                                 case 3: altitude = averageNonVoid(fouralts); break;
 280                                                 default: altitude = VOID_VAL;
 281                                                 }
 282                                                 // Special case for terrain tracks, don't interpolate voids yet
 283                                                 if (!_normalTrack && numVoids > 0) {
 284                                                         altitude = VOID_VAL;
 285                                                 }
 286                                                 if (altitude != VOID_VAL)
 287                                                 {
 288                                                         point.setFieldValue(Field.ALTITUDE, ""+altitude, false);
 289                                                         // depending on settings, this value may have been added as feet, we need to force metres
 290                                                         point.getAltitude().reset(new Altitude((int)altitude, UnitSetLibrary.UNITS_METRES));
 291                                                         numAltitudesFound++;
 292                                                 }
 293                                         }
 294                                         catch (ArrayIndexOutOfBoundsException obe) {
 295                                                 throw new SrtmSourceException("Point not in tile? lat=" + point.getLatitude().getDouble() + ", x=" + x + ", y=" + y + ", idx=" + idx1+"\n");
 296                                         }
 297                                 }
 298                         }
 299                 }
 300                 return numAltitudesFound;
 301         }
 302
 303         /**
 304          * Perform a bilinear interpolation on the given altitude array
 305          * @param inAltitudes array of four altitude values on corners of square (bl, br, tl, tr)
 306          * @param inX x coordinate
 307          * @param inY y coordinate
 308          * @return interpolated altitude
 309          */
 310         private static double bilinearInterpolate(int[] inAltitudes, double inX, double inY)
 311         {
 312                 double alpha = inX - (int) inX;
 313                 double beta  = 1 - (inY - (int) inY);
 314                 double alt = (1-alpha)*(1-beta)*inAltitudes[0] + alpha*(1-beta)*inAltitudes[1]
 315                         + (1-alpha)*beta*inAltitudes[2] + alpha*beta*inAltitudes[3];
 316                 return alt;
 317         }
 318
 319         /**
 320          * Fix a single void in the given array by replacing it with the average of the others
 321          * @param inAltitudes array of altitudes containing one void
 322          * @return fixed array without voids
 323          */
 324         private static int[] fixVoid(int[] inAltitudes)
 325         {
 326                 int[] fixed = new int[inAltitudes.length];
 327                 for (int i = 0; i < inAltitudes.length; i++)
 328                 {
 329                         if (inAltitudes[i] == VOID_VAL) {
 330                                 fixed[i] = (int) Math.round(averageNonVoid(inAltitudes));
 331                         }
 332                         else {
 333                                 fixed[i] = inAltitudes[i];
 334                         }
 335                 }
 336                 return fixed;
 337         }
 338
 339         /**
 340          * Calculate the average of the non-void altitudes in the given array
 341          * @param inAltitudes array of altitudes with one or more voids
 342          * @return average of non-void altitudes
 343          */
 344         private static final double averageNonVoid(int[] inAltitudes)
 345         {
 346                 double totalAltitude = 0.0;
 347                 int numAlts = 0;
 348                 for (int i = 0; i < inAltitudes.length; i++)
 349                 {
 350                         if (inAltitudes[i] != VOID_VAL)
 351                         {
 352                                 totalAltitude += inAltitudes[i];
 353                                 numAlts++;
 354                         }
 355                 }
 356                 if (numAlts < 1) {return VOID_VAL;}
 357                 return totalAltitude / numAlts;
 358         }
 359
 360         /**
 361          * @return true if a thread is currently running
 362          */
 363         public boolean isRunning()
 364         {
 365                 return _running;
 366         }
 367 }