qgsmesheditor.h

Go to the documentation of this file.

/***************************************************************************
  qgsmesheditor.h - QgsMeshEditor
 
 ---------------------
 begin                : 8.6.2021
 copyright            : (C) 2021 by Vincent Cloarec
 email                : vcloarec 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.                                   *
 *                                                                         *
 ***************************************************************************/
#ifndef QGSMESHEDITOR_H
#define QGSMESHEDITOR_H
 
#include "qgis.h"
#include "qgsmeshdataprovider.h"
#include "qgsmeshdataset.h"
#include "qgstopologicalmesh.h"
#include "qgstriangularmesh.h"
 
#include <QObject>
#include <QPointer>
#include <QUndoCommand>
 
class QgsMeshAdvancedEditing;
 
#if defined( _MSC_VER )
template CORE_EXPORT QVector<QVector<int>> SIP_SKIP;
#endif

class CORE_EXPORT QgsMeshEditingError
{
  public:
    QgsMeshEditingError();

    QgsMeshEditingError( Qgis::MeshEditingErrorType type, int elementIndex );
 
    Qgis::MeshEditingErrorType errorType = Qgis::MeshEditingErrorType::NoError;
 
    int elementIndex = -1;
 
    bool operator==( const QgsMeshEditingError &other ) const { return ( other.errorType == errorType && other.elementIndex == elementIndex ); }
    bool operator!=( const QgsMeshEditingError &other ) const { return !operator==( other ); }
};

class CORE_EXPORT QgsMeshEditor : public QObject
{
    Q_OBJECT
  public:
    QgsMeshEditor( QgsMeshLayer *meshLayer );

    QgsMeshEditor( QgsMesh *nativeMesh, QgsTriangularMesh *triangularMesh, QObject *parent = nullptr ) SIP_SKIP;
    ~QgsMeshEditor() override;

    std::unique_ptr< QgsMeshDatasetGroup > createZValueDatasetGroup();

    QgsMeshEditingError initialize();

    QgsMeshEditingError initializeWithErrorsFix();

    bool fixError( const QgsMeshEditingError &error );

    void resetTriangularMesh( QgsTriangularMesh *triangularMesh ) SIP_SKIP;

    bool faceCanBeAdded( const QgsMeshFace &face ) const;

    bool faceCanBeAddedWithNewVertices( const QList<int> &verticesIndex, const QList<QgsMeshVertex> &newVertices ) const SIP_SKIP;

    bool isFaceGeometricallyCompatible( const QgsMeshFace &face ) const;

    QgsMeshEditingError addFaces( const QVector<QgsMeshFace> &faces ) SIP_SKIP;

    QgsMeshEditingError addFace( const QVector<int> &vertexIndexes );

    QgsMeshEditingError addFaceWithNewVertices( const QList<int> &vertexIndexes, const QList<QgsMeshVertex> &newVertices ) SIP_SKIP;

    QgsMeshEditingError removeFaces( const QList<int> &facesToRemove );

    bool edgeCanBeFlipped( int vertexIndex1, int vertexIndex2 ) const;

    void flipEdge( int vertexIndex1, int vertexIndex2 );

    bool canBeMerged( int vertexIndex1, int vertexIndex2 ) const;

    void merge( int vertexIndex1, int vertexIndex2 );

    bool faceCanBeSplit( int faceIndex ) const;

    int splitFaces( const QList<int> &faceIndexes );

    int addVertices( const QVector<QgsMeshVertex> &vertices, double tolerance ) SIP_SKIP;

    int addPointsAsVertices( const QVector<QgsPoint> &point, double tolerance );

    QgsMeshEditingError removeVerticesWithoutFillHoles( const QList<int> &verticesToRemoveIndexes );

    QList<int> removeVerticesFillHoles( const QList<int> &verticesToRemoveIndexes );

    void changeZValues( const QList<int> &verticesIndexes, const QList<double> &newValues );

    bool canBeTransformed( const QList<int> &facesToCheck, const std::function<const QgsMeshVertex( int )> &transformFunction ) const SIP_SKIP;

    void changeXYValues( const QList<int> &verticesIndexes, const QList<QgsPointXY> &newValues );

    void changeCoordinates( const QList<int> &verticesIndexes, const QList<QgsPoint> &newCoordinates );

    void advancedEdit( QgsMeshAdvancedEditing *editing );

    void stopEditing();

    QgsRectangle extent() const;

    bool isModified() const;

    bool reindex( bool renumbering );
 
    //----------- access element methods

    QList<int> freeVerticesIndexes() const;

    bool isVertexOnBoundary( int vertexIndex ) const;

    bool isVertexFree( int vertexIndex ) const;

    QgsMeshVertexCirculator vertexCirculator( int vertexIndex ) const SIP_SKIP;

    QgsTopologicalMesh &topologicalMesh() SIP_SKIP;

    QgsTriangularMesh *triangularMesh() SIP_SKIP;

    bool checkConsistency( QgsMeshEditingError &error ) const;

    bool edgeIsClose( QgsPointXY point, double tolerance, int &faceIndex, int &edgePosition );

    int validFacesCount() const;

    int validVerticesCount() const;

    int maximumVerticesPerFace() const;

    void addVertexWithDelaunayRefinement( const QgsMeshVertex &vertex, const double tolerance );
 
  signals:
    void meshEdited();
 
  private:
    QgsMesh *mMesh = nullptr;
    QgsTopologicalMesh mTopologicalMesh;
    QgsTriangularMesh *mTriangularMesh = nullptr;
    int mMaximumVerticesPerFace = 0;
    int mValidVerticesCount = 0;
    int mValidFacesCount = 0;
 
    QVector<QgsMeshFace> prepareFaces( const QVector<QgsMeshFace> &faces, QgsMeshEditingError &error ) const;
    QList<int> prepareFaceWithNewVertices( const QList<int> &vertices, const QList<QgsMeshVertex> &newVertices, QgsMeshEditingError &error ) const;
    bool isFaceGeometricallyCompatible( const QList<int> &vertexIndex, const QList<QgsMeshVertex> &vertices ) const;

    QUndoStack *mUndoStack = nullptr;
 
    struct Edit
    {
        QgsTopologicalMesh::Changes topologicalChanges;
        QgsTriangularMesh::Changes triangularMeshChanges;
    };
    void applyEdit( Edit &edit );
    void reverseEdit( Edit &edit );
 
    void applyAddVertex( Edit &edit, const QgsMeshVertex &vertex, double tolerance );
    bool applyRemoveVertexFillHole( Edit &edit, int vertexIndex );
    void applyRemoveVerticesWithoutFillHole( QgsMeshEditor::Edit &edit, const QList<int> &verticesIndexes );
    void applyAddFaces( Edit &edit, const QgsTopologicalMesh::TopologicalFaces &faces );
    void applyRemoveFaces( Edit &edit, const QList<int> &faceToRemoveIndex );
    void applyChangeZValue( Edit &edit, const QList<int> &verticesIndexes, const QList<double> &newValues );
    void applyChangeXYValue( Edit &edit, const QList<int> &verticesIndexes, const QList<QgsPointXY> &newValues );
    void applyFlipEdge( Edit &edit, int vertexIndex1, int vertexIndex2 );
    void applyMerge( Edit &edit, int vertexIndex1, int vertexIndex2 );
    void applySplit( QgsMeshEditor::Edit &edit, int faceIndex );
    void applyAdvancedEdit( Edit &edit, QgsMeshAdvancedEditing *editing );
 
    void applyEditOnTriangularMesh( Edit &edit, const QgsTopologicalMesh::Changes &topologicChanges );
 
    void updateElementsCount( const QgsTopologicalMesh::Changes &changes, bool apply = true );
 
    friend class TestQgsMeshEditor;
    friend class QgsMeshLayerUndoCommandMeshEdit;
    friend class QgsMeshLayerUndoCommandAddVertices;
    friend class QgsMeshLayerUndoCommandRemoveVerticesWithoutFillHoles;
    friend class QgsMeshLayerUndoCommandRemoveVerticesFillHoles;
    friend class QgsMeshLayerUndoCommandAddFaces;
    friend class QgsMeshLayerUndoCommandRemoveFaces;
    friend class QgsMeshLayerUndoCommandSetZValue;
    friend class QgsMeshLayerUndoCommandChangeZValue;
    friend class QgsMeshLayerUndoCommandChangeXYValue;
    friend class QgsMeshLayerUndoCommandChangeCoordinates;
    friend class QgsMeshLayerUndoCommandFlipEdge;
    friend class QgsMeshLayerUndoCommandMerge;
    friend class QgsMeshLayerUndoCommandSplitFaces;
    friend class QgsMeshLayerUndoCommandAddVertexInFaceWithDelaunayRefinement;
 
    friend class QgsMeshLayerUndoCommandAdvancedEditing;
};
 
#ifndef SIP_RUN

class QgsMeshLayerUndoCommandMeshEdit : public QUndoCommand
{
  public:
    void undo() override;
    void redo() override;
 
  protected:
    QgsMeshLayerUndoCommandMeshEdit( QgsMeshEditor *meshEditor );
    QPointer<QgsMeshEditor> mMeshEditor;
    QList<QgsMeshEditor::Edit> mEdits;
};

class QgsMeshLayerUndoCommandAddVertices : public QgsMeshLayerUndoCommandMeshEdit
{
  public:
    QgsMeshLayerUndoCommandAddVertices( QgsMeshEditor *meshEditor, const QVector<QgsMeshVertex> &vertices, double tolerance );
    void redo() override;
 
  private:
    QVector<QgsMeshVertex> mVertices;
    double mTolerance = 0;
};

class QgsMeshLayerUndoCommandRemoveVerticesWithoutFillHoles : public QgsMeshLayerUndoCommandMeshEdit
{
  public:
    QgsMeshLayerUndoCommandRemoveVerticesWithoutFillHoles( QgsMeshEditor *meshEditor, const QList<int> &verticesToRemoveIndexes );
    void redo() override;
 
  private:
    QList<int> mVerticesToRemoveIndexes;
};

class QgsMeshLayerUndoCommandRemoveVerticesFillHoles : public QgsMeshLayerUndoCommandMeshEdit
{
  public:
    QgsMeshLayerUndoCommandRemoveVerticesFillHoles( QgsMeshEditor *meshEditor, const QList<int> &verticesToRemoveIndexes, QList<int> *remainingVerticesPointer = nullptr );
    void redo() override;
 
  private:
    QList<int> mVerticesToRemoveIndexes;
    QList<int> *mRemainingVerticesPointer = nullptr;
};

class QgsMeshLayerUndoCommandAddFaces : public QgsMeshLayerUndoCommandMeshEdit
{
  public:
    QgsMeshLayerUndoCommandAddFaces( QgsMeshEditor *meshEditor, QgsTopologicalMesh::TopologicalFaces &faces );
 
    void redo() override;
 
  private:
    QgsTopologicalMesh::TopologicalFaces mFaces;
};

class QgsMeshLayerUndoCommandRemoveFaces : public QgsMeshLayerUndoCommandMeshEdit
{
  public:
    QgsMeshLayerUndoCommandRemoveFaces( QgsMeshEditor *meshEditor, const QList<int> &facesToRemoveIndexes );
 
    void redo() override;
 
  private:
    QList<int> mfacesToRemoveIndexes;
};

class QgsMeshLayerUndoCommandChangeZValue : public QgsMeshLayerUndoCommandMeshEdit
{
  public:
    QgsMeshLayerUndoCommandChangeZValue( QgsMeshEditor *meshEditor, const QList<int> &verticesIndexes, const QList<double> &newValues );
    void redo() override;
 
  private:
    QList<int> mVerticesIndexes;
    QList<double> mNewValues;
};

class QgsMeshLayerUndoCommandChangeXYValue : public QgsMeshLayerUndoCommandMeshEdit
{
  public:
    QgsMeshLayerUndoCommandChangeXYValue( QgsMeshEditor *meshEditor, const QList<int> &verticesIndexes, const QList<QgsPointXY> &newValues );
    void redo() override;
 
  private:
    QList<int> mVerticesIndexes;
    QList<QgsPointXY> mNewValues;
};

class QgsMeshLayerUndoCommandChangeCoordinates : public QgsMeshLayerUndoCommandMeshEdit
{
  public:
    QgsMeshLayerUndoCommandChangeCoordinates( QgsMeshEditor *meshEditor, const QList<int> &verticesIndexes, const QList<QgsPoint> &newCoordinates );
    void redo() override;
 
  private:
    QList<int> mVerticesIndexes;
    QList<QgsPoint> mNewCoordinates;
};

class QgsMeshLayerUndoCommandFlipEdge : public QgsMeshLayerUndoCommandMeshEdit
{
  public:
    QgsMeshLayerUndoCommandFlipEdge( QgsMeshEditor *meshEditor, int vertexIndex1, int vertexIndex2 );
    void redo() override;
 
  private:
    int mVertexIndex1 = -1;
    int mVertexIndex2 = -1;
};

class QgsMeshLayerUndoCommandMerge : public QgsMeshLayerUndoCommandMeshEdit
{
  public:
    QgsMeshLayerUndoCommandMerge( QgsMeshEditor *meshEditor, int vertexIndex1, int vertexIndex2 );
    void redo() override;
 
  private:
    int mVertexIndex1 = -1;
    int mVertexIndex2 = -1;
};

class QgsMeshLayerUndoCommandSplitFaces : public QgsMeshLayerUndoCommandMeshEdit
{
  public:
    QgsMeshLayerUndoCommandSplitFaces( QgsMeshEditor *meshEditor, const QList<int> &faceIndexes );
    void redo() override;
 
  private:
    QList<int> mFaceIndexes;
};
 

class QgsMeshLayerUndoCommandAdvancedEditing : public QgsMeshLayerUndoCommandMeshEdit
{
  public:
    QgsMeshLayerUndoCommandAdvancedEditing( QgsMeshEditor *meshEditor, QgsMeshAdvancedEditing *advancdEdit );
    void redo() override;
 
  private:
    QgsMeshAdvancedEditing *mAdvancedEditing = nullptr;
};
 

class QgsMeshLayerUndoCommandAddVertexInFaceWithDelaunayRefinement : public QgsMeshLayerUndoCommandMeshEdit
{
  public:
    QgsMeshLayerUndoCommandAddVertexInFaceWithDelaunayRefinement( QgsMeshEditor *meshEditor, const QgsMeshVertex &vertex, double tolerance );
 
    void redo() override;
 
  private:
    QList<std::pair<int, int>> innerEdges( const QSet<int> &faces );
    QSet<int> secondNeighboringTriangularFaces();
 
    QgsMeshVertex mVertex;
    double mTolerance;
};
 
#endif //SIP_RUN
 
#endif // QGSMESHEDITOR_H