qgsgeometrycheckerutils.h

Go to the documentation of this file.

/***************************************************************************
 *  qgsgeometrycheckerutils.h                                              *
 *  -------------------                                                    *
 *  copyright            : (C) 2014 by Sandro Mani / Sourcepole AG         *
 *  email                : [email protected]                             *
 ***************************************************************************/
 
/***************************************************************************
 *                                                                         *
 *   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 QGS_GEOMETRYCHECKERUTILS_H
#define QGS_GEOMETRYCHECKERUTILS_H
 
#include "qgis_analysis.h"
#include "qgsfeature.h"
#include "geometry/qgsabstractgeometry.h"
#include "geometry/qgspoint.h"
#include "qgsgeometrycheckcontext.h"
#include <qmath.h>
 
class QgsGeometryEngine;
class QgsFeaturePool;
class QgsFeedback;
 
class ANALYSIS_EXPORT QgsGeometryCheckerUtils
{
  public:
 
    class ANALYSIS_EXPORT LayerFeature
    {
      public:
 
        LayerFeature( const QgsFeaturePool *pool, const QgsFeature &feature, const QgsGeometryCheckContext *context, bool useMapCrs );
 
        QgsFeature feature() const;
 
        QPointer<QgsVectorLayer> layer() const SIP_SKIP;
 
        QString layerId() const;
 
        QgsGeometry geometry() const;
 
        QString id() const;
        bool operator==( const QgsGeometryCheckerUtils::LayerFeature &other ) const;
        bool operator!=( const QgsGeometryCheckerUtils::LayerFeature &other ) const;
 
        bool useMapCrs() const;
 
      private:
        const QgsFeaturePool *mFeaturePool;
        QgsFeature mFeature;
        QgsGeometry mGeometry;
        bool mMapCrs;
    };
 
    class ANALYSIS_EXPORT LayerFeatures
    {
      public:
#ifndef SIP_RUN
 
        LayerFeatures( const QMap<QString, QgsFeaturePool *> &featurePools,
                       const QMap<QString, QgsFeatureIds> &featureIds,
                       const QList<QgsWkbTypes::GeometryType> &geometryTypes,
                       QgsFeedback *feedback,
                       const QgsGeometryCheckContext *context,
                       bool useMapCrs = false );
 
        LayerFeatures( const QMap<QString, QgsFeaturePool *> &featurePools,
                       const QList<QString> &layerIds, const QgsRectangle &extent,
                       const QList<QgsWkbTypes::GeometryType> &geometryTypes,
                       const QgsGeometryCheckContext *context );
 
        class iterator
        {
          public:
 
            iterator( const QStringList::const_iterator &layerIt, const LayerFeatures *parent );
 
            iterator( const iterator &rh );
            ~iterator();
 
            const iterator &operator++();
 
            iterator operator++( int n );
 
            const QgsGeometryCheckerUtils::LayerFeature &operator*() const;
            bool operator!=( const iterator &other );
 
          private:
            bool nextLayerFeature( bool begin );
            bool nextLayer( bool begin );
            bool nextFeature( bool begin );
            QList<QString>::const_iterator mLayerIt;
            QgsFeatureIds::const_iterator mFeatureIt;
            const LayerFeatures *mParent = nullptr;
            std::unique_ptr<QgsGeometryCheckerUtils::LayerFeature> mCurrentFeature;
 
            iterator &operator= ( const iterator & ) = delete;
        };
 
        iterator begin() const;
 
        iterator end() const;
 
#endif
 
      private:
#ifdef SIP_RUN
        LayerFeatures();
#endif
        QMap<QString, QgsFeaturePool *> mFeaturePools;
        QMap<QString, QgsFeatureIds> mFeatureIds;
        QList<QString> mLayerIds;
        QgsRectangle mExtent;
        QList<QgsWkbTypes::GeometryType> mGeometryTypes;
        QgsFeedback *mFeedback = nullptr;
        const QgsGeometryCheckContext *mContext = nullptr;
        bool mUseMapCrs = true;
    };
 
#ifndef SIP_RUN
 
    static std::unique_ptr<QgsGeometryEngine> createGeomEngine( const QgsAbstractGeometry *geometry, double tolerance );
 
    static QgsAbstractGeometry *getGeomPart( QgsAbstractGeometry *geom, int partIdx );
    static const QgsAbstractGeometry *getGeomPart( const QgsAbstractGeometry *geom, int partIdx );
 
    static QList <const QgsLineString *> polygonRings( const QgsPolygon *polygon );
 
    static void filter1DTypes( QgsAbstractGeometry *geom );
 
    static inline int polyLineSize( const QgsAbstractGeometry *geom, int iPart, int iRing, bool *isClosed = nullptr )
    {
      if ( !geom->isEmpty() )
      {
        const int nVerts = geom->vertexCount( iPart, iRing );
        const QgsPoint front = geom->vertexAt( QgsVertexId( iPart, iRing, 0 ) );
        const QgsPoint back = geom->vertexAt( QgsVertexId( iPart, iRing, nVerts - 1 ) );
        const bool closed = back == front;
        if ( isClosed )
          *isClosed = closed;
        return closed ? nVerts - 1 : nVerts;
      }
      else
      {
        if ( isClosed )
          *isClosed = true;
        return 0;
      }
    }
 
    static bool pointOnLine( const QgsPoint &p, const QgsLineString *line, double tol, bool excludeExtremities = false );
 
    static QList<QgsPoint> lineIntersections( const QgsLineString *line1, const QgsLineString *line2, double tol );
 
    static double sharedEdgeLength( const QgsAbstractGeometry *geom1, const QgsAbstractGeometry *geom2, double tol );
 
    static inline bool pointsFuzzyEqual( const QgsPointXY &p1, const QgsPointXY &p2, double tol )
    {
      double dx = p1.x() - p2.x(), dy = p1.y() - p2.y();
      return ( dx * dx + dy * dy ) < tol * tol;
    }
 
    static inline bool canDeleteVertex( const QgsAbstractGeometry *geom, int iPart, int iRing )
    {
      const int nVerts = geom->vertexCount( iPart, iRing );
      const QgsPoint front = geom->vertexAt( QgsVertexId( iPart, iRing, 0 ) );
      const QgsPoint back = geom->vertexAt( QgsVertexId( iPart, iRing, nVerts - 1 ) );
      const bool closed = back == front;
      return closed ? nVerts > 4 : nVerts > 2;
    }
 
#endif
 
}; // QgsGeometryCheckerUtils
 
#endif // QGS_GEOMETRYCHECKERUTILS_H