Remove caching of GEOS representation within QgsGeometry (legacy)

wonder-sk · wonder-sk · commit 9872b4848d05 · 2016-11-14T13:36:12.000+08:00
diff --git a/doc/api_break.dox b/doc/api_break.dox
@@ -844,6 +844,7 @@ value instead of a pointer. The biggest impact with this change is that PyQGIS c
 result to None, but instead either use a boolean test (`if g.buffer(10):`) or explicitly use the isEmpty()
 method to determine if a geometry is valid.
 - wkbSize() and asWkb() has been replaced by exportToWkb(). WKB representation is no longer cached within QgsGeometry
+- asGeos() has been replaced by exportToGeos(). GEOS representation is no longer cached within QgsGeometry
 - int addPart( const QList<QgsPoint> &points, QgsWkbTypes::GeometryType geomType ) has been renamed to addPoints
 - int addPart( const QList<QgsPointV2> &points, QgsWkbTypes::GeometryType geomType ) has been renamed to addPointsV2
 - static bool compare( const QgsPolyline& p1, const QgsPolyline& p2, double epsilon ) has been renamed to comparePolylines
diff --git a/python/core/geometry/qgsgeometry.sip b/python/core/geometry/qgsgeometry.sip
@@ -103,12 +103,12 @@ class QgsGeometry
      */
     void fromWkb( const QByteArray& wkb );
 
-    /** Returns a geos geometry. QgsGeometry retains ownership of the geometry, so the returned object should not be deleted.
+    /** Returns a geos geometry - caller takes ownership of the object (should be deleted with GEOSGeom_destroy_r)
      *  @param precision The precision of the grid to which to snap the geometry vertices. If 0, no snapping is performed.
-     *  @note this method was added in version 1.1
+     *  @note added in version 3.0
      *  @note not available in python bindings
      */
-    // const GEOSGeometry* asGeos( double precision = 0 ) const;
+    // GEOSGeometry* exportToGeos( double precision = 0 ) const;
 
     /** Returns type of the geometry as a WKB type (point / linestring / polygon etc.)
      * @see type
diff --git a/src/analysis/vector/qgsgeometryanalyzer.cpp b/src/analysis/vector/qgsgeometryanalyzer.cpp
@@ -1063,7 +1063,9 @@ QgsGeometry QgsGeometryAnalyzer::createOffsetGeometry( const QgsGeometry& geom,
   {
     if ( geom.type() == QgsWkbTypes::LineGeometry )
     {
-      GEOSGeometry* offsetGeom = GEOSOffsetCurve_r( geosctxt, ( *inputGeomIt ).asGeos(), -offset, 8 /*quadSegments*/, 0 /*joinStyle*/, 5.0 /*mitreLimit*/ );
+      GEOSGeometry* inputGeomItGeos = inputGeomIt->exportToGeos();
+      GEOSGeometry* offsetGeom = GEOSOffsetCurve_r( geosctxt, inputGeomItGeos, -offset, 8 /*quadSegments*/, 0 /*joinStyle*/, 5.0 /*mitreLimit*/ );
+      GEOSGeom_destroy_r( geosctxt, inputGeomItGeos );
       if ( !offsetGeom || !GEOSisValid_r( geosctxt, offsetGeom ) )
       {
         return QgsGeometry();
diff --git a/src/analysis/vector/qgszonalstatistics.cpp b/src/analysis/vector/qgszonalstatistics.cpp
@@ -419,16 +419,17 @@ void QgsZonalStatistics::statisticsFromMiddlePointTest( void* band, const QgsGeo
   cellCenterY = rasterBBox.yMaximum() - pixelOffsetY * cellSizeY - cellSizeY / 2;
   stats.reset();
 
-  const GEOSGeometry* polyGeos = poly.asGeos();
+  GEOSGeometry* polyGeos = poly.exportToGeos();
   if ( !polyGeos )
   {
     return;
   }
 
   GEOSContextHandle_t geosctxt = QgsGeometry::getGEOSHandler();
-  const GEOSPreparedGeometry* polyGeosPrepared = GEOSPrepare_r( geosctxt, poly.asGeos() );
+  const GEOSPreparedGeometry* polyGeosPrepared = GEOSPrepare_r( geosctxt, polyGeos );
   if ( !polyGeosPrepared )
   {
+    GEOSGeom_destroy_r( geosctxt, polyGeos );
     return;
   }
 
@@ -464,6 +465,7 @@ void QgsZonalStatistics::statisticsFromMiddlePointTest( void* band, const QgsGeo
   GEOSGeom_destroy_r( geosctxt, currentCellCenter );
   CPLFree( scanLine );
   GEOSPreparedGeom_destroy_r( geosctxt, polyGeosPrepared );
+  GEOSGeom_destroy_r( geosctxt, polyGeos );
 }
 
 void QgsZonalStatistics::statisticsFromPreciseIntersection( void* band, const QgsGeometry& poly, int pixelOffsetX,
diff --git a/src/app/qgsmaptooloffsetcurve.cpp b/src/app/qgsmaptooloffsetcurve.cpp
@@ -368,7 +368,7 @@ void QgsMapToolOffsetCurve::setOffsetForRubberBand( double offset )
   }
 
   QgsGeometry geomCopy( mOriginalGeometry );
-  const GEOSGeometry* geosGeom = geomCopy.asGeos();
+  GEOSGeometry* geosGeom = geomCopy.exportToGeos();
   if ( geosGeom )
   {
     QSettings s;
@@ -377,6 +377,7 @@ void QgsMapToolOffsetCurve::setOffsetForRubberBand( double offset )
     double mitreLimit = s.value( QStringLiteral( "/qgis/digitizing/offset_miter_limit" ), 5.0 ).toDouble();
 
     GEOSGeometry* offsetGeom = GEOSOffsetCurve_r( QgsGeometry::getGEOSHandler(), geosGeom, offset, quadSegments, joinStyle, mitreLimit );
+    GEOSGeom_destroy_r( QgsGeometry::getGEOSHandler(), geosGeom );
     if ( !offsetGeom )
     {
       deleteRubberBandAndGeometry();
diff --git a/src/core/geometry/qgsgeometry.cpp b/src/core/geometry/qgsgeometry.cpp
@@ -54,11 +54,10 @@ email                : morb at ozemail dot com dot au
 
 struct QgsGeometryPrivate
 {
-  QgsGeometryPrivate(): ref( 1 ), geometry( nullptr ), mGeos( nullptr ) {}
-  ~QgsGeometryPrivate() { delete geometry; GEOSGeom_destroy_r( QgsGeos::getGEOSHandler(), mGeos ); }
+  QgsGeometryPrivate(): ref( 1 ), geometry( nullptr ) {}
+  ~QgsGeometryPrivate() { delete geometry; }
   QAtomicInt ref;
   QgsAbstractGeometry* geometry;
-  mutable GEOSGeometry* mGeos;
 };
 
 QgsGeometry::QgsGeometry(): d( new QgsGeometryPrivate() )
@@ -269,18 +268,14 @@ void QgsGeometry::fromWkb( const QByteArray &wkb )
   d->geometry = QgsGeometryFactory::geomFromWkb( ptr );
 }
 
-const GEOSGeometry* QgsGeometry::asGeos( double precision ) const
+GEOSGeometry* QgsGeometry::exportToGeos( double precision ) const
 {
   if ( !d->geometry )
   {
     return nullptr;
   }
 
-  if ( !d->mGeos )
-  {
-    d->mGeos = QgsGeos::asGeos( d->geometry, precision );
-  }
-  return d->mGeos;
+  return QgsGeos::asGeos( d->geometry, precision );
 }
 
 
@@ -320,7 +315,7 @@ void QgsGeometry::fromGeos( GEOSGeometry *geos )
   detach( false );
   delete d->geometry;
   d->geometry = QgsGeos::fromGeos( geos );
-  d->mGeos = geos;
+  GEOSGeom_destroy_r( QgsGeos::getGEOSHandler(), geos );
 }
 
 QgsPoint QgsGeometry::closestVertex( const QgsPoint& point, int& atVertex, int& beforeVertex, int& afterVertex, double& sqrDist ) const
diff --git a/src/core/geometry/qgsgeometry.h b/src/core/geometry/qgsgeometry.h
@@ -156,12 +156,12 @@ class CORE_EXPORT QgsGeometry
      */
     void fromWkb( const QByteArray& wkb );
 
-    /** Returns a geos geometry. QgsGeometry retains ownership of the geometry, so the returned object should not be deleted.
+    /** Returns a geos geometry - caller takes ownership of the object (should be deleted with GEOSGeom_destroy_r)
      *  @param precision The precision of the grid to which to snap the geometry vertices. If 0, no snapping is performed.
-     *  @note this method was added in version 1.1
+     *  @note added in 3.0
      *  @note not available in python bindings
      */
-    const GEOSGeometry* asGeos( double precision = 0 ) const;
+    GEOSGeometry* exportToGeos( double precision = 0 ) const;
 
     /** Returns type of the geometry as a WKB type (point / linestring / polygon etc.)
      * @see type
diff --git a/src/core/geometry/qgswkbptr.h b/src/core/geometry/qgswkbptr.h
@@ -66,6 +66,7 @@ class CORE_EXPORT QgsWkbPtr
     }
 
   public:
+    //! Construct WKB pointer from QByteArray
     QgsWkbPtr( QByteArray& wkb );
     QgsWkbPtr( unsigned char *p, int size );
 
@@ -82,6 +83,7 @@ class CORE_EXPORT QgsWkbPtr
     inline QgsWkbPtr &operator<<( const unsigned int &v ) { write( v ); return *this; }
     inline QgsWkbPtr &operator<<( const char &v ) { write( v ); return *this; }
     inline QgsWkbPtr &operator<<( const QgsWkbTypes::Type &v ) { write( v ); return *this; }
+    //! Append data from a byte array
     inline QgsWkbPtr &operator<<( const QByteArray &data ) { write( data ); return *this; }
 
     inline void operator+=( int n ) { verifyBound( n ); mP += n; }
@@ -119,6 +121,7 @@ class CORE_EXPORT QgsConstWkbPtr
     }
 
   public:
+    //! Construct WKB pointer from QByteArray
     explicit QgsConstWkbPtr( const QByteArray& wkb );
     QgsConstWkbPtr( const unsigned char *p, int size );
     QgsWkbTypes::Type readHeader() const;
diff --git a/src/core/qgsgeometryvalidator.cpp b/src/core/qgsgeometryvalidator.cpp
@@ -220,7 +220,7 @@ void QgsGeometryValidator::run()
   if ( settings.value( QStringLiteral( "/qgis/digitizing/validate_geometries" ), 1 ).toInt() == 2 )
   {
     char *r = nullptr;
-    const GEOSGeometry *g0 = mG.asGeos();
+    GEOSGeometry *g0 = mG.exportToGeos();
     GEOSContextHandle_t handle = QgsGeometry::getGEOSHandler();
     if ( !g0 )
     {
@@ -229,7 +229,9 @@ void QgsGeometryValidator::run()
     else
     {
       GEOSGeometry *g1 = nullptr;
-      if ( GEOSisValidDetail_r( handle, g0, GEOSVALID_ALLOW_SELFTOUCHING_RING_FORMING_HOLE, &r, &g1 ) != 1 )
+      char res = GEOSisValidDetail_r( handle, g0, GEOSVALID_ALLOW_SELFTOUCHING_RING_FORMING_HOLE, &r, &g1 );
+      GEOSGeom_destroy_r( handle, g0 );
+      if ( res != 1 )
       {
         if ( g1 )
         {
diff --git a/src/core/qgslabelfeature.cpp b/src/core/qgslabelfeature.cpp
@@ -35,6 +35,7 @@ QgsLabelFeature::QgsLabelFeature( QgsFeatureId id, GEOSGeometry* geometry, QSize
     , mIsObstacle( false )
     , mObstacleFactor( 1 )
     , mInfo( nullptr )
+    , mPermissibleZoneGeos( nullptr )
     , mPermissibleZoneGeosPrepared( nullptr )
 {
 }
@@ -48,7 +49,10 @@ QgsLabelFeature::~QgsLabelFeature()
     GEOSGeom_destroy_r( QgsGeometry::getGEOSHandler(), mObstacleGeometry );
 
   if ( mPermissibleZoneGeosPrepared )
+  {
     GEOSPreparedGeom_destroy_r( QgsGeometry::getGEOSHandler(), mPermissibleZoneGeosPrepared );
+    GEOSGeom_destroy_r( QgsGeometry::getGEOSHandler(), mPermissibleZoneGeos );
+  }
 
   delete mInfo;
 }
@@ -68,15 +72,17 @@ void QgsLabelFeature::setPermissibleZone( const QgsGeometry &geometry )
   if ( mPermissibleZoneGeosPrepared )
   {
     GEOSPreparedGeom_destroy_r( QgsGeometry::getGEOSHandler(), mPermissibleZoneGeosPrepared );
+    GEOSGeom_destroy_r( QgsGeometry::getGEOSHandler(), mPermissibleZoneGeos );
     mPermissibleZoneGeosPrepared = nullptr;
+    mPermissibleZoneGeos = nullptr;
   }
 
   if ( mPermissibleZone.isEmpty() )
     return;
 
-  const GEOSGeometry* zoneGeos = mPermissibleZone.asGeos();
-  if ( !zoneGeos )
+  mPermissibleZoneGeos = mPermissibleZone.exportToGeos();
+  if ( !mPermissibleZoneGeos )
     return;
 
-  mPermissibleZoneGeosPrepared = GEOSPrepare_r( QgsGeometry::getGEOSHandler(), zoneGeos );
+  mPermissibleZoneGeosPrepared = GEOSPrepare_r( QgsGeometry::getGEOSHandler(), mPermissibleZoneGeos );
 }
diff --git a/src/core/qgslabelfeature.h b/src/core/qgslabelfeature.h
@@ -394,6 +394,9 @@ class CORE_EXPORT QgsLabelFeature
 
   private:
 
+    //! GEOS geometry on which mPermissibleZoneGeosPrepared is based on
+    GEOSGeometry* mPermissibleZoneGeos;
+
     // TODO - not required when QgsGeometry caches geos preparedness
     const GEOSPreparedGeometry* mPermissibleZoneGeosPrepared;
 
diff --git a/src/core/qgspallabeling.cpp b/src/core/qgspallabeling.cpp
@@ -1851,17 +1851,16 @@ void QgsPalLayerSettings::registerFeature( QgsFeature& f, QgsRenderContext &cont
     geom = QgsGeometry( geom.geometry()->boundary() );
   }
 
-  const GEOSGeometry* geos_geom = nullptr;
+  GEOSGeometry* geos_geom_clone = nullptr;
   if ( QgsPalLabeling::geometryRequiresPreparation( geom, context, ct, doClip ? &extentGeom : nullptr ) )
   {
     geom = QgsPalLabeling::prepareGeometry( geom, context, ct, doClip ? &extentGeom : nullptr );
 
     if ( geom.isEmpty() )
       return;
   }
-  geos_geom = geom.asGeos();
+  geos_geom_clone = geom.exportToGeos();
 
-  const GEOSGeometry* geosObstacleGeom = nullptr;
   QScopedPointer<QgsGeometry> scopedObstacleGeom;
   if ( isObstacle )
   {
@@ -1870,16 +1869,12 @@ void QgsPalLayerSettings::registerFeature( QgsFeature& f, QgsRenderContext &cont
       scopedObstacleGeom.reset( new QgsGeometry( QgsPalLabeling::prepareGeometry( *obstacleGeometry, context, ct, doClip ? &extentGeom : nullptr ) ) );
       obstacleGeometry = scopedObstacleGeom.data();
     }
-    if ( obstacleGeometry )
-    {
-      geosObstacleGeom = obstacleGeometry->asGeos();
-    }
   }
 
   if ( minFeatureSize > 0 && !checkMinimumSizeMM( context, geom, minFeatureSize ) )
     return;
 
-  if ( !geos_geom )
+  if ( !geos_geom_clone )
     return; // invalid geometry
 
   // likelihood exists label will be registered with PAL and may be drawn
@@ -1907,11 +1902,10 @@ void QgsPalLayerSettings::registerFeature( QgsFeature& f, QgsRenderContext &cont
     }
   }
 
-  GEOSGeometry* geos_geom_clone = GEOSGeom_clone_r( QgsGeometry::getGEOSHandler(), geos_geom );
   GEOSGeometry* geosObstacleGeomClone = nullptr;
-  if ( geosObstacleGeom )
+  if ( obstacleGeometry )
   {
-    geosObstacleGeomClone = GEOSGeom_clone_r( QgsGeometry::getGEOSHandler(), geosObstacleGeom );
+    geosObstacleGeomClone = obstacleGeometry->exportToGeos();
   }
 
 
@@ -2384,21 +2378,18 @@ void QgsPalLayerSettings::registerObstacleFeature( QgsFeature& f, QgsRenderConte
     geom = simplifier.simplify( geom );
   }
 
-  const GEOSGeometry* geos_geom = nullptr;
+  GEOSGeometry* geos_geom_clone = nullptr;
   QScopedPointer<QgsGeometry> scopedPreparedGeom;
 
   if ( QgsPalLabeling::geometryRequiresPreparation( geom, context, ct, &extentGeom ) )
   {
     geom = QgsPalLabeling::prepareGeometry( geom, context, ct, &extentGeom );
   }
-  geos_geom = geom.asGeos();
+  geos_geom_clone = geom.exportToGeos();
 
-  if ( !geos_geom )
+  if ( !geos_geom_clone )
     return; // invalid geometry
 
-  GEOSGeometry* geos_geom_clone;
-  geos_geom_clone = GEOSGeom_clone_r( QgsGeometry::getGEOSHandler(), geos_geom );
-
   //  feature to the layer
   *obstacleFeature = new QgsLabelFeature( f.id(), geos_geom_clone, QSizeF( 0, 0 ) );
   ( *obstacleFeature )->setIsObstacle( true );
@@ -3416,8 +3407,10 @@ QgsGeometry QgsPalLabeling::prepareGeometry( const QgsGeometry& geometry, QgsRen
     }
   }
 
-  if ( !geom.asGeos() )
-    return QgsGeometry();  // there is something really wrong with the geometry
+  // MD: exporting geometry to GEOS just to see if the geometry is wrong...?
+  // if still needed, we could have a more specific test here
+  //if ( !geom.asGeos() )
+  //  return QgsGeometry();  // there is something really wrong with the geometry
 
   // fix invalid polygons
   if ( geom.type() == QgsWkbTypes::PolygonGeometry && !geom.isGeosValid() )
diff --git a/src/core/qgstracer.cpp b/src/core/qgstracer.cpp
@@ -533,7 +533,9 @@ bool QgsTracer::initGraph()
   {
     t2a.start();
     // GEOSNode_r may throw an exception
-    GEOSGeometry* allNoded = GEOSNode_r( QgsGeometry::getGEOSHandler(), allGeom.asGeos() );
+    GEOSGeometry* allGeomGeos = allGeom.exportToGeos();
+    GEOSGeometry* allNoded = GEOSNode_r( QgsGeometry::getGEOSHandler(), allGeomGeos );
+    GEOSGeom_destroy_r( QgsGeometry::getGEOSHandler(), allGeomGeos );
     timeNodingCall = t2a.elapsed();
 
     QgsGeometry* noded = new QgsGeometry;
diff --git a/src/core/qgsvectorlayerdiagramprovider.cpp b/src/core/qgsvectorlayerdiagramprovider.cpp
@@ -224,44 +224,36 @@ QgsLabelFeature* QgsVectorLayerDiagramProvider::registerDiagram( QgsFeature& fea
     extentGeom.rotate( -mapSettings.rotation(), mapSettings.visibleExtent().center() );
   }
 
-  const GEOSGeometry* geos_geom = nullptr;
+  GEOSGeometry* geomCopy = nullptr;
   QScopedPointer<QgsGeometry> scopedPreparedGeom;
   if ( QgsPalLabeling::geometryRequiresPreparation( geom, context, mSettings.coordinateTransform(), &extentGeom ) )
   {
     scopedPreparedGeom.reset( new QgsGeometry( QgsPalLabeling::prepareGeometry( geom, context, mSettings.coordinateTransform(), &extentGeom ) ) );
     QgsGeometry* preparedGeom = scopedPreparedGeom.data();
     if ( preparedGeom->isEmpty() )
       return nullptr;
-    geos_geom = preparedGeom->asGeos();
+    geomCopy = preparedGeom->exportToGeos();
   }
   else
   {
-    geos_geom = geom.asGeos();
+    geomCopy = geom.exportToGeos();
   }
 
-  if ( !geos_geom )
+  if ( !geomCopy )
     return nullptr; // invalid geometry
 
-  GEOSGeometry* geomCopy = GEOSGeom_clone_r( QgsGeometry::getGEOSHandler(), geos_geom );
-
-  const GEOSGeometry* geosObstacleGeom = nullptr;
+  GEOSGeometry* geosObstacleGeomClone = nullptr;
   QScopedPointer<QgsGeometry> scopedObstacleGeom;
   if ( mSettings.isObstacle() && obstacleGeometry && QgsPalLabeling::geometryRequiresPreparation( *obstacleGeometry, context, mSettings.coordinateTransform(), &extentGeom ) )
   {
     QgsGeometry preparedObstacleGeom = QgsPalLabeling::prepareGeometry( *obstacleGeometry, context, mSettings.coordinateTransform(), &extentGeom );
-    geosObstacleGeom = preparedObstacleGeom.asGeos();
+    geosObstacleGeomClone = preparedObstacleGeom.exportToGeos();
   }
   else if ( mSettings.isObstacle() && obstacleGeometry )
   {
-    geosObstacleGeom = obstacleGeometry->asGeos();
-  }
-  GEOSGeometry* geosObstacleGeomClone = nullptr;
-  if ( geosObstacleGeom )
-  {
-    geosObstacleGeomClone = GEOSGeom_clone_r( QgsGeometry::getGEOSHandler(), geosObstacleGeom );
+    geosObstacleGeomClone = obstacleGeometry->exportToGeos();
   }
 
-
   double diagramWidth = 0;
   double diagramHeight = 0;
   if ( dr )
diff --git a/src/plugins/topology/topolTest.cpp b/src/plugins/topology/topolTest.cpp

Original file line number	Diff line number	Diff line change
`@@ -1063,7 +1063,9 @@ QgsGeometry QgsGeometryAnalyzer::createOffsetGeometry( const QgsGeometry& geom,`
`1063`	`1063`	`{`
`1064`	`1064`	`if ( geom.type() == QgsWkbTypes::LineGeometry )`
`1065`	`1065`	`{`
`1066`		`- GEOSGeometry* offsetGeom = GEOSOffsetCurve_r( geosctxt, ( inputGeomIt ).asGeos(), -offset, 8 /quadSegments/, 0 /joinStyle/, 5.0 /mitreLimit*/ );`
	`1066`	`+ GEOSGeometry* inputGeomItGeos = inputGeomIt->exportToGeos();`
	`1067`	`+ GEOSGeometry* offsetGeom = GEOSOffsetCurve_r( geosctxt, inputGeomItGeos, -offset, 8 /quadSegments/, 0 /joinStyle/, 5.0 /mitreLimit/ );`
	`1068`	`+ GEOSGeom_destroy_r( geosctxt, inputGeomItGeos );`
`1067`	`1069`	`if ( !offsetGeom \|\| !GEOSisValid_r( geosctxt, offsetGeom ) )`
`1068`	`1070`	`{`
`1069`	`1071`	`return QgsGeometry();`
Original file line number	Diff line number	Diff line change
`@@ -419,16 +419,17 @@ void QgsZonalStatistics::statisticsFromMiddlePointTest( void* band, const QgsGeo`
`419`	`419`	`cellCenterY = rasterBBox.yMaximum() - pixelOffsetY * cellSizeY - cellSizeY / 2;`
`420`	`420`	`stats.reset();`
`421`	`421`
`422`		`- const GEOSGeometry* polyGeos = poly.asGeos();`
	`422`	`+ GEOSGeometry* polyGeos = poly.exportToGeos();`
`423`	`423`	`if ( !polyGeos )`
`424`	`424`	`{`
`425`	`425`	`return;`
`426`	`426`	`}`
`427`	`427`
`428`	`428`	`GEOSContextHandle_t geosctxt = QgsGeometry::getGEOSHandler();`
`429`		`- const GEOSPreparedGeometry* polyGeosPrepared = GEOSPrepare_r( geosctxt, poly.asGeos() );`
	`429`	`+ const GEOSPreparedGeometry* polyGeosPrepared = GEOSPrepare_r( geosctxt, polyGeos );`
`430`	`430`	`if ( !polyGeosPrepared )`
`431`	`431`	`{`
	`432`	`+ GEOSGeom_destroy_r( geosctxt, polyGeos );`
`432`	`433`	`return;`
`433`	`434`	`}`
`434`	`435`
`@@ -464,6 +465,7 @@ void QgsZonalStatistics::statisticsFromMiddlePointTest( void* band, const QgsGeo`
`464`	`465`	`GEOSGeom_destroy_r( geosctxt, currentCellCenter );`
`465`	`466`	`CPLFree( scanLine );`
`466`	`467`	`GEOSPreparedGeom_destroy_r( geosctxt, polyGeosPrepared );`
	`468`	`+ GEOSGeom_destroy_r( geosctxt, polyGeos );`
`467`	`469`	`}`
`468`	`470`
`469`	`471`	`void QgsZonalStatistics::statisticsFromPreciseIntersection( void* band, const QgsGeometry& poly, int pixelOffsetX,`
Original file line number	Diff line number	Diff line change
`@@ -368,7 +368,7 @@ void QgsMapToolOffsetCurve::setOffsetForRubberBand( double offset )`
`368`	`368`	`}`
`369`	`369`
`370`	`370`	`QgsGeometry geomCopy( mOriginalGeometry );`
`371`		`- const GEOSGeometry* geosGeom = geomCopy.asGeos();`
	`371`	`+ GEOSGeometry* geosGeom = geomCopy.exportToGeos();`
`372`	`372`	`if ( geosGeom )`
`373`	`373`	`{`
`374`	`374`	`QSettings s;`
`@@ -377,6 +377,7 @@ void QgsMapToolOffsetCurve::setOffsetForRubberBand( double offset )`
`377`	`377`	`double mitreLimit = s.value( QStringLiteral( "/qgis/digitizing/offset_miter_limit" ), 5.0 ).toDouble();`
`378`	`378`
`379`	`379`	`GEOSGeometry* offsetGeom = GEOSOffsetCurve_r( QgsGeometry::getGEOSHandler(), geosGeom, offset, quadSegments, joinStyle, mitreLimit );`
	`380`	`+ GEOSGeom_destroy_r( QgsGeometry::getGEOSHandler(), geosGeom );`
`380`	`381`	`if ( !offsetGeom )`
`381`	`382`	`{`
`382`	`383`	`deleteRubberBandAndGeometry();`
Original file line number	Diff line number	Diff line change
`@@ -54,11 +54,10 @@ email : morb at ozemail dot com dot au`
`54`	`54`
`55`	`55`	`struct QgsGeometryPrivate`
`56`	`56`	`{`
`57`		`- QgsGeometryPrivate(): ref( 1 ), geometry( nullptr ), mGeos( nullptr ) {}`
`58`		`- ~QgsGeometryPrivate() { delete geometry; GEOSGeom_destroy_r( QgsGeos::getGEOSHandler(), mGeos ); }`
	`57`	`+ QgsGeometryPrivate(): ref( 1 ), geometry( nullptr ) {}`
	`58`	`+ ~QgsGeometryPrivate() { delete geometry; }`
`59`	`59`	`QAtomicInt ref;`
`60`	`60`	`QgsAbstractGeometry* geometry;`
`61`		`- mutable GEOSGeometry* mGeos;`
`62`	`61`	`};`
`63`	`62`
`64`	`63`	`QgsGeometry::QgsGeometry(): d( new QgsGeometryPrivate() )`
`@@ -269,18 +268,14 @@ void QgsGeometry::fromWkb( const QByteArray &wkb )`
`269`	`268`	`d->geometry = QgsGeometryFactory::geomFromWkb( ptr );`
`270`	`269`	`}`
`271`	`270`
`272`		`-const GEOSGeometry* QgsGeometry::asGeos( double precision ) const`
	`271`	`+GEOSGeometry* QgsGeometry::exportToGeos( double precision ) const`
`273`	`272`	`{`
`274`	`273`	`if ( !d->geometry )`
`275`	`274`	`{`
`276`	`275`	`return nullptr;`
`277`	`276`	`}`
`278`	`277`
`279`		`- if ( !d->mGeos )`
`280`		`- {`
`281`		`- d->mGeos = QgsGeos::asGeos( d->geometry, precision );`
`282`		`- }`
`283`		`- return d->mGeos;`
	`278`	`+ return QgsGeos::asGeos( d->geometry, precision );`
`284`	`279`	`}`
`285`	`280`
`286`	`281`
`@@ -320,7 +315,7 @@ void QgsGeometry::fromGeos( GEOSGeometry *geos )`
`320`	`315`	`detach( false );`
`321`	`316`	`delete d->geometry;`
`322`	`317`	`d->geometry = QgsGeos::fromGeos( geos );`
`323`		`- d->mGeos = geos;`
	`318`	`+ GEOSGeom_destroy_r( QgsGeos::getGEOSHandler(), geos );`
`324`	`319`	`}`
`325`	`320`
`326`	`321`	`QgsPoint QgsGeometry::closestVertex( const QgsPoint& point, int& atVertex, int& beforeVertex, int& afterVertex, double& sqrDist ) const`
Original file line number	Diff line number	Diff line change
`@@ -220,7 +220,7 @@ void QgsGeometryValidator::run()`
`220`	`220`	`if ( settings.value( QStringLiteral( "/qgis/digitizing/validate_geometries" ), 1 ).toInt() == 2 )`
`221`	`221`	`{`
`222`	`222`	`char *r = nullptr;`
`223`		`- const GEOSGeometry *g0 = mG.asGeos();`
	`223`	`+ GEOSGeometry *g0 = mG.exportToGeos();`
`224`	`224`	`GEOSContextHandle_t handle = QgsGeometry::getGEOSHandler();`
`225`	`225`	`if ( !g0 )`
`226`	`226`	`{`
`@@ -229,7 +229,9 @@ void QgsGeometryValidator::run()`
`229`	`229`	`else`
`230`	`230`	`{`
`231`	`231`	`GEOSGeometry *g1 = nullptr;`
`232`		`- if ( GEOSisValidDetail_r( handle, g0, GEOSVALID_ALLOW_SELFTOUCHING_RING_FORMING_HOLE, &r, &g1 ) != 1 )`
	`232`	`+ char res = GEOSisValidDetail_r( handle, g0, GEOSVALID_ALLOW_SELFTOUCHING_RING_FORMING_HOLE, &r, &g1 );`
	`233`	`+ GEOSGeom_destroy_r( handle, g0 );`
	`234`	`+ if ( res != 1 )`
`233`	`235`	`{`
`234`	`236`	`if ( g1 )`
`235`	`237`	`{`
Original file line number	Diff line number	Diff line change
`@@ -35,6 +35,7 @@ QgsLabelFeature::QgsLabelFeature( QgsFeatureId id, GEOSGeometry* geometry, QSize`
`35`	`35`	`, mIsObstacle( false )`
`36`	`36`	`, mObstacleFactor( 1 )`
`37`	`37`	`, mInfo( nullptr )`
	`38`	`+ , mPermissibleZoneGeos( nullptr )`
`38`	`39`	`, mPermissibleZoneGeosPrepared( nullptr )`
`39`	`40`	`{`
`40`	`41`	`}`
`@@ -48,7 +49,10 @@ QgsLabelFeature::~QgsLabelFeature()`
`48`	`49`	`GEOSGeom_destroy_r( QgsGeometry::getGEOSHandler(), mObstacleGeometry );`
`49`	`50`
`50`	`51`	`if ( mPermissibleZoneGeosPrepared )`
	`52`	`+ {`
`51`	`53`	`GEOSPreparedGeom_destroy_r( QgsGeometry::getGEOSHandler(), mPermissibleZoneGeosPrepared );`
	`54`	`+ GEOSGeom_destroy_r( QgsGeometry::getGEOSHandler(), mPermissibleZoneGeos );`
	`55`	`+ }`
`52`	`56`
`53`	`57`	`delete mInfo;`
`54`	`58`	`}`
`@@ -68,15 +72,17 @@ void QgsLabelFeature::setPermissibleZone( const QgsGeometry &geometry )`
`68`	`72`	`if ( mPermissibleZoneGeosPrepared )`
`69`	`73`	`{`
`70`	`74`	`GEOSPreparedGeom_destroy_r( QgsGeometry::getGEOSHandler(), mPermissibleZoneGeosPrepared );`
	`75`	`+ GEOSGeom_destroy_r( QgsGeometry::getGEOSHandler(), mPermissibleZoneGeos );`
`71`	`76`	`mPermissibleZoneGeosPrepared = nullptr;`
	`77`	`+ mPermissibleZoneGeos = nullptr;`
`72`	`78`	`}`
`73`	`79`
`74`	`80`	`if ( mPermissibleZone.isEmpty() )`
`75`	`81`	`return;`
`76`	`82`
`77`		`- const GEOSGeometry* zoneGeos = mPermissibleZone.asGeos();`
`78`		`- if ( !zoneGeos )`
	`83`	`+ mPermissibleZoneGeos = mPermissibleZone.exportToGeos();`
	`84`	`+ if ( !mPermissibleZoneGeos )`
`79`	`85`	`return;`
`80`	`86`
`81`		`- mPermissibleZoneGeosPrepared = GEOSPrepare_r( QgsGeometry::getGEOSHandler(), zoneGeos );`
	`87`	`+ mPermissibleZoneGeosPrepared = GEOSPrepare_r( QgsGeometry::getGEOSHandler(), mPermissibleZoneGeos );`
`82`	`88`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1851,17 +1851,16 @@ void QgsPalLayerSettings::registerFeature( QgsFeature& f, QgsRenderContext &cont`
`1851`	`1851`	`geom = QgsGeometry( geom.geometry()->boundary() );`
`1852`	`1852`	`}`
`1853`	`1853`
`1854`		`- const GEOSGeometry* geos_geom = nullptr;`
	`1854`	`+ GEOSGeometry* geos_geom_clone = nullptr;`
`1855`	`1855`	`if ( QgsPalLabeling::geometryRequiresPreparation( geom, context, ct, doClip ? &extentGeom : nullptr ) )`
`1856`	`1856`	`{`
`1857`	`1857`	`geom = QgsPalLabeling::prepareGeometry( geom, context, ct, doClip ? &extentGeom : nullptr );`
`1858`	`1858`
`1859`	`1859`	`if ( geom.isEmpty() )`
`1860`	`1860`	`return;`
`1861`	`1861`	`}`
`1862`		`- geos_geom = geom.asGeos();`
	`1862`	`+ geos_geom_clone = geom.exportToGeos();`
`1863`	`1863`
`1864`		`- const GEOSGeometry* geosObstacleGeom = nullptr;`
`1865`	`1864`	`QScopedPointer<QgsGeometry> scopedObstacleGeom;`
`1866`	`1865`	`if ( isObstacle )`
`1867`	`1866`	`{`
`@@ -1870,16 +1869,12 @@ void QgsPalLayerSettings::registerFeature( QgsFeature& f, QgsRenderContext &cont`
`1870`	`1869`	`scopedObstacleGeom.reset( new QgsGeometry( QgsPalLabeling::prepareGeometry( *obstacleGeometry, context, ct, doClip ? &extentGeom : nullptr ) ) );`
`1871`	`1870`	`obstacleGeometry = scopedObstacleGeom.data();`
`1872`	`1871`	`}`
`1873`		`- if ( obstacleGeometry )`
`1874`		`- {`
`1875`		`- geosObstacleGeom = obstacleGeometry->asGeos();`
`1876`		`- }`
`1877`	`1872`	`}`
`1878`	`1873`
`1879`	`1874`	`if ( minFeatureSize > 0 && !checkMinimumSizeMM( context, geom, minFeatureSize ) )`
`1880`	`1875`	`return;`
`1881`	`1876`
`1882`		`- if ( !geos_geom )`
	`1877`	`+ if ( !geos_geom_clone )`
`1883`	`1878`	`return; // invalid geometry`
`1884`	`1879`
`1885`	`1880`	`// likelihood exists label will be registered with PAL and may be drawn`
`@@ -1907,11 +1902,10 @@ void QgsPalLayerSettings::registerFeature( QgsFeature& f, QgsRenderContext &cont`
`1907`	`1902`	`}`
`1908`	`1903`	`}`
`1909`	`1904`
`1910`		`- GEOSGeometry* geos_geom_clone = GEOSGeom_clone_r( QgsGeometry::getGEOSHandler(), geos_geom );`
`1911`	`1905`	`GEOSGeometry* geosObstacleGeomClone = nullptr;`
`1912`		`- if ( geosObstacleGeom )`
	`1906`	`+ if ( obstacleGeometry )`
`1913`	`1907`	`{`
`1914`		`- geosObstacleGeomClone = GEOSGeom_clone_r( QgsGeometry::getGEOSHandler(), geosObstacleGeom );`
	`1908`	`+ geosObstacleGeomClone = obstacleGeometry->exportToGeos();`
`1915`	`1909`	`}`
`1916`	`1910`
`1917`	`1911`
`@@ -2384,21 +2378,18 @@ void QgsPalLayerSettings::registerObstacleFeature( QgsFeature& f, QgsRenderConte`
`2384`	`2378`	`geom = simplifier.simplify( geom );`
`2385`	`2379`	`}`
`2386`	`2380`
`2387`		`- const GEOSGeometry* geos_geom = nullptr;`
	`2381`	`+ GEOSGeometry* geos_geom_clone = nullptr;`
`2388`	`2382`	`QScopedPointer<QgsGeometry> scopedPreparedGeom;`
`2389`	`2383`
`2390`	`2384`	`if ( QgsPalLabeling::geometryRequiresPreparation( geom, context, ct, &extentGeom ) )`
`2391`	`2385`	`{`
`2392`	`2386`	`geom = QgsPalLabeling::prepareGeometry( geom, context, ct, &extentGeom );`
`2393`	`2387`	`}`
`2394`		`- geos_geom = geom.asGeos();`
	`2388`	`+ geos_geom_clone = geom.exportToGeos();`
`2395`	`2389`
`2396`		`- if ( !geos_geom )`
	`2390`	`+ if ( !geos_geom_clone )`
`2397`	`2391`	`return; // invalid geometry`
`2398`	`2392`
`2399`		`- GEOSGeometry* geos_geom_clone;`
`2400`		`- geos_geom_clone = GEOSGeom_clone_r( QgsGeometry::getGEOSHandler(), geos_geom );`
`2401`		`-`
`2402`	`2393`	`// feature to the layer`
`2403`	`2394`	`*obstacleFeature = new QgsLabelFeature( f.id(), geos_geom_clone, QSizeF( 0, 0 ) );`
`2404`	`2395`	`( *obstacleFeature )->setIsObstacle( true );`
`@@ -3416,8 +3407,10 @@ QgsGeometry QgsPalLabeling::prepareGeometry( const QgsGeometry& geometry, QgsRen`
`3416`	`3407`	`}`
`3417`	`3408`	`}`
`3418`	`3409`
`3419`		`- if ( !geom.asGeos() )`
`3420`		`- return QgsGeometry(); // there is something really wrong with the geometry`
	`3410`	`+ // MD: exporting geometry to GEOS just to see if the geometry is wrong...?`
	`3411`	`+ // if still needed, we could have a more specific test here`
	`3412`	`+ //if ( !geom.asGeos() )`
	`3413`	`+ // return QgsGeometry(); // there is something really wrong with the geometry`
`3421`	`3414`
`3422`	`3415`	`// fix invalid polygons`
`3423`	`3416`	`if ( geom.type() == QgsWkbTypes::PolygonGeometry && !geom.isGeosValid() )`
Original file line number	Diff line number	Diff line change
`@@ -224,44 +224,36 @@ QgsLabelFeature* QgsVectorLayerDiagramProvider::registerDiagram( QgsFeature& fea`
`224`	`224`	`extentGeom.rotate( -mapSettings.rotation(), mapSettings.visibleExtent().center() );`
`225`	`225`	`}`
`226`	`226`
`227`		`- const GEOSGeometry* geos_geom = nullptr;`
	`227`	`+ GEOSGeometry* geomCopy = nullptr;`
`228`	`228`	`QScopedPointer<QgsGeometry> scopedPreparedGeom;`
`229`	`229`	`if ( QgsPalLabeling::geometryRequiresPreparation( geom, context, mSettings.coordinateTransform(), &extentGeom ) )`
`230`	`230`	`{`
`231`	`231`	`scopedPreparedGeom.reset( new QgsGeometry( QgsPalLabeling::prepareGeometry( geom, context, mSettings.coordinateTransform(), &extentGeom ) ) );`
`232`	`232`	`QgsGeometry* preparedGeom = scopedPreparedGeom.data();`
`233`	`233`	`if ( preparedGeom->isEmpty() )`
`234`	`234`	`return nullptr;`
`235`		`- geos_geom = preparedGeom->asGeos();`
	`235`	`+ geomCopy = preparedGeom->exportToGeos();`
`236`	`236`	`}`
`237`	`237`	`else`
`238`	`238`	`{`
`239`		`- geos_geom = geom.asGeos();`
	`239`	`+ geomCopy = geom.exportToGeos();`
`240`	`240`	`}`
`241`	`241`
`242`		`- if ( !geos_geom )`
	`242`	`+ if ( !geomCopy )`
`243`	`243`	`return nullptr; // invalid geometry`
`244`	`244`
`245`		`- GEOSGeometry* geomCopy = GEOSGeom_clone_r( QgsGeometry::getGEOSHandler(), geos_geom );`
`246`		`-`
`247`		`- const GEOSGeometry* geosObstacleGeom = nullptr;`
	`245`	`+ GEOSGeometry* geosObstacleGeomClone = nullptr;`
`248`	`246`	`QScopedPointer<QgsGeometry> scopedObstacleGeom;`
`249`	`247`	`if ( mSettings.isObstacle() && obstacleGeometry && QgsPalLabeling::geometryRequiresPreparation( *obstacleGeometry, context, mSettings.coordinateTransform(), &extentGeom ) )`
`250`	`248`	`{`
`251`	`249`	`QgsGeometry preparedObstacleGeom = QgsPalLabeling::prepareGeometry( *obstacleGeometry, context, mSettings.coordinateTransform(), &extentGeom );`
`252`		`- geosObstacleGeom = preparedObstacleGeom.asGeos();`
	`250`	`+ geosObstacleGeomClone = preparedObstacleGeom.exportToGeos();`
`253`	`251`	`}`
`254`	`252`	`else if ( mSettings.isObstacle() && obstacleGeometry )`
`255`	`253`	`{`
`256`		`- geosObstacleGeom = obstacleGeometry->asGeos();`
`257`		`- }`
`258`		`- GEOSGeometry* geosObstacleGeomClone = nullptr;`
`259`		`- if ( geosObstacleGeom )`
`260`		`- {`
`261`		`- geosObstacleGeomClone = GEOSGeom_clone_r( QgsGeometry::getGEOSHandler(), geosObstacleGeom );`
	`254`	`+ geosObstacleGeomClone = obstacleGeometry->exportToGeos();`
`262`	`255`	`}`
`263`	`256`
`264`		`-`
`265`	`257`	`double diagramWidth = 0;`
`266`	`258`	`double diagramHeight = 0;`
`267`	`259`	`if ( dr )`