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 <QObject>
#include <QUndoCommand>
#include <QPointer>
 
#include "qgis.h"
#include "qgsmeshdataset.h"
#include "qgsmeshdataprovider.h"
#include "qgstriangularmesh.h"
#include "qgstopologicalmesh.h"
 
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();
 
    QgsMeshDatasetGroup *createZValueDatasetGroup() SIP_TRANSFERBACK;
 
    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;
    QgsMeshDatasetGroup *mZValueDatasetGroup = nullptr;
    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