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_core.h"
#include "qgis_sip.h"
 
#include "qgis.h"
#include "qgsrectangle.h"
#include "qgscoordinatereferencesystem.h"
#include "qgsreadwritecontext.h"
 
class QgsRenderContext;
 
class CORE_EXPORT QgsTileXYZ
{
  public:
    QgsTileXYZ( int tc = -1, int tr = -1, int tz = -1 )
      : mColumn( tc ), mRow( tr ), mZoomLevel( tz )
    {
    }
    QgsTileXYZ( int tc = -1, int tr = -1, int tz = -1 ) {…}
 
    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;
};
class CORE_EXPORT QgsTileXYZ {…};
 
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 );
}
CORE_EXPORT inline uint qHash( QgsTileXYZ id ) SIP_SKIP {…}
 
 
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 ) {}
    QgsTileRange( int c1 = -1, int c2 = -1, int r1 = -1, int r2 = -1 ) {…}
 
    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; }
 
  private:
    int mStartColumn = -1;
    int mEndColumn = -1;
    int mStartRow = -1;
    int mEndRow = -1;
};
class CORE_EXPORT QgsTileRange {…};
 
 
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 QgsTileMatrix {…};
 
 
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;
};
class CORE_EXPORT QgsTileMatrixSet {…};
 
#endif // QGSTILES_H