qgstiles.h

Go to the documentation of this file.

/***************************************************************************
  qgstiles.h
  --------------------------------------
  Date                 : March 2020
  Copyright            : (C) 2020 by Martin Dobias
  Email                : wonder dot sk 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 QGSTILES_H
#define QGSTILES_H
 
#include "qgis.h"
#include "qgis_core.h"
#include "qgis_sip.h"
#include "qgscoordinatereferencesystem.h"
#include "qgsreadwritecontext.h"
#include "qgsrectangle.h"
 
class QgsRenderContext;

class CORE_EXPORT QgsTileXYZ
{
  public:
    QgsTileXYZ( int tc = -1, int tr = -1, int tz = -1 )
      : mColumn( tc ), mRow( tr ), mZoomLevel( tz )
    {
    }

    int column() const { return mColumn; }
    int row() const { return mRow; }
    int zoomLevel() const { return mZoomLevel; }

    QString toString() const { return QStringLiteral( "X=%1 Y=%2 Z=%3" ).arg( mColumn ).arg( mRow ).arg( mZoomLevel ); }
 
    bool operator==( const QgsTileXYZ &other ) const { return mColumn == other.mColumn && mRow == other.mRow && mZoomLevel == other.mZoomLevel; }
    bool operator!=( const QgsTileXYZ &other ) const { return !( *this == other ); }
 
#ifdef SIP_RUN
    SIP_PYOBJECT __repr__();
    % MethodCode
    const QString str = QStringLiteral( "<QgsTileXYZ: %1, %2, %3>" ).arg( sipCpp->column() ).arg( sipCpp->row() ).arg( sipCpp->zoomLevel() );
    sipRes = PyUnicode_FromString( str.toUtf8().constData() );
    % End
#endif
 
  private:
    int mColumn = -1;
    int mRow = -1;
    int mZoomLevel = -1;
};
 
#ifndef SIP_RUN
#if (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) || defined(__clang__)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wattributes"
#elif defined(_MSC_VER)
__pragma( warning( push ) )
__pragma( warning( disable: 4273 ) )
#endif
#endif

CORE_EXPORT inline uint qHash( QgsTileXYZ id ) SIP_SKIP
{
  const uint h1 = qHash( static_cast< quint64 >( id.column( ) ) );
  const uint h2 = qHash( static_cast< quint64 >( id.row() ) );
  const uint h3 = qHash( static_cast< quint64 >( id.zoomLevel() ) );
  return h1 ^ ( h2 << 1 ) ^ ( h3 << 2 );
}
 
#ifndef SIP_RUN
#if (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) || defined(__clang__)
#pragma GCC diagnostic pop
#elif defined(_MSC_VER)
__pragma( warning( pop ) )
#endif
#endif

class CORE_EXPORT QgsTileRange
{
  public:
    QgsTileRange( int c1 = -1, int c2 = -1, int r1 = -1, int r2 = -1 )
      : mStartColumn( c1 ), mEndColumn( c2 ), mStartRow( r1 ), mEndRow( r2 ) {}

    bool isValid() const { return mStartColumn >= 0 && mEndColumn >= 0 && mStartRow >= 0 && mEndRow >= 0; }

    int startColumn() const { return mStartColumn; }
    int endColumn() const { return mEndColumn; }
    int startRow() const { return mStartRow; }
    int endRow() const { return mEndRow; }

    int count() const { return isValid() ? ( mEndRow - mStartRow + 1 ) * ( mEndColumn - mStartColumn + 1 ) : 0; }
 
  private:
    int mStartColumn = -1;
    int mEndColumn = -1;
    int mStartRow = -1;
    int mEndRow = -1;
};
 

class CORE_EXPORT QgsTileMatrix
{
  public:

    static QgsTileMatrix fromWebMercator( int zoomLevel );

    static QgsTileMatrix fromCustomDef( int zoomLevel, const QgsCoordinateReferenceSystem &crs,
                                        const QgsPointXY &z0TopLeftPoint, double z0Dimension,
                                        int z0MatrixWidth = 1, int z0MatrixHeight = 1 );

    static QgsTileMatrix fromTileMatrix( int zoomLevel, const QgsTileMatrix &tileMatrix );

    QgsCoordinateReferenceSystem crs() const { return mCrs; }

    void setCrs( const QgsCoordinateReferenceSystem &crs ) { mCrs = crs;}

    int zoomLevel() const { return mZoomLevel; }

    void setZoomLevel( int level ) { mZoomLevel = level; }

    int matrixWidth() const { return mMatrixWidth; }

    int matrixHeight() const { return mMatrixHeight; }

    QgsRectangle extent() const { return mExtent; }

    double scale() const { return mScaleDenom; }

    void setScale( double scale ) { mScaleDenom = scale; }

    QgsRectangle tileExtent( QgsTileXYZ id ) const;

    QgsPointXY tileCenter( QgsTileXYZ id ) const;

    QgsTileRange tileRangeFromExtent( const QgsRectangle &mExtent ) const;

    QPointF mapToTileCoordinates( const QgsPointXY &mapPoint ) const;

    bool isRootTileMatrix() const { return mZoomLevel == 0; }
 
  private:
    QgsCoordinateReferenceSystem mCrs;
    int mZoomLevel = -1;
    int mMatrixWidth = 0;
    int mMatrixHeight = 0;
    QgsRectangle mExtent;
    double mScaleDenom = 0;
    double mTileXSpan = 0;
    double mTileYSpan = 0;
 
    friend class QgsTileMatrixSet;
};
 

class CORE_EXPORT QgsTileMatrixSet
{
 
  public:
 
    QgsTileMatrixSet();
 
    virtual ~QgsTileMatrixSet() = default;

    bool isEmpty() const;

    void addGoogleCrs84QuadTiles( int minimumZoom = 0, int maximumZoom = 14 );

    QgsTileMatrix tileMatrix( int zoom ) const;

    QgsTileMatrix rootMatrix() const;

    void setRootMatrix( const QgsTileMatrix &matrix );

    void addMatrix( const QgsTileMatrix &matrix );

    int minimumZoom() const;

    int maximumZoom() const;

    void dropMatricesOutsideZoomRange( int minimumZoom, int maximumZoom );

    Qgis::TileAvailability tileAvailability( QgsTileXYZ id ) const;

    QgsCoordinateReferenceSystem crs() const;

    double scaleToZoom( double scale ) const;

    int scaleToZoomLevel( double scale, bool clamp = true ) const;

    double scaleForRenderContext( const QgsRenderContext &context ) const;

    double calculateTileScaleForMap( double actualMapScale,
                                     const QgsCoordinateReferenceSystem &mapCrs,
                                     const QgsRectangle &mapExtent,
                                     const QSize mapSize,
                                     const double mapDpi
                                   ) const;

    virtual bool readXml( const QDomElement &element, QgsReadWriteContext &context );

    virtual QDomElement writeXml( QDomDocument &document, const QgsReadWriteContext &context ) const;

    Qgis::ScaleToTileZoomLevelMethod scaleToTileZoomMethod() const { return mScaleToTileZoomMethod; }

    void setScaleToTileZoomMethod( Qgis::ScaleToTileZoomLevelMethod method ) { mScaleToTileZoomMethod = method; }

    QVector<QgsTileXYZ> tilesInRange( QgsTileRange range, int zoomLevel ) const;
 
  protected:
    std::function< Qgis::TileAvailability( QgsTileXYZ id ) > mTileAvailabilityFunction;
    std::function< Qgis::TileAvailability( QgsTileXYZ id, QgsTileXYZ &replacement ) > mTileReplacementFunction;
 
    // Usually corresponds to zoom level 0, even if that zoom level is NOT present in the actual tile matrices for this set
    QgsTileMatrix mRootMatrix;
    QMap< int, QgsTileMatrix > mTileMatrices;
    Qgis::ScaleToTileZoomLevelMethod mScaleToTileZoomMethod = Qgis::ScaleToTileZoomLevelMethod::MapBox;
};
 
#endif // QGSTILES_H