arctohgt/arcToHgt.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 #include <QString>
  21 #include <QByteArray>
  22 #include <QFile>
  23 #include <QRegExp>
  24 #include <QtDebug>
  25
  26 #include <cmath>
  27
  28 double readDouble(QFile& file)
  29 {
  30   QByteArray line = file.readLine();
  31   static QRegExp intLine("^\\s*\\w+\\s+([-+]?\\d+(\\.\\d+)?)\\s*$");
  32   if (intLine.exactMatch(line))
  33   {
  34     return intLine.cap(1).toDouble();
  35   }
  36   else
  37   {
  38     return -1;
  39   }
  40 }
  41
  42 int readInt(QFile& file)
  43 {
  44   QByteArray line = file.readLine();
  45   static QRegExp intLine("^\\s*\\w+\\s+([-+]?\\d+)\\s*$");
  46   if (intLine.exactMatch(line))
  47   {
  48     return intLine.cap(1).toInt();
  49   }
  50   else
  51   {
  52     return -1;
  53   }
  54 }
  55
  56 int arcToHgt(const QString filename, char* voids)
  57 {
  58   qDebug() << "Reading" << filename;
  59
  60   // first open arcinfo file
  61   QFile af(filename);
  62   if (!af.open(QIODevice::ReadOnly))
  63   {
  64     return 1;
  65   }
  66
  67   // and read the header info
  68   int ncols = readInt(af);
  69   int nrows = readInt(af);
  70   double xllcorner = readDouble(af);
  71   double yllcorner = readDouble(af);
  72   double cellsize = readDouble(af);
  73   int nodata_value = readInt(af);
  74
  75   // find corresponding HGT tiles
  76   int lonMin = (int)floor(xllcorner);
  77   int lonMax = (int)floor(xllcorner + cellsize*(ncols-1));
  78   int latMin = (int)floor(yllcorner);
  79   int latMax = (int)floor(yllcorner + cellsize*(nrows-1));
  80   int tilesX = 1+lonMax-lonMin;
  81   int tilesY = 1+latMax-latMin;
  82   QFile* srtm = new QFile[tilesX*tilesY];
  83   QFile* voidfs = 0;
  84   if (0 != voids)
  85   {
  86     voidfs = new QFile[tilesX*tilesY];
  87   }
  88   for (int lon = lonMin; lon <= lonMax; ++lon)
  89   {
  90     for (int lat = latMin; lat <= latMax; ++lat)
  91     {
  92       QString filename = QString("%3%4%5%6.hgt")
  93                                     .arg(lat >= 0 ? 'N' : 'S')
  94                                     .arg(abs(lat), 2, 10, QLatin1Char('0'))
  95                                     .arg(lon >= 0 ? 'E' : 'W')
  96                                     .arg(abs(lon), 3, 10, QLatin1Char('0'));
  97       int index = tilesX*(lat-latMin) + lon-lonMin;
  98       srtm[index].setFileName(filename);
  99       srtm[index].open(QIODevice::ReadWrite);
 100       if (0 != voids)
 101       {
 102         voidfs[index].setFileName(QString("%1/%2").arg(voids).arg(filename));
 103         voidfs[index].open(QIODevice::ReadOnly);
 104       }
 105       // if it doesn't exist, initialize with void
 106       if (srtm[index].atEnd())
 107       {
 108         qDebug() << "  Creating" << filename;
 109         QDataStream stream(&srtm[index]);
 110         stream.setByteOrder(QDataStream::BigEndian);
 111         uint16_t sample = 0x8000;
 112         for (int i = 0; i < 1201*1201; ++i)
 113         {
 114           stream << sample;
 115         }
 116       }
 117       else
 118       {
 119         qDebug() << "  Writing to" << filename;
 120       }
 121     }
 122   }
 123
 124   // overwrite directly with new values
 125
 126   QTextStream in(&af);
 127   // go through the rows
 128   for (int row = nrows-1; row >= 0; --row)
 129   {
 130     int y = (int)floor(0.5 + yllcorner/cellsize - latMin/cellsize + row);
 131     int latDiv = y/1200;
 132     int latMod = y%1200;
 133     for (int col = 0; col < ncols; ++col)
 134     {
 135       int x = (int)floor(0.5 + xllcorner/cellsize - lonMin/cellsize + col);
 136       int lonDiv = x/1200;
 137       int lonMod = x%1200;
 138
 139       int value;
 140       in >> value;
 141       uint16_t sample = value;
 142
 143       bool inX = (lonDiv >= 0 && lonDiv < tilesX);
 144       bool inY = (latDiv >= 0 && latDiv < tilesY);
 145       bool inXm1 = (lonDiv > 0 && lonDiv <= tilesX);
 146       bool inYm1 = (latDiv > 0 && latDiv <= tilesY);
 147 #define FILEPOS(X,Y) (((1201-(Y))*1201 + (X))*2)
 148       if (inX && inY)
 149       {
 150         int index = latDiv*tilesX + lonDiv;
 151         // if void flag is set, adjust sample
 152         if (0 != voidfs && voidfs[index].isOpen())
 153         {
 154           QDataStream stream(&voidfs[index]);
 155           stream.setByteOrder(QDataStream::BigEndian);
 156           voidfs[index].seek(FILEPOS(lonMod, latMod));
 157           uint16_t mask;
 158           stream >> mask;
 159           if (mask & 0x8000)
 160           {
 161             sample |= 0x8000;
 162           }
 163         }
 164         QDataStream stream(&srtm[index]);
 165         stream.setByteOrder(QDataStream::BigEndian);
 166         srtm[index].seek(FILEPOS(lonMod, latMod));
 167         stream << sample;
 168       }
 169       bool edgeX = (lonMod == 0);
 170       bool edgeY = (latMod == 0);
 171       if (edgeX && inXm1 && inY)
 172       {
 173         int index = latDiv*tilesX + lonDiv-1;
 174         QDataStream stream(&srtm[index]);
 175         stream.setByteOrder(QDataStream::BigEndian);
 176         srtm[index].seek(FILEPOS(1200, latMod));
 177         stream << sample;
 178       }
 179       if (edgeY && inX && inYm1)
 180       {
 181         int index = (latDiv-1)*tilesX + lonDiv;
 182         QDataStream stream(&srtm[index]);
 183         stream.setByteOrder(QDataStream::BigEndian);
 184         srtm[index].seek(FILEPOS(lonMod, 1200));
 185         stream << sample;
 186       }
 187       if (edgeX && edgeY && inXm1 && inYm1)
 188       {
 189         int index = (latDiv-1)*tilesX + lonDiv-1;
 190         QDataStream stream(&srtm[index]);
 191         stream.setByteOrder(QDataStream::BigEndian);
 192         srtm[index].seek(FILEPOS(1200, 1200));
 193         stream << sample;
 194       }
 195     }
 196   }
 197
 198   delete [] srtm;
 199   if (0 != voidfs)
 200   {
 201     delete [] voidfs;
 202   }
 203
 204   return 0;
 205 }
 206
 207 int main(int argc, char** argv)
 208 {
 209   qDebug() << "Welcome to arcToHgt";
 210   int error = 0;
 211   // Convert the file in each argument to HGT, overwriting any existing data
 212   char * voids = 0;
 213   for (int i = 1; i < argc; ++i)
 214   {
 215     if (0 == strcmp(argv[i], "--voids"))
 216     {
 217       // next argument is voids directory
 218       if (++i < argc)
 219       {
 220         voids = argv[i];
 221         qDebug() << "Using voids from " << voids;
 222       }
 223     }
 224     else
 225     {
 226       error |= arcToHgt(argv[i], voids);
 227     }
 228   }
 229   return error;
 230 }