void RialtoTest::populateDatabase(pdal::PointTable& table,
pdal::PointViewPtr view,
const std::string& filename,
uint32_t maxLevel,
const std::string& tableName)
{
assert(FileUtils::fileExists(filename));
{
time_t now;
time(&now);
char buf[sizeof("yyyy-mm-ddThh:mm:ss.sssZ")+1];
// TODO: this produces "ss", not "ss.sss" as the gpkg spec implies is required
strftime(buf, sizeof(buf), "%FT%TZ", gmtime(&now));
const std::string timestamp(buf);
pdal::Options readerOptions;
pdal::BufferReader reader;
reader.setOptions(readerOptions);
reader.addView(view);
reader.setSpatialReference(SpatialReference("EPSG:4326"));
pdal::StageFactory f;
pdal::Options writerOptions;
writerOptions.add("filename", filename);
writerOptions.add("name", tableName);
writerOptions.add("numColsAtL0", 2);
writerOptions.add("numRowsAtL0", 1);
writerOptions.add("timestamp", timestamp);
writerOptions.add("description", "");
writerOptions.add("maxLevel", maxLevel);
writerOptions.add("tms_minx", -180.0);
writerOptions.add("tms_miny", -90.0);
writerOptions.add("tms_maxx", 180.0);
writerOptions.add("tms_maxy", 90.0);
//writerOptions.add("overwrite", true);
//writerOptions.add("verbose", LogLevel::Debug);
pdal::Stage* writer = new RialtoWriter();
writer->setOptions(writerOptions);
writer->setInput(reader);
// execution: write to database
writer->prepare(table);
PointViewSet outputViews = writer->execute(table);
delete writer;
}
assert(FileUtils::fileExists(filename));
}
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()));
}
SpatialReference anySpatialReference() const
{
return m_spatialRefs.size() ?
*m_spatialRefs.begin() : SpatialReference();
}
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;
}
SpatialReference spatialReference() const
{
return spatialReferenceUnique() ? anySpatialReference() :
SpatialReference();
}
