qgsmaptooleditblanksegments.cpp

Go to the documentation of this file.

/***************************************************************************
    qgsmaptooleditblanksegments.cpp
    ---------------------
    begin                : 2025/08/19
    copyright            : (C) 2025 by Julien Cabieces
    email                : julien dot cabieces at oslandia 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 "qgsmaptooleditblanksegments.h"
 
#include <line_p.h>
 
#include "qgsauxiliarystorage.h"
#include "qgscoordinatetransform.h"
#include "qgsfeatureid.h"
#include "qgsguiutils.h"
#include "qgslinesymbollayer.h"
#include "qgsmapcanvas.h"
#include "qgsmapmouseevent.h"
#include "qgsnewauxiliarylayerdialog.h"
#include "qgsnullpainterdevice.h"
#include "qgsrubberband.h"
#include "qgssettingsentryimpl.h"
#include "qgssettingsregistrycore.h"
#include "qgssinglesymbolrenderer.h"
#include "qgssnappingutils.h"
#include "qgsstyleentityvisitor.h"
#include "qgssymbol.h"
#include "qgsvectorlayer.h"
 
#include "moc_qgsmaptooleditblanksegments.cpp"
 
constexpr int TOLERANCE = 20;
 


 
namespace
{

  class QgsSymbolLayerFinder : public QgsStyleEntityVisitorInterface
  {
    public:
      QgsSymbolLayerFinder( const QString &symbolLayerId )
        : mSymbolLayerId( symbolLayerId )
      {}
 
      bool visitEnter( const QgsStyleEntityVisitorInterface::Node &node ) override
      {
        if ( node.type != QgsStyleEntityVisitorInterface::NodeType::SymbolRule )
          return false;
 
        return true;
      }

      bool visitSymbol( const QgsSymbol *symbol )
      {
        if ( symbol && !mSymbol )
          mSymbol = symbol;
 
        for ( int idx = 0; idx < symbol->symbolLayerCount(); idx++ )
        {
          const QgsSymbolLayer *sl = symbol->symbolLayer( idx );
          if ( sl->id() == mSymbolLayerId )
          {
            mSymbolLayer = dynamic_cast<const QgsTemplatedLineSymbolLayerBase *>( sl );
            mSymbolLayerIndex = mSymbolLayer ? idx : -1;
            return false;
          }
 
          // recurse over sub symbols
          if ( const QgsSymbol *subSymbol = const_cast<QgsSymbolLayer *>( sl )->subSymbol(); subSymbol && !visitSymbol( subSymbol ) )
          {
            return false;
          }
        }
 
        return true;
      }
 
      bool visit( const QgsStyleEntityVisitorInterface::StyleLeaf &leaf ) override
      {
        if ( leaf.entity && leaf.entity->type() == QgsStyle::SymbolEntity )
        {
          auto symbolEntity = static_cast<const QgsStyleSymbolEntity *>( leaf.entity );
          if ( symbolEntity->symbol() )
            visitSymbol( symbolEntity->symbol() );
        }
        return true;
      }

      const QgsSymbol *symbol() const { return mSymbol; }

      const QgsTemplatedLineSymbolLayerBase *symbolLayer() const { return mSymbolLayer; }

      int symbolLayerIndex() const { return mSymbolLayerIndex; }
 
    private:
      const QgsSymbol *mSymbol = nullptr;
      const QgsTemplatedLineSymbolLayerBase *mSymbolLayer = nullptr;
      int mSymbolLayerIndex = -1;
      const QString &mSymbolLayerId;
  };

  const QPointF &pointAt( const QList<QList<QPolygonF>> &points, int partIndex, int ringIndex, int pointIndex )
  {
    if ( partIndex < 0 || partIndex >= points.count() )
      throw std::invalid_argument( "Blank segments internal error : Invalid part index" );
 
    const QList<QPolygonF> &rings = points.at( partIndex );
    if ( ringIndex < 0 || ringIndex >= rings.count() )
      throw std::invalid_argument( "blank segments internal error : Invalid ring index" );
 
    const QPolygonF &pts = rings.at( ringIndex );
    if ( pointIndex < 0 || pointIndex >= pts.count() )
      throw std::invalid_argument( "blank segments internal error : Invalid point index" );
 
    return pts.at( pointIndex );
  }
 
  enum ProjectedPointStatus
  {
    OK,            // ok, point is on the segment
    LINE_EMPTY,    // line is empty, cannot project point
    NOT_ON_SEGMENT // point is on the line, but not on the segment
  };

  QPointF projectedPoint( const QPointF &lineStartPt, const QPointF &lineEndPt, const QPointF &point, double &distance, ProjectedPointStatus &status )
  {
    status = ProjectedPointStatus::OK;
    distance = -1;
 
    const double Ax = lineStartPt.x();
    const double Ay = lineStartPt.y();
    const double Bx = lineEndPt.x();
    const double By = lineEndPt.y();
    const double Cx = point.x();
    const double Cy = point.y();
 
    const double length = QgsGeometryUtilsBase::distance2D( Ax, Ay, Bx, By );
    if ( length == 0 )
    {
      status = ProjectedPointStatus::LINE_EMPTY;
      return QPointF();
    }
 
    const double r = ( ( Cx - Ax ) * ( Bx - Ax ) + ( Cy - Ay ) * ( By - Ay ) ) / std::pow( length, 2 );
    if ( r < 0 or r > 1 )
    {
      status = ProjectedPointStatus::NOT_ON_SEGMENT;
    }
 
    // projected point
    const double Px = Ax + r * ( Bx - Ax );
    const double Py = Ay + r * ( By - Ay );
 
    distance = QgsGeometryUtilsBase::distance2D( Cx, Cy, Px, Py );
 
    return QPointF( Px, Py );
  }
 
} //namespace
 

class QgsMapToolEditBlankSegmentsBase::QgsBlankSegmentRubberBand : public QgsRubberBand
{
  public:
    QgsBlankSegmentRubberBand( int partIndex, int ringIndex, int startIndex, int endIndex, QPointF startPt, QPointF endPt, QgsMapCanvas *canvas, const FeaturePoints &points );

    QgsBlankSegmentRubberBand( QgsMapCanvas *canvas, const FeaturePoints &points );

    void setPoints( int partIndex, int ringIndex, int startIndex, int endIndex, QPointF startPt, QPointF endPt );

    void copyFrom( const QgsBlankSegmentRubberBand &blankSegment );

    void setHighlighted( bool highlighted );

    const QPointF &getStartPoint() const;

    const QPointF &getEndPoint() const;

    int getStartIndex() const;

    int getEndIndex() const;

    int getPartIndex() const;

    int getRingIndex() const;

    QPair<double, double> getStartEndDistance( Qgis::RenderUnit unit ) const;

    int pointsCount() const;

    const QPointF &pointAt( int index ) const;
 
  private:
    void updatePoints();
 
    int mPartIndex = -1;
    int mRingIndex = -1;
    int mStartIndex = -1;
    int mEndIndex = -1;
    QPointF mStartPt;
    QPointF mEndPt;
    bool mNeedSwap = false;
    const FeaturePoints &mPoints; 
};
 
QgsMapToolEditBlankSegmentsBase::QgsMapToolEditBlankSegmentsBase( QgsMapCanvas *canvas, QgsVectorLayer *layer, QgsTemplatedLineSymbolLayerBase *symbolLayer, QgsPropertyOverrideButton *propertyButton )
  : QgsMapTool( canvas )
  , mLayer( layer )
  , mSymbolLayer( symbolLayer )
  , mPropertyButton( propertyButton )
  , mEditedBlankSegment( new QgsBlankSegmentRubberBand( canvas, mPoints ) )
  , mStartRubberBand( new QgsRubberBand( canvas, Qgis::GeometryType::Point ) )
  , mEndRubberBand( new QgsRubberBand( canvas, Qgis::GeometryType::Point ) )
{
  auto initRubberBand = []( QgsRubberBand *rb ) {
    rb->setWidth( QgsGuiUtils::scaleIconSize( 4 ) );
    rb->setColor( QgsSettingsRegistryCore::settingsDigitizingLineColor->value() );
    rb->setIcon( QgsRubberBand::IconType::ICON_BOX );
  };
 
  initRubberBand( mStartRubberBand );
  initRubberBand( mEndRubberBand );
 
  mEditedBlankSegment->setHighlighted( true );
 
  connect( mPropertyButton, &QgsPropertyOverrideButton::changed, this, [this] {
    mBlankSegmentsFieldIndex = dataDefinedColumnIndex( static_cast<int>( QgsSymbolLayer::Property::BlankSegments ), mSymbolLayer->dataDefinedProperties(), mLayer );
 
    mCurrentFeatureId = FID_NULL;
    mState = SelectFeature;
    loadFeaturePoints();
  } );
}
 
QgsMapToolEditBlankSegmentsBase::~QgsMapToolEditBlankSegmentsBase() = default;
 
void QgsMapToolEditBlankSegmentsBase::activate()
{
  if ( !mLayer || !mLayer->renderer() || !mSymbolLayer )
    return;
 
  if ( !mSymbol || !mRenderedPointsSymbolLayer )
  {
    // search and symbol and symbol layer
    QgsSymbolLayerFinder finder( mSymbolLayer->id() );
    mLayer->renderer()->accept( &finder );
    if ( finder.symbol() && finder.symbolLayer() && finder.symbolLayerIndex() > -1 )
    {
      mSymbol.reset( finder.symbol()->clone() );
      if ( mRenderedPointsSymbolLayer = createRenderedPointsSymbolLayer( finder.symbolLayer() ); mRenderedPointsSymbolLayer )
      {
        // set our on symbol layer to later retrieve rendered points
        mSymbol->changeSymbolLayer( finder.symbolLayerIndex(), mRenderedPointsSymbolLayer );
      }
      else
      {
        mSymbol.reset();
        QgsDebugError( "Fail to create fake templated line symbol layer" );
      }
    }
    else
    {
      QgsDebugError( "Fail to retrieve symbol and templated line symbol layer" );
    }
  }
 
  QgsMapTool::activate();
}
 
void QgsMapToolEditBlankSegmentsBase::canvasMoveEvent( QgsMapMouseEvent *e )
{
  if ( !mSymbol || mPoints.isEmpty() )
    return;
 
  const QPoint &pos = e->pos();
 
  if ( canvas()->extent() != mExtent )
  {
    loadFeaturePoints();
 
    // If edition has been started, we cancel them because they are no longer in the same extent reference
    switch ( mState )
    {
      case State::SelectFeature:
      case State::BlankSegmentSelected:
      case State::FeatureSelected:
        break;
 
      case State::BlankSegmentCreationStarted:
        mState = State::FeatureSelected;
        setCurrentBlankSegment( -1 );
        break;
 
      case State::BlankSegmentModificationStarted:
        mState = State::BlankSegmentSelected;
        // force original blank segment
        setCurrentBlankSegment( mCurrentBlankSegmentIndex );
        break;
    }
  }
 
  switch ( mState )
  {
    case State::SelectFeature:
      return;
 
    case State::BlankSegmentSelected:
      updateHoveredBlankSegment( pos );
      break;
 
    case State::FeatureSelected:
    {
      updateHoveredBlankSegment( pos );
 
      // display current start point to create a new blank segment
      mStartRubberBand->setVisible( mHoveredBlankSegmentIndex == -1 );
      if ( mHoveredBlankSegmentIndex == -1 )
      {
        const QgsMapToPixel &m2p = *( canvas()->getCoordinateTransform() );
        mStartRubberBand->reset( Qgis::GeometryType::Point );
        double distance;
        int partIndex = -1, ringIndex = -1, pointIndex = -1;
        const QPointF closestPt = closestPoint( pos, distance, partIndex, ringIndex, pointIndex );
 
        // for now end point is the same as start one
        mStartRubberBand->addPoint( m2p.toMapCoordinates( closestPt.x(), closestPt.y() ) );
      }
 
      break;
    }
 
    case State::BlankSegmentModificationStarted:
    case State::BlankSegmentCreationStarted:
    {
      double distance = -1;
      int partIndex = -1;
      int pointIndex = -1;
      int ringIndex = -1;
      QPointF P = closestPoint( pos, distance, partIndex, ringIndex, pointIndex );
      if ( distance > -1 && pointIndex > -1 )
      {
        mEditedBlankSegment->setPoints( partIndex, ringIndex, mEditedBlankSegment->getStartIndex(), pointIndex, mEditedBlankSegment->getStartPoint(), P );
        updateStartEndRubberBand();
      }
    }
    break;
  }
}
 
void QgsMapToolEditBlankSegmentsBase::selectFeature( QgsMapMouseEvent *event )
{
  if ( !mLayer || !mSymbolLayer || !mPropertyButton || mPropertyButton->propertyKey() != static_cast<int>( QgsSymbolLayer::Property::BlankSegments ) )
    return;
 
  // find the closest feature to the pressed position
  const QgsPointLocator::Match m = mCanvas->snappingUtils()->snapToCurrentLayer( event->pos(), QgsPointLocator::Types( QgsPointLocator::Edge ) );
  if ( !m.isValid() )
  {
    emit
      messageEmitted( tr( "No feature was detected at the clicked position. Please click closer to the feature or enhance the search tolerance under Settings->Options->Digitizing->Search radius for vertex edits" ), Qgis::MessageLevel::Critical );
    return;
  }
 
  // initialize field index if not already done
  if ( mBlankSegmentsFieldIndex < 0 )
  {
    mBlankSegmentsFieldIndex = dataDefinedColumnIndex( static_cast<int>( QgsSymbolLayer::Property::BlankSegments ), mSymbolLayer->dataDefinedProperties(), mLayer );
  }
 
  // No data defined property, create one
  if ( mBlankSegmentsFieldIndex < 0 )
  {
    if ( !mLayer->auxiliaryLayer() )
    {
      QgsNewAuxiliaryLayerDialog dlg( mLayer );
      dlg.exec();
    }
 
    if ( !mLayer->auxiliaryLayer() )
      return;
 
    mBlankSegmentsFieldIndex = QgsAuxiliaryLayer::createProperty( QgsSymbolLayer::Property::BlankSegments, mLayer, mSymbolLayer, false );
    if ( mBlankSegmentsFieldIndex < 0 )
    {
      emit messageEmitted( tr( "Failed to create blank segments auxiliary field for layer '%1'" ).arg( mLayer->name() ) );
      return;
    }
 
    // update property override button from new property
    QgsPropertyCollection c = mSymbolLayer->dataDefinedProperties();
    QgsProperty property = c.property( static_cast<int>( QgsSymbolLayer::Property::BlankSegments ) );
    mPropertyButton->updateFieldLists();
    mPropertyButton->setToProperty( property );
    emit mPropertyButton->changed(); // setToProperty doesn't fire the changed signal
  }
 
  // start editing
 
  const bool usesAuxFields = mLayer->fields().fieldOrigin( mBlankSegmentsFieldIndex ) == Qgis::FieldOrigin::Join;
  if ( !usesAuxFields && !mLayer->isEditable() )
  {
    if ( mLayer->startEditing() )
    {
      emit messageEmitted( tr( "Layer “%1” was made editable" ).arg( mLayer->name() ) );
    }
    else
    {
      emit messageEmitted( tr( "Cannot modify blank segments — the layer “%1” could not be made editable" ).arg( mLayer->name() ) );
      return;
    }
  }
 
  mCurrentFeatureId = m.featureId();
  loadFeaturePoints();
  updateHoveredBlankSegment( event->pos() );
 
  mState = State::FeatureSelected;
}
 
void QgsMapToolEditBlankSegmentsBase::canvasPressEvent( QgsMapMouseEvent *e )
{
  switch ( mState )
  {
    case State::SelectFeature:
    {
      selectFeature( e );
      break;
    }
    case State::FeatureSelected:
 
      // new blank segment selected
      if ( mHoveredBlankSegmentIndex > -1 )
      {
        mState = State::BlankSegmentSelected;
        setCurrentBlankSegment( mHoveredBlankSegmentIndex );
      }
      // init first point of new blank segment
      else
      {
        mState = State::BlankSegmentCreationStarted;
        double distance = -1;
        int partIndex = -1;
        int pointIndex = -1;
        int ringIndex = -1;
        QPointF P = closestPoint( e->pos(), distance, partIndex, ringIndex, pointIndex );
        if ( distance > -1 && pointIndex > -1 )
        {
          mEditedBlankSegment->setPoints( partIndex, ringIndex, pointIndex, pointIndex, P, P );
          updateStartEndRubberBand();
        }
      }
 
      break;
 
    case State::BlankSegmentSelected:
    {
      Q_ASSERT( mCurrentBlankSegmentIndex > -1 && mCurrentBlankSegmentIndex < static_cast<int>( mBlankSegments.size() ) );
      const QObjectUniquePtr<QgsBlankSegmentRubberBand> &currentBlankSegment = mBlankSegments.at( mCurrentBlankSegmentIndex );
 
      // selected blank segment has changed
      if ( mHoveredBlankSegmentIndex > -1 && mHoveredBlankSegmentIndex != mCurrentBlankSegmentIndex )
      {
        setCurrentBlankSegment( mHoveredBlankSegmentIndex );
      }
      else
      {
        const double distanceFromStart = ( currentBlankSegment->getStartPoint() - e->pos() ).manhattanLength();
        const double distanceFromEnd = ( currentBlankSegment->getEndPoint() - e->pos() ).manhattanLength();
 
        // user clicked on start or end point to move it
        if ( std::min( distanceFromStart, distanceFromEnd ) < TOLERANCE )
        {
          if ( distanceFromStart < distanceFromEnd )
          {
            // start point become end point because we always edit end point
            mEditedBlankSegment->setPoints(
              currentBlankSegment->getPartIndex(),
              currentBlankSegment->getRingIndex(),
              currentBlankSegment->getEndIndex(),
              currentBlankSegment->getStartIndex(),
              currentBlankSegment->getEndPoint(),
              currentBlankSegment->getStartPoint()
            );
          }
 
          mState = State::BlankSegmentModificationStarted;
        }
      }
    }
 
    break;
 
    case State::BlankSegmentModificationStarted:
    case State::BlankSegmentCreationStarted:
 
      // this is a new one
      if ( mCurrentBlankSegmentIndex < 0 )
      {
        mBlankSegments.emplace_back( new QgsBlankSegmentRubberBand( canvas(), mPoints ) );
        mBlankSegments.back()->copyFrom( *mEditedBlankSegment );
        mState = State::FeatureSelected;
      }
      // modify an existing one
      else
      {
        QObjectUniquePtr<QgsBlankSegmentRubberBand> &blankSegment = mBlankSegments.at( mCurrentBlankSegmentIndex );
        blankSegment->copyFrom( *mEditedBlankSegment );
        mState = State::BlankSegmentSelected;
      }
 
      updateAttribute();
      break;
  }
}
 
void QgsMapToolEditBlankSegmentsBase::keyPressEvent( QKeyEvent *e )
{
  // !!! We need to ignore event instead of accept them if we want to consume them
  // see QgsMapCanvas::keyPressEvent
 
  switch ( mState )
  {
    case State::SelectFeature:
      return;
 
    case State::BlankSegmentSelected:
      if ( e->matches( QKeySequence::Delete ) && mCurrentBlankSegmentIndex > -1 )
      {
        mState = State::FeatureSelected;
        int toRemoveIndex = mCurrentBlankSegmentIndex;
        setCurrentBlankSegment( -1 );
        mBlankSegments.erase( mBlankSegments.begin() + toRemoveIndex );
        updateAttribute();
        e->ignore();
      }
      else if ( e->matches( QKeySequence::Cancel ) )
      {
        mState = State::FeatureSelected;
        setCurrentBlankSegment( -1 );
        e->ignore();
      }
 
      break;
 
    case State::FeatureSelected:
      if ( e->matches( QKeySequence::Cancel ) )
      {
        mCurrentFeatureId = FID_NULL;
        mState = State::SelectFeature;
        loadFeaturePoints();
        e->ignore();
      }
      break;
 
    case State::BlankSegmentCreationStarted:
      if ( e->matches( QKeySequence::Cancel ) )
      {
        mState = State::FeatureSelected;
        setCurrentBlankSegment( -1 );
        e->ignore();
      }
      break;
 
    case State::BlankSegmentModificationStarted:
      if ( e->matches( QKeySequence::Cancel ) )
      {
        mState = State::BlankSegmentSelected;
        // force original blank segment
        setCurrentBlankSegment( mCurrentBlankSegmentIndex );
        e->ignore();
      }
      break;
  }
}
 
QPair<double, double> QgsMapToolEditBlankSegmentsBase::QgsBlankSegmentRubberBand::getStartEndDistance( Qgis::RenderUnit unit ) const
{
  double startDistance = 0;
  const int startIndex = mNeedSwap ? mEndIndex : mStartIndex;
  const QPointF startPt = mNeedSwap ? mEndPt : mStartPt;
  for ( int i = 1; i < startIndex; i++ )
  {
    startDistance += QgsGeometryUtilsBase::distance2D( ::pointAt( mPoints, mPartIndex, mRingIndex, i - 1 ), ::pointAt( mPoints, mPartIndex, mRingIndex, i ) );
  }
 
  startDistance += QgsGeometryUtilsBase::distance2D( ::pointAt( mPoints, mPartIndex, mRingIndex, startIndex - 1 ), startPt );
 
  double endDistance = startDistance;
  for ( int i = 1; i < pointsCount(); i++ )
  {
    endDistance += QgsGeometryUtilsBase::distance2D( pointAt( i ), pointAt( i - 1 ) );
  }
 
  QgsRenderContext renderContext = QgsRenderContext::fromMapSettings( mMapCanvas->mapSettings() );
 
  startDistance = renderContext.convertFromPainterUnits( startDistance, unit );
  endDistance = renderContext.convertFromPainterUnits( endDistance, unit );
 
  return QPair<double, double>( startDistance, endDistance );
}
 
int QgsMapToolEditBlankSegmentsBase::closestBlankSegmentIndex( const QPointF &point, double &distance ) const
{
  // search for closest blankSegment
  distance = -1;
  int iBlankSegment = -1;
  for ( int i = 0; i < static_cast<int>( mBlankSegments.size() ); i++ )
  {
    const QObjectUniquePtr<QgsBlankSegmentRubberBand> &blankSegment = mBlankSegments.at( i );
    for ( int iPoint = 1; iPoint < blankSegment->pointsCount(); iPoint++ )
    {
      double d = 0;
      ProjectedPointStatus status = ProjectedPointStatus::OK;
 
      try
      {
        projectedPoint( blankSegment->pointAt( iPoint - 1 ), blankSegment->pointAt( iPoint ), point, d, status );
      }
      catch ( std::invalid_argument &e )
      {
        QgsDebugError( e.what() );
        continue;
      }
 
      switch ( status )
      {
        case ProjectedPointStatus::LINE_EMPTY:
          continue;
 
        case ProjectedPointStatus::NOT_ON_SEGMENT:
          d = std::min( ( blankSegment->getStartPoint() - point ).manhattanLength(), ( blankSegment->getEndPoint() - point ).manhattanLength() );
          break;
 
        case ProjectedPointStatus::OK:
          break;
      }
 
      if ( distance == -1 || d < distance )
      {
        distance = d;
        iBlankSegment = i;
      }
    }
  }
 
  return iBlankSegment;
}
 
QPointF QgsMapToolEditBlankSegmentsBase::closestPoint( const QPointF &point, double &distance, int &partIndex, int &ringIndex, int &pointIndex ) const
{
  distance = -1;
  QPointF currentPoint;
 
  // iterate through all points from parts and ring to get the closest one
  for ( int iPart = 0; iPart < mPoints.count(); iPart++ )
  {
    const QList<QPolygonF> &rings = mPoints.at( iPart );
    for ( int iRing = 0; iRing < rings.count(); iRing++ )
    {
      const QPolygonF &points = rings.at( iRing );
      for ( int i = 1; i < points.count(); i++ )
      {
        double d = 0;
        ProjectedPointStatus status = ProjectedPointStatus::OK;
        QPointF P = projectedPoint( points.at( i - 1 ), points.at( i ), point, d, status );
        switch ( status )
        {
          case ProjectedPointStatus::LINE_EMPTY:
          case ProjectedPointStatus::NOT_ON_SEGMENT:
            continue;
 
          case ProjectedPointStatus::OK:
            break;
        }
 
        if ( distance == -1 || d < distance )
        {
          distance = d;
          currentPoint = P;
          partIndex = iPart;
          ringIndex = iRing;
          pointIndex = i;
        }
      }
    }
  }
  return currentPoint;
}
 
 
void QgsMapToolEditBlankSegmentsBase::updateStartEndRubberBand()
{
  mStartRubberBand->reset( Qgis::GeometryType::Point );
  mEndRubberBand->reset( Qgis::GeometryType::Point );
 
  bool displayEndPoint = true;
  switch ( mState )
  {
    case State::SelectFeature:
    case State::BlankSegmentCreationStarted:
      return;
 
    case State::FeatureSelected:
      displayEndPoint = false;
      [[fallthrough]];
 
    case State::BlankSegmentSelected:
    case State::BlankSegmentModificationStarted:
      break;
  }
 
  const QgsMapToPixel &m2p = *( canvas()->getCoordinateTransform() );
 
  const QPointF &startPoint = mEditedBlankSegment->getStartPoint();
  mStartRubberBand->addPoint( m2p.toMapCoordinates( startPoint.x(), startPoint.y() ) );
 
  if ( displayEndPoint )
  {
    const QPointF &endPoint = mEditedBlankSegment->getEndPoint();
    mEndRubberBand->addPoint( m2p.toMapCoordinates( endPoint.x(), endPoint.y() ) );
  }
}
 
void QgsMapToolEditBlankSegmentsBase::updateHoveredBlankSegment( const QPoint &pos )
{
  double distance = -1;
  int iBlankSegment = closestBlankSegmentIndex( pos, distance );
 
  if ( mHoveredBlankSegmentIndex > -1 && mHoveredBlankSegmentIndex < static_cast<int>( mBlankSegments.size() ) && mHoveredBlankSegmentIndex != mCurrentBlankSegmentIndex )
  {
    mBlankSegments.at( mHoveredBlankSegmentIndex )->setHighlighted( false );
  }
 
  // blank segment is hovered
  if ( iBlankSegment > -1 && distance < TOLERANCE )
  {
    mHoveredBlankSegmentIndex = iBlankSegment;
    if ( mHoveredBlankSegmentIndex < static_cast<int>( mBlankSegments.size() ) )
    {
      mBlankSegments.at( mHoveredBlankSegmentIndex )->setHighlighted( true );
    }
  }
  // no blank segment hovered, display the first point to create a new blank segment
  else
  {
    mHoveredBlankSegmentIndex = -1;
  }
}
 
void QgsMapToolEditBlankSegmentsBase::setCurrentBlankSegment( int currentBlankSegmentIndex )
{
  // copy current blank segment so we can edit it later (and hide the original one)
 
  if ( mCurrentBlankSegmentIndex > -1 && mCurrentBlankSegmentIndex < static_cast<int>( mBlankSegments.size() ) )
  {
    mBlankSegments.at( mCurrentBlankSegmentIndex )->setVisible( true );
    mBlankSegments.at( mCurrentBlankSegmentIndex )->setHighlighted( false );
  }
 
  mCurrentBlankSegmentIndex = currentBlankSegmentIndex;
  if ( mCurrentBlankSegmentIndex > -1 && mCurrentBlankSegmentIndex < static_cast<int>( mBlankSegments.size() ) )
  {
    mBlankSegments.at( mCurrentBlankSegmentIndex )->setVisible( false );
    mEditedBlankSegment->copyFrom( *( mBlankSegments.at( mCurrentBlankSegmentIndex ).get() ) );
  }
  else
  {
    mEditedBlankSegment->setVisible( false );
  }
 
  updateStartEndRubberBand();
}
 
void QgsMapToolEditBlankSegmentsBase::updateAttribute()
{
  if ( !mRenderedPointsSymbolLayer )
    return;
 
  QList<QList<QgsSymbolLayerUtils::BlankSegments>> blankSegments;
  for ( const QObjectUniquePtr<QgsBlankSegmentRubberBand> &blankSegment : mBlankSegments )
  {
    try
    {
      QPair<double, double> startEndDistance = blankSegment->getStartEndDistance( mRenderedPointsSymbolLayer->blankSegmentsUnit() );
 
      const int partIndex = blankSegment->getPartIndex();
      if ( partIndex >= blankSegments.count() )
        blankSegments.resize( partIndex + 1 );
 
      QList<QgsSymbolLayerUtils::BlankSegments> &rings = blankSegments[partIndex];
      const int ringIndex = blankSegment->getRingIndex();
      if ( ringIndex >= rings.count() )
        rings.resize( ringIndex + 1 );
 
      QgsSymbolLayerUtils::BlankSegments &segments = rings[ringIndex];
      segments << startEndDistance;
    }
    catch ( std::invalid_argument &e )
    {
      QgsDebugError( e.what() );
      return;
    }
  }
 
  QStringList strParts;
  for ( QList<QgsSymbolLayerUtils::BlankSegments> &part : blankSegments )
  {
    QStringList strRings;
    for ( QgsSymbolLayerUtils::BlankSegments &ring : part )
    {
      std::sort( ring.begin(), ring.end() );
      QStringList strDistances;
      for ( const QPair<double, double> &distance : ring )
      {
        strDistances << ( QString::number( distance.first ) + " " + QString::number( distance.second ) );
      }
 
      strRings << "(" + strDistances.join( "," ) + ")";
    }
 
    strParts << "(" + strRings.join( "," ) + ")";
  }
 
  QString strNewBlankSegments = "(" + strParts.join( "," ) + ")";
 
  mLayer->beginEditCommand( tr( "Set blank segment list" ) );
  if ( mLayer->changeAttributeValue( mCurrentFeatureId, mBlankSegmentsFieldIndex, strNewBlankSegments ) )
  {
    mLayer->endEditCommand();
    mLayer->triggerRepaint();
  }
  else
  {
    QgsDebugError( "Fail to edit blank segments attribute" );
    mLayer->destroyEditCommand();
  }
}
 
void QgsMapToolEditBlankSegmentsBase::loadFeaturePoints()
{
  mPoints.clear();
  mExtent = canvas()->extent();
  mBlankSegments.clear();
  setCurrentBlankSegment( -1 );
 
  if ( FID_IS_NULL( mCurrentFeatureId ) || !mRenderedPointsSymbolLayer )
    return;
 
  QgsFeature feature;
  feature = mLayer->getFeature( mCurrentFeatureId );
  QString currentBlankSegments = feature.attribute( mBlankSegmentsFieldIndex ).toString();
 
 
  // render feature to update mPoints
  QgsRenderContext context = QgsRenderContext::fromMapSettings( canvas()->mapSettings() );
  QgsCoordinateTransform transform( canvas()->mapSettings().layerTransform( mLayer ) );
  QgsNullPaintDevice nullPaintDevice;
  QPainter painter( &nullPaintDevice );
  context.setPainter( &painter );
  context.setCoordinateTransform( transform );
  mSymbol->startRender( context );
  mSymbol->renderFeature( feature, context );
  mSymbol->stopRender( context );
 
  if ( mPoints.isEmpty() )
    return;
 
  QString error;
  QList<QList<QgsSymbolLayerUtils::BlankSegments>> allBlankSegments = QgsSymbolLayerUtils::parseBlankSegments( currentBlankSegments, context, mRenderedPointsSymbolLayer->blankSegmentsUnit(), error );
  if ( !error.isEmpty() )
  {
    emit messageEmitted( tr( "Error while parsing feature blank segments: %1" ).arg( error ), Qgis::MessageLevel::Critical );
    return;
  }
 
  // iterate through all points from parts and ring to get the closest one
  for ( int iPart = 0; iPart < mPoints.count(); iPart++ )
  {
    const QList<QPolygonF> &rings = mPoints.at( iPart );
    for ( int iRing = 0; iRing < rings.count(); iRing++ )
    {
      if ( iPart >= allBlankSegments.count() || iRing >= allBlankSegments.at( iPart ).count() )
        continue;
 
      const QgsSymbolLayerUtils::BlankSegments &blankSegments = allBlankSegments.at( iPart ).at( iRing );
 
      double currentLength = 0;
      int iPoint = 0;
      const QPolygonF &points = rings.at( iRing );
      for ( QPair<double, double> ba : blankSegments )
      {
        while ( iPoint < points.count() - 1 && currentLength < ba.first )
        {
          iPoint++;
          currentLength += QgsGeometryUtilsBase::distance2D( points.at( iPoint ), points.at( iPoint - 1 ) );
        }
 
        if ( iPoint == points.count() )
          break;
 
        int startIndex = iPoint;
        Line l( points.at( iPoint ), points.at( iPoint - 1 ) );
        QPointF startPt = points.at( iPoint ) + l.diffForInterval( currentLength - ba.first );
 
        while ( iPoint < points.count() - 1 && currentLength < ba.second )
        {
          iPoint++;
          currentLength += QgsGeometryUtilsBase::distance2D( points.at( iPoint ), points.at( iPoint - 1 ) );
        }
 
        if ( iPoint == points.count() )
          break;
 
        int endIndex = iPoint;
        Line l2( points.at( iPoint ), points.at( iPoint - 1 ) );
        QPointF endPt = points.at( iPoint ) + l2.diffForInterval( currentLength - ba.second );
 
        mBlankSegments.emplace_back( new QgsBlankSegmentRubberBand( iPart, iRing, startIndex, endIndex, startPt, endPt, canvas(), mPoints ) );
      }
    }
  }
}
 
QgsMapToolEditBlankSegmentsBase::QgsBlankSegmentRubberBand::QgsBlankSegmentRubberBand( QgsMapCanvas *canvas, const FeaturePoints &points )
  : QgsRubberBand( canvas )
  , mPoints( points )
{
  setHighlighted( false );
  setColor( QgsSettingsRegistryCore::settingsDigitizingLineColor->value() );
}
 
QgsMapToolEditBlankSegmentsBase::QgsBlankSegmentRubberBand::QgsBlankSegmentRubberBand(
  int partIndex, int ringIndex, int startIndex, int endIndex, QPointF startPt, QPointF endPt, QgsMapCanvas *canvas, const FeaturePoints &points
)
  : QgsBlankSegmentRubberBand( canvas, points )
{
  setPoints( partIndex, ringIndex, startIndex, endIndex, startPt, endPt );
}
 
void QgsMapToolEditBlankSegmentsBase::QgsBlankSegmentRubberBand::setPoints( int partIndex, int ringIndex, int startIndex, int endIndex, QPointF startPt, QPointF endPt )
{
  mPartIndex = partIndex;
  mRingIndex = ringIndex;
  mStartIndex = startIndex;
  mEndIndex = endIndex;
  mStartPt = startPt;
  mEndPt = endPt;
 
  mNeedSwap = false;
  if ( mStartIndex == mEndIndex )
  {
    try
    {
      if ( const QPointF &startIndexPoint = ::pointAt( mPoints, mPartIndex, mRingIndex, mStartIndex );
           QgsGeometryUtilsBase::distance2D( startPt, startIndexPoint ) < QgsGeometryUtilsBase::distance2D( endPt, startIndexPoint ) )
      {
        mNeedSwap = true;
      }
    }
    catch ( std::invalid_argument &e )
    {
      QgsDebugError( e.what() );
    }
  }
  else if ( mStartIndex > mEndIndex )
  {
    mNeedSwap = true;
  }
 
  updatePoints();
}
 
void QgsMapToolEditBlankSegmentsBase::QgsBlankSegmentRubberBand::updatePoints()
{
  const QgsMapToPixel &m2p = *( mMapCanvas->getCoordinateTransform() );
 
  reset();
  for ( int iPoint = 0; iPoint < pointsCount(); iPoint++ )
  {
    try
    {
      const QPointF &point = pointAt( iPoint );
      const QgsPointXY mapPoint = m2p.toMapCoordinates( point.x(), point.y() );
      addPoint( mapPoint, iPoint == pointsCount() - 1 ); // update only last one
    }
    catch ( std::invalid_argument &e )
    {
      QgsDebugError( e.what() );
    }
  }
}
 
 
void QgsMapToolEditBlankSegmentsBase::QgsBlankSegmentRubberBand::copyFrom( const QgsBlankSegmentRubberBand &blankSegment )
{
  setPoints( blankSegment.mPartIndex, blankSegment.mRingIndex, blankSegment.getStartIndex(), blankSegment.getEndIndex(), blankSegment.getStartPoint(), blankSegment.getEndPoint() );
}
 
void QgsMapToolEditBlankSegmentsBase::QgsBlankSegmentRubberBand::setHighlighted( bool highlighted )
{
  setWidth( QgsGuiUtils::scaleIconSize( highlighted ? 4 : 2 ) );
  update();
}
 
 
const QPointF &QgsMapToolEditBlankSegmentsBase::QgsBlankSegmentRubberBand::getStartPoint() const
{
  return mStartPt;
}
 
const QPointF &QgsMapToolEditBlankSegmentsBase::QgsBlankSegmentRubberBand::getEndPoint() const
{
  return mEndPt;
}
 
int QgsMapToolEditBlankSegmentsBase::QgsBlankSegmentRubberBand::getStartIndex() const
{
  return mStartIndex;
}
 
int QgsMapToolEditBlankSegmentsBase::QgsBlankSegmentRubberBand::getEndIndex() const
{
  return mEndIndex;
}
 
int QgsMapToolEditBlankSegmentsBase::QgsBlankSegmentRubberBand::getPartIndex() const
{
  return mPartIndex;
}
 
int QgsMapToolEditBlankSegmentsBase::QgsBlankSegmentRubberBand::getRingIndex() const
{
  return mRingIndex;
}
 
int QgsMapToolEditBlankSegmentsBase::QgsBlankSegmentRubberBand::pointsCount() const
{
  return std::abs( mEndIndex - mStartIndex ) + 2;
}
 
const QPointF &QgsMapToolEditBlankSegmentsBase::QgsBlankSegmentRubberBand::pointAt( int index ) const
{
  return index == 0 ?
                    // first point
           ( mNeedSwap ? mEndPt : mStartPt )
                    // last point
                    : ( index == pointsCount() - 1 ? ( mNeedSwap ? mStartPt : mEndPt )
                                                   // point in between
                                                   : ::pointAt( mPoints, mPartIndex, mRingIndex, ( mNeedSwap ? mEndIndex : mStartIndex ) + index - 1 ) );
}