qgsrectangle.cpp

Go to the documentation of this file.

/***************************************************************************
                          qgsrectangle.cpp  -  description
                             -------------------
    begin                : Sat Jun 22 2002
    copyright            : (C) 2002 by Gary E.Sherman
    email                : sherman at mrcc.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.                                   *
 *                                                                         *
 ***************************************************************************/
 
#include "qgsrectangle.h"
 
#include <algorithm>
#include <cmath>
#include <limits>
 
#include "qgsbox3d.h"
#include "qgsgeometry.h"
#include "qgslinestring.h"
#include "qgslogger.h"
#include "qgspointxy.h"
#include "qgspolygon.h"
 
#include <QString>
#include <QTextStream>
#include <QTransform>
 
#include "moc_qgsrectangle.cpp"
 
using namespace Qt::StringLiterals;
 
QgsRectangle QgsRectangle::fromWkt( const QString &wkt )
{
  const QgsGeometry geom = QgsGeometry::fromWkt( wkt );
  if ( geom.isEmpty() )
    return QgsRectangle();
 
  if ( const QgsPolygon *polygon = qgsgeometry_cast< const QgsPolygon * >( geom.constGet()->simplifiedTypeRef() ) )
  {
    if ( polygon->numInteriorRings() > 0 )
      return QgsRectangle();
 
    if ( const QgsLineString *exterior = qgsgeometry_cast< const QgsLineString * >( polygon->exteriorRing() ) )
    {
      if ( exterior->numPoints() == 5 && qgsDoubleNear( exterior->xAt( 0 ), exterior->xAt( 4 ) ) && qgsDoubleNear( exterior->yAt( 0 ), exterior->yAt( 4 ) ) && geom.isGeosValid() )
        return QgsRectangle( exterior->xAt( 0 ), exterior->yAt( 0 ), exterior->xAt( 2 ), exterior->yAt( 2 ) );
    }
  }
  return QgsRectangle();
}
 
QgsRectangle QgsRectangle::fromCenterAndSize( const QgsPointXY &center, double width, double height )
{
  const double xMin = center.x() - width / 2.0;
  const double xMax = xMin + width;
  const double yMin = center.y() - height / 2.0;
  const double yMax = yMin + height;
  return QgsRectangle( xMin, yMin, xMax, yMax );
}
 
QgsRectangle QgsRectangle::fromEdges( double left, double top, double right, double bottom )
{
  return QgsRectangle( left, bottom, right, top, false );
}
 
QgsRectangle QgsRectangle::scaled( double scaleFactor, const QgsPointXY *center ) const
{
  QgsRectangle scaledRect = QgsRectangle( *this );
  scaledRect.scale( scaleFactor, center );
  return scaledRect;
}
 
QgsRectangle QgsRectangle::operator-( const QgsVector v ) const
{
  const double xmin = mXmin - v.x();
  const double xmax = mXmax - v.x();
  const double ymin = mYmin - v.y();
  const double ymax = mYmax - v.y();
  return QgsRectangle( xmin, ymin, xmax, ymax );
}
 
QgsRectangle QgsRectangle::operator+( const QgsVector v ) const
{
  const double xmin = mXmin + v.x();
  const double xmax = mXmax + v.x();
  const double ymin = mYmin + v.y();
  const double ymax = mYmax + v.y();
  return QgsRectangle( xmin, ymin, xmax, ymax );
}
 
QgsRectangle &QgsRectangle::operator-=( const QgsVector v )
{
  mXmin -= v.x();
  mXmax -= v.x();
  mYmin -= v.y();
  mYmax -= v.y();
  return *this;
}
 
QgsRectangle &QgsRectangle::operator+=( const QgsVector v )
{
  mXmin += v.x();
  mXmax += v.x();
  mYmin += v.y();
  mYmax += v.y();
  return *this;
}
 
QString QgsRectangle::asWktCoordinates() const
{
  QString rep = qgsDoubleToString( mXmin ) + ' ' + qgsDoubleToString( mYmin ) + ", "_L1 + qgsDoubleToString( mXmax ) + ' ' + qgsDoubleToString( mYmax );
 
  return rep;
}
 
QString QgsRectangle::asWktPolygon() const
{
  if ( isNull() )
  {
    return u"Polygon EMPTY"_s;
  }
 
  return u"Polygon ((%1 %2, %3 %2, %3 %4, %1 %4, %1 %2))"_s.arg( qgsDoubleToString( mXmin ), qgsDoubleToString( mYmin ), qgsDoubleToString( mXmax ), qgsDoubleToString( mYmax ) );
}
 
QString QgsRectangle::toString( int precision ) const
{
  QString rep;
 
  if ( precision < 0 )
  {
    precision = 0;
    if ( ( width() < 10 || height() < 10 ) && ( width() > 0 && height() > 0 ) )
    {
      precision = static_cast<int>( std::ceil( -1.0 * std::log10( std::min( width(), height() ) ) ) ) + 1;
      // sanity check
      if ( precision > 20 )
        precision = 20;
    }
  }
 
  if ( isNull() )
    rep = u"Null"_s;
  else
    rep = u"%1,%2 : %3,%4"_s.arg( mXmin, 0, 'f', precision ).arg( mYmin, 0, 'f', precision ).arg( mXmax, 0, 'f', precision ).arg( mYmax, 0, 'f', precision );
 
  QgsDebugMsgLevel( u"Extents : %1"_s.arg( rep ), 4 );
 
  return rep;
}
 
QString QgsRectangle::asPolygon() const
{
  if ( isNull() )
  {
    return u"EMPTY"_s;
  }
 
  QString rep;
 
  QTextStream foo( &rep );
 
  foo.setRealNumberPrecision( 8 );
  foo.setRealNumberNotation( QTextStream::FixedNotation );
  // NOTE: a polygon isn't a polygon unless its closed. In the case of
  //       a rectangle, that means 5 points (last == first)
  foo << mXmin << ' ' << mYmin << ", " << mXmin << ' ' << mYmax << ", " << mXmax << ' ' << mYmax << ", " << mXmax << ' ' << mYmin << ", " << mXmin << ' ' << mYmin;
 
  return rep;
}
 
QgsBox3D QgsRectangle::toBox3d( double zMin, double zMax ) const
{
  return QgsBox3D( mXmin, mYmin, zMin, mXmax, mYmax, zMax );
}
 
std::pair<QgsRectangle, QgsRectangle> QgsRectangle::splitAtAntimeridian() const
{
  if ( isNull() )
    return { QgsRectangle(), QgsRectangle() };
 
  auto normalizeLongitude = []( double x ) {
    double res = std::fmod( x, 360 );
    if ( res > 180 )
      res -= 360;
    else if ( res < -180 )
      res += 360;
    return res;
  };
 
  if ( qgsDoubleNear( xMinimum(), xMaximum() ) )
  {
    // vertical slice
    const double x = normalizeLongitude( xMinimum() );
    return { QgsRectangle( x, yMinimum(), x, yMaximum() ), QgsRectangle() };
  }
  else if ( xMinimum() < xMaximum() )
  {
    // normalized rect
    const double x1 = normalizeLongitude( xMinimum() );
    const double x2 = normalizeLongitude( xMaximum() );
    if ( x1 < x2 )
    {
      return { QgsRectangle( x1, yMinimum(), x2, yMaximum() ), QgsRectangle() };
    }
    else
    {
      return { QgsRectangle( x1, yMinimum(), 180, yMaximum() ), QgsRectangle( -180, yMinimum(), x2, yMaximum() ) };
    }
  }
  else
  {
    // non-normalized
    const double x1 = normalizeLongitude( xMinimum() );
    const double x2 = normalizeLongitude( xMaximum() );
    return { QgsRectangle( x1, yMinimum(), 180, yMaximum() ), QgsRectangle( -180, yMinimum(), x2, yMaximum() ) };
  }
}
 
QgsRectangle QgsRectangle::snappedToGrid( double spacing ) const
{
  if ( isNull() )
    return *this;
 
  // helper function
  auto gridifyValue = []( double value, double spacing ) -> double {
    if ( spacing > 0 )
      return std::round( value / spacing ) * spacing;
    else
      return value;
  };
 
  return QgsRectangle( gridifyValue( mXmin, spacing ), gridifyValue( mYmin, spacing ), gridifyValue( mXmax, spacing ), gridifyValue( mYmax, spacing ) );
}
 
QDataStream &operator<<( QDataStream &out, const QgsRectangle &rectangle )
{
  out << rectangle.xMinimum() << rectangle.yMinimum() << rectangle.xMaximum() << rectangle.yMaximum();
  return out;
}
 
QDataStream &operator>>( QDataStream &in, QgsRectangle &rectangle )
{
  double xmin, ymin, xmax, ymax;
  in >> xmin >> ymin >> xmax >> ymax;
  rectangle.setXMinimum( xmin );
  rectangle.setYMinimum( ymin );
  rectangle.setXMaximum( xmax );
  rectangle.setYMaximum( ymax );
  return in;
}