qgstopologicalmesh.h

Go to the documentation of this file.

/***************************************************************************
  qgstopologicalmesh.h - QgsTopologicalMesh
 
 ---------------------
 begin                : 18.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 QGSTOPOLOGICALMESH_H
#define QGSTOPOLOGICALMESH_H
 
#include <QSet>
 
#include "qgsmeshdataprovider.h"
 
#if defined(_MSC_VER)
template CORE_EXPORT QVector<int> SIP_SKIP;
template CORE_EXPORT QList<int> SIP_SKIP;
template CORE_EXPORT QVector<QVector<int>> SIP_SKIP;
#endif
 
class QgsMeshEditingError;
class QgsMeshVertexCirculator;
 
class CORE_EXPORT QgsTopologicalMesh
{
  public:
 
    using FaceNeighbors = QVector<int>;
 
    class CORE_EXPORT TopologicalFaces
    {
      public:
 
        SIP_SKIP QVector<QgsMeshFace>  meshFaces() const {return mFaces;}
 
        void clear();
 
        SIP_SKIP QVector<FaceNeighbors> facesNeighborhood() const;
 
        int vertexToFace( int vertexIndex ) const;
 
      private:
        QVector<QgsMeshFace> mFaces; // the faces containing the vertices indexes in the mesh
        QVector<FaceNeighbors> mFacesNeighborhood; // neighborhood of the faces, face indexes are local
        QMultiHash<int, int> mVerticesToFace; // map of vertices to incident face, face indexes are local
        QList<int> mBoundaries; // list of boundary vertices indexes in the mesh
 
        friend class QgsTopologicalMesh;
        friend class QgsMeshVertexCirculator;
    };
 
 
    class CORE_EXPORT Changes
    {
      public:
 
        SIP_SKIP QVector<QgsMeshFace> addedFaces() const;
 
        SIP_SKIP QVector<QgsMeshFace> removedFaces() const;
 
        QList<int> removedFaceIndexes() const;
 
#ifndef SIP_RUN
        QVector<QgsMeshVertex> addedVertices() const;
#else
        QVector<QgsPoint> addedVertices() const;
#endif
 
        QList<int> verticesToRemoveIndexes() const;
 
        QList<int> changedCoordinatesVerticesIndexes() const;
 
        QList<double> newVerticesZValues() const;
 
        QList<QgsPointXY> newVerticesXYValues() const;
 
        QList<QgsPointXY> oldVerticesXYValues() const;
 
        QList<int> nativeFacesIndexesGeometryChanged() const;
 
        bool isEmpty() const;
 
      protected:
        int mAddedFacesFirstIndex = 0;
        QList<int> mFaceIndexesToRemove; // the removed faces indexes in the mesh
        QVector<QgsMeshFace> mFacesToAdd;
        QVector<FaceNeighbors> mFacesNeighborhoodToAdd;
        QVector<QgsMeshFace> mFacesToRemove;
        QVector<FaceNeighbors> mFacesNeighborhoodToRemove;
        QList<std::array<int, 4>> mNeighborhoodChanges; // {index of concerned face, neighbor position, previous value, changed value}
 
        QVector<QgsMeshVertex> mVerticesToAdd;
        QVector<int> mVertexToFaceToAdd;
        QList<int> mVerticesToRemoveIndexes;
        QList<QgsMeshVertex> mRemovedVertices;
        QList<int> mVerticesToFaceRemoved;
        QList<std::array<int, 3>> mVerticesToFaceChanges; // {index of concerned vertex, previous value, changed value}
 
        QList<int> mChangeCoordinateVerticesIndexes;
        QList<double> mNewZValues;
        QList<double> mOldZValues;
        QList<QgsPointXY> mNewXYValues;
        QList<QgsPointXY> mOldXYValues;
        QList<int> mNativeFacesIndexesGeometryChanged;
 
        void clearChanges();
 
      private:
        int addedFaceIndexInMesh( int internalIndex ) const;
        int removedFaceIndexInMesh( int internalIndex ) const;
 
        friend class QgsTopologicalMesh;
    };
 
    static QgsTopologicalMesh createTopologicalMesh( QgsMesh *mesh, int maxVerticesPerFace, QgsMeshEditingError &error );
 
    SIP_SKIP static TopologicalFaces createNewTopologicalFaces( const QVector<QgsMeshFace> &faces, bool uniqueSharedVertexAllowed, QgsMeshEditingError &error );
 
    //----------- access element methods
 
    QVector<int> neighborsOfFace( int faceIndex ) const;
 
    QList<int> facesAroundVertex( int vertexIndex ) const;
 
    QgsMesh *mesh() const;
 
    int firstFaceLinked( int vertexIndex ) const;
 
    bool isVertexOnBoundary( int vertexIndex ) const;
 
    bool isVertexFree( int vertexIndex ) const;
 
    QList<int> freeVerticesIndexes() const;
 
    SIP_SKIP QgsMeshVertexCirculator vertexCirculator( int vertexIndex ) const;
 
    //----------- editing methods
 
    QgsMeshEditingError facesCanBeAdded( const TopologicalFaces &topologicalFaces ) const;
 
    Changes addFaces( const TopologicalFaces &topologicFaces );
 
    QgsMeshEditingError facesCanBeRemoved( const QList<int> &facesIndexes );
 
    Changes removeFaces( const QList<int> &facesIndexes );
 
    bool edgeCanBeFlipped( int vertexIndex1, int vertexIndex2 ) const;
 
    Changes flipEdge( int vertexIndex1, int vertexIndex2 );
 
    bool delaunayConditionForEdge( int vertexIndex1, int vertexIndex2 );
 
    bool canBeMerged( int vertexIndex1, int vertexIndex2 ) const;
 
    Changes merge( int vertexIndex1, int vertexIndex2 );
 
    bool canBeSplit( int faceIndex ) const;
 
    Changes splitFace( int faceIndex );
 
    Changes addVertexInFace( int faceIndex, const QgsMeshVertex &vertex );
 
    Changes insertVertexInFacesEdge( int faceIndex, int position, const QgsMeshVertex &vertex );
 
    Changes addFreeVertex( const QgsMeshVertex &vertex );
 
    Changes removeVertexFillHole( int vertexIndex );
 
    Changes removeVertices( const QList<int> &vertices );
 
    Changes changeZValue( const QList<int> &verticesIndexes, const QList<double> &newValues );
 
    Changes changeXYValue( const QList<int> &verticesIndexes, const QList<QgsPointXY> &newValues );
 
 
    void applyChanges( const Changes &changes );
 
    void reverseChanges( const Changes &changes );
 
    static QgsMeshEditingError counterClockwiseFaces( QgsMeshFace &face, QgsMesh *mesh );
 
    SIP_SKIP static QgsMeshEditingError checkTopologyOfVerticesAsFace( const QVector<QgsMeshVertex> &vertices, bool &clockwise );
 
    void reindex();
 
    bool renumber();
 
    QgsMeshEditingError checkConsistency() const;
 
    static QgsMeshEditingError checkTopology( const QgsMesh &mesh, int maxVerticesPerFace );
 
    static inline int vertexPositionInFace( int vertexIndex, const QgsMeshFace &face )
    {
      return face.indexOf( vertexIndex );
    }
 
    static int vertexPositionInFace( const QgsMesh &mesh, int vertexIndex, int faceIndex );
 
  private:
 
    static TopologicalFaces  createTopologicalFaces(
      const QVector<QgsMeshFace> &faces,
      QVector<int> *globalVertexToFace,
      QgsMeshEditingError &error,
      bool allowUniqueSharedVertex );
 
    QSet<int> concernedFacesBy( const QList<int> &faceIndexes ) const;
 
    void referenceAsFreeVertex( int vertexIndex );
    void dereferenceAsFreeVertex( int vertexIndex );
 
    bool eitherSideFacesAndVertices( int vertexIndex1,
                                     int vertexIndex2,
                                     int &face1,
                                     int &face2,
                                     int &neighborVertex1InFace1,
                                     int &neighborVertex1InFace2,
                                     int &neighborVertex2inFace1,
                                     int &neighborVertex2inFace2 ) const;
 
    bool renumberVertices( QVector<int> &oldToNewIndex ) const;
    bool renumberFaces( QVector<int> &oldToNewIndex ) const;
 
    //Attributes
    QgsMesh *mMesh = nullptr;
    QVector<int> mVertexToFace;
    QVector<FaceNeighbors> mFacesNeighborhood;
 
    QSet<int> mFreeVertices;
 
    int mMaximumVerticesPerFace = 0;
 
    friend class QgsMeshVertexCirculator;
 
};
 
#ifndef SIP_RUN
 
class CORE_EXPORT QgsMeshVertexCirculator
{
  public:
 
    QgsMeshVertexCirculator( const QgsTopologicalMesh &topologicalMesh, int vertexIndex );
 
    QgsMeshVertexCirculator( const QgsTopologicalMesh::TopologicalFaces &topologicalFaces, int faceIndex, int vertexIndex );
 
    QgsMeshVertexCirculator( const QgsTopologicalMesh::TopologicalFaces &topologicalFaces, int vertexIndex );
 
    int turnCounterClockwise() const;
 
    int turnClockwise() const;
 
    int currentFaceIndex() const;
 
    QgsMeshFace currentFace() const;
 
    bool goBoundaryClockwise() const;
 
    bool goBoundaryCounterClockwise() const;
 
    int oppositeVertexClockwise() const;
 
    int oppositeVertexCounterClockwise() const;
 
    bool isValid() const;
 
    QList<int> facesAround() const;
 
    int degree() const;
 
  private:
    const QVector<QgsMeshFace> mFaces;
    const QVector<QgsTopologicalMesh::FaceNeighbors> mFacesNeighborhood;
    const int mVertexIndex = -1;
    mutable int mCurrentFace = -1;
    mutable int mLastValidFace = -1;
    bool mIsValid = false;
    mutable int mDegree = -1;
 
    int positionInCurrentFace() const;
};
#endif
 
#endif // QGSTOPOLOGICALMESH_H