//------------------------------------------------------------------------------ // Locates an elevation value (meters) for a given reference point and returns // it in 'elev'. Function returns true if successful, otherwise 'elev' is unchanged. //------------------------------------------------------------------------------ bool QuadMap::getElevation( LCreal* const elev, // The elevation value (meters) const double lat, // Reference latitude (degs) const double lon, // Reference longitude (degs) const bool interp // Interpolate between elevation posts (if true) ) const { // Early out tests if ( !isDataLoaded() || // Not loaded or (lat < getLatitudeSW() || lat > getLatitudeNE()) || // wrong latitude or (lon < getLongitudeSW() || lon > getLongitudeNE()) // wrong longitude ) return false; LCreal value = 0.0; // the elevation (meters) bool found = false; for (unsigned int i = 0; i < numDataFiles && !found; i++) { found = dataFiles[i]->getElevation(&value, lat, lon, interp); } if (found) { *elev = value; } return found; }
//------------------------------------------------------------------------------ // reset() -- Reset the simulation & players //------------------------------------------------------------------------------ void Terrain::reset() { if ( !isDataLoaded() ) { loadData(); } BaseClass::reset(); }
const short* DataFile::getColumn(const unsigned int idx) const { const short* p = 0; if (isDataLoaded() && idx < getNumLonPoints()) { p = columns[idx]; } return p; }
// Number of longitude points (# of columns), or zero if the data isn't loaded unsigned int DataFile::getNumLonPoints() const { unsigned int v = 0; if (isDataLoaded()) { v = nptlong; } return v; }
// Spacing between longitude points (degs), or zero if the data isn't loaded double DataFile::getLonSpacing() const { double v = 0; if (isDataLoaded()) { v = lonSpacing; } return v; }
//------------------------------------------------------------------------------ // Computes the longitude (degs) for a given column index. // Returns true if the longitude is valid //------------------------------------------------------------------------------ bool DataFile::computeLongitude(double* const lon, const unsigned int icol) const { // Early out tests if ( (icol >= nptlong) || // the index isn't within range, or (lon == 0) || // the longitude pointer wasn't provided, or !isDataLoaded() // the data isn't loaded ) return false; *lon = getLongitudeSW() + static_cast<double>(icol) * lonSpacing; return true; }
//------------------------------------------------------------------------------ // Computes the latitude (degs) for a given row index. // Returns true if the latitude is valid //------------------------------------------------------------------------------ bool DataFile::computeLatitude(double* const lat, const unsigned int irow) const { // Early out tests if ( (irow >= nptlat) || // the index isn't within range, or (lat == 0) || // the latitude pointer wasn't provided, or !isDataLoaded() // the data isn't loaded ) return false; *lat = getLatitudeSW() + static_cast<double>(irow) * latSpacing; return true; }
void TLDExtractor::loadData() { if (isDataLoaded()) { return; } QString dataFileName; bool parsedDataFileExist = false; foreach(const QString &path, m_dataSearchPaths) { dataFileName = QFileInfo(path + QLatin1String("/effective_tld_names.dat")).absoluteFilePath(); if (QFileInfo(dataFileName).exists()) { parsedDataFileExist = true; break; } }
//------------------------------------------------------------------------------ // Computes the nearest column index for the longitude (degs) // Returns true if the index is valid //------------------------------------------------------------------------------ bool DataFile::computeColumnIndex(unsigned int* const icol, const double lon) const { // Early out tests if ( (lon < getLongitudeSW() || lon > getLongitudeNE()) || // the longitude's out of range, or (icol == 0) || // the 'icol' pointer wasn't provided, or !isDataLoaded() // the data isn't loaded ) return false; // Locate column (longitude) index double points = (lon - getLongitudeSW()) / lonSpacing; if (points < 0) points = 0; unsigned int idx = static_cast<unsigned int>(points + 0.5); if (idx >= nptlong) idx = (nptlong-1); *icol = idx; return true; }
//------------------------------------------------------------------------------ // Computes the nearest row index for the latitude (degs). // Returns true if the index is valid //------------------------------------------------------------------------------ bool DataFile::computerRowIndex(unsigned int* const irow, const double lat) const { // Early out tests if ( (lat < getLatitudeSW() || lat > getLatitudeNE()) || // the latitude's out of range, or (irow == 0) || // the 'irow' pointer wasn't provided, or !isDataLoaded() // the data isn't loaded ) return false; // Locate row (latitude) index double points = (lat - getLatitudeSW()) / latSpacing; if (points < 0) points = 0; unsigned int idx = static_cast<unsigned int>(points + 0.5); if (idx >= nptlat) idx = (nptlat-1); *irow = idx; return true; }
//------------------------------------------------------------------------------ // Locates an elevation value (meters) for a given reference point and returns // it in 'elev'. Function returns true if successful, otherwise 'elev' is unchanged. //------------------------------------------------------------------------------ bool DataFile::getElevation( LCreal* const elev, // The elevation value (meters) const double lat, // Reference latitude (degs) const double lon, // Reference longitude (degs) const bool interp // Interpolate between elevation posts (if true) ) const { LCreal value = 0; // the elevation (meters) // Early out tests if ( !isDataLoaded() || // Not loaded or (lat < getLatitudeSW() || lat > getLatitudeNE()) || // wrong latitude or (lon < getLongitudeSW() || lon > getLongitudeNE()) // wrong longitude ) return false; // --- // Compute the lat and lon points // --- double pointsLat = (lat - getLatitudeSW()) / latSpacing; if (pointsLat < 0) pointsLat = 0; double pointsLon = (lon - getLongitudeSW()) / lonSpacing; if (pointsLon < 0) pointsLon = 0; // --- // Interpolating between elevation posts? // --- if (interp) { // Yes --- // South-west corner post is [icol][irow] unsigned int irow = static_cast<unsigned int>(pointsLat); unsigned int icol = static_cast<unsigned int>(pointsLon); if (irow > (nptlat-2)) irow = (nptlat-2); if (icol > (nptlong-2)) icol = (nptlong-2); // delta from s-w corner post LCreal deltaLat = static_cast<LCreal>(pointsLat - static_cast<double>(irow)); LCreal deltaLon = static_cast<LCreal>(pointsLon - static_cast<double>(icol)); // Get the elevations at each corner LCreal elevSW = static_cast<LCreal>(columns[icol][irow]); LCreal elevNW = static_cast<LCreal>(columns[icol][irow+1]); LCreal elevSE = static_cast<LCreal>(columns[icol+1][irow]); LCreal elevNE = static_cast<LCreal>(columns[icol+1][irow+1]); // Interpolate the west point LCreal westPoint = elevSW + (elevNW - elevSW) * deltaLat; // Interpolate the east point LCreal eastPoint = elevSE + (elevNE - elevSE) * deltaLat; // Interpolate between the west and east points value = westPoint + (eastPoint - westPoint) * deltaLon; } else { // No -- just use the nearest post // Nearest post unsigned int irow = static_cast<unsigned int>(pointsLat + 0.5f); unsigned int icol = static_cast<unsigned int>(pointsLon + 0.5f); if (irow >= nptlat) irow = (nptlat-1); if (icol >= nptlong) icol = (nptlong-1); // Get the elevation post at the current indices. value = static_cast<LCreal>(columns[icol][irow]); } // --- // Return the elevation value to the user // --- *elev = value; return true; }