qgsrenderchecker.h

Go to the documentation of this file.

/***************************************************************************
     qgsrenderchecker.h - check maprender output against an expected image
                     --------------------------------------
               Date                 : 18 Jan 2008
               Copyright            : (C) 2008 by Tim Sutton
               email                : tim  @ linfiniti.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 QGSRENDERCHECKER_H
#define QGSRENDERCHECKER_H
 
#include "qgis_core.h"
#include "qgis_sip.h"
#include "qgsdartmeasurement.h"
#include "qgslogger.h"
#include "qgsmapsettings.h"
 
#include <QDir>
#include <QList>
#include <QRegularExpression>
#include <QString>
 
using namespace Qt::StringLiterals;
 
class QImage;
 
#define DUMP_BASE64_IMAGES 0

class CORE_EXPORT QgsRenderChecker
{
    Q_GADGET
 
  public:

    QgsRenderChecker();

    static QDir testReportDir();

    static bool shouldGenerateReport();

    QString controlImagePath() const;

    void setControlImagePath( const QString &path );

    QString report( bool ignoreSuccess = true ) const;

    QString markdownReport( bool ignoreSuccess = true ) const;

    float matchPercent() const
    {
      return static_cast<float>( mMismatchCount ) /
             static_cast<float>( mMatchTarget ) * 100;
    }

    unsigned int mismatchCount() const { return mMismatchCount; }

    unsigned int matchTarget() const { return mMatchTarget; }

    int elapsedTime() const { return mElapsedTime; }
    void setElapsedTimeTarget( int target ) { mElapsedTimeTarget = target; }

    void setControlName( const QString &name );

    void setControlExtension( const QString &extension ) { mControlExtension = extension; }

    void setControlPathPrefix( const QString &name ) { mControlPathPrefix = name + '/'; }
 
    void setControlPathSuffix( const QString &name );

    QString imageToHash( const QString &imageFile );

    void setRenderedImage( const QString &imageFileName ) { mRenderedImageFile = imageFileName; }

    void setExpectFail( bool expectFail ) { mExpectFail = expectFail; }

    QString renderedImage() const { return mRenderedImageFile; }
 
    void setMapSettings( const QgsMapSettings &mapSettings );

    void setColorTolerance( unsigned int colorTolerance ) { mColorTolerance = colorTolerance; }

    void setSizeTolerance( int xTolerance, int yTolerance ) { mMaxSizeDifferenceX = xTolerance; mMaxSizeDifferenceY = yTolerance; }

    enum class Flag : int SIP_ENUM_BASETYPE( IntFlag )
    {
      AvoidExportingRenderedImage = 1 << 0, 
      Silent = 1 << 1, 
    };
    Q_ENUM( Flag )
 
    
    Q_DECLARE_FLAGS( Flags, Flag )
    Q_FLAG( Flags )

    bool runTest( const QString &testName, unsigned int mismatchCount = 0, QgsRenderChecker::Flags flags = QgsRenderChecker::Flags() );

    bool compareImages( const QString &testName, unsigned int mismatchCount = 0, const QString &renderedImageFile = QString(), QgsRenderChecker::Flags flags = QgsRenderChecker::Flags() );

    bool compareImages( const QString &testName, const QString &referenceImageFile, const QString &renderedImageFile, unsigned int mismatchCount = 0, QgsRenderChecker::Flags flags = QgsRenderChecker::Flags() );

    Q_DECL_DEPRECATED bool isKnownAnomaly( const QString &diffImageFile ) SIP_DEPRECATED;

    static void drawBackground( QImage *image );

    QString expectedImageFile() const { return mExpectedImageFile; }

    void enableDashBuffering( bool enable ) { mBufferDashMessages = enable; }

    QVector<QgsDartMeasurement> dartMeasurements() const { return mDashMessages; }

    static QString sourcePath();
 
  protected:
    QString mReport;
    QString mMarkdownReport;
    unsigned int mMatchTarget = 0;
    int mElapsedTime = 0;
    QImage mRenderedImage;
    QString mRenderedImageFile;
    QString mExpectedImageFile;
 
  private:
    void emitDashMessage( const QgsDartMeasurement &dashMessage );
    void emitDashMessage( const QString &name, QgsDartMeasurement::Type type, const QString &value );
 
#if DUMP_BASE64_IMAGES
    void dumpRenderedImageAsBase64();
#endif
 
    void performPostTestActions( Flags flags );
 
    bool mResult = false;
    bool mExpectFail = false;
 
    QString mBasePath;
 
    QString mControlName;
    unsigned int mMismatchCount = 0;
    unsigned int mColorTolerance = 0;
    int mMaxSizeDifferenceX = 0;
    int mMaxSizeDifferenceY = 0;
    int mElapsedTimeTarget = 0;
    QgsMapSettings mMapSettings;
    QString mControlExtension = u"png"_s;
    QString mControlPathPrefix;
    QString mControlPathSuffix;
    bool mIsCiRun = false;
    QVector<QgsDartMeasurement> mDashMessages;
    bool mBufferDashMessages = false;
    QString mDiffImageFile;
 
    friend class QgsMultiRenderChecker;
};
 
Q_DECLARE_OPERATORS_FOR_FLAGS( QgsRenderChecker::Flags )
 

 
inline bool compareWkt( const QString &a, const QString &b, double tolerance = 0.000001 )
{
  QgsDebugMsgLevel( u"a:%1 b:%2 tol:%3"_s.arg( a, b ).arg( tolerance ), 2 );
  const thread_local QRegularExpression re( "-?\\d+(?:\\.\\d+)?(?:[eE]\\d+)?" );
 
  QString a0( a ), b0( b );
  a0.replace( re, u"#"_s );
  b0.replace( re, u"#"_s );
 
  QgsDebugMsgLevel( u"a0:%1 b0:%2"_s.arg( a0, b0 ), 2 );
 
  if ( a0 != b0 )
    return false;
 
  QList<double> al, bl;
 
  int pos = 0;
  QRegularExpressionMatch match = re.match( a );
  while ( match.hasMatch() )
  {
    al << match.captured( 0 ).toDouble();
    pos = match.capturedStart( 0 ) + match.capturedLength( 0 );
    match = re.match( a, pos );
  }
  match = re.match( b );
  while ( match.hasMatch() )
  {
    bl << match.captured( 0 ).toDouble();
    pos = match.capturedStart( 0 ) + match.capturedLength( 0 );
    match = re.match( b, pos );
  }
 
  if ( al.size() != bl.size() )
    return false;
 
  for ( int i = 0; i < al.size(); i++ )
  {
    if ( !qgsDoubleNear( al[i], bl[i], tolerance ) )
      return false;
  }
 
  return true;
}
 
#endif