qgscircle.h

Go to the documentation of this file.

/***************************************************************************
                         qgscircle.h
                         --------------
    begin                : March 2017
    copyright            : (C) 2017 by Loïc Bartoletti
    email                : lituus at free dot fr
 ***************************************************************************/
 
/***************************************************************************
 *                                                                         *
 *   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 QGSCIRCLE_H
#define QGSCIRCLE_H
 
#include <cmath>
 
#include "qgis_core.h"
#include "qgscircularstring.h"
#include "qgsellipse.h"
#include "qgspolygon.h"
#include "qgsrectangle.h"
 
#include <QString>
 
using namespace Qt::StringLiterals;
 
class QgsPoint;

 
 
class CORE_EXPORT QgsCircle : public QgsEllipse
{
  public:
    QgsCircle();

    QgsCircle( const QgsPoint &center, double radius, double azimuth = 0 ) SIP_HOLDGIL;

    static QgsCircle from2Points( const QgsPoint &pt1, const QgsPoint &pt2 ) SIP_HOLDGIL;

    static QgsCircle from3Points( const QgsPoint &pt1, const QgsPoint &pt2, const QgsPoint &pt3, double epsilon = 1E-8 ) SIP_HOLDGIL;

    static QgsCircle fromCenterDiameter( const QgsPoint &center, double diameter, double azimuth = 0 ) SIP_HOLDGIL;
 

    static QgsCircle fromCenterPoint( const QgsPoint &center, const QgsPoint &pt1 ) SIP_HOLDGIL; // cppcheck-suppress duplInheritedMember
 

    static QgsCircle from3Tangents( const QgsPoint &pt1_tg1, const QgsPoint &pt2_tg1, const QgsPoint &pt1_tg2, const QgsPoint &pt2_tg2, const QgsPoint &pt1_tg3, const QgsPoint &pt2_tg3, double epsilon = 1E-8, const QgsPoint &pos = QgsPoint() ) SIP_HOLDGIL;

    static QVector<QgsCircle> from3TangentsMulti( const QgsPoint &pt1_tg1, const QgsPoint &pt2_tg1, const QgsPoint &pt1_tg2, const QgsPoint &pt2_tg2, const QgsPoint &pt1_tg3, const QgsPoint &pt2_tg3, double epsilon = 1E-8, const QgsPoint &pos = QgsPoint() ) SIP_HOLDGIL;

    static QgsCircle fromExtent( const QgsPoint &pt1, const QgsPoint &pt2 ) SIP_HOLDGIL; // cppcheck-suppress duplInheritedMember

    static QgsCircle minimalCircleFrom3Points( const QgsPoint &pt1, const QgsPoint &pt2, const QgsPoint &pt3, double epsilon = 1E-8 ) SIP_HOLDGIL;

    int intersections( const QgsCircle &other, QgsPoint &intersection1 SIP_OUT, QgsPoint &intersection2 SIP_OUT, bool useZ = false ) const;

    bool tangentToPoint( const QgsPointXY &p, QgsPointXY &pt1 SIP_OUT, QgsPointXY &pt2 SIP_OUT ) const;

    int outerTangents( const QgsCircle &other, QgsPointXY &line1P1 SIP_OUT, QgsPointXY &line1P2 SIP_OUT, QgsPointXY &line2P1 SIP_OUT, QgsPointXY &line2P2 SIP_OUT ) const;

    int innerTangents( const QgsCircle &other, QgsPointXY &line1P1 SIP_OUT, QgsPointXY &line1P2 SIP_OUT, QgsPointXY &line2P1 SIP_OUT, QgsPointXY &line2P2 SIP_OUT ) const;
 
    double area() const override SIP_HOLDGIL;
    double perimeter() const override SIP_HOLDGIL;
 
    //inherited
    // void setAzimuth(const double azimuth);
    // double azimuth() const {return mAzimuth; }
 

    void setSemiMajorAxis( double semiMajorAxis ) override SIP_HOLDGIL;

    void setSemiMinorAxis( double semiMinorAxis ) override SIP_HOLDGIL;

    double radius() const SIP_HOLDGIL { return mSemiMajorAxis; }
    void setRadius( double radius ) SIP_HOLDGIL
    {
      mSemiMajorAxis = std::fabs( radius );
      mSemiMinorAxis = mSemiMajorAxis;
    }

    QVector<QgsPoint> northQuadrant() const SIP_FACTORY;

    QgsCircularString *toCircularString( bool oriented = false ) const;

    bool contains( const QgsPoint &point, double epsilon = 1E-8 ) const;
 
    QgsRectangle boundingBox() const override;
 
    QString toString( int pointPrecision = 17, int radiusPrecision = 17, int azimuthPrecision = 2 ) const override;

    QDomElement asGml2( QDomDocument &doc, int precision = 17, const QString &ns = "gml", QgsAbstractGeometry::AxisOrder axisOrder = QgsAbstractGeometry::AxisOrder::XY ) const;

    QDomElement asGml3( QDomDocument &doc, int precision = 17, const QString &ns = "gml", QgsAbstractGeometry::AxisOrder axisOrder = QgsAbstractGeometry::AxisOrder::XY ) const;

    static int calculateSegments( double radius, double parameter, int minSegments, Qgis::SegmentCalculationMethod method );
 
 
#ifdef SIP_RUN
    SIP_PYOBJECT __repr__();
    % MethodCode
    QString str
      = u"<QgsCircle: %1>"_s.arg( sipCpp->toString() );
    sipRes = PyUnicode_FromString( str.toUtf8().constData() );
    % End
#endif
 
  private :

    static int calculateSegmentsStandard( double radius, double tolerance, int minSegments )
    {
      if ( tolerance >= radius )
      {
        return minSegments;
      }
 
      // Using the sagitta formula: s = r(1 - cos(θ/2))
      const double halfAngle = std::acos( 1.0 - tolerance / radius );
      const int segments = std::ceil( M_PI / halfAngle );
 
      return std::max( segments, minSegments );
    }

    static int calculateSegmentsAdaptive( double radius, double tolerance, int minSegments )
    {
      // Compute adaptive tolerance that varies with radius
      const double adaptiveTolerance = tolerance * std::sqrt( radius ) / std::log10( radius + 1.0 );
 
      if ( adaptiveTolerance >= radius )
      {
        return minSegments;
      }
 
      const double halfAngle = std::acos( 1.0 - adaptiveTolerance / radius );
      const int segments = std::ceil( M_PI / halfAngle );
 
      return std::max( segments, minSegments );
    }

    static int calculateSegmentsByAreaError( double radius, double baseTolerance, int minSegments )
    {
      Q_UNUSED( radius );
      // Convert tolerance from percentage to decimal
      const double decimalTolerance = baseTolerance / 100.0;
 
      // Avoid division by zero or extremely small tolerance
      const double tolerance = std::max( decimalTolerance, 1.0e-8 );
 
      // Calculate required segments using the area error formula
      const double requiredSegments = M_PI * std::sqrt( 2.0 / ( 3.0 * tolerance ) );
 
      return std::max( static_cast<int>( std::ceil( requiredSegments ) ), minSegments );
    }

    static int calculateSegmentsByConstant( double radius, double constant, int minSegments )
    {
      return std::max( minSegments, static_cast<int>( std::ceil( constant * radius ) ) );
    }
};
 
#endif // QGSCIRCLE_H