qgsgeometry.h

Go to the documentation of this file.

/***************************************************************************
  qgsgeometry.h - Geometry (stored as Open Geospatial Consortium WKB)
  -------------------------------------------------------------------
Date                 : 02 May 2005
Copyright            : (C) 2005 by Brendan Morley
email                : morb at ozemail dot com dot au
 ***************************************************************************
 *                                                                         *
 *   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 QGSGEOMETRY_H
#define QGSGEOMETRY_H

#include <QString>
#include <QVector>
#include <QDomDocument>

#include "qgis.h"

#include <geos_c.h>
#include <climits>

#if defined(GEOS_VERSION_MAJOR) && (GEOS_VERSION_MAJOR<3)
#define GEOSGeometry struct GEOSGeom_t
#define GEOSCoordSequence struct GEOSCoordSeq_t
#endif

#include "qgsabstractgeometryv2.h"
#include "qgspoint.h"
#include "qgscoordinatetransform.h"
#include "qgsfeature.h"
#include <limits>
#include <QSet>

class QgsGeometryEngine;
class QgsVectorLayer;
class QgsMapToPixel;
class QPainter;
class QgsPolygonV2;

typedef QVector<QgsPoint> QgsPolyline;

typedef QVector<QgsPolyline> QgsPolygon;

typedef QVector<QgsPoint> QgsMultiPoint;

typedef QVector<QgsPolyline> QgsMultiPolyline;

typedef QVector<QgsPolygon> QgsMultiPolygon;

class QgsRectangle;

class QgsConstWkbPtr;

struct QgsGeometryPrivate;

class CORE_EXPORT QgsGeometry
{
  public:
    QgsGeometry();

    QgsGeometry( const QgsGeometry & );

    QgsGeometry & operator=( QgsGeometry const & rhs );

    explicit QgsGeometry( QgsAbstractGeometryV2* geom );

    ~QgsGeometry();

    QgsAbstractGeometryV2* geometry() const;

    void setGeometry( QgsAbstractGeometryV2* geometry );

    bool isEmpty() const;

    static QgsGeometry* fromWkt( const QString& wkt );
    static QgsGeometry* fromPoint( const QgsPoint& point );
    static QgsGeometry* fromMultiPoint( const QgsMultiPoint& multipoint );
    static QgsGeometry* fromPolyline( const QgsPolyline& polyline );
    static QgsGeometry* fromMultiPolyline( const QgsMultiPolyline& multiline );
    static QgsGeometry* fromPolygon( const QgsPolygon& polygon );
    static QgsGeometry* fromMultiPolygon( const QgsMultiPolygon& multipoly );
    static QgsGeometry* fromRect( const QgsRectangle& rect );

    void fromGeos( GEOSGeometry* geos );

    void fromWkb( unsigned char *wkb, int length );

    const unsigned char* asWkb() const;

    int wkbSize() const;

    const GEOSGeometry* asGeos( double precision = 0 ) const;

    QGis::WkbType wkbType() const;

    QGis::GeometryType type() const;

    bool isMultipart() const;

    bool isGeosEqual( const QgsGeometry& ) const;

    bool isGeosValid() const;

    bool isGeosEmpty() const;

    double area() const;

    double length() const;

    double distance( const QgsGeometry& geom ) const;

    //TODO QGIS 3.0 - rename beforeVertex to previousVertex, afterVertex to nextVertex
    QgsPoint closestVertex( const QgsPoint& point, int& atVertex, int& beforeVertex, int& afterVertex, double& sqrDist ) const;

    double distanceToVertex( int vertex ) const;

    double angleAtVertex( int vertex ) const;

    void adjacentVertices( int atVertex, int& beforeVertex, int& afterVertex ) const;

    bool insertVertex( double x, double y, int beforeVertex );

    bool moveVertex( double x, double y, int atVertex );

    bool moveVertex( const QgsPointV2& p, int atVertex );

    bool deleteVertex( int atVertex );

    QgsPoint vertexAt( int atVertex ) const;

    double sqrDistToVertexAt( QgsPoint& point, int atVertex ) const;

    QgsGeometry nearestPoint( const QgsGeometry& other ) const;

    QgsGeometry shortestLine( const QgsGeometry& other ) const;

    double closestVertexWithContext( const QgsPoint& point, int& atVertex ) const;

    double closestSegmentWithContext( const QgsPoint& point, QgsPoint& minDistPoint, int& afterVertex, double* leftOf = nullptr, double epsilon = DEFAULT_SEGMENT_EPSILON ) const;

    // TODO QGIS 3.0 returns an enum instead of a magic constant
    int addRing( const QList<QgsPoint>& ring );

    // TODO QGIS 3.0 returns an enum instead of a magic constant
    int addRing( QgsCurveV2* ring );

    // TODO QGIS 3.0 returns an enum instead of a magic constant
    int addPart( const QList<QgsPoint> &points, QGis::GeometryType geomType = QGis::UnknownGeometry );

    // TODO QGIS 3.0 returns an enum instead of a magic constant
    int addPart( const QgsPointSequenceV2 &points, QGis::GeometryType geomType = QGis::UnknownGeometry );

    // TODO QGIS 3.0 returns an enum instead of a magic constant
    int addPart( QgsAbstractGeometryV2* part, QGis::GeometryType geomType = QGis::UnknownGeometry );

    // TODO QGIS 3.0 returns an enum instead of a magic constant
    int addPart( GEOSGeometry *newPart );

    // TODO QGIS 3.0 returns an enum instead of a magic constant
    int addPart( const QgsGeometry *newPart );

    int translate( double dx, double dy );

    int transform( const QgsCoordinateTransform& ct );

    int transform( const QTransform& ct );

    int rotate( double rotation, const QgsPoint& center );

    // TODO QGIS 3.0 returns an enum instead of a magic constant
    int splitGeometry( const QList<QgsPoint>& splitLine,
                       QList<QgsGeometry*>&newGeometries,
                       bool topological,
                       QList<QgsPoint> &topologyTestPoints );

    int reshapeGeometry( const QList<QgsPoint>& reshapeWithLine );

    int reshapeGeometry( const QList<QgsPointV2>& reshapeLine );

    int makeDifference( const QgsGeometry* other );

    QgsRectangle boundingBox() const;

    bool intersects( const QgsRectangle& r ) const;

    bool intersects( const QgsGeometry* geometry ) const;

    bool contains( const QgsPoint* p ) const;

    bool contains( const QgsGeometry* geometry ) const;

    bool disjoint( const QgsGeometry* geometry ) const;

    bool equals( const QgsGeometry* geometry ) const;

    bool touches( const QgsGeometry* geometry ) const;

    bool overlaps( const QgsGeometry* geometry ) const;

    bool within( const QgsGeometry* geometry ) const;

    bool crosses( const QgsGeometry* geometry ) const;

    QgsGeometry* buffer( double distance, int segments ) const;

    QgsGeometry* buffer( double distance, int segments, int endCapStyle, int joinStyle, double mitreLimit ) const;

    QgsGeometry* offsetCurve( double distance, int segments, int joinStyle, double mitreLimit ) const;

    QgsGeometry* simplify( double tolerance ) const;

    QgsGeometry* centroid() const;

    QgsGeometry* pointOnSurface() const;

    QgsGeometry* convexHull() const;

    QgsGeometry* interpolate( double distance ) const;

    double lineLocatePoint( const QgsGeometry& point ) const;

    double interpolateAngle( double distance ) const;

    QgsGeometry* intersection( const QgsGeometry* geometry ) const;

    QgsGeometry* combine( const QgsGeometry* geometry ) const;

    QgsGeometry mergeLines() const;

    QgsGeometry* difference( const QgsGeometry* geometry ) const;

    QgsGeometry* symDifference( const QgsGeometry* geometry ) const;

    QgsGeometry extrude( double x, double y );

    QString exportToWkt( int precision = 17 ) const;

    QString exportToGeoJSON( int precision = 17 ) const;

    QgsGeometry* convertToType( QGis::GeometryType destType, bool destMultipart = false ) const;

    /* Accessor functions for getting geometry data */

    QgsPoint asPoint() const;

    QgsPolyline asPolyline() const;

    QgsPolygon asPolygon() const;

    QgsMultiPoint asMultiPoint() const;

    QgsMultiPolyline asMultiPolyline() const;

    QgsMultiPolygon asMultiPolygon() const;

    QList<QgsGeometry*> asGeometryCollection() const;

    QPointF asQPointF() const;

    QPolygonF asQPolygonF() const;

    bool deleteRing( int ringNum, int partNum = 0 );

    bool deletePart( int partNum );

    bool convertToMultiType();

    bool convertToSingleType();

    int avoidIntersections( const QMap<QgsVectorLayer*, QSet<QgsFeatureId> >& ignoreFeatures = ( QMap<QgsVectorLayer*, QSet<QgsFeatureId> >() ) );

    class Error
    {
        QString message;
        QgsPoint location;
        bool hasLocation;
      public:
        Error() : message( "none" ), hasLocation( false ) {}
        explicit Error( const QString& m ) : message( m ), hasLocation( false ) {}
        Error( const QString& m, const QgsPoint& p ) : message( m ), location( p ), hasLocation( true ) {}

        QString what() { return message; }
        QgsPoint where() { return location; }
        bool hasWhere() { return hasLocation; }
    };

    void validateGeometry( QList<Error> &errors );

    static QgsGeometry *unaryUnion( const QList<QgsGeometry*>& geometryList );

    void convertToStraightSegment();

    bool requiresConversionToStraightSegments() const;

    void mapToPixel( const QgsMapToPixel& mtp );

    // not implemented for 2.10
    /* Clips the geometry using the specified rectangle
     * @param rect clip rectangle
     * @note added in QGIS 2.10
     */
    // void clip( const QgsRectangle& rect );

    void draw( QPainter& p ) const;

    bool vertexIdFromVertexNr( int nr, QgsVertexId& id ) const;

    int vertexNrFromVertexId( QgsVertexId i ) const;

    static GEOSContextHandle_t getGEOSHandler();

    static QgsGeometry* fromQPointF( QPointF point );

    static QgsGeometry* fromQPolygonF( const QPolygonF& polygon );

    static QgsPolyline createPolylineFromQPolygonF( const QPolygonF &polygon );

    static QgsPolygon createPolygonFromQPolygonF( const QPolygonF &polygon );

    static bool compare( const QgsPolyline& p1, const QgsPolyline& p2, double epsilon = 4 * std::numeric_limits<double>::epsilon() );

    static bool compare( const QgsPolygon& p1, const QgsPolygon& p2, double epsilon = 4 * std::numeric_limits<double>::epsilon() );

    static bool compare( const QgsMultiPolygon& p1, const QgsMultiPolygon& p2, double epsilon = 4 * std::numeric_limits<double>::epsilon() );

    QgsGeometry* smooth( const unsigned int iterations = 1, const double offset = 0.25 ) const;

    QgsPolygon smoothPolygon( const QgsPolygon &polygon, const unsigned int iterations = 1, const double offset = 0.25 ) const;
    QgsPolyline smoothLine( const QgsPolyline &polyline, const unsigned int iterations = 1, const double offset = 0.25 ) const;

    static QgsGeometryEngine* createGeometryEngine( const QgsAbstractGeometryV2* geometry );

    static void convertPointList( const QList<QgsPoint> &input, QgsPointSequenceV2 &output );

    static void convertPointList( const QgsPointSequenceV2 &input, QList<QgsPoint> &output );

    operator QVariant() const
    {
      return QVariant::fromValue( *this );
    }

  private:

    QgsGeometryPrivate* d; //implicitely shared data pointer

    void detach( bool cloneGeom = true ); //make sure mGeometry only referenced from this instance
    void removeWkbGeos();

    static void convertToPolyline( const QgsPointSequenceV2 &input, QgsPolyline& output );
    static void convertPolygon( const QgsPolygonV2& input, QgsPolygon& output );

    QgsGeometry* convertToPoint( bool destMultipart ) const;
    QgsGeometry* convertToLine( bool destMultipart ) const;
    QgsGeometry* convertToPolygon( bool destMultipart ) const;
}; // class QgsGeometry

Q_DECLARE_METATYPE( QgsGeometry )


CORE_EXPORT QDataStream& operator<<( QDataStream& out, const QgsGeometry& geometry );
CORE_EXPORT QDataStream& operator>>( QDataStream& in, QgsGeometry& geometry );

#endif