Remove QgsGeometry pointers from QgsGeometryAnalyzer

nyalldawson · nyalldawson · commit 5f6dfaed3814 · 2016-08-15T09:47:04.000+10:00
diff --git a/src/analysis/vector/qgsgeometryanalyzer.cpp b/src/analysis/vector/qgsgeometryanalyzer.cpp
@@ -347,14 +347,14 @@ QList<double> QgsGeometryAnalyzer::simpleMeasure( QgsGeometry& mpGeometry )
     list.append( measure.measureArea( mpGeometry ) );
     if ( mpGeometry.type() == QgsWkbTypes::PolygonGeometry )
     {
-      perim = perimeterMeasure( &mpGeometry, measure );
+      perim = perimeterMeasure( mpGeometry, measure );
       list.append( perim );
     }
   }
   return list;
 }
 
-double QgsGeometryAnalyzer::perimeterMeasure( QgsGeometry* geometry, QgsDistanceArea& measure )
+double QgsGeometryAnalyzer::perimeterMeasure( const QgsGeometry& geometry, QgsDistanceArea& measure )
 {
   return measure.measurePerimeter( geometry );
 }
@@ -520,7 +520,6 @@ bool QgsGeometryAnalyzer::convexHull( QgsVectorLayer* layer, const QString& shap
         ++jt;
       }
       QList<double> values;
-      // QgsGeometry* tmpGeometry = 0;
       if ( dissolveGeometry.isEmpty() )
       {
         QgsDebugMsg( "no dissolved geometry - should not happen" );
@@ -615,7 +614,7 @@ bool QgsGeometryAnalyzer::dissolve( QgsVectorLayer* layer, const QString& shapef
     }
   }
 
-  QgsGeometry *dissolveGeometry = nullptr; //dissolve geometry
+  QgsGeometry dissolveGeometry; //dissolve geometry
   QMultiMap<QString, QgsFeatureId>::const_iterator jt = map.constBegin();
   QgsFeature outputFeature;
   while ( jt != map.constEnd() )
@@ -653,7 +652,7 @@ bool QgsGeometryAnalyzer::dissolve( QgsVectorLayer* layer, const QString& shapef
             outputFeature.setAttributes( currentFeature.attributes() );
             first = false;
           }
-          dissolveFeature( currentFeature, processedFeatures, &dissolveGeometry );
+          dissolveGeometry = dissolveFeature( currentFeature, dissolveGeometry );
           ++processedFeatures;
         }
         ++jt;
@@ -686,38 +685,33 @@ bool QgsGeometryAnalyzer::dissolve( QgsVectorLayer* layer, const QString& shapef
           outputFeature.setAttributes( currentFeature.attributes() );
           first = false;
         }
-        dissolveFeature( currentFeature, processedFeatures, &dissolveGeometry );
+        dissolveGeometry = dissolveFeature( currentFeature, dissolveGeometry );
         ++processedFeatures;
         ++jt;
       }
     }
-    outputFeature.setGeometry( *dissolveGeometry );
-    delete dissolveGeometry;
+    outputFeature.setGeometry( dissolveGeometry );
     vWriter.addFeature( outputFeature );
   }
   return true;
 }
 
-void QgsGeometryAnalyzer::dissolveFeature( QgsFeature& f, int nProcessedFeatures, QgsGeometry** dissolveGeometry )
+QgsGeometry QgsGeometryAnalyzer::dissolveFeature( const QgsFeature& f, const QgsGeometry& dissolveInto )
 {
   if ( !f.hasGeometry() )
   {
-    return;
+    return dissolveInto;
   }
 
   QgsGeometry featureGeometry = f.geometry();
 
-  if ( nProcessedFeatures == 0 )
+  if ( dissolveInto.isEmpty() )
   {
-    int geomSize = featureGeometry.wkbSize();
-    *dissolveGeometry = new QgsGeometry();
-    unsigned char* wkb = new unsigned char[geomSize];
-    memcpy( wkb, featureGeometry.asWkb(), geomSize );
-    ( *dissolveGeometry )->fromWkb( wkb, geomSize );
+    return featureGeometry;
   }
   else
   {
-    **dissolveGeometry = ( *dissolveGeometry )->combine( featureGeometry );
+    return dissolveInto.combine( featureGeometry );
   }
 }
 
@@ -744,7 +738,7 @@ bool QgsGeometryAnalyzer::buffer( QgsVectorLayer* layer, const QString& shapefil
 
   QgsVectorFileWriter vWriter( shapefileName, dp->encoding(), layer->fields(), outputType, crs );
   QgsFeature currentFeature;
-  QgsGeometry *dissolveGeometry = nullptr; //dissolve geometry (if dissolve enabled)
+  QgsGeometry dissolveGeometry; //dissolve geometry (if dissolve enabled)
 
   //take only selection
   if ( onlySelectedFeatures )
@@ -773,7 +767,7 @@ bool QgsGeometryAnalyzer::buffer( QgsVectorLayer* layer, const QString& shapefil
       {
         continue;
       }
-      bufferFeature( currentFeature, processedFeatures, &vWriter, dissolve, *dissolveGeometry, bufferDistance, bufferDistanceField );
+      bufferFeature( currentFeature, processedFeatures, &vWriter, dissolve, dissolveGeometry, bufferDistance, bufferDistanceField );
       ++processedFeatures;
     }
 
@@ -804,7 +798,7 @@ bool QgsGeometryAnalyzer::buffer( QgsVectorLayer* layer, const QString& shapefil
       {
         break;
       }
-      bufferFeature( currentFeature, processedFeatures, &vWriter, dissolve, *dissolveGeometry, bufferDistance, bufferDistanceField );
+      bufferFeature( currentFeature, processedFeatures, &vWriter, dissolve, dissolveGeometry, bufferDistance, bufferDistanceField );
       ++processedFeatures;
     }
     if ( p )
@@ -816,13 +810,12 @@ bool QgsGeometryAnalyzer::buffer( QgsVectorLayer* layer, const QString& shapefil
   if ( dissolve )
   {
     QgsFeature dissolveFeature;
-    if ( !dissolveGeometry )
+    if ( dissolveGeometry.isEmpty() )
     {
       QgsDebugMsg( "no dissolved geometry - should not happen" );
       return false;
     }
-    dissolveFeature.setGeometry( *dissolveGeometry );
-    delete dissolveGeometry;
+    dissolveFeature.setGeometry( dissolveGeometry );
     vWriter.addFeature( dissolveFeature );
   }
   return true;
@@ -977,7 +970,7 @@ bool QgsGeometryAnalyzer::eventLayer( QgsVectorLayer* lineLayer, QgsVectorLayer*
       if ( !lrsGeom.isEmpty() )
       {
         ++nOutputFeatures;
-        addEventLayerFeature( fet, &lrsGeom, featureIdIt->geometry(), fileWriter, memoryProviderFeatures, offsetField, offsetScale, forceSingleGeometry );
+        addEventLayerFeature( fet, lrsGeom, featureIdIt->geometry(), fileWriter, memoryProviderFeatures, offsetField, offsetScale, forceSingleGeometry );
       }
     }
     if ( nOutputFeatures < 1 )
@@ -999,39 +992,41 @@ bool QgsGeometryAnalyzer::eventLayer( QgsVectorLayer* lineLayer, QgsVectorLayer*
   return true;
 }
 
-void QgsGeometryAnalyzer::addEventLayerFeature( QgsFeature& feature, QgsGeometry* geom, const QgsGeometry& lineGeom, QgsVectorFileWriter* fileWriter, QgsFeatureList& memoryFeatures,
+void QgsGeometryAnalyzer::addEventLayerFeature( QgsFeature& feature, const QgsGeometry& geom, const QgsGeometry& lineGeom, QgsVectorFileWriter* fileWriter, QgsFeatureList& memoryFeatures,
     int offsetField, double offsetScale, bool forceSingleType )
 {
-  if ( !geom )
+  if ( geom.isEmpty() )
   {
     return;
   }
 
   QList<QgsGeometry> geomList;
   if ( forceSingleType )
   {
-    geomList = geom->asGeometryCollection();
+    geomList = geom.asGeometryCollection();
   }
   else
   {
-    geomList.push_back( *geom );
+    geomList.push_back( geom );
   }
 
   QList<QgsGeometry>::iterator geomIt = geomList.begin();
   for ( ; geomIt != geomList.end(); ++geomIt )
   {
     //consider offset
+    QgsGeometry newGeom = *geomIt;
     if ( offsetField >= 0 )
     {
       double offsetVal = feature.attribute( offsetField ).toDouble();
       offsetVal *= offsetScale;
-      if ( !createOffsetGeometry( &( *geomIt ), lineGeom, offsetVal ) )
+      newGeom = createOffsetGeometry( *geomIt, lineGeom, offsetVal );
+      if ( newGeom.isEmpty() )
       {
         continue;
       }
     }
 
-    feature.setGeometry( *geomIt );
+    feature.setGeometry( newGeom );
     if ( fileWriter )
     {
       fileWriter->addFeature( feature );
@@ -1041,57 +1036,52 @@ void QgsGeometryAnalyzer::addEventLayerFeature( QgsFeature& feature, QgsGeometry
       memoryFeatures << feature;
     }
   }
-
-  if ( forceSingleType )
-  {
-    delete geom;
-  }
 }
 
-bool QgsGeometryAnalyzer::createOffsetGeometry( QgsGeometry* geom, const QgsGeometry& lineGeom, double offset )
+QgsGeometry QgsGeometryAnalyzer::createOffsetGeometry( const QgsGeometry& geom, const QgsGeometry& lineGeom, double offset )
 {
   if ( !geom || lineGeom.isEmpty() )
   {
-    return false;
+    return QgsGeometry();
   }
 
   QList<QgsGeometry> inputGeomList;
 
-  if ( geom->isMultipart() )
+  if ( geom.isMultipart() )
   {
-    inputGeomList = geom->asGeometryCollection();
+    inputGeomList = geom.asGeometryCollection();
   }
   else
   {
-    inputGeomList.push_back( *geom );
+    inputGeomList.push_back( geom );
   }
 
   QList<GEOSGeometry*> outputGeomList;
   QList<QgsGeometry>::const_iterator inputGeomIt = inputGeomList.constBegin();
   GEOSContextHandle_t geosctxt = QgsGeometry::getGEOSHandler();
   for ( ; inputGeomIt != inputGeomList.constEnd(); ++inputGeomIt )
   {
-    if ( geom->type() == QgsWkbTypes::LineGeometry )
+    if ( geom.type() == QgsWkbTypes::LineGeometry )
     {
       //geos 3.3 needed for line offsets
 #if defined(GEOS_VERSION_MAJOR) && defined(GEOS_VERSION_MINOR) && \
       ((GEOS_VERSION_MAJOR>3) || ((GEOS_VERSION_MAJOR==3) && (GEOS_VERSION_MINOR>=3)))
       GEOSGeometry* offsetGeom = GEOSOffsetCurve_r( geosctxt, ( *inputGeomIt ).asGeos(), -offset, 8 /*quadSegments*/, 0 /*joinStyle*/, 5.0 /*mitreLimit*/ );
       if ( !offsetGeom || !GEOSisValid_r( geosctxt, offsetGeom ) )
       {
-        return false;
+        return QgsGeometry();
       }
       if ( !GEOSisValid_r( geosctxt, offsetGeom ) || GEOSGeomTypeId_r( geosctxt, offsetGeom ) != GEOS_LINESTRING || GEOSGeomGetNumPoints_r( geosctxt, offsetGeom ) < 1 )
       {
         GEOSGeom_destroy_r( geosctxt, offsetGeom );
-        return false;
+        return QgsGeometry();
       }
       outputGeomList.push_back( offsetGeom );
 #else
       outputGeomList.push_back( GEOSGeom_clone_r( geosctxt, ( *inputGeomIt )->asGeos() ) );
 #endif
     }
-    else if ( geom->type() == QgsWkbTypes::PointGeometry )
+    else if ( geom.type() == QgsWkbTypes::PointGeometry )
     {
       QgsPoint p = ( *inputGeomIt ).asPoint();
       p = createPointOffset( p.x(), p.y(), offset, lineGeom );
@@ -1103,12 +1093,13 @@ bool QgsGeometryAnalyzer::createOffsetGeometry( QgsGeometry* geom, const QgsGeom
     }
   }
 
-  if ( !geom->isMultipart() )
+  QgsGeometry outGeometry;
+  if ( !geom.isMultipart() )
   {
     GEOSGeometry* outputGeom = outputGeomList.at( 0 );
     if ( outputGeom )
     {
-      geom->fromGeos( outputGeom );
+      outGeometry.fromGeos( outputGeom );
     }
   }
   else
@@ -1119,18 +1110,18 @@ bool QgsGeometryAnalyzer::createOffsetGeometry( QgsGeometry* geom, const QgsGeom
       geomArray[i] = outputGeomList.at( i );
     }
     GEOSGeometry* collection = nullptr;
-    if ( geom->type() == QgsWkbTypes::PointGeometry )
+    if ( geom.type() == QgsWkbTypes::PointGeometry )
     {
       collection = GEOSGeom_createCollection_r( geosctxt, GEOS_MULTIPOINT, geomArray, outputGeomList.size() );
     }
-    else if ( geom->type() == QgsWkbTypes::LineGeometry )
+    else if ( geom.type() == QgsWkbTypes::LineGeometry )
     {
       collection = GEOSGeom_createCollection_r( geosctxt, GEOS_MULTILINESTRING, geomArray, outputGeomList.size() );
     }
-    geom->fromGeos( collection );
+    outGeometry.fromGeos( collection );
     delete[] geomArray;
   }
-  return true;
+  return outGeometry;
 }
 
 QgsPoint QgsGeometryAnalyzer::createPointOffset( double x, double y, double dist, const QgsGeometry& lineGeom ) const
diff --git a/src/analysis/vector/qgsgeometryanalyzer.h b/src/analysis/vector/qgsgeometryanalyzer.h
@@ -128,7 +128,7 @@ class ANALYSIS_EXPORT QgsGeometryAnalyzer
   private:
 
     QList<double> simpleMeasure( QgsGeometry& geometry );
-    double perimeterMeasure( QgsGeometry* geometry, QgsDistanceArea& measure );
+    double perimeterMeasure( const QgsGeometry& geometry, QgsDistanceArea& measure );
     /** Helper function to simplify an individual feature*/
     void simplifyFeature( QgsFeature& f, QgsVectorFileWriter* vfw, double tolerance );
     /** Helper function to get the cetroid of an individual feature*/
@@ -139,16 +139,16 @@ class ANALYSIS_EXPORT QgsGeometryAnalyzer
     /** Helper function to get the convex hull of feature(s)*/
     void convexFeature( QgsFeature& f, int nProcessedFeatures, QgsGeometry& dissolveGeometry );
     /** Helper function to dissolve feature(s)*/
-    void dissolveFeature( QgsFeature& f, int nProcessedFeatures, QgsGeometry** dissolveGeometry );
+    QgsGeometry dissolveFeature( const QgsFeature& f, const QgsGeometry& dissolveInto );
 
     //helper functions for event layer
-    void addEventLayerFeature( QgsFeature& feature, QgsGeometry* geom, const QgsGeometry& lineGeom, QgsVectorFileWriter* fileWriter, QgsFeatureList& memoryFeatures, int offsetField = -1, double offsetScale = 1.0,
+    void addEventLayerFeature( QgsFeature& feature, const QgsGeometry& geom, const QgsGeometry& lineGeom, QgsVectorFileWriter* fileWriter, QgsFeatureList& memoryFeatures, int offsetField = -1, double offsetScale = 1.0,
                                bool forceSingleType = false );
     /** Create geometry offset relative to line geometry.
         @param geom the geometry to modify
         @param lineGeom the line geometry to which the feature is referenced
         @param offset the offset value in layer unit. Negative values mean offset towards left, positive values offset to the right side*/
-    bool createOffsetGeometry( QgsGeometry* geom, const QgsGeometry& lineGeom, double offset );
+    QgsGeometry createOffsetGeometry( const QgsGeometry& geom, const QgsGeometry& lineGeom, double offset );
     QgsPoint createPointOffset( double x, double y, double dist, const QgsGeometry& lineGeom ) const;
     QgsConstWkbPtr locateBetweenWkbString( QgsConstWkbPtr ptr, QgsMultiPolyline& result, double fromMeasure, double toMeasure );
     QgsConstWkbPtr locateAlongWkbString( QgsConstWkbPtr ptr, QgsMultiPoint& result, double measure );

Original file line number	Diff line number	Diff line change
`@@ -347,14 +347,14 @@ QList<double> QgsGeometryAnalyzer::simpleMeasure( QgsGeometry& mpGeometry )`
`347`	`347`	`list.append( measure.measureArea( mpGeometry ) );`
`348`	`348`	`if ( mpGeometry.type() == QgsWkbTypes::PolygonGeometry )`
`349`	`349`	`{`
`350`		`- perim = perimeterMeasure( &mpGeometry, measure );`
	`350`	`+ perim = perimeterMeasure( mpGeometry, measure );`
`351`	`351`	`list.append( perim );`
`352`	`352`	`}`
`353`	`353`	`}`
`354`	`354`	`return list;`
`355`	`355`	`}`
`356`	`356`
`357`		`-double QgsGeometryAnalyzer::perimeterMeasure( QgsGeometry* geometry, QgsDistanceArea& measure )`
	`357`	`+double QgsGeometryAnalyzer::perimeterMeasure( const QgsGeometry& geometry, QgsDistanceArea& measure )`
`358`	`358`	`{`
`359`	`359`	`return measure.measurePerimeter( geometry );`
`360`	`360`	`}`
`@@ -520,7 +520,6 @@ bool QgsGeometryAnalyzer::convexHull( QgsVectorLayer* layer, const QString& shap`
`520`	`520`	`++jt;`
`521`	`521`	`}`
`522`	`522`	`QList<double> values;`
`523`		`- // QgsGeometry* tmpGeometry = 0;`
`524`	`523`	`if ( dissolveGeometry.isEmpty() )`
`525`	`524`	`{`
`526`	`525`	`QgsDebugMsg( "no dissolved geometry - should not happen" );`
`@@ -615,7 +614,7 @@ bool QgsGeometryAnalyzer::dissolve( QgsVectorLayer* layer, const QString& shapef`
`615`	`614`	`}`
`616`	`615`	`}`
`617`	`616`
`618`		`- QgsGeometry *dissolveGeometry = nullptr; //dissolve geometry`
	`617`	`+ QgsGeometry dissolveGeometry; //dissolve geometry`
`619`	`618`	`QMultiMap<QString, QgsFeatureId>::const_iterator jt = map.constBegin();`
`620`	`619`	`QgsFeature outputFeature;`
`621`	`620`	`while ( jt != map.constEnd() )`
`@@ -653,7 +652,7 @@ bool QgsGeometryAnalyzer::dissolve( QgsVectorLayer* layer, const QString& shapef`
`653`	`652`	`outputFeature.setAttributes( currentFeature.attributes() );`
`654`	`653`	`first = false;`
`655`	`654`	`}`
`656`		`- dissolveFeature( currentFeature, processedFeatures, &dissolveGeometry );`
	`655`	`+ dissolveGeometry = dissolveFeature( currentFeature, dissolveGeometry );`
`657`	`656`	`++processedFeatures;`
`658`	`657`	`}`
`659`	`658`	`++jt;`
`@@ -686,38 +685,33 @@ bool QgsGeometryAnalyzer::dissolve( QgsVectorLayer* layer, const QString& shapef`
`686`	`685`	`outputFeature.setAttributes( currentFeature.attributes() );`
`687`	`686`	`first = false;`
`688`	`687`	`}`
`689`		`- dissolveFeature( currentFeature, processedFeatures, &dissolveGeometry );`
	`688`	`+ dissolveGeometry = dissolveFeature( currentFeature, dissolveGeometry );`
`690`	`689`	`++processedFeatures;`
`691`	`690`	`++jt;`
`692`	`691`	`}`
`693`	`692`	`}`
`694`		`- outputFeature.setGeometry( *dissolveGeometry );`
`695`		`- delete dissolveGeometry;`
	`693`	`+ outputFeature.setGeometry( dissolveGeometry );`
`696`	`694`	`vWriter.addFeature( outputFeature );`
`697`	`695`	`}`
`698`	`696`	`return true;`
`699`	`697`	`}`
`700`	`698`
`701`		`-void QgsGeometryAnalyzer::dissolveFeature( QgsFeature& f, int nProcessedFeatures, QgsGeometry** dissolveGeometry )`
	`699`	`+QgsGeometry QgsGeometryAnalyzer::dissolveFeature( const QgsFeature& f, const QgsGeometry& dissolveInto )`
`702`	`700`	`{`
`703`	`701`	`if ( !f.hasGeometry() )`
`704`	`702`	`{`
`705`		`- return;`
	`703`	`+ return dissolveInto;`
`706`	`704`	`}`
`707`	`705`
`708`	`706`	`QgsGeometry featureGeometry = f.geometry();`
`709`	`707`
`710`		`- if ( nProcessedFeatures == 0 )`
	`708`	`+ if ( dissolveInto.isEmpty() )`
`711`	`709`	`{`
`712`		`- int geomSize = featureGeometry.wkbSize();`
`713`		`- *dissolveGeometry = new QgsGeometry();`
`714`		`- unsigned char* wkb = new unsigned char[geomSize];`
`715`		`- memcpy( wkb, featureGeometry.asWkb(), geomSize );`
`716`		`- ( *dissolveGeometry )->fromWkb( wkb, geomSize );`
	`710`	`+ return featureGeometry;`
`717`	`711`	`}`
`718`	`712`	`else`
`719`	`713`	`{`
`720`		`- *dissolveGeometry = ( dissolveGeometry )->combine( featureGeometry );`
	`714`	`+ return dissolveInto.combine( featureGeometry );`
`721`	`715`	`}`
`722`	`716`	`}`
`723`	`717`
`@@ -744,7 +738,7 @@ bool QgsGeometryAnalyzer::buffer( QgsVectorLayer* layer, const QString& shapefil`
`744`	`738`
`745`	`739`	`QgsVectorFileWriter vWriter( shapefileName, dp->encoding(), layer->fields(), outputType, crs );`
`746`	`740`	`QgsFeature currentFeature;`
`747`		`- QgsGeometry *dissolveGeometry = nullptr; //dissolve geometry (if dissolve enabled)`
	`741`	`+ QgsGeometry dissolveGeometry; //dissolve geometry (if dissolve enabled)`
`748`	`742`
`749`	`743`	`//take only selection`
`750`	`744`	`if ( onlySelectedFeatures )`
`@@ -773,7 +767,7 @@ bool QgsGeometryAnalyzer::buffer( QgsVectorLayer* layer, const QString& shapefil`
`773`	`767`	`{`
`774`	`768`	`continue;`
`775`	`769`	`}`
`776`		`- bufferFeature( currentFeature, processedFeatures, &vWriter, dissolve, *dissolveGeometry, bufferDistance, bufferDistanceField );`
	`770`	`+ bufferFeature( currentFeature, processedFeatures, &vWriter, dissolve, dissolveGeometry, bufferDistance, bufferDistanceField );`
`777`	`771`	`++processedFeatures;`
`778`	`772`	`}`
`779`	`773`
`@@ -804,7 +798,7 @@ bool QgsGeometryAnalyzer::buffer( QgsVectorLayer* layer, const QString& shapefil`
`804`	`798`	`{`
`805`	`799`	`break;`
`806`	`800`	`}`
`807`		`- bufferFeature( currentFeature, processedFeatures, &vWriter, dissolve, *dissolveGeometry, bufferDistance, bufferDistanceField );`
	`801`	`+ bufferFeature( currentFeature, processedFeatures, &vWriter, dissolve, dissolveGeometry, bufferDistance, bufferDistanceField );`
`808`	`802`	`++processedFeatures;`
`809`	`803`	`}`
`810`	`804`	`if ( p )`
`@@ -816,13 +810,12 @@ bool QgsGeometryAnalyzer::buffer( QgsVectorLayer* layer, const QString& shapefil`
`816`	`810`	`if ( dissolve )`
`817`	`811`	`{`
`818`	`812`	`QgsFeature dissolveFeature;`
`819`		`- if ( !dissolveGeometry )`
	`813`	`+ if ( dissolveGeometry.isEmpty() )`
`820`	`814`	`{`
`821`	`815`	`QgsDebugMsg( "no dissolved geometry - should not happen" );`
`822`	`816`	`return false;`
`823`	`817`	`}`
`824`		`- dissolveFeature.setGeometry( *dissolveGeometry );`
`825`		`- delete dissolveGeometry;`
	`818`	`+ dissolveFeature.setGeometry( dissolveGeometry );`
`826`	`819`	`vWriter.addFeature( dissolveFeature );`
`827`	`820`	`}`
`828`	`821`	`return true;`
`@@ -977,7 +970,7 @@ bool QgsGeometryAnalyzer::eventLayer( QgsVectorLayer* lineLayer, QgsVectorLayer*`
`977`	`970`	`if ( !lrsGeom.isEmpty() )`
`978`	`971`	`{`
`979`	`972`	`++nOutputFeatures;`
`980`		`- addEventLayerFeature( fet, &lrsGeom, featureIdIt->geometry(), fileWriter, memoryProviderFeatures, offsetField, offsetScale, forceSingleGeometry );`
	`973`	`+ addEventLayerFeature( fet, lrsGeom, featureIdIt->geometry(), fileWriter, memoryProviderFeatures, offsetField, offsetScale, forceSingleGeometry );`
`981`	`974`	`}`
`982`	`975`	`}`
`983`	`976`	`if ( nOutputFeatures < 1 )`
`@@ -999,39 +992,41 @@ bool QgsGeometryAnalyzer::eventLayer( QgsVectorLayer* lineLayer, QgsVectorLayer*`
`999`	`992`	`return true;`
`1000`	`993`	`}`
`1001`	`994`
`1002`		`-void QgsGeometryAnalyzer::addEventLayerFeature( QgsFeature& feature, QgsGeometry* geom, const QgsGeometry& lineGeom, QgsVectorFileWriter* fileWriter, QgsFeatureList& memoryFeatures,`
	`995`	`+void QgsGeometryAnalyzer::addEventLayerFeature( QgsFeature& feature, const QgsGeometry& geom, const QgsGeometry& lineGeom, QgsVectorFileWriter* fileWriter, QgsFeatureList& memoryFeatures,`
`1003`	`996`	`int offsetField, double offsetScale, bool forceSingleType )`
`1004`	`997`	`{`
`1005`		`- if ( !geom )`
	`998`	`+ if ( geom.isEmpty() )`
`1006`	`999`	`{`
`1007`	`1000`	`return;`
`1008`	`1001`	`}`
`1009`	`1002`
`1010`	`1003`	`QList<QgsGeometry> geomList;`
`1011`	`1004`	`if ( forceSingleType )`
`1012`	`1005`	`{`
`1013`		`- geomList = geom->asGeometryCollection();`
	`1006`	`+ geomList = geom.asGeometryCollection();`
`1014`	`1007`	`}`
`1015`	`1008`	`else`
`1016`	`1009`	`{`
`1017`		`- geomList.push_back( *geom );`
	`1010`	`+ geomList.push_back( geom );`
`1018`	`1011`	`}`
`1019`	`1012`
`1020`	`1013`	`QList<QgsGeometry>::iterator geomIt = geomList.begin();`
`1021`	`1014`	`for ( ; geomIt != geomList.end(); ++geomIt )`
`1022`	`1015`	`{`
`1023`	`1016`	`//consider offset`
	`1017`	`+ QgsGeometry newGeom = *geomIt;`
`1024`	`1018`	`if ( offsetField >= 0 )`
`1025`	`1019`	`{`
`1026`	`1020`	`double offsetVal = feature.attribute( offsetField ).toDouble();`
`1027`	`1021`	`offsetVal *= offsetScale;`
`1028`		`- if ( !createOffsetGeometry( &( *geomIt ), lineGeom, offsetVal ) )`
	`1022`	`+ newGeom = createOffsetGeometry( *geomIt, lineGeom, offsetVal );`
	`1023`	`+ if ( newGeom.isEmpty() )`
`1029`	`1024`	`{`
`1030`	`1025`	`continue;`
`1031`	`1026`	`}`
`1032`	`1027`	`}`
`1033`	`1028`
`1034`		`- feature.setGeometry( *geomIt );`
	`1029`	`+ feature.setGeometry( newGeom );`
`1035`	`1030`	`if ( fileWriter )`
`1036`	`1031`	`{`
`1037`	`1032`	`fileWriter->addFeature( feature );`
`@@ -1041,57 +1036,52 @@ void QgsGeometryAnalyzer::addEventLayerFeature( QgsFeature& feature, QgsGeometry`
`1041`	`1036`	`memoryFeatures << feature;`
`1042`	`1037`	`}`
`1043`	`1038`	`}`
`1044`		`-`
`1045`		`- if ( forceSingleType )`
`1046`		`- {`
`1047`		`- delete geom;`
`1048`		`- }`
`1049`	`1039`	`}`
`1050`	`1040`
`1051`		`-bool QgsGeometryAnalyzer::createOffsetGeometry( QgsGeometry* geom, const QgsGeometry& lineGeom, double offset )`
	`1041`	`+QgsGeometry QgsGeometryAnalyzer::createOffsetGeometry( const QgsGeometry& geom, const QgsGeometry& lineGeom, double offset )`
`1052`	`1042`	`{`
`1053`	`1043`	`if ( !geom \|\| lineGeom.isEmpty() )`
`1054`	`1044`	`{`
`1055`		`- return false;`
	`1045`	`+ return QgsGeometry();`
`1056`	`1046`	`}`
`1057`	`1047`
`1058`	`1048`	`QList<QgsGeometry> inputGeomList;`
`1059`	`1049`
`1060`		`- if ( geom->isMultipart() )`
	`1050`	`+ if ( geom.isMultipart() )`
`1061`	`1051`	`{`
`1062`		`- inputGeomList = geom->asGeometryCollection();`
	`1052`	`+ inputGeomList = geom.asGeometryCollection();`
`1063`	`1053`	`}`
`1064`	`1054`	`else`
`1065`	`1055`	`{`
`1066`		`- inputGeomList.push_back( *geom );`
	`1056`	`+ inputGeomList.push_back( geom );`
`1067`	`1057`	`}`
`1068`	`1058`
`1069`	`1059`	`QList<GEOSGeometry*> outputGeomList;`
`1070`	`1060`	`QList<QgsGeometry>::const_iterator inputGeomIt = inputGeomList.constBegin();`
`1071`	`1061`	`GEOSContextHandle_t geosctxt = QgsGeometry::getGEOSHandler();`
`1072`	`1062`	`for ( ; inputGeomIt != inputGeomList.constEnd(); ++inputGeomIt )`
`1073`	`1063`	`{`
`1074`		`- if ( geom->type() == QgsWkbTypes::LineGeometry )`
	`1064`	`+ if ( geom.type() == QgsWkbTypes::LineGeometry )`
`1075`	`1065`	`{`
`1076`	`1066`	`//geos 3.3 needed for line offsets`
`1077`	`1067`	`#if defined(GEOS_VERSION_MAJOR) && defined(GEOS_VERSION_MINOR) && \`
`1078`	`1068`	`((GEOS_VERSION_MAJOR>3) \|\| ((GEOS_VERSION_MAJOR==3) && (GEOS_VERSION_MINOR>=3)))`
`1079`	`1069`	`GEOSGeometry* offsetGeom = GEOSOffsetCurve_r( geosctxt, ( inputGeomIt ).asGeos(), -offset, 8 /quadSegments/, 0 /joinStyle/, 5.0 /mitreLimit*/ );`
`1080`	`1070`	`if ( !offsetGeom \|\| !GEOSisValid_r( geosctxt, offsetGeom ) )`
`1081`	`1071`	`{`
`1082`		`- return false;`
	`1072`	`+ return QgsGeometry();`
`1083`	`1073`	`}`
`1084`	`1074`	`if ( !GEOSisValid_r( geosctxt, offsetGeom ) \|\| GEOSGeomTypeId_r( geosctxt, offsetGeom ) != GEOS_LINESTRING \|\| GEOSGeomGetNumPoints_r( geosctxt, offsetGeom ) < 1 )`
`1085`	`1075`	`{`
`1086`	`1076`	`GEOSGeom_destroy_r( geosctxt, offsetGeom );`
`1087`		`- return false;`
	`1077`	`+ return QgsGeometry();`
`1088`	`1078`	`}`
`1089`	`1079`	`outputGeomList.push_back( offsetGeom );`
`1090`	`1080`	`#else`
`1091`	`1081`	`outputGeomList.push_back( GEOSGeom_clone_r( geosctxt, ( *inputGeomIt )->asGeos() ) );`
`1092`	`1082`	`#endif`
`1093`	`1083`	`}`
`1094`		`- else if ( geom->type() == QgsWkbTypes::PointGeometry )`
	`1084`	`+ else if ( geom.type() == QgsWkbTypes::PointGeometry )`
`1095`	`1085`	`{`
`1096`	`1086`	`QgsPoint p = ( *inputGeomIt ).asPoint();`
`1097`	`1087`	`p = createPointOffset( p.x(), p.y(), offset, lineGeom );`
`@@ -1103,12 +1093,13 @@ bool QgsGeometryAnalyzer::createOffsetGeometry( QgsGeometry* geom, const QgsGeom`
`1103`	`1093`	`}`
`1104`	`1094`	`}`
`1105`	`1095`
`1106`		`- if ( !geom->isMultipart() )`
	`1096`	`+ QgsGeometry outGeometry;`
	`1097`	`+ if ( !geom.isMultipart() )`
`1107`	`1098`	`{`
`1108`	`1099`	`GEOSGeometry* outputGeom = outputGeomList.at( 0 );`
`1109`	`1100`	`if ( outputGeom )`
`1110`	`1101`	`{`
`1111`		`- geom->fromGeos( outputGeom );`
	`1102`	`+ outGeometry.fromGeos( outputGeom );`
`1112`	`1103`	`}`
`1113`	`1104`	`}`
`1114`	`1105`	`else`
`@@ -1119,18 +1110,18 @@ bool QgsGeometryAnalyzer::createOffsetGeometry( QgsGeometry* geom, const QgsGeom`
`1119`	`1110`	`geomArray[i] = outputGeomList.at( i );`
`1120`	`1111`	`}`
`1121`	`1112`	`GEOSGeometry* collection = nullptr;`
`1122`		`- if ( geom->type() == QgsWkbTypes::PointGeometry )`
	`1113`	`+ if ( geom.type() == QgsWkbTypes::PointGeometry )`
`1123`	`1114`	`{`
`1124`	`1115`	`collection = GEOSGeom_createCollection_r( geosctxt, GEOS_MULTIPOINT, geomArray, outputGeomList.size() );`
`1125`	`1116`	`}`
`1126`		`- else if ( geom->type() == QgsWkbTypes::LineGeometry )`
	`1117`	`+ else if ( geom.type() == QgsWkbTypes::LineGeometry )`
`1127`	`1118`	`{`
`1128`	`1119`	`collection = GEOSGeom_createCollection_r( geosctxt, GEOS_MULTILINESTRING, geomArray, outputGeomList.size() );`
`1129`	`1120`	`}`
`1130`		`- geom->fromGeos( collection );`
	`1121`	`+ outGeometry.fromGeos( collection );`
`1131`	`1122`	`delete[] geomArray;`
`1132`	`1123`	`}`
`1133`		`- return true;`
	`1124`	`+ return outGeometry;`
`1134`	`1125`	`}`
`1135`	`1126`
`1136`	`1127`	`QgsPoint QgsGeometryAnalyzer::createPointOffset( double x, double y, double dist, const QgsGeometry& lineGeom ) const`