qgsmeshtracerenderer.h

Go to the documentation of this file.

/***************************************************************************
                         qgsmeshtracerenderer.h
                         -------------------------
    begin                : November 2019
    copyright            : (C) 2019 by Vincent Cloarec
    email                : vcloarec 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 QGSMESHTRACERENDERER_H
#define QGSMESHTRACERENDERER_H
 
 
#include <QVector>
#include <QSize>
 
#include "qgis_core.h"
#include "qgis.h"
#include "qgstriangularmesh.h"
#include "qgsmeshlayer.h"
#include "qgsmeshvectorrenderer.h"
#include "qgsmaptopixel.h"
#include "qgsrendercontext.h"
 
class QgsMeshLayerInterpolator;
class QgsMeshLayerRendererFeedback;
 
 
#ifndef SIP_RUN
 
class QgsMeshVectorValueInterpolator
{
  public:
    QgsMeshVectorValueInterpolator(
      const QgsTriangularMesh &triangularMesh,
      const QgsMeshDataBlock &datasetVectorValues );
 
    QgsMeshVectorValueInterpolator(
      const QgsTriangularMesh &triangularMesh,
      const QgsMeshDataBlock &datasetVectorValues,
      const QgsMeshDataBlock &scalarActiveFaceFlagValues );
 
    QgsMeshVectorValueInterpolator( const QgsMeshVectorValueInterpolator &other );
 
    virtual QgsMeshVectorValueInterpolator *clone() = 0;
 
    virtual ~QgsMeshVectorValueInterpolator() = default;
 
    virtual QgsVector vectorValue( const QgsPointXY &point ) const;
 
    QgsMeshVectorValueInterpolator &operator=( const QgsMeshVectorValueInterpolator &other );
 
  protected:
    void updateCacheFaceIndex( const QgsPointXY &point ) const;
 
    QgsTriangularMesh mTriangularMesh;
    QgsMeshDataBlock mDatasetValues;
    QgsMeshDataBlock mActiveFaceFlagValues;
    mutable QgsMeshFace mFaceCache;
    mutable int mCacheFaceIndex = -1;
    bool mUseScalarActiveFaceFlagValues = false;
    bool isVectorValid( const QgsVector &v ) const;
 
  private:
 
    void activeFaceFilter( QgsVector &vector, int faceIndex ) const;
 
    virtual QgsVector interpolatedValuePrivate( int faceIndex, const QgsPointXY point ) const = 0;
};
 
class QgsMeshVectorValueInterpolatorFromVertex: public QgsMeshVectorValueInterpolator
{
  public:
    QgsMeshVectorValueInterpolatorFromVertex(
      const QgsTriangularMesh &triangularMesh,
      const QgsMeshDataBlock &datasetVectorValues );
 
    QgsMeshVectorValueInterpolatorFromVertex(
      const QgsTriangularMesh &triangularMesh,
      const QgsMeshDataBlock &datasetVectorValues,
      const QgsMeshDataBlock &scalarActiveFaceFlagValues );
 
    QgsMeshVectorValueInterpolatorFromVertex( const QgsMeshVectorValueInterpolatorFromVertex &other );
 
    virtual QgsMeshVectorValueInterpolatorFromVertex *clone() override;
 
    QgsMeshVectorValueInterpolatorFromVertex &operator=( const QgsMeshVectorValueInterpolatorFromVertex &other );
 
  private:
    QgsVector interpolatedValuePrivate( int faceIndex, const QgsPointXY point ) const override;
};
 
class QgsMeshVectorValueInterpolatorFromFace: public QgsMeshVectorValueInterpolator
{
  public:
    QgsMeshVectorValueInterpolatorFromFace(
      const QgsTriangularMesh &triangularMesh,
      const QgsMeshDataBlock &datasetVectorValues );
 
    QgsMeshVectorValueInterpolatorFromFace(
      const QgsTriangularMesh &triangularMesh,
      const QgsMeshDataBlock &datasetVectorValues,
      const QgsMeshDataBlock &scalarActiveFaceFlagValues );
 
    QgsMeshVectorValueInterpolatorFromFace( const QgsMeshVectorValueInterpolatorFromFace &other );
 
    virtual QgsMeshVectorValueInterpolatorFromFace *clone() override;
 
    QgsMeshVectorValueInterpolatorFromFace &operator=( const QgsMeshVectorValueInterpolatorFromFace &other );
 
  private:
    QgsVector interpolatedValuePrivate( int faceIndex, const QgsPointXY point ) const override;
};
 
class QgsMeshStreamField
{
  public:
    struct FieldData
    {
      double magnitude;
      float time;
      int directionX;
      int directionY;
    };
 
    QgsMeshStreamField(
      const QgsTriangularMesh &triangularMesh,
      const QgsMeshDataBlock &dataSetVectorValues,
      const QgsMeshDataBlock &scalarActiveFaceFlagValues,
      const QgsRectangle &layerExtent,
      double magnitudeMaximum,
      bool dataIsOnVertices,
      const QgsRenderContext &rendererContext,
      const QgsInterpolatedLineColor &vectorColoring,
      int resolution = 1 );
 
    QgsMeshStreamField( const QgsMeshStreamField &other );
 
    virtual ~QgsMeshStreamField();
 
    void updateSize( const QgsRenderContext &renderContext );
 
    void updateSize( const QgsRenderContext &renderContext, int resolution );
 
    bool isValid() const;
 
    QSize size() const;
 
    QPoint topLeft() const;
 
    void addTrace( QPoint startPixel );
 
    void addTrace( QgsPointXY startPoint );
 
    void addRandomTraces();
 
    void addRandomTrace();
 
    void addGriddedTraces( int dx, int dy );
 
    void addTracesOnMesh( const QgsTriangularMesh &mesh, const QgsRectangle &extent );
 
    void setResolution( int width );
 
    int resolution() const;
 
    QSize imageSize() const;
 
    virtual QImage image() const;
 
    void setPixelFillingDensity( double maxFilling );
 
    void setColor( QColor color );
 
    void setLineWidth( double width );
 
    void setFilter( double min, double max );
 
    void setMinimizeFieldSize( bool minimizeFieldSize );
 
    QgsMeshStreamField &operator=( const QgsMeshStreamField &other );
 
  protected:
    virtual void initImage();
    QPointF fieldToDevice( const QPoint &pixel ) const;
    bool filterMag( double value ) const;
    bool isTraceOutside( const QPoint &pixel ) const;
 
  private:
    QgsPointXY positionToMapCoordinates( const QPoint &pixelPosition, const QgsPointXY &positionInPixel );
    bool addPixelToChunkTrace( QPoint &pixel,
                               QgsMeshStreamField::FieldData &data,
                               std::list<QPair<QPoint, QgsMeshStreamField::FieldData> > &chunkTrace );
    void setChunkTrace( std::list<QPair<QPoint, FieldData>> &chunkTrace );
    virtual void drawTrace( const QPoint & ) const {}
    void clearChunkTrace( std::list<QPair<QPoint, FieldData>> &chunkTrace );
    virtual void storeInField( const QPair<QPoint, FieldData> pixelData ) = 0;
    virtual void initField() = 0;
    void simplifyChunkTrace( std::list<QPair<QPoint, FieldData>> &shunkTrace );
 
    virtual bool isTraceExists( const QPoint &pixel ) const = 0;
 
  protected:
 
    QSize mFieldSize;
    std::unique_ptr<QPainter> mPainter = std::unique_ptr<QPainter>( nullptr );
    int mFieldResolution = 1;
    QPen mPen;
    QImage mTraceImage;
 
    QgsMapToPixel mMapToFieldPixel;
    QgsRectangle mOutputExtent = QgsRectangle();
    QgsInterpolatedLineColor mVectorColoring;
 
    /*the direction for a pixel is defined with a char value
     *
     *     1  2  3
     *     4  5  6
     *     7  8  9
     *
     *     convenient to retrieve the indexes of the next pixel from the direction d:
     *     Xnext= (d-1)%3-1
     *     Ynext = (d-1)/3-1
     *
     *     and the direction is defined by :
     *     d=incX + 2 + (incY+1)*3
     */
    QVector<unsigned char> mDirectionField;
    QgsRenderContext mRenderContext;
 
  private:
    int mPixelFillingCount = 0;
    int mMaxPixelFillingCount = 0;
    std::unique_ptr<QgsMeshVectorValueInterpolator> mVectorValueInterpolator;
    QgsRectangle mLayerExtent;
    QgsRectangle mMapExtent;
    QPoint mFieldTopLeftInDeviceCoordinates;
    bool mValid = false;
    double mMaximumMagnitude = 0;
    double mPixelFillingDensity = 0;
    double mMinMagFilter = -1;
    double mMaxMagFilter = -1;
    bool mMinimizeFieldSize = true; //
};
 
class QgsMeshStreamlinesField: public QgsMeshStreamField
{
  public:
    Q_DECL_DEPRECATED QgsMeshStreamlinesField(
      const QgsTriangularMesh &triangularMesh,
      const QgsMeshDataBlock &datasetVectorValues,
      const QgsMeshDataBlock &scalarActiveFaceFlagValues,
      const QgsRectangle &layerExtent,
      double magMax,
      bool dataIsOnVertices,
      QgsRenderContext &rendererContext,
      const QgsInterpolatedLineColor vectorColoring );
 
    QgsMeshStreamlinesField(
      const QgsTriangularMesh &triangularMesh,
      const QgsMeshDataBlock &datasetVectorValues,
      const QgsMeshDataBlock &scalarActiveFaceFlagValues,
      const QVector<double> &datasetMagValues,
      const QgsRectangle &layerExtent,
      QgsMeshLayerRendererFeedback *feedBack,
      double magMax,
      bool dataIsOnVertices,
      QgsRenderContext &rendererContext,
      const QgsInterpolatedLineColor vectorColoring );
 
    void compose();
 
  private:
    void storeInField( const QPair<QPoint, FieldData> pixelData ) override;
    void initField() override;
    void initImage() override;
    bool isTraceExists( const QPoint &pixel ) const override;
    void drawTrace( const QPoint &start ) const override;
 
    QVector<bool> mField;
    QImage mDrawingTraceImage;
    std::unique_ptr<QPainter> mDrawingTracePainter;
 
    //** Needed data
    QgsTriangularMesh mTriangularMesh;
    QVector<double> mMagValues;
    QgsMeshDataBlock mScalarActiveFaceFlagValues;
    QgsMeshDatasetGroupMetadata::DataType mDataType = QgsMeshDatasetGroupMetadata::DataOnVertices;
    QgsMeshLayerRendererFeedback *mFeedBack = nullptr;
 
};
 
class QgsMeshParticleTracesField;
 
struct QgsMeshTraceParticle
{
  double lifeTime = 0;
  QPoint position;
  std::list<QPoint> tail;
  double remainingTime = 0; //time remaining to spend in the current pixel at the end of the time step
};
 
class QgsMeshParticleTracesField: public QgsMeshStreamField
{
  public:
    QgsMeshParticleTracesField(
      const QgsTriangularMesh &triangularMesh,
      const QgsMeshDataBlock &datasetVectorValues,
      const QgsMeshDataBlock &scalarActiveFaceFlagValues,
      const QgsRectangle &layerExtent,
      double magMax,
      bool dataIsOnVertices,
      const QgsRenderContext &rendererContext,
      const QgsInterpolatedLineColor vectorColoring );
 
    QgsMeshParticleTracesField( const QgsMeshParticleTracesField &other );
 
    void addParticle( const QPoint &startPoint, double lifeTime );
 
    void addParticleXY( const QgsPointXY &startPoint, double lifeTime );
 
    void addRandomParticles();
 
    void moveParticles();
 
    QImage imageRendered() const;
 
    void setParticlesCount( int particlesCount );
 
    void setParticlesLifeTime( double particlesLifeTime );
 
    void stump();
 
    void setStumpFactor( int sf );
 
    void setTimeStep( double timeStep );
 
    void setParticleSize( double particleSize );
 
    void setTailFactor( double tailFactor );
 
    void setMinTailLength( int minTailLength );
 
    void setStumpParticleWithLifeTime( bool stumpParticleWithLifeTime );
 
    void setParticlesColor( const QColor &c );
 
    QgsMeshParticleTracesField &operator=( const QgsMeshParticleTracesField &other );
 
  private:
    QPoint direction( QPoint position ) const;
 
    float time( QPoint position ) const;
    float magnitude( QPoint position ) const;
 
    void drawParticleTrace( const QgsMeshTraceParticle &particle );
 
    void storeInField( const QPair<QPoint, FieldData> pixelData ) override;
    void initField() override;
    bool isTraceExists( const QPoint &pixel ) const override;
 
    /* Nondimensional time
     * This field store the time spent by the particle in the pixel
     *
     * This time is nondimensional and value 1 is equivalent to the time spent by the particle in a pixel
     * for Vmax, the maximum magnitude of the vector field.
     *
     */
    QVector<float> mTimeField;
    QVector<float> mMagnitudeField;
 
    QList<QgsMeshTraceParticle> mParticles;
    QImage mStumpImage;
 
    double mTimeStep = 200;
    double mParticlesLifeTime = 5000;
    int mParticlesCount = 1000;
    double mTailFactor = 5;
    int mMinTailLength = 3;
    QColor mParticleColor = Qt::white;
    double mParticleSize = 2.5;
    int mStumpFactor = 50;
    bool mStumpParticleWithLifeTime = true;
};
 
class QgsMeshVectorStreamlineRenderer: public QgsMeshVectorRenderer
{
  public:
    Q_DECL_DEPRECATED QgsMeshVectorStreamlineRenderer(
      const QgsTriangularMesh &triangularMesh,
      const QgsMeshDataBlock &dataSetVectorValues,
      const QgsMeshDataBlock &scalarActiveFaceFlagValues,
      bool dataIsOnVertices,
      const QgsMeshRendererVectorSettings &settings,
      QgsRenderContext &rendererContext,
      const QgsRectangle &layerExtent,
      double magMax );
 
    QgsMeshVectorStreamlineRenderer(
      const QgsTriangularMesh &triangularMesh,
      const QgsMeshDataBlock &dataSetVectorValues,
      const QgsMeshDataBlock &scalarActiveFaceFlagValues,
      const QVector<double> &datasetMagValues,
      bool dataIsOnVertices,
      const QgsMeshRendererVectorSettings &settings,
      QgsRenderContext &rendererContext,
      const QgsRectangle &layerExtent,
      QgsMeshLayerRendererFeedback *feedBack,
      double magMax );
 
    void draw() override;
 
  private:
    std::unique_ptr<QgsMeshStreamlinesField> mStreamlineField;
    QgsRenderContext &mRendererContext;
};
 
 
class QgsMeshVectorTraceRenderer: public QgsMeshVectorRenderer
{
  public:
    QgsMeshVectorTraceRenderer(
      const QgsTriangularMesh &triangularMesh,
      const QgsMeshDataBlock &dataSetVectorValues,
      const QgsMeshDataBlock &scalarActiveFaceFlagValues,
      bool dataIsOnVertices,
      const QgsMeshRendererVectorSettings &settings,
      QgsRenderContext &rendererContext,
      const QgsRectangle &layerExtent,
      double magMax );
 
    void draw() override;
 
  private:
    std::unique_ptr<QgsMeshParticleTracesField> mParticleField;
    QgsRenderContext &mRendererContext;
};
 
 
#endif //SIP_RUN
 
 
class CORE_EXPORT QgsMeshVectorTraceAnimationGenerator
{
  public:
    QgsMeshVectorTraceAnimationGenerator(
      const QgsTriangularMesh &triangularMesh,
      const QgsMeshDataBlock &dataSetVectorValues,
      const QgsMeshDataBlock &scalarActiveFaceFlagValues,
      bool dataIsOnVertices,
      const QgsRenderContext &rendererContext,
      const QgsRectangle &layerExtent,
      double magMax,
      const QgsMeshRendererVectorSettings &vectorSettings ) SIP_SKIP;
 
    QgsMeshVectorTraceAnimationGenerator( QgsMeshLayer *layer, const QgsRenderContext &rendererContext );
 
    QgsMeshVectorTraceAnimationGenerator( const QgsMeshVectorTraceAnimationGenerator &other );
 
    ~QgsMeshVectorTraceAnimationGenerator() = default;
 
    void seedRandomParticles( int count );
 
    QImage imageRendered();
 
    void setFPS( int FPS );
 
    void setMaxSpeedPixel( int max );
 
    void setParticlesLifeTime( double particleLifeTime );
 
    void setParticlesColor( const QColor &c );
 
    void setParticlesSize( double width );
 
    void setTailFactor( double fct );
 
    void setMinimumTailLength( int l );
 
    void setTailPersitence( double p );
 
    QgsMeshVectorTraceAnimationGenerator &operator=( const QgsMeshVectorTraceAnimationGenerator &other );
 
  private:
    std::unique_ptr<QgsMeshParticleTracesField> mParticleField;
    const QgsRenderContext &mRendererContext;
    int mFPS = 15; //frame per second of the output, used to calculate orher parameters of the field
    int mVpixMax = 2000; //is the number of pixels that are going through for 1 s
    double mParticleLifeTime = 5;
 
    void updateFieldParameter();
};
 
#endif // QGSMESHTRACERENDERER_H