web-dev-qa-db-fra.com

Création d'une carte de terrain avec un fichier SRTM HGT

Je travaille sur une application iOS. Où je montre la carte d'élévation et de topographie d'un certain secteur. J'ai réussi à télécharger le fichier .hgt dans l'application à partir de ici .

Jusqu'à présent, je suis en mesure d'extraire l'altitude du fichier hgt. Maintenant, je dois aussi montrer la carte de terrain pour cette zone. J'ai cherché à ce sujet et je pense que je ne peux pas créer de carte de terrain directement avec un fichier hgt dans une application iOS. Je dois utiliser GRASS GIS, SRTM2OSM ou TileMill pour créer une carte de terrain, puis l’utiliser en application.

S'il vous plaît, n'importe qui peut m'indiquer ce que je peux faire ici et comment procéder.

MODIFIER:

J'ai demandé à ne pas utiliser n'importe quel type de carte pour cela. Donc, fondamentalement, je dois créer la carte en utilisant un dessin principal, et je n’en ai aucune idée.

Quelque chose comme ça sans le texte:

 enter image description here

iosswiftterrainsrtmhgt
22
superGokuN

Avec iOS, vous avez accès à Maps via MapKit framework pour afficher des images cartographiques ou satellite directement depuis l'interface de votre application. Vous pouvez également utiliser Google Maps via Google Maps SDK pour iOS mais les deux (iOS Maps et Google Maps). ) n'ont pas de niveau de terrain.

Donc, pour éviter de recréer quelque chose qui existe déjà, vous pouvez jeter un oeil aux frameworks OpenStreetMaps , ici vous pouvez trouver de nombreux frameworks disponibles, l'un d'eux s'appelle MapBox et vous pouvez télécharger les dernières sources. et exemple ici

Comme vous pouvez le lire sur les pages wiki, nous avons également le niveau de terrain:  enter image description here

Je pense que c'est une bibliothèque vraiment utile, mise à jour et fonctionnant avec Swift 4, ici vous pouvez trouver un tutoriel simple pour commencer:

import Mapbox
class ViewController: UIViewController {
    override func viewDidLoad() {
        super.viewDidLoad()
        let mapView = MGLMapView(frame: view.bounds)
        mapView.autoresizingMask = [.flexibleWidth, .flexibleHeight]
        mapView.setCenter(CLLocationCoordinate2D(latitude: 40.74699, longitude: -73.98742), zoomLevel: 9, animated: false)
        view.addSubview(mapView)
        // to show the terrain level 
        mapView.styleURL = MGLStyle.outdoorsStyleURL()
    }
}
13
Alessandro Ornano

Je dois créer la carte en utilisant le dessin de base

  • Vous pouvez dessiner un objet Map à partir du fichier SRTM HGT [1]

  • Pour lire la hauteur interpolée à partir de fichiers SRTM HGT [2]

  • Ci-dessous est le code travaillant avec le fichier .cpp vous pouvez avoir une idée sur la façon de le tirer à partir de SRTM [3]

#include "generator/srtm_parser.hpp"

#include "coding/endianness.hpp"
#include "coding/Zip_reader.hpp"

#include "base/logging.hpp"

#include <iomanip>
#include <sstream>

namespace generator
{
namespace
{
size_t constexpr kArcSecondsInDegree = 60 * 60;
size_t constexpr kSrtmTileSize = (kArcSecondsInDegree + 1) * (kArcSecondsInDegree + 1) * 2;

struct UnzipMemDelegate : public ZipFileReader::Delegate
{
  UnzipMemDelegate(std::string & buffer) : m_buffer(buffer), m_completed(false) {}

  // ZipFileReader::Delegate overrides:
  void OnBlockUnzipped(size_t size, char const * data) override { m_buffer.append(data, size); }

  void OnStarted() override
  {
    m_buffer.clear();
    m_completed = false;
  }

  void OnCompleted() override { m_completed = true; }

  std::string & m_buffer;
  bool m_completed;
};
}  // namespace

// SrtmTile ----------------------------------------------------------------------------------------
SrtmTile::SrtmTile()
{
  Invalidate();
}

SrtmTile::SrtmTile(SrtmTile && rhs) : m_data(move(rhs.m_data)), m_valid(rhs.m_valid)
{
  rhs.Invalidate();
}

void SrtmTile::Init(std::string const & dir, ms::LatLon const & coord)
{
  Invalidate();

  std::string const base = GetBase(coord);
  std::string const cont = dir + base + ".SRTMGL1.hgt.Zip";
  std::string file = base + ".hgt";

  UnzipMemDelegate delegate(m_data);
  try
  {
    ZipFileReader::UnzipFile(cont, file, delegate);
  }
  catch (ZipFileReader::LocateZipException const & e)
  {
    // Sometimes packed file has different name. See N39E051 measure.
    file = base + ".SRTMGL1.hgt";

    ZipFileReader::UnzipFile(cont, file, delegate);
  }

  if (!delegate.m_completed)
  {
    LOG(LWARNING, ("Can't decompress SRTM file:", cont));
    Invalidate();
    return;
  }

  if (m_data.size() != kSrtmTileSize)
  {
    LOG(LWARNING, ("Bad decompressed SRTM file size:", cont, m_data.size()));
    Invalidate();
    return;
  }

  m_valid = true;
}

feature::TAltitude SrtmTile::GetHeight(ms::LatLon const & coord)
{
  if (!IsValid())
    return feature::kInvalidAltitude;

  double ln = coord.lon - static_cast<int>(coord.lon);
  if (ln < 0)
    ln += 1;
  double lt = coord.lat - static_cast<int>(coord.lat);
  if (lt < 0)
    lt += 1;
  lt = 1 - lt;  // from North to South

  size_t const row = kArcSecondsInDegree * lt;
  size_t const col = kArcSecondsInDegree * ln;

  size_t const ix = row * (kArcSecondsInDegree + 1) + col;

  if (ix >= Size())
    return feature::kInvalidAltitude;
  return ReverseByteOrder(Data()[ix]);
}

std::string SrtmTile::GetBase(ms::LatLon coord)
{
  std::ostringstream ss;
  if (coord.lat < 0)
  {
    ss << "S";
    coord.lat *= -1;
    coord.lat += 1;
  }
  else
  {
    ss << "N";
  }
  ss << std::setw(2) << std::setfill('0') << static_cast<int>(coord.lat);

  if (coord.lon < 0)
  {
    ss << "W";
    coord.lon *= -1;
    coord.lon += 1;
  }
  else
  {
    ss << "E";
  }
  ss << std::setw(3) << static_cast<int>(coord.lon);
  return ss.str();
}

void SrtmTile::Invalidate()
{
  m_data.clear();
  m_data.shrink_to_fit();
  m_valid = false;
}

// SrtmTileManager ---------------------------------------------------------------------------------
SrtmTileManager::SrtmTileManager(std::string const & dir) : m_dir(dir) {}
feature::TAltitude SrtmTileManager::GetHeight(ms::LatLon const & coord)
{
  std::string const base = SrtmTile::GetBase(coord);
  auto it = m_tiles.find(base);
  if (it == m_tiles.end())
  {
    SrtmTile tile;
    try
    {
      tile.Init(m_dir, coord);
    }
    catch (RootException const & e)
    {
      LOG(LINFO, ("Can't init SRTM tile:", base, "reason:", e.Msg()));
    }

    // It's OK to store even invalid tiles and return invalid height
    // for them later.
    it = m_tiles.emplace(base, std::move(tile)).first;
  }

  return it->second.GetHeight(coord);
}
}  // namespace generator
0
user5377037