42using namespace Qt::StringLiterals;
44#define DEFAULT_QUADRANT_SEGMENTS 8
46#define CATCH_GEOS( r ) \
47 catch ( QgsGeosException & ) \
52#define CATCH_GEOS_WITH_ERRMSG( r ) \
53 catch ( QgsGeosException & e ) \
57 *errorMsg = e.what(); \
58 if ( errorMsg->startsWith( "InterruptedException"_L1, Qt::CaseInsensitive ) ) \
68static void throwQgsGeosException(
const char *fmt, ... )
74 vsnprintf( buffer,
sizeof buffer, fmt, ap );
77 QString message = QString::fromUtf8( buffer );
87 throw QgsGeosException( message );
95 throw QgsGeosException( message );
100static void printGEOSNotice(
const char *fmt, ... )
102#if defined( QGISDEBUG )
107 vsnprintf( buffer,
sizeof buffer, fmt, ap );
118#if defined( USE_THREAD_LOCAL ) && !defined( Q_OS_WIN )
121QThreadStorage< QgsGeosContext * > QgsGeosContext::sGeosContext;
127 mContext = GEOS_init_r();
128 GEOSContext_setNoticeHandler_r( mContext, printGEOSNotice );
129 GEOSContext_setErrorHandler_r( mContext, throwQgsGeosException );
131#if GEOS_VERSION_NUM >= GEOS_COMPUTE_VERSION( 3, 15, 0 )
136 GEOSCurveToLineParams *curveToLineParams = GEOSCurveToLineParams_create();
137 GEOSContext_setCurveToLineParams_r( mContext, curveToLineParams );
138 GEOSCurveToLineParams_destroy( curveToLineParams );
144 GEOSLineToCurveParams *lineToCurveParams = GEOSLineToCurveParams_create();
145 GEOSContext_setLineToCurveParams_r( mContext, lineToCurveParams );
146 GEOSLineToCurveParams_destroy( lineToCurveParams );
153 GEOS_finish_r( mContext );
158#if defined( USE_THREAD_LOCAL ) && !defined( Q_OS_WIN )
159 return sGeosContext.mContext;
161 GEOSContextHandle_t gContext =
nullptr;
162 if ( sGeosContext.hasLocalData() )
164 gContext = sGeosContext.localData()->mContext;
169 gContext = sGeosContext.localData()->mContext;
203 =
new QgsSettingsEntryBool( u
"line-to-curve-param"_s,
QgsSettingsTree::sTreeGeos,
false, u
"Whether to convert any linear output of a GEOS method to a curved type, if the inputs were converted to curves."_s );
208 , mPrecision( precision )
235#if GEOS_VERSION_NUM < GEOS_COMPUTE_VERSION( 3, 10, 0 )
237 throw QgsNotSupportedException( QObject::tr(
"The structured method to make geometries valid requires a QGIS build based on GEOS 3.10 or later" ) );
240 throw QgsNotSupportedException( QObject::tr(
"The keep collapsed option for making geometries valid requires a QGIS build based on GEOS 3.10 or later" ) );
244 geos.reset( GEOSMakeValid_r( context, mGeos.get() ) );
249 GEOSMakeValidParams *params = GEOSMakeValidParams_create_r( context );
254 GEOSMakeValidParams_setMethod_r( context, params, GEOS_MAKE_VALID_LINEWORK );
258 GEOSMakeValidParams_setMethod_r( context, params, GEOS_MAKE_VALID_STRUCTURE );
262 GEOSMakeValidParams_setKeepCollapsed_r( context, params, keepCollapsed ? 1 : 0 );
267 geos.reset( GEOSMakeValidWithParams_r( context, mGeos.get(), params ) );
268 GEOSMakeValidParams_destroy_r( context, params );
270 catch ( QgsGeosException &e )
274 *errorMsg = e.what();
276 GEOSMakeValidParams_destroy_r( context, params );
305 std::unique_ptr< QgsAbstractGeometry > geom =
fromGeos( newPart );
312 mGeosPrepared.reset();
325#if GEOS_VERSION_NUM >= GEOS_COMPUTE_VERSION( 3, 15, 0 )
329 std::unique_ptr< QgsAbstractGeometry > segmentized(
mGeometry->segmentize() );
336#if GEOS_VERSION_NUM >= GEOS_COMPUTE_VERSION( 3, 15, 0 )
359 return overlay( geom, OverlayIntersection, errorMsg, parameters, feedback ).release();
364 return overlay( geom, OverlayDifference, errorMsg, parameters, feedback ).release();
380 catch ( QgsGeosException &e )
385 *errorMsg = e.what();
394 int partType = GEOSGeomTypeId_r( context, currentPart );
397 if ( partType == GEOS_POINT )
408 if ( partType == GEOS_MULTILINESTRING || partType == GEOS_MULTIPOLYGON || partType == GEOS_GEOMETRYCOLLECTION )
410 int partCount = GEOSGetNumGeometries_r( context, currentPart );
411 for (
int i = 0; i < partCount; ++i )
413 subdivideRecursive( GEOSGetGeometryN_r( context, currentPart, i ), maxNodes, depth, parts, clipRect, gridSize );
424 int vertexCount = GEOSGetNumCoordinates_r( context, currentPart );
425 if ( vertexCount == 0 )
429 else if ( vertexCount < maxNodes )
436 double width = clipRect.
width();
437 double height = clipRect.
height();
438 QgsRectangle halfClipRect1 = clipRect;
439 QgsRectangle halfClipRect2 = clipRect;
440 if ( width > height )
453 halfClipRect1.
setYMinimum( halfClipRect1.
yMinimum() - std::numeric_limits<double>::epsilon() );
454 halfClipRect2.
setYMinimum( halfClipRect2.
yMinimum() - std::numeric_limits<double>::epsilon() );
455 halfClipRect1.
setYMaximum( halfClipRect1.
yMaximum() + std::numeric_limits<double>::epsilon() );
456 halfClipRect2.
setYMaximum( halfClipRect2.
yMaximum() + std::numeric_limits<double>::epsilon() );
460 halfClipRect1.
setXMinimum( halfClipRect1.
xMinimum() - std::numeric_limits<double>::epsilon() );
461 halfClipRect2.
setXMinimum( halfClipRect2.
xMinimum() - std::numeric_limits<double>::epsilon() );
462 halfClipRect1.
setXMaximum( halfClipRect1.
xMaximum() + std::numeric_limits<double>::epsilon() );
463 halfClipRect2.
setXMaximum( halfClipRect2.
xMaximum() + std::numeric_limits<double>::epsilon() );
475 clipPart1.reset( GEOSIntersectionPrec_r( context, mGeos.get(), clipPart1.get(), gridSize ) );
477 subdivideRecursive( clipPart1.get(), maxNodes, depth, parts, halfClipRect1, gridSize );
483 clipPart2.reset( GEOSIntersectionPrec_r( context, mGeos.get(), clipPart2.get(), gridSize ) );
485 subdivideRecursive( clipPart2.get(), maxNodes, depth, parts, halfClipRect2, gridSize );
497 maxNodes = std::max( maxNodes, 8 );
503 subdivideRecursive( mGeos.get(), maxNodes, 0, parts.get(),
mGeometry->boundingBox(), parameters.
gridSize() );
507 return std::move( parts );
512 return overlay( geom, OverlayUnion, errorMsg, parameters, feedback ).release();
517 std::vector<geos::unique_ptr> geosGeometries;
518 geosGeometries.reserve( geomList.size() );
524 geosGeometries.emplace_back(
asGeos( g, mPrecision ) );
532 geos::unique_ptr geomCollection = createGeosCollection( GEOS_GEOMETRYCOLLECTION, geosGeometries );
535 geomUnion.reset( GEOSUnaryUnionPrec_r( context, geomCollection.get(), parameters.
gridSize() ) );
539 geomUnion.reset( GEOSUnaryUnion_r( context, geomCollection.get() ) );
544 std::unique_ptr< QgsAbstractGeometry > result =
fromGeos( geomUnion.get() );
545 return result.release();
550 std::vector<geos::unique_ptr> geosGeometries;
551 geosGeometries.reserve( geomList.size() );
557 geosGeometries.emplace_back(
asGeos( g.constGet(), mPrecision ) );
565 geos::unique_ptr geomCollection = createGeosCollection( GEOS_GEOMETRYCOLLECTION, geosGeometries );
569 geomUnion.reset( GEOSUnaryUnionPrec_r( context, geomCollection.get(), parameters.
gridSize() ) );
573 geomUnion.reset( GEOSUnaryUnion_r( context, geomCollection.get() ) );
578 std::unique_ptr< QgsAbstractGeometry > result =
fromGeos( geomUnion.get() );
579 return result.release();
584 return overlay( geom, OverlaySymDifference, errorMsg, parameters, feedback ).release();
587static bool isZVerticalLine(
const QgsAbstractGeometry *geom,
double tolerance = 4 * std::numeric_limits<double>::epsilon() )
597 bool isVertical =
true;
600 const int nrPoints = line->numPoints();
608 const double sqrTolerance = tolerance * tolerance;
609 const double *lineX = line->xData();
610 const double *lineY = line->yData();
611 for (
int iVert = nrPoints - 1, jVert = 0; jVert < nrPoints; iVert = jVert++ )
642 otherGeosGeom =
asGeos( &firstPoint, mPrecision );
646 otherGeosGeom =
asGeos( geom, mPrecision );
649 if ( !otherGeosGeom )
657 if ( mGeosPrepared && !isZVerticalLine(
mGeometry->simplifiedTypeRef() ) )
659 GEOSPreparedDistance_r( context, mGeosPrepared.get(), otherGeosGeom.get(), &
distance );
663 GEOSDistance_r( context, mGeos.get(), otherGeosGeom.get(), &
distance );
680 geos::unique_ptr point = createGeosPointXY( x, y,
false, 0,
false, 0, 2, 0 );
689 GEOSPreparedDistance_r( context, mGeosPrepared.get(), point.get(), &
distance );
693 GEOSDistance_r( context, mGeos.get(), point.get(), &
distance );
710 return intersects( geom, errorMsg, feedback );
722 otherGeosGeom =
asGeos( &firstPoint );
726 otherGeosGeom =
asGeos( geom, mPrecision );
729 if ( !otherGeosGeom )
743 if ( mGeosPrepared && !isZVerticalLine(
mGeometry->simplifiedTypeRef() ) )
745#if GEOS_VERSION_NUM >= GEOS_COMPUTE_VERSION( 3, 10, 0 )
746 return GEOSPreparedDistanceWithin_r( context, mGeosPrepared.get(), otherGeosGeom.get(), maxdist );
748 GEOSPreparedDistance_r( context, mGeosPrepared.get(), otherGeosGeom.get(), &
distance );
753#if GEOS_VERSION_NUM >= GEOS_COMPUTE_VERSION( 3, 10, 0 )
754 return GEOSDistanceWithin_r( context, mGeos.get(), otherGeosGeom.get(), maxdist );
756 GEOSDistance_r( context, mGeos.get(), otherGeosGeom.get(), &
distance );
772#if GEOS_VERSION_NUM >= GEOS_COMPUTE_VERSION( 3, 12, 0 )
775 geos::unique_ptr point = createGeosPointXY( x, y,
false, 0,
false, 0, 2, 0 );
781#if GEOS_VERSION_NUM >= GEOS_COMPUTE_VERSION( 3, 12, 0 )
782 return GEOSPreparedContainsXY_r( context, mGeosPrepared.get(), x, y ) == 1;
784 return GEOSPreparedContains_r( context, mGeosPrepared.get(), point.get() ) == 1;
788#if GEOS_VERSION_NUM >= GEOS_COMPUTE_VERSION( 3, 12, 0 )
789 geos::unique_ptr point = createGeosPointXY( x, y,
false, 0,
false, 0, 2, 0 );
794 result = ( GEOSContains_r( context, mGeos.get(), point.get() ) == 1 );
796 catch ( QgsGeosException &e )
801 *errorMsg = e.what();
819 if ( !otherGeosGeom )
843 if ( !otherGeosGeom )
867 if ( !otherGeosGeom )
891 if ( !otherGeosGeom )
907 if ( !mGeos || !geom )
913#if GEOS_VERSION_NUM >= GEOS_COMPUTE_VERSION( 3, 12, 0 )
921 return GEOSPreparedIntersectsXY_r(
QgsGeosContext::get(), mGeosPrepared.get(), point->x(), point->y() ) == 1;
923 catch ( QgsGeosException &e )
928 *errorMsg = e.what();
936 return relation( geom, RelationIntersects, errorMsg );
941 return relation( geom, RelationTouches, errorMsg, feedback );
946 return relation( geom, RelationCrosses, errorMsg, feedback );
951 return relation( geom, RelationWithin, errorMsg, feedback );
956 return relation( geom, RelationOverlaps, errorMsg, feedback );
961 if ( !mGeos || !geom )
966#if GEOS_VERSION_NUM >= GEOS_COMPUTE_VERSION( 3, 12, 0 )
975 return GEOSPreparedContainsXY_r(
QgsGeosContext::get(), mGeosPrepared.get(), point->x(), point->y() ) == 1;
977 catch ( QgsGeosException &e )
982 *errorMsg = e.what();
990 return relation( geom, RelationContains, errorMsg, feedback );
995 return relation( geom, RelationDisjoint, errorMsg, feedback );
1016 char *r = GEOSRelate_r( context, mGeos.get(), geosGeom.get() );
1019 result = QString( r );
1020 GEOSFree_r( context, r );
1023 catch ( QgsGeosException &e )
1028 *errorMsg = e.what();
1037 if ( !mGeos || !geom )
1048 bool result =
false;
1054 result = ( GEOSRelatePattern_r( context, mGeos.get(), geosGeom.get(), pattern.toLocal8Bit().constData() ) == 1 );
1056 catch ( QgsGeosException &e )
1061 *errorMsg = e.what();
1106#if GEOS_VERSION_NUM >= GEOS_COMPUTE_VERSION( 3, 15, 0 )
1122 if ( !GEOSisValid_r( context, mGeos.get() ) )
1126 if ( !splitGeosGeom || !GEOSisValid_r( context, splitGeosGeom.get() ) || !GEOSisSimple_r( context, splitGeosGeom.get() ) )
1141 if ( !topologicalTestPointsSplit( splitGeosGeom.get(), topologyTestPoints, errorMsg ) )
1147 newGeometries.clear();
1149 geos::unique_ptr split( GEOSSplit_r( context, mGeos.get(), splitGeosGeom.get() ) );
1156 const int nParts = GEOSGetNumGeometries_r( context, split.get() );
1161 for (
int i = 0; i < nParts; ++i )
1163 newGeometries <<
QgsGeometry(
fromGeos( GEOSGetGeometryN_r( context, split.get(), i ) ) );
1174 const QgsLineString *splitLine = qgis::down_cast< const QgsLineString * >( &splitGeom );
1177 return splitGeometry( *splitLine, newGeometries, topological, topologyTestPoints, errorMsg,
false );
1192 const QgsLineString &splitLine, QVector<QgsGeometry> &newGeometries,
bool topological,
QgsPointSequence &topologyTestPoints, QString *errorMsg,
bool skipIntersectionCheck
1208 if ( !GEOSisValid_r( context, mGeos.get() ) )
1215 newGeometries.clear();
1222 splitLineGeos = createGeosLinestring( &splitLine, mPrecision );
1226 splitLineGeos = createGeosPointXY( splitLine.
xAt( 0 ), splitLine.
yAt( 0 ),
false, 0,
false, 0, 2, mPrecision );
1233 if ( !GEOSisValid_r( context, splitLineGeos.get() ) || !GEOSisSimple_r( context, splitLineGeos.get() ) )
1241 if ( !topologicalTestPointsSplit( splitLineGeos.get(), topologyTestPoints, errorMsg ) )
1250 returnCode = splitLinearGeometry( splitLineGeos.get(), newGeometries, skipIntersectionCheck );
1254 returnCode = splitPolygonGeometry( splitLineGeos.get(), newGeometries, skipIntersectionCheck );
1282 geos::unique_ptr intersectionGeom( GEOSIntersection_r( context, mGeos.get(), splitLine ) );
1283 if ( !intersectionGeom )
1288 if ( !( GEOSGeomTypeId_r( context, intersectionGeom.get() ) == GEOS_POINT
1289 || GEOSGeomTypeId_r( context, intersectionGeom.get() ) == GEOS_LINESTRING
1290 || GEOSGeomTypeId_r( context, intersectionGeom.get() ) == GEOS_MULTIPOINT
1291 || GEOSGeomTypeId_r( context, intersectionGeom.get() ) == GEOS_MULTILINESTRING ) )
1295 *errorMsg = u
"Extracting topological points from curves or polygons is not yet supported."_s;
1300 bool simple =
false;
1301 int nIntersectGeoms = 1;
1302 if ( GEOSGeomTypeId_r( context, intersectionGeom.get() ) == GEOS_LINESTRING || GEOSGeomTypeId_r( context, intersectionGeom.get() ) == GEOS_POINT )
1306 nIntersectGeoms = GEOSGetNumGeometries_r( context, intersectionGeom.get() );
1308 for (
int i = 0; i < nIntersectGeoms; ++i )
1312 currentIntersectGeom = intersectionGeom.get();
1314 currentIntersectGeom = GEOSGetGeometryN_r( context, intersectionGeom.get(), i );
1316 const GEOSCoordSequence *lineSequence = GEOSGeom_getCoordSeq_r( context, currentIntersectGeom );
1317 unsigned int sequenceSize = 0;
1319 if ( GEOSCoordSeq_getSize_r( context, lineSequence, &sequenceSize ) != 0 )
1321 for (
unsigned int i = 0; i < sequenceSize; ++i )
1323 if ( GEOSCoordSeq_getXYZ_r( context, lineSequence, i, &x, &y, &z ) )
1325 testPoints.push_back( QgsPoint( x, y, z ) );
1339 int type = GEOSGeomTypeId_r( context, mGeos.get() );
1341 std::unique_ptr< QgsMultiCurve > multiCurve;
1342 if ( type == GEOS_MULTILINESTRING )
1346 else if ( type == GEOS_LINESTRING )
1348 multiCurve = std::make_unique<QgsMultiCurve>();
1349 multiCurve->addGeometry(
mGeometry->clone() );
1364 std::unique_ptr< QgsMultiPoint > splitPoints;
1366 std::unique_ptr< QgsAbstractGeometry > splitGeom(
fromGeos( GEOSsplitPoint ) );
1370 splitPoints.reset( qgis::down_cast<QgsMultiPoint *>( splitGeom.release() ) );
1374 splitPoints = std::make_unique< QgsMultiPoint >();
1377 splitPoints->addGeometry( qgis::down_cast<QgsPoint *>( splitGeom.release() ) );
1385 QgsMultiCurve lines;
1388 for (
int geometryIndex = 0; geometryIndex < multiCurve->numGeometries(); ++geometryIndex )
1401 QMap< int, QVector< QPair< double, QgsPoint > > > pointMap;
1402 for (
int splitPointIndex = 0; splitPointIndex < splitPoints->numGeometries(); ++splitPointIndex )
1404 const QgsPoint *intersectionPoint = splitPoints->pointN( splitPointIndex );
1406 QgsPoint segmentPoint2D;
1407 QgsVertexId nextVertex;
1410 line->
closestSegment( *intersectionPoint, segmentPoint2D, nextVertex );
1426 const QPair< double, QgsPoint > pair = qMakePair(
distance, *correctSegmentPoint.get() );
1427 if ( pointMap.contains( nextVertex.
vertex - 1 ) )
1428 pointMap[nextVertex.
vertex - 1].append( pair );
1430 pointMap[nextVertex.
vertex - 1] = QVector< QPair< double, QgsPoint > >() << pair;
1435 for (
auto &p : pointMap )
1437 std::sort( p.begin(), p.end(), [](
const QPair< double, QgsPoint > &a,
const QPair< double, QgsPoint > &b ) { return a.first < b.first; } );
1441 QgsLineString newLine;
1443 QgsPoint splitPoint;
1444 for (
int vertexIndex = 0; vertexIndex < nVertices; ++vertexIndex )
1446 QgsPoint currentPoint = line->
pointN( vertexIndex );
1448 if ( pointMap.contains( vertexIndex ) )
1451 for (
int k = 0; k < pointMap[vertexIndex].size(); ++k )
1453 splitPoint = pointMap[vertexIndex][k].second;
1454 if ( splitPoint == currentPoint )
1457 newLine = QgsLineString();
1460 else if ( splitPoint == line->
pointN( vertexIndex + 1 ) )
1464 newLine = QgsLineString();
1470 newLine = QgsLineString();
1479 return asGeos( &lines, mPrecision );
1484 Q_UNUSED( skipIntersectionCheck )
1493 geos::unique_ptr intersectGeom( GEOSIntersection_r( context, splitLine, mGeos.get() ) );
1494 if ( !intersectGeom || GEOSisEmpty_r( context, intersectGeom.get() ) )
1498 const int linearIntersect = GEOSRelatePattern_r( context, mGeos.get(), splitLine,
"1********" );
1499 if ( linearIntersect > 0 )
1507 std::vector<geos::unique_ptr> lineGeoms;
1509 const int splitType = GEOSGeomTypeId_r( context, splitGeom.get() );
1510 if ( splitType == GEOS_MULTILINESTRING )
1512 const int nGeoms = GEOSGetNumGeometries_r( context, splitGeom.get() );
1513 lineGeoms.reserve( nGeoms );
1514 for (
int i = 0; i < nGeoms; ++i )
1515 lineGeoms.emplace_back( GEOSGeom_clone_r( context, GEOSGetGeometryN_r( context, splitGeom.get(), i ) ) );
1519 lineGeoms.emplace_back( GEOSGeom_clone_r( context, splitGeom.get() ) );
1522 mergeGeometriesMultiTypeSplit( lineGeoms );
1526 newGeometries << QgsGeometry(
fromGeos( lineGeom.get() ) );
1542 if ( !mGeosPrepared )
1548 if ( !skipIntersectionCheck && !GEOSPreparedIntersects_r( context, mGeosPrepared.get(), splitLine ) )
1553 if ( !nodedGeometry )
1562 const int numberOfGeometriesPolygon = numberOfGeometries( polygons.get() );
1563 if ( numberOfGeometriesPolygon == 0 )
1570 std::vector<geos::unique_ptr> testedGeometries;
1575 for (
int i = 0; i < numberOfGeometriesPolygon; i++ )
1577 const GEOSGeometry *polygon = GEOSGetGeometryN_r( context, polygons.get(), i );
1581 testedGeometries.emplace_back( GEOSGeom_clone_r( context, polygon ) );
1584 const size_t nGeometriesThis = numberOfGeometries( mGeos.get() );
1585 if ( testedGeometries.empty() || testedGeometries.size() == nGeometriesThis )
1595 mergeGeometriesMultiTypeSplit( testedGeometries );
1598 for ( i = 0; i < testedGeometries.size() && GEOSisValid_r( context, testedGeometries[i].get() ); ++i )
1601 if ( i < testedGeometries.size() )
1608 newGeometries << QgsGeometry(
fromGeos( testedGeometry.get() ) );
1616 if ( !splitLine || !geom )
1621 if ( GEOSGeom_getDimensions_r( context, geom ) == 2 )
1622 geometryBoundary.reset( GEOSBoundary_r( context, geom ) );
1624 geometryBoundary.reset( GEOSGeom_clone_r( context, geom ) );
1627 geos::unique_ptr unionGeometry( GEOSUnion_r( context, splitLineClone.get(), geometryBoundary.get() ) );
1629 return unionGeometry;
1632int QgsGeos::mergeGeometriesMultiTypeSplit( std::vector<geos::unique_ptr> &splitResult )
const
1639 int type = GEOSGeomTypeId_r( context, mGeos.get() );
1640 if ( type != GEOS_GEOMETRYCOLLECTION && type != GEOS_MULTILINESTRING && type != GEOS_MULTIPOLYGON && type != GEOS_MULTIPOINT )
1644 std::vector<geos::unique_ptr> unionGeom;
1646 std::vector<geos::unique_ptr> newSplitResult;
1648 for (
size_t i = 0; i < splitResult.size(); ++i )
1651 bool isPart =
false;
1652 for (
int j = 0; j < GEOSGetNumGeometries_r( context, mGeos.get() ); j++ )
1654 if ( GEOSEquals_r( context, splitResult[i].get(), GEOSGetGeometryN_r( context, mGeos.get(), j ) ) )
1663 unionGeom.emplace_back( std::move( splitResult[i] ) );
1667 std::vector<geos::unique_ptr> geomVector;
1668 geomVector.emplace_back( std::move( splitResult[i] ) );
1670 if ( type == GEOS_MULTILINESTRING )
1671 newSplitResult.emplace_back( createGeosCollection( GEOS_MULTILINESTRING, geomVector ) );
1672 else if ( type == GEOS_MULTIPOLYGON )
1673 newSplitResult.emplace_back( createGeosCollection( GEOS_MULTIPOLYGON, geomVector ) );
1677 splitResult = std::move( newSplitResult );
1680 if ( !unionGeom.empty() )
1682 if ( type == GEOS_MULTILINESTRING )
1683 splitResult.emplace_back( createGeosCollection( GEOS_MULTILINESTRING, unionGeom ) );
1684 else if ( type == GEOS_MULTIPOLYGON )
1685 splitResult.emplace_back( createGeosCollection( GEOS_MULTIPOLYGON, unionGeom ) );
1691geos::unique_ptr QgsGeos::createGeosCollection(
int typeId, std::vector<geos::unique_ptr> &geoms )
1693 std::vector<GEOSGeometry *> geomarr;
1694 geomarr.reserve( geoms.size() );
1699 if ( geomUniquePtr )
1701 if ( !GEOSisEmpty_r( context, geomUniquePtr.get() ) )
1705 geomarr.emplace_back( geomUniquePtr.release() );
1713 geomRes.reset( GEOSGeom_createCollection_r( context, typeId, geomarr.data(), geomarr.size() ) );
1715 catch ( QgsGeosException & )
1719 GEOSGeom_destroy_r( context, geom );
1734#ifdef GEOS_SUPPORTS_ZM
1735 bool hasZ = GEOSHasZ_r( context,
geos );
1736 bool hasM = GEOSHasM_r( context,
geos );
1738 int nCoordDims = GEOSGeom_getCoordinateDimension_r( context,
geos );
1739 int nDims = GEOSGeom_getDimensions_r( context,
geos );
1740 bool hasZ = ( nCoordDims == 3 );
1741 bool hasM = ( ( nDims - nCoordDims ) == 1 );
1744 switch ( GEOSGeomTypeId_r( context,
geos ) )
1748 if ( GEOSisEmpty_r( context,
geos ) )
1751 const GEOSCoordSequence *cs = GEOSGeom_getCoordSeq_r( context,
geos );
1752 unsigned int nPoints = 0;
1753 GEOSCoordSeq_getSize_r( context, cs, &nPoints );
1762 return !point.
isEmpty() ? std::unique_ptr<QgsAbstractGeometry>( point.
clone() ) :
nullptr;
1764 case GEOS_LINESTRING:
1766 return sequenceToLinestring(
geos, hasZ, hasM );
1768#if GEOS_VERSION_NUM >= GEOS_COMPUTE_VERSION( 3, 15, 0 )
1769 case GEOS_CIRCULARSTRING:
1771 return sequenceToCircularString(
geos, hasZ, hasM );
1773 case GEOS_COMPOUNDCURVE:
1775 auto compoundCurve = std::make_unique< QgsCompoundCurve >();
1776 const int nCurves = GEOSGetNumCurves_r( context,
geos );
1777 for (
int i = 0; i < nCurves; i++ )
1779 std::unique_ptr< QgsSimpleCurve > curve = sequenceToSimpleCurve( GEOSGetCurveN_r( context,
geos, i ), hasZ, hasM );
1780 compoundCurve->addCurve( curve.release(),
true );
1782 return std::move( compoundCurve );
1789#if GEOS_VERSION_NUM >= GEOS_COMPUTE_VERSION( 3, 15, 0 )
1790 case GEOS_CURVEPOLYGON:
1795 case GEOS_MULTIPOINT:
1797 auto multiPoint = std::make_unique<QgsMultiPoint>();
1798 const int nParts = GEOSGetNumGeometries_r( context,
geos );
1799 multiPoint->reserve( nParts );
1800 for (
int i = 0; i < nParts; ++i )
1802 const GEOSCoordSequence *cs = GEOSGeom_getCoordSeq_r( context, GEOSGetGeometryN_r( context,
geos, i ) );
1805 unsigned int nPoints = 0;
1806 GEOSCoordSeq_getSize_r( context, cs, &nPoints );
1808 multiPoint->addGeometry(
coordSeqPoint( cs, 0, hasZ, hasM ).clone() );
1811 return std::move( multiPoint );
1813 case GEOS_MULTILINESTRING:
1815 auto multiLineString = std::make_unique<QgsMultiLineString>();
1816 const int nParts = GEOSGetNumGeometries_r( context,
geos );
1817 multiLineString->reserve( nParts );
1818 for (
int i = 0; i < nParts; ++i )
1820 std::unique_ptr< QgsLineString > line( sequenceToLinestring( GEOSGetGeometryN_r( context,
geos, i ), hasZ, hasM ) );
1823 multiLineString->addGeometry( line.release() );
1826 return std::move( multiLineString );
1828#if GEOS_VERSION_NUM >= GEOS_COMPUTE_VERSION( 3, 15, 0 )
1829 case GEOS_MULTICURVE:
1831 auto multiCurve = std::make_unique<QgsMultiCurve>();
1832 const int nParts = GEOSGetNumGeometries_r( context,
geos );
1833 multiCurve->reserve( nParts );
1834 for (
int i = 0; i < nParts; ++i )
1836 std::unique_ptr< QgsAbstractGeometry > curve(
fromGeos( GEOSGetGeometryN_r( context,
geos, i ) ) );
1837 multiCurve->addGeometry( curve.release() );
1839 return std::move( multiCurve );
1842 case GEOS_MULTIPOLYGON:
1844 auto multiPolygon = std::make_unique<QgsMultiPolygon>();
1846 const int nParts = GEOSGetNumGeometries_r( context,
geos );
1847 multiPolygon->reserve( nParts );
1848 for (
int i = 0; i < nParts; ++i )
1850 std::unique_ptr< QgsPolygon > poly =
fromGeosPolygon( GEOSGetGeometryN_r( context,
geos, i ) );
1853 multiPolygon->addGeometry( poly.release() );
1856 return std::move( multiPolygon );
1858#if GEOS_VERSION_NUM >= GEOS_COMPUTE_VERSION( 3, 15, 0 )
1859 case GEOS_MULTISURFACE:
1861 auto multiSurface = std::make_unique<QgsMultiSurface>();
1862 const int nParts = GEOSGetNumGeometries_r( context,
geos );
1863 multiSurface->reserve( nParts );
1864 for (
int i = 0; i < nParts; ++i )
1866 std::unique_ptr< QgsAbstractGeometry > polygon(
fromGeos( GEOSGetGeometryN_r( context,
geos, i ) ) );
1867 multiSurface->addGeometry( polygon.release() );
1869 return std::move( multiSurface );
1872 case GEOS_GEOMETRYCOLLECTION:
1874 auto geomCollection = std::make_unique<QgsGeometryCollection>();
1875 const int nParts = GEOSGetNumGeometries_r( context,
geos );
1876 geomCollection->reserve( nParts );
1877 for (
int i = 0; i < nParts; ++i )
1879 std::unique_ptr< QgsAbstractGeometry > geom(
fromGeos( GEOSGetGeometryN_r( context,
geos, i ) ) );
1882 geomCollection->addGeometry( geom.release() );
1885 return std::move( geomCollection );
1891#if GEOS_VERSION_NUM >= GEOS_COMPUTE_VERSION( 3, 15, 0 )
1895 if ( GEOSGeomTypeId_r( context,
geos ) != GEOS_CURVEPOLYGON )
1900#ifdef GEOS_SUPPORTS_ZM
1901 bool hasZ = GEOSHasZ_r( context,
geos );
1902 bool hasM = GEOSHasM_r( context,
geos );
1904 int nCoordDims = GEOSGeom_getCoordinateDimension_r( context,
geos );
1905 int nDims = GEOSGeom_getDimensions_r( context,
geos );
1906 bool hasZ = ( nCoordDims == 3 );
1907 bool hasM = ( ( nDims - nCoordDims ) == 1 );
1910 auto curvePolygon = std::make_unique<QgsCurvePolygon>();
1915 if ( GEOSGeomTypeId_r( context, ring ) == GEOS_COMPOUNDCURVE )
1917 curvePolygon->setExteriorRing( qgis::down_cast< QgsCompoundCurve *>(
fromGeos( ring ).release() ) );
1921 curvePolygon->setExteriorRing( sequenceToSimpleCurve( ring, hasZ, hasM ).release() );
1925 QVector<QgsCurve *> interiorRings;
1926 const int ringCount = GEOSGetNumInteriorRings_r( context,
geos );
1927 interiorRings.reserve( ringCount );
1928 for (
int i = 0; i < ringCount; ++i )
1930 ring = GEOSGetInteriorRingN_r( context,
geos, i );
1933 if ( GEOSGeomTypeId_r( context, ring ) == GEOS_COMPOUNDCURVE )
1935 interiorRings.push_back( qgis::down_cast< QgsCompoundCurve *>(
fromGeos( ring ).release() ) );
1939 interiorRings.push_back( sequenceToSimpleCurve( ring, hasZ, hasM ).release() );
1943 curvePolygon->setInteriorRings( interiorRings );
1945 return curvePolygon;
1952 if ( GEOSGeomTypeId_r( context,
geos ) != GEOS_POLYGON )
1957#ifdef GEOS_SUPPORTS_ZM
1958 bool hasZ = GEOSHasZ_r( context,
geos );
1959 bool hasM = GEOSHasM_r( context,
geos );
1961 int nCoordDims = GEOSGeom_getCoordinateDimension_r( context,
geos );
1962 int nDims = GEOSGeom_getDimensions_r( context,
geos );
1963 bool hasZ = ( nCoordDims == 3 );
1964 bool hasM = ( ( nDims - nCoordDims ) == 1 );
1967 auto polygon = std::make_unique<QgsPolygon>();
1972 polygon->setExteriorRing( sequenceToLinestring( ring, hasZ, hasM ).release() );
1975 QVector<QgsCurve *> interiorRings;
1976 const int ringCount = GEOSGetNumInteriorRings_r( context,
geos );
1977 interiorRings.reserve( ringCount );
1978 for (
int i = 0; i < ringCount; ++i )
1980 ring = GEOSGetInteriorRingN_r( context,
geos, i );
1983 interiorRings.push_back( sequenceToLinestring( ring, hasZ, hasM ).release() );
1986 polygon->setInteriorRings( interiorRings );
1991std::unique_ptr<QgsSimpleCurve> QgsGeos::sequenceToSimpleCurve(
const GEOSGeometry *
geos,
bool hasZ,
bool hasM )
1995 const int geometryType = GEOSGeomTypeId_r( context,
geos );
1996 if ( !( geometryType == GEOS_LINESTRING || geometryType == GEOS_LINEARRING || geometryType == GEOS_CIRCULARSTRING ) )
1999 const GEOSCoordSequence *cs = GEOSGeom_getCoordSeq_r( context,
geos );
2001 unsigned int nPoints;
2002 GEOSCoordSeq_getSize_r( context, cs, &nPoints );
2004 QVector< double > xOut( nPoints );
2005 QVector< double > yOut( nPoints );
2006 QVector< double > zOut;
2008 zOut.resize( nPoints );
2009 QVector< double > mOut;
2011 mOut.resize( nPoints );
2013 double *x = xOut.data();
2014 double *y = yOut.data();
2015 double *z = zOut.data();
2016 double *m = mOut.data();
2018#if GEOS_VERSION_NUM >= GEOS_COMPUTE_VERSION( 3, 10, 0 )
2019 GEOSCoordSeq_copyToArrays_r( context, cs, x, y, hasZ ? z :
nullptr, hasM ? m :
nullptr );
2021 for (
unsigned int i = 0; i < nPoints; ++i )
2024 GEOSCoordSeq_getXYZ_r( context, cs, i, x++, y++, z++ );
2026 GEOSCoordSeq_getXY_r( context, cs, i, x++, y++ );
2029 GEOSCoordSeq_getOrdinate_r( context, cs, i, 3, m++ );
2034 std::unique_ptr< QgsSimpleCurve > simpleCurve;
2035 if ( geometryType == GEOS_LINESTRING || geometryType == GEOS_LINEARRING )
2037 simpleCurve = std::make_unique<QgsLineString>( xOut, yOut, zOut, mOut );
2039 else if ( geometryType == GEOS_CIRCULARSTRING )
2041 simpleCurve = std::make_unique<QgsCircularString>( xOut, yOut, zOut, mOut );
2046std::unique_ptr<QgsLineString> QgsGeos::sequenceToLinestring(
const GEOSGeometry *geos,
bool hasZ,
bool hasM )
2048 return std::unique_ptr<QgsLineString>( qgis::down_cast<QgsLineString *>( sequenceToSimpleCurve( geos, hasZ, hasM ).release() ) );
2051#if GEOS_VERSION_NUM >= GEOS_COMPUTE_VERSION( 3, 15, 0 )
2052std::unique_ptr<QgsCircularString> QgsGeos::sequenceToCircularString(
const GEOSGeometry *geos,
bool hasZ,
bool hasM )
2054 return std::unique_ptr<QgsCircularString>( qgis::down_cast<QgsCircularString *>( sequenceToSimpleCurve( geos, hasZ, hasM ).release() ) );
2064 int geometryType = GEOSGeomTypeId_r( context, g );
2065 if ( geometryType == GEOS_POINT || geometryType == GEOS_LINESTRING || geometryType == GEOS_LINEARRING || geometryType == GEOS_POLYGON )
2069 return GEOSGetNumGeometries_r( context, g );
2085 GEOSCoordSeq_getXYZ_r( context, cs, i, &x, &y, &z );
2087 GEOSCoordSeq_getXY_r( context, cs, i, &x, &y );
2090 GEOSCoordSeq_getOrdinate_r( context, cs, i, 3, &m );
2130 geosType = GEOS_MULTIPOINT;
2134#if GEOS_VERSION_NUM < GEOS_COMPUTE_VERSION( 3, 15, 0 )
2137 geosType = GEOS_MULTILINESTRING;
2141#if GEOS_VERSION_NUM < GEOS_COMPUTE_VERSION( 3, 15, 0 )
2144 geosType = GEOS_MULTIPOLYGON;
2147#if GEOS_VERSION_NUM >= GEOS_COMPUTE_VERSION( 3, 15, 0 )
2149 geosType = GEOS_MULTICURVE;
2153 geosType = GEOS_MULTISURFACE;
2158 geosType = GEOS_GEOMETRYCOLLECTION;
2172 std::vector<geos::unique_ptr> geomVector;
2173 geomVector.reserve(
c->numGeometries() );
2174 for (
int i = 0; i <
c->numGeometries(); ++i )
2181 geomVector.emplace_back( std::move( geosGeom ) );
2183 return createGeosCollection( geosType, geomVector );
2190 return createGeosPoint( geom, coordDims, precision, flags );
2195#if GEOS_VERSION_NUM < GEOS_COMPUTE_VERSION( 3, 15, 0 )
2197 return createGeosLinestring( geom, precision, flags );
2199 return createGeosSimpleCurve( geom, precision, flags );
2202 return createGeosCompoundCurve( geom, precision, flags );
2207#if GEOS_VERSION_NUM < GEOS_COMPUTE_VERSION( 3, 15, 0 )
2210 return createGeosPolygon( geom, precision, flags );
2212#if GEOS_VERSION_NUM >= GEOS_COMPUTE_VERSION( 3, 15, 0 )
2214 return createGeosCurvePolygon( geom, precision, flags );
2223 if ( !polyhedralSurface )
2226 std::vector<geos::unique_ptr> geomVector;
2227 geomVector.reserve( polyhedralSurface->
numPatches() );
2228 for (
int i = 0; i < polyhedralSurface->
numPatches(); ++i )
2235 geomVector.emplace_back( std::move( geosPolygon ) );
2238 return createGeosCollection( GEOS_MULTIPOLYGON, geomVector );
2252 if ( !mGeos || !geom )
2263 QgsScopedGeosContextRegisterFeedback interrupt( feedback );
2265 const double gridSize = parameters.
gridSize();
2273 case OverlayIntersection:
2276 opGeom.reset( GEOSIntersectionPrec_r( context, mGeos.get(), geosGeom.get(), gridSize ) );
2280 opGeom.reset( GEOSIntersection_r( context, mGeos.get(), geosGeom.get() ) );
2284 case OverlayDifference:
2287 opGeom.reset( GEOSDifferencePrec_r( context, mGeos.get(), geosGeom.get(), gridSize ) );
2291 opGeom.reset( GEOSDifference_r( context, mGeos.get(), geosGeom.get() ) );
2300 unionGeometry.reset( GEOSUnionPrec_r( context, mGeos.get(), geosGeom.get(), gridSize ) );
2304 unionGeometry.reset( GEOSUnion_r( context, mGeos.get(), geosGeom.get() ) );
2307#if GEOS_VERSION_NUM < GEOS_COMPUTE_VERSION( 3, 15, 0 )
2308 if ( unionGeometry && GEOSGeomTypeId_r( context, unionGeometry.get() ) == GEOS_MULTILINESTRING )
2310 geos::unique_ptr mergedLines( GEOSLineMerge_r( context, unionGeometry.get() ) );
2313 unionGeometry = std::move( mergedLines );
2318 opGeom = std::move( unionGeometry );
2322 case OverlaySymDifference:
2325 opGeom.reset( GEOSSymDifferencePrec_r( context, mGeos.get(), geosGeom.get(), gridSize ) );
2329 opGeom.reset( GEOSSymDifference_r( context, mGeos.get(), geosGeom.get() ) );
2335 catch ( QgsGeosException &e )
2340 *errorMsg = e.what();
2346bool QgsGeos::relation(
const QgsAbstractGeometry *geom, Relation r, QString *errorMsg, QgsFeedback *feedback )
const
2348 if ( !mGeos || !geom )
2360 QgsScopedGeosContextRegisterFeedback interrupt( feedback );
2362 bool result =
false;
2365 if ( mGeosPrepared )
2369 case RelationIntersects:
2370 result = ( GEOSPreparedIntersects_r( context, mGeosPrepared.get(), geosGeom.get() ) == 1 );
2372 case RelationTouches:
2373 result = ( GEOSPreparedTouches_r( context, mGeosPrepared.get(), geosGeom.get() ) == 1 );
2375 case RelationCrosses:
2376 result = ( GEOSPreparedCrosses_r( context, mGeosPrepared.get(), geosGeom.get() ) == 1 );
2378 case RelationWithin:
2379 result = ( GEOSPreparedWithin_r( context, mGeosPrepared.get(), geosGeom.get() ) == 1 );
2381 case RelationContains:
2382 result = ( GEOSPreparedContains_r( context, mGeosPrepared.get(), geosGeom.get() ) == 1 );
2384 case RelationDisjoint:
2385 result = ( GEOSPreparedDisjoint_r( context, mGeosPrepared.get(), geosGeom.get() ) == 1 );
2387 case RelationOverlaps:
2388 result = ( GEOSPreparedOverlaps_r( context, mGeosPrepared.get(), geosGeom.get() ) == 1 );
2396 case RelationIntersects:
2397 result = ( GEOSIntersects_r( context, mGeos.get(), geosGeom.get() ) == 1 );
2399 case RelationTouches:
2400 result = ( GEOSTouches_r( context, mGeos.get(), geosGeom.get() ) == 1 );
2402 case RelationCrosses:
2403 result = ( GEOSCrosses_r( context, mGeos.get(), geosGeom.get() ) == 1 );
2405 case RelationWithin:
2406 result = ( GEOSWithin_r( context, mGeos.get(), geosGeom.get() ) == 1 );
2408 case RelationContains:
2409 result = ( GEOSContains_r( context, mGeos.get(), geosGeom.get() ) == 1 );
2411 case RelationDisjoint:
2412 result = ( GEOSDisjoint_r( context, mGeos.get(), geosGeom.get() ) == 1 );
2414 case RelationOverlaps:
2415 result = ( GEOSOverlaps_r( context, mGeos.get(), geosGeom.get() ) == 1 );
2419 catch ( QgsGeosException &e )
2424 *errorMsg = e.what();
2469 geos.reset( GEOSBufferWithStyle_r(
QgsGeosContext::get(), geometry,
distance, segments,
static_cast< int >( endCapStyle ),
static_cast< int >( joinStyle ), miterLimit ) );
2522 geos.reset( GEOSGetCentroid_r( context, mGeos.get() ) );
2527 GEOSGeomGetX_r( context,
geos.get(), &x );
2528 GEOSGeomGetY_r( context,
geos.get(), &y );
2565 geos.reset( GEOSPointOnSurface_r( context, mGeos.get() ) );
2567 if ( !
geos || GEOSisEmpty_r( context,
geos.get() ) != 0 )
2572 GEOSGeomGetX_r( context,
geos.get(), &x );
2573 GEOSGeomGetY_r( context,
geos.get(), &y );
2591 std::unique_ptr< QgsAbstractGeometry > cHullGeom =
fromGeos( cHull.get() );
2592 return cHullGeom.release();
2599#if GEOS_VERSION_NUM < GEOS_COMPUTE_VERSION( 3, 11, 0 )
2600 ( void ) allowHoles;
2601 ( void ) targetPercent;
2603 throw QgsNotSupportedException( QObject::tr(
"Calculating concaveHull requires a QGIS build based on GEOS 3.11 or later" ) );
2615 return concaveHullGeom;
2623#if GEOS_VERSION_NUM < GEOS_COMPUTE_VERSION( 3, 11, 0 )
2624 ( void ) allowHoles;
2625 ( void ) targetPercent;
2627 throw QgsNotSupportedException( QObject::tr(
"Calculating concaveHullOfPolygons requires a QGIS build based on GEOS 3.11 or later" ) );
2639 return concaveHullGeom;
2647#if GEOS_VERSION_NUM < GEOS_COMPUTE_VERSION( 3, 12, 0 )
2649 ( void ) invalidEdges;
2651 throw QgsNotSupportedException( QObject::tr(
"Validating coverages requires a QGIS build based on GEOS 3.12 or later" ) );
2656 *errorMsg = u
"Input geometry was not set"_s;
2665 const int result = GEOSCoverageIsValid_r( context, mGeos.get(), gapWidth, invalidEdges ? &invalidEdgesGeos :
nullptr );
2666 if ( invalidEdges && invalidEdgesGeos )
2668 *invalidEdges =
fromGeos( invalidEdgesGeos );
2670 if ( invalidEdgesGeos )
2672 GEOSGeom_destroy_r( context, invalidEdgesGeos );
2673 invalidEdgesGeos =
nullptr;
2693#if GEOS_VERSION_NUM < GEOS_COMPUTE_VERSION( 3, 12, 0 )
2695 ( void ) preserveBoundary;
2697 throw QgsNotSupportedException( QObject::tr(
"Simplifying coverages requires a QGIS build based on GEOS 3.12 or later" ) );
2702 *errorMsg = u
"Input geometry was not set"_s;
2710 std::unique_ptr< QgsAbstractGeometry > simplifiedGeom =
fromGeos( simplified.get() );
2711 return simplifiedGeom;
2722 *errorMsg = u
"Input geometry was not set"_s;
2730 std::unique_ptr< QgsAbstractGeometry > result =
fromGeos( unioned.get() );
2738#if GEOS_VERSION_NUM < GEOS_COMPUTE_VERSION( 3, 14, 0 )
2739 ( void ) parameters;
2742 throw QgsNotSupportedException( QObject::tr(
"Cleaning coverages requires a QGIS build based on GEOS 3.14 or later" ) );
2747 *errorMsg = u
"Input geometry was not set"_s;
2751 GEOSCoverageCleanParams *params =
nullptr;
2780 std::unique_ptr< QgsAbstractGeometry> cleanedGeom =
fromGeos( cleaned.get() );
2784 catch ( QgsGeosException &e )
2794 *errorMsg = e.what();
2795 if ( errorMsg->startsWith(
"InterruptedException"_L1, Qt::CaseInsensitive ) )
2810 *errorMsg = QObject::tr(
"QGIS geometry cannot be converted to a GEOS geometry",
"GEOS Error" );
2820 char res = GEOSisValidDetail_r( context, mGeos.get(), allowSelfTouchingHoles ? GEOSVALID_ALLOW_SELFTOUCHING_RING_FORMING_HOLE : 0, &r, &g1 );
2821 const bool invalid = res != 1;
2826 error = QString( r );
2827 GEOSFree_r( context, r );
2830 if ( invalid && errorMsg )
2833 static const std::map< QString, QString > sTranslatedErrors {
2834 { u
"topology validation error"_s, QObject::tr(
"Topology validation error",
"GEOS Error" ) },
2835 { u
"repeated point"_s, QObject::tr(
"Repeated point",
"GEOS Error" ) },
2836 { u
"hole lies outside shell"_s, QObject::tr(
"Hole lies outside shell",
"GEOS Error" ) },
2837 { u
"holes are nested"_s, QObject::tr(
"Holes are nested",
"GEOS Error" ) },
2838 { u
"interior is disconnected"_s, QObject::tr(
"Interior is disconnected",
"GEOS Error" ) },
2839 { u
"self-intersection"_s, QObject::tr(
"Self-intersection",
"GEOS Error" ) },
2840 { u
"ring self-intersection"_s, QObject::tr(
"Ring self-intersection",
"GEOS Error" ) },
2841 { u
"nested shells"_s, QObject::tr(
"Nested shells",
"GEOS Error" ) },
2842 { u
"duplicate rings"_s, QObject::tr(
"Duplicate rings",
"GEOS Error" ) },
2843 { u
"too few points in geometry component"_s, QObject::tr(
"Too few points in geometry component",
"GEOS Error" ) },
2844 { u
"invalid coordinate"_s, QObject::tr(
"Invalid coordinate",
"GEOS Error" ) },
2845 { u
"ring is not closed"_s, QObject::tr(
"Ring is not closed",
"GEOS Error" ) },
2848 const auto translatedError = sTranslatedErrors.find( error.toLower() );
2849 if ( translatedError != sTranslatedErrors.end() )
2850 *errorMsg = translatedError->second;
2854 if ( g1 && errorLoc )
2860 GEOSGeom_destroy_r( context, g1 );
2870 if ( !mGeos || !geom )
2891 if ( !mGeos || !geom )
2905 bool equal = GEOSEqualsExact_r(
QgsGeosContext::get(), mGeos.get(), geosGeom.get(), epsilon );
2939GEOSCoordSequence *QgsGeos::createCoordinateSequence(
const QgsCurve *curve,
double precision,
bool forceClose )
2944#if GEOS_VERSION_NUM >= GEOS_COMPUTE_VERSION( 3, 15, 0 )
2954 std::unique_ptr< QgsLineString > segmentized;
2958 simpleCurve = segmentized.get();
2960#if GEOS_VERSION_NUM >= GEOS_COMPUTE_VERSION( 3, 15, 0 )
2968 GEOSCoordSequence *coordSeq =
nullptr;
2970 const int numPoints = simpleCurve->
numPoints();
2972 const bool hasZ = simpleCurve->
is3D();
2973#ifdef GEOS_SUPPORTS_ZM
2974 const bool hasM = simpleCurve->
isMeasure();
2976 const bool hasM =
false;
2979#if GEOS_VERSION_NUM >= GEOS_COMPUTE_VERSION( 3, 10, 0 )
2982 if ( !forceClose || ( simpleCurve->
pointN( 0 ) == simpleCurve->
pointN( numPoints - 1 ) ) )
2987#ifdef GEOS_SUPPORTS_ZM
2988 coordSeq = GEOSCoordSeq_copyFromArrays_r( context, simpleCurve->
xData(), simpleCurve->
yData(), simpleCurve->
zData(), simpleCurve->
mData(), numPoints );
2990 coordSeq = GEOSCoordSeq_copyFromArrays_r( context, simpleCurve->
xData(), simpleCurve->
yData(), simpleCurve->
zData(),
nullptr, numPoints );
2994 QgsDebugError( u
"GEOS Exception: Could not create coordinate sequence for %1 points"_s.arg( numPoints ) );
3002 QVector< double > x = simpleCurve->
xVector();
3003 if ( numPoints > 0 )
3004 x.append( x.at( 0 ) );
3005 QVector< double > y = simpleCurve->
yVector();
3006 if ( numPoints > 0 )
3007 y.append( y.at( 0 ) );
3008 QVector< double > z = simpleCurve->
zVector();
3009 if ( hasZ && numPoints > 0 )
3010 z.append( z.at( 0 ) );
3011 QVector< double > m = simpleCurve->
mVector();
3012 if ( hasM && numPoints > 0 )
3013 m.append( m.at( 0 ) );
3016 coordSeq = GEOSCoordSeq_copyFromArrays_r( context, x.constData(), y.constData(), !hasZ ?
nullptr : z.constData(), !hasM ?
nullptr : m.constData(), numPoints + 1 );
3019 QgsDebugError( u
"GEOS Exception: Could not create closed coordinate sequence for %1 points"_s.arg( numPoints + 1 ) );
3040 int numOutPoints = numPoints;
3041 if ( forceClose && ( simpleCurve->
pointN( 0 ) != simpleCurve->
pointN( numPoints - 1 ) ) )
3048 coordSeq = GEOSCoordSeq_create_r( context, numOutPoints, coordDims );
3051 QgsDebugError( u
"GEOS Exception: Could not create coordinate sequence for %1 points in %2 dimensions"_s.arg( numPoints ).arg( coordDims ) );
3055 const double *xData = simpleCurve->
xData();
3056 const double *yData = simpleCurve->
yData();
3057 const double *zData = hasZ ? simpleCurve->
zData() :
nullptr;
3058 const double *mData = hasM ? simpleCurve->
mData() :
nullptr;
3060 if ( precision > 0. )
3062 for (
int i = 0; i < numOutPoints; ++i )
3064 if ( i >= numPoints )
3067 xData = simpleCurve->
xData();
3068 yData = simpleCurve->
yData();
3069 zData = hasZ ? simpleCurve->
zData() :
nullptr;
3070 mData = hasM ? simpleCurve->
mData() :
nullptr;
3074 GEOSCoordSeq_setXYZ_r( context, coordSeq, i, std::round( *xData++ / precision ) * precision, std::round( *yData++ / precision ) * precision, std::round( *zData++ / precision ) * precision );
3078 GEOSCoordSeq_setXY_r( context, coordSeq, i, std::round( *xData++ / precision ) * precision, std::round( *yData++ / precision ) * precision );
3082 GEOSCoordSeq_setOrdinate_r( context, coordSeq, i, 3, *mData++ );
3088 for (
int i = 0; i < numOutPoints; ++i )
3090 if ( i >= numPoints )
3093 xData = simpleCurve->
xData();
3094 yData = simpleCurve->
yData();
3095 zData = hasZ ? simpleCurve->
zData() :
nullptr;
3096 mData = hasM ? simpleCurve->
mData() :
nullptr;
3100 GEOSCoordSeq_setXYZ_r( context, coordSeq, i, *xData++, *yData++, *zData++ );
3104 GEOSCoordSeq_setXY_r( context, coordSeq, i, *xData++, *yData++ );
3108 GEOSCoordSeq_setOrdinate_r( context, coordSeq, i, 3, *mData++ );
3118geos::unique_ptr
QgsGeos::createGeosPoint( const QgsAbstractGeometry *point,
int coordDims,
double precision, Qgis::GeosCreationFlags )
3124 return createGeosPointXY( pt->
x(), pt->
y(), pt->
is3D(), pt->
z(), pt->
isMeasure(), pt->
m(), coordDims, precision );
3129#ifndef GEOS_SUPPORTS_ZM
3138 if ( coordDims == 2 )
3141 if ( precision > 0. )
3142 geosPoint.reset( GEOSGeom_createPointFromXY_r( context, std::round( x / precision ) * precision, std::round( y / precision ) * precision ) );
3144 geosPoint.reset( GEOSGeom_createPointFromXY_r( context, x, y ) );
3148#ifdef GEOS_SUPPORTS_ZM
3149 GEOSCoordSequence *coordSeq = GEOSCoordSeq_createWithDimensions_r( context, 1, hasZ ? 1 : 0, hasM ? 1 : 0 );
3151 GEOSCoordSequence *coordSeq = GEOSCoordSeq_create_r( context, 1, coordDims );
3155 QgsDebugError( u
"GEOS Exception: Could not create coordinate sequence for point with %1 dimensions"_s.arg( coordDims ) );
3158 if ( precision > 0. )
3160 GEOSCoordSeq_setX_r( context, coordSeq, 0, std::round( x / precision ) * precision );
3161 GEOSCoordSeq_setY_r( context, coordSeq, 0, std::round( y / precision ) * precision );
3164#ifdef GEOS_SUPPORTS_ZM
3165 GEOSCoordSeq_setZ_r( context, coordSeq, 0, z );
3167 GEOSCoordSeq_setOrdinate_r( context, coordSeq, 0, 2, std::round( z / precision ) * precision );
3173 GEOSCoordSeq_setX_r( context, coordSeq, 0, x );
3174 GEOSCoordSeq_setY_r( context, coordSeq, 0, y );
3177#ifdef GEOS_SUPPORTS_ZM
3178 GEOSCoordSeq_setZ_r( context, coordSeq, 0, z );
3180 GEOSCoordSeq_setOrdinate_r( context, coordSeq, 0, 2, z );
3184#ifdef GEOS_SUPPORTS_ZM
3187 GEOSCoordSeq_setM_r( context, coordSeq, 0, m );
3190 geosPoint.reset( GEOSGeom_createPoint_r( context, coordSeq ) );
3196geos::unique_ptr
QgsGeos::createGeosLinestring( const QgsAbstractGeometry *curve,
double precision, Qgis::GeosCreationFlags )
3202 GEOSCoordSequence *coordSeq = createCoordinateSequence(
c, precision );
3215#if GEOS_VERSION_NUM >= GEOS_COMPUTE_VERSION( 3, 15, 0 )
3222 if ( !
c->isSimpleCurve() )
3225 GEOSCoordSequence *coordSeq = createCoordinateSequence(
c, precision );
3232 if ( !
c->hasCurvedSegments() )
3245geos::unique_ptr
QgsGeos::createGeosCompoundCurve( const QgsAbstractGeometry *curve,
double precision, Qgis::GeosCreationFlags flags )
3256 const int nCurves =
c->nCurves();
3259 for (
int i = 0; i < nCurves; i++ )
3261 if (
c->curveAt( i )->isSimpleCurve() )
3263 curves[i] = createGeosSimpleCurve(
c->curveAt( i ), precision, flags ).release();
3266 geosCurve.reset( GEOSGeom_createCompoundCurve_r( context, curves, nCurves ) );
3273geos::unique_ptr
QgsGeos::createGeosCurvePolygon( const QgsAbstractGeometry *poly,
double precision, Qgis::GeosCreationFlags flags )
3279 const QgsCurve *exteriorRing = polygon->
exteriorRing();
3280 if ( !exteriorRing )
3292 exteriorRingGeos.reset( createGeosSimpleCurve( exteriorRing, precision, flags ).release() );
3296 exteriorRingGeos.reset( createGeosCompoundCurve( exteriorRing, precision, flags ).release() );
3300 QList< const QgsCurve * > holesToExport;
3301 holesToExport.reserve( nInteriorRings );
3302 for (
int i = 0; i < nInteriorRings; ++i )
3304 const QgsCurve *interiorRing = polygon->
interiorRing( i );
3307 holesToExport << interiorRing;
3312 if ( !holesToExport.empty() )
3315 for (
int i = 0; i < holesToExport.size(); ++i )
3317 if ( holesToExport[i]->isSimpleCurve() )
3319 holes[i] = createGeosSimpleCurve( holesToExport[i], precision, flags ).release();
3323 holes[i] = createGeosCompoundCurve( holesToExport[i], precision, flags ).release();
3328 geosCurvePolygon.reset( GEOSGeom_createCurvePolygon_r( context, exteriorRingGeos.release(), holes, holesToExport.size() ) );
3333 return geosCurvePolygon;
3343 const QgsCurve *exteriorRing = polygon->
exteriorRing();
3344 if ( !exteriorRing )
3353 geos::unique_ptr exteriorRingGeos( GEOSGeom_createLinearRing_r( context, createCoordinateSequence( exteriorRing, precision,
true ) ) );
3356 QList< const QgsCurve * > holesToExport;
3357 holesToExport.reserve( nInteriorRings );
3358 for (
int i = 0; i < nInteriorRings; ++i )
3360 const QgsCurve *interiorRing = polygon->
interiorRing( i );
3363 holesToExport << interiorRing;
3368 if ( !holesToExport.empty() )
3371 for (
int i = 0; i < holesToExport.size(); ++i )
3373 holes[i] = GEOSGeom_createLinearRing_r( context, createCoordinateSequence( holesToExport[i], precision,
true ) );
3377 geosPolygon.reset( GEOSGeom_createPolygon_r( context, exteriorRingGeos.release(), holes, holesToExport.size() ) );
3398 offset.reset( GEOSOffsetCurve_r(
QgsGeosContext::get(), geometry,
distance, segments,
static_cast< int >( joinStyle ), miterLimit ) );
3410 return fromGeos( res.get() ).release();
3428 GEOSBufferParams_setSingleSided_r( context, bp.get(), 1 );
3429 GEOSBufferParams_setQuadrantSegments_r( context, bp.get(), segments );
3430 GEOSBufferParams_setJoinStyle_r( context, bp.get(),
static_cast< int >( joinStyle ) );
3431 GEOSBufferParams_setMitreLimit_r( context, bp.get(), miterLimit );
3437 geos.reset( GEOSBufferWithParams_r( context, mGeos.get(), bp.get(),
distance ) );
3472 boundaryGeos =
asGeos( boundary );
3502 return std::numeric_limits< double >::quiet_NaN();
3511 return std::numeric_limits< double >::quiet_NaN();
3553 if ( !mGeos || !other )
3574 if ( !mGeos ||
mGeometry->dimension() == 0 )
3592 geos::unique_ptr reshapeLineGeos = createGeosLinestring( &reshapeWithLine, mPrecision );
3596 int numGeoms = GEOSGetNumGeometries_r( context, mGeos.get() );
3597 if ( numGeoms == -1 )
3606 bool isMultiGeom =
false;
3607 int geosTypeId = GEOSGeomTypeId_r( context, mGeos.get() );
3608 if ( geosTypeId == GEOS_MULTILINESTRING || geosTypeId == GEOS_MULTIPOLYGON )
3611 bool isLine = (
mGeometry->dimension() == 1 );
3618 reshapedGeometry = reshapeLine( mGeos.get(), reshapeLineGeos.get(), mPrecision );
3622 reshapedGeometry = reshapePolygon( mGeos.get(), reshapeLineGeos.get(), mPrecision );
3627 if ( reshapedGeometry )
3633 std::unique_ptr< QgsAbstractGeometry > reshapeResult =
fromGeos( reshapedGeometry.get() );
3634 return reshapeResult;
3641 bool reshapeTookPlace =
false;
3646 for (
int i = 0; i < numGeoms; ++i )
3649 currentReshapeGeometry = reshapeLine( GEOSGetGeometryN_r( context, mGeos.get(), i ), reshapeLineGeos.get(), mPrecision );
3651 currentReshapeGeometry = reshapePolygon( GEOSGetGeometryN_r( context, mGeos.get(), i ), reshapeLineGeos.get(), mPrecision );
3653 if ( currentReshapeGeometry )
3655 newGeoms[i] = currentReshapeGeometry.release();
3656 reshapeTookPlace =
true;
3660 newGeoms[i] = GEOSGeom_clone_r( context, GEOSGetGeometryN_r( context, mGeos.get(), i ) );
3667 newMultiGeom.reset( GEOSGeom_createCollection_r( context, GEOS_MULTILINESTRING, newGeoms, numGeoms ) );
3671 newMultiGeom.reset( GEOSGeom_createCollection_r( context, GEOS_MULTIPOLYGON, newGeoms, numGeoms ) );
3675 if ( !newMultiGeom )
3684 if ( reshapeTookPlace )
3688 std::unique_ptr< QgsAbstractGeometry > reshapedMultiGeom =
fromGeos( newMultiGeom.get() );
3689 return reshapedMultiGeom;
3712 if ( GEOSGeomTypeId_r( context, mGeos.get() ) != GEOS_MULTILINESTRING )
3719 double gridSize = parameters.
gridSize();
3722 geos::unique_ptr geosFixedSize( GEOSGeom_setPrecision_r( context, mGeos.get(), gridSize, 0 ) );
3723 geos.reset( GEOSLineMerge_r( context, geosFixedSize.get() ) );
3726 geos.reset( GEOSLineMerge_r( context, mGeos.get() ) );
3752 if ( mGeosPrepared )
3754 nearestCoord.reset( GEOSPreparedNearestPoints_r( context, mGeosPrepared.get(), otherGeom.get() ) );
3758 nearestCoord.reset( GEOSNearestPoints_r( context, mGeos.get(), otherGeom.get() ) );
3761 ( void ) GEOSCoordSeq_getX_r( context, nearestCoord.get(), 0, &nx );
3762 ( void ) GEOSCoordSeq_getY_r( context, nearestCoord.get(), 0, &ny );
3764 catch ( QgsGeosException &e )
3769 *errorMsg = e.what();
3774 return std::make_unique< QgsPoint >( nx, ny );
3779 if ( !mGeos || other.
isEmpty() )
3789 if ( !other || other->
isEmpty() )
3808 if ( !nearestCoord )
3811 *errorMsg = u
"GEOS returned no nearest points"_s;
3815 ( void ) GEOSCoordSeq_getX_r( context, nearestCoord.get(), 0, &nx1 );
3816 ( void ) GEOSCoordSeq_getY_r( context, nearestCoord.get(), 0, &ny1 );
3817 ( void ) GEOSCoordSeq_getX_r( context, nearestCoord.get(), 1, &nx2 );
3818 ( void ) GEOSCoordSeq_getY_r( context, nearestCoord.get(), 1, &ny2 );
3820 catch ( QgsGeosException &e )
3825 *errorMsg = e.what();
3830 auto line = std::make_unique< QgsLineString >();
3855 catch ( QgsGeosException &e )
3860 *errorMsg = e.what();
3875 geos::unique_ptr point = createGeosPointXY( x, y,
false, 0,
false, 0, 2, 0 );
3885 catch ( QgsGeosException &e )
3890 *errorMsg = e.what();
3907 lineGeosGeometries[validLines] = l.release();
3916 geos::unique_ptr result( GEOSPolygonize_r( context, lineGeosGeometries, validLines ) );
3917 for (
int i = 0; i < validLines; ++i )
3919 GEOSGeom_destroy_r( context, lineGeosGeometries[i] );
3921 delete[] lineGeosGeometries;
3924 catch ( QgsGeosException &e )
3928 *errorMsg = e.what();
3930 for (
int i = 0; i < validLines; ++i )
3932 GEOSGeom_destroy_r( context, lineGeosGeometries[i] );
3934 delete[] lineGeosGeometries;
3949 extentGeosGeom =
asGeos( extent, mPrecision );
3950 if ( !extentGeosGeom )
3961 geos.reset( GEOSVoronoiDiagram_r( context, mGeos.get(), extentGeosGeom.get(), tolerance, edgesOnly ) );
3963 if ( !
geos || GEOSisEmpty_r( context,
geos.get() ) != 0 )
3985 geos.reset( GEOSDelaunayTriangulation_r( context, mGeos.get(), tolerance, edgesOnly ) );
3987 if ( !
geos || GEOSisEmpty_r( context,
geos.get() ) != 0 )
3999#if GEOS_VERSION_NUM < GEOS_COMPUTE_VERSION( 3, 11, 0 )
4001 throw QgsNotSupportedException( QObject::tr(
"Calculating constrainedDelaunayTriangulation requires a QGIS build based on GEOS 3.11 or later" ) );
4013 geos.reset( GEOSConstrainedDelaunayTriangulation_r( context, mGeos.get() ) );
4015 if ( !
geos || GEOSisEmpty_r( context,
geos.get() ) != 0 )
4020 std::unique_ptr< QgsAbstractGeometry > res =
fromGeos(
geos.get() );
4023 return std::unique_ptr< QgsAbstractGeometry >( collection->extractPartsByType(
Qgis::WkbType::Polygon,
true ) );
4035static bool _linestringEndpoints(
const GEOSGeometry *linestring,
double &x1,
double &y1,
double &x2,
double &y2 )
4038 const GEOSCoordSequence *coordSeq = GEOSGeom_getCoordSeq_r( context, linestring );
4042 unsigned int coordSeqSize;
4043 if ( GEOSCoordSeq_getSize_r( context, coordSeq, &coordSeqSize ) == 0 )
4046 if ( coordSeqSize < 2 )
4049 GEOSCoordSeq_getX_r( context, coordSeq, 0, &x1 );
4050 GEOSCoordSeq_getY_r( context, coordSeq, 0, &y1 );
4051 GEOSCoordSeq_getX_r( context, coordSeq, coordSeqSize - 1, &x2 );
4052 GEOSCoordSeq_getY_r( context, coordSeq, coordSeqSize - 1, &y2 );
4060 double x1, y1, x2, y2;
4061 if ( !_linestringEndpoints( line1, x1, y1, x2, y2 ) )
4064 double rx1, ry1, rx2, ry2;
4065 if ( !_linestringEndpoints( line2, rx1, ry1, rx2, ry2 ) )
4068 bool intersectionAtOrigLineEndpoint = ( intersectionPoint.
x() == x1 && intersectionPoint.
y() == y1 ) != ( intersectionPoint.
x() == x2 && intersectionPoint.
y() == y2 );
4069 bool intersectionAtReshapeLineEndpoint = ( intersectionPoint.
x() == rx1 && intersectionPoint.
y() == ry1 ) || ( intersectionPoint.
x() == rx2 && intersectionPoint.
y() == ry2 );
4073 if ( intersectionAtOrigLineEndpoint && intersectionAtReshapeLineEndpoint )
4077 GEOSGeometry *geoms[2] = { g1.release(), g2.release() };
4078 geos::unique_ptr multiGeom( GEOSGeom_createCollection_r( context, GEOS_MULTILINESTRING, geoms, 2 ) );
4083 double x1res, y1res, x2res, y2res;
4084 if ( !_linestringEndpoints( res.get(), x1res, y1res, x2res, y2res ) )
4086 if ( ( x1res == x2 && y1res == y2 ) || ( x2res == x1 && y2res == y1 ) )
4087 res.reset( GEOSReverse_r( context, res.get() ) );
4098 if ( !line || !reshapeLineGeos )
4101 bool atLeastTwoIntersections =
false;
4102 bool oneIntersection =
false;
4103 QgsPointXY oneIntersectionPoint;
4109 geos::unique_ptr intersectGeom( GEOSIntersection_r( context, line, reshapeLineGeos ) );
4110 if ( intersectGeom )
4112 const int geomType = GEOSGeomTypeId_r( context, intersectGeom.get() );
4113 atLeastTwoIntersections = ( geomType == GEOS_MULTIPOINT && GEOSGetNumGeometries_r( context, intersectGeom.get() ) > 1 )
4114 || ( geomType == GEOS_GEOMETRYCOLLECTION && GEOSGetNumGeometries_r( context, intersectGeom.get() ) > 0 )
4115 || ( geomType == GEOS_MULTILINESTRING && GEOSGetNumGeometries_r( context, intersectGeom.get() ) > 0 );
4117 if ( GEOSGeomTypeId_r( context, intersectGeom.get() ) == GEOS_POINT )
4119 const GEOSCoordSequence *intersectionCoordSeq = GEOSGeom_getCoordSeq_r( context, intersectGeom.get() );
4121 GEOSCoordSeq_getX_r( context, intersectionCoordSeq, 0, &xi );
4122 GEOSCoordSeq_getY_r( context, intersectionCoordSeq, 0, &yi );
4123 oneIntersection =
true;
4124 oneIntersectionPoint = QgsPointXY( xi, yi );
4128 catch ( QgsGeosException & )
4130 atLeastTwoIntersections =
false;
4134 if ( oneIntersection )
4135 return _mergeLinestrings( line, reshapeLineGeos, oneIntersectionPoint );
4137 if ( !atLeastTwoIntersections )
4141 double x1, y1, x2, y2;
4142 if ( !_linestringEndpoints( line, x1, y1, x2, y2 ) )
4145 geos::unique_ptr beginLineVertex = createGeosPointXY( x1, y1,
false, 0,
false, 0, 2, precision );
4146 geos::unique_ptr endLineVertex = createGeosPointXY( x2, y2,
false, 0,
false, 0, 2, precision );
4148 bool isRing =
false;
4149 if ( GEOSGeomTypeId_r( context, line ) == GEOS_LINEARRING || GEOSEquals_r( context, beginLineVertex.get(), endLineVertex.get() ) == 1 )
4154 if ( !nodedGeometry )
4160 geos::unique_ptr mergedLines( GEOSLineMerge_r( context, nodedGeometry.get() ) );
4166 int numMergedLines = GEOSGetNumGeometries_r( context, mergedLines.get() );
4167 if ( numMergedLines < 2 )
4169 if ( numMergedLines == 1 )
4178 QVector<GEOSGeometry *> resultLineParts;
4179 QVector<GEOSGeometry *> probableParts;
4181 for (
int i = 0; i < numMergedLines; ++i )
4183 const GEOSGeometry *currentGeom = GEOSGetGeometryN_r( context, mergedLines.get(), i );
4186 bool alreadyAdded =
false;
4188 double bufferDistance = std::pow( 10.0L, geomDigits( currentGeom ) - 11 );
4189 for (
const GEOSGeometry *other : std::as_const( resultLineParts ) )
4191 GEOSHausdorffDistance_r( context, currentGeom, other, &
distance );
4194 alreadyAdded =
true;
4201 const GEOSCoordSequence *currentCoordSeq = GEOSGeom_getCoordSeq_r( context, currentGeom );
4202 unsigned int currentCoordSeqSize;
4203 GEOSCoordSeq_getSize_r( context, currentCoordSeq, ¤tCoordSeqSize );
4204 if ( currentCoordSeqSize < 2 )
4208 double xBegin, xEnd, yBegin, yEnd;
4209 GEOSCoordSeq_getX_r( context, currentCoordSeq, 0, &xBegin );
4210 GEOSCoordSeq_getY_r( context, currentCoordSeq, 0, &yBegin );
4211 GEOSCoordSeq_getX_r( context, currentCoordSeq, currentCoordSeqSize - 1, &xEnd );
4212 GEOSCoordSeq_getY_r( context, currentCoordSeq, currentCoordSeqSize - 1, &yEnd );
4213 geos::unique_ptr beginCurrentGeomVertex = createGeosPointXY( xBegin, yBegin,
false, 0,
false, 0, 2, precision );
4214 geos::unique_ptr endCurrentGeomVertex = createGeosPointXY( xEnd, yEnd,
false, 0,
false, 0, 2, precision );
4217 int nEndpointsOnOriginalLine = 0;
4218 if ( pointContainedInLine( beginCurrentGeomVertex.get(), line ) == 1 )
4219 nEndpointsOnOriginalLine += 1;
4221 if ( pointContainedInLine( endCurrentGeomVertex.get(), line ) == 1 )
4222 nEndpointsOnOriginalLine += 1;
4225 int nEndpointsSameAsOriginalLine = 0;
4226 if ( GEOSEquals_r( context, beginCurrentGeomVertex.get(), beginLineVertex.get() ) == 1 || GEOSEquals_r( context, beginCurrentGeomVertex.get(), endLineVertex.get() ) == 1 )
4227 nEndpointsSameAsOriginalLine += 1;
4229 if ( GEOSEquals_r( context, endCurrentGeomVertex.get(), beginLineVertex.get() ) == 1 || GEOSEquals_r( context, endCurrentGeomVertex.get(), endLineVertex.get() ) == 1 )
4230 nEndpointsSameAsOriginalLine += 1;
4233 bool currentGeomOverlapsOriginalGeom =
false;
4234 bool currentGeomOverlapsReshapeLine =
false;
4235 if ( lineContainedInLine( currentGeom, line ) == 1 )
4236 currentGeomOverlapsOriginalGeom =
true;
4238 if ( lineContainedInLine( currentGeom, reshapeLineGeos ) == 1 )
4239 currentGeomOverlapsReshapeLine =
true;
4242 if ( !isRing && nEndpointsSameAsOriginalLine == 1 && nEndpointsOnOriginalLine == 2 && currentGeomOverlapsOriginalGeom )
4244 resultLineParts.push_back( GEOSGeom_clone_r( context, currentGeom ) );
4247 else if ( isRing && nEndpointsOnOriginalLine == 2 && currentGeomOverlapsOriginalGeom )
4249 probableParts.push_back( GEOSGeom_clone_r( context, currentGeom ) );
4251 else if ( nEndpointsOnOriginalLine == 2 && !currentGeomOverlapsOriginalGeom )
4253 resultLineParts.push_back( GEOSGeom_clone_r( context, currentGeom ) );
4255 else if ( nEndpointsSameAsOriginalLine == 2 && !currentGeomOverlapsOriginalGeom )
4257 resultLineParts.push_back( GEOSGeom_clone_r( context, currentGeom ) );
4259 else if ( currentGeomOverlapsOriginalGeom && currentGeomOverlapsReshapeLine )
4261 resultLineParts.push_back( GEOSGeom_clone_r( context, currentGeom ) );
4266 if ( isRing && !probableParts.isEmpty() )
4270 double maxLength = -std::numeric_limits<double>::max();
4271 double currentLength = 0;
4272 for (
int i = 0; i < probableParts.size(); ++i )
4274 currentGeom = probableParts.at( i );
4275 GEOSLength_r( context, currentGeom, ¤tLength );
4276 if ( currentLength > maxLength )
4278 maxLength = currentLength;
4279 maxGeom.reset( currentGeom );
4283 GEOSGeom_destroy_r( context, currentGeom );
4286 resultLineParts.push_back( maxGeom.release() );
4290 if ( resultLineParts.empty() )
4293 if ( resultLineParts.size() == 1 )
4295 result.reset( resultLineParts[0] );
4300 for (
int i = 0; i < resultLineParts.size(); ++i )
4302 lineArray[i] = resultLineParts[i];
4306 geos::unique_ptr multiLineGeom( GEOSGeom_createCollection_r( context, GEOS_MULTILINESTRING, lineArray, resultLineParts.size() ) );
4310 result.reset( GEOSLineMerge_r( context, multiLineGeom.get() ) );
4314 if ( GEOSGeomTypeId_r( context, result.get() ) != GEOS_LINESTRING )
4320 bool reverseLine =
false;
4324 char isResultCCW = 0, isOriginCCW = 0;
4325 if ( GEOSCoordSeq_isCCW_r( context, GEOSGeom_getCoordSeq_r( context, result.get() ), &isResultCCW ) && GEOSCoordSeq_isCCW_r( context, GEOSGeom_getCoordSeq_r( context, line ), &isOriginCCW ) )
4328 reverseLine = ( isOriginCCW == 1 && isResultCCW == 0 ) || ( isOriginCCW == 0 && isResultCCW == 1 );
4334 double x1res, y1res, x2res, y2res;
4335 if ( !_linestringEndpoints( result.get(), x1res, y1res, x2res, y2res ) )
4337 geos::unique_ptr beginResultLineVertex = createGeosPointXY( x1res, y1res,
false, 0,
false, 0, 2, precision );
4338 geos::unique_ptr endResultLineVertex = createGeosPointXY( x2res, y2res,
false, 0,
false, 0, 2, precision );
4339 reverseLine = GEOSEquals_r( context, beginLineVertex.get(), endResultLineVertex.get() ) == 1 || GEOSEquals_r( context, endLineVertex.get(), beginResultLineVertex.get() ) == 1;
4342 result.reset( GEOSReverse_r( context, result.get() ) );
4350 int nIntersections = 0;
4351 int lastIntersectingRing = -2;
4355 int nRings = GEOSGetNumInteriorRings_r( context, polygon );
4360 const GEOSGeometry *outerRing = GEOSGetExteriorRing_r( context, polygon );
4361 if ( GEOSIntersects_r( context, outerRing, reshapeLineGeos ) == 1 )
4364 lastIntersectingRing = -1;
4365 lastIntersectingGeom = outerRing;
4373 for (
int i = 0; i < nRings; ++i )
4375 innerRings[i] = GEOSGetInteriorRingN_r( context, polygon, i );
4376 if ( GEOSIntersects_r( context, innerRings[i], reshapeLineGeos ) == 1 )
4379 lastIntersectingRing = i;
4380 lastIntersectingGeom = innerRings[i];
4384 catch ( QgsGeosException & )
4389 if ( nIntersections != 1 )
4391 delete[] innerRings;
4396 geos::unique_ptr reshapeResult = reshapeLine( lastIntersectingGeom, reshapeLineGeos, precision );
4397 if ( !reshapeResult )
4399 delete[] innerRings;
4405 const GEOSCoordSequence *reshapeSequence = GEOSGeom_getCoordSeq_r( context, reshapeResult.get() );
4406 GEOSCoordSequence *newCoordSequence = GEOSCoordSeq_clone_r( context, reshapeSequence );
4408 reshapeResult.reset();
4412 newRing = GEOSGeom_createLinearRing_r( context, newCoordSequence );
4414 catch ( QgsGeosException & )
4421 delete[] innerRings;
4426 if ( lastIntersectingRing == -1 )
4427 newOuterRing = newRing;
4429 newOuterRing = GEOSGeom_clone_r( context, outerRing );
4432 QVector<GEOSGeometry *> ringList;
4435 GEOSGeometry *outerRingPoly = GEOSGeom_createPolygon_r( context, GEOSGeom_clone_r( context, newOuterRing ),
nullptr, 0 );
4436 if ( outerRingPoly )
4438 ringList.reserve( nRings );
4440 for (
int i = 0; i < nRings; ++i )
4442 if ( lastIntersectingRing == i )
4443 currentRing = newRing;
4445 currentRing = GEOSGeom_clone_r( context, innerRings[i] );
4448 if ( GEOSContains_r( context, outerRingPoly, currentRing ) == 1 )
4449 ringList.push_back( currentRing );
4451 GEOSGeom_destroy_r( context, currentRing );
4454 GEOSGeom_destroy_r( context, outerRingPoly );
4458 for (
int i = 0; i < ringList.size(); ++i )
4459 newInnerRings[i] = ringList.at( i );
4461 delete[] innerRings;
4463 geos::unique_ptr reshapedPolygon( GEOSGeom_createPolygon_r( context, newOuterRing, newInnerRings, ringList.size() ) );
4464 delete[] newInnerRings;
4466 return reshapedPolygon;
4471 if ( !line1 || !line2 )
4476 double bufferDistance = std::pow( 10.0L, geomDigits( line2 ) - 11 );
4483 geos::unique_ptr intersectionGeom( GEOSIntersection_r( context, bufferGeom.get(), line1 ) );
4486 double intersectGeomLength;
4489 GEOSLength_r( context, intersectionGeom.get(), &intersectGeomLength );
4490 GEOSLength_r( context, line1, &line1Length );
4492 double intersectRatio = line1Length / intersectGeomLength;
4493 if ( intersectRatio > 0.9 && intersectRatio < 1.1 )
4501 if ( !point || !line )
4504 double bufferDistance = std::pow( 10.0L, geomDigits( line ) - 11 );
4507 geos::unique_ptr lineBuffer( GEOSBuffer_r( context, line, bufferDistance, 8 ) );
4511 bool contained =
false;
4512 if ( GEOSContains_r( context, lineBuffer.get(), point ) == 1 )
4525 const GEOSGeometry *bBoxRing = GEOSGetExteriorRing_r( context, bbox.get() );
4529 const GEOSCoordSequence *bBoxCoordSeq = GEOSGeom_getCoordSeq_r( context, bBoxRing );
4531 if ( !bBoxCoordSeq )
4534 unsigned int nCoords = 0;
4535 if ( !GEOSCoordSeq_getSize_r( context, bBoxCoordSeq, &nCoords ) )
4539 for (
unsigned int i = 0; i < nCoords - 1; ++i )
4542 GEOSCoordSeq_getX_r( context, bBoxCoordSeq, i, &t );
4545 digits = std::ceil( std::log10( std::fabs( t ) ) );
4546 if ( digits > maxDigits )
4549 GEOSCoordSeq_getY_r( context, bBoxCoordSeq, i, &t );
4550 digits = std::ceil( std::log10( std::fabs( t ) ) );
4551 if ( digits > maxDigits )
4559#if GEOS_VERSION_NUM >= GEOS_COMPUTE_VERSION( 3, 14, 0 )
4560 : mFeedback( feedback )
4562 GEOSContext_setInterruptCallback_r(
QgsGeosContext::get(), &callback,
reinterpret_cast< void *
>( mFeedback ) );
4573#if GEOS_VERSION_NUM >= GEOS_COMPUTE_VERSION( 3, 14, 0 )
4578#if GEOS_VERSION_NUM >= GEOS_COMPUTE_VERSION( 3, 14, 0 )
4579int QgsScopedGeosContextRegisterFeedback::callback(
void *userData )
4585 return feedback && feedback->
isCanceled() ? 1 : 0;
Provides global constants and enumerations for use throughout the application.
BufferSide
Side of line to buffer.
@ Right
Buffer to right of line.
@ LongestBorder
Polygon with longest common border is selected to merge overlapping polygons into.
@ MaximumArea
Polygon with largest area is selected to merge overlapping polygons into.
@ MinimumArea
Polygon with minimum area is selected to merge overlapping polygons into.
@ MinimumIndex
Polygon with smallest input index is selected to merge overlapping polygons into.
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.
@ RejectOnInvalidSubGeometry
Don't allow geometries with invalid sub-geometries to be created.
@ SkipEmptyInteriorRings
Skip any empty polygon interior ring.
QFlags< GeosCreationFlag > GeosCreationFlags
Geos geometry creation behavior flags.
JoinStyle
Join styles for buffers.
EndCapStyle
End cap styles for buffers.
CoverageValidityResult
Coverage validity results.
@ Valid
Coverage is valid.
@ Invalid
Coverage is invalid. Invalidity includes polygons that overlap, that have gaps smaller than the gap w...
@ Error
An exception occurred while determining validity.
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.
@ CompoundCurve
CompoundCurve.
@ LineStringZM
LineStringZM.
@ MultiPolygon
MultiPolygon.
@ MultiLineString
MultiLineString.
@ CircularString
CircularString.
@ GeometryCollection
GeometryCollection.
@ CurvePolygon
CurvePolygon.
@ LineStringZ
LineStringZ.
@ PolyhedralSurface
PolyhedralSurface.
@ MultiSurface
MultiSurface.
Abstract base class for all geometries.
virtual const QgsAbstractGeometry * simplifiedTypeRef() const
Returns a reference to the simplest lossless representation of this geometry, e.g.
bool isMeasure() const
Returns true if the geometry contains m values.
bool is3D() const
Returns true if the geometry is 3D and contains a z-value.
virtual QgsPoint vertexAt(QgsVertexId id) const =0
Returns the point corresponding to a specified vertex id.
Qgis::WkbType wkbType() const
Returns the WKB type of the geometry.
virtual bool isEmpty() const
Returns true if the geometry is empty.
Encapsulates parameters for a coverage cleaning operation.
double maximumGapWidth() const
Returns the maximum gap width.
Qgis::CoverageCleanOverlapMergeStrategy overlapMergeStrategy() const
Returns the overlap merge strategy to use during cleaning.
double snappingDistance() const
Returns the snapping distance.
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 bool isSimpleCurve() const =0
This method returns true for classes that can be cast to the QgsSimpleCurve class.
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.
Base class for feedback objects to be used for cancellation of something running in a worker thread.
bool isCanceled() const
Tells whether the operation has been canceled already.
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.
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.
@ MethodNotImplemented
Method not implemented in geometry engine.
QgsGeometryEngine(const QgsAbstractGeometry *geometry)
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.
static double sqrDistance2D(double x1, double y1, double x2, double y2)
Returns the squared 2D distance between (x1, y1) and (x2, y2).
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...
Used to create and store a GEOS context object, correctly freeing the context upon destruction.
static GEOSContextHandle_t get()
Returns a thread local instance of a GEOS context, safe for use in the current thread.
std::unique_ptr< QgsAbstractGeometry > singleSidedBuffer(double distance, int segments, Qgis::BufferSide side, Qgis::JoinStyle joinStyle, double miterLimit, QString *errorMsg=nullptr, QgsFeedback *feedback=nullptr) const
Returns a single sided buffer for a geometry.
double minimumClearance(QString *errorMsg=nullptr, QgsFeedback *feedback=nullptr) const
Computes the minimum clearance of a geometry.
bool intersects(const QgsAbstractGeometry *geom, QString *errorMsg=nullptr, QgsFeedback *feedback=nullptr) const override
Checks if geom intersects this.
bool distanceWithin(const QgsAbstractGeometry *geom, double maxdistance, QString *errorMsg=nullptr, QgsFeedback *feedback=nullptr) const override
Checks if geom is within maxdistance distance from this geometry.
std::unique_ptr< QgsAbstractGeometry > concaveHull(double targetPercent, bool allowHoles=false, QString *errorMsg=nullptr, QgsFeedback *feedback=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.
double distance(const QgsAbstractGeometry *geom, QString *errorMsg=nullptr, QgsFeedback *feedback=nullptr) const override
Calculates the distance between this and geom.
std::unique_ptr< QgsAbstractGeometry > sharedPaths(const QgsAbstractGeometry *other, QString *errorMsg=nullptr, QgsFeedback *feedback=nullptr) const
Find paths shared between the two given lineal geometries (this and other).
std::unique_ptr< QgsAbstractGeometry > minimumClearanceLine(QString *errorMsg=nullptr, QgsFeedback *feedback=nullptr) const
Returns a LineString whose endpoints define the minimum clearance of a geometry.
static geos::unique_ptr asGeos(const QgsGeometry &geometry, double precision=0, Qgis::GeosCreationFlags flags=Qgis::GeosCreationFlags())
Returns a geos geometry - caller takes ownership of the object (should be deleted with GEOSGeom_destr...
QgsAbstractGeometry * symDifference(const QgsAbstractGeometry *geom, QString *errorMsg=nullptr, const QgsGeometryParameters ¶meters=QgsGeometryParameters(), QgsFeedback *feedback=nullptr) const override
Calculate the symmetric difference of this and geom.
std::unique_ptr< QgsAbstractGeometry > closestPoint(const QgsGeometry &other, QString *errorMsg=nullptr, QgsFeedback *feedback=nullptr) const
Returns the closest point on the geometry to the other geometry.
std::unique_ptr< QgsAbstractGeometry > unionCoverage(QString *errorMsg=nullptr, QgsFeedback *feedback=nullptr) const
Optimized union algorithm for polygonal inputs that are correctly noded and do not overlap.
bool isFuzzyEqual(const QgsAbstractGeometry *geom, double epsilon, QString *errorMsg=nullptr, QgsFeedback *feedback=nullptr) const override
Checks if this is equal to geom ie.
QgsAbstractGeometry * simplify(double tolerance, QString *errorMsg=nullptr, QgsFeedback *feedback=nullptr) const override
Simplifies the geometery.
static const QgsSettingsEntryBool * settingLineToCurveParam
Settings entry - Whether to convert any linear output of a GEOS method to a curved type,...
static geos::unique_ptr offsetCurve(const GEOSGeometry *geometry, double distance, int segments, Qgis::JoinStyle joinStyle, double miterLimit, QString *errorMsg=nullptr, QgsFeedback *feedback=nullptr)
Directly calculates the offset curve for a GEOS geometry object and returns a GEOS geometry result.
std::unique_ptr< QgsAbstractGeometry > cleanCoverage(const QgsCoverageCleanParameters ¶meters, QString *errorMsg=nullptr, QgsFeedback *feedback=nullptr) const
Operates on a coverage (represented as a list of polygonal geometry), to fix cases where the geometry...
QgsAbstractGeometry * intersection(const QgsAbstractGeometry *geom, QString *errorMsg=nullptr, const QgsGeometryParameters ¶meters=QgsGeometryParameters(), QgsFeedback *feedback=nullptr) const override
Calculate the intersection of this and geom.
double lineLocatePoint(const QgsPoint &point, QString *errorMsg=nullptr, QgsFeedback *feedback=nullptr) const
Returns a distance representing the location along this linestring of the closest point on this lines...
std::unique_ptr< QgsAbstractGeometry > subdivide(int maxNodes, QString *errorMsg=nullptr, const QgsGeometryParameters ¶meters=QgsGeometryParameters(), QgsFeedback *feedback=nullptr) const
Subdivides the geometry.
bool touches(const QgsAbstractGeometry *geom, QString *errorMsg=nullptr, QgsFeedback *feedback=nullptr) const override
Checks if geom touches this.
static std::unique_ptr< QgsPolygon > fromGeosPolygon(const GEOSGeometry *geos)
std::unique_ptr< QgsAbstractGeometry > largestEmptyCircle(double tolerance, const QgsAbstractGeometry *boundary=nullptr, QString *errorMsg=nullptr, QgsFeedback *feedback=nullptr) const
Constructs the Largest Empty Circle for a set of obstacle geometries, up to a specified tolerance.
QgsAbstractGeometry * envelope(QString *errorMsg=nullptr) const override
Qgis::CoverageValidityResult validateCoverage(double gapWidth, std::unique_ptr< QgsAbstractGeometry > *invalidEdges, QString *errorMsg=nullptr, QgsFeedback *feedback=nullptr) const
Analyze a coverage (represented as a collection of polygonal geometry with exactly matching edge geom...
QgsAbstractGeometry * buffer(double distance, int segments, QString *errorMsg=nullptr, QgsFeedback *feedback=nullptr) const override
Buffers the geometry.
QString relate(const QgsAbstractGeometry *geom, QString *errorMsg=nullptr, QgsFeedback *feedback=nullptr) const override
Returns the Dimensional Extended 9 Intersection Model (DE-9IM) representation of the relationship bet...
std::unique_ptr< QgsAbstractGeometry > constrainedDelaunayTriangulation(QString *errorMsg=nullptr, QgsFeedback *feedback=nullptr) const
Returns a constrained Delaunay triangulation for the vertices of the geometry.
bool within(const QgsAbstractGeometry *geom, QString *errorMsg=nullptr, QgsFeedback *feedback=nullptr) const override
Checks if geom is within this.
bool contains(double x, double y, QString *errorMsg=nullptr, QgsFeedback *feedback=nullptr) const
Returns true if the geometry contains the point at (x, y).
bool isSimple(QString *errorMsg=nullptr) const override
Determines whether the geometry is simple (according to OGC definition).
bool isValid(QString *errorMsg=nullptr, bool allowSelfTouchingHoles=false, QgsGeometry *errorLoc=nullptr, QgsFeedback *feedback=nullptr) const override
Returns true if the geometry is valid.
std::unique_ptr< QgsAbstractGeometry > minimumWidth(QString *errorMsg=nullptr, QgsFeedback *feedback=nullptr) const
Returns a linestring geometry which represents the minimum diameter of the geometry.
std::unique_ptr< QgsAbstractGeometry > simplifyCoverageVW(double tolerance, bool preserveBoundary, QString *errorMsg=nullptr, QgsFeedback *feedback=nullptr) const
Operates on a coverage (represented as a list of polygonal geometry with exactly matching edge geomet...
QgsGeos(const QgsAbstractGeometry *geometry, double precision=0, Qgis::GeosCreationFlags flags=Qgis::GeosCreationFlag::SkipEmptyInteriorRings)
GEOS geometry engine constructor.
std::unique_ptr< QgsAbstractGeometry > shortestLine(const QgsGeometry &other, QString *errorMsg=nullptr, QgsFeedback *feedback=nullptr) const
Returns the shortest line joining this geometry to the other geometry.
QgsAbstractGeometry * convexHull(QString *errorMsg=nullptr, QgsFeedback *feedback=nullptr) const override
Calculate the convex hull of this geometry.
void prepareGeometry() override
Prepares the geometry, so that subsequent calls to spatial relation methods are much faster.
std::unique_ptr< QgsAbstractGeometry > makeValid(Qgis::MakeValidMethod method=Qgis::MakeValidMethod::Linework, bool keepCollapsed=false, QString *errorMsg=nullptr, QgsFeedback *feedback=nullptr) const
Repairs the geometry using GEOS make valid routine.
QgsPoint * pointOnSurface(QString *errorMsg=nullptr, QgsFeedback *feedback=nullptr) const override
Calculate a point that is guaranteed to be on the surface of this.
static std::unique_ptr< QgsAbstractGeometry > fromGeos(const GEOSGeometry *geos)
Create a geometry from a GEOSGeometry.
std::unique_ptr< QgsAbstractGeometry > node(QString *errorMsg=nullptr, QgsFeedback *feedback=nullptr) const
Returns a (Multi)LineString representing the fully noded version of a collection of linestrings.
QgsAbstractGeometry * combine(const QgsAbstractGeometry *geom, QString *errorMsg=nullptr, const QgsGeometryParameters ¶meters=QgsGeometryParameters(), QgsFeedback *feedback=nullptr) const override
Calculate the combination of this and geom.
bool disjoint(const QgsAbstractGeometry *geom, QString *errorMsg=nullptr, QgsFeedback *feedback=nullptr) const override
Checks if geom is disjoint from this.
bool relatePattern(const QgsAbstractGeometry *geom, const QString &pattern, QString *errorMsg=nullptr, QgsFeedback *feedback=nullptr) const override
Tests whether two geometries are related by a specified Dimensional Extended 9 Intersection Model (DE...
double hausdorffDistanceDensify(const QgsAbstractGeometry *geometry, double densifyFraction, QString *errorMsg=nullptr, QgsFeedback *feedback=nullptr) const
Returns the Hausdorff distance between this geometry and another geometry.
bool isEqual(const QgsAbstractGeometry *geom, QString *errorMsg=nullptr, QgsFeedback *feedback=nullptr) const override
Check if geometries are topologically equivalent.
static std::unique_ptr< QgsCurvePolygon > fromGeosCurvePolygon(const GEOSGeometry *geos)
std::unique_ptr< QgsAbstractGeometry > maximumInscribedCircle(double tolerance, QString *errorMsg=nullptr, QgsFeedback *feedback=nullptr) const
Returns the maximum inscribed circle.
std::unique_ptr< QgsAbstractGeometry > voronoiDiagram(const QgsAbstractGeometry *extent=nullptr, double tolerance=0.0, bool edgesOnly=false, QString *errorMsg=nullptr, QgsFeedback *feedback=nullptr) const
Creates a Voronoi diagram for the nodes contained within the geometry.
double frechetDistanceDensify(const QgsAbstractGeometry *geometry, double densifyFraction, QString *errorMsg=nullptr, QgsFeedback *feedback=nullptr) const
Returns the Fréchet distance between this geometry and another geometry, restricted to discrete point...
std::unique_ptr< QgsAbstractGeometry > delaunayTriangulation(double tolerance=0.0, bool edgesOnly=false, QString *errorMsg=nullptr, QgsFeedback *feedback=nullptr) const
Returns the Delaunay triangulation for the vertices of the geometry.
bool crosses(const QgsAbstractGeometry *geom, QString *errorMsg=nullptr, QgsFeedback *feedback=nullptr) const override
Checks if geom crosses this.
std::unique_ptr< QgsAbstractGeometry > concaveHullOfPolygons(double lengthRatio, bool allowHoles=false, bool isTight=false, QString *errorMsg=nullptr, QgsFeedback *feedback=nullptr) const
Constructs a concave hull of a set of polygons, respecting the polygons as constraints.
std::unique_ptr< QgsAbstractGeometry > clip(const QgsRectangle &rectangle, QString *errorMsg=nullptr, QgsFeedback *feedback=nullptr) const
Performs a fast, non-robust intersection between the geometry and a rectangle.
bool isEmpty(QString *errorMsg=nullptr) const override
static Qgis::GeometryOperationResult addPart(QgsGeometry &geometry, GEOSGeometry *newPart)
Adds a new island polygon to a multipolygon feature.
bool overlaps(const QgsAbstractGeometry *geom, QString *errorMsg=nullptr, QgsFeedback *feedback=nullptr) const override
Checks if geom overlaps this.
QgsPoint * centroid(QString *errorMsg=nullptr, QgsFeedback *feedback=nullptr) const override
Calculates the centroid of this.
std::unique_ptr< QgsAbstractGeometry > mergeLines(QString *errorMsg=nullptr, const QgsGeometryParameters ¶meters=QgsGeometryParameters(), QgsFeedback *feedback=nullptr) const
Merges any connected lines in a LineString/MultiLineString geometry and converts them to single line ...
QgsAbstractGeometry * difference(const QgsAbstractGeometry *geom, QString *errorMsg=nullptr, const QgsGeometryParameters ¶meters=QgsGeometryParameters(), QgsFeedback *feedback=nullptr) const override
Calculate the difference of this and geom.
void geometryChanged() override
Should be called whenever the geometry associated with the engine has been modified and the engine mu...
double area(QString *errorMsg=nullptr) const override
double length(QString *errorMsg=nullptr) const override
double hausdorffDistance(const QgsAbstractGeometry *geometry, QString *errorMsg=nullptr, QgsFeedback *feedback=nullptr) const
Returns the Hausdorff distance between this geometry and another geometry.
double frechetDistance(const QgsAbstractGeometry *geometry, QString *errorMsg=nullptr, QgsFeedback *feedback=nullptr) const
Returns the Fréchet distance between this geometry and another geometry, restricted to discrete point...
QgsAbstractGeometry * interpolate(double distance, QString *errorMsg=nullptr, QgsFeedback *feedback=nullptr) const override
Interpolates a point by distance along the geometry.
static QgsPoint coordSeqPoint(const GEOSCoordSequence *cs, int i, bool hasZ, bool hasM)
static QgsGeometry polygonize(const QVector< const QgsAbstractGeometry * > &geometries, QString *errorMsg=nullptr, QgsFeedback *feedback=nullptr)
Creates a GeometryCollection geometry containing possible polygons formed from the constituent linewo...
static QgsGeometry geometryFromGeos(GEOSGeometry *geos)
Creates a new QgsGeometry object, feeding in a geometry in GEOS format.
QgsGeometryEngine::EngineOperationResult splitGeometry(const QgsAbstractGeometry &splitGeom, QVector< QgsGeometry > &newGeometries, bool topological, QgsPointSequence &topologyTestPoints, QString *errorMsg=nullptr) const override
Splits this geometry according to a given geometry.
Line string geometry type, with support for z-dimension and m-values.
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.
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.
bool addGeometry(QgsAbstractGeometry *g) override
Adds a geometry and takes ownership. Returns true in case of success.
Custom exception class which is raised when an operation is not supported.
Point geometry type, with support for z-dimension and m-values.
QgsPoint * clone() const override
Clones the geometry by performing a deep copy.
bool isEmpty() const override
Returns true if the geometry is empty.
double distance(double x, double y) const
Returns the Cartesian 2D distance between this point and a specified x, y coordinate.
Polyhedral surface geometry type.
int numPatches() const
Returns the number of patches contained with the polyhedral surface.
const QgsPolygon * patchN(int i) const
Retrieves a patch from the polyhedral surface.
A rectangle specified with double values.
void setYMinimum(double y)
Set the minimum y value.
void setXMinimum(double x)
Set the minimum x value.
void setYMaximum(double y)
Set the maximum y value.
void setXMaximum(double x)
Set the maximum x value.
Scoped object for setting the current thread GEOS context feedback object.
QgsScopedGeosContextRegisterFeedback(QgsFeedback *feedback)
Registers a feedback object for GEOS interruption checking.
~QgsScopedGeosContextRegisterFeedback()
Resets the GEOS interruption checker for the current thread.
static QgsSettingsTreeNode * sTreeGeos
Abstract base class for simple curved geometry type.
double yAt(int index) const override
Returns the y-coordinate of the specified node in the line string.
QVector< double > yVector() const
Returns the y vertex values as a vector.
int numPoints() const override
Returns the number of points in the curve.
const double * mData() const
Returns a const pointer to the m vertex data, or nullptr if the simple curve does not have m values.
QVector< double > zVector() const
Returns the z vertex values as a vector.
QVector< double > xVector() const
Returns the x vertex values as a vector.
double xAt(int index) const override
Returns the x-coordinate of the specified node in the line string.
const double * yData() const
Returns a const pointer to the y vertex data.
QgsPoint pointN(int i) const
Returns the specified point from inside the simple curve.
const double * xData() const
Returns a const pointer to the x vertex data.
QVector< double > mVector() const
Returns the m vertex values as a vector.
const double * zData() const
Returns a const pointer to the z vertex data, or nullptr if the simple curve does not have z values.
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 Qgis::WkbType flatType(Qgis::WkbType type)
Returns the flat type for a WKB type.
static Q_INVOKABLE bool isMultiType(Qgis::WkbType type)
Returns true if the WKB type is a multi 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).
T qgsgeometry_cast(QgsAbstractGeometry *geom)
QVector< QgsPoint > QgsPointSequence
#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