bool Polygon::valid() const
{
int gtype = GEOSGeomTypeId_r(m_ctx, m_geom);
if (gtype != GEOS_POLYGON && gtype != GEOS_MULTIPOLYGON)
return false;
return (bool)GEOSisValid_r(m_ctx, m_geom);
}
static GEOSGeometry *LWGEOM_GEOS_makeValid( const GEOSGeometry *gin, QString &errorMessage )
{
GEOSContextHandle_t handle = QgsGeos::getGEOSHandler();
// return what we got so far if already valid
Q_NOWARN_UNREACHABLE_PUSH
try
{
if ( GEOSisValid_r( handle, gin ) )
{
// It's valid at this step, return what we have
return GEOSGeom_clone_r( handle, gin );
}
}
catch ( GEOSException &e )
{
// I don't think should ever happen
errorMessage = QStringLiteral( "GEOSisValid(): %1" ).arg( e.what() );
return nullptr;
}
Q_NOWARN_UNREACHABLE_POP
// make what we got valid
switch ( GEOSGeomTypeId_r( handle, gin ) )
{
case GEOS_MULTIPOINT:
case GEOS_POINT:
// points are always valid, but we might have invalid ordinate values
QgsDebugMsg( QStringLiteral( "PUNTUAL geometry resulted invalid to GEOS -- dunno how to clean that up" ) );
return nullptr;
case GEOS_LINESTRING:
return LWGEOM_GEOS_makeValidLine( gin, errorMessage );
case GEOS_MULTILINESTRING:
return LWGEOM_GEOS_makeValidMultiLine( gin, errorMessage );
case GEOS_POLYGON:
case GEOS_MULTIPOLYGON:
return LWGEOM_GEOS_makeValidPolygon( gin, errorMessage );
case GEOS_GEOMETRYCOLLECTION:
return LWGEOM_GEOS_makeValidCollection( gin, errorMessage );
default:
errorMessage = QStringLiteral( "ST_MakeValid: doesn't support geometry type: %1" ).arg( GEOSGeomTypeId_r( handle, gin ) );
return nullptr;
}
}
void Crop::ready(PointContext ctx)
{
#ifdef PDAL_HAVE_GEOS
if (!m_poly.empty())
{
m_geosEnvironment = initGEOS_r(pdal::geos::_GEOSWarningHandler,
pdal::geos::_GEOSErrorHandler);
m_geosGeometry = GEOSGeomFromWKT_r(m_geosEnvironment, m_poly.c_str());
if (!m_geosGeometry)
throw pdal_error("unable to import polygon WKT");
int gtype = GEOSGeomTypeId_r(m_geosEnvironment, m_geosGeometry);
if (!(gtype == GEOS_POLYGON || gtype == GEOS_MULTIPOLYGON))
throw pdal_error("input WKT was not a POLYGON or MULTIPOLYGON");
char* out_wkt = GEOSGeomToWKT_r(m_geosEnvironment, m_geosGeometry);
log()->get(LogLevel::Debug2) << "Ingested WKT for filters.crop: " <<
std::string(out_wkt) <<std::endl;
GEOSFree_r(m_geosEnvironment, out_wkt);
if (!GEOSisValid_r(m_geosEnvironment, m_geosGeometry))
{
char* reason =
GEOSisValidReason_r(m_geosEnvironment, m_geosGeometry);
std::ostringstream oss;
oss << "WKT is invalid: " << std::string(reason) << std::endl;
GEOSFree_r(m_geosEnvironment, reason);
throw pdal_error(oss.str());
}
m_geosPreparedGeometry =
GEOSPrepare_r(m_geosEnvironment, m_geosGeometry);
if (!m_geosPreparedGeometry)
throw pdal_error("unable to prepare geometry for "
"index-accelerated intersection");
m_bounds = computeBounds(m_geosGeometry);
log()->get(LogLevel::Debug) << "Computed bounds from given WKT: " <<
m_bounds <<std::endl;
}
else
{
log()->get(LogLevel::Debug) << "Using simple bounds for "
"filters.crop: " << m_bounds << std::endl;
}
#endif
}
ErrorList topolTest::checkValid( double tolerance, QgsVectorLayer *layer1, QgsVectorLayer *layer2, bool isExtent )
{
Q_UNUSED( tolerance );
Q_UNUSED( layer1 );
Q_UNUSED( layer2 );
Q_UNUSED( isExtent );
int i = 0;
ErrorList errorList;
QgsFeature f;
QList<FeatureLayer>::Iterator it;
for ( it = mFeatureList1.begin(); it != mFeatureList1.end(); ++it )
{
if ( !( ++i % 100 ) )
emit progress( ++i );
if ( testCanceled() )
break;
QgsGeometry g = it->feature.geometry();
if ( g.isNull() )
{
QgsMessageLog::logMessage( tr( "Invalid geometry in validity test." ), tr( "Topology plugin" ) );
continue;
}
GEOSGeometry *gGeos = g.exportToGeos();
if ( !gGeos )
continue;
if ( !GEOSisValid_r( QgsGeometry::getGEOSHandler(), gGeos ) )
{
QgsRectangle r = g.boundingBox();
QList<FeatureLayer> fls;
fls << *it << *it;
TopolErrorValid *err = new TopolErrorValid( r, g, fls );
errorList << err;
}
GEOSGeom_destroy_r( QgsGeometry::getGEOSHandler(), gGeos );
}
return errorList;
}
QgsGeometry QgsGeometryAnalyzer::createOffsetGeometry( const QgsGeometry& geom, const QgsGeometry& lineGeom, double offset )
{
if ( !geom || lineGeom.isEmpty() )
{
return QgsGeometry();
}
QList<QgsGeometry> inputGeomList;
if ( geom.isMultipart() )
{
inputGeomList = geom.asGeometryCollection();
}
else
{
inputGeomList.push_back( geom );
}
QList<GEOSGeometry*> outputGeomList;
QList<QgsGeometry>::const_iterator inputGeomIt = inputGeomList.constBegin();
GEOSContextHandle_t geosctxt = QgsGeometry::getGEOSHandler();
for ( ; inputGeomIt != inputGeomList.constEnd(); ++inputGeomIt )
{
if ( geom.type() == QgsWkbTypes::LineGeometry )
{
GEOSGeometry* inputGeomItGeos = inputGeomIt->exportToGeos();
GEOSGeometry* offsetGeom = GEOSOffsetCurve_r( geosctxt, inputGeomItGeos, -offset, 8 /*quadSegments*/, 0 /*joinStyle*/, 5.0 /*mitreLimit*/ );
GEOSGeom_destroy_r( geosctxt, inputGeomItGeos );
if ( !offsetGeom || !GEOSisValid_r( geosctxt, offsetGeom ) )
{
return QgsGeometry();
}
if ( !GEOSisValid_r( geosctxt, offsetGeom ) || GEOSGeomTypeId_r( geosctxt, offsetGeom ) != GEOS_LINESTRING || GEOSGeomGetNumPoints_r( geosctxt, offsetGeom ) < 1 )
{
GEOSGeom_destroy_r( geosctxt, offsetGeom );
return QgsGeometry();
}
outputGeomList.push_back( offsetGeom );
}
else if ( geom.type() == QgsWkbTypes::PointGeometry )
{
QgsPoint p = ( *inputGeomIt ).asPoint();
p = createPointOffset( p.x(), p.y(), offset, lineGeom );
GEOSCoordSequence* ptSeq = GEOSCoordSeq_create_r( geosctxt, 1, 2 );
GEOSCoordSeq_setX_r( geosctxt, ptSeq, 0, p.x() );
GEOSCoordSeq_setY_r( geosctxt, ptSeq, 0, p.y() );
GEOSGeometry* geosPt = GEOSGeom_createPoint_r( geosctxt, ptSeq );
outputGeomList.push_back( geosPt );
}
}
QgsGeometry outGeometry;
if ( !geom.isMultipart() )
{
GEOSGeometry* outputGeom = outputGeomList.at( 0 );
if ( outputGeom )
{
outGeometry.fromGeos( outputGeom );
}
}
else
{
GEOSGeometry** geomArray = new GEOSGeometry*[outputGeomList.size()];
for ( int i = 0; i < outputGeomList.size(); ++i )
{
geomArray[i] = outputGeomList.at( i );
}
GEOSGeometry* collection = nullptr;
if ( geom.type() == QgsWkbTypes::PointGeometry )
{
collection = GEOSGeom_createCollection_r( geosctxt, GEOS_MULTIPOINT, geomArray, outputGeomList.size() );
}
else if ( geom.type() == QgsWkbTypes::LineGeometry )
{
collection = GEOSGeom_createCollection_r( geosctxt, GEOS_MULTILINESTRING, geomArray, outputGeomList.size() );
}
outGeometry.fromGeos( collection );
delete[] geomArray;
}
return outGeometry;
}
bool Layer::registerFeature( const QString& geom_id, PalGeometry *userGeom, double label_x, double label_y, const QString &labelText,
double labelPosX, double labelPosY, bool fixedPos, double angle, bool fixedAngle,
int xQuadOffset, int yQuadOffset, double xOffset, double yOffset, bool alwaysShow, double repeatDistance )
{
if ( geom_id.isEmpty() || label_x < 0 || label_y < 0 )
return false;
mMutex.lock();
if ( hashtable->contains( geom_id ) )
{
mMutex.unlock();
//A feature with this id already exists. Don't throw an exception as sometimes,
//the same feature is added twice (dateline split with otf-reprojection)
return false;
}
// Split MULTI GEOM and Collection in simple geometries
const GEOSGeometry *the_geom = userGeom->getGeosGeometry();
Feature* f = new Feature( this, geom_id, userGeom, label_x, label_y );
if ( fixedPos )
{
f->setFixedPosition( labelPosX, labelPosY );
}
if ( xQuadOffset != 0 || yQuadOffset != 0 )
{
f->setQuadOffset( xQuadOffset, yQuadOffset );
}
if ( xOffset != 0.0 || yOffset != 0.0 )
{
f->setPosOffset( xOffset, yOffset );
}
if ( fixedAngle )
{
f->setFixedAngle( angle );
}
// use layer-level defined rotation, but not if position fixed
if ( !fixedPos && angle != 0.0 )
{
f->setFixedAngle( angle );
}
f->setRepeatDistance( repeatDistance );
f->setAlwaysShow( alwaysShow );
bool first_feat = true;
double geom_size = -1, biggest_size = -1;
FeaturePart* biggest_part = NULL;
// break the (possibly multi-part) geometry into simple geometries
QLinkedList<const GEOSGeometry*>* simpleGeometries = unmulti( the_geom );
if ( simpleGeometries == NULL ) // unmulti() failed?
{
mMutex.unlock();
throw InternalException::UnknownGeometry();
}
GEOSContextHandle_t geosctxt = geosContext();
while ( simpleGeometries->size() > 0 )
{
const GEOSGeometry* geom = simpleGeometries->takeFirst();
// ignore invalid geometries (e.g. polygons with self-intersecting rings)
if ( GEOSisValid_r( geosctxt, geom ) != 1 ) // 0=invalid, 1=valid, 2=exception
{
// std::cerr << "ignoring invalid feature " << geom_id << std::endl;
continue;
}
int type = GEOSGeomTypeId_r( geosctxt, geom );
if ( type != GEOS_POINT && type != GEOS_LINESTRING && type != GEOS_POLYGON )
{
mMutex.unlock();
throw InternalException::UnknownGeometry();
}
FeaturePart* fpart = new FeaturePart( f, geom );
// ignore invalid geometries
if (( type == GEOS_LINESTRING && fpart->nbPoints < 2 ) ||
( type == GEOS_POLYGON && fpart->nbPoints < 3 ) )
{
delete fpart;
continue;
}
// polygons: reorder coordinates
if ( type == GEOS_POLYGON && reorderPolygon( fpart->nbPoints, fpart->x, fpart->y ) != 0 )
{
delete fpart;
continue;
}
if ( mMode == LabelPerFeature && ( type == GEOS_POLYGON || type == GEOS_LINESTRING ) )
{
if ( type == GEOS_LINESTRING )
GEOSLength_r( geosctxt, geom, &geom_size );
else if ( type == GEOS_POLYGON )
GEOSArea_r( geosctxt, geom, &geom_size );
if ( geom_size > biggest_size )
{
biggest_size = geom_size;
delete biggest_part; // safe with NULL part
biggest_part = fpart;
}
continue; // don't add the feature part now, do it later
// TODO: we should probably add also other parts to act just as obstacles
}
// feature part is ready!
addFeaturePart( fpart, labelText );
first_feat = false;
}
delete simpleGeometries;
userGeom->releaseGeosGeometry( the_geom );
mMutex.unlock();
// if using only biggest parts...
if (( mMode == LabelPerFeature || f->fixedPosition() ) && biggest_part != NULL )
{
addFeaturePart( biggest_part, labelText );
first_feat = false;
}
// add feature to layer if we have added something
if ( !first_feat )
{
features->append( f );
hashtable->insert( geom_id, f );
}
else
{
delete f;
}
return !first_feat; // true if we've added something
}
void OGRILI1Layer::PolygonizeAreaLayer( OGRILI1Layer* poAreaLineLayer, int nAreaFieldIndex, int nPointFieldIndex )
{
//add all lines from poAreaLineLayer to collection
OGRGeometryCollection *gc = new OGRGeometryCollection();
poAreaLineLayer->ResetReading();
while (OGRFeature *feature = poAreaLineLayer->GetNextFeatureRef())
gc->addGeometry(feature->GetGeometryRef());
//polygonize lines
CPLDebug( "OGR_ILI", "Polygonizing layer %s with %d multilines", poAreaLineLayer->GetLayerDefn()->GetName(), gc->getNumGeometries());
poAreaLineLayer = 0;
OGRMultiPolygon* polys = Polygonize( gc , false);
CPLDebug( "OGR_ILI", "Resulting polygons: %d", polys->getNumGeometries());
if (polys->getNumGeometries() != GetFeatureCount())
{
CPLDebug( "OGR_ILI", "Feature count of layer %s: " CPL_FRMT_GIB, GetLayerDefn()->GetName(), GetFeatureCount());
CPLDebug( "OGR_ILI", "Polygonizing again with crossing line fix");
delete polys;
polys = Polygonize( gc, true ); //try again with crossing line fix
CPLDebug( "OGR_ILI", "Resulting polygons: %d", polys->getNumGeometries());
}
delete gc;
//associate polygon feature with data row according to centroid
#if defined(HAVE_GEOS)
int i;
OGRPolygon emptyPoly;
GEOSGeom *ahInGeoms = NULL;
CPLDebug( "OGR_ILI", "Associating layer %s with area polygons", GetLayerDefn()->GetName());
ahInGeoms = (GEOSGeom *) CPLCalloc(sizeof(void*), polys->getNumGeometries());
GEOSContextHandle_t hGEOSCtxt = OGRGeometry::createGEOSContext();
for( i = 0; i < polys->getNumGeometries(); i++ )
{
ahInGeoms[i] = polys->getGeometryRef(i)->exportToGEOS(hGEOSCtxt);
if (!GEOSisValid_r(hGEOSCtxt, ahInGeoms[i])) ahInGeoms[i] = NULL;
}
for ( int nFidx = 0; nFidx < nFeatures; nFidx++)
{
OGRFeature *feature = papoFeatures[nFidx];
OGRGeometry* geomRef = feature->GetGeomFieldRef(nPointFieldIndex);
if( !geomRef )
{
continue;
}
GEOSGeom point = (GEOSGeom)(geomRef->exportToGEOS(hGEOSCtxt));
for (i = 0; i < polys->getNumGeometries(); i++ )
{
if (ahInGeoms[i] && GEOSWithin_r(hGEOSCtxt, point, ahInGeoms[i]))
{
feature->SetGeomField(nAreaFieldIndex, polys->getGeometryRef(i));
break;
}
}
if (i == polys->getNumGeometries())
{
CPLDebug( "OGR_ILI", "Association between area and point failed.");
feature->SetGeometry( &emptyPoly );
}
GEOSGeom_destroy_r( hGEOSCtxt, point );
}
for( i = 0; i < polys->getNumGeometries(); i++ )
GEOSGeom_destroy_r( hGEOSCtxt, ahInGeoms[i] );
CPLFree( ahInGeoms );
OGRGeometry::freeGEOSContext( hGEOSCtxt );
#endif
poAreaLineLayer = 0;
delete polys;
}
bool QgsGeometryAnalyzer::createOffsetGeometry( QgsGeometry* geom, QgsGeometry* lineGeom, double offset )
{
if ( !geom || !lineGeom )
{
return false;
}
QList<QgsGeometry*> inputGeomList;
if ( geom->isMultipart() )
{
inputGeomList = geom->asGeometryCollection();
}
else
{
inputGeomList.push_back( geom );
}
QList<GEOSGeometry*> outputGeomList;
QList<QgsGeometry*>::const_iterator inputGeomIt = inputGeomList.constBegin();
GEOSContextHandle_t geosctxt = QgsGeometry::getGEOSHandler();
for ( ; inputGeomIt != inputGeomList.constEnd(); ++inputGeomIt )
{
if ( geom->type() == QGis::Line )
{
//geos 3.3 needed for line offsets
#if defined(GEOS_VERSION_MAJOR) && defined(GEOS_VERSION_MINOR) && \
((GEOS_VERSION_MAJOR>3) || ((GEOS_VERSION_MAJOR==3) && (GEOS_VERSION_MINOR>=3)))
GEOSGeometry* offsetGeom = GEOSOffsetCurve_r( geosctxt, ( *inputGeomIt )->asGeos(), -offset, 8 /*quadSegments*/, 0 /*joinStyle*/, 5.0 /*mitreLimit*/ );
if ( !offsetGeom || !GEOSisValid_r( geosctxt, offsetGeom ) )
{
return false;
}
if ( !GEOSisValid_r( geosctxt, offsetGeom ) || GEOSGeomTypeId_r( geosctxt, offsetGeom ) != GEOS_LINESTRING || GEOSGeomGetNumPoints_r( geosctxt, offsetGeom ) < 1 )
{
GEOSGeom_destroy_r( geosctxt, offsetGeom );
return false;
}
outputGeomList.push_back( offsetGeom );
#else
outputGeomList.push_back( GEOSGeom_clone_r( geosctxt, ( *inputGeomIt )->asGeos() ) );
#endif
}
else if ( geom->type() == QGis::Point )
{
QgsPoint p = ( *inputGeomIt )->asPoint();
p = createPointOffset( p.x(), p.y(), offset, lineGeom );
GEOSCoordSequence* ptSeq = GEOSCoordSeq_create_r( geosctxt, 1, 2 );
GEOSCoordSeq_setX_r( geosctxt, ptSeq, 0, p.x() );
GEOSCoordSeq_setY_r( geosctxt, ptSeq, 0, p.y() );
GEOSGeometry* geosPt = GEOSGeom_createPoint_r( geosctxt, ptSeq );
outputGeomList.push_back( geosPt );
}
}
if ( !geom->isMultipart() )
{
GEOSGeometry* outputGeom = outputGeomList.at( 0 );
if ( outputGeom )
{
geom->fromGeos( outputGeom );
}
}
else
{
GEOSGeometry** geomArray = new GEOSGeometry*[outputGeomList.size()];
for ( int i = 0; i < outputGeomList.size(); ++i )
{
geomArray[i] = outputGeomList.at( i );
}
GEOSGeometry* collection = 0;
if ( geom->type() == QGis::Point )
{
collection = GEOSGeom_createCollection_r( geosctxt, GEOS_MULTIPOINT, geomArray, outputGeomList.size() );
}
else if ( geom->type() == QGis::Line )
{
collection = GEOSGeom_createCollection_r( geosctxt, GEOS_MULTILINESTRING, geomArray, outputGeomList.size() );
}
geom->fromGeos( collection );
delete[] geomArray;
}
return true;
}
