Geospatial::GDAL Class Reference

#include <GDAL.h>

Classes
struct	CoordinateTransformationDeleter
struct	DataSourceDeleter
struct	FeatureDeleter
struct	SpatialReferenceDeleter

Public Types
using	DataSourceUqPtr = std::unique_ptr< OGRDataSource, DataSourceDeleter >
using	FeatureUqPtr = std::unique_ptr< OGRFeature, FeatureDeleter >
using	SpatialReferenceUqPtr = std::unique_ptr< OGRSpatialReference, SpatialReferenceDeleter >
using	CoordinateTransformationUqPtr = std::unique_ptr< OGRCoordinateTransformation, CoordinateTransformationDeleter >

Static Public Member Functions
static void	init ()
static bool	supportsNetworkFileAccess ()
static bool	supportsDriver (const std::string &driver_name)
static void	setAuthorizationTokens (const std::string &s3_region, const std::string &s3_endpoint, const std::string &s3_access_key, const std::string &s3_secret_key, const std::string &s3_session_token)
static DataSourceUqPtr	openDataSource (const std::string &name, const import_export::SourceType source_type)
static import_export::SourceType	getDataSourceType (const std::string &name)
static std::vector< std::string >	unpackMetadata (char **metadata)
static void	logMetadata (GDALMajorObject *object)
static std::string	getMetadataString (char **metadata, const std::string &key)

Static Private Attributes
static bool	initialized_ = false
static std::mutex	init_mutex_

Detailed Description

Definition at line 34 of file GDAL.h.

Member Typedef Documentation

using Geospatial::GDAL::CoordinateTransformationUqPtr = std::unique_ptr<OGRCoordinateTransformation, CoordinateTransformationDeleter>

Definition at line 65 of file GDAL.h.

using Geospatial::GDAL::DataSourceUqPtr = std::unique_ptr<OGRDataSource, DataSourceDeleter>

Definition at line 48 of file GDAL.h.

using Geospatial::GDAL::FeatureUqPtr = std::unique_ptr<OGRFeature, FeatureDeleter>

Definition at line 53 of file GDAL.h.

using Geospatial::GDAL::SpatialReferenceUqPtr = std::unique_ptr<OGRSpatialReference, SpatialReferenceDeleter>

Definition at line 59 of file GDAL.h.

Member Function Documentation

import_export::SourceType Geospatial::GDAL::getDataSourceType ( const std::string &  name )

static

Definition at line 211 of file GDAL.cpp.

References getMetadataString(), init(), import_export::kGeoFile, import_export::kRasterFile, import_export::kUnknown, import_export::kUnsupported, and openDataSource().

                                                                     {
  // lazy init
  init();

  // attempt to open datasource as either vector or raster
  DataSourceUqPtr datasource(openDataSource(name, import_export::SourceType::kUnknown));

  import_export::SourceType source_type{import_export::SourceType::kUnsupported};

  // couldn't open it at all
  if (!datasource) {
    return source_type;
  }

  // get the driver
  auto* driver = datasource->GetDriver();
  if (!driver) {
    return source_type;
  }

  // get capabilities
  auto const is_vector = getMetadataString(driver->GetMetadata(), "DCAP_VECTOR") == "YES";
  auto const is_raster = getMetadataString(driver->GetMetadata(), "DCAP_RASTER") == "YES";

  // analyze
  if (is_vector && !is_raster) {
    source_type = import_export::SourceType::kGeoFile;
  } else if (is_raster && !is_vector) {
    source_type = import_export::SourceType::kRasterFile;
  }

  // done
  return source_type;
}

Here is the call graph for this function:

std::string Geospatial::GDAL::getMetadataString ( char **  metadata, const std::string &  key  )

static

Definition at line 276 of file GDAL.cpp.

References CHECK, initialized_, and unpackMetadata().

Referenced by getDataSourceType(), and import_export::RasterImporter::getRawBandNamesForFormat().

                                                                       {
  CHECK(initialized_) << "GDAL not initialized!";
  auto const key_len = key.length();
  auto const strings = unpackMetadata(metadata);
  for (auto const& str : strings) {
    if (str.substr(0, key_len) == key) {
      return str.substr(key_len + 1, std::string::npos);
    }
  }
  return std::string();
}

Here is the call graph for this function:

Here is the caller graph for this function:

void Geospatial::GDAL::init ( )

static

Definition at line 67 of file GDAL.cpp.

References Geospatial::anonymous_namespace{GDAL.cpp}::gdal_error_handler(), heavyai::get_root_abs_path(), logger::INFO, init_mutex_, initialized_, and LOG.

Referenced by import_export::QueryExporterGDAL::beginExport(), import_export::Importer::gdalGetAllFilesInArchive(), import_export::Importer::gdalGetLayersInGeoFile(), import_export::Importer::gdalStatInternal(), import_export::Importer::gdalToColumnDescriptorsRaster(), getDataSourceType(), Geospatial::GeoBase::getTransformation(), openDataSource(), import_export::Importer::openGDALDataSource(), setAuthorizationTokens(), supportsDriver(), and GDALTableFunctions::tf_raster_contour_impl().

                {
  // this should not be called from multiple threads, but...
  std::lock_guard<std::mutex> guard(init_mutex_);

  // init under mutex
  if (!initialized_) {
    // FIXME(andrewseidl): investigate if CPLPushFinderLocation can be public
#ifdef _WIN32
    _putenv_s(
        "GDAL_DATA",
        std::string(heavyai::get_root_abs_path() + "/ThirdParty/gdal-data").c_str());
    _putenv_s(
        "PROJ_LIB",
        std::string(heavyai::get_root_abs_path() + "/ThirdParty/gdal-data/proj").c_str());
#else
    setenv("GDAL_DATA",
           std::string(heavyai::get_root_abs_path() + "/ThirdParty/gdal-data").c_str(),
           true);
    setenv(
        "PROJ_LIB",
        std::string(heavyai::get_root_abs_path() + "/ThirdParty/gdal-data/proj").c_str(),
        true);
#endif

#ifndef _MSC_VER  // TODO
    // configure SSL certificate path (per S3Archive::init_for_read)
    // in a production build, GDAL and Curl will have been built on
    // CentOS, so the baked-in system path will be wrong for Ubuntu
    // and other Linux distros. Unless the user is deliberately
    // overriding it by setting SSL_CERT_FILE explicitly in the server
    // environment, we set it to whichever CA bundle directory exists
    // on the machine we're running on
    static constexpr std::array<const char*, 6> known_ca_paths{
        "/etc/ssl/certs/ca-certificates.crt",
        "/etc/pki/tls/certs/ca-bundle.crt",
        "/usr/share/ssl/certs/ca-bundle.crt",
        "/usr/local/share/certs/ca-root.crt",
        "/etc/ssl/cert.pem",
        "/etc/ssl/ca-bundle.pem"};
    for (const auto& known_ca_path : known_ca_paths) {
      if (boost::filesystem::exists(known_ca_path)) {
        LOG(INFO) << "GDAL SSL Certificate path: " << known_ca_path;
        setenv("SSL_CERT_FILE", known_ca_path, false);  // no overwrite
        break;
      }
    }
#endif

    GDALAllRegister();
    OGRRegisterAll();
    CPLSetErrorHandler(*gdal_error_handler);
    LOG(INFO) << "GDAL Initialized: " << GDALVersionInfo("--version");
    initialized_ = true;
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void Geospatial::GDAL::logMetadata ( GDALMajorObject *  object )

static

Definition at line 257 of file GDAL.cpp.

References CHECK, anonymous_namespace{AbstractMLModel.h}::default_metadata(), logger::INFO, initialized_, LOG, and unpackMetadata().

Referenced by import_export::RasterImporter::detect().

                                              {
  CHECK(initialized_) << "GDAL not initialized!";
  CHECK(object);
  LOG(INFO) << "DEBUG: Metadata domains for object '" << object->GetDescription() << "'";
  LOG(INFO) << "DEBUG:   (default)";
  auto const default_metadata = unpackMetadata(object->GetMetadata());
  for (auto const& str : default_metadata) {
    LOG(INFO) << "DEBUG:     " << str;
  }
  auto const metadata_domains = unpackMetadata(object->GetMetadataDomainList());
  for (auto const& domain : metadata_domains) {
    LOG(INFO) << "DEBUG:   " << domain;
    auto const metadata = unpackMetadata(object->GetMetadata(domain.c_str()));
    for (auto const& str : metadata) {
      LOG(INFO) << "DEBUG:     " << str;
    }
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

GDAL::DataSourceUqPtr Geospatial::GDAL::openDataSource ( const std::string &  name, const import_export::SourceType  source_type  )

static

Definition at line 181 of file GDAL.cpp.

References CHECK, init(), import_export::kGeoFile, import_export::kRasterFile, and import_export::kUnknown.

Referenced by import_export::RasterImporter::detect(), getDataSourceType(), import_export::RasterImporter::import(), and import_export::Importer::openGDALDataSource().

                                                                                      {
  // lazy init
  init();

  // how should we try to open it?
  unsigned int open_flags{0u};
  switch (source_type) {
    case import_export::SourceType::kUnknown:
      open_flags = GDAL_OF_VECTOR | GDAL_OF_RASTER;
      break;
    case import_export::SourceType::kGeoFile:
      open_flags = GDAL_OF_VECTOR;
      break;
    case import_export::SourceType::kRasterFile:
      open_flags = GDAL_OF_RASTER;
      break;
    default:
      CHECK(false) << "Invalid datasource source type";
  }

  // attempt to open datasource
  // error will simply log and return null to be trapped later
  auto* datasource = static_cast<OGRDataSource*>(
      GDALOpenEx(name.c_str(), open_flags | GDAL_OF_READONLY, nullptr, nullptr, nullptr));

  // done
  return DataSourceUqPtr(datasource);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void Geospatial::GDAL::setAuthorizationTokens ( const std::string &  s3_region, const std::string &  s3_endpoint, const std::string &  s3_access_key, const std::string &  s3_secret_key, const std::string &  s3_session_token  )

static

Definition at line 138 of file GDAL.cpp.

References init().

Referenced by import_export::Importer::gdalGetAllFilesInArchive(), import_export::Importer::gdalGetLayersInGeoFile(), import_export::Importer::gdalStatInternal(), import_export::Importer::gdalToColumnDescriptorsRaster(), and import_export::Importer::openGDALDataSource().

                                                                     {
  // lazy init
  init();

  // set tokens
  if (s3_region.size()) {
    CPLSetConfigOption("AWS_REGION", s3_region.c_str());
  } else {
    CPLSetConfigOption("AWS_REGION", nullptr);
  }
  if (s3_endpoint.size()) {
    CPLSetConfigOption("AWS_S3_ENDPOINT", s3_endpoint.c_str());
  } else {
    CPLSetConfigOption("AWS_S3_ENDPOINT", nullptr);
  }
  if (s3_access_key.size()) {
    CPLSetConfigOption("AWS_ACCESS_KEY_ID", s3_access_key.c_str());
  } else {
    CPLSetConfigOption("AWS_ACCESS_KEY_ID", nullptr);
  }
  if (s3_secret_key.size()) {
    CPLSetConfigOption("AWS_SECRET_ACCESS_KEY", s3_secret_key.c_str());
  } else {
    CPLSetConfigOption("AWS_SECRET_ACCESS_KEY", nullptr);
  }
  if (s3_session_token.size()) {
    CPLSetConfigOption("AWS_SESSION_TOKEN", s3_session_token.c_str());
  } else {
    CPLSetConfigOption("AWS_SESSION_TOKEN", nullptr);
  }

  // if we haven't set keys, we need to disable signed access
  if (s3_access_key.size() || s3_secret_key.size()) {
    CPLSetConfigOption("AWS_NO_SIGN_REQUEST", nullptr);
  } else {
    CPLSetConfigOption("AWS_NO_SIGN_REQUEST", "YES");
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool Geospatial::GDAL::supportsDriver ( const std::string &  driver_name )

static

Definition at line 131 of file GDAL.cpp.

References init().

                                                      {
  // lazy init
  init();

  return GetGDALDriverManager()->GetDriverByName(driver_name.c_str()) != nullptr;
}

Here is the call graph for this function:

bool Geospatial::GDAL::supportsNetworkFileAccess ( )

static

Definition at line 123 of file GDAL.cpp.

Referenced by anonymous_namespace{DBHandler.cpp}::add_vsi_network_prefix().

                                     {
#if (GDAL_VERSION_MAJOR > 2) || (GDAL_VERSION_MAJOR == 2 && GDAL_VERSION_MINOR >= 2)
  return true;
#else
  return false;
#endif
}

Here is the caller graph for this function:

std::vector< std::string > Geospatial::GDAL::unpackMetadata ( char **  metadata )

static

Definition at line 246 of file GDAL.cpp.

Referenced by import_export::RasterImporter::detect(), getMetadataString(), and logMetadata().

                                                         {
  std::vector<std::string> strings;
  if (metadata) {
    while (*metadata) {
      strings.emplace_back(*metadata);
      metadata++;
    }
  }
  return strings;
}

Here is the caller graph for this function:

Member Data Documentation

std::mutex Geospatial::GDAL::init_mutex_

staticprivate

Definition at line 77 of file GDAL.h.

Referenced by init().

bool Geospatial::GDAL::initialized_ = false

staticprivate

Definition at line 76 of file GDAL.h.

Referenced by getMetadataString(), init(), and logMetadata().

---

The documentation for this class was generated from the following files:

• /home/jenkins-slave/workspace/core-os-doxygen/Geospatial/GDAL.h
• /home/jenkins-slave/workspace/core-os-doxygen/Geospatial/GDAL.cpp