qgsgeometryutils_base.h

Go to the documentation of this file.

/***************************************************************************
                       qgsgeometryutils_base.h
 -------------------------------------------------------------------
Date                 : 14 september 2023
Copyright            : (C) 2023 by Loïc Bartoletti
email                : loic dot bartoletti at oslandia 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 "qgis_core.h"
#include "qgis_sip.h"
#include "qgsvector3d.h"
#include "qgsvector.h"
#include <iterator>
 
class CORE_EXPORT QgsGeometryUtilsBase
{
  public:
 
    static double sqrDistance3D( double x1, double y1, double z1, double x2, double y2, double z2 ) SIP_HOLDGIL {return ( x1 - x2 ) * ( x1 - x2 ) + ( y1 - y2 ) * ( y1 - y2 ) + ( z1 - z2 ) * ( z1 - z2 ); }
 
    static double distance3D( double x1, double y1, double z1, double x2, double y2, double z2 ) SIP_HOLDGIL {return std::sqrt( sqrDistance3D( x1, y1, z1, x2, y2, z2 ) ); }
 
    static double sqrDistance2D( double x1, double y1, double x2, double y2 ) SIP_HOLDGIL {return ( x1 - x2 ) * ( x1 - x2 ) + ( y1 - y2 ) * ( y1 - y2 ); }
 
    static double distance2D( double x1, double y1, double x2, double y2 ) SIP_HOLDGIL {return std::sqrt( sqrDistance2D( x1, y1, x2, y2 ) ); }
 
    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_HOLDGIL;
 
    static int leftOfLine( const double x, const double y, const double x1, const double y1, const double x2, const double y2 ) SIP_HOLDGIL;
 
    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;
 
    static void perpendicularOffsetPointAlongSegment( double x1, double y1, double x2, double y2, double proportion, double offset, double *x SIP_OUT, double *y SIP_OUT );
 
    static double ccwAngle( double dy, double dx ) SIP_HOLDGIL;
 
    static void circleCenterRadius( double x1, double y1, double x2, double y2, double x3, double y3, double &radius SIP_OUT,
                                    double &centerX SIP_OUT, double &centerY SIP_OUT ) SIP_HOLDGIL;
 
    static bool circleClockwise( double angle1, double angle2, double angle3 ) SIP_HOLDGIL;
 
    static bool circleAngleBetween( double angle, double angle1, double angle2, bool clockwise ) SIP_HOLDGIL;
 
    static bool angleOnCircle( double angle, double angle1, double angle2, double angle3 ) SIP_HOLDGIL;
 
    static double circleLength( double x1, double y1, double x2, double y2, double x3, double y3 ) SIP_HOLDGIL;
 
    static double sweepAngle( double centerX, double centerY, double x1, double y1, double x2, double y2, double x3, double y3 ) SIP_HOLDGIL;
 
    static double interpolateArcValue( double angle, double a1, double a2, double a3, double zm1, double zm2, double zm3 ) SIP_HOLDGIL;
 
    static double normalizedAngle( double angle ) SIP_HOLDGIL;
 
    static double lineAngle( double x1, double y1, double x2, double y2 ) SIP_HOLDGIL;
 
    static double angleBetweenThreePoints( double x1, double y1, double x2, double y2,
                                           double x3, double y3 ) SIP_HOLDGIL;
 
    static double linePerpendicularAngle( double x1, double y1, double x2, double y2 ) SIP_HOLDGIL;
 
    static double averageAngle( double x1, double y1, double x2, double y2, double x3, double y3 ) SIP_HOLDGIL;
 
    static double averageAngle( double a1, double a2 ) SIP_HOLDGIL;
 
    static int closestSideOfRectangle( double right, double bottom, double left, double top, double x, double y );
 
    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;
 
    static double skewLinesDistance( const QgsVector3D &P1, const QgsVector3D &P12,
                                     const QgsVector3D &P2, const QgsVector3D &P22 ) SIP_HOLDGIL;
 
    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;
 
    static bool linesIntersection3D( const QgsVector3D &La1, const QgsVector3D &La2,
                                     const QgsVector3D &Lb1, const QgsVector3D &Lb2,
                                     QgsVector3D &intersection SIP_OUT ) SIP_HOLDGIL;
 
    static double triangleArea( double aX, double aY, double bX, double bY, double cX, double cY ) SIP_HOLDGIL;
 
    static double pointFractionAlongLine( double x1, double y1, double x2, double y2, double px, double py );
 
    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;
 
    static bool pointsAreCollinear( double x1, double y1, double x2, double y2, double x3, double y3, double epsilon );
 
    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;
 
    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;
 
 
    static bool lineIntersection( double p1x, double p1y, QgsVector v1, double p2x, double p2y, QgsVector v2, double &intersectionX SIP_OUT, double &intersectionY SIP_OUT ) SIP_HOLDGIL;
 
    static bool segmentIntersection( double p1x, double p1y, double p2x, double p2y, double q1x, double q1y, double q2x, double q2y, double &intersectionPointX SIP_OUT, double &intersectionPointY SIP_OUT, bool &isIntersection SIP_OUT, double tolerance = 1e-8, bool acceptImproperIntersection = false ) SIP_HOLDGIL;
 
    static void project( double aX, double aY, double aZ, double distance, double azimuth, double inclination, double &resultX SIP_OUT, double &resultY SIP_OUT, double &resultZ SIP_OUT ) SIP_HOLDGIL;
 
    static double azimuth( double x1, double y1, double x2, double y2 ) SIP_HOLDGIL;
 
#ifndef SIP_RUN
 
    template<typename T, typename... Args>
    static bool fuzzyEqual( T epsilon, const Args &... args ) noexcept
    {
      static_assert( ( sizeof...( args ) % 2 == 0 || sizeof...( args ) != 0 ), "The number of arguments must be greater than 0 and even" );
      constexpr size_t numArgs = sizeof...( args );
      bool result = true;
      T values[] = {static_cast<T>( args )...};
 
      for ( size_t i = 0; i < numArgs / 2; ++i )
      {
        result = result && qgsNumberNear( values[i], values[i + numArgs / 2], epsilon );
      }
 
      return result;
    }
 
    template<typename T, typename... Args>
    static bool fuzzyDistanceEqual( T epsilon, const Args &... args ) noexcept
    {
      static_assert( ( sizeof...( args ) % 2 == 0 || sizeof...( args ) >= 4 ), "The number of arguments must be greater than 4 and even" );
      constexpr size_t numArgs = sizeof...( args );
      const T squaredEpsilon = epsilon * epsilon;
      T sum = 0;
 
      T values[] = {static_cast<T>( args )...};
 
      for ( size_t i = 0; i < numArgs / 2; ++i )
      {
        const T diff = values[i] - values[i + numArgs / 2];
        sum += diff * diff;
      }
 
      return sum < squaredEpsilon;
    }
#endif
 
};