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 <iterator>
 
#include "qgis_core.h"
#include "qgis_sip.h"
#include "qgsvector.h"
#include "qgsvector3d.h"

class CORE_EXPORT QgsGeometryUtilsBase
{
  public:
    // clang-format off
    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 ); }
    // clang-format on

    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 sqrDistance2D( QPointF point1, QPointF point2 ) SIP_HOLDGIL {return sqrDistance2D( point1.x(), point1.y(), point2.x(), point2.y() ); }

    static double distance2D( QPointF point1, QPointF point2 ) SIP_HOLDGIL {return distance2D( point1.x(), point1.y(), point2.x(), point2.y() );}

    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 interpolatePointOnCubicBezier(
      double p0x, double p0y, double p0z, double p0m,
      double p1x, double p1y, double p1z, double p1m,
      double p2x, double p2y, double p2z, double p2m,
      double p3x, double p3y, double p3z, double p3m,
      double t, bool hasZ, bool hasM,
      double &outX, double &outY, double &outZ, double &outM ) 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 calculateArcLength( double centerX, double centerY, double radius,
                                      double x1, double y1, double x2, double y2,
                                      double x3, double y3, int fromVertex, int toVertex ) 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 points3DAreCollinear( double x1, double y1, double z1, double x2, double y2, double z2, double x3, double y3, double z3, 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 intersectionPointOfLinesByBearing( double x1, double y1, double bearing1,
        double x2, double y2, double bearing2,
        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;
    }

    static double maximumFilletRadius( const double segment1StartX, const double segment1StartY, const double segment1EndX, const double segment1EndY, const double segment2StartX, const double segment2StartY, const double segment2EndX, const double segment2EndY, double epsilon = 1e-8 ) SIP_HOLDGIL;

    static bool createChamfer( const double segment1StartX, const double segment1StartY, const double segment1EndX, const double segment1EndY,
                               const double segment2StartX, const double segment2StartY, const double segment2EndX, const double segment2EndY,
                               const double distance1, const double distance2,
                               double &chamferStartX, double &chamferStartY,
                               double &chamferEndX, double &chamferEndY,
                               double *trim1StartX = nullptr, double *trim1StartY = nullptr,
                               double *trim1EndX = nullptr, double *trim1EndY = nullptr,
                               double *trim2StartX = nullptr, double *trim2StartY = nullptr,
                               double *trim2EndX = nullptr, double *trim2EndY = nullptr,
                               const double epsilon = 1e-8 );

    static bool createFillet( const double segment1StartX, const double segment1StartY, const double segment1EndX, const double segment1EndY,
                              const double segment2StartX, const double segment2StartY, const double segment2EndX, const double segment2EndY,
                              const double radius,
                              double *filletPointsX, double *filletPointsY,
                              double *trim1StartX = nullptr, double *trim1StartY = nullptr,
                              double *trim1EndX = nullptr, double *trim1EndY = nullptr,
                              double *trim2StartX = nullptr, double *trim2StartY = nullptr,
                              double *trim2EndX = nullptr, double *trim2EndY = nullptr,
                              const double epsilon = 1e-8 );
#endif
};