31#define DEFAULT_QUADRANT_SEGMENTS 8
33#define CATCH_GEOS(r) \
34 catch (GEOSException &) \
39#define CATCH_GEOS_WITH_ERRMSG(r) \
40 catch (GEOSException &e) \
44 *errorMsg = e.what(); \
51static void throwGEOSException(
const char *fmt, ... )
57 vsnprintf( buffer,
sizeof buffer, fmt, ap );
60 QString message = QString::fromUtf8( buffer );
70 throw GEOSException( message );
78 throw GEOSException( message );
83static void printGEOSNotice(
const char *fmt, ... )
90 vsnprintf( buffer,
sizeof buffer, fmt, ap );
100 GEOSContextHandle_t ctxt;
104 ctxt = initGEOS_r( printGEOSNotice, throwGEOSException );
109 finishGEOS_r( ctxt );
112 GEOSInit(
const GEOSInit &rh ) =
delete;
113 GEOSInit &operator=(
const GEOSInit &rh ) =
delete;
120 GEOSGeom_destroy_r( geosinit()->ctxt, geom );
125 GEOSPreparedGeom_destroy_r( geosinit()->ctxt, geom );
130 GEOSBufferParams_destroy_r( geosinit()->ctxt, params );
135 GEOSCoordSeq_destroy_r( geosinit()->ctxt, sequence );
170#if GEOS_VERSION_MAJOR==3 && GEOS_VERSION_MINOR<10
172 throw QgsNotSupportedException( QObject::tr(
"The structured method to make geometries valid requires a QGIS build based on GEOS 3.10 or later" ) );
175 throw QgsNotSupportedException( QObject::tr(
"The keep collapsed option for making geometries valid requires a QGIS build based on GEOS 3.10 or later" ) );
179 geos.reset( GEOSMakeValid_r( geosinit()->ctxt, mGeos.get() ) );
184 GEOSMakeValidParams *params = GEOSMakeValidParams_create_r( geosinit()->ctxt );
188 GEOSMakeValidParams_setMethod_r( geosinit()->ctxt, params, GEOS_MAKE_VALID_LINEWORK );
192 GEOSMakeValidParams_setMethod_r( geosinit()->ctxt, params, GEOS_MAKE_VALID_STRUCTURE );
196 GEOSMakeValidParams_setKeepCollapsed_r( geosinit()->ctxt,
198 keepCollapsed ? 1 : 0 );
203 geos.reset( GEOSMakeValidWithParams_r( geosinit()->ctxt, mGeos.get(), params ) );
204 GEOSMakeValidParams_destroy_r( geosinit()->ctxt, params );
206 catch ( GEOSException &e )
210 *errorMsg = e.what();
212 GEOSMakeValidParams_destroy_r( geosinit()->ctxt, params );
241 std::unique_ptr< QgsAbstractGeometry > geom =
fromGeos( newPart );
248 mGeosPrepared.reset();
261 mGeosPrepared.reset( GEOSPrepare_r( geosinit()->ctxt, mGeos.get() ) );
265void QgsGeos::cacheGeos()
const
282 return overlay( geom, OverlayIntersection, errorMsg, parameters ).release();
287 return overlay( geom, OverlayDifference, errorMsg, parameters ).release();
302 catch ( GEOSException &e )
304 logError( QStringLiteral(
"GEOS" ), e.what() );
307 *errorMsg = e.what();
318 int partType = GEOSGeomTypeId_r( geosinit()->ctxt, currentPart );
321 if ( partType == GEOS_POINT )
332 if ( partType == GEOS_MULTILINESTRING || partType == GEOS_MULTIPOLYGON || partType == GEOS_GEOMETRYCOLLECTION )
334 int partCount = GEOSGetNumGeometries_r( geosinit()->ctxt, currentPart );
335 for (
int i = 0; i < partCount; ++i )
337 subdivideRecursive( GEOSGetGeometryN_r( geosinit()->ctxt, currentPart, i ), maxNodes, depth, parts, clipRect, gridSize );
348 int vertexCount = GEOSGetNumCoordinates_r( geosinit()->ctxt, currentPart );
349 if ( vertexCount == 0 )
353 else if ( vertexCount < maxNodes )
360 double width = clipRect.
width();
361 double height = clipRect.
height();
364 if ( width > height )
377 halfClipRect1.
setYMinimum( halfClipRect1.
yMinimum() - std::numeric_limits<double>::epsilon() );
378 halfClipRect2.
setYMinimum( halfClipRect2.
yMinimum() - std::numeric_limits<double>::epsilon() );
379 halfClipRect1.
setYMaximum( halfClipRect1.
yMaximum() + std::numeric_limits<double>::epsilon() );
380 halfClipRect2.
setYMaximum( halfClipRect2.
yMaximum() + std::numeric_limits<double>::epsilon() );
384 halfClipRect1.
setXMinimum( halfClipRect1.
xMinimum() - std::numeric_limits<double>::epsilon() );
385 halfClipRect2.
setXMinimum( halfClipRect2.
xMinimum() - std::numeric_limits<double>::epsilon() );
386 halfClipRect1.
setXMaximum( halfClipRect1.
xMaximum() + std::numeric_limits<double>::epsilon() );
387 halfClipRect2.
setXMaximum( halfClipRect2.
xMaximum() + std::numeric_limits<double>::epsilon() );
399 clipPart1.reset( GEOSIntersectionPrec_r( geosinit()->ctxt, mGeos.get(), clipPart1.get(), gridSize ) );
401 subdivideRecursive( clipPart1.get(), maxNodes, depth, parts, halfClipRect1, gridSize );
407 clipPart2.reset( GEOSIntersectionPrec_r( geosinit()->ctxt, mGeos.get(), clipPart2.get(), gridSize ) );
409 subdivideRecursive( clipPart2.get(), maxNodes, depth, parts, halfClipRect2, gridSize );
421 maxNodes = std::max( maxNodes, 8 );
430 return std::move( parts );
435 return overlay( geom, OverlayUnion, errorMsg, parameters ).release();
440 QVector< GEOSGeometry * > geosGeometries;
441 geosGeometries.reserve( geomList.size() );
447 geosGeometries <<
asGeos( g, mPrecision ).release();
453 geos::unique_ptr geomCollection = createGeosCollection( GEOS_GEOMETRYCOLLECTION, geosGeometries );
456 geomUnion.reset( GEOSUnaryUnionPrec_r( geosinit()->ctxt, geomCollection.get(), parameters.
gridSize() ) );
460 geomUnion.reset( GEOSUnaryUnion_r( geosinit()->ctxt, geomCollection.get() ) );
465 std::unique_ptr< QgsAbstractGeometry > result =
fromGeos( geomUnion.get() );
466 return result.release();
471 QVector< GEOSGeometry * > geosGeometries;
472 geosGeometries.reserve( geomList.size() );
478 geosGeometries <<
asGeos( g.constGet(), mPrecision ).release();
484 geos::unique_ptr geomCollection = createGeosCollection( GEOS_GEOMETRYCOLLECTION, geosGeometries );
488 geomUnion.reset( GEOSUnaryUnionPrec_r( geosinit()->ctxt, geomCollection.get(), parameters.
gridSize() ) );
492 geomUnion.reset( GEOSUnaryUnion_r( geosinit()->ctxt, geomCollection.get() ) );
498 std::unique_ptr< QgsAbstractGeometry > result =
fromGeos( geomUnion.get() );
499 return result.release();
504 return overlay( geom, OverlaySymDifference, errorMsg, parameters ).release();
516 if ( !otherGeosGeom )
525 GEOSPreparedDistance_r( geosinit()->ctxt, mGeosPrepared.get(), otherGeosGeom.get(), &
distance );
529 GEOSDistance_r( geosinit()->ctxt, mGeos.get(), otherGeosGeom.get(), &
distance );
545 geos::unique_ptr point = createGeosPointXY( x, y,
false, 0,
false, 0, 2, 0 );
553 GEOSPreparedDistance_r( geosinit()->ctxt, mGeosPrepared.get(), point.get(), &
distance );
557 GEOSDistance_r( geosinit()->ctxt, mGeos.get(), point.get(), &
distance );
573 if ( !otherGeosGeom )
588#if GEOS_VERSION_MAJOR>3 || ( GEOS_VERSION_MAJOR == 3 && GEOS_VERSION_MINOR>=10 )
589 return GEOSPreparedDistanceWithin_r( geosinit()->ctxt, mGeosPrepared.get(), otherGeosGeom.get(), maxdist );
591 GEOSPreparedDistance_r( geosinit()->ctxt, mGeosPrepared.get(), otherGeosGeom.get(), &
distance );
596#if GEOS_VERSION_MAJOR>3 || ( GEOS_VERSION_MAJOR == 3 && GEOS_VERSION_MINOR>=10 )
597 return GEOSDistanceWithin_r( geosinit()->ctxt, mGeos.get(), otherGeosGeom.get(), maxdist );
599 GEOSDistance_r( geosinit()->ctxt, mGeos.get(), otherGeosGeom.get(), &
distance );
610 geos::unique_ptr point = createGeosPointXY( x, y,
false, 0,
false, 0, 2, 0 );
619 return GEOSPreparedContains_r( geosinit()->ctxt, mGeosPrepared.get(), point.get() ) == 1;
622 result = ( GEOSContains_r( geosinit()->ctxt, mGeos.get(), point.get() ) == 1 );
624 catch ( GEOSException &e )
626 logError( QStringLiteral(
"GEOS" ), e.what() );
629 *errorMsg = e.what();
646 if ( !otherGeosGeom )
653 GEOSHausdorffDistance_r( geosinit()->ctxt, mGeos.get(), otherGeosGeom.get(), &
distance );
669 if ( !otherGeosGeom )
676 GEOSHausdorffDistanceDensify_r( geosinit()->ctxt, mGeos.get(), otherGeosGeom.get(), densifyFraction, &
distance );
692 if ( !otherGeosGeom )
699 GEOSFrechetDistance_r( geosinit()->ctxt, mGeos.get(), otherGeosGeom.get(), &
distance );
715 if ( !otherGeosGeom )
722 GEOSFrechetDistanceDensify_r( geosinit()->ctxt, mGeos.get(), otherGeosGeom.get(), densifyFraction, &
distance );
731 return relation( geom, RelationIntersects, errorMsg );
736 return relation( geom, RelationTouches, errorMsg );
741 return relation( geom, RelationCrosses, errorMsg );
746 return relation( geom, RelationWithin, errorMsg );
751 return relation( geom, RelationOverlaps, errorMsg );
756 return relation( geom, RelationContains, errorMsg );
761 return relation( geom, RelationDisjoint, errorMsg );
780 char *r = GEOSRelate_r( geosinit()->ctxt, mGeos.get(), geosGeom.get() );
783 result = QString( r );
784 GEOSFree_r( geosinit()->ctxt, r );
787 catch ( GEOSException &e )
789 logError( QStringLiteral(
"GEOS" ), e.what() );
792 *errorMsg = e.what();
801 if ( !mGeos || !geom )
815 result = ( GEOSRelatePattern_r( geosinit()->ctxt, mGeos.get(), geosGeom.get(), pattern.toLocal8Bit().constData() ) == 1 );
817 catch ( GEOSException &e )
819 logError( QStringLiteral(
"GEOS" ), e.what() );
822 *errorMsg = e.what();
839 if ( GEOSArea_r( geosinit()->ctxt, mGeos.get(), &
area ) != 1 )
855 if ( GEOSLength_r( geosinit()->ctxt, mGeos.get(), &
length ) != 1 )
863 QVector<QgsGeometry> &newGeometries,
866 QString *errorMsg,
bool skipIntersectionCheck )
const
881 if ( !GEOSisValid_r( geosinit()->ctxt, mGeos.get() ) )
889 newGeometries.clear();
896 splitLineGeos = createGeosLinestring( &splitLine, mPrecision );
900 splitLineGeos = createGeosPointXY( splitLine.
xAt( 0 ), splitLine.
yAt( 0 ),
false, 0,
false, 0, 2, mPrecision );
907 if ( !GEOSisValid_r( geosinit()->ctxt, splitLineGeos.get() ) || !GEOSisSimple_r( geosinit()->ctxt, splitLineGeos.get() ) )
915 if ( !topologicalTestPointsSplit( splitLineGeos.get(), topologyTestPoints ) )
924 returnCode = splitLinearGeometry( splitLineGeos.get(), newGeometries, skipIntersectionCheck );
928 returnCode = splitPolygonGeometry( splitLineGeos.get(), newGeometries, skipIntersectionCheck );
956 geos::unique_ptr intersectionGeom( GEOSIntersection_r( geosinit()->ctxt, mGeos.get(), splitLine ) );
957 if ( !intersectionGeom )
961 int nIntersectGeoms = 1;
962 if ( GEOSGeomTypeId_r( geosinit()->ctxt, intersectionGeom.get() ) == GEOS_LINESTRING
963 || GEOSGeomTypeId_r( geosinit()->ctxt, intersectionGeom.get() ) == GEOS_POINT )
967 nIntersectGeoms = GEOSGetNumGeometries_r( geosinit()->ctxt, intersectionGeom.get() );
969 for (
int i = 0; i < nIntersectGeoms; ++i )
973 currentIntersectGeom = intersectionGeom.get();
975 currentIntersectGeom = GEOSGetGeometryN_r( geosinit()->ctxt, intersectionGeom.get(), i );
977 const GEOSCoordSequence *lineSequence = GEOSGeom_getCoordSeq_r( geosinit()->ctxt, currentIntersectGeom );
978 unsigned int sequenceSize = 0;
980 if ( GEOSCoordSeq_getSize_r( geosinit()->ctxt, lineSequence, &sequenceSize ) != 0 )
982 for (
unsigned int i = 0; i < sequenceSize; ++i )
984 if ( GEOSCoordSeq_getXYZ_r( geosinit()->ctxt, lineSequence, i, &x, &y, &z ) )
986 testPoints.push_back(
QgsPoint( x, y, z ) );
999 int type = GEOSGeomTypeId_r( geosinit()->ctxt, mGeos.get() );
1001 std::unique_ptr< QgsMultiCurve > multiCurve;
1002 if ( type == GEOS_MULTILINESTRING )
1004 multiCurve.reset( qgsgeometry_cast<QgsMultiCurve *>(
mGeometry->
clone() ) );
1006 else if ( type == GEOS_LINESTRING )
1024 std::unique_ptr< QgsMultiPoint > splitPoints;
1026 std::unique_ptr< QgsAbstractGeometry > splitGeom(
fromGeos( GEOSsplitPoint ) );
1028 if ( qgsgeometry_cast<QgsMultiPoint *>( splitGeom.get() ) )
1030 splitPoints.reset( qgsgeometry_cast<QgsMultiPoint *>( splitGeom.release() ) );
1032 else if ( qgsgeometry_cast<QgsPoint *>( splitGeom.get() ) )
1034 splitPoints = std::make_unique< QgsMultiPoint >();
1035 if ( qgsgeometry_cast<QgsPoint *>( splitGeom.get() ) )
1037 splitPoints->addGeometry( qgsgeometry_cast<QgsPoint *>( splitGeom.release() ) );
1045 for (
int geometryIndex = 0; geometryIndex < multiCurve->numGeometries(); ++geometryIndex )
1047 const QgsLineString *line = qgsgeometry_cast<const QgsLineString *>( multiCurve->geometryN( geometryIndex ) );
1050 const QgsCurve *curve = qgsgeometry_cast<const QgsCurve *>( multiCurve->geometryN( geometryIndex ) );
1058 QMap< int, QVector< QPair< double, QgsPoint > > >pointMap;
1059 for (
int splitPointIndex = 0; splitPointIndex < splitPoints->numGeometries(); ++splitPointIndex )
1061 const QgsPoint *intersectionPoint = splitPoints->pointN( splitPointIndex );
1067 line->
closestSegment( *intersectionPoint, segmentPoint2D, nextVertex );
1083 const QPair< double, QgsPoint > pair = qMakePair(
distance, *correctSegmentPoint.get() );
1084 if ( pointMap.contains( nextVertex.
vertex - 1 ) )
1085 pointMap[ nextVertex.
vertex - 1 ].append( pair );
1087 pointMap[ nextVertex.
vertex - 1 ] = QVector< QPair< double, QgsPoint > >() << pair;
1092 for (
auto &p : pointMap )
1094 std::sort( p.begin(), p.end(), [](
const QPair< double, QgsPoint > &a,
const QPair< double, QgsPoint > &b ) { return a.first < b.first; } );
1101 for (
int vertexIndex = 0; vertexIndex < nVertices; ++vertexIndex )
1105 if ( pointMap.contains( vertexIndex ) )
1108 for (
int k = 0; k < pointMap[ vertexIndex ].size(); ++k )
1110 splitPoint = pointMap[ vertexIndex ][k].second;
1111 if ( splitPoint == currentPoint )
1117 else if ( splitPoint == line->
pointN( vertexIndex + 1 ) )
1136 return asGeos( &lines, mPrecision );
1141 Q_UNUSED( skipIntersectionCheck )
1148 geos::unique_ptr intersectGeom( GEOSIntersection_r( geosinit()->ctxt, splitLine, mGeos.get() ) );
1149 if ( !intersectGeom || GEOSisEmpty_r( geosinit()->ctxt, intersectGeom.get() ) )
1153 int linearIntersect = GEOSRelatePattern_r( geosinit()->ctxt, mGeos.get(), splitLine,
"1********" );
1154 if ( linearIntersect > 0 )
1158 splitGeom = linePointDifference( intersectGeom.get() );
1163 QVector<GEOSGeometry *> lineGeoms;
1165 int splitType = GEOSGeomTypeId_r( geosinit()->ctxt, splitGeom.get() );
1166 if ( splitType == GEOS_MULTILINESTRING )
1168 int nGeoms = GEOSGetNumGeometries_r( geosinit()->ctxt, splitGeom.get() );
1169 lineGeoms.reserve( nGeoms );
1170 for (
int i = 0; i < nGeoms; ++i )
1171 lineGeoms << GEOSGeom_clone_r( geosinit()->ctxt, GEOSGetGeometryN_r( geosinit()->ctxt, splitGeom.get(), i ) );
1176 lineGeoms << GEOSGeom_clone_r( geosinit()->ctxt, splitGeom.get() );
1179 mergeGeometriesMultiTypeSplit( lineGeoms );
1181 for (
int i = 0; i < lineGeoms.size(); ++i )
1184 GEOSGeom_destroy_r( geosinit()->ctxt, lineGeoms[i] );
1200 if ( !mGeosPrepared )
1204 if ( !skipIntersectionCheck && !GEOSPreparedIntersects_r( geosinit()->ctxt, mGeosPrepared.get(), splitLine ) )
1209 if ( !nodedGeometry )
1213 geos::unique_ptr polygons( GEOSPolygonize_r( geosinit()->ctxt, &noded, 1 ) );
1214 if ( !polygons || numberOfGeometries( polygons.get() ) == 0 )
1221 QVector<GEOSGeometry *> testedGeometries;
1226 for (
int i = 0; i < numberOfGeometries( polygons.get() ); i++ )
1228 const GEOSGeometry *polygon = GEOSGetGeometryN_r( geosinit()->ctxt, polygons.get(), i );
1232 testedGeometries << GEOSGeom_clone_r( geosinit()->ctxt, polygon );
1235 int nGeometriesThis = numberOfGeometries( mGeos.get() );
1236 if ( testedGeometries.empty() || testedGeometries.size() == nGeometriesThis )
1239 for (
int i = 0; i < testedGeometries.size(); ++i )
1241 GEOSGeom_destroy_r( geosinit()->ctxt, testedGeometries[i] );
1250 mergeGeometriesMultiTypeSplit( testedGeometries );
1253 for ( i = 0; i < testedGeometries.size() && GEOSisValid_r( geosinit()->ctxt, testedGeometries[i] ); ++i )
1256 if ( i < testedGeometries.size() )
1258 for ( i = 0; i < testedGeometries.size(); ++i )
1259 GEOSGeom_destroy_r( geosinit()->ctxt, testedGeometries[i] );
1264 for ( i = 0; i < testedGeometries.size(); ++i )
1267 GEOSGeom_destroy_r( geosinit()->ctxt, testedGeometries[i] );
1275 if ( !splitLine || !geom )
1279 if ( GEOSGeomTypeId_r( geosinit()->ctxt, geom ) == GEOS_POLYGON || GEOSGeomTypeId_r( geosinit()->ctxt, geom ) == GEOS_MULTIPOLYGON )
1280 geometryBoundary.reset( GEOSBoundary_r( geosinit()->ctxt, geom ) );
1282 geometryBoundary.reset( GEOSGeom_clone_r( geosinit()->ctxt, geom ) );
1284 geos::unique_ptr splitLineClone( GEOSGeom_clone_r( geosinit()->ctxt, splitLine ) );
1285 geos::unique_ptr unionGeometry( GEOSUnion_r( geosinit()->ctxt, splitLineClone.get(), geometryBoundary.get() ) );
1287 return unionGeometry;
1290int QgsGeos::mergeGeometriesMultiTypeSplit( QVector<GEOSGeometry *> &splitResult )
const
1296 int type = GEOSGeomTypeId_r( geosinit()->ctxt, mGeos.get() );
1297 if ( type != GEOS_GEOMETRYCOLLECTION &&
1298 type != GEOS_MULTILINESTRING &&
1299 type != GEOS_MULTIPOLYGON &&
1300 type != GEOS_MULTIPOINT )
1303 QVector<GEOSGeometry *> copyList = splitResult;
1304 splitResult.clear();
1307 QVector<GEOSGeometry *> unionGeom;
1309 for (
int i = 0; i < copyList.size(); ++i )
1312 bool isPart =
false;
1313 for (
int j = 0; j < GEOSGetNumGeometries_r( geosinit()->ctxt, mGeos.get() ); j++ )
1315 if ( GEOSEquals_r( geosinit()->ctxt, copyList[i], GEOSGetGeometryN_r( geosinit()->ctxt, mGeos.get(), j ) ) )
1324 unionGeom << copyList[i];
1328 QVector<GEOSGeometry *> geomVector;
1329 geomVector << copyList[i];
1331 if ( type == GEOS_MULTILINESTRING )
1332 splitResult << createGeosCollection( GEOS_MULTILINESTRING, geomVector ).release();
1333 else if ( type == GEOS_MULTIPOLYGON )
1334 splitResult << createGeosCollection( GEOS_MULTIPOLYGON, geomVector ).release();
1336 GEOSGeom_destroy_r( geosinit()->ctxt, copyList[i] );
1341 if ( !unionGeom.isEmpty() )
1343 if ( type == GEOS_MULTILINESTRING )
1344 splitResult << createGeosCollection( GEOS_MULTILINESTRING, unionGeom ).release();
1345 else if ( type == GEOS_MULTIPOLYGON )
1346 splitResult << createGeosCollection( GEOS_MULTIPOLYGON, unionGeom ).release();
1356geos::unique_ptr QgsGeos::createGeosCollection(
int typeId,
const QVector<GEOSGeometry *> &geoms )
1358 int nNullGeoms = geoms.count(
nullptr );
1359 int nNotNullGeoms = geoms.size() - nNullGeoms;
1368 QVector<GEOSGeometry *>::const_iterator geomIt = geoms.constBegin();
1369 for ( ; geomIt != geoms.constEnd(); ++geomIt )
1373 if ( GEOSisEmpty_r( geosinit()->ctxt, *geomIt ) )
1378 GEOSGeom_destroy_r( geosinit()->ctxt, *geomIt );
1382 geomarr[i] = *geomIt;
1391 geom.reset( GEOSGeom_createCollection_r( geosinit()->ctxt, typeId, geomarr, nNotNullGeoms ) );
1393 catch ( GEOSException & )
1409 int nCoordDims = GEOSGeom_getCoordinateDimension_r( geosinit()->ctxt,
geos );
1410 int nDims = GEOSGeom_getDimensions_r( geosinit()->ctxt,
geos );
1411 bool hasZ = ( nCoordDims == 3 );
1412 bool hasM = ( ( nDims - nCoordDims ) == 1 );
1414 switch ( GEOSGeomTypeId_r( geosinit()->ctxt,
geos ) )
1418 if ( GEOSisEmpty_r( geosinit()->ctxt,
geos ) )
1421 const GEOSCoordSequence *cs = GEOSGeom_getCoordSeq_r( geosinit()->ctxt,
geos );
1422 unsigned int nPoints = 0;
1423 GEOSCoordSeq_getSize_r( geosinit()->ctxt, cs, &nPoints );
1424 return nPoints > 0 ? std::unique_ptr<QgsAbstractGeometry>(
coordSeqPoint( cs, 0, hasZ, hasM ).clone() ) :
nullptr;
1426 case GEOS_LINESTRING:
1428 return sequenceToLinestring(
geos, hasZ, hasM );
1434 case GEOS_MULTIPOINT:
1436 std::unique_ptr< QgsMultiPoint > multiPoint(
new QgsMultiPoint() );
1437 int nParts = GEOSGetNumGeometries_r( geosinit()->ctxt,
geos );
1438 multiPoint->reserve( nParts );
1439 for (
int i = 0; i < nParts; ++i )
1441 const GEOSCoordSequence *cs = GEOSGeom_getCoordSeq_r( geosinit()->ctxt, GEOSGetGeometryN_r( geosinit()->ctxt,
geos, i ) );
1444 unsigned int nPoints = 0;
1445 GEOSCoordSeq_getSize_r( geosinit()->ctxt, cs, &nPoints );
1447 multiPoint->addGeometry(
coordSeqPoint( cs, 0, hasZ, hasM ).clone() );
1450 return std::move( multiPoint );
1452 case GEOS_MULTILINESTRING:
1455 int nParts = GEOSGetNumGeometries_r( geosinit()->ctxt,
geos );
1456 multiLineString->reserve( nParts );
1457 for (
int i = 0; i < nParts; ++i )
1459 std::unique_ptr< QgsLineString >line( sequenceToLinestring( GEOSGetGeometryN_r( geosinit()->ctxt,
geos, i ), hasZ, hasM ) );
1462 multiLineString->addGeometry( line.release() );
1465 return std::move( multiLineString );
1467 case GEOS_MULTIPOLYGON:
1469 std::unique_ptr< QgsMultiPolygon > multiPolygon(
new QgsMultiPolygon() );
1471 int nParts = GEOSGetNumGeometries_r( geosinit()->ctxt,
geos );
1472 multiPolygon->reserve( nParts );
1473 for (
int i = 0; i < nParts; ++i )
1475 std::unique_ptr< QgsPolygon > poly =
fromGeosPolygon( GEOSGetGeometryN_r( geosinit()->ctxt,
geos, i ) );
1478 multiPolygon->addGeometry( poly.release() );
1481 return std::move( multiPolygon );
1483 case GEOS_GEOMETRYCOLLECTION:
1486 int nParts = GEOSGetNumGeometries_r( geosinit()->ctxt,
geos );
1487 geomCollection->reserve( nParts );
1488 for (
int i = 0; i < nParts; ++i )
1490 std::unique_ptr< QgsAbstractGeometry > geom(
fromGeos( GEOSGetGeometryN_r( geosinit()->ctxt,
geos, i ) ) );
1493 geomCollection->addGeometry( geom.release() );
1496 return std::move( geomCollection );
1504 if ( GEOSGeomTypeId_r( geosinit()->ctxt,
geos ) != GEOS_POLYGON )
1509 int nCoordDims = GEOSGeom_getCoordinateDimension_r( geosinit()->ctxt,
geos );
1510 int nDims = GEOSGeom_getDimensions_r( geosinit()->ctxt,
geos );
1511 bool hasZ = ( nCoordDims == 3 );
1512 bool hasM = ( ( nDims - nCoordDims ) == 1 );
1514 std::unique_ptr< QgsPolygon > polygon(
new QgsPolygon() );
1516 const GEOSGeometry *ring = GEOSGetExteriorRing_r( geosinit()->ctxt,
geos );
1519 polygon->setExteriorRing( sequenceToLinestring( ring, hasZ, hasM ).release() );
1522 QVector<QgsCurve *> interiorRings;
1523 const int ringCount = GEOSGetNumInteriorRings_r( geosinit()->ctxt,
geos );
1524 interiorRings.reserve( ringCount );
1525 for (
int i = 0; i < ringCount; ++i )
1527 ring = GEOSGetInteriorRingN_r( geosinit()->ctxt,
geos, i );
1530 interiorRings.push_back( sequenceToLinestring( ring, hasZ, hasM ).release() );
1533 polygon->setInteriorRings( interiorRings );
1538std::unique_ptr<QgsLineString> QgsGeos::sequenceToLinestring(
const GEOSGeometry *
geos,
bool hasZ,
bool hasM )
1540 const GEOSCoordSequence *cs = GEOSGeom_getCoordSeq_r( geosinit()->ctxt,
geos );
1542 unsigned int nPoints;
1543 GEOSCoordSeq_getSize_r( geosinit()->ctxt, cs, &nPoints );
1545 QVector< double > xOut( nPoints );
1546 QVector< double > yOut( nPoints );
1547 QVector< double > zOut;
1549 zOut.resize( nPoints );
1550 QVector< double > mOut;
1552 mOut.resize( nPoints );
1554 double *x = xOut.data();
1555 double *y = yOut.data();
1556 double *z = zOut.data();
1557 double *m = mOut.data();
1559#if GEOS_VERSION_MAJOR>3 || ( GEOS_VERSION_MAJOR == 3 && GEOS_VERSION_MINOR>=10 )
1560 GEOSCoordSeq_copyToArrays_r( geosinit()->ctxt, cs, x, y, hasZ ? z : nullptr, hasM ? m : nullptr );
1562 for (
unsigned int i = 0; i < nPoints; ++i )
1565 GEOSCoordSeq_getXYZ_r( geosinit()->ctxt, cs, i, x++, y++, z++ );
1567 GEOSCoordSeq_getXY_r( geosinit()->ctxt, cs, i, x++, y++ );
1570 GEOSCoordSeq_getOrdinate_r( geosinit()->ctxt, cs, i, 3, m++ );
1574 std::unique_ptr< QgsLineString > line(
new QgsLineString( xOut, yOut, zOut, mOut ) );
1583 int geometryType = GEOSGeomTypeId_r( geosinit()->ctxt, g );
1584 if ( geometryType == GEOS_POINT || geometryType == GEOS_LINESTRING || geometryType == GEOS_LINEARRING
1585 || geometryType == GEOS_POLYGON )
1589 return GEOSGetNumGeometries_r( geosinit()->ctxt, g );
1603 GEOSCoordSeq_getXYZ_r( geosinit()->ctxt, cs, i, &x, &y, &z );
1605 GEOSCoordSeq_getXY_r( geosinit()->ctxt, cs, i, &x, &y );
1608 GEOSCoordSeq_getOrdinate_r( geosinit()->ctxt, cs, i, 3, &m );
1644 int geosType = GEOS_GEOMETRYCOLLECTION;
1651 geosType = GEOS_MULTIPOINT;
1655 geosType = GEOS_MULTILINESTRING;
1659 geosType = GEOS_MULTIPOLYGON;
1674 QVector< GEOSGeometry * > geomVector(
c->numGeometries() );
1675 for (
int i = 0; i <
c->numGeometries(); ++i )
1679 return createGeosCollection( geosType, geomVector );
1686 return createGeosPoint(
static_cast<const QgsPoint *
>( geom ), coordDims,
precision );
1704 if ( !mGeos || !geom )
1715 const double gridSize = parameters.
gridSize();
1722 case OverlayIntersection:
1725 opGeom.reset( GEOSIntersectionPrec_r( geosinit()->ctxt, mGeos.get(), geosGeom.get(), gridSize ) );
1729 opGeom.reset( GEOSIntersection_r( geosinit()->ctxt, mGeos.get(), geosGeom.get() ) );
1733 case OverlayDifference:
1736 opGeom.reset( GEOSDifferencePrec_r( geosinit()->ctxt, mGeos.get(), geosGeom.get(), gridSize ) );
1740 opGeom.reset( GEOSDifference_r( geosinit()->ctxt, mGeos.get(), geosGeom.get() ) );
1749 unionGeometry.reset( GEOSUnionPrec_r( geosinit()->ctxt, mGeos.get(), geosGeom.get(), gridSize ) );
1753 unionGeometry.reset( GEOSUnion_r( geosinit()->ctxt, mGeos.get(), geosGeom.get() ) );
1756 if ( unionGeometry && GEOSGeomTypeId_r( geosinit()->ctxt, unionGeometry.get() ) == GEOS_MULTILINESTRING )
1758 geos::unique_ptr mergedLines( GEOSLineMerge_r( geosinit()->ctxt, unionGeometry.get() ) );
1761 unionGeometry = std::move( mergedLines );
1765 opGeom = std::move( unionGeometry );
1769 case OverlaySymDifference:
1772 opGeom.reset( GEOSSymDifferencePrec_r( geosinit()->ctxt, mGeos.get(), geosGeom.get(), gridSize ) );
1776 opGeom.reset( GEOSSymDifference_r( geosinit()->ctxt, mGeos.get(), geosGeom.get() ) );
1782 catch ( GEOSException &e )
1784 logError( QStringLiteral(
"GEOS" ), e.what() );
1787 *errorMsg = e.what();
1793bool QgsGeos::relation(
const QgsAbstractGeometry *geom, Relation r, QString *errorMsg )
const
1795 if ( !mGeos || !geom )
1806 bool result =
false;
1809 if ( mGeosPrepared )
1813 case RelationIntersects:
1814 result = ( GEOSPreparedIntersects_r( geosinit()->ctxt, mGeosPrepared.get(), geosGeom.get() ) == 1 );
1816 case RelationTouches:
1817 result = ( GEOSPreparedTouches_r( geosinit()->ctxt, mGeosPrepared.get(), geosGeom.get() ) == 1 );
1819 case RelationCrosses:
1820 result = ( GEOSPreparedCrosses_r( geosinit()->ctxt, mGeosPrepared.get(), geosGeom.get() ) == 1 );
1822 case RelationWithin:
1823 result = ( GEOSPreparedWithin_r( geosinit()->ctxt, mGeosPrepared.get(), geosGeom.get() ) == 1 );
1825 case RelationContains:
1826 result = ( GEOSPreparedContains_r( geosinit()->ctxt, mGeosPrepared.get(), geosGeom.get() ) == 1 );
1828 case RelationDisjoint:
1829 result = ( GEOSPreparedDisjoint_r( geosinit()->ctxt, mGeosPrepared.get(), geosGeom.get() ) == 1 );
1831 case RelationOverlaps:
1832 result = ( GEOSPreparedOverlaps_r( geosinit()->ctxt, mGeosPrepared.get(), geosGeom.get() ) == 1 );
1840 case RelationIntersects:
1841 result = ( GEOSIntersects_r( geosinit()->ctxt, mGeos.get(), geosGeom.get() ) == 1 );
1843 case RelationTouches:
1844 result = ( GEOSTouches_r( geosinit()->ctxt, mGeos.get(), geosGeom.get() ) == 1 );
1846 case RelationCrosses:
1847 result = ( GEOSCrosses_r( geosinit()->ctxt, mGeos.get(), geosGeom.get() ) == 1 );
1849 case RelationWithin:
1850 result = ( GEOSWithin_r( geosinit()->ctxt, mGeos.get(), geosGeom.get() ) == 1 );
1852 case RelationContains:
1853 result = ( GEOSContains_r( geosinit()->ctxt, mGeos.get(), geosGeom.get() ) == 1 );
1855 case RelationDisjoint:
1856 result = ( GEOSDisjoint_r( geosinit()->ctxt, mGeos.get(), geosGeom.get() ) == 1 );
1858 case RelationOverlaps:
1859 result = ( GEOSOverlaps_r( geosinit()->ctxt, mGeos.get(), geosGeom.get() ) == 1 );
1863 catch ( GEOSException &e )
1865 logError( QStringLiteral(
"GEOS" ), e.what() );
1868 *errorMsg = e.what();
1886 geos.reset( GEOSBuffer_r( geosinit()->ctxt, mGeos.get(),
distance, segments ) );
1902 geos.reset( GEOSBufferWithStyle_r( geosinit()->ctxt, mGeos.get(),
distance, segments,
static_cast< int >( endCapStyle ),
static_cast< int >( joinStyle ), miterLimit ) );
1917 geos.reset( GEOSTopologyPreserveSimplify_r( geosinit()->ctxt, mGeos.get(), tolerance ) );
1932 geos.reset( GEOSInterpolate_r( geosinit()->ctxt, mGeos.get(),
distance ) );
1951 geos.reset( GEOSGetCentroid_r( geosinit()->ctxt, mGeos.get() ) );
1956 GEOSGeomGetX_r( geosinit()->ctxt,
geos.get(), &x );
1957 GEOSGeomGetY_r( geosinit()->ctxt,
geos.get(), &y );
1973 geos.reset( GEOSEnvelope_r( geosinit()->ctxt, mGeos.get() ) );
1992 geos.reset( GEOSPointOnSurface_r( geosinit()->ctxt, mGeos.get() ) );
1994 if ( !
geos || GEOSisEmpty_r( geosinit()->ctxt,
geos.get() ) != 0 )
1999 GEOSGeomGetX_r( geosinit()->ctxt,
geos.get(), &x );
2000 GEOSGeomGetY_r( geosinit()->ctxt,
geos.get(), &y );
2016 geos::unique_ptr cHull( GEOSConvexHull_r( geosinit()->ctxt, mGeos.get() ) );
2017 std::unique_ptr< QgsAbstractGeometry > cHullGeom =
fromGeos( cHull.get() );
2018 return cHullGeom.release();
2025#if GEOS_VERSION_MAJOR==3 && GEOS_VERSION_MINOR<11
2027 ( void )targetPercent;
2029 throw QgsNotSupportedException( QObject::tr(
"Calculating concaveHull requires a QGIS build based on GEOS 3.11 or later" ) );
2040 return concaveHullGeom.release();
2057 char res = GEOSisValidDetail_r( geosinit()->ctxt, mGeos.get(), allowSelfTouchingHoles ? GEOSVALID_ALLOW_SELFTOUCHING_RING_FORMING_HOLE : 0, &r, &g1 );
2058 const bool invalid = res != 1;
2063 error = QString( r );
2064 GEOSFree_r( geosinit()->ctxt, r );
2067 if ( invalid && errorMsg )
2071 if ( translatedErrors.empty() )
2074 translatedErrors.insert( QStringLiteral(
"topology validation error" ), QObject::tr(
"Topology validation error",
"GEOS Error" ) );
2075 translatedErrors.insert( QStringLiteral(
"repeated point" ), QObject::tr(
"Repeated point",
"GEOS Error" ) );
2076 translatedErrors.insert( QStringLiteral(
"hole lies outside shell" ), QObject::tr(
"Hole lies outside shell",
"GEOS Error" ) );
2077 translatedErrors.insert( QStringLiteral(
"holes are nested" ), QObject::tr(
"Holes are nested",
"GEOS Error" ) );
2078 translatedErrors.insert( QStringLiteral(
"interior is disconnected" ), QObject::tr(
"Interior is disconnected",
"GEOS Error" ) );
2079 translatedErrors.insert( QStringLiteral(
"self-intersection" ), QObject::tr(
"Self-intersection",
"GEOS Error" ) );
2080 translatedErrors.insert( QStringLiteral(
"ring self-intersection" ), QObject::tr(
"Ring self-intersection",
"GEOS Error" ) );
2081 translatedErrors.insert( QStringLiteral(
"nested shells" ), QObject::tr(
"Nested shells",
"GEOS Error" ) );
2082 translatedErrors.insert( QStringLiteral(
"duplicate rings" ), QObject::tr(
"Duplicate rings",
"GEOS Error" ) );
2083 translatedErrors.insert( QStringLiteral(
"too few points in geometry component" ), QObject::tr(
"Too few points in geometry component",
"GEOS Error" ) );
2084 translatedErrors.insert( QStringLiteral(
"invalid coordinate" ), QObject::tr(
"Invalid coordinate",
"GEOS Error" ) );
2085 translatedErrors.insert( QStringLiteral(
"ring is not closed" ), QObject::tr(
"Ring is not closed",
"GEOS Error" ) );
2088 *errorMsg = translatedErrors.value( error.toLower(), error );
2090 if ( g1 && errorLoc )
2096 GEOSGeom_destroy_r( geosinit()->ctxt, g1 );
2106 if ( !mGeos || !geom )
2118 bool equal = GEOSEquals_r( geosinit()->ctxt, mGeos.get(), geosGeom.get() );
2133 return GEOSisEmpty_r( geosinit()->ctxt, mGeos.get() );
2147 return GEOSisSimple_r( geosinit()->ctxt, mGeos.get() );
2152GEOSCoordSequence *QgsGeos::createCoordinateSequence(
const QgsCurve *curve,
double precision,
bool forceClose )
2154 GEOSContextHandle_t ctxt = geosinit()->ctxt;
2156 std::unique_ptr< QgsLineString > segmentized;
2157 const QgsLineString *line = qgsgeometry_cast<const QgsLineString *>( curve );
2162 line = segmentized.get();
2169 GEOSCoordSequence *coordSeq =
nullptr;
2171 const int numPoints = line->
numPoints();
2173 const bool hasZ = line->
is3D();
2175#if GEOS_VERSION_MAJOR>3 || ( GEOS_VERSION_MAJOR == 3 && GEOS_VERSION_MINOR>=10 )
2178 if ( !forceClose || ( line->
pointN( 0 ) == line->
pointN( numPoints - 1 ) ) )
2183 coordSeq = GEOSCoordSeq_copyFromArrays_r( ctxt, line->
xData(), line->
yData(), line->
zData(),
nullptr, numPoints );
2186 QgsDebugError( QStringLiteral(
"GEOS Exception: Could not create coordinate sequence for %1 points" ).arg( numPoints ) );
2194 QVector< double > x = line->
xVector();
2195 if ( numPoints > 0 )
2196 x.append( x.at( 0 ) );
2197 QVector< double > y = line->
yVector();
2198 if ( numPoints > 0 )
2199 y.append( y.at( 0 ) );
2200 QVector< double > z = line->
zVector();
2201 if ( hasZ && numPoints > 0 )
2202 z.append( z.at( 0 ) );
2205 coordSeq = GEOSCoordSeq_copyFromArrays_r( ctxt, x.constData(), y.constData(), !hasZ ?
nullptr : z.constData(), nullptr, numPoints + 1 );
2208 QgsDebugError( QStringLiteral(
"GEOS Exception: Could not create closed coordinate sequence for %1 points" ).arg( numPoints + 1 ) );
2219 const bool hasM =
false;
2230 int numOutPoints = numPoints;
2231 if ( forceClose && ( line->
pointN( 0 ) != line->
pointN( numPoints - 1 ) ) )
2238 coordSeq = GEOSCoordSeq_create_r( ctxt, numOutPoints, coordDims );
2241 QgsDebugError( QStringLiteral(
"GEOS Exception: Could not create coordinate sequence for %1 points in %2 dimensions" ).arg( numPoints ).arg( coordDims ) );
2245 const double *xData = line->
xData();
2246 const double *yData = line->
yData();
2247 const double *zData = hasZ ? line->
zData() :
nullptr;
2248 const double *mData = hasM ? line->
mData() :
nullptr;
2252 for (
int i = 0; i < numOutPoints; ++i )
2254 if ( i >= numPoints )
2257 xData = line->
xData();
2258 yData = line->
yData();
2259 zData = hasZ ? line->
zData() :
nullptr;
2260 mData = hasM ? line->
mData() :
nullptr;
2272 GEOSCoordSeq_setOrdinate_r( ctxt, coordSeq, i, 3, *mData++ );
2278 for (
int i = 0; i < numOutPoints; ++i )
2280 if ( i >= numPoints )
2283 xData = line->
xData();
2284 yData = line->
yData();
2285 zData = hasZ ? line->
zData() :
nullptr;
2286 mData = hasM ? line->
mData() :
nullptr;
2290 GEOSCoordSeq_setXYZ_r( ctxt, coordSeq, i, *xData++, *yData++, *zData++ );
2294 GEOSCoordSeq_setXY_r( ctxt, coordSeq, i, *xData++, *yData++ );
2298 GEOSCoordSeq_setOrdinate_r( ctxt, coordSeq, i, 3, *mData++ );
2310 const QgsPoint *pt = qgsgeometry_cast<const QgsPoint *>( point );
2317geos::unique_ptr QgsGeos::createGeosPointXY(
double x,
double y,
bool hasZ,
double z,
bool hasM,
double m,
int coordDims,
double precision )
2325 if ( coordDims == 2 )
2331 geosPoint.reset( GEOSGeom_createPointFromXY_r( geosinit()->ctxt, x, y ) );
2335 GEOSCoordSequence *coordSeq = GEOSCoordSeq_create_r( geosinit()->ctxt, 1, coordDims );
2338 QgsDebugError( QStringLiteral(
"GEOS Exception: Could not create coordinate sequence for point with %1 dimensions" ).arg( coordDims ) );
2343 GEOSCoordSeq_setX_r( geosinit()->ctxt, coordSeq, 0, std::round( x /
precision ) *
precision );
2344 GEOSCoordSeq_setY_r( geosinit()->ctxt, coordSeq, 0, std::round( y /
precision ) *
precision );
2347 GEOSCoordSeq_setOrdinate_r( geosinit()->ctxt, coordSeq, 0, 2, std::round( z /
precision ) *
precision );
2352 GEOSCoordSeq_setX_r( geosinit()->ctxt, coordSeq, 0, x );
2353 GEOSCoordSeq_setY_r( geosinit()->ctxt, coordSeq, 0, y );
2356 GEOSCoordSeq_setOrdinate_r( geosinit()->ctxt, coordSeq, 0, 2, z );
2362 GEOSCoordSeq_setOrdinate_r( geosinit()->ctxt, coordSeq, 0, 3, m );
2365 geosPoint.reset( GEOSGeom_createPoint_r( geosinit()->ctxt, coordSeq ) );
2373 const QgsCurve *
c = qgsgeometry_cast<const QgsCurve *>( curve );
2377 GEOSCoordSequence *coordSeq = createCoordinateSequence(
c,
precision );
2384 geosGeom.reset( GEOSGeom_createLineString_r( geosinit()->ctxt, coordSeq ) );
2392 const QgsCurvePolygon *polygon = qgsgeometry_cast<const QgsCurvePolygon *>( poly );
2397 if ( !exteriorRing )
2405 geos::unique_ptr exteriorRingGeos( GEOSGeom_createLinearRing_r( geosinit()->ctxt, createCoordinateSequence( exteriorRing,
precision,
true ) ) );
2414 for (
int i = 0; i < nHoles; ++i )
2417 holes[i] = GEOSGeom_createLinearRing_r( geosinit()->ctxt, createCoordinateSequence( interiorRing,
precision,
true ) );
2419 geosPolygon.reset( GEOSGeom_createPolygon_r( geosinit()->ctxt, exteriorRingGeos.release(), holes, nHoles ) );
2439 offset.reset( GEOSOffsetCurve_r( geosinit()->ctxt, mGeos.get(),
distance, segments,
static_cast< int >( joinStyle ), miterLimit ) );
2442 std::unique_ptr< QgsAbstractGeometry > offsetGeom =
fromGeos( offset.get() );
2443 return offsetGeom.release();
2457 GEOSBufferParams_setSingleSided_r( geosinit()->ctxt, bp.get(), 1 );
2458 GEOSBufferParams_setQuadrantSegments_r( geosinit()->ctxt, bp.get(), segments );
2459 GEOSBufferParams_setJoinStyle_r( geosinit()->ctxt, bp.get(),
static_cast< int >( joinStyle ) );
2460 GEOSBufferParams_setMitreLimit_r( geosinit()->ctxt, bp.get(), miterLimit );
2466 geos.reset( GEOSBufferWithParams_r( geosinit()->ctxt, mGeos.get(), bp.get(),
distance ) );
2482 geos.reset( GEOSMaximumInscribedCircle_r( geosinit()->ctxt, mGeos.get(), tolerance ) );
2500 boundaryGeos =
asGeos( boundary );
2502 geos.reset( GEOSLargestEmptyCircle_r( geosinit()->ctxt, mGeos.get(), boundaryGeos.get(), tolerance ) );
2518 geos.reset( GEOSMinimumWidth_r( geosinit()->ctxt, mGeos.get() ) );
2528 return std::numeric_limits< double >::quiet_NaN();
2535 if ( GEOSMinimumClearance_r( geosinit()->ctxt, mGeos.get(), &res ) != 0 )
2536 return std::numeric_limits< double >::quiet_NaN();
2552 geos.reset( GEOSMinimumClearanceLine_r( geosinit()->ctxt, mGeos.get() ) );
2568 geos.reset( GEOSNode_r( geosinit()->ctxt, mGeos.get() ) );
2576 if ( !mGeos || !other )
2588 geos.reset( GEOSSharedPaths_r( geosinit()->ctxt, mGeos.get(), otherGeos.get() ) );
2608 geos::unique_ptr reshapeLineGeos = createGeosLinestring( &reshapeWithLine, mPrecision );
2611 int numGeoms = GEOSGetNumGeometries_r( geosinit()->ctxt, mGeos.get() );
2612 if ( numGeoms == -1 )
2621 bool isMultiGeom =
false;
2622 int geosTypeId = GEOSGeomTypeId_r( geosinit()->ctxt, mGeos.get() );
2623 if ( geosTypeId == GEOS_MULTILINESTRING || geosTypeId == GEOS_MULTIPOLYGON )
2633 reshapedGeometry = reshapeLine( mGeos.get(), reshapeLineGeos.get(), mPrecision );
2637 reshapedGeometry = reshapePolygon( mGeos.get(), reshapeLineGeos.get(), mPrecision );
2642 std::unique_ptr< QgsAbstractGeometry > reshapeResult =
fromGeos( reshapedGeometry.get() );
2643 return reshapeResult;
2650 bool reshapeTookPlace =
false;
2655 for (
int i = 0; i < numGeoms; ++i )
2658 currentReshapeGeometry = reshapeLine( GEOSGetGeometryN_r( geosinit()->ctxt, mGeos.get(), i ), reshapeLineGeos.get(), mPrecision );
2660 currentReshapeGeometry = reshapePolygon( GEOSGetGeometryN_r( geosinit()->ctxt, mGeos.get(), i ), reshapeLineGeos.get(), mPrecision );
2662 if ( currentReshapeGeometry )
2664 newGeoms[i] = currentReshapeGeometry.release();
2665 reshapeTookPlace =
true;
2669 newGeoms[i] = GEOSGeom_clone_r( geosinit()->ctxt, GEOSGetGeometryN_r( geosinit()->ctxt, mGeos.get(), i ) );
2676 newMultiGeom.reset( GEOSGeom_createCollection_r( geosinit()->ctxt, GEOS_MULTILINESTRING, newGeoms, numGeoms ) );
2680 newMultiGeom.reset( GEOSGeom_createCollection_r( geosinit()->ctxt, GEOS_MULTIPOLYGON, newGeoms, numGeoms ) );
2684 if ( !newMultiGeom )
2690 if ( reshapeTookPlace )
2694 std::unique_ptr< QgsAbstractGeometry > reshapedMultiGeom =
fromGeos( newMultiGeom.get() );
2695 return reshapedMultiGeom;
2717 if ( GEOSGeomTypeId_r( geosinit()->ctxt, mGeos.get() ) != GEOS_MULTILINESTRING )
2723 geos.reset( GEOSLineMerge_r( geosinit()->ctxt, mGeos.get() ) );
2747 if ( mGeosPrepared )
2749 nearestCoord.reset( GEOSPreparedNearestPoints_r( geosinit()->ctxt, mGeosPrepared.get(), otherGeom.get() ) );
2753 nearestCoord.reset( GEOSNearestPoints_r( geosinit()->ctxt, mGeos.get(), otherGeom.get() ) );
2756 ( void )GEOSCoordSeq_getX_r( geosinit()->ctxt, nearestCoord.get(), 0, &nx );
2757 ( void )GEOSCoordSeq_getY_r( geosinit()->ctxt, nearestCoord.get(), 0, &ny );
2759 catch ( GEOSException &e )
2761 logError( QStringLiteral(
"GEOS" ), e.what() );
2764 *errorMsg = e.what();
2774 if ( !mGeos || other.
isEmpty() )
2784 if ( !other || other->
isEmpty() )
2801 if ( !nearestCoord )
2804 *errorMsg = QStringLiteral(
"GEOS returned no nearest points" );
2808 ( void )GEOSCoordSeq_getX_r( geosinit()->ctxt, nearestCoord.get(), 0, &nx1 );
2809 ( void )GEOSCoordSeq_getY_r( geosinit()->ctxt, nearestCoord.get(), 0, &ny1 );
2810 ( void )GEOSCoordSeq_getX_r( geosinit()->ctxt, nearestCoord.get(), 1, &nx2 );
2811 ( void )GEOSCoordSeq_getY_r( geosinit()->ctxt, nearestCoord.get(), 1, &ny2 );
2813 catch ( GEOSException &e )
2815 logError( QStringLiteral(
"GEOS" ), e.what() );
2818 *errorMsg = e.what();
2845 distance = GEOSProject_r( geosinit()->ctxt, mGeos.get(), otherGeom.get() );
2847 catch ( GEOSException &e )
2849 logError( QStringLiteral(
"GEOS" ), e.what() );
2852 *errorMsg = e.what();
2867 geos::unique_ptr point = createGeosPointXY( x, y,
false, 0,
false, 0, 2, 0 );
2874 distance = GEOSProject_r( geosinit()->ctxt, mGeos.get(), point.get() );
2876 catch ( GEOSException &e )
2878 logError( QStringLiteral(
"GEOS" ), e.what() );
2881 *errorMsg = e.what();
2898 lineGeosGeometries[validLines] = l.release();
2905 geos::unique_ptr result( GEOSPolygonize_r( geosinit()->ctxt, lineGeosGeometries, validLines ) );
2906 for (
int i = 0; i < validLines; ++i )
2908 GEOSGeom_destroy_r( geosinit()->ctxt, lineGeosGeometries[i] );
2910 delete[] lineGeosGeometries;
2913 catch ( GEOSException &e )
2917 *errorMsg = e.what();
2919 for (
int i = 0; i < validLines; ++i )
2921 GEOSGeom_destroy_r( geosinit()->ctxt, lineGeosGeometries[i] );
2923 delete[] lineGeosGeometries;
2938 extentGeosGeom =
asGeos( extent, mPrecision );
2939 if ( !extentGeosGeom )
2948 geos.reset( GEOSVoronoiDiagram_r( geosinit()->ctxt, mGeos.get(), extentGeosGeom.get(), tolerance, edgesOnly ) );
2950 if ( !
geos || GEOSisEmpty_r( geosinit()->ctxt,
geos.get() ) != 0 )
2970 geos.reset( GEOSDelaunayTriangulation_r( geosinit()->ctxt, mGeos.get(), tolerance, edgesOnly ) );
2972 if ( !
geos || GEOSisEmpty_r( geosinit()->ctxt,
geos.get() ) != 0 )
2984static bool _linestringEndpoints(
const GEOSGeometry *linestring,
double &x1,
double &y1,
double &x2,
double &y2 )
2986 const GEOSCoordSequence *coordSeq = GEOSGeom_getCoordSeq_r( geosinit()->ctxt, linestring );
2990 unsigned int coordSeqSize;
2991 if ( GEOSCoordSeq_getSize_r( geosinit()->ctxt, coordSeq, &coordSeqSize ) == 0 )
2994 if ( coordSeqSize < 2 )
2997 GEOSCoordSeq_getX_r( geosinit()->ctxt, coordSeq, 0, &x1 );
2998 GEOSCoordSeq_getY_r( geosinit()->ctxt, coordSeq, 0, &y1 );
2999 GEOSCoordSeq_getX_r( geosinit()->ctxt, coordSeq, coordSeqSize - 1, &x2 );
3000 GEOSCoordSeq_getY_r( geosinit()->ctxt, coordSeq, coordSeqSize - 1, &y2 );
3008 double x1, y1, x2, y2;
3009 if ( !_linestringEndpoints( line1, x1, y1, x2, y2 ) )
3012 double rx1, ry1, rx2, ry2;
3013 if ( !_linestringEndpoints( line2, rx1, ry1, rx2, ry2 ) )
3016 bool intersectionAtOrigLineEndpoint =
3017 ( intersectionPoint.
x() == x1 && intersectionPoint.
y() == y1 ) !=
3018 ( intersectionPoint.
x() == x2 && intersectionPoint.
y() == y2 );
3019 bool intersectionAtReshapeLineEndpoint =
3020 ( intersectionPoint.
x() == rx1 && intersectionPoint.
y() == ry1 ) ||
3021 ( intersectionPoint.
x() == rx2 && intersectionPoint.
y() == ry2 );
3024 if ( intersectionAtOrigLineEndpoint && intersectionAtReshapeLineEndpoint )
3028 GEOSGeometry *geoms[2] = { g1.release(), g2.release() };
3029 geos::unique_ptr multiGeom( GEOSGeom_createCollection_r( geosinit()->ctxt, GEOS_MULTILINESTRING, geoms, 2 ) );
3030 geos::unique_ptr res( GEOSLineMerge_r( geosinit()->ctxt, multiGeom.get() ) );
3040 if ( !line || !reshapeLineGeos )
3043 bool atLeastTwoIntersections =
false;
3044 bool oneIntersection =
false;
3050 geos::unique_ptr intersectGeom( GEOSIntersection_r( geosinit()->ctxt, line, reshapeLineGeos ) );
3051 if ( intersectGeom )
3053 const int geomType = GEOSGeomTypeId_r( geosinit()->ctxt, intersectGeom.get() );
3054 atLeastTwoIntersections = ( geomType == GEOS_MULTIPOINT && GEOSGetNumGeometries_r( geosinit()->ctxt, intersectGeom.get() ) > 1 )
3055 || ( geomType == GEOS_GEOMETRYCOLLECTION && GEOSGetNumGeometries_r( geosinit()->ctxt, intersectGeom.get() ) > 0 )
3056 || ( geomType == GEOS_MULTILINESTRING && GEOSGetNumGeometries_r( geosinit()->ctxt, intersectGeom.get() ) > 0 );
3058 if ( GEOSGeomTypeId_r( geosinit()->ctxt, intersectGeom.get() ) == GEOS_POINT )
3060 const GEOSCoordSequence *intersectionCoordSeq = GEOSGeom_getCoordSeq_r( geosinit()->ctxt, intersectGeom.get() );
3062 GEOSCoordSeq_getX_r( geosinit()->ctxt, intersectionCoordSeq, 0, &xi );
3063 GEOSCoordSeq_getY_r( geosinit()->ctxt, intersectionCoordSeq, 0, &yi );
3064 oneIntersection =
true;
3069 catch ( GEOSException & )
3071 atLeastTwoIntersections =
false;
3075 if ( oneIntersection )
3076 return _mergeLinestrings( line, reshapeLineGeos, oneIntersectionPoint );
3078 if ( !atLeastTwoIntersections )
3082 double x1, y1, x2, y2;
3083 if ( !_linestringEndpoints( line, x1, y1, x2, y2 ) )
3089 bool isRing =
false;
3090 if ( GEOSGeomTypeId_r( geosinit()->ctxt, line ) == GEOS_LINEARRING
3091 || GEOSEquals_r( geosinit()->ctxt, beginLineVertex.get(), endLineVertex.get() ) == 1 )
3096 if ( !nodedGeometry )
3102 geos::unique_ptr mergedLines( GEOSLineMerge_r( geosinit()->ctxt, nodedGeometry.get() ) );
3108 int numMergedLines = GEOSGetNumGeometries_r( geosinit()->ctxt, mergedLines.get() );
3109 if ( numMergedLines < 2 )
3111 if ( numMergedLines == 1 )
3113 geos::unique_ptr result( GEOSGeom_clone_r( geosinit()->ctxt, reshapeLineGeos ) );
3120 QVector<GEOSGeometry *> resultLineParts;
3121 QVector<GEOSGeometry *> probableParts;
3123 for (
int i = 0; i < numMergedLines; ++i )
3125 const GEOSGeometry *currentGeom = GEOSGetGeometryN_r( geosinit()->ctxt, mergedLines.get(), i );
3128 bool alreadyAdded =
false;
3130 double bufferDistance = std::pow( 10.0L, geomDigits( currentGeom ) - 11 );
3131 for (
const GEOSGeometry *other : std::as_const( resultLineParts ) )
3133 GEOSHausdorffDistance_r( geosinit()->ctxt, currentGeom, other, &
distance );
3136 alreadyAdded =
true;
3143 const GEOSCoordSequence *currentCoordSeq = GEOSGeom_getCoordSeq_r( geosinit()->ctxt, currentGeom );
3144 unsigned int currentCoordSeqSize;
3145 GEOSCoordSeq_getSize_r( geosinit()->ctxt, currentCoordSeq, ¤tCoordSeqSize );
3146 if ( currentCoordSeqSize < 2 )
3150 double xBegin, xEnd, yBegin, yEnd;
3151 GEOSCoordSeq_getX_r( geosinit()->ctxt, currentCoordSeq, 0, &xBegin );
3152 GEOSCoordSeq_getY_r( geosinit()->ctxt, currentCoordSeq, 0, &yBegin );
3153 GEOSCoordSeq_getX_r( geosinit()->ctxt, currentCoordSeq, currentCoordSeqSize - 1, &xEnd );
3154 GEOSCoordSeq_getY_r( geosinit()->ctxt, currentCoordSeq, currentCoordSeqSize - 1, &yEnd );
3159 int nEndpointsOnOriginalLine = 0;
3160 if ( pointContainedInLine( beginCurrentGeomVertex.get(), line ) == 1 )
3161 nEndpointsOnOriginalLine += 1;
3163 if ( pointContainedInLine( endCurrentGeomVertex.get(), line ) == 1 )
3164 nEndpointsOnOriginalLine += 1;
3167 int nEndpointsSameAsOriginalLine = 0;
3168 if ( GEOSEquals_r( geosinit()->ctxt, beginCurrentGeomVertex.get(), beginLineVertex.get() ) == 1
3169 || GEOSEquals_r( geosinit()->ctxt, beginCurrentGeomVertex.get(), endLineVertex.get() ) == 1 )
3170 nEndpointsSameAsOriginalLine += 1;
3172 if ( GEOSEquals_r( geosinit()->ctxt, endCurrentGeomVertex.get(), beginLineVertex.get() ) == 1
3173 || GEOSEquals_r( geosinit()->ctxt, endCurrentGeomVertex.get(), endLineVertex.get() ) == 1 )
3174 nEndpointsSameAsOriginalLine += 1;
3177 bool currentGeomOverlapsOriginalGeom =
false;
3178 bool currentGeomOverlapsReshapeLine =
false;
3179 if ( lineContainedInLine( currentGeom, line ) == 1 )
3180 currentGeomOverlapsOriginalGeom =
true;
3182 if ( lineContainedInLine( currentGeom, reshapeLineGeos ) == 1 )
3183 currentGeomOverlapsReshapeLine =
true;
3186 if ( !isRing && nEndpointsSameAsOriginalLine == 1 && nEndpointsOnOriginalLine == 2 && currentGeomOverlapsOriginalGeom )
3188 resultLineParts.push_back( GEOSGeom_clone_r( geosinit()->ctxt, currentGeom ) );
3191 else if ( isRing && nEndpointsOnOriginalLine == 2 && currentGeomOverlapsOriginalGeom )
3193 probableParts.push_back( GEOSGeom_clone_r( geosinit()->ctxt, currentGeom ) );
3195 else if ( nEndpointsOnOriginalLine == 2 && !currentGeomOverlapsOriginalGeom )
3197 resultLineParts.push_back( GEOSGeom_clone_r( geosinit()->ctxt, currentGeom ) );
3199 else if ( nEndpointsSameAsOriginalLine == 2 && !currentGeomOverlapsOriginalGeom )
3201 resultLineParts.push_back( GEOSGeom_clone_r( geosinit()->ctxt, currentGeom ) );
3203 else if ( currentGeomOverlapsOriginalGeom && currentGeomOverlapsReshapeLine )
3205 resultLineParts.push_back( GEOSGeom_clone_r( geosinit()->ctxt, currentGeom ) );
3210 if ( isRing && !probableParts.isEmpty() )
3214 double maxLength = -std::numeric_limits<double>::max();
3215 double currentLength = 0;
3216 for (
int i = 0; i < probableParts.size(); ++i )
3218 currentGeom = probableParts.at( i );
3219 GEOSLength_r( geosinit()->ctxt, currentGeom, ¤tLength );
3220 if ( currentLength > maxLength )
3222 maxLength = currentLength;
3223 maxGeom.reset( currentGeom );
3227 GEOSGeom_destroy_r( geosinit()->ctxt, currentGeom );
3230 resultLineParts.push_back( maxGeom.release() );
3234 if ( resultLineParts.empty() )
3237 if ( resultLineParts.size() == 1 )
3239 result.reset( resultLineParts[0] );
3244 for (
int i = 0; i < resultLineParts.size(); ++i )
3246 lineArray[i] = resultLineParts[i];
3250 geos::unique_ptr multiLineGeom( GEOSGeom_createCollection_r( geosinit()->ctxt, GEOS_MULTILINESTRING, lineArray, resultLineParts.size() ) );
3251 delete [] lineArray;
3254 result.reset( GEOSLineMerge_r( geosinit()->ctxt, multiLineGeom.get() ) );
3258 if ( GEOSGeomTypeId_r( geosinit()->ctxt, result.get() ) != GEOS_LINESTRING )
3269 int nIntersections = 0;
3270 int lastIntersectingRing = -2;
3273 int nRings = GEOSGetNumInteriorRings_r( geosinit()->ctxt, polygon );
3278 const GEOSGeometry *outerRing = GEOSGetExteriorRing_r( geosinit()->ctxt, polygon );
3279 if ( GEOSIntersects_r( geosinit()->ctxt, outerRing, reshapeLineGeos ) == 1 )
3282 lastIntersectingRing = -1;
3283 lastIntersectingGeom = outerRing;
3291 for (
int i = 0; i < nRings; ++i )
3293 innerRings[i] = GEOSGetInteriorRingN_r( geosinit()->ctxt, polygon, i );
3294 if ( GEOSIntersects_r( geosinit()->ctxt, innerRings[i], reshapeLineGeos ) == 1 )
3297 lastIntersectingRing = i;
3298 lastIntersectingGeom = innerRings[i];
3302 catch ( GEOSException & )
3307 if ( nIntersections != 1 )
3309 delete [] innerRings;
3315 if ( !reshapeResult )
3317 delete [] innerRings;
3323 const GEOSCoordSequence *reshapeSequence = GEOSGeom_getCoordSeq_r( geosinit()->ctxt, reshapeResult.get() );
3324 GEOSCoordSequence *newCoordSequence = GEOSCoordSeq_clone_r( geosinit()->ctxt, reshapeSequence );
3326 reshapeResult.reset();
3328 newRing = GEOSGeom_createLinearRing_r( geosinit()->ctxt, newCoordSequence );
3331 delete [] innerRings;
3336 if ( lastIntersectingRing == -1 )
3337 newOuterRing = newRing;
3339 newOuterRing = GEOSGeom_clone_r( geosinit()->ctxt, outerRing );
3342 QVector<GEOSGeometry *> ringList;
3345 GEOSGeometry *outerRingPoly = GEOSGeom_createPolygon_r( geosinit()->ctxt, GEOSGeom_clone_r( geosinit()->ctxt, newOuterRing ),
nullptr, 0 );
3346 if ( outerRingPoly )
3348 ringList.reserve( nRings );
3350 for (
int i = 0; i < nRings; ++i )
3352 if ( lastIntersectingRing == i )
3353 currentRing = newRing;
3355 currentRing = GEOSGeom_clone_r( geosinit()->ctxt, innerRings[i] );
3358 if ( GEOSContains_r( geosinit()->ctxt, outerRingPoly, currentRing ) == 1 )
3359 ringList.push_back( currentRing );
3361 GEOSGeom_destroy_r( geosinit()->ctxt, currentRing );
3364 GEOSGeom_destroy_r( geosinit()->ctxt, outerRingPoly );
3368 for (
int i = 0; i < ringList.size(); ++i )
3369 newInnerRings[i] = ringList.at( i );
3371 delete [] innerRings;
3373 geos::unique_ptr reshapedPolygon( GEOSGeom_createPolygon_r( geosinit()->ctxt, newOuterRing, newInnerRings, ringList.size() ) );
3374 delete[] newInnerRings;
3376 return reshapedPolygon;
3381 if ( !line1 || !line2 )
3386 double bufferDistance = std::pow( 10.0L, geomDigits( line2 ) - 11 );
3392 geos::unique_ptr intersectionGeom( GEOSIntersection_r( geosinit()->ctxt, bufferGeom.get(), line1 ) );
3395 double intersectGeomLength;
3398 GEOSLength_r( geosinit()->ctxt, intersectionGeom.get(), &intersectGeomLength );
3399 GEOSLength_r( geosinit()->ctxt, line1, &line1Length );
3401 double intersectRatio = line1Length / intersectGeomLength;
3402 if ( intersectRatio > 0.9 && intersectRatio < 1.1 )
3410 if ( !point || !line )
3413 double bufferDistance = std::pow( 10.0L, geomDigits( line ) - 11 );
3415 geos::unique_ptr lineBuffer( GEOSBuffer_r( geosinit()->ctxt, line, bufferDistance, 8 ) );
3419 bool contained =
false;
3420 if ( GEOSContains_r( geosinit()->ctxt, lineBuffer.get(), point ) == 1 )
3432 const GEOSGeometry *bBoxRing = GEOSGetExteriorRing_r( geosinit()->ctxt, bbox.get() );
3436 const GEOSCoordSequence *bBoxCoordSeq = GEOSGeom_getCoordSeq_r( geosinit()->ctxt, bBoxRing );
3438 if ( !bBoxCoordSeq )
3441 unsigned int nCoords = 0;
3442 if ( !GEOSCoordSeq_getSize_r( geosinit()->ctxt, bBoxCoordSeq, &nCoords ) )
3446 for (
unsigned int i = 0; i < nCoords - 1; ++i )
3449 GEOSCoordSeq_getX_r( geosinit()->ctxt, bBoxCoordSeq, i, &t );
3452 digits = std::ceil( std::log10( std::fabs( t ) ) );
3453 if ( digits > maxDigits )
3456 GEOSCoordSeq_getY_r( geosinit()->ctxt, bBoxCoordSeq, i, &t );
3457 digits = std::ceil( std::log10( std::fabs( t ) ) );
3458 if ( digits > maxDigits )
3467 return geosinit()->ctxt;
The Qgis class provides global constants for use throughout the application.
BufferSide
Side of line to buffer.
@ Right
Buffer to right of line.
GeometryOperationResult
Success or failure of a geometry operation.
@ AddPartNotMultiGeometry
The source geometry is not multi.
@ InvalidBaseGeometry
The base geometry on which the operation is done is invalid or empty.
JoinStyle
Join styles for buffers.
EndCapStyle
End cap styles for buffers.
MakeValidMethod
Algorithms to use when repairing invalid geometries.
@ Linework
Combines all rings into a set of noded lines and then extracts valid polygons from that linework.
@ Structure
Structured method, first makes all rings valid and then merges shells and subtracts holes from shells...
WkbType
The WKB type describes the number of dimensions a geometry has.
@ GeometryCollection
GeometryCollection.
Abstract base class for all geometries.
bool isMeasure() const
Returns true if the geometry contains m values.
virtual QgsRectangle boundingBox() const
Returns the minimal bounding box for the geometry.
bool is3D() const
Returns true if the geometry is 3D and contains a z-value.
Qgis::WkbType wkbType() const
Returns the WKB type of the geometry.
virtual bool isEmpty() const
Returns true if the geometry is empty.
virtual int dimension() const =0
Returns the inherent dimension of the geometry.
virtual QgsAbstractGeometry * clone() const =0
Clones the geometry by performing a deep copy.
Curve polygon geometry type.
int numInteriorRings() const
Returns the number of interior rings contained with the curve polygon.
const QgsCurve * exteriorRing() const
Returns the curve polygon's exterior ring.
const QgsCurve * interiorRing(int i) const
Retrieves an interior ring from the curve polygon.
Abstract base class for curved geometry type.
virtual QgsLineString * curveToLine(double tolerance=M_PI_2/90, SegmentationToleranceType toleranceType=MaximumAngle) const =0
Returns a new line string geometry corresponding to a segmentized approximation of the curve.
virtual bool addGeometry(QgsAbstractGeometry *g)
Adds a geometry and takes ownership. Returns true in case of success.
static Qgis::GeometryOperationResult addPart(QgsAbstractGeometry *geometry, std::unique_ptr< QgsAbstractGeometry > part)
Add a part to multi type geometry.
A geometry engine is a low-level representation of a QgsAbstractGeometry object, optimised for use wi...
const QgsAbstractGeometry * mGeometry
EngineOperationResult
Success or failure of a geometry operation.
@ NothingHappened
Nothing happened, without any error.
@ InvalidBaseGeometry
The geometry on which the operation occurs is not valid.
@ InvalidInput
The input is not valid.
@ NodedGeometryError
Error occurred while creating a noded geometry.
@ EngineError
Error occurred in the geometry engine.
@ SplitCannotSplitPoint
Points cannot be split.
@ Success
Operation succeeded.
void logError(const QString &engineName, const QString &message) const
Logs an error message encountered during an operation.
static std::unique_ptr< QgsGeometryCollection > createCollectionOfType(Qgis::WkbType type)
Returns a new geometry collection matching a specified WKB type.
Encapsulates parameters under which a geometry operation is performed.
double gridSize() const
Returns the grid size which will be used to snap vertices of a geometry.
A geometry is the spatial representation of a feature.
QgsAbstractGeometry * get()
Returns a modifiable (non-const) reference to the underlying abstract geometry primitive.
const QgsAbstractGeometry * constGet() const
Returns a non-modifiable (const) reference to the underlying abstract geometry primitive.
bool isEmpty() const
Returns true if the geometry is empty (eg a linestring with no vertices, or a collection with no geom...
Does vector analysis using the geos library and handles import, export, exception handling*.
QgsGeometry delaunayTriangulation(double tolerance=0.0, bool edgesOnly=false, QString *errorMsg=nullptr) const
Returns the Delaunay triangulation for the vertices of the geometry.
bool touches(const QgsAbstractGeometry *geom, QString *errorMsg=nullptr) const override
Checks if geom touches this.
QgsAbstractGeometry * symDifference(const QgsAbstractGeometry *geom, QString *errorMsg=nullptr, const QgsGeometryParameters ¶meters=QgsGeometryParameters()) const override
Calculate the symmetric difference of this and geom.
double hausdorffDistanceDensify(const QgsAbstractGeometry *geom, double densifyFraction, QString *errorMsg=nullptr) const
Returns the Hausdorff distance between this geometry and geom.
bool isValid(QString *errorMsg=nullptr, bool allowSelfTouchingHoles=false, QgsGeometry *errorLoc=nullptr) const override
Returns true if the geometry is valid.
std::unique_ptr< QgsAbstractGeometry > subdivide(int maxNodes, QString *errorMsg=nullptr, const QgsGeometryParameters ¶meters=QgsGeometryParameters()) const
Subdivides the geometry.
QgsAbstractGeometry * intersection(const QgsAbstractGeometry *geom, QString *errorMsg=nullptr, const QgsGeometryParameters ¶meters=QgsGeometryParameters()) const override
Calculate the intersection of this and geom.
double hausdorffDistance(const QgsAbstractGeometry *geom, QString *errorMsg=nullptr) const
Returns the Hausdorff distance between this geometry and geom.
static geos::unique_ptr asGeos(const QgsGeometry &geometry, double precision=0)
Returns a geos geometry - caller takes ownership of the object (should be deleted with GEOSGeom_destr...
QgsAbstractGeometry * buffer(double distance, int segments, QString *errorMsg=nullptr) const override
QgsAbstractGeometry * concaveHull(double targetPercent, bool allowHoles=false, QString *errorMsg=nullptr) const
Returns a possibly concave geometry that encloses the input geometry.
std::unique_ptr< QgsAbstractGeometry > reshapeGeometry(const QgsLineString &reshapeWithLine, EngineOperationResult *errorCode, QString *errorMsg=nullptr) const
Reshapes the geometry using a line.
std::unique_ptr< QgsAbstractGeometry > maximumInscribedCircle(double tolerance, QString *errorMsg=nullptr) const
Returns the maximum inscribed circle.
QgsAbstractGeometry * difference(const QgsAbstractGeometry *geom, QString *errorMsg=nullptr, const QgsGeometryParameters ¶meters=QgsGeometryParameters()) const override
Calculate the difference of this and geom.
EngineOperationResult splitGeometry(const QgsLineString &splitLine, QVector< QgsGeometry > &newGeometries, bool topological, QgsPointSequence &topologyTestPoints, QString *errorMsg=nullptr, bool skipIntersectionCheck=false) const override
Splits this geometry according to a given line.
std::unique_ptr< QgsAbstractGeometry > sharedPaths(const QgsAbstractGeometry *other, QString *errorMsg=nullptr) const
Find paths shared between the two given lineal geometries (this and other).
std::unique_ptr< QgsAbstractGeometry > clip(const QgsRectangle &rectangle, QString *errorMsg=nullptr) const
Performs a fast, non-robust intersection between the geometry and a rectangle.
std::unique_ptr< QgsAbstractGeometry > node(QString *errorMsg=nullptr) const
Returns a (Multi)LineString representing the fully noded version of a collection of linestrings.
double minimumClearance(QString *errorMsg=nullptr) const
Computes the minimum clearance of a geometry.
std::unique_ptr< QgsAbstractGeometry > singleSidedBuffer(double distance, int segments, Qgis::BufferSide side, Qgis::JoinStyle joinStyle, double miterLimit, QString *errorMsg=nullptr) const
Returns a single sided buffer for a geometry.
bool disjoint(const QgsAbstractGeometry *geom, QString *errorMsg=nullptr) const override
Checks if geom is disjoint from this.
QgsGeos(const QgsAbstractGeometry *geometry, double precision=0)
GEOS geometry engine constructor.
std::unique_ptr< QgsAbstractGeometry > makeValid(Qgis::MakeValidMethod method=Qgis::MakeValidMethod::Linework, bool keepCollapsed=false, QString *errorMsg=nullptr) const
Repairs the geometry using GEOS make valid routine.
QgsGeometry shortestLine(const QgsGeometry &other, QString *errorMsg=nullptr) const
Returns the shortest line joining this geometry to the other geometry.
QgsAbstractGeometry * simplify(double tolerance, QString *errorMsg=nullptr) const override
QgsGeometry closestPoint(const QgsGeometry &other, QString *errorMsg=nullptr) const
Returns the closest point on the geometry to the other geometry.
static std::unique_ptr< QgsPolygon > fromGeosPolygon(const GEOSGeometry *geos)
std::unique_ptr< QgsAbstractGeometry > minimumClearanceLine(QString *errorMsg=nullptr) const
Returns a LineString whose endpoints define the minimum clearance of a geometry.
QgsAbstractGeometry * envelope(QString *errorMsg=nullptr) const override
QString relate(const QgsAbstractGeometry *geom, QString *errorMsg=nullptr) const override
Returns the Dimensional Extended 9 Intersection Model (DE-9IM) representation of the relationship bet...
bool crosses(const QgsAbstractGeometry *geom, QString *errorMsg=nullptr) const override
Checks if geom crosses this.
QgsAbstractGeometry * convexHull(QString *errorMsg=nullptr) const override
Calculate the convex hull of this.
double distance(const QgsAbstractGeometry *geom, QString *errorMsg=nullptr) const override
Calculates the distance between this and geom.
std::unique_ptr< QgsAbstractGeometry > minimumWidth(QString *errorMsg=nullptr) const
Returns a linestring geometry which represents the minimum diameter of the geometry.
bool isSimple(QString *errorMsg=nullptr) const override
Determines whether the geometry is simple (according to OGC definition).
QgsAbstractGeometry * combine(const QgsAbstractGeometry *geom, QString *errorMsg=nullptr, const QgsGeometryParameters ¶meters=QgsGeometryParameters()) const override
Calculate the combination of this and geom.
bool within(const QgsAbstractGeometry *geom, QString *errorMsg=nullptr) const override
Checks if geom is within this.
void prepareGeometry() override
Prepares the geometry, so that subsequent calls to spatial relation methods are much faster.
static std::unique_ptr< QgsAbstractGeometry > fromGeos(const GEOSGeometry *geos)
Create a geometry from a GEOSGeometry.
QgsAbstractGeometry * interpolate(double distance, QString *errorMsg=nullptr) const override
bool distanceWithin(const QgsAbstractGeometry *geom, double maxdistance, QString *errorMsg=nullptr) const override
Checks if geom is within maxdistance distance from this geometry.
bool isEqual(const QgsAbstractGeometry *geom, QString *errorMsg=nullptr) const override
Checks if this is equal to geom.
bool contains(double x, double y, QString *errorMsg=nullptr) const
Returns true if the geometry contains the point at (x, y).
QgsGeometry mergeLines(QString *errorMsg=nullptr) const
Merges any connected lines in a LineString/MultiLineString geometry and converts them to single line ...
static QgsGeometry polygonize(const QVector< const QgsAbstractGeometry * > &geometries, QString *errorMsg=nullptr)
Creates a GeometryCollection geometry containing possible polygons formed from the constituent linewo...
bool relatePattern(const QgsAbstractGeometry *geom, const QString &pattern, QString *errorMsg=nullptr) const override
Tests whether two geometries are related by a specified Dimensional Extended 9 Intersection Model (DE...
QgsAbstractGeometry * offsetCurve(double distance, int segments, Qgis::JoinStyle joinStyle, double miterLimit, QString *errorMsg=nullptr) const override
Offsets a curve.
static GEOSContextHandle_t getGEOSHandler()
QgsPoint * centroid(QString *errorMsg=nullptr) const override
Calculates the centroid of this.
double lineLocatePoint(const QgsPoint &point, QString *errorMsg=nullptr) const
Returns a distance representing the location along this linestring of the closest point on this lines...
bool isEmpty(QString *errorMsg=nullptr) const override
static Qgis::GeometryOperationResult addPart(QgsGeometry &geometry, GEOSGeometry *newPart)
Adds a new island polygon to a multipolygon feature.
double frechetDistance(const QgsAbstractGeometry *geom, QString *errorMsg=nullptr) const
Returns the Fréchet distance between this geometry and geom, restricted to discrete points for both g...
QgsGeometry voronoiDiagram(const QgsAbstractGeometry *extent=nullptr, double tolerance=0.0, bool edgesOnly=false, QString *errorMsg=nullptr) const
Creates a Voronoi diagram for the nodes contained within the geometry.
bool intersects(const QgsAbstractGeometry *geom, QString *errorMsg=nullptr) const override
Checks if geom intersects this.
void geometryChanged() override
Should be called whenever the geometry associated with the engine has been modified and the engine mu...
bool overlaps(const QgsAbstractGeometry *geom, QString *errorMsg=nullptr) const override
Checks if geom overlaps this.
double area(QString *errorMsg=nullptr) const override
double length(QString *errorMsg=nullptr) const override
std::unique_ptr< QgsAbstractGeometry > largestEmptyCircle(double tolerance, const QgsAbstractGeometry *boundary=nullptr, QString *errorMsg=nullptr) const
Constructs the Largest Empty Circle for a set of obstacle geometries, up to a specified tolerance.
double frechetDistanceDensify(const QgsAbstractGeometry *geom, double densifyFraction, QString *errorMsg=nullptr) const
Returns the Fréchet distance between this geometry and geom, restricted to discrete points for both g...
static QgsPoint coordSeqPoint(const GEOSCoordSequence *cs, int i, bool hasZ, bool hasM)
QgsPoint * pointOnSurface(QString *errorMsg=nullptr) const override
Calculate a point that is guaranteed to be on the surface of this.
static QgsGeometry geometryFromGeos(GEOSGeometry *geos)
Creates a new QgsGeometry object, feeding in a geometry in GEOS format.
Line string geometry type, with support for z-dimension and m-values.
const double * yData() const
Returns a const pointer to the y vertex data.
const double * xData() const
Returns a const pointer to the x vertex data.
QVector< double > xVector() const
Returns the x vertex values as a vector.
const double * zData() const
Returns a const pointer to the z vertex data, or nullptr if the linestring does not have z values.
int numPoints() const override
Returns the number of points in the curve.
QgsPoint pointN(int i) const
Returns the specified point from inside the line string.
QVector< double > yVector() const
Returns the y vertex values as a vector.
double yAt(int index) const override
Returns the y-coordinate of the specified node in the line string.
QVector< double > zVector() const
Returns the z vertex values as a vector.
double closestSegment(const QgsPoint &pt, QgsPoint &segmentPt, QgsVertexId &vertexAfter, int *leftOf=nullptr, double epsilon=4 *std::numeric_limits< double >::epsilon()) const override
Searches for the closest segment of the geometry to a given point.
const double * mData() const
Returns a const pointer to the m vertex data, or nullptr if the linestring does not have m values.
void addVertex(const QgsPoint &pt)
Adds a new vertex to the end of the line string.
QgsLineString * clone() const override
Clones the geometry by performing a deep copy.
double xAt(int index) const override
Returns the x-coordinate of the specified node in the line string.
Multi curve geometry collection.
bool addGeometry(QgsAbstractGeometry *g) override
Adds a geometry and takes ownership. Returns true in case of success.
Multi line string geometry collection.
Multi point geometry collection.
Multi polygon geometry collection.
Custom exception class which is raised when an operation is not supported.
A class to represent a 2D point.
Point geometry type, with support for z-dimension and m-values.
double distance(double x, double y) const
Returns the Cartesian 2D distance between this point and a specified x, y coordinate.
A rectangle specified with double values.
double xMinimum() const
Returns the x minimum value (left side of rectangle).
void setYMinimum(double y)
Set the minimum y value.
double yMinimum() const
Returns the y minimum value (bottom side of rectangle).
void setXMinimum(double x)
Set the minimum x value.
double width() const
Returns the width of the rectangle.
double xMaximum() const
Returns the x maximum value (right side of rectangle).
bool isNull() const
Test if the rectangle is null (holding no spatial information).
double yMaximum() const
Returns the y maximum value (top side of rectangle).
void setYMaximum(double y)
Set the maximum y value.
void setXMaximum(double x)
Set the maximum x value.
bool isEmpty() const
Returns true if the rectangle has no area.
double height() const
Returns the height of the rectangle.
static Qgis::GeometryType geometryType(Qgis::WkbType type)
Returns the geometry type for a WKB type, e.g., both MultiPolygon and CurvePolygon would have a Polyg...
static bool isMultiType(Qgis::WkbType type)
Returns true if the WKB type is a multi type.
static Qgis::WkbType flatType(Qgis::WkbType type)
Returns the flat type for a WKB type.
Contains geos related utilities and functions.
std::unique_ptr< GEOSGeometry, GeosDeleter > unique_ptr
Scoped GEOS pointer.
std::unique_ptr< GEOSCoordSequence, GeosDeleter > coord_sequence_unique_ptr
Scoped GEOS coordinate sequence pointer.
std::unique_ptr< GEOSBufferParams, GeosDeleter > buffer_params_unique_ptr
Scoped GEOS buffer params pointer.
As part of the API refactoring and improvements which landed in the Processing API was substantially reworked from the x version This was done in order to allow much of the underlying Processing framework to be ported into c
bool qgsDoubleNear(double a, double b, double epsilon=4 *std::numeric_limits< double >::epsilon())
Compare two doubles (but allow some difference)
QMap< QString, QString > QgsStringMap
QVector< QgsPoint > QgsPointSequence
Q_GLOBAL_STATIC(QReadWriteLock, sDefinitionCacheLock)
#define DEFAULT_QUADRANT_SEGMENTS
#define CATCH_GEOS_WITH_ERRMSG(r)
#define QgsDebugError(str)
QLineF segment(int index, QRectF rect, double radius)
Utility class for identifying a unique vertex within a geometry.
void CORE_EXPORT operator()(GEOSGeometry *geom) const
Destroys the GEOS geometry geom, using the static QGIS geos context.
struct GEOSGeom_t GEOSGeometry