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 "qgspoint.h"
#include "qgscoordinatetransform.h"
#include "qgsfeature.h"

#include <QSet>

class QgsVectorLayer;

typedef QVector<QgsPoint> QgsPolyline;

typedef QVector<QgsPolyline> QgsPolygon;

typedef QVector<QgsPoint> QgsMultiPoint;

typedef QVector<QgsPolyline> QgsMultiPolyline;

typedef QVector<QgsPolygon> QgsMultiPolygon;

class QgsRectangle;

class QgsConstWkbPtr;
class QgsWkbPtr;

class CORE_EXPORT QgsGeometry
{
  public:
    QgsGeometry();

    QgsGeometry( const QgsGeometry & );

    QgsGeometry & operator=( QgsGeometry const & rhs );

    ~QgsGeometry();

    static GEOSContextHandle_t getGEOSHandler();

    static QgsGeometry* fromWkt( 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 );
    static QgsGeometry* fromQPointF( const QPointF& point );

    static QgsGeometry* fromQPolygonF( const QPolygonF& polygon );

    void fromGeos( GEOSGeometry* geos );
    void fromWkb( unsigned char * wkb, size_t length );

    const unsigned char* asWkb() const;

    size_t wkbSize() const;

    const GEOSGeometry* asGeos() const;

    QGis::WkbType wkbType() const;

    QGis::GeometryType type() const;

    bool isMultipart() const;

    bool isGeosEqual( QgsGeometry & );

    bool isGeosValid();

    bool isGeosEmpty();

    double area();

    double length();

    double distance( QgsGeometry& geom );

    QgsPoint closestVertex( const QgsPoint& point, int& atVertex, int& beforeVertex, int& afterVertex, double& sqrDist );

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

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

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

    bool deleteVertex( int atVertex );

    QgsPoint vertexAt( int atVertex );

    double sqrDistToVertexAt( QgsPoint& point, int atVertex );

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

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

    int addRing( const QList<QgsPoint>& ring );

    int addPart( const QList<QgsPoint> &points, QGis::GeometryType geomType = QGis::UnknownGeometry );

    int addPart( GEOSGeometry *newPart );

    int addPart( 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 );

    int splitGeometry( const QList<QgsPoint>& splitLine,
                       QList<QgsGeometry*>&newGeometries,
                       bool topological,
                       QList<QgsPoint> &topologyTestPoints );

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

    int makeDifference( QgsGeometry* other );

    QgsRectangle boundingBox();

    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 );

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

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

    QgsGeometry* simplify( double tolerance );

    QgsGeometry* centroid();

    QgsGeometry* pointOnSurface();

    QgsGeometry* convexHull();

    /* Return interpolated point on line at distance */
    QgsGeometry* interpolate( double distance );

    QgsGeometry* intersection( QgsGeometry* geometry );

    QgsGeometry* combine( QgsGeometry* geometry );

    QgsGeometry* difference( QgsGeometry* geometry );

    QgsGeometry* symDifference( QgsGeometry* geometry );

    QString exportToWkt( const int &precision = 17 ) const;

    QString exportToGeoJSON( const int &precision = 17 ) const;

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

    /* 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();

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

    class Error
    {
        QString message;
        QgsPoint location;
        bool hasLocation;
      public:
        Error() : message( "none" ), hasLocation( false ) {}
        Error( QString m ) : message( m ), hasLocation( false ) {}
        Error( QString m, 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 );

  private:
    // Private variables

    // All of these are mutable since there may be on-the-fly
    // conversions between WKB, GEOS and Wkt;
    // However the intent is the const functions do not
    // semantically change the value that this object represents.

    mutable unsigned char * mGeometry;

    mutable size_t mGeometrySize;

    mutable GEOSGeometry* mGeos;

    mutable bool mDirtyWkb;

    mutable bool mDirtyGeos;


    // Private functions

    bool exportWkbToGeos() const;

    bool exportGeosToWkb() const;

    bool insertVertex( double x, double y,
                       int beforeVertex,
                       const GEOSCoordSequence*  old_sequence,
                       GEOSCoordSequence** new_sequence );

    void transformVertex( QgsWkbPtr &wkbPtr, const QTransform& trans, bool hasZValue );

    void transformVertex( QgsWkbPtr &wkbPtr, const QgsCoordinateTransform& ct, bool hasZValue );

    //helper functions for geometry splitting

    int splitLinearGeometry( GEOSGeometry *splitLine, QList<QgsGeometry*>& newGeometries );
    int splitPolygonGeometry( GEOSGeometry *splitLine, QList<QgsGeometry*>& newGeometries );
    GEOSGeometry* linePointDifference( GEOSGeometry* GEOSsplitPoint );

    int topologicalTestPointsSplit( const GEOSGeometry* splitLine, QList<QgsPoint>& testPoints ) const;

    static GEOSGeometry* reshapeLine( const GEOSGeometry* origLine, const GEOSGeometry* reshapeLineGeos );

    static GEOSGeometry* reshapePolygon( const GEOSGeometry* polygon, const GEOSGeometry* reshapeLineGeos );

    static GEOSGeometry* nodeGeometries( const GEOSGeometry *splitLine, const GEOSGeometry *poly );

    static int lineContainedInLine( const GEOSGeometry* line1, const GEOSGeometry* line2 );

    static int pointContainedInLine( const GEOSGeometry* point, const GEOSGeometry* line );

    static int geomDigits( const GEOSGeometry* geom );

    int numberOfGeometries( GEOSGeometry* g ) const;

    int mergeGeometriesMultiTypeSplit( QVector<GEOSGeometry*>& splitResult );

    QgsPoint asPoint( QgsConstWkbPtr &wkbPtr, bool hasZValue ) const;

    QgsPolyline asPolyline( QgsConstWkbPtr &wkbPtr, bool hasZValue ) const;

    QgsPolygon asPolygon( QgsConstWkbPtr &wkbPtr, bool hasZValue ) const;

    static bool geosRelOp( char( *op )( GEOSContextHandle_t handle, const GEOSGeometry*, const GEOSGeometry * ),
                           const QgsGeometry* a, const QgsGeometry* b );

    double leftOf( double x, double y, double& x1, double& y1, double& x2, double& y2 );

    static inline bool moveVertex( QgsWkbPtr &wkbPtr, const double &x, const double &y, int atVertex, bool hasZValue, int &pointIndex, bool isRing );
    static inline int deleteVertex( QgsConstWkbPtr &srcPtr, QgsWkbPtr &dstPtr, int atVertex, bool hasZValue, int &pointIndex, bool isRing, bool lastItem );
    static inline bool insertVertex( QgsConstWkbPtr &srcPtr, QgsWkbPtr &dstPtr, int beforeVertex, const double &x, const double &y, bool hasZValue, int &pointIndex, bool isRing );

    QgsGeometry* convertToPoint( bool destMultipart );
    QgsGeometry* convertToLine( bool destMultipart );
    QgsGeometry* convertToPolygon( bool destMultipart );

    static QgsPolyline createPolylineFromQPolygonF( const QPolygonF &polygon );
    static QgsPolygon createPolygonFromQPolygonF( const QPolygonF &polygon );
}; // class QgsGeometry

Q_DECLARE_METATYPE( QgsGeometry );

class CORE_EXPORT QgsWkbPtr
{
    mutable unsigned char *mP;

  public:
    QgsWkbPtr( unsigned char *p ) { mP = p; }

    inline const QgsWkbPtr &operator>>( double &v ) const { memcpy( &v, mP, sizeof( v ) ); mP += sizeof( v ); return *this; }
    inline const QgsWkbPtr &operator>>( int &v ) const { memcpy( &v, mP, sizeof( v ) ); mP += sizeof( v ); return *this; }
    inline const QgsWkbPtr &operator>>( unsigned int &v ) const { memcpy( &v, mP, sizeof( v ) ); mP += sizeof( v ); return *this; }
    inline const QgsWkbPtr &operator>>( char &v ) const { memcpy( &v, mP, sizeof( v ) ); mP += sizeof( v ); return *this; }
    inline const QgsWkbPtr &operator>>( QGis::WkbType &v ) const { memcpy( &v, mP, sizeof( v ) ); mP += sizeof( v ); return *this; }
#ifdef QT_ARCH_ARM
    inline const QgsWkbPtr &operator>>( qreal &v ) const { double d; memcpy( &d, mP, sizeof( d ) ); mP += sizeof( d ); v=d; return *this; }
#endif

    inline QgsWkbPtr &operator<<( const double &v ) { memcpy( mP, &v, sizeof( v ) ); mP += sizeof( v ); return *this; }
    inline QgsWkbPtr &operator<<( const int &v ) { memcpy( mP, &v, sizeof( v ) ); mP += sizeof( v ); return *this; }
    inline QgsWkbPtr &operator<<( const unsigned int &v ) { memcpy( mP, &v, sizeof( v ) ); mP += sizeof( v ); return *this; }
    inline QgsWkbPtr &operator<<( const char &v ) { memcpy( mP, &v, sizeof( v ) ); mP += sizeof( v ); return *this; }
    inline QgsWkbPtr &operator<<( const QGis::WkbType &v ) { memcpy( mP, &v, sizeof( v ) ); mP += sizeof( v ); return *this; }
#ifdef QT_ARCH_ARM
    inline QgsWkbPtr &operator<<( const qreal &v ) { double d = v; memcpy( mP, &d, sizeof( d ) ); mP += sizeof( d ); return *this; }
#endif

    inline void operator+=( int n ) { mP += n; }

    inline operator unsigned char *() const { return mP; }
};

class CORE_EXPORT QgsConstWkbPtr
{
    mutable unsigned char *mP;

  public:
    QgsConstWkbPtr( const unsigned char *p ) { mP = ( unsigned char * ) p; }

    inline const QgsConstWkbPtr &operator>>( double &v ) const { memcpy( &v, mP, sizeof( v ) ); mP += sizeof( v ); return *this; }
    inline const QgsConstWkbPtr &operator>>( int &v ) const { memcpy( &v, mP, sizeof( v ) ); mP += sizeof( v ); return *this; }
    inline const QgsConstWkbPtr &operator>>( unsigned int &v ) const { memcpy( &v, mP, sizeof( v ) ); mP += sizeof( v ); return *this; }
    inline const QgsConstWkbPtr &operator>>( char &v ) const { memcpy( &v, mP, sizeof( v ) ); mP += sizeof( v ); return *this; }
    inline const QgsConstWkbPtr &operator>>( QGis::WkbType &v ) const { memcpy( &v, mP, sizeof( v ) ); mP += sizeof( v ); return *this; }
#ifdef QT_ARCH_ARM
    inline const QgsConstWkbPtr &operator>>( qreal &v ) const { double d; memcpy( &d, mP, sizeof( d ) ); mP += sizeof( d ); v=d; return *this; }
#endif

    inline void operator+=( int n ) { mP += n; }

    inline operator const unsigned char *() const { return mP; }
};

#endif