gpesquero/organicmaps
1
Fork 0
forked from organicmaps/organicmaps
Code Pull requests Activity

[topography_generator] Stable tiles addressing scheme for positive and negative latitudes and longitudes of theirs left bottom corner.

Browse source
This commit is contained in:
Daria Volvenkova 2020-01-26 19:26:35 +03:00
parent 2d38cc665b
commit 1981907912
6 changed files with 98 additions and 64 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

59
generator/srtm_parser.cpp
View file

@ -13,6 +13,7 @@ namespace generator
{
namespace
{
double constexpr kTileSizeInDegree = 1.0;
size_t constexpr kArcSecondsInDegree = 60 * 60;
size_t constexpr kSrtmTileSize = (kArcSecondsInDegree + 1) * (kArcSecondsInDegree + 1) * 2;
@ -90,7 +91,11 @@ void SrtmTile::Init(std::string const & dir, ms::LatLon const & coord)
m_valid = true;
}
<<<<<<< HEAD
geometry::Altitude SrtmTile::GetHeight(ms::LatLon const & coord)
=======
feature::TAltitude SrtmTile::GetHeight(ms::LatLon const & coord) const
>>>>>>> 877249c4d0... [topography_generator] Stable tiles addressing scheme for positive and negative latitudes and longitudes of theirs left bottom corner.
{
if (!IsValid())
return geometry::kInvalidAltitude;
@ -107,9 +112,13 @@ geometry::Altitude SrtmTile::GetHeight(ms::LatLon const & coord)
auto const col = static_cast<size_t>(std::round(kArcSecondsInDegree * ln));
size_t const ix = row * (kArcSecondsInDegree + 1) + col;
<<<<<<< HEAD
if (ix >= Size())
return geometry::kInvalidAltitude;
=======
CHECK_LESS(ix, Size(), (coord));
>>>>>>> 877249c4d0... [topography_generator] Stable tiles addressing scheme for positive and negative latitudes and longitudes of theirs left bottom corner.
return ReverseByteOrder(Data()[ix]);
}
@ -120,32 +129,40 @@ std::string SrtmTile::GetPath(std::string const & dir, std::string const & base)
}
// static
std::string SrtmTile::GetBase(ms::LatLon coord)
ms::LatLon SrtmTile::GetCenter(ms::LatLon const & coord)
{
return {floor(coord.m_lat) + kTileSizeInDegree / 2.0,
floor(coord.m_lon) + kTileSizeInDegree / 2.0};
}
// static
std::string SrtmTile::GetBase(ms::LatLon const & coord)
{
auto center = GetCenter(coord);
std::ostringstream ss;
if (coord.m_lat < 0)
if (center.m_lat < 0)
{
ss << "S";
coord.m_lat *= -1;
coord.m_lat += 1;
center.m_lat *= -1;
center.m_lat += 1;
}
else
{
ss << "N";
}
ss << std::setw(2) << std::setfill('0') << static_cast<int>(coord.m_lat);
ss << std::setw(2) << std::setfill('0') << static_cast<int>(center.m_lat);
if (coord.m_lon < 0)
if (center.m_lon < 0)
{
ss << "W";
coord.m_lon *= -1;
coord.m_lon += 1;
center.m_lon *= -1;
center.m_lon += 1;
}
else
{
ss << "E";
}
ss << std::setw(3) << static_cast<int>(coord.m_lon);
ss << std::setw(3) << static_cast<int>(center.m_lon);
return ss.str();
}
@ -160,8 +177,7 @@ void SrtmTile::Invalidate()
SrtmTileManager::SrtmTileManager(std::string const & dir) : m_dir(dir) {}
geometry::Altitude SrtmTileManager::GetHeight(ms::LatLon const & coord)
{
LatLonKey const key = {static_cast<int32_t>(floor(coord.m_lat)),
static_cast<int32_t>(floor(coord.m_lon))};
auto const key = GetKey(coord);
auto it = m_tiles.find(key);
if (it == m_tiles.end())
@ -184,13 +200,20 @@ geometry::Altitude SrtmTileManager::GetHeight(ms::LatLon const & coord)
return it->second.GetHeight(coord);
}
bool SrtmTileManager::HasValidTile(ms::LatLon const & coord) const
// static
SrtmTileManager::LatLonKey SrtmTileManager::GetKey(ms::LatLon const & coord)
{
LatLonKey const key = {static_cast<int32_t>(floor(coord.m_lat)),
static_cast<int32_t>(floor(coord.m_lon))};
auto it = m_tiles.find(key);
if (it != m_tiles.end())
return it->second.IsValid();
return false;
auto const tileCenter = SrtmTile::GetCenter(coord);
return {static_cast<int32_t>(tileCenter.m_lat), static_cast<int32_t>(tileCenter.m_lon)};
}
SrtmTile const & SrtmTileManager::GetTile(ms::LatLon const & coord)
{
// Touch the tile to force its loading.
GetHeight(coord);
auto const key = GetKey(coord);
auto const it = m_tiles.find(key);
CHECK(it != m_tiles.end(), (coord));
return it->second;
}
} // namespace generator

14
generator/srtm_parser.hpp
View file

@ -24,9 +24,10 @@ public:
inline bool IsValid() const { return m_valid; }
// Returns height in meters at |coord| or kInvalidAltitude.
geometry::Altitude GetHeight(ms::LatLon const & coord);
feature::TAltitude GetHeight(ms::LatLon const & coord) const;
static std::string GetBase(ms::LatLon coord);
static std::string GetBase(ms::LatLon const & coord);
static ms::LatLon GetCenter(ms::LatLon const & coord);
static std::string GetPath(std::string const & dir, std::string const & base);
private:
@ -47,15 +48,18 @@ private:
class SrtmTileManager
{
public:
SrtmTileManager(std::string const & dir);
explicit SrtmTileManager(std::string const & dir);
feature::TAltitude GetHeight(ms::LatLon const & coord);
bool HasValidTile(ms::LatLon const & coord) const;
SrtmTile const & GetTile(ms::LatLon const & coord);
private:
using LatLonKey = std::pair<int32_t, int32_t>;
static LatLonKey GetKey(ms::LatLon const & coord);
std::string m_dir;
using LatLonKey = std::pair<int32_t, int32_t>;
struct Hash
{
size_t operator()(LatLonKey const & key) const

72
topography_generator/generator.cpp
View file

@ -18,6 +18,7 @@
namespace topography_generator
{
double const kEps = 1e-7;
double constexpr kTileSizeInDegree = 1.0;
size_t constexpr kArcSecondsInDegree = 60 * 60;
int constexpr kAsterTilesLatTop = 60;
int constexpr kAsterTilesLatBottom = -60;
@ -29,53 +30,46 @@ public:
m_srtmManager(srtmDir)
{}
void SetPrefferedTile(ms::LatLon const & pos)
{
m_preferredTile = &m_srtmManager.GetTile(pos);
m_leftBottomOfPreferredTile = {std::floor(pos.m_lat), std::floor(pos.m_lon)};
}
Altitude GetValue(ms::LatLon const & pos) override
{
auto const leftEdge = pos.m_lon - floor(pos.m_lon) < kEps;
auto const bottomEdge = pos.m_lat - floor(pos.m_lat) < kEps;
if ((leftEdge || bottomEdge) && !m_srtmManager.HasValidTile(pos))
{
// Each SRTM tile overlaps the top row in the bottom tile and the right row in the left tile.
// Try to prevent loading a new tile if the position can be found in the loaded ones.
if (leftEdge)
{
auto const shiftedPos = ms::LatLon(pos.m_lat, pos.m_lon - kEps);
if (m_srtmManager.HasValidTile(shiftedPos))
return GetSafeValue(shiftedPos);
}
if (bottomEdge)
{
auto const shiftedPos = ms::LatLon(pos.m_lat - kEps, pos.m_lon);
if (m_srtmManager.HasValidTile(shiftedPos))
return GetSafeValue(shiftedPos);
}
auto const shiftedPos = ms::LatLon(pos.m_lat - kEps, pos.m_lon - kEps);
if (m_srtmManager.HasValidTile(shiftedPos))
return GetSafeValue(shiftedPos);
}
return GetSafeValue(pos);
auto const alt = GetValueImpl(pos);
if (alt != kInvalidAltitude)
return alt;
return GetMedianValue(pos);
}
Altitude GetInvalidValue() const override { return kInvalidAltitude; }
private:
Altitude GetSafeValue(ms::LatLon const & pos)
Altitude GetValueImpl(ms::LatLon const & pos)
{
auto const alt = m_srtmManager.GetHeight(pos);
if (alt != kInvalidAltitude)
return alt;
if (m_preferredTile != nullptr)
{
// Each SRTM tile overlaps the top row in the bottom tile and the right row in the left tile.
// Try to prevent loading a new tile if the position can be found in the loaded one.
auto const latDist = pos.m_lat - m_leftBottomOfPreferredTile.m_lat;
auto const lonDist = pos.m_lon - m_leftBottomOfPreferredTile.m_lon;
if (latDist >= 0.0 && latDist <= kTileSizeInDegree &&
lonDist >= 0.0 && lonDist <= kTileSizeInDegree)
{
return m_preferredTile->GetHeight(pos);
}
}
if (m_srtmManager.HasValidTile(pos))
return GetMedianValue(pos);
return kInvalidAltitude;
return m_srtmManager.GetHeight(pos);
}
Altitude GetMedianValue(ms::LatLon const & pos)
{
// Look around the position with invalid altitude
// and return median of surrounding valid altitudes.
double const step = 1.0 / kArcSecondsInDegree;
double const step = kTileSizeInDegree / kArcSecondsInDegree;
int const kMaxKernelRadius = 3;
std::vector<Altitude> kernel;
int kernelRadius = 0;
@ -90,7 +84,7 @@ private:
{
if (abs(i) != kernelRadius && abs(j) != kernelRadius)
continue;
auto const alt = m_srtmManager.GetHeight({pos.m_lat + i * step, pos.m_lon + j * step});
auto const alt = GetValueImpl({pos.m_lat + i * step, pos.m_lon + j * step});
if (alt == kInvalidAltitude)
continue;
kernel.push_back(alt);
@ -103,6 +97,8 @@ private:
}
generator::SrtmTileManager m_srtmManager;
generator::SrtmTile const * m_preferredTile = nullptr;
ms::LatLon m_leftBottomOfPreferredTile;
};
class RawAltitudesTile : public ValuesProvider<Altitude>
@ -198,7 +194,7 @@ public:
private:
void ProcessTile(int lat, int lon)
{
auto const tileName = generator::SrtmTile::GetBase(ms::LatLon(lat, lon));
auto const tileName = GetIsolinesTileBase(lat, lon);
std::ostringstream os;
os << tileName << " (" << lat << ", " << lon << ")";
@ -212,6 +208,8 @@ private:
LOG(LINFO, ("Begin generating isolines for tile", tileName));
m_srtmProvider.SetPrefferedTile({lat + kTileSizeInDegree / 2.0, lon + kTileSizeInDegree / 2.0});
Contours<Altitude> contours;
if (!m_params.m_filters.empty() && (lat >= kAsterTilesLatTop || lat < kAsterTilesLatBottom))
{
@ -275,9 +273,9 @@ private:
void GenerateContours(int lat, int lon, ValuesProvider<Altitude> & altProvider,
Contours<Altitude> & contours)
{
ms::LatLon const leftBottom = ms::LatLon(lat, lon);
ms::LatLon const rightTop = ms::LatLon(lat + 1.0, lon + 1.0);
double const squaresStep = 1.0 / (kArcSecondsInDegree) * m_params.m_latLonStepFactor;
auto const leftBottom = ms::LatLon(lat, lon);
auto const rightTop = ms::LatLon(lat + kTileSizeInDegree, lon + kTileSizeInDegree);
auto const squaresStep = kTileSizeInDegree / kArcSecondsInDegree * m_params.m_latLonStepFactor;
MarchingSquares<Altitude> squares(leftBottom, rightTop,
squaresStep, m_params.m_alitudesStep,

10
topography_generator/isolines_utils.cpp
View file

@ -10,9 +10,15 @@ namespace topography_generator
{
std::string const kIsolinesExt = ".isolines";
std::string GetIsolinesFilePath(int lat, int lon, std::string const & dir)
std::string GetIsolinesTileBase(int bottomLat, int leftLon)
{
auto const fileName = generator::SrtmTile::GetBase(ms::LatLon(lat, lon));
auto const centerPoint = ms::LatLon(bottomLat + 0.5, leftLon + 0.5);
return generator::SrtmTile::GetBase(centerPoint);
}
std::string GetIsolinesFilePath(int bottomLat, int leftLon, std::string const & dir)
{
auto const fileName = GetIsolinesTileBase(bottomLat, leftLon);
return base::JoinPath(dir, fileName + kIsolinesExt);
}

3
topography_generator/isolines_utils.hpp
View file

@ -9,6 +9,7 @@ namespace topography_generator
using Altitude = feature::TAltitude;
Altitude constexpr kInvalidAltitude = feature::kInvalidAltitude;
std::string GetIsolinesFilePath(int lat, int lon, std::string const & dir);
std::string GetIsolinesTileBase(int bottomLat, int leftLon);
std::string GetIsolinesFilePath(int bottomLat, int leftLon, std::string const & dir);
std::string GetIsolinesFilePath(std::string const & countryId, std::string const & dir);
} // namespace topography_generator

4
topography_generator/marching_squares/square.hpp
View file

@ -71,7 +71,9 @@ private:
// If a contour goes right through the corner of the square false segments can be generated.
// Shift the value slightly from the corner.
ValueType val = valuesProvider.GetValue(pos);
if (val != valuesProvider.GetInvalidValue() && (val % m_valueStep == 0))
CHECK(val != valuesProvider.GetInvalidValue(), (m_debugId, pos));
if (val % m_valueStep == 0)
return val + 1;
return val;
}