geo/tcSrtmCache.cpp

   1 /***************************************************************************
   2  *   This file is part of Tecorrec.                                        *
   3  *   Copyright 2008 James Hogan <james@albanarts.com>                      *
   4  *                                                                         *
   5  *   Tecorrec is free software: you can redistribute it and/or modify      *
   6  *   it under the terms of the GNU General Public License as published by  *
   7  *   the Free Software Foundation, either version 2 of the License, or     *
   8  *   (at your option) any later version.                                   *
   9  *                                                                         *
  10  *   Tecorrec is distributed in the hope that it will be useful,           *
  11  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
  12  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
  13  *   GNU General Public License for more details.                          *
  14  *                                                                         *
  15  *   You should have received a copy of the GNU General Public License     *
  16  *   along with Tecorrec.  If not, write to the Free Software Foundation,  *
  17  *   Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.   *
  18  ***************************************************************************/
  19
  20 /**
  21  * @file tcSrtmCache.cpp
  22  * @brief Manages cache of SRTM data.
  23  */
  24
  25 #include "tcSrtmCache.h"
  26 #include "tcSrtmData.h"
  27 #include "tcElevationData.h"
  28
  29 #include <QString>
  30 #include <QStringList>
  31 #include <QFile>
  32
  33 #include <cstdlib>
  34
  35 /*
  36  * Static variables
  37  */
  38
  39 QDir tcSrtmCache::s_dataDirectory("/home/james/cs/pro/data/srtm");
  40
  41 /*
  42  * Static functions
  43  */
  44
  45 /// Get a list of datasets.
  46 QStringList tcSrtmCache::dataSets()
  47 {
  48   return s_dataDirectory.entryList(QDir::AllDirs | QDir::NoDotAndDotDot, QDir::Name);
  49 }
  50
  51 /*
  52  * Constructors + destructor
  53  */
  54
  55 /// Primary constructor.
  56 tcSrtmCache::tcSrtmCache(const QString& dataSet)
  57 : m_dataSet(dataSet)
  58 {
  59   for (int i = 0; i < 360; ++i)
  60   {
  61     for (int j = 0; j < 180; ++j)
  62     {
  63       m_cache[i][j] = 0;
  64     }
  65   }
  66 }
  67
  68 /// Destructor.
  69 tcSrtmCache::~tcSrtmCache()
  70 {
  71   for (int i = 0; i < 360; ++i)
  72   {
  73     for (int j = 0; j < 180; ++j)
  74     {
  75       if ((tcSrtmData*)0x1 != m_cache[i][j])
  76       {
  77         delete m_cache[i][j];
  78       }
  79     }
  80   }
  81 }
  82
  83 /*
  84  * Main interface
  85  */
  86
  87 /// Load raw SRTM height file.
  88 tcSrtmData* tcSrtmCache::loadData(int lon, int lat)
  89 {
  90   tcSrtmData*& cacheItem = cache(lon, lat);
  91   if (0 == cacheItem)
  92   {
  93     QString filename = QString("%1/%2/%3%4%5%6.hgt")
  94                                   .arg(s_dataDirectory.path())
  95                                   .arg(m_dataSet)
  96                                   .arg(lat >= 0 ? 'N' : 'S')
  97                                   .arg(abs(lat), 2, 10, QLatin1Char('0'))
  98                                   .arg(lon >= 0 ? 'E' : 'W')
  99                                   .arg(abs(lon), 3, 10, QLatin1Char('0'));
 100     QFile file(filename);
 101     if (file.open(QIODevice::ReadOnly))
 102     {
 103       cacheItem = new tcSrtmData(lon, lat, file, this, SIGNAL(progressing(const QString&)));
 104     }
 105     else
 106     {
 107       // 0x1 represents a previous failed attempt
 108       cacheItem = (tcSrtmData*)0x1;
 109     }
 110   }
 111   if ((tcSrtmData*)0x1 != cacheItem)
 112   {
 113     return cacheItem;
 114   }
 115   else
 116   {
 117     return 0;
 118   }
 119 }
 120
 121 /// Load raw SRTM height file.
 122 tcSrtmData* tcSrtmCache::loadData(const tcGeo& coord)
 123 {
 124   int lon,lat;
 125   toIntLonLat(coord, &lon, &lat);
 126   return loadData(lon, lat);
 127 }
 128
 129 /** Find some SRTM height data overlapping an area.
 130  * @param swCorner Geographical coordinate of south-west corner.
 131  * @param neCorner Geographical coordinate of north-east corner.
 132  * @returns An arbitrary SRTM data for a chunk in the lon lat range.
 133  */
 134 tcSrtmData* tcSrtmCache::findData(const tcGeo& swCorner, const tcGeo& neCorner)
 135 {
 136   int swLon,swLat;
 137   int neLon,neLat;
 138   toIntLonLat(swCorner, &swLon, &swLat);
 139   toIntLonLat(neCorner, &neLon, &neLat);
 140   for (int lon = swLon; lon <= neLon; ++lon)
 141   {
 142     for (int lat = swLat; lat <= neLat; ++lat)
 143     {
 144       tcSrtmData* result = loadData(lon,lat);
 145       if (0 != result)
 146       {
 147         return result;
 148       }
 149     }
 150   }
 151   return 0;
 152 }
 153
 154 /// Update any samples affected by the elevation field.
 155 void tcSrtmCache::updateFromElevationData(const tcElevationData* elevation)
 156 {
 157   tcGeo swCorner = elevation->swCorner();
 158   tcGeo neCorner = elevation->neCorner();
 159   int mini = (int)floor(swCorner.lon()*180.0/M_PI) + 180;
 160   int maxi = (int) ceil(neCorner.lon()*180.0/M_PI) + 180;
 161   int minj = (int)floor(swCorner.lat()*180.0/M_PI) + 90;
 162   int maxj = (int) ceil(neCorner.lat()*180.0/M_PI) + 90;
 163   for (int ii = mini; ii < maxi; ++ii)
 164   {
 165     int i = ii % 360;
 166     for (int j = minj; j < maxj; ++j)
 167     {
 168       if (0 != m_cache[i][j] && (tcSrtmData*)0x1 != m_cache[i][j])
 169       {
 170         m_cache[i][j]->updateFromElevationData(elevation);
 171       }
 172     }
 173   }
 174 }
 175
 176 /*
 177  * Private functions
 178  */
 179
 180 /// Convert a geographical coordinate into lon lat ints.
 181 void tcSrtmCache::toIntLonLat(const tcGeo& coord, int* const outLon, int* const outLat)
 182 {
 183   int lat = (int)floor(coord.lat() * 180.0/M_PI);
 184   int lon = (int)floor(coord.lon() * 180.0/M_PI);
 185   lat = lat % 360;
 186   if (lat < -90)
 187   {
 188     lat += 360;
 189   }
 190   if (lat >= 90)
 191   {
 192     lat -= 180;
 193     lon += 180;
 194   }
 195   lon = lon % 360;
 196   if (lon < -180)
 197   {
 198     lon += 360;
 199   }
 200   else if (lon >= 180)
 201   {
 202     lon -= 360;
 203   }
 204   *outLon = lon;
 205   *outLat = lat;
 206 }
 207
 208 /// Cache index.
 209 tcSrtmData*& tcSrtmCache::cache(int lon, int lat)
 210 {
 211   Q_ASSERT(lon >= -180 && lon < 180);
 212   Q_ASSERT(lat >= -90 && lat < 90);
 213   return m_cache[180 + lon][90 + lat];
 214 }