qgsvectorfieldstreamfield.h

Go to the documentation of this file.

/***************************************************************************
    qgsvectorfieldstreamfield.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 QGSVECTORFIELDSTREAMFIELD_H
#define QGSVECTORFIELDSTREAMFIELD_H
 
#include <list>
#include <memory>
 
#include "qgsinterpolatedlinerenderer.h"
#include "qgsmaptopixel.h"
#include "qgsrendercontext.h"
#include "qgsvectorfieldvaluesource.h"
 
#include <QImage>
#include <QPainter>
#include <QSize>
#include <QVector>
 
#define SIP_NO_FILE
 
class QgsRasterBlockFeedback;


class QgsVectorFieldStreamField
{
  public:
    struct FieldData
    {
        double magnitude;
        float time;
        int directionX;
        int directionY;
    };

    QgsVectorFieldStreamField( std::unique_ptr<QgsVectorFieldValueSource> source, const QgsRenderContext &rendererContext, const QgsInterpolatedLineColor &vectorColoring, int resolution = 1 );
 
    QgsVectorFieldStreamField( const QgsVectorFieldStreamField &other );
    virtual ~QgsVectorFieldStreamField();

    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 addTracesOnDataPoints( 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 );

    QgsVectorFieldStreamField &operator=( const QgsVectorFieldStreamField &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, QgsVectorFieldStreamField::FieldData &data, std::list<QPair<QPoint, QgsVectorFieldStreamField::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;
 
    std::unique_ptr<QgsVectorFieldValueSource> mSource;
 
  private:
    int mPixelFillingCount = 0;
    int mMaxPixelFillingCount = 0;
    QgsRectangle mMapExtent;
    QPoint mFieldTopLeftInDeviceCoordinates;
    bool mValid = false;
    double mPixelFillingDensity = 0;
    double mMinMagFilter = -1;
    double mMaxMagFilter = -1;
    bool mMinimizeFieldSize = true; //
};

class QgsVectorFieldStreamlinesField : public QgsVectorFieldStreamField
{
  public:
    QgsVectorFieldStreamlinesField(
      std::unique_ptr<QgsVectorFieldValueSource> source, QgsRenderContext &rendererContext, const QgsInterpolatedLineColor &vectorColoring, QgsRasterBlockFeedback *feedBack = nullptr
    );
 
    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;
 
    QgsRasterBlockFeedback *mFeedBack = nullptr;
};

struct QgsVectorFieldTraceParticle
{
    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 QgsVectorFieldParticleTracesField : public QgsVectorFieldStreamField
{
  public:
    QgsVectorFieldParticleTracesField( std::unique_ptr<QgsVectorFieldValueSource> source, const QgsRenderContext &rendererContext, const QgsInterpolatedLineColor &vectorColoring );
 
    QgsVectorFieldParticleTracesField( const QgsVectorFieldParticleTracesField &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 );
 
    QgsVectorFieldParticleTracesField &operator=( const QgsVectorFieldParticleTracesField &other );
 
  private:
    QPoint direction( QPoint position ) const;
 
    float time( QPoint position ) const;
    float magnitude( QPoint position ) const;
 
    void drawParticleTrace( const QgsVectorFieldTraceParticle &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<QgsVectorFieldTraceParticle> 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;
};

 
#endif // QGSVECTORFIELDSTREAMFIELD_H