qgsbox3d.h

Go to the documentation of this file.

/***************************************************************************
                             qgsbox3d.h
                             ----------
    begin                : April 2017
    copyright            : (C) 2017 by Nyall Dawson
    email                : nyall dot dawson at gmail 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.                                   *
 *                                                                         *
 ***************************************************************************/
 
#ifndef QGSBOX3D_H
#define QGSBOX3D_H
 
#include "qgis_core.h"
#include "qgsrectangle.h"
 
#include <QVector3D>
 
#include "qgspoint.h"
 
class QgsVector3D;
 
class CORE_EXPORT QgsBox3D
{
    Q_GADGET
 
  public:
 
#ifndef SIP_RUN
    QgsBox3D( double xmin = std::numeric_limits<double>::quiet_NaN(), double ymin = std::numeric_limits<double>::quiet_NaN(), double zmin = std::numeric_limits<double>::quiet_NaN(),
              double xmax = std::numeric_limits<double>::quiet_NaN(), double ymax = std::numeric_limits<double>::quiet_NaN(), double zmax = std::numeric_limits<double>::quiet_NaN(),
              bool normalize = true );
 
    QgsBox3D( const QgsPoint &p1, const QgsPoint &p2, bool normalize = true );
 
    QgsBox3D( const QgsVector3D &corner1, const QgsVector3D &corner2, bool normalize = true );
 
    QgsBox3D( const QgsRectangle &rect,
              double zMin = std::numeric_limits<double>::quiet_NaN(), double zMax = std::numeric_limits<double>::quiet_NaN(),
              bool normalize = true );
 
#else
    QgsBox3D( SIP_PYOBJECT x SIP_TYPEHINT( Optional[Union[QgsPoint, QgsVector3D, QgsRectangle, float]] ) = Py_None, SIP_PYOBJECT y SIP_TYPEHINT( Optional[QgsPoint, QgsVector3D, float] ) = Py_None, SIP_PYOBJECT z SIP_TYPEHINT( Optional[Union[bool, float]] ) = Py_None, SIP_PYOBJECT x2 SIP_TYPEHINT( Optional[Union[bool, float]] ) = Py_None, SIP_PYOBJECT y2 SIP_TYPEHINT( Optional[float] ) = Py_None, SIP_PYOBJECT z2 SIP_TYPEHINT( Optional[float] ) = Py_None, SIP_PYOBJECT n SIP_TYPEHINT( Optional[bool] ) = Py_None ) [( double x = 0.0, double y = 0.0, double z = 0.0, double x2 = 0.0, double y2 = 0.0, double z2 = 0.0, bool n = true )];
    % MethodCode
    if ( sipCanConvertToType( a0, sipType_QgsRectangle, SIP_NOT_NONE ) && a4 == Py_None && a5 == Py_None && a6 == Py_None )
    {
      int state;
      sipIsErr = 0;
 
      QgsRectangle *p = reinterpret_cast<QgsRectangle *>( sipConvertToType( a0, sipType_QgsRectangle, 0, SIP_NOT_NONE, &state, &sipIsErr ) );
      if ( !sipIsErr )
      {
        double z1 = a1 == Py_None ? std::numeric_limits<double>::quiet_NaN() : PyFloat_AsDouble( a1 );
        double z2 = a2 == Py_None ? std::numeric_limits<double>::quiet_NaN() : PyFloat_AsDouble( a2 );
        bool n = a3 == Py_None ? true : PyObject_IsTrue( a3 );
 
        sipCpp = new QgsBox3D( *p, z1, z2, n );
      }
      sipReleaseType( p, sipType_QgsRectangle, state );
    }
    else if ( sipCanConvertToType( a0, sipType_QgsPoint, SIP_NOT_NONE ) && sipCanConvertToType( a1, sipType_QgsPoint, SIP_NOT_NONE ) && a3 == Py_None && a4 == Py_None && a5 == Py_None && a6 == Py_None )
    {
      int state;
      sipIsErr = 0;
 
      QgsPoint *pt1 = reinterpret_cast<QgsPoint *>( sipConvertToType( a0, sipType_QgsPoint, 0, SIP_NOT_NONE, &state, &sipIsErr ) );
      if ( !sipIsErr )
      {
        QgsPoint *pt2 = reinterpret_cast<QgsPoint *>( sipConvertToType( a1, sipType_QgsPoint, 0, SIP_NOT_NONE, &state, &sipIsErr ) );
        if ( !sipIsErr )
        {
          bool n = a2 == Py_None ? true : PyObject_IsTrue( a2 );
          sipCpp = new QgsBox3D( *pt1, *pt2, n );
        }
        sipReleaseType( pt2, sipType_QgsPoint, state );
      }
      sipReleaseType( pt1, sipType_QgsPoint, state );
    }
    else if ( sipCanConvertToType( a0, sipType_QgsVector3D, SIP_NOT_NONE ) && sipCanConvertToType( a1, sipType_QgsVector3D, SIP_NOT_NONE ) && a3 == Py_None && a4 == Py_None && a5 == Py_None && a6 == Py_None )
    {
      int state;
      sipIsErr = 0;
 
      QgsVector3D *corner1 = reinterpret_cast<QgsVector3D *>( sipConvertToType( a0, sipType_QgsVector3D, 0, SIP_NOT_NONE, &state, &sipIsErr ) );
      if ( !sipIsErr )
      {
        QgsVector3D *corner2 = reinterpret_cast<QgsVector3D *>( sipConvertToType( a1, sipType_QgsVector3D, 0, SIP_NOT_NONE, &state, &sipIsErr ) );
        if ( !sipIsErr )
        {
          bool n = a2 == Py_None ? true : PyObject_IsTrue( a2 );
          sipCpp = new QgsBox3D( *corner1, *corner2, n );
        }
        sipReleaseType( corner2, sipType_QgsVector3D, state );
      }
      sipReleaseType( corner1, sipType_QgsVector3D, state );
    }
    else if (
      ( a0 == Py_None || PyFloat_AsDouble( a0 ) != -1.0 || !PyErr_Occurred() ) &&
      ( a1 == Py_None || PyFloat_AsDouble( a1 ) != -1.0 || !PyErr_Occurred() ) &&
      ( a2 == Py_None || PyFloat_AsDouble( a2 ) != -1.0 || !PyErr_Occurred() ) &&
      ( a3 == Py_None || PyFloat_AsDouble( a3 ) != -1.0 || !PyErr_Occurred() ) &&
      ( a4 == Py_None || PyFloat_AsDouble( a3 ) != -1.0 || !PyErr_Occurred() ) &&
      ( a5 == Py_None || PyFloat_AsDouble( a3 ) != -1.0 || !PyErr_Occurred() ) &&
      ( a6 == Py_None || PyFloat_AsDouble( a3 ) != -1.0 || !PyErr_Occurred() ) )
    {
      double x1 = a0 == Py_None ? std::numeric_limits<double>::quiet_NaN() : PyFloat_AsDouble( a0 );
      double y1 = a1 == Py_None ? std::numeric_limits<double>::quiet_NaN() : PyFloat_AsDouble( a1 );
      double z1 = a2 == Py_None ? std::numeric_limits<double>::quiet_NaN() : PyFloat_AsDouble( a2 );
      double x2 = a3 == Py_None ? std::numeric_limits<double>::quiet_NaN() : PyFloat_AsDouble( a3 );
      double y2 = a4 == Py_None ? std::numeric_limits<double>::quiet_NaN() : PyFloat_AsDouble( a4 );
      double z2 = a5 == Py_None ? std::numeric_limits<double>::quiet_NaN() : PyFloat_AsDouble( a5 );
      bool n = a6 == Py_None ? true : PyObject_IsTrue( a6 );
      sipCpp = new QgsBox3D( x1, y1, z1, x2, y2, z2, n );
    }
    else // Invalid ctor arguments
    {
      PyErr_SetString( PyExc_TypeError, QStringLiteral( "Invalid type in constructor arguments." ).toUtf8().constData() );
      sipIsErr = 1;
    }
    % End
#endif
 
    void set( double xMin, double yMin, double zMin, double xMax, double yMax, double zMax, bool normalize = true )
    {
      mBounds2d.set( xMin, yMin, xMax, yMax, false );
      mZmin = zMin;
      mZmax = zMax;
      if ( normalize )
      {
        QgsBox3D::normalize();
      }
    }
 
    void setXMinimum( double x ) SIP_HOLDGIL;
 
    void setXMaximum( double x ) SIP_HOLDGIL;
 
    double xMinimum() const SIP_HOLDGIL { return mBounds2d.xMinimum(); }
 
    double xMaximum() const SIP_HOLDGIL { return mBounds2d.xMaximum(); }
 
    void setYMinimum( double y ) SIP_HOLDGIL;
 
    void setYMaximum( double y ) SIP_HOLDGIL;
 
    double yMinimum() const SIP_HOLDGIL { return mBounds2d.yMinimum(); }
 
    double yMaximum() const SIP_HOLDGIL { return mBounds2d.yMaximum(); }
 
    void setZMinimum( double z ) SIP_HOLDGIL;
 
    void setZMaximum( double z ) SIP_HOLDGIL;
 
    double zMinimum() const SIP_HOLDGIL { return mZmin; }
 
    double zMaximum() const SIP_HOLDGIL { return mZmax; }
 
    void setNull() SIP_HOLDGIL;
 
    void normalize() SIP_HOLDGIL;
 
    double width() const SIP_HOLDGIL { return mBounds2d.width(); }
 
    double height() const SIP_HOLDGIL { return mBounds2d.height(); }
 
    double depth() const SIP_HOLDGIL { return mZmax - mZmin; }
 
    QgsVector3D center() const SIP_HOLDGIL;
 
    double area() const SIP_HOLDGIL { return mBounds2d.area(); }
 
    double volume() const SIP_HOLDGIL { return mBounds2d.area() * ( mZmax - mZmin ); }
 
    QgsBox3D intersect( const QgsBox3D &other ) const SIP_HOLDGIL;
 
    bool is2d() const SIP_HOLDGIL;
 
    bool is3D() const SIP_HOLDGIL;
 
    bool intersects( const QgsBox3D &other ) const SIP_HOLDGIL;
 
    bool contains( const QgsBox3D &other ) const SIP_HOLDGIL;
 
    bool contains( const QgsPoint &point ) const SIP_HOLDGIL;
 
    bool contains( double x, double y, double z ) const SIP_HOLDGIL;
 
    void combineWith( const QgsBox3D &box ) SIP_HOLDGIL;
 
    void combineWith( double x, double y, double z ) SIP_HOLDGIL;
 
    QgsRectangle toRectangle() const SIP_HOLDGIL { return mBounds2d; }
 
    Q_DECL_DEPRECATED double distanceTo( const QVector3D &point ) const SIP_DEPRECATED { return distanceTo( QgsVector3D( point ) ); }
 
    double distanceTo( const QgsVector3D &point ) const SIP_HOLDGIL;
 
    bool operator==( const QgsBox3D &other ) const SIP_HOLDGIL;
 
    void scale( double scaleFactor, const QgsPoint &center = QgsPoint() ) SIP_HOLDGIL;
 
    void scale( double scaleFactor, double centerX, double centerY, double centerZ ) SIP_HOLDGIL;
 
    void grow( double delta );
 
    bool isNull() const SIP_HOLDGIL;
 
    bool isEmpty() const SIP_HOLDGIL;
 
    QString toString( int precision = 16 ) const SIP_HOLDGIL;
 
    QVector< QgsVector3D > corners() const SIP_HOLDGIL;
 
    QgsBox3D operator-( const QgsVector3D &v ) const SIP_HOLDGIL;
 
    QgsBox3D operator+( const QgsVector3D &v ) const SIP_HOLDGIL;
 
    QgsBox3D &operator-=( const QgsVector3D &v ) SIP_HOLDGIL;
 
    QgsBox3D &operator+=( const QgsVector3D &v ) SIP_HOLDGIL;
 
 
#ifdef SIP_RUN
    SIP_PYOBJECT __repr__();
    % MethodCode
    QString str = QStringLiteral( "<QgsBox3D(%1, %2, %3, %4, %5, %6)>" )
                  .arg( sipCpp->xMinimum() )
                  .arg( sipCpp->yMinimum() )
                  .arg( sipCpp->zMinimum() )
                  .arg( sipCpp->xMaximum() )
                  .arg( sipCpp->yMaximum() )
                  .arg( sipCpp->zMaximum() );
    sipRes = PyUnicode_FromString( str.toUtf8().constData() );
    % End
#endif
 
  private:
 
    QgsRectangle mBounds2d;
    double mZmin = std::numeric_limits<double>::quiet_NaN();
    double mZmax = std::numeric_limits<double>::quiet_NaN();
 
};
 
#endif // QGSBOX3D_H