qgsgeometryutils.h

Go to the documentation of this file.

/***************************************************************************
                       qgsgeometryutils.h
 -------------------------------------------------------------------
Date                 : 21 Nov 2014
Copyright            : (C) 2014 by Marco Hugentobler
email                : marco.hugentobler at sourcepole 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.                                   *
*                                                                         *
***************************************************************************/
 
#pragma once
 
#include <limits>
 
#include "qgis_core.h"
#include "qgis_sip.h"
#include "qgsgeometry.h"
#include "qgsgeometryutils_base.h"
#include "qgspoint.h"
#include "qgsvector3d.h"
#include "qgsvertexid.h"
 
#include <QJsonArray>
 
class QgsLineString;

class CORE_EXPORT QgsGeometryUtils
{
  public:

    static QVector<QgsLineString *> extractLineStrings( const QgsAbstractGeometry *geom ) SIP_FACTORY;

    static QgsPoint closestVertex( const QgsAbstractGeometry &geom, const QgsPoint &pt, QgsVertexId &id SIP_OUT );

    static QgsPoint closestPoint( const QgsAbstractGeometry &geometry, const QgsPoint &point );

    static double distanceToVertex( const QgsAbstractGeometry &geom, QgsVertexId id );

    static bool verticesAtDistance( const QgsAbstractGeometry &geometry,
                                    double distance,
                                    QgsVertexId &previousVertex SIP_OUT,
                                    QgsVertexId &nextVertex SIP_OUT );

    static double distToInfiniteLine( const QgsPoint &point, const QgsPoint &linePoint1, const QgsPoint &linePoint2, double epsilon = 1e-7 );

    static bool lineCircleIntersection( const QgsPointXY &center, double radius,
                                        const QgsPointXY &linePoint1, const QgsPointXY &linePoint2,
                                        QgsPointXY &intersection SIP_INOUT ) SIP_HOLDGIL;

    static int circleCircleIntersections( const QgsPointXY &center1, double radius1,
                                          const QgsPointXY &center2, double radius2,
                                          QgsPointXY &intersection1 SIP_OUT, QgsPointXY &intersection2 SIP_OUT ) SIP_HOLDGIL;

    static bool tangentPointAndCircle( const QgsPointXY &center, double radius,
                                       const QgsPointXY &p, QgsPointXY &pt1 SIP_OUT, QgsPointXY &pt2 SIP_OUT ) SIP_HOLDGIL;

    static int circleCircleOuterTangents(
      const QgsPointXY &center1, double radius1, const QgsPointXY &center2, double radius2,
      QgsPointXY &line1P1 SIP_OUT, QgsPointXY &line1P2 SIP_OUT,
      QgsPointXY &line2P1 SIP_OUT, QgsPointXY &line2P2 SIP_OUT ) SIP_HOLDGIL;

    static int circleCircleInnerTangents(
      const QgsPointXY &center1, double radius1, const QgsPointXY &center2, double radius2,
      QgsPointXY &line1P1 SIP_OUT, QgsPointXY &line1P2 SIP_OUT,
      QgsPointXY &line2P1 SIP_OUT, QgsPointXY &line2P2 SIP_OUT ) SIP_HOLDGIL;

    static QgsPoint projectPointOnSegment( const QgsPoint &p, const QgsPoint &s1, const QgsPoint &s2 ) SIP_HOLDGIL
    {
      const double nx = s2.y() - s1.y();
      const double ny = -( s2.x() - s1.x() );
      const double t = ( p.x() * ny - p.y() * nx - s1.x() * ny + s1.y() * nx ) / ( ( s2.x() - s1.x() ) * ny - ( s2.y() - s1.y() ) * nx );
      return t < 0. ? s1 : t > 1. ? s2 : QgsPoint( s1.x() + ( s2.x() - s1.x() ) * t, s1.y() + ( s2.y() - s1.y() ) * t );
    }

    struct SelfIntersection SIP_SKIP
    {
      int segment1;
      int segment2;
      QgsPoint point;
    };

    static QVector<SelfIntersection> selfIntersections( const QgsAbstractGeometry *geom, int part, int ring, double tolerance ) SIP_SKIP;

    static int leftOfLine( const QgsPoint &point, const QgsPoint &p1, const QgsPoint &p2 ) SIP_HOLDGIL;

    static QgsPoint pointOnLineWithDistance( const QgsPoint &startPoint, const QgsPoint &directionPoint, double distance ) SIP_HOLDGIL;

    static QgsPoint interpolatePointOnArc( const QgsPoint &pt1, const QgsPoint &pt2, const QgsPoint &pt3, double distance ) SIP_HOLDGIL;

    static QgsPoint interpolatePointOnCubicBezier( const QgsPoint &p0, const QgsPoint &p1, const QgsPoint &p2, const QgsPoint &p3, double t ) SIP_HOLDGIL;

    static bool segmentMidPoint( const QgsPoint &p1, const QgsPoint &p2, QgsPoint &result SIP_OUT, double radius, const QgsPoint &mousePos ) SIP_HOLDGIL;

    static QgsPoint segmentMidPointFromCenter( const QgsPoint &p1, const QgsPoint &p2, const QgsPoint &center, bool useShortestArc = true ) SIP_HOLDGIL;

    static double circleTangentDirection( const QgsPoint &tangentPoint, const QgsPoint &cp1, const QgsPoint &cp2, const QgsPoint &cp3 ) SIP_HOLDGIL;

    static void segmentizeArc( const QgsPoint &p1, const QgsPoint &p2, const QgsPoint &p3,
                               QgsPointSequence SIP_PYALTERNATIVETYPE( QVector<QgsPoint> ) &points SIP_OUT, double tolerance = M_PI_2 / 90,
                               QgsAbstractGeometry::SegmentationToleranceType toleranceType = QgsAbstractGeometry::MaximumAngle,
                               bool hasZ = false, bool hasM = false );

    static bool pointContinuesArc( const QgsPoint &a1, const QgsPoint &a2, const QgsPoint &a3, const QgsPoint &b, double distanceTolerance,
                                   double pointSpacingAngleTolerance ) SIP_HOLDGIL;

    static int segmentSide( const QgsPoint &pt1, const QgsPoint &pt3, const QgsPoint &pt2 ) SIP_HOLDGIL;

    static QgsPointSequence pointsFromWKT( const QString &wktCoordinateList, bool is3D, bool isMeasure ) SIP_SKIP;

    static void pointsToWKB( QgsWkbPtr &wkb, const QgsPointSequence &points, bool is3D, bool isMeasure, QgsAbstractGeometry::WkbFlags flags ) SIP_SKIP;

    static QString pointsToWKT( const QgsPointSequence &points, int precision, bool is3D, bool isMeasure ) SIP_SKIP;

    static QDomElement pointsToGML2( const QgsPointSequence &points, QDomDocument &doc, int precision, const QString &ns, QgsAbstractGeometry::AxisOrder axisOrder = QgsAbstractGeometry::AxisOrder::XY ) SIP_SKIP;

    static QDomElement pointsToGML3( const QgsPointSequence &points, QDomDocument &doc, int precision, const QString &ns, bool is3D, QgsAbstractGeometry::AxisOrder axisOrder = QgsAbstractGeometry::AxisOrder::XY ) SIP_SKIP;

    static QString pointsToJSON( const QgsPointSequence &points, int precision ) SIP_SKIP;

    static json pointsToJson( const QgsPointSequence &points, int precision ) SIP_SKIP;

    static QPair<Qgis::WkbType, QString> wktReadBlock( const QString &wkt ) SIP_SKIP;

    static QStringList wktGetChildBlocks( const QString &wkt, const QString &defaultType = QString() ) SIP_SKIP;

    static QgsPoint midpoint( const QgsPoint &pt1, const QgsPoint &pt2 ) SIP_HOLDGIL;

    static QgsPointXY interpolatePointOnLine( double x1, double y1, double x2, double y2, double fraction ) SIP_HOLDGIL;

    static QgsPoint interpolatePointOnLine( const QgsPoint &p1, const QgsPoint &p2, double fraction ) SIP_HOLDGIL;

    static QgsPointXY interpolatePointOnLineByValue( double x1, double y1, double v1, double x2, double y2, double v2, double value ) SIP_HOLDGIL;

    static double gradient( const QgsPoint &pt1, const QgsPoint &pt2 ) SIP_HOLDGIL;

    static void coefficients( const QgsPoint &pt1, const QgsPoint &pt2,
                              double &a SIP_OUT, double &b SIP_OUT, double &c SIP_OUT ) SIP_HOLDGIL;

    static QgsLineString perpendicularSegment( const QgsPoint &p, const QgsPoint &s1, const QgsPoint &s2 ) SIP_HOLDGIL;

    Q_DECL_DEPRECATED static bool setZValueFromPoints( const QgsPointSequence &points, QgsPoint &point ) SIP_DEPRECATED
    {
      return transferFirstZValueToPoint( points, point );
    }

    static bool transferFirstZValueToPoint( const QgsPointSequence &points, QgsPoint &point );

    static bool transferFirstMValueToPoint( const QgsPointSequence &points, QgsPoint &point );

    template <class Iterator> static bool transferFirstZOrMValueToPoint( Iterator verticesBegin, Iterator verticesEnd, QgsPoint &point ) SIP_SKIP
    {
      bool zFound = false;
      bool mFound = false;
 
      for ( auto it = verticesBegin ; it != verticesEnd ; ++it )
      {
        if ( !mFound && ( *it ).isMeasure() )
        {
          point.convertTo( QgsWkbTypes::addM( point.wkbType() ) );
          point.setM( ( *it ).m() );
          mFound = true;
        }
        if ( !zFound && ( *it ).is3D() )
        {
          point.convertTo( QgsWkbTypes::addZ( point.wkbType() ) );
          point.setZ( ( *it ).z() );
          zFound = true;
        }
        if ( zFound && mFound )
          break;
      }
 
      return zFound || mFound;
    }

    static bool transferFirstZOrMValueToPoint( const QgsPointSequence &points, QgsPoint &point )
    {
      return QgsGeometryUtils::transferFirstZOrMValueToPoint( points.constBegin(), points.constEnd(), point );
    }

    static bool transferFirstZOrMValueToPoint( const QgsGeometry &geom, QgsPoint &point )
    {
      return QgsGeometryUtils::transferFirstZOrMValueToPoint( geom.vertices_begin(), geom.vertices_end(), point );
    }

    enum ComponentType SIP_SKIP
    {
      Vertex,
      Ring,
      Part
    };

    template<class T> static double closestSegmentFromComponents( T &container, ComponentType ctype, const QgsPoint &pt, QgsPoint &segmentPt,  QgsVertexId &vertexAfter, int *leftOf, double epsilon ) SIP_SKIP
    {
      double minDist = std::numeric_limits<double>::max();
      double minDistSegmentX = 0.0, minDistSegmentY = 0.0;
      QgsVertexId minDistVertexAfter;
      int minDistLeftOf = 0;
      double sqrDist = 0.0;
      int vertexOffset = 0;
      int ringOffset = 0;
      int partOffset = 0;
 
      for ( int i = 0; i < container.size(); ++i )
      {
        sqrDist = container.at( i )->closestSegment( pt, segmentPt, vertexAfter, leftOf, epsilon );
        if ( sqrDist >= 0 && sqrDist < minDist )
        {
          minDist = sqrDist;
          minDistSegmentX = segmentPt.x();
          minDistSegmentY = segmentPt.y();
          minDistVertexAfter = vertexAfter;
          minDistVertexAfter.vertex = vertexAfter.vertex + vertexOffset;
          minDistVertexAfter.part = vertexAfter.part + partOffset;
          minDistVertexAfter.ring = vertexAfter.ring + ringOffset;
          if ( leftOf )
          {
            minDistLeftOf = *leftOf;
          }
        }
 
        if ( ctype == Vertex )
        {
          //-1 because compoundcurve counts duplicated vertices of neighbour curves as one node
          vertexOffset += container.at( i )->nCoordinates() - 1;
        }
        else if ( ctype == Ring )
        {
          ringOffset += 1;
        }
        else if ( ctype == Part )
        {
          partOffset += 1;
        }
      }
 
      if ( minDist == std::numeric_limits<double>::max() )
        return -1;  // error: no segments
 
      segmentPt.setX( minDistSegmentX );
      segmentPt.setY( minDistSegmentY );
      vertexAfter = minDistVertexAfter;
      if ( leftOf )
      {
        *leftOf = minDistLeftOf;
      }
      return minDist;
    }
 
    /******************************/
    /* From QgsGeometryUtils_Base */
    /******************************/

    Q_DECL_DEPRECATED static double sqrDistance2D( double x1, double y1, double x2, double y2 ) SIP_DEPRECATED SIP_HOLDGIL {return QgsGeometryUtilsBase::sqrDistance2D( x1, y1, x2, y2 ); }

    static double sqrDistance2D( const QgsPoint &pt1, const QgsPoint &pt2 ) SIP_HOLDGIL
    {
      return QgsGeometryUtilsBase::sqrDistance2D( pt1.x(), pt1.y(), pt2.x(), pt2.y() );
    }

    static double sqrDistance3D( const QgsPoint &pt1, const QgsPoint &pt2 ) SIP_HOLDGIL
    {
      return QgsGeometryUtilsBase::sqrDistance3D( pt1.x(), pt1.y(), pt1.z(), pt2.x(), pt2.y(), pt2.z() );
    }

    Q_DECL_DEPRECATED static double distance2D( double x1, double y1, double x2, double y2 ) SIP_DEPRECATED SIP_HOLDGIL {return QgsGeometryUtilsBase::distance2D( x1, y1, x2, y2 ); }

    static double distance2D( const QgsPoint &pt1, const QgsPoint &pt2 ) SIP_HOLDGIL { return QgsGeometryUtilsBase::distance2D( pt1.x(), pt1.y(), pt2.x(), pt2.y() );}

    static double distance3D( const QgsPoint &pt1, const QgsPoint &pt2 ) SIP_HOLDGIL
    {
      return QgsGeometryUtilsBase::distance3D( pt1.x(), pt1.y(), pt1.z(), pt2.x(), pt2.y(), pt2.z() );
    }
 

    Q_DECL_DEPRECATED static double sqrDistToLine( double ptX, double ptY, double x1, double y1, double x2, double y2, double &minDistX SIP_OUT, double &minDistY SIP_OUT, double epsilon ) SIP_DEPRECATED SIP_HOLDGIL
    {
      return QgsGeometryUtilsBase::sqrDistToLine( ptX, ptY, x1, y1, x2, y2, minDistX, minDistY, epsilon );
    }

    Q_DECL_DEPRECATED static int leftOfLine( const double x, const double y, const double x1, const double y1, const double x2, const double y2 ) SIP_DEPRECATED SIP_HOLDGIL
    {
      return QgsGeometryUtilsBase::leftOfLine( x, y, x1, y1, x2, y2 ) ;
    }

    Q_DECL_DEPRECATED static void pointOnLineWithDistance( double x1, double y1, double x2, double y2, double distance, double &x, double &y,
        double *z1 = nullptr, double *z2 = nullptr, double *z = nullptr,
        double *m1 = nullptr, double *m2 = nullptr, double *m = nullptr ) SIP_SKIP
    {
      return QgsGeometryUtilsBase::pointOnLineWithDistance( x1, y1, x2, y2, distance, x, y,
          z1, z2, z,
          m1, m2, m );
    }

    Q_DECL_DEPRECATED static void perpendicularOffsetPointAlongSegment( double x1, double y1, double x2, double y2, double proportion, double offset, double *x SIP_OUT, double *y SIP_OUT )
    {
      QgsGeometryUtilsBase::perpendicularOffsetPointAlongSegment( x1, y1, x2, y2, proportion, offset, x, y );
    }
 
 
 

    Q_DECL_DEPRECATED static double ccwAngle( double dy, double dx ) SIP_DEPRECATED SIP_HOLDGIL
    {
      return QgsGeometryUtilsBase::ccwAngle( dy, dx );
    }
 

    Q_DECL_DEPRECATED static bool circleClockwise( double angle1, double angle2, double angle3 ) SIP_DEPRECATED SIP_HOLDGIL
    {
      return QgsGeometryUtilsBase::circleClockwise( angle1, angle2, angle3 );
    }

    Q_DECL_DEPRECATED static bool circleAngleBetween( double angle, double angle1, double angle2, bool clockwise ) SIP_DEPRECATED SIP_HOLDGIL
    {
      return QgsGeometryUtilsBase::circleAngleBetween( angle, angle1, angle2, clockwise );
    }

    Q_DECL_DEPRECATED static bool angleOnCircle( double angle, double angle1, double angle2, double angle3 ) SIP_DEPRECATED SIP_HOLDGIL
    {
      return QgsGeometryUtilsBase::angleOnCircle( angle, angle1, angle2, angle3 );
    }

    Q_DECL_DEPRECATED static double circleLength( double x1, double y1, double x2, double y2, double x3, double y3 ) SIP_DEPRECATED SIP_HOLDGIL
    {
      return QgsGeometryUtilsBase::circleLength( x1, y1, x2, y2, x3, y3 );
    }

    Q_DECL_DEPRECATED static double sweepAngle( double centerX, double centerY, double x1, double y1, double x2, double y2, double x3, double y3 ) SIP_DEPRECATED SIP_HOLDGIL
    {
      return QgsGeometryUtilsBase::sweepAngle( centerX, centerY, x1, y1, x2, y2, x3, y3 );
    }

    Q_DECL_DEPRECATED static double interpolateArcValue( double angle, double a1, double a2, double a3, double zm1, double zm2, double zm3 ) SIP_DEPRECATED SIP_HOLDGIL
    {
      return QgsGeometryUtilsBase::interpolateArcValue( angle, a1, a2, a3, zm1, zm2, zm3 );
    }

    Q_DECL_DEPRECATED static double normalizedAngle( double angle ) SIP_DEPRECATED SIP_HOLDGIL
    {
      return QgsGeometryUtilsBase::normalizedAngle( angle );
    }

    Q_DECL_DEPRECATED static double lineAngle( double x1, double y1, double x2, double y2 ) SIP_DEPRECATED SIP_HOLDGIL
    {
      return QgsGeometryUtilsBase::lineAngle( x1, y1, x2, y2 );
    }

    Q_DECL_DEPRECATED static double angleBetweenThreePoints( double x1, double y1, double x2, double y2, double x3, double y3 ) SIP_DEPRECATED SIP_HOLDGIL
    {
      return QgsGeometryUtilsBase::angleBetweenThreePoints( x1, y1, x2, y2, x3, y3 );
    }

    Q_DECL_DEPRECATED static double linePerpendicularAngle( double x1, double y1, double x2, double y2 ) SIP_DEPRECATED SIP_HOLDGIL
    {
      return QgsGeometryUtilsBase::linePerpendicularAngle( x1, y1, x2, y2 );
    }

    Q_DECL_DEPRECATED static double averageAngle( double x1, double y1, double x2, double y2, double x3, double y3 ) SIP_DEPRECATED SIP_HOLDGIL
    {
      return QgsGeometryUtilsBase::averageAngle( x1, y1, x2, y2, x3, y3 );
    }

    Q_DECL_DEPRECATED static double averageAngle( double a1, double a2 ) SIP_DEPRECATED SIP_HOLDGIL
    {
      return QgsGeometryUtilsBase::averageAngle( a1, a2 );
    }
 

    Q_DECL_DEPRECATED static int closestSideOfRectangle( double right, double bottom, double left, double top, double x, double y )
    {
      return QgsGeometryUtilsBase::closestSideOfRectangle( right, bottom, left, top, x, y );
    }

    Q_DECL_DEPRECATED static void perpendicularCenterSegment( double centerPointX, double centerPointY,
        double segmentPoint1x, double segmentPoint1y,
        double segmentPoint2x, double segmentPoint2y,
        double &perpendicularSegmentPoint1x SIP_OUT, double &perpendicularSegmentPoint1y SIP_OUT,
        double &perpendicularSegmentPoint2x SIP_OUT, double &perpendicularSegmentPoint2y SIP_OUT,
        double segmentLength = 0 ) SIP_HOLDGIL
    {
      return QgsGeometryUtilsBase::perpendicularCenterSegment( centerPointX, centerPointY, segmentPoint1x, segmentPoint1y, segmentPoint2x, segmentPoint2y, perpendicularSegmentPoint1x, perpendicularSegmentPoint1y, perpendicularSegmentPoint2x, perpendicularSegmentPoint2y, segmentLength );
    }

    Q_DECL_DEPRECATED static double skewLinesDistance( const QgsVector3D &P1, const QgsVector3D &P12, const QgsVector3D &P2, const QgsVector3D &P22 ) SIP_DEPRECATED SIP_HOLDGIL
    {
      return QgsGeometryUtilsBase::skewLinesDistance( P1, P12, P2, P22 );
    }

    Q_DECL_DEPRECATED static bool skewLinesProjection( const QgsVector3D &P1, const QgsVector3D &P12,
        const QgsVector3D &P2, const QgsVector3D &P22,
        QgsVector3D &X1 SIP_OUT,
        double epsilon = 0.0001 ) SIP_HOLDGIL
    {
      return QgsGeometryUtilsBase::skewLinesProjection( P1, P12, P2, P22, X1, epsilon );
    }
 

    Q_DECL_DEPRECATED static bool linesIntersection3D( const QgsVector3D &La1, const QgsVector3D &La2,
        const QgsVector3D &Lb1, const QgsVector3D &Lb2,
        QgsVector3D &intersection SIP_OUT ) SIP_HOLDGIL
    {
      return QgsGeometryUtilsBase::linesIntersection3D( La1, La2, Lb1, Lb2, intersection );
    }

    Q_DECL_DEPRECATED static double triangleArea( double aX, double aY, double bX, double bY, double cX, double cY ) SIP_DEPRECATED SIP_HOLDGIL
    {
      return QgsGeometryUtilsBase::triangleArea( aX, aY, bX, bY, cX, cY );
    }

    Q_DECL_DEPRECATED static double pointFractionAlongLine( double x1, double y1, double x2, double y2, double px, double py )
    {
      return QgsGeometryUtilsBase::pointFractionAlongLine( x1, y1, x2, y2, px, py );
    }

    Q_DECL_DEPRECATED static void weightedPointInTriangle( double aX, double aY, double bX, double bY, double cX, double cY,
        double weightB, double weightC, double &pointX SIP_OUT, double &pointY SIP_OUT ) SIP_HOLDGIL
    {
      return QgsGeometryUtilsBase::weightedPointInTriangle( aX, aY, bX, bY, cX, cY, weightB, weightC, pointX, pointY );
    }

    Q_DECL_DEPRECATED static bool pointsAreCollinear( double x1, double y1, double x2, double y2, double x3, double y3, double epsilon )
    {
      return QgsGeometryUtilsBase::pointsAreCollinear( x1, y1, x2, y2, x3, y3, epsilon );
    }

    Q_DECL_DEPRECATED static bool angleBisector( double aX, double aY, double bX, double bY, double cX, double cY, double dX, double dY,
        double &pointX SIP_OUT, double &pointY SIP_OUT, double &angle SIP_OUT ) SIP_HOLDGIL
    {
      return QgsGeometryUtilsBase::angleBisector( aX, aY, bX, bY, cX, cY, dX, dY, pointX, pointY, angle );
    }

    Q_DECL_DEPRECATED static bool bisector( double aX, double aY, double bX, double bY, double cX, double cY,
                                            double &pointX SIP_OUT, double &pointY SIP_OUT ) SIP_HOLDGIL
    {
      return QgsGeometryUtilsBase::bisector( aX, aY, bX, bY, cX, cY, pointX, pointY );
    }

    static void circleCenterRadius( const QgsPoint &pt1, const QgsPoint &pt2, const QgsPoint &pt3, double &radius SIP_OUT,
                                    double &centerX SIP_OUT, double &centerY SIP_OUT ) SIP_HOLDGIL
    {
      return QgsGeometryUtilsBase::circleCenterRadius( pt1.x(), pt1.y(), pt2.x(), pt2.y(), pt3.x(), pt3.y(), radius, centerX, centerY );
    }

    static bool lineIntersection( const QgsPoint &p1, QgsVector v1, const QgsPoint &p2, QgsVector v2, QgsPoint &intersection SIP_OUT ) SIP_HOLDGIL
    {
      double intersectionX = 0.0, intersectionY = 0.0;
      bool result = QgsGeometryUtilsBase::lineIntersection( p1.x(), p1.y(), v1, p2.x(), p2.y(), v2, intersectionX, intersectionY );
      intersection = QgsPoint( intersectionX, intersectionY );
 
      // z and m support for intersection point
      QgsGeometryUtils::transferFirstZOrMValueToPoint( QgsPointSequence() << p1 << p2, intersection );
 
      return result;
    }

    static bool segmentIntersection( const QgsPoint &p1, const QgsPoint &p2, const QgsPoint &q1, const QgsPoint &q2, QgsPoint &intersectionPoint SIP_OUT, bool &isIntersection SIP_OUT, double tolerance = 1e-8, bool acceptImproperIntersection = false ) SIP_HOLDGIL
    {
      double intersectionPointX = 0.0, intersectionPointY = 0.0;
      bool result = QgsGeometryUtilsBase::segmentIntersection( p1.x(), p1.y(), p2.x(), p2.y(), q1.x(), q1.y(), q2.x(), q2.y(), intersectionPointX, intersectionPointY, isIntersection, tolerance, acceptImproperIntersection );
      intersectionPoint.setX( intersectionPointX );
      intersectionPoint.setY( intersectionPointY );
      return result;
    }

    static QgsPoint createPointWithMatchingDimensions( double x, double y, const QgsPoint &reference ) SIP_HOLDGIL;

    static QgsPoint interpolatePointOnSegment( double x, double y,
        const QgsPoint &segmentStart, const QgsPoint &segmentEnd ) SIP_HOLDGIL;

    static bool createChamfer( const QgsPoint &segment1Start, const QgsPoint &segment1End,
                               const QgsPoint &segment2Start, const QgsPoint &segment2End,
                               double distance1, double distance2,
                               QgsPoint &chamferStart SIP_OUT, QgsPoint &chamferEnd SIP_OUT,
                               double epsilon = 1e-8 ) SIP_THROW( QgsInvalidArgumentException ) SIP_HOLDGIL;

    static bool createFillet( const QgsPoint &segment1Start, const QgsPoint &segment1End,
                              const QgsPoint &segment2Start, const QgsPoint &segment2End,
                              double radius,
                              QgsPoint &filletPoint1 SIP_OUT,
                              QgsPoint &filletMidPoint SIP_OUT,
                              QgsPoint &filletPoint2 SIP_OUT,
                              double epsilon = 1e-8 ) SIP_THROW( QgsInvalidArgumentException ) SIP_HOLDGIL;

    static std::unique_ptr< QgsLineString > createChamferGeometry(
      const QgsPoint &segment1Start, const QgsPoint &segment1End,
      const QgsPoint &segment2Start, const QgsPoint &segment2End,
      double distance1, double distance2
    ) SIP_THROW( QgsInvalidArgumentException );

    static std::unique_ptr< QgsAbstractGeometry > createFilletGeometry(
      const QgsPoint &segment1Start, const QgsPoint &segment1End,
      const QgsPoint &segment2Start, const QgsPoint &segment2End,
      double radius, int segments
    ) SIP_THROW( QgsInvalidArgumentException );

    static double maxFilletRadius( const QgsPoint &segment1Start, const QgsPoint &segment1End,
                                   const QgsPoint &segment2Start, const QgsPoint &segment2End,
                                   double epsilon = 1e-8 ) SIP_HOLDGIL;

    static std::unique_ptr< QgsAbstractGeometry > chamferVertex(
      const QgsCurve *curve, int vertexIndex,
      double distance1, double distance2
    ) SIP_THROW( QgsInvalidArgumentException );

    static std::unique_ptr< QgsAbstractGeometry > filletVertex(
      const QgsCurve *curve, int vertexIndex,
      double radius, int segments
    ) SIP_THROW( QgsInvalidArgumentException );

    static bool createFilletArray( const QgsPoint &segment1Start, const QgsPoint &segment1End,
                                   const QgsPoint &segment2Start, const QgsPoint &segment2End,
                                   double radius,
                                   QgsPoint filletPoints[3],
                                   double epsilon = 1e-8 ) SIP_SKIP;

    static bool pointsAreCollinear( const QgsPoint &pt1, const QgsPoint &pt2, const QgsPoint &pt3, double epsilon );
 

    static bool checkWeaklyFor3DPlane( const QgsAbstractGeometry *geom, QgsPoint &pt1 SIP_OUT, QgsPoint &pt2 SIP_OUT, QgsPoint &pt3 SIP_OUT, double epsilon = std::numeric_limits<double>::epsilon() );
 
  private:

    static std::unique_ptr< QgsAbstractGeometry > doChamferFilletOnVertex(
      QgsGeometry::ChamferFilletOperationType operation, const QgsCurve *curve, int vertexIndex,
      double value1, double value2, int segments
    );
};
#include "qgsgeometryutils_base.h"