import_export::anonymous_namespace{RasterImporter.cpp} Namespace Reference

Functions
SQLTypes	gdal_data_type_to_sql_type (const GDALDataType gdal_data_type)
GDALDataType	sql_type_to_gdal_data_type (const SQLTypes sql_type)
std::vector< std::string >	get_ome_tiff_band_names (const std::string &tifftag_imagedescription)
SQLTypes	point_type_to_sql_type (const RasterImporter::PointType point_type)
double	conv_4326_900913_x (const double x)
double	conv_4326_900913_y (const double y)
std::string	get_datasource_driver_name (OGRDataSource *source)
bool	datasource_requires_libhdf (OGRDataSource *source)

Function Documentation

double import_export::anonymous_namespace{RasterImporter.cpp}::conv_4326_900913_x

(

const double

x

)

Definition at line 249 of file RasterImporter.cpp.

                                          {
  return x * 111319.490778;
}

double import_export::anonymous_namespace{RasterImporter.cpp}::conv_4326_900913_y

(

const double

y

)

Definition at line 253 of file RasterImporter.cpp.

                                          {
  return 6378136.99911 * log(tan(.00872664626 * y + .785398163397));
}

bool import_export::anonymous_namespace{RasterImporter.cpp}::datasource_requires_libhdf

(

OGRDataSource *

source

)

Definition at line 265 of file RasterImporter.cpp.

References get_datasource_driver_name(), and setup::name.

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

                                                       {
  std::string name = get_datasource_driver_name(source);
  return name == "HDF5Image" || name == "HDF5" || name == "BAG" || name == "KEA";
}

Here is the call graph for this function:

Here is the caller graph for this function:

SQLTypes import_export::anonymous_namespace{RasterImporter.cpp}::gdal_data_type_to_sql_type

(

const GDALDataType

gdal_data_type

)

Definition at line 98 of file RasterImporter.cpp.

References kBIGINT, kDOUBLE, kFLOAT, kINT, kSMALLINT, and to_string().

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

                                                                       {
  switch (gdal_data_type) {
    case GDT_Byte:
    case GDT_Int16:
      return kSMALLINT;
    case GDT_UInt16:
    case GDT_Int32:
      return kINT;
    case GDT_UInt32:
      return kBIGINT;
    case GDT_Float32:
      return kFLOAT;
    case GDT_Float64:
      return kDOUBLE;
    case GDT_CInt16:
    case GDT_CInt32:
    case GDT_CFloat32:
    case GDT_CFloat64:
    default:
      break;
  }
  throw std::runtime_error("Unknown/unsupported GDAL data type: " +
                           std::to_string(gdal_data_type));
}

Here is the call graph for this function:

Here is the caller graph for this function:

std::string import_export::anonymous_namespace{RasterImporter.cpp}::get_datasource_driver_name

(

OGRDataSource *

source

)

Definition at line 257 of file RasterImporter.cpp.

References CHECK, and setup::name.

Referenced by datasource_requires_libhdf(), and import_export::RasterImporter::import().

                                                            {
  CHECK(source);
  auto driver = source->GetDriver();
  CHECK(driver);
  std::string name = driver->GetDescription();
  return name;
}

Here is the caller graph for this function:

std::vector<std::string> import_export::anonymous_namespace{RasterImporter.cpp}::get_ome_tiff_band_names

(

const std::string &

tifftag_imagedescription

)

Definition at line 142 of file RasterImporter.cpp.

References setup::name, and run_benchmark_import::parser.

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

                                               {
  // expected schema:
  //
  // ...
  // <Image ...>
  //   <Pixels ...>
  //     <Channel ID="Channel:0:<index>" Name="<name>" ...>
  //       ...
  //     </Channel>
  //     ...
  //   </Pixels>
  // </Image>
  // ...

  using Document = xercesc_3_2::DOMDocument;
  using Element = xercesc_3_2::DOMElement;
  using String = xercesc_3_2::XMLString;
  using Utils = xercesc_3_2::XMLPlatformUtils;
  using Parser = xercesc_3_2::XercesDOMParser;
  using Source = xercesc_3_2::MemBufInputSource;

  Utils::Initialize();

  std::unordered_map<std::string, XMLCh*> tags;

  ScopeGuard release_tags = [&] {
    for (auto& tag : tags) {
      String::release(&tag.second);
    }
  };

  tags.emplace("ID", String::transcode("ID"));
  tags.emplace("Name", String::transcode("Name"));
  tags.emplace("Buffer", String::transcode("Buffer"));
  tags.emplace("Image", String::transcode("Image"));
  tags.emplace("Pixels", String::transcode("Pixels"));
  tags.emplace("Channel", String::transcode("Channel"));

  auto get_tag = [&](const std::string& name) -> const XMLCh* {
    return tags.find(name)->second;
  };

  Parser parser;

  parser.setValidationScheme(Parser::Val_Never);
  parser.setDoNamespaces(false);
  parser.setDoSchema(false);
  parser.setLoadExternalDTD(false);

  Source source(reinterpret_cast<const XMLByte*>(tifftag_imagedescription.c_str()),
                tifftag_imagedescription.length(),
                get_tag("Buffer"));

  parser.parse(source);

  std::vector<std::string> band_names;

  auto const* document = parser.getDocument();
  if (document) {
    auto const* root_element = document->getDocumentElement();
    if (root_element) {
      auto const* image_list = root_element->getElementsByTagName(get_tag("Image"));
      if (image_list && image_list->getLength() > 0) {
        auto const* image_element = dynamic_cast<const Element*>(image_list->item(0));
        auto const* pixels_list = image_element->getElementsByTagName(get_tag("Pixels"));
        if (pixels_list && pixels_list->getLength() > 0) {
          auto const* pixels_element = dynamic_cast<const Element*>(pixels_list->item(0));
          auto const* channel_list =
              pixels_element->getElementsByTagName(get_tag("Channel"));
          for (XMLSize_t i = 0; i < channel_list->getLength(); i++) {
            auto const* channel_element =
                dynamic_cast<const Element*>(channel_list->item(i));
            auto const* name_attribute = channel_element->getAttribute(get_tag("Name"));
            if (name_attribute) {
              auto const* name = String::transcode(name_attribute);
              if (name) {
                band_names.emplace_back(name);
              }
            }
          }
        }
      }
    }
  }

  return band_names;
}

Here is the caller graph for this function:

SQLTypes import_export::anonymous_namespace{RasterImporter.cpp}::point_type_to_sql_type

(

const RasterImporter::PointType

point_type

)

Definition at line 231 of file RasterImporter.cpp.

References CHECK, import_export::RasterImporter::kDouble, kDOUBLE, import_export::RasterImporter::kFloat, kFLOAT, import_export::RasterImporter::kInt, kINT, kNULLT, import_export::RasterImporter::kPoint, kPOINT, import_export::RasterImporter::kSmallInt, and kSMALLINT.

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

                                                                          {
  switch (point_type) {
    case RasterImporter::PointType::kSmallInt:
      return kSMALLINT;
    case RasterImporter::PointType::kInt:
      return kINT;
    case RasterImporter::PointType::kFloat:
      return kFLOAT;
    case RasterImporter::PointType::kDouble:
      return kDOUBLE;
    case RasterImporter::PointType::kPoint:
      return kPOINT;
    default:
      CHECK(false);
  }
  return kNULLT;
}

Here is the caller graph for this function:

GDALDataType import_export::anonymous_namespace{RasterImporter.cpp}::sql_type_to_gdal_data_type

(

const SQLTypes

sql_type

)

Definition at line 123 of file RasterImporter.cpp.

References kBIGINT, kDOUBLE, kFLOAT, kINT, kSMALLINT, kTINYINT, and to_string().

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

                                                                 {
  switch (sql_type) {
    case kTINYINT:
    case kSMALLINT:
      return GDT_Int16;
    case kINT:
      return GDT_Int32;
    case kBIGINT:
      return GDT_UInt32;
    case kFLOAT:
      return GDT_Float32;
    case kDOUBLE:
      return GDT_Float64;
    default:
      break;
  }
  throw std::runtime_error("Unknown/unsupported SQL type: " + to_string(sql_type));
}

Here is the call graph for this function:

Here is the caller graph for this function: