OGRGeometry* OGRGeometryCollection::getCurveGeometry( const char* const* papszOptions) const { OGRGeometryCollection* poGC = OGRGeometryFactory::createGeometry( OGR_GT_GetCurve(getGeometryType()))->toGeometryCollection(); if( poGC == nullptr ) return nullptr; poGC->assignSpatialReference( getSpatialReference() ); bool bHasCurveGeometry = false; for( int iGeom = 0; iGeom < nGeomCount; iGeom++ ) { OGRGeometry* poSubGeom = papoGeoms[iGeom]->getCurveGeometry(papszOptions); if( poSubGeom->hasCurveGeometry() ) bHasCurveGeometry = true; poGC->addGeometryDirectly( poSubGeom ); } if( !bHasCurveGeometry ) { delete poGC; return clone(); } return poGC; }
OGRGeometry *OGRPoint::clone() const { OGRPoint *poNewPoint = new OGRPoint( x, y, z ); poNewPoint->assignSpatialReference( getSpatialReference() ); return poNewPoint; }
OGRGeometry *OGRPoint::clone() const { OGRPoint *poNewPoint = new OGRPoint( x, y, z ); poNewPoint->assignSpatialReference( getSpatialReference() ); poNewPoint->setCoordinateDimension( nCoordDimension ); return poNewPoint; }
OGRGeometry *OGRLinearRing::clone() const { OGRLinearRing *poNewLinearRing = new OGRLinearRing(); poNewLinearRing->assignSpatialReference( getSpatialReference() ); poNewLinearRing->setPoints( nPointCount, paoPoints, padfZ, padfM ); poNewLinearRing->flags = flags; return poNewLinearRing; }
boost::property_tree::ptree Stage::toPTree() const { boost::property_tree::ptree tree = StageBase::toPTree(); tree.add("NumPoints", getNumPoints()); tree.add("PointCountType", getPointCountType()); tree.add("Bounds", getBounds()); tree.add("SRS", getSpatialReference()); return tree; }
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(); }
OGRGeometry *OGRPoint::clone() const { OGRPoint *poNewPoint = new (std::nothrow) OGRPoint( x, y, z, m ); if( poNewPoint == NULL ) return NULL; poNewPoint->assignSpatialReference( getSpatialReference() ); poNewPoint->flags = flags; return poNewPoint; }
OGRGeometry *OGRCompoundCurve::clone() const { OGRCompoundCurve *poNewCC = new OGRCompoundCurve; poNewCC->assignSpatialReference( getSpatialReference() ); poNewCC->flags = flags; for( int i = 0; i < oCC.nCurveCount; i++ ) { poNewCC->addCurve( oCC.papoCurves[i] ); } return poNewCC; }
OGRPolygon* OGRCurvePolygon::CurvePolyToPoly(double dfMaxAngleStepSizeDegrees, const char* const* papszOptions) const { OGRPolygon* poPoly = new OGRPolygon(); poPoly->assignSpatialReference(getSpatialReference()); for( int iRing = 0; iRing < oCC.nCurveCount; iRing++ ) { OGRLineString* poLS = oCC.papoCurves[iRing]->CurveToLine(dfMaxAngleStepSizeDegrees, papszOptions); poPoly->addRingDirectly(OGRCurve::CastToLinearRing(poLS)); } return poPoly; }
PointViewSet MergeFilter::run(PointViewPtr in) { PointViewSet viewSet; // If the SRS of all the point views aren't the same, print a warning // unless we're explicitly overriding the SRS. if (getSpatialReference().empty() && (in->spatialReference() != m_view->spatialReference())) log()->get(LogLevel::Warning) << getName() << ": merging points " "with inconsistent spatial references." << std::endl; m_view->append(*in.get()); viewSet.insert(m_view); return viewSet; }
OGRErr OGRGeometry::transformTo( OGRSpatialReference *poSR ) { #ifdef DISABLE_OGRGEOM_TRANSFORM return OGRERR_FAILURE; #else OGRCoordinateTransformation *poCT; OGRErr eErr; if( getSpatialReference() == NULL || poSR == NULL ) return OGRERR_FAILURE; poCT = OGRCreateCoordinateTransformation( getSpatialReference(), poSR ); if( poCT == NULL ) return OGRERR_FAILURE; eErr = transform( poCT ); delete poCT; return eErr; #endif }
OGRGeometry *OGRLineString::clone() { OGRLineString *poNewLineString; poNewLineString = new OGRLineString(); poNewLineString->assignSpatialReference( getSpatialReference() ); poNewLineString->setPoints( nPointCount, paoPoints, padfZ ); // notdef: not 3D return poNewLineString; }
OGRGeometry *OGRMultiPoint::clone() const { OGRMultiPoint *poNewGC; poNewGC = new OGRMultiPoint; poNewGC->assignSpatialReference( getSpatialReference() ); for( int i = 0; i < getNumGeometries(); i++ ) { poNewGC->addGeometry( getGeometryRef(i) ); } return poNewGC; }
OGRGeometry *OGRGeometryCollection::clone() const { OGRGeometryCollection *poNewGC; poNewGC = new OGRGeometryCollection; poNewGC->assignSpatialReference( getSpatialReference() ); for( int i = 0; i < nGeomCount; i++ ) { poNewGC->addGeometry( papoGeoms[i] ); } return poNewGC; }
OGRGeometry *OGRPolygon::clone() { OGRPolygon *poNewPolygon; poNewPolygon = new OGRPolygon; poNewPolygon->assignSpatialReference( getSpatialReference() ); for( int i = 0; i < nRingCount; i++ ) { poNewPolygon->addRing( papoRings[i] ); } return poNewPolygon; }
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(); }
OGRGeometry* OGRGeometryCollection::getLinearGeometry(double dfMaxAngleStepSizeDegrees, const char* const* papszOptions) const { OGRGeometryCollection* poGC = (OGRGeometryCollection*) OGRGeometryFactory::createGeometry(OGR_GT_GetLinear(getGeometryType())); if( poGC == NULL ) return NULL; poGC->assignSpatialReference( getSpatialReference() ); for( int iGeom = 0; iGeom < nGeomCount; iGeom++ ) { OGRGeometry* poSubGeom = papoGeoms[iGeom]->getLinearGeometry(dfMaxAngleStepSizeDegrees, papszOptions); poGC->addGeometryDirectly( poSubGeom ); } return poGC; }
OGRGeometry *OGRCurvePolygon::clone() const { OGRCurvePolygon *poNewPolygon; poNewPolygon = (OGRCurvePolygon*) OGRGeometryFactory::createGeometry(getGeometryType()); poNewPolygon->assignSpatialReference( getSpatialReference() ); for( int i = 0; i < oCC.nCurveCount; i++ ) { poNewPolygon->addRing( oCC.papoCurves[i] ); } return poNewPolygon; }
OGRLineString* OGRCompoundCurve::CurveToLineInternal(double dfMaxAngleStepSizeDegrees, const char* const* papszOptions, int bIsLinearRing) const { OGRLineString* const poLine = bIsLinearRing ? new OGRLinearRing() : new OGRLineString(); poLine->assignSpatialReference(getSpatialReference()); for( int iGeom = 0; iGeom < oCC.nCurveCount; iGeom++ ) { OGRLineString* poSubLS = oCC.papoCurves[iGeom]->CurveToLine(dfMaxAngleStepSizeDegrees, papszOptions); poLine->addSubLineString(poSubLS, (iGeom == 0) ? 0 : 1); delete poSubLS; } return poLine; }
OGRGeometry* OGRPolygon::getCurveGeometry(const char* const* papszOptions) const { OGRCurvePolygon* poCC = new OGRCurvePolygon(); poCC->assignSpatialReference( getSpatialReference() ); bool bHasCurveGeometry = false; for( int iRing = 0; iRing < oCC.nCurveCount; iRing++ ) { OGRCurve* poSubGeom = (OGRCurve* )oCC.papoCurves[iRing]->getCurveGeometry(papszOptions); if( wkbFlatten(poSubGeom->getGeometryType()) != wkbLineString ) bHasCurveGeometry = true; poCC->addRingDirectly( poSubGeom ); } if( !bHasCurveGeometry ) { delete poCC; return clone(); } return poCC; }
OGRGeometry *OGRGeometryCollection::clone() const { OGRGeometryCollection *poNewGC = OGRGeometryFactory::createGeometry(getGeometryType())-> toGeometryCollection(); poNewGC->assignSpatialReference( getSpatialReference() ); poNewGC->flags = flags; for( auto&& poSubGeom: *this ) { if( poNewGC->addGeometry( poSubGeom ) != OGRERR_NONE ) { delete poNewGC; return nullptr; } } return poNewGC; }
OGRLineString* OGRCircularString::CurveToLine( double dfMaxAngleStepSizeDegrees, const char* const* papszOptions ) const { OGRLineString* poLine = new OGRLineString(); poLine->assignSpatialReference(getSpatialReference()); const bool bHasZ = getCoordinateDimension() == 3; for( int i = 0; i < nPointCount - 2; i += 2 ) { OGRLineString* poArc = OGRGeometryFactory::curveToLineString( paoPoints[i].x, paoPoints[i].y, padfZ ? padfZ[i] : 0.0, paoPoints[i+1].x, paoPoints[i+1].y, padfZ ? padfZ[i+1] : 0.0, paoPoints[i+2].x, paoPoints[i+2].y, padfZ ? padfZ[i+2] : 0.0, bHasZ, dfMaxAngleStepSizeDegrees, papszOptions); poLine->addSubLineString(poArc, (i == 0) ? 0 : 1); delete poArc; } return poLine; }
OGRGeometry * OGRPolygon::getCurveGeometry( const char* const* papszOptions ) const { OGRCurvePolygon* poCC = new OGRCurvePolygon(); poCC->assignSpatialReference( getSpatialReference() ); bool bHasCurveGeometry = false; for( auto&& poRing: *this ) { auto poSubGeom = poRing->getCurveGeometry(papszOptions); if( wkbFlatten(poSubGeom->getGeometryType()) != wkbLineString ) bHasCurveGeometry = true; poCC->addRingDirectly( poSubGeom->toCurve() ); } if( !bHasCurveGeometry ) { delete poCC; return clone(); } return poCC; }
QuickInfo LasReader::inspect() { QuickInfo qi; std::unique_ptr<PointLayout> layout(new PointLayout()); PointTable table; initialize(table); addDimensions(layout.get()); Dimension::IdList dims = layout->dims(); for (auto di = dims.begin(); di != dims.end(); ++di) qi.m_dimNames.push_back(layout->dimName(*di)); if (!Utils::numericCast(m_lasHeader.pointCount(), qi.m_pointCount)) qi.m_pointCount = std::numeric_limits<point_count_t>::max(); qi.m_bounds = m_lasHeader.getBounds(); qi.m_srs = getSpatialReference(); qi.m_valid = true; done(table); return qi; }
OGRGeometry *OGRGeometryCollection::clone() const { OGRGeometryCollection *poNewGC; poNewGC = (OGRGeometryCollection*) OGRGeometryFactory::createGeometry(getGeometryType()); if( poNewGC == NULL ) return NULL; poNewGC->assignSpatialReference( getSpatialReference() ); poNewGC->flags = flags; for( int i = 0; i < nGeomCount; i++ ) { if( poNewGC->addGeometry( papoGeoms[i] ) != OGRERR_NONE ) { delete poNewGC; return NULL; } } return poNewGC; }
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) throwError("Unable to datasource '" + m_filename + "'"); 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) throwError("Unable to open layer '" + m_layerName + "' from OGR datasource '" + m_filename + "'"); 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())); // Set SRS if not overridden. if (getSpatialReference().empty()) 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) throwError("Unable to set attribute filter '" + m_attributeFilter + "' for OGR datasource '" + m_filename + "'"); } 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) throwError("Unable to create reader for file '" + f.m_filename + "'."); 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 P2gWriter::write(const PointBuffer& buf) { std::string z_name = getOptions().getValueOrDefault<std::string>("Z", "Z"); for (point_count_t idx = 0; idx < buf.size(); idx++) { double x = buf.getFieldAs<double>(Dimension::Id::X, idx); double y = buf.getFieldAs<double>(Dimension::Id::Y, idx); double z = buf.getFieldAs<double>(Dimension::Id::Z, idx); m_coordinates.push_back(boost::tuple<double, double, double>(x, y, z)); } m_bounds = buf.calculateBounds(); m_GRID_SIZE_X = (int)(ceil((m_bounds.maxx - m_bounds.minx)/m_GRID_DIST_X)) + 1; m_GRID_SIZE_Y = (int)(ceil((m_bounds.maxy - m_bounds.miny)/m_GRID_DIST_Y)) + 1; log()->get(LogLevel::Debug) << "X grid size: " << m_GRID_SIZE_X << std::endl; log()->get(LogLevel::Debug) << "Y grid size: " << m_GRID_SIZE_Y << std::endl; log()->floatPrecision(6); log()->get(LogLevel::Debug) << "X grid distance: " << m_GRID_DIST_X << std::endl; log()->get(LogLevel::Debug) << "Y grid distance: " << m_GRID_DIST_Y << std::endl; log()->clearFloat(); boost::scoped_ptr<OutCoreInterp> p(new OutCoreInterp(m_GRID_DIST_X, m_GRID_DIST_Y, m_GRID_SIZE_X, m_GRID_SIZE_Y, m_RADIUS_SQ, m_bounds.minx, m_bounds.maxx, m_bounds.miny, m_bounds.maxy, m_fill_window_size)); m_interpolator.swap(p); if (m_interpolator->init() < 0) { throw p2g_error("unable to initialize interpolator"); } int rc(0); std::vector<boost::tuple<double, double, double> >::const_iterator i; for (i = m_coordinates.begin(); i!= m_coordinates.end(); ++i) { double x = i->get<0>(); double y = i->get<1>(); x = x - m_bounds.minx; y = y - m_bounds.miny; rc = m_interpolator->update(x, y, i->get<2>()); if (rc < 0) { throw p2g_error("interp->update() error while processing "); } } double adfGeoTransform[6]; adfGeoTransform[0] = m_bounds.minx; adfGeoTransform[1] = m_GRID_DIST_X; adfGeoTransform[2] = 0.0; adfGeoTransform[3] = m_bounds.maxy; adfGeoTransform[4] = 0.0; adfGeoTransform[5] = -1 * m_GRID_DIST_Y; SpatialReference const& srs = getSpatialReference(); if ((rc = m_interpolator->finish(const_cast<char*>(m_filename.c_str()), m_outputFormat, m_outputTypes, adfGeoTransform, srs.getWKT().c_str())) < 0) { throw p2g_error("interp->finish() error"); } return; }
PointViewSet Stage::execute(PointTableRef table) { table.finalize(); PointViewSet views; // If the inputs are empty, we're a reader. if (m_inputs.empty()) { views.insert(PointViewPtr(new PointView(table))); } else { for (size_t i = 0; i < m_inputs.size(); ++i) { Stage *prev = m_inputs[i]; PointViewSet temp = prev->execute(table); views.insert(temp.begin(), temp.end()); } } PointViewSet outViews; std::vector<StageRunnerPtr> runners; // Put the spatial references from the views onto the table. // The table's spatial references are only valid as long as the stage // is running. // ABELL - Should we clear the references once the stage run has // completed? Wondering if that would break something where a // writer wants to check a table's SRS. SpatialReference srs; table.clearSpatialReferences(); for (auto const& it : views) table.addSpatialReference(it->spatialReference()); // Do the ready operation and then start running all the views // through the stage. ready(table); for (auto const& it : views) { StageRunnerPtr runner(new StageRunner(this, it)); runners.push_back(runner); runner->run(); } // As the stages complete (synchronously at this time), propagate the // spatial reference and merge the output views. srs = getSpatialReference(); for (auto const& it : runners) { StageRunnerPtr runner(it); PointViewSet temp = runner->wait(); // If our stage has a spatial reference, the view takes it on once // the stage has been run. if (!srs.empty()) for (PointViewPtr v : temp) v->setSpatialReference(srs); outViews.insert(temp.begin(), temp.end()); } done(table); return outViews; }