void CoordinateConversionController::setGeoView(QObject* geoView)
{
if (!geoView)
return;
if (std::strcmp(geoView->metaObject()->className(), MapQuickView::staticMetaObject.className()) == 0)
{
m_mapView = reinterpret_cast<MapQuickView*>(geoView);
m_sceneView = nullptr;
if (m_mapView)
{
setSpatialReference(m_mapView->spatialReference());
connect(m_mapView, &MapQuickView::mouseClicked, this, &CoordinateConversionController::onMouseClicked);
}
}
else if (std::strcmp(geoView->metaObject()->className(), SceneQuickView::staticMetaObject.className()) == 0)
{
m_sceneView = reinterpret_cast<SceneQuickView*>(geoView);
m_mapView = nullptr;
if (m_sceneView)
{
setSpatialReference(m_sceneView->spatialReference());
connect(m_sceneView, &SceneQuickView::mouseClicked, this, &CoordinateConversionController::onMouseClicked);
}
}
}
void Reader::initialize()
{
pdal::Reader::initialize();
std::string const& query = getOptions().getValueOrThrow<std::string>("query");
std::string const& connection = getOptions().getValueOrThrow<std::string>("connection");
m_session->set_log_stream(&(log()->get(logDEBUG2)));
m_schema = fetchSchema(query);
try
{
setSpatialReference(getOptions().getValueOrThrow<pdal::SpatialReference>("spatialreference"));
}
catch (pdal::option_not_found const&)
{
// If one wasn't set on the options, we'll ignore at this
setSpatialReference(fetchSpatialReference(query));
}
}
void Reprojection::initialize()
{
Filter::initialize();
checkImpedance();
if (m_inferInputSRS)
{
m_inSRS = getPrevStage().getSpatialReference();
}
#ifdef PDAL_HAVE_GDAL
m_gdal_debug = boost::shared_ptr<pdal::gdal::Debug>( new pdal::gdal::Debug(isDebug(), log()));
m_in_ref_ptr = ReferencePtr(OSRNewSpatialReference(0), OGRSpatialReferenceDeleter());
m_out_ref_ptr = ReferencePtr(OSRNewSpatialReference(0), OGRSpatialReferenceDeleter());
int result = OSRSetFromUserInput(m_in_ref_ptr.get(), m_inSRS.getWKT(pdal::SpatialReference::eCompoundOK).c_str());
if (result != OGRERR_NONE)
{
std::ostringstream msg;
msg << "Could not import input spatial reference for ReprojectionFilter:: "
<< CPLGetLastErrorMsg() << " code: " << result
<< " wkt: '" << m_inSRS.getWKT() << "'";
throw std::runtime_error(msg.str());
}
result = OSRSetFromUserInput(m_out_ref_ptr.get(), m_outSRS.getWKT(pdal::SpatialReference::eCompoundOK).c_str());
if (result != OGRERR_NONE)
{
std::ostringstream msg;
msg << "Could not import output spatial reference for ReprojectionFilter:: "
<< CPLGetLastErrorMsg() << " code: " << result
<< " wkt: '" << m_outSRS.getWKT() << "'";
std::string message(msg.str());
throw std::runtime_error(message);
}
m_transform_ptr = TransformPtr(OCTNewCoordinateTransformation( m_in_ref_ptr.get(), m_out_ref_ptr.get()), OSRTransformDeleter());
if (!m_transform_ptr.get())
{
std::ostringstream msg;
msg << "Could not construct CoordinateTransformation in ReprojectionFilter:: ";
std::string message(msg.str());
throw std::runtime_error(message);
}
#endif
setSpatialReference(m_outSRS);
updateBounds();
return;
}
void InPlaceReprojection::initialize()
{
Filter::initialize();
if (m_inferInputSRS)
{
m_inSRS = getPrevStage().getSpatialReference();
}
#ifdef PDAL_HAVE_GDAL
pdal::GlobalEnvironment::get().getGDALDebug()->addLog(log());
m_in_ref_ptr = ReferencePtr(OSRNewSpatialReference(0), OGRSpatialReferenceDeleter());
m_out_ref_ptr = ReferencePtr(OSRNewSpatialReference(0), OGRSpatialReferenceDeleter());
int result = OSRSetFromUserInput(m_in_ref_ptr.get(), m_inSRS.getWKT(pdal::SpatialReference::eCompoundOK).c_str());
if (result != OGRERR_NONE)
{
std::ostringstream msg;
msg << "Could not import input spatial reference for InPlaceReprojection:: "
<< CPLGetLastErrorMsg() << " code: " << result
<< " wkt: '" << m_inSRS.getWKT() << "'";
throw std::runtime_error(msg.str());
}
result = OSRSetFromUserInput(m_out_ref_ptr.get(), m_outSRS.getWKT(pdal::SpatialReference::eCompoundOK).c_str());
if (result != OGRERR_NONE)
{
std::ostringstream msg;
msg << "Could not import output spatial reference for InPlaceReprojection:: "
<< CPLGetLastErrorMsg() << " code: " << result
<< " wkt: '" << m_outSRS.getWKT() << "'";
std::string message(msg.str());
throw std::runtime_error(message);
}
m_transform_ptr = TransformPtr(OCTNewCoordinateTransformation(m_in_ref_ptr.get(), m_out_ref_ptr.get()), OSRTransformDeleter());
if (!m_transform_ptr.get())
{
std::ostringstream msg;
msg << "Could not construct CoordinateTransformation in InPlaceReprojection:: ";
std::string message(msg.str());
throw std::runtime_error(message);
}
#endif
setSpatialReference(m_outSRS);
Schema& s = getSchemaRef();
s = alterSchema(s);
return;
}
void GDALReader::initialize()
{
gdal::registerDrivers();
m_raster.reset(new gdal::Raster(m_filename));
m_raster->open();
setSpatialReference(m_raster->getSpatialRef());
m_count = m_raster->m_raster_x_size * m_raster->m_raster_y_size;
m_raster->close();
}
void GDALReader::initialize()
{
GlobalEnvironment::get().wakeGDALDrivers();
m_raster.reset(new gdal::Raster(m_filename));
m_raster->open();
setSpatialReference(m_raster->getSpatialRef());
m_count = m_raster->m_raster_x_size * m_raster->m_raster_y_size;
m_raster->close();
}
bool CoordinateConversionController::setGeoViewInternal(GeoView* geoView)
{
if (geoView == nullptr)
return false;
setSpatialReference(geoView->spatialReference());
m_sceneView = dynamic_cast<SceneQuickView*>(geoView);
m_mapView = dynamic_cast<MapQuickView*>(geoView);
return m_sceneView != nullptr || m_mapView != nullptr;
}
void PgReader::ready(PointTableRef /*table*/)
{
m_atEnd = false;
m_cur_row = 0;
m_cur_nrows = 0;
m_cur_result = NULL;
if (getSpatialReference().empty())
setSpatialReference(fetchSpatialReference());
CursorSetup();
}
void ReprojectionFilter::ready(PointTableRef table)
{
if (m_inferInputSRS)
{
m_inSRS = table.spatialRef();
if (m_inSRS.getWKT().empty())
throw pdal_error("Source data has no spatial reference and none "
"is specified with the 'in_srs' option.");
}
m_in_ref_ptr = ReferencePtr(OSRNewSpatialReference(0),
OGRSpatialReferenceDeleter());
m_out_ref_ptr = ReferencePtr(OSRNewSpatialReference(0),
OGRSpatialReferenceDeleter());
int result =
OSRSetFromUserInput(m_in_ref_ptr.get(),
m_inSRS.getWKT(pdal::SpatialReference::eCompoundOK).c_str());
if (result != OGRERR_NONE)
{
std::ostringstream msg;
msg << "Invalid input spatial reference '" << m_inSRS.getWKT() <<
"'. This is usually caused by a bad value for the 'in_srs'"
"option or an invalid spatial reference in the source file.";
throw pdal_error(msg.str());
}
result = OSRSetFromUserInput(m_out_ref_ptr.get(),
m_outSRS.getWKT(pdal::SpatialReference::eCompoundOK).c_str());
if (result != OGRERR_NONE)
{
std::ostringstream msg;
msg << "Invalid output spatial reference '" << m_outSRS.getWKT() <<
"'. This is usually caused by a bad value for the 'out_srs'"
"option.";
throw pdal_error(msg.str());
}
m_transform_ptr = TransformPtr(
OCTNewCoordinateTransformation(m_in_ref_ptr.get(),
m_out_ref_ptr.get()), OSRTransformDeleter());
if (!m_transform_ptr.get())
{
std::string msg = "Could not construct CoordinateTransformation in "
"ReprojectionFilter:: ";
throw std::runtime_error(msg);
}
setSpatialReference(m_outSRS);
}
/*!
\brief A constructor that accepts an optional \a parent.
*/
CoordinateConversionController::CoordinateConversionController(QObject* parent):
AbstractTool(parent),
m_coordinateFormats{CoordinateConversionConstants::DECIMAL_DEGREES_FORMAT,
CoordinateConversionConstants::DEGREES_DECIMAL_MINUTES_FORMAT,
CoordinateConversionConstants::DEGREES_MINUTES_SECONDS_FORMAT,
CoordinateConversionConstants::MGRS_FORMAT,
CoordinateConversionConstants::USNG_FORMAT,
CoordinateConversionConstants::UTM_FORMAT,
CoordinateConversionConstants::GARS_FORMAT}
{
ToolManager::instance().addTool(this);
auto geoView = ToolResourceProvider::instance()->geoView();
if (geoView)
setSpatialReference(geoView->spatialReference());
connect(ToolResourceProvider::instance(), &ToolResourceProvider::spatialReferenceChanged, this, [this]()
{
setSpatialReference(ToolResourceProvider::instance()->spatialReference());
});
connect(ToolResourceProvider::instance(), &ToolResourceProvider::mouseClicked, this, &CoordinateConversionController::onMouseClicked);
connect(ToolResourceProvider::instance(), &ToolResourceProvider::locationChanged, this, &CoordinateConversionController::onLocationChanged);
connect(ToolResourceProvider::instance(), &ToolResourceProvider::geoViewChanged, this, [this]()
{
setGeoViewInternal(Toolkit::ToolResourceProvider::instance()->geoView());
});
connect(this, &CoordinateConversionController::optionsChanged, this,
[this]()
{
convertPoint();
});
}
void PgReader::ready(PointContextRef ctx)
{
m_atEnd = false;
m_cur_row = 0;
m_cur_nrows = 0;
m_cur_result = NULL;
if (getSpatialReference().empty())
setSpatialReference(fetchSpatialReference());
m_point_size = 0;
for (auto di = m_dims.begin(); di != m_dims.end(); ++di)
m_point_size += Dimension::size(di->m_dimType.m_type);
CursorSetup();
}
void RialtoReader::initialize()
{
log()->get(LogLevel::Debug) << "RialtoReader::initialize()" << std::endl;
if (!m_gpkg)
{
m_gpkg = new GeoPackageReader(m_filename, log());
m_gpkg->open();
m_matrixSet = std::unique_ptr<GpkgMatrixSet>(new GpkgMatrixSet());
m_gpkg->readMatrixSet(m_dataset, *m_matrixSet);
const SpatialReference srs(m_matrixSet->getWkt());
setSpatialReference(srs);
}
}
void PgReader::processOptions(const Options& options)
{
// If we don't know the table name, we're SOL
m_table_name = options.getValueOrThrow<std::string>("table");
// Connection string needs to exist and actually work
m_connection = options.getValueOrThrow<std::string>("connection");
// Schema and column name can be defaulted safely
m_column_name = options.getValueOrDefault<std::string>("column", "pa");
m_schema_name = options.getValueOrDefault<std::string>("schema", "");
// Read other preferences
m_where = options.getValueOrDefault<std::string>("where", "");
// Spatial reference.
setSpatialReference(options.getValueOrDefault<SpatialReference>(
"spatialreference", SpatialReference()));
}
void GreyhoundReader::initialize(PointTableRef table)
{
// Parse the URL and query parameters (although we won't handle the schema
// until addDimensions) and fetch the dataset `info`.
Json::Value config;
if (log()->getLevel() > LogLevel::Debug4)
config["arbiter"]["verbose"] = true;
m_arbiter.reset(new arbiter::Arbiter(config));
// If this stage was parsed from a string parameter rather than JSON object
// specification, normalize it to our URL.
if (m_filename.size() && m_args.url.empty())
{
m_args.url = m_filename;
const std::string pre("greyhound://");
if (m_args.url.find(pre) == 0)
m_args.url = m_args.url.substr(pre.size());
}
m_params = GreyhoundParams(m_args);
log()->get(LogLevel::Debug) << "Fetching info from " << m_params.root() <<
std::endl;
try
{
m_info = parse(m_arbiter->get(m_params.root() + "info"));
}
catch (std::exception& e)
{
throw pdal_error(std::string("Failed to fetch info: ") + e.what());
}
if (m_info.isMember("srs") && getSpatialReference().empty())
setSpatialReference(m_info["srs"].asString());
}
void TIndexReader::initialize()
{
if (!m_bounds.empty())
m_wkt = m_bounds.toWKT();
m_out_ref.reset(new gdal::SpatialRef());
log()->get(LogLevel::Debug) << "Opening file " << m_filename <<
std::endl;
gdal::registerDrivers();
m_dataset = OGROpen(m_filename.c_str(), FALSE, NULL);
if (!m_dataset)
{
std::stringstream oss;
oss << "unable to datasource '" << m_filename << "'";
throw pdal::pdal_error(oss.str());
}
OGRGeometryH geometry(0);
if (m_sql.size())
{
m_layer = OGR_DS_ExecuteSQL(m_dataset, m_sql.c_str(), geometry,
m_dialect.c_str());
}
else
{
m_layer = OGR_DS_GetLayerByName(m_dataset, m_layerName.c_str());
}
if (!m_layer)
{
std::stringstream oss;
oss << getName() << ": Unable to open layer '" << m_layerName <<
"' from OGR datasource '" << m_filename << "'";
throw pdal::pdal_error(oss.str());
}
m_out_ref->setFromLayer(m_layer);
// Override the SRS if the user set one, otherwise, take it
// from the layer
if (m_tgtSrsString.size())
m_out_ref.reset(new gdal::SpatialRef(m_tgtSrsString));
else
m_out_ref.reset(new gdal::SpatialRef(m_out_ref->wkt()));
setSpatialReference(SpatialReference(m_out_ref->wkt()));
std::unique_ptr<gdal::Geometry> wkt_g;
// If the user set either explicit 'polygon' or 'boundary' options
// we will filter by that geometry. The user can set a 'filter_srs'
// option to override the SRS of the input geometry and we will
// reproject to the output projection as needed.
if (m_wkt.size())
{
// Reproject the given wkt to the output SRS so
// filtering/cropping works
gdal::SpatialRef assign(m_filterSRS);
gdal::Geometry before(m_wkt, assign);
before.transform(*m_out_ref);
wkt_g.reset (new gdal::Geometry(before.wkt(), *m_out_ref));
geometry = wkt_g->get();
m_wkt = wkt_g->wkt();
OGR_L_SetSpatialFilter(m_layer, geometry);
}
if (m_attributeFilter.size())
{
OGRErr err = OGR_L_SetAttributeFilter(m_layer,
m_attributeFilter.c_str());
if (err != OGRERR_NONE)
{
std::stringstream oss;
oss << getName() << ": Unable to set attribute filter '"
<< m_attributeFilter << "' for OGR datasource '"
<< m_filename << "'";
throw pdal::pdal_error(oss.str());
}
}
Options cropOptions;
if (m_wkt.size())
cropOptions.add("polygon", m_wkt);
for (auto f : getFiles())
{
log()->get(LogLevel::Debug) << "Adding file "
<< f.m_filename
<< " to merge filter" <<std::endl;
std::string driver = m_factory.inferReaderDriver(f.m_filename);
Stage *reader = m_factory.createStage(driver);
if (!reader)
{
std::stringstream out;
out << "Unable to create reader for file '"
<< f.m_filename << "'.";
throw pdal_error(out.str());
}
Options readerOptions;
readerOptions.add("filename", f.m_filename);
reader->setOptions(readerOptions);
Stage *premerge = reader;
if (m_tgtSrsString != f.m_srs &&
(m_tgtSrsString.size() && f.m_srs.size()))
{
Stage *repro = m_factory.createStage("filters.reprojection");
repro->setInput(*reader);
Options reproOptions;
reproOptions.add("out_srs", m_tgtSrsString);
reproOptions.add("in_srs", f.m_srs);
log()->get(LogLevel::Debug2) << "Repro = "
<< m_tgtSrsString << "/"
<< f.m_srs << "!\n";
repro->setOptions(reproOptions);
premerge = repro;
}
// WKT is set even if we're using a bounding box for filtering, so
// can be used as a test here.
if (!m_wkt.empty())
{
Stage *crop = m_factory.createStage("filters.crop");
crop->setOptions(cropOptions);
crop->setInput(*premerge);
log()->get(LogLevel::Debug3) << "Cropping data with wkt '"
<< m_wkt << "'" << std::endl;
premerge = crop;
}
m_merge.setInput(*premerge);
}
if (m_sql.size())
{
// We were created with OGR_DS_ExecuteSQL which needs to have
// its layer explicitly released
OGR_DS_ReleaseResultSet(m_dataset, m_layer);
}
else
{
OGR_DS_Destroy(m_dataset);
}
m_layer = 0;
m_dataset = 0;
}
void Stage::setSpatialReference(const SpatialReference& spatialRef)
{
setSpatialReference(m_metadata, spatialRef);
}