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 "qgsmeshdataprovider.h"
 
#include <QSet>
 
#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