Merge pull request #5195 from wonder-sk/tracing-with-offset

wonder-sk · web-flow · commit 9d8734c2b959 · 2017-10-10T13:12:57.000+02:00
Tracing with offset
diff --git a/python/core/qgstracer.sip b/python/core/qgstracer.sip
@@ -60,6 +60,33 @@ Get extent to which graph's features will be limited (empty extent means no limi
     void setExtent( const QgsRectangle &extent );
 %Docstring
 Set extent to which graph's features will be limited (empty extent means no limit)
+%End
+
+    double offset() const;
+%Docstring
+ Get offset in map units that should be applied to the traced paths returned from findShortestPath().
+ Positive offset for right side, negative offset for left side.
+.. versionadded:: 3.0
+ :rtype: float
+%End
+
+    void setOffset( double offset );
+%Docstring
+ Set offset in map units that should be applied to the traced paths returned from findShortestPath().
+ Positive offset for right side, negative offset for left side.
+.. versionadded:: 3.0
+%End
+
+    void offsetParameters( int &quadSegments /Out/, int &joinStyle /Out/, double &miterLimit /Out/ );
+%Docstring
+ Get extra parameters for offset curve algorithm (used when offset is non-zero)
+.. versionadded:: 3.0
+%End
+
+    void setOffsetParameters( int quadSegments, int joinStyle, double miterLimit );
+%Docstring
+ Set extra parameters for offset curve algorithm (used when offset is non-zero)
+.. versionadded:: 3.0
 %End
 
     int maxFeatureCount() const;
diff --git a/python/gui/qgsmaptooladvanceddigitizing.sip b/python/gui/qgsmaptooladvanceddigitizing.sip
@@ -108,6 +108,8 @@ Catch the mouse move event, filters it, transforms it to map coordinates and sen
 .. versionadded:: 3.0
 %End
 
+  public:
+
     virtual void cadCanvasPressEvent( QgsMapMouseEvent *e );
 %Docstring
  Override this method when subclassing this class.
diff --git a/src/app/qgisapp.cpp b/src/app/qgisapp.cpp
@@ -1246,6 +1246,7 @@ QgisApp::QgisApp()
   mLayerTreeView = new QgsLayerTreeView( this );
   mUndoWidget = new QgsUndoWidget( nullptr, mMapCanvas );
   mInfoBar = new QgsMessageBar( centralWidget() );
+  mAdvancedDigitizingDockWidget = new QgsAdvancedDigitizingDockWidget( mMapCanvas, this );
   // More tests may need more members to be initialized
 }
 
@@ -2285,6 +2286,8 @@ void QgisApp::createToolBars()
 
   mTracer = new QgsMapCanvasTracer( mMapCanvas, messageBar() );
   mTracer->setActionEnableTracing( mSnappingWidget->enableTracingAction() );
+  connect( mSnappingWidget->tracingOffsetSpinBox(), static_cast< void ( QgsDoubleSpinBox::* )( double ) >( &QgsDoubleSpinBox::valueChanged ),
+  this, [ = ]( double v ) { mTracer->setOffset( v ); } );
 
   QList<QAction *> toolbarMenuActions;
   // Set action names so that they can be used in customization
diff --git a/src/app/qgssnappingwidget.cpp b/src/app/qgssnappingwidget.cpp
@@ -16,15 +16,17 @@
 
 #include <QAction>
 #include <QComboBox>
-#include <QDoubleSpinBox>
 #include <QFont>
 #include <QHBoxLayout>
 #include <QHeaderView>
+#include <QLabel>
 #include <QMenu>
 #include <QToolBar>
 #include <QToolButton>
+#include <QWidgetAction>
 
 #include "qgsapplication.h"
+#include "qgsdoublespinbox.h"
 #include "qgslayertreegroup.h"
 #include "qgslayertree.h"
 #include "qgslayertreeview.h"
@@ -148,6 +150,22 @@ QgsSnappingWidget::QgsSnappingWidget( QgsProject *project, QgsMapCanvas *canvas,
   mEnableTracingAction->setShortcut( tr( "T", "Enable Tracing" ) );
   mEnableTracingAction->setObjectName( QStringLiteral( "EnableTracingAction" ) );
 
+  mTracingOffsetSpinBox = new QgsDoubleSpinBox;
+  mTracingOffsetSpinBox->setRange( -1000000, 1000000 );
+  mTracingOffsetSpinBox->setDecimals( 6 );
+  mTracingOffsetSpinBox->setClearValue( 0 );
+  mTracingOffsetSpinBox->setClearValueMode( QgsDoubleSpinBox::CustomValue );
+  QMenu *tracingMenu = new QMenu( this );
+  QWidgetAction *widgetAction = new QWidgetAction( tracingMenu );
+  QVBoxLayout *tracingWidgetLayout = new QVBoxLayout;
+  tracingWidgetLayout->addWidget( new QLabel( "Offset" ) );
+  tracingWidgetLayout->addWidget( mTracingOffsetSpinBox );
+  QWidget *tracingWidget = new QWidget;
+  tracingWidget->setLayout( tracingWidgetLayout );
+  widgetAction->setDefaultWidget( tracingWidget );
+  tracingMenu->addAction( widgetAction );
+  mEnableTracingAction->setMenu( tracingMenu );
+
   // layout
   if ( mDisplayMode == ToolBar )
   {
diff --git a/src/app/qgssnappingwidget.h b/src/app/qgssnappingwidget.h
@@ -24,6 +24,7 @@ class QFont;
 class QToolButton;
 class QTreeView;
 
+class QgsDoubleSpinBox;
 class QgsLayerTreeGroup;
 class QgsLayerTreeNode;
 class QgsLayerTreeView;
@@ -74,6 +75,9 @@ class APP_EXPORT QgsSnappingWidget : public QWidget
      */
     QAction *enableTracingAction() { return mEnableTracingAction; }
 
+    //! Returns spin box used to set offset for tracing
+    QgsDoubleSpinBox *tracingOffsetSpinBox() { return mTracingOffsetSpinBox; }
+
   signals:
     void snappingConfigChanged();
 
@@ -136,6 +140,7 @@ class APP_EXPORT QgsSnappingWidget : public QWidget
     QAction *mTopologicalEditingAction = nullptr;
     QAction *mIntersectionSnappingAction = nullptr;
     QAction *mEnableTracingAction = nullptr;
+    QgsDoubleSpinBox *mTracingOffsetSpinBox = nullptr;
     QTreeView *mLayerTreeView = nullptr;
 
     void cleanGroup( QgsLayerTreeNode *node );
diff --git a/src/core/qgstracer.cpp b/src/core/qgstracer.cpp
@@ -615,6 +615,25 @@ void QgsTracer::setExtent( const QgsRectangle &extent )
   invalidateGraph();
 }
 
+void QgsTracer::setOffset( double offset )
+{
+  mOffset = offset;
+}
+
+void QgsTracer::offsetParameters( int &quadSegments, int &joinStyle, double &miterLimit )
+{
+  quadSegments = mOffsetSegments;
+  joinStyle = mOffsetJoinStyle;
+  miterLimit = mOffsetMiterLimit;
+}
+
+void QgsTracer::setOffsetParameters( int quadSegments, int joinStyle, double miterLimit )
+{
+  mOffsetSegments = quadSegments;
+  mOffsetJoinStyle = joinStyle;
+  mOffsetMiterLimit = miterLimit;
+}
+
 bool QgsTracer::init()
 {
   if ( mGraph )
@@ -695,6 +714,30 @@ QVector<QgsPointXY> QgsTracer::findShortestPath( const QgsPointXY &p1, const Qgs
 
   resetGraph( *mGraph );
 
+  if ( !points.isEmpty() && mOffset != 0 )
+  {
+    QList<QgsPointXY> pointsInput( points.toList() );
+    QgsLineString linestring( pointsInput );
+    std::unique_ptr<QgsGeometryEngine> linestringEngine( QgsGeometry::createGeometryEngine( &linestring ) );
+    std::unique_ptr<QgsAbstractGeometry> linestringOffset( linestringEngine->offsetCurve( mOffset, mOffsetSegments, mOffsetJoinStyle, mOffsetMiterLimit ) );
+    if ( QgsLineString *ls2 = qgsgeometry_cast<QgsLineString *>( linestringOffset.get() ) )
+    {
+      points.clear();
+      for ( int i = 0; i < ls2->numPoints(); ++i )
+        points << QgsPointXY( ls2->pointN( i ) );
+
+      // sometimes (with negative offset?) the resulting curve is reversed
+      if ( points.count() >= 2 )
+      {
+        QgsPointXY res1 = points.first(), res2 = points.last();
+        double diffNormal = res1.distance( p1 ) + res2.distance( p2 );
+        double diffReversed = res1.distance( p2 ) + res2.distance( p1 );
+        if ( diffReversed < diffNormal )
+          std::reverse( points.begin(), points.end() );
+      }
+    }
+  }
+
   if ( error )
     *error = points.isEmpty() ? ErrNoPath : ErrNone;
 
diff --git a/src/core/qgstracer.h b/src/core/qgstracer.h
@@ -63,6 +63,32 @@ class CORE_EXPORT QgsTracer : public QObject
     //! Set extent to which graph's features will be limited (empty extent means no limit)
     void setExtent( const QgsRectangle &extent );
 
+    /**
+     * Get offset in map units that should be applied to the traced paths returned from findShortestPath().
+     * Positive offset for right side, negative offset for left side.
+     * \since QGIS 3.0
+     */
+    double offset() const { return mOffset; }
+
+    /**
+     * Set offset in map units that should be applied to the traced paths returned from findShortestPath().
+     * Positive offset for right side, negative offset for left side.
+     * \since QGIS 3.0
+     */
+    void setOffset( double offset );
+
+    /**
+     * Get extra parameters for offset curve algorithm (used when offset is non-zero)
+     * \since QGIS 3.0
+     */
+    void offsetParameters( int &quadSegments SIP_OUT, int &joinStyle SIP_OUT, double &miterLimit SIP_OUT );
+
+    /**
+     * Set extra parameters for offset curve algorithm (used when offset is non-zero)
+     * \since QGIS 3.0
+     */
+    void setOffsetParameters( int quadSegments, int joinStyle, double miterLimit );
+
     //! Get maximum possible number of features in graph. If the number is exceeded, graph is not created.
     int maxFeatureCount() const { return mMaxFeatureCount; }
     //! Get maximum possible number of features in graph. If the number is exceeded, graph is not created.
@@ -138,6 +164,15 @@ class CORE_EXPORT QgsTracer : public QObject
     //! Extent for graph building (empty extent means no limit)
     QgsRectangle mExtent;
 
+    //! Offset in map units that should be applied to the traced paths
+    double mOffset = 0;
+    //! Offset parameter: Number of segments (approximation of circle quarter) when using round join style
+    int mOffsetSegments = 8;
+    //! Offset parameter: Join style (1 = round, 2 = miter, 3 = bevel)
+    int mOffsetJoinStyle = 2;
+    //! Offset parameter: Limit for miter join style
+    double mOffsetMiterLimit = 5.;
+
     /**
      * Limit of how many features can be in the graph (0 means no limit).
      * This is to avoid possibly long graph preparation for complicated layers
diff --git a/src/gui/qgsmaptooladvanceddigitizing.h b/src/gui/qgsmaptooladvanceddigitizing.h
@@ -106,6 +106,8 @@ class GUI_EXPORT QgsMapToolAdvancedDigitizing : public QgsMapToolEdit
      */
     void setAutoSnapEnabled( bool enabled ) { mAutoSnapEnabled = enabled; }
 
+  public:
+
     /**
      * Override this method when subclassing this class.
      * This will receive adapted events from the cad system whenever a
diff --git a/src/gui/qgsmaptoolcapture.cpp b/src/gui/qgsmaptoolcapture.cpp
@@ -142,6 +142,12 @@ QgsPointXY QgsMapToolCapture::tracingStartPoint()
     QgsMapLayer *layer = mCanvas->currentLayer();
     if ( !layer )
       return QgsPointXY();
+
+    // if we have starting point from previous trace, then preferably use that one
+    // (useful when tracing with offset)
+    if ( mTracingStartPoint != QgsPointXY() )
+      return mTracingStartPoint;
+
     QgsPoint v = mCaptureCurve.endPoint();
     return toMapCoordinates( layer, QgsPointXY( v.x(), v.y() ) );
   }
@@ -179,6 +185,26 @@ bool QgsMapToolCapture::tracingMouseMove( QgsMapMouseEvent *e )
   if ( mCaptureMode == CapturePolygon )
     mTempRubberBand->addPoint( *mRubberBand->getPoint( 0, 0 ), false );
 
+  // if there is offset, we need to fix the rubber bands to make sure they are aligned correctly.
+  // There are two cases we need to sort out:
+  // 1. the last point of mRubberBand may need to be moved off the traced curve to respect the offset
+  // 2. extra first point of mTempRubberBand may be needed if there is gap between where mRubberBand ends and trace starts
+  if ( mRubberBand->numberOfVertices() != 0 )
+  {
+    QgsPointXY lastPoint = *mRubberBand->getPoint( 0, mRubberBand->numberOfVertices() - 1 );
+    if ( lastPoint == pt0 && points[0] != lastPoint )
+    {
+      // if rubber band had just one point, for some strange reason it contains the point twice
+      // we only want to move the last point if there are multiple points already
+      if ( mRubberBand->numberOfVertices() > 2 || ( mRubberBand->numberOfVertices() == 2 && *mRubberBand->getPoint( 0, 0 ) != *mRubberBand->getPoint( 0, 1 ) ) )
+        mRubberBand->movePoint( points[0] );
+    }
+    else
+    {
+      mTempRubberBand->addPoint( lastPoint, false );
+    }
+  }
+
   //  update rubberband
   for ( int i = 0; i < points.count(); ++i )
     mTempRubberBand->addPoint( points.at( i ), i == points.count() - 1 );
@@ -225,22 +251,53 @@ bool QgsMapToolCapture::tracingAddVertex( const QgsPointXY &point )
   if ( points.isEmpty() )
     return false; // ignore the vertex - can't find path to the end point!
 
+  if ( !mCaptureCurve.isEmpty() )
+  {
+    QgsPoint lp; // in layer coords
+    if ( nextPoint( QgsPoint( pt0 ), lp ) != 0 )
+      return false;
+    QgsPoint last;
+    QgsVertexId::VertexType type;
+    mCaptureCurve.pointAt( mCaptureCurve.numPoints() - 1, last, type );
+    if ( last == lp )
+    {
+      // remove the last point in the curve if it is the same as our first point
+      if ( mCaptureCurve.numPoints() != 2 )
+        mCaptureCurve.deleteVertex( QgsVertexId( 0, 0, mCaptureCurve.numPoints() - 1 ) );
+      else
+      {
+        // there is a strange behavior in deleteVertex() that with just two points
+        // the whole curve is cleared - so we need to do this little dance to work it around
+        QgsPoint first = mCaptureCurve.startPoint();
+        mCaptureCurve.clear();
+        mCaptureCurve.addVertex( first );
+      }
+      // for unknown reasons, rubber band has 2 points even if only one point has been added - handle that case
+      if ( mRubberBand->numberOfVertices() == 2 && *mRubberBand->getPoint( 0, 0 ) == *mRubberBand->getPoint( 0, 1 ) )
+        mRubberBand->removeLastPoint();
+      mRubberBand->removeLastPoint();
+      mSnappingMatches.removeLast();
+    }
+  }
+
   // transform points
   QgsPointSequence layerPoints;
   QgsPoint lp; // in layer coords
-  for ( int i = 1; i < points.count(); ++i )
+  for ( int i = 0; i < points.count(); ++i )
   {
     if ( nextPoint( QgsPoint( points[i] ), lp ) != 0 )
       return false;
     layerPoints << lp;
   }
 
-  for ( int i = 1; i < points.count(); ++i )
+  for ( int i = 0; i < points.count(); ++i )
   {
-    if ( points[i] == points[i - 1] )
+    if ( i == 0 && !mCaptureCurve.isEmpty() && mCaptureCurve.endPoint() == layerPoints[0] )
+      continue;  // avoid duplicate of the first vertex
+    if ( i > 0 && points[i] == points[i - 1] )
       continue; // avoid duplicate vertices if there are any
     mRubberBand->addPoint( points[i], i == points.count() - 1 );
-    mCaptureCurve.addVertex( layerPoints[i - 1] );
+    mCaptureCurve.addVertex( layerPoints[i] );
     mSnappingMatches.append( QgsPointLocator::Match() );
   }
 
@@ -291,9 +348,7 @@ void QgsMapToolCapture::cadCanvasMoveEvent( QgsMapMouseEvent *e )
 
     if ( !hasTrace )
     {
-      if ( mCaptureCurve.numPoints() > 0 &&
-           ( ( mCaptureMode == CaptureLine && mTempRubberBand->numberOfVertices() != 2 ) ||
-             ( mCaptureMode == CapturePolygon && mTempRubberBand->numberOfVertices() != 3 ) ) )
+      if ( mCaptureCurve.numPoints() > 0 )
       {
         // fix temporary rubber band after tracing which may have added multiple points
         mTempRubberBand->reset( mCaptureMode == CapturePolygon ? QgsWkbTypes::PolygonGeometry : QgsWkbTypes::LineGeometry );
@@ -303,6 +358,10 @@ void QgsMapToolCapture::cadCanvasMoveEvent( QgsMapMouseEvent *e )
         QgsPointXY mapPt = toMapCoordinates( qobject_cast<QgsVectorLayer *>( mCanvas->currentLayer() ), QgsPointXY( pt.x(), pt.y() ) );
         mTempRubberBand->addPoint( mapPt );
         mTempRubberBand->addPoint( point );
+
+        // fix existing rubber band after tracing - the last point may have been moved if using offset
+        if ( mRubberBand->numberOfVertices() )
+          mRubberBand->movePoint( mapPt );
       }
       else
         mTempRubberBand->movePoint( point );
@@ -419,6 +478,10 @@ int QgsMapToolCapture::addVertex( const QgsPointXY &point, const QgsPointLocator
     traceCreated = tracingAddVertex( point );
   }
 
+  // keep new tracing start point if we created a trace. This is useful when tracing with
+  // offset so that the user stays "snapped"
+  mTracingStartPoint = traceCreated ? point : QgsPointXY();
+
   if ( !traceCreated )
   {
     // ordinary digitizing
@@ -499,6 +562,8 @@ QList<QgsPointLocator::Match> QgsMapToolCapture::snappingMatches() const
 
 void QgsMapToolCapture::undo()
 {
+  mTracingStartPoint = QgsPointXY();
+
   if ( mRubberBand )
   {
     int rubberBandSize = mRubberBand->numberOfVertices();
@@ -585,6 +650,8 @@ void QgsMapToolCapture::stopCapturing()
 
   mGeomErrors.clear();
 
+  mTracingStartPoint = QgsPointXY();
+
 #ifdef Q_OS_WIN
   Q_FOREACH ( QWidget *w, qApp->topLevelWidgets() )
   {
diff --git a/src/gui/qgsmaptoolcapture.h b/src/gui/qgsmaptoolcapture.h
diff --git a/tests/src/app/CMakeLists.txt b/tests/src/app/CMakeLists.txt
diff --git a/tests/src/app/testqgsmaptooladdfeature.cpp b/tests/src/app/testqgsmaptooladdfeature.cpp
diff --git a/tests/src/core/testqgstracer.cpp b/tests/src/core/testqgstracer.cpp

-Original file line number
+Diff line change
     QgsVertexMarker *mSnappingMarker = nullptr;
 +    /**
 +     * Keeps point (in map units) snapped to a segment where we most recently finished tracing,
 +     * so that we can use as the starting point for further tracing. This is useful mainly when
 +     * tracing with offset: without knowledge of this point user would need to click a segment
 +     * again after every time a new trace with offset is created (to get new "anchor" point)
 +     */
 +    QgsPointXY mTracingStartPoint;
++
 #ifdef Q_OS_WIN
     int mSkipNextContextMenuEvent;
 #endif
-Original file line number
+Diff line change
 ADD_QGIS_TEST(qgisappclipboard testqgisappclipboard.cpp)
 ADD_QGIS_TEST(attributetabletest testqgsattributetable.cpp)
 ADD_QGIS_TEST(fieldcalculatortest testqgsfieldcalculator.cpp)
 +ADD_QGIS_TEST(maptooladdfeature testqgsmaptooladdfeature.cpp)
 ADD_QGIS_TEST(maptoolidentifyaction testqgsmaptoolidentifyaction.cpp)
 ADD_QGIS_TEST(maptoolselect testqgsmaptoolselect.cpp)
 ADD_QGIS_TEST(measuretool testqgsmeasuretool.cpp)
-Original file line number
+Diff line change
@@ @@ -0,0 +1,351 @@ @@
 +/***************************************************************************
 +     testqgsmaptooladdfeature.cpp
 +     ----------------------
 +    Date                 : October 2017
 +    Copyright            : (C) 2017 by Martin Dobias
 +    Email                : wonder dot sk at gmail dot com
 + ***************************************************************************
 + *                                                                         *
 + *   This program is free software; you can redistribute it and/or modify  *
 + *   it under the terms of the GNU General Public License as published by  *
 + *   the Free Software Foundation; either version 2 of the License, or     *
 + *   (at your option) any later version.                                   *
 + *                                                                         *
 + ***************************************************************************/
++
 +#include "qgstest.h"
++
 +#include "qgisapp.h"
 +#include "qgsadvanceddigitizingdockwidget.h"
 +#include "qgsgeometry.h"
 +#include "qgsmapcanvas.h"
 +#include "qgsmapcanvassnappingutils.h"
 +#include "qgsmaptooladdfeature.h"
 +#include "qgsmapcanvastracer.h"
 +#include "qgsproject.h"
 +#include "qgsvectorlayer.h"
++
++
 +bool operator==( const QgsGeometry &g1, const QgsGeometry &g2 )
 +{
 +  if ( g1.isNull() && g2.isNull() )
 +    return true;
 +  else
 +    return g1.isGeosEqual( g2 );
 +}
++
 +namespace QTest
 +{
 +  // pretty printing of geometries in comparison tests
 +  template<> char *toString( const QgsGeometry &geom )
 +  {
 +    QByteArray ba = geom.exportToWkt().toAscii();
 +    return qstrdup( ba.data() );
 +  }
 +}
++
 +static QSet<QgsFeatureId> _existingFeatureIds( QgsVectorLayer *layer )
 +{
 +  QSet<QgsFeatureId> fids;
 +  QgsFeature f;
 +  QgsFeatureIterator it = layer->getFeatures();
 +  while ( it.nextFeature( f ) )
 +    fids << f.id();
 +  return fids;
 +}
++
 +static QgsFeatureId _newFeatureId( QgsVectorLayer *layer, QSet<QgsFeatureId> oldFids )
 +{
 +  QSet<QgsFeatureId> newFids = _existingFeatureIds( layer );
 +  QSet<QgsFeatureId> diffFids = newFids.subtract( oldFids );
 +  Q_ASSERT( diffFids.count() == 1 );
 +  return *diffFids.constBegin();
 +}
++
++
++
 +/**
 + * \ingroup UnitTests
 + * This is a unit test for the node tool
 + */
 +class TestQgsMapToolAddFeature : public QObject
 +{
 +    Q_OBJECT
 +  public:
 +    TestQgsMapToolAddFeature();
++
 +  private slots:
 +    void initTestCase();// will be called before the first testfunction is executed.
 +    void cleanupTestCase();// will be called after the last testfunction was executed.
++
 +    void testNoTracing();
 +    void testTracing();
 +    void testTracingWithOffset();
++
 +  private:
 +    QPoint mapToScreen( double mapX, double mapY )
 +    {
 +      QgsPointXY pt = mCanvas->mapSettings().mapToPixel().transform( mapX, mapY );
 +      return QPoint( std::round( pt.x() ), std::round( pt.y() ) );
 +    }
++
 +    void mouseMove( double mapX, double mapY )
 +    {
 +      QgsMapMouseEvent e( mCanvas, QEvent::MouseMove, mapToScreen( mapX, mapY ) );
 +      mCaptureTool->cadCanvasMoveEvent( &e );
 +    }
++
 +    void mousePress( double mapX, double mapY, Qt::MouseButton button, Qt::KeyboardModifiers stateKey = Qt::KeyboardModifiers() )
 +    {
 +      QgsMapMouseEvent e1( mCanvas, QEvent::MouseButtonPress, mapToScreen( mapX, mapY ), button, button, stateKey );
 +      mCaptureTool->cadCanvasPressEvent( &e1 );
 +    }
++
 +    void mouseRelease( double mapX, double mapY, Qt::MouseButton button, Qt::KeyboardModifiers stateKey = Qt::KeyboardModifiers() )
 +    {
 +      QgsMapMouseEvent e2( mCanvas, QEvent::MouseButtonRelease, mapToScreen( mapX, mapY ), button, Qt::MouseButton(), stateKey );
 +      mCaptureTool->cadCanvasReleaseEvent( &e2 );
 +    }
++
 +    void mouseClick( double mapX, double mapY, Qt::MouseButton button, Qt::KeyboardModifiers stateKey = Qt::KeyboardModifiers() )
 +    {
 +      mousePress( mapX, mapY, button, stateKey );
 +      mouseRelease( mapX, mapY, button, stateKey );
 +    }
++
 +    void keyClick( int key )
 +    {
 +      QKeyEvent e1( QEvent::KeyPress, key, Qt::KeyboardModifiers() );
 +      mCaptureTool->keyPressEvent( &e1 );
++
 +      QKeyEvent e2( QEvent::KeyRelease, key, Qt::KeyboardModifiers() );
 +      mCaptureTool->keyReleaseEvent( &e2 );
 +    }
++
 +  private:
 +    QgisApp *mQgisApp = nullptr;
 +    QgsMapCanvas *mCanvas = nullptr;
 +    QgsMapCanvasTracer *mTracer = nullptr;
 +    QAction *mEnableTracingAction = nullptr;
 +    QgsMapToolAddFeature *mCaptureTool = nullptr;
 +    QgsVectorLayer *mLayerLine = nullptr;
 +    QgsFeatureId mFidLineF1 = 0;
 +};
++
 +TestQgsMapToolAddFeature::TestQgsMapToolAddFeature() = default;
++
++
 +//runs before all tests
 +void TestQgsMapToolAddFeature::initTestCase()
 +{
 +  qDebug() << "TestMapToolCapture::initTestCase()";
 +  // init QGIS's paths - true means that all path will be inited from prefix
 +  QgsApplication::init();
 +  QgsApplication::initQgis();
++
 +  // Set up the QSettings environment
 +  QCoreApplication::setOrganizationName( QStringLiteral( "QGIS" ) );
 +  QCoreApplication::setOrganizationDomain( QStringLiteral( "qgis.org" ) );
 +  QCoreApplication::setApplicationName( QStringLiteral( "QGIS-TEST" ) );
++
 +  mQgisApp = new QgisApp();
++
 +  mCanvas = new QgsMapCanvas();
++
 +  mCanvas->setDestinationCrs( QgsCoordinateReferenceSystem( QStringLiteral( "EPSG:27700" ) ) );
++
 +  // make testing layers
 +  mLayerLine = new QgsVectorLayer( QStringLiteral( "LineString?crs=EPSG:27700" ), QStringLiteral( "layer line" ), QStringLiteral( "memory" ) );
 +  QVERIFY( mLayerLine->isValid() );
 +  QgsProject::instance()->addMapLayers( QList<QgsMapLayer *>() << mLayerLine );
++
 +  QgsPolyline line1;
 +  line1 << QgsPointXY( 1, 1 ) << QgsPointXY( 2, 1 ) << QgsPointXY( 3, 2 ) << QgsPointXY( 1, 2 ) << QgsPointXY( 1, 1 );
 +  QgsFeature lineF1;
 +  lineF1.setGeometry( QgsGeometry::fromPolyline( line1 ) );
++
 +  mLayerLine->startEditing();
 +  mLayerLine->addFeature( lineF1 );
 +  mFidLineF1 = lineF1.id();
 +  QCOMPARE( mLayerLine->featureCount(), ( long )1 );
++
 +  // just one added feature
 +  QCOMPARE( mLayerLine->undoStack()->index(), 1 );
++
 +  mCanvas->setFrameStyle( QFrame::NoFrame );
 +  mCanvas->resize( 512, 512 );
 +  mCanvas->setExtent( QgsRectangle( 0, 0, 8, 8 ) );
 +  mCanvas->show(); // to make the canvas resize
 +  mCanvas->hide();
 +  QCOMPARE( mCanvas->mapSettings().outputSize(), QSize( 512, 512 ) );
 +  QCOMPARE( mCanvas->mapSettings().visibleExtent(), QgsRectangle( 0, 0, 8, 8 ) );
++
 +  mCanvas->setLayers( QList<QgsMapLayer *>() << mLayerLine ); //<< mLayerPolygon << mLayerPoint );
++
 +  mCanvas->setSnappingUtils( new QgsMapCanvasSnappingUtils( mCanvas, this ) );
++
 +  // create the tool
 +  mCaptureTool = new QgsMapToolAddFeature( mCanvas, /*mAdvancedDigitizingDockWidget, */ QgsMapToolCapture::CaptureLine );
++
 +  mCanvas->setMapTool( mCaptureTool );
 +  mCanvas->setCurrentLayer( mLayerLine );
++
 +  mEnableTracingAction = new QAction( nullptr );
 +  mEnableTracingAction->setCheckable( true );
++
 +  mTracer = new QgsMapCanvasTracer( mCanvas, nullptr );
 +  mTracer->setActionEnableTracing( mEnableTracingAction );
++
 +  QCOMPARE( mCanvas->mapSettings().outputSize(), QSize( 512, 512 ) );
 +  QCOMPARE( mCanvas->mapSettings().visibleExtent(), QgsRectangle( 0, 0, 8, 8 ) );
 +}
++
 +//runs after all tests
 +void TestQgsMapToolAddFeature::cleanupTestCase()
 +{
 +  delete mCaptureTool;
 +  delete mCanvas;
 +  QgsApplication::exitQgis();
 +}
++
 +void TestQgsMapToolAddFeature::testNoTracing()
 +{
 +  // tracing not enabled - will be straight line
++
 +  QSet<QgsFeatureId> oldFids = _existingFeatureIds( mLayerLine );
++
 +  mouseClick( 1, 1, Qt::LeftButton );
 +  mouseClick( 3, 2, Qt::LeftButton );
 +  mouseClick( 3, 2, Qt::RightButton );
++
 +  QgsFeatureId newFid = _newFeatureId( mLayerLine, oldFids );
++
 +  QCOMPARE( mLayerLine->undoStack()->index(), 2 );
 +  QCOMPARE( mLayerLine->getFeature( newFid ).geometry(), QgsGeometry::fromWkt( "LINESTRING(1 1, 3 2)" ) );
++
 +  mLayerLine->undoStack()->undo();
 +  QCOMPARE( mLayerLine->undoStack()->index(), 1 );
 +}
++
 +void TestQgsMapToolAddFeature::testTracing()
 +{
 +  // tracing enabled - same clicks - now following line
++
 +  mEnableTracingAction->setChecked( true );
++
 +  QSet<QgsFeatureId> oldFids = _existingFeatureIds( mLayerLine );
++
 +  mouseClick( 1, 1, Qt::LeftButton );
 +  mouseClick( 3, 2, Qt::LeftButton );
 +  mouseClick( 3, 2, Qt::RightButton );
++
 +  QgsFeatureId newFid = _newFeatureId( mLayerLine, oldFids );
++
 +  QCOMPARE( mLayerLine->undoStack()->index(), 2 );
 +  QCOMPARE( mLayerLine->getFeature( newFid ).geometry(), QgsGeometry::fromWkt( "LINESTRING(1 1, 2 1, 3 2)" ) );
++
 +  mLayerLine->undoStack()->undo();
++
 +  // no other unexpected changes happened
 +  QCOMPARE( mLayerLine->undoStack()->index(), 1 );
++
 +  // tracing enabled - combined with first and last segments that are not traced
++
 +  mouseClick( 0, 2, Qt::LeftButton );
 +  mouseClick( 1, 1, Qt::LeftButton );
 +  mouseClick( 3, 2, Qt::LeftButton );
 +  mouseClick( 4, 1, Qt::LeftButton );
 +  mouseClick( 4, 1, Qt::RightButton );
++
 +  QgsFeatureId newFid2 = _newFeatureId( mLayerLine, oldFids );
++
 +  QCOMPARE( mLayerLine->undoStack()->index(), 2 );
 +  QCOMPARE( mLayerLine->getFeature( newFid2 ).geometry(), QgsGeometry::fromWkt( "LINESTRING(0 2, 1 1, 2 1, 3 2, 4 1)" ) );
++
 +  mLayerLine->undoStack()->undo();
++
 +  // no other unexpected changes happened
 +  QCOMPARE( mLayerLine->undoStack()->index(), 1 );
++
 +  mEnableTracingAction->setChecked( false );
 +}
++
 +void TestQgsMapToolAddFeature::testTracingWithOffset()
 +{
 +  // tracing enabled + offset enabled
++
 +  mEnableTracingAction->setChecked( true );
 +  mTracer->setOffset( 0.1 );
++
 +  QSet<QgsFeatureId> oldFids = _existingFeatureIds( mLayerLine );
++
 +  mouseClick( 2, 1, Qt::LeftButton );
 +  mouseClick( 1, 2, Qt::LeftButton );
 +  mouseClick( 1, 2, Qt::RightButton );
++
 +  QgsFeatureId newFid = _newFeatureId( mLayerLine, oldFids );
++
 +  QCOMPARE( mLayerLine->undoStack()->index(), 2 );
++
 +  QgsGeometry g = mLayerLine->getFeature( newFid ).geometry();
 +  QgsPolyline poly = g.asPolyline();
 +  QCOMPARE( poly.count(), 3 );
 +  QCOMPARE( poly[0], QgsPointXY( 2, 0.9 ) );
 +  QCOMPARE( poly[1], QgsPointXY( 0.9, 0.9 ) );
 +  QCOMPARE( poly[2], QgsPointXY( 0.9, 2 ) );
++
 +  mLayerLine->undoStack()->undo();
++
 +  // no other unexpected changes happened
 +  QCOMPARE( mLayerLine->undoStack()->index(), 1 );
++
 +  // use negative offset
 +  mTracer->setOffset( -0.1 );
++
 +  mouseClick( 2, 1, Qt::LeftButton );
 +  mouseClick( 1, 2, Qt::LeftButton );
 +  mouseClick( 1, 2, Qt::RightButton );
++
 +  QgsFeatureId newFid2 = _newFeatureId( mLayerLine, oldFids );
++
 +  QgsGeometry g2 = mLayerLine->getFeature( newFid2 ).geometry();
 +  QgsPolyline poly2 = g2.asPolyline();
 +  QCOMPARE( poly2.count(), 3 );
 +  QCOMPARE( poly2[0], QgsPointXY( 2, 1.1 ) );
 +  QCOMPARE( poly2[1], QgsPointXY( 1.1, 1.1 ) );
 +  QCOMPARE( poly2[2], QgsPointXY( 1.1, 2 ) );
++
 +  mLayerLine->undoStack()->undo();
++
 +  // tracing enabled + offset enabled - combined with first and last segments that are not traced
++
 +  mouseClick( 3, 0, Qt::LeftButton );
 +  mouseClick( 2, 1, Qt::LeftButton );
 +  mouseClick( 1, 2, Qt::LeftButton );
 +  mouseClick( 0, 1, Qt::LeftButton );
 +  mouseClick( 0, 1, Qt::RightButton );
++
 +  QgsFeatureId newFid3 = _newFeatureId( mLayerLine, oldFids );
++
 +  QCOMPARE( mLayerLine->undoStack()->index(), 2 );
 +  QgsGeometry g3 = mLayerLine->getFeature( newFid3 ).geometry();
 +  QgsPolyline poly3 = g3.asPolyline();
 +  QCOMPARE( poly3.count(), 5 );
 +  QCOMPARE( poly3[0], QgsPointXY( 3, 0 ) );
 +  QCOMPARE( poly3[1], QgsPointXY( 2, 1.1 ) );
 +  QCOMPARE( poly3[2], QgsPointXY( 1.1, 1.1 ) );
 +  QCOMPARE( poly3[3], QgsPointXY( 1.1, 2 ) );
 +  QCOMPARE( poly3[4], QgsPointXY( 0, 1 ) );
++
 +  mLayerLine->undoStack()->undo();
++
 +  // no other unexpected changes happened
 +  QCOMPARE( mLayerLine->undoStack()->index(), 1 );
++
++
 +  mEnableTracingAction->setChecked( false );
 +}
++
++
 +QGSTEST_MAIN( TestQgsMapToolAddFeature )
 +#include "testqgsmaptooladdfeature.moc"
-Original file line number
+Diff line change
     void testExtent();
     void testReprojection();
     void testCurved();
 +    void testOffset();
   private:
   delete vl;
+}
 +void TestQgsTracer::testOffset()
 +{
 +  QStringList wkts;
 +  wkts  << QStringLiteral( "LINESTRING(0 0, 0 10)" )
 +        << QStringLiteral( "LINESTRING(0 0, 10 0)" )
 +        << QStringLiteral( "LINESTRING(0 10, 20 10)" )
 +        << QStringLiteral( "LINESTRING(10 0, 20 10)" );
++
 +  /* This shape - nearly a square (one side is shifted to have exactly one shortest
 +   * path between corners):
 +   * 0,10 +----+  20,10
 +   *      |   /
 +   * 0,0  +--+  10,0
 +   */
++
 +  QgsVectorLayer *vl = make_layer( wkts );
++
 +  QgsTracer tracer;
 +  tracer.setLayers( QList<QgsVectorLayer *>() << vl );
++
 +  // curve on the right side
 +  tracer.setOffset( -1 );
 +  QgsPolyline points1 = tracer.findShortestPath( QgsPointXY( 0, 0 ), QgsPointXY( 20, 10 ) );
 +  QCOMPARE( points1.count(), 3 );
 +  QCOMPARE( points1[0], QgsPointXY( 0, -1 ) );
 +  QCOMPARE( points1[1], QgsPointXY( 10 + sqrt( 2 ) - 1, -1 ) );
 +  QCOMPARE( points1[2], QgsPointXY( 20 + sqrt( 2 ) / 2, 10 - sqrt( 2 ) / 2 ) );
++
 +  // curve on the left side
 +  tracer.setOffset( 1 );
 +  QgsPolyline points2 = tracer.findShortestPath( QgsPointXY( 0, 0 ), QgsPointXY( 20, 10 ) );
 +  QCOMPARE( points2.count(), 3 );
 +  QCOMPARE( points2[0], QgsPointXY( 0, 1 ) );
 +  QCOMPARE( points2[1], QgsPointXY( 10 - sqrt( 2 ) + 1, 1 ) );
 +  QCOMPARE( points2[2], QgsPointXY( 20 - sqrt( 2 ) / 2, 10 + sqrt( 2 ) / 2 ) );
++
 +  delete vl;
 +}
++
 QGSTEST_MAIN( TestQgsTracer )
 #include "testqgstracer.moc"