qgspointcloudrenderer.h

Go to the documentation of this file.

/***************************************************************************
                         qgspointcloudrenderer.h
                         --------------------
    begin                : October 2020
    copyright            : (C) 2020 by Peter Petrik
    email                : zilolv 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 QGSPOINTCLOUDRENDERER_H
#define QGSPOINTCLOUDRENDERER_H
 
#include "qgis_core.h"
#include "qgis_sip.h"
#include "qgspointcloudattribute.h"
#include "qgspropertycollection.h"
#include "qgsrendercontext.h"
#include "qgsstyle.h"
#include "qgsvector3d.h"
 
#include <QString>
#include <QStringList>
 
using namespace Qt::StringLiterals;
 
class QgsPointCloudBlock;
class QgsLayerTreeLayer;
class QgsLayerTreeModelLegendNode;
class QgsPointCloudLayer;
class QgsElevationMap;
class QgsExpressionContextScope;

class CORE_EXPORT QgsPointCloudRenderContext
{
  public:
    QgsPointCloudRenderContext( QgsRenderContext &context, const QgsVector3D &scale, const QgsVector3D &offset, double zValueScale, double zValueFixedOffset, QgsFeedback *feedback = nullptr );
 
    QgsPointCloudRenderContext( const QgsPointCloudRenderContext &rh ) = delete;
    QgsPointCloudRenderContext &operator=( const QgsPointCloudRenderContext & ) = delete;

    QgsRenderContext &renderContext() { return mRenderContext; }

    const QgsRenderContext &renderContext() const SIP_SKIP { return mRenderContext; }

    QgsVector3D scale() const { return mScale; }

    void setScale( const QgsVector3D &scale ) { mScale = scale; }

    QgsVector3D offset() const { return mOffset; }

    void setOffset( const QgsVector3D &offset ) { mOffset = offset; }

    long pointsRendered() const;

    void incrementPointsRendered( long count );

    QgsPointCloudAttributeCollection attributes() const { return mAttributes; }

    void setAttributes( const QgsPointCloudAttributeCollection &attributes );

    int pointRecordSize() const { return mPointRecordSize; }

    int xOffset() const { return mXOffset; }

    int yOffset() const { return mYOffset; }

    int zOffset() const { return mZOffset; }

    double zValueScale() const { return mZValueScale; }

    double zValueFixedOffset() const { return mZValueFixedOffset; }

    QgsFeedback *feedback() const { return mFeedback; }
 
#ifndef SIP_RUN

    template<typename T> static void getAttribute( const char *data, std::size_t offset, QgsPointCloudAttribute::DataType type, T &value )
    {
      switch ( type )
      {
        case QgsPointCloudAttribute::UChar:
          value = *reinterpret_cast< const unsigned char * >( data + offset );
          return;
        case QgsPointCloudAttribute::Char:
          value = *( data + offset );
          return;
 
        case QgsPointCloudAttribute::UInt32:
          value = *reinterpret_cast< const quint32 * >( data + offset );
          return;
        case QgsPointCloudAttribute::Int32:
          value = *reinterpret_cast< const qint32 * >( data + offset );
          return;
 
        case QgsPointCloudAttribute::UInt64:
          value = *reinterpret_cast< const quint64 * >( data + offset );
          return;
        case QgsPointCloudAttribute::Int64:
          value = *reinterpret_cast< const qint64 * >( data + offset );
          return;
 
        case QgsPointCloudAttribute::Short:
          value = *reinterpret_cast< const short * >( data + offset );
          return;
 
        case QgsPointCloudAttribute::UShort:
          value = *reinterpret_cast< const unsigned short * >( data + offset );
          return;
 
        case QgsPointCloudAttribute::Float:
          value = *reinterpret_cast< const float * >( data + offset );
          return;
 
        case QgsPointCloudAttribute::Double:
          value = *reinterpret_cast< const double * >( data + offset );
          return;
      }
    }
#endif
 
#ifndef SIP_RUN // this is only meant for low-level rendering in C++ code

    struct TriangulationData
    {
        std::vector<double> points;    
        std::vector<QRgb> colors;      
        std::vector<float> elevations; 
    };

    TriangulationData &triangulationData() { return mTriangulationData; }
#endif
 
  private:
#ifdef SIP_RUN
    QgsPointCloudRenderContext( const QgsPointCloudRenderContext &rh );
#endif
 
    QgsRenderContext &mRenderContext;
    QgsVector3D mScale;
    QgsVector3D mOffset;
    long mPointsRendered = 0;
    QgsPointCloudAttributeCollection mAttributes;
    int mPointRecordSize = 0;
    int mXOffset = 0;
    int mYOffset = 0;
    int mZOffset = 0;
    double mZValueScale = 1.0;
    double mZValueFixedOffset = 0;
 
    QgsFeedback *mFeedback = nullptr;
 
    TriangulationData mTriangulationData;
};
 
#ifndef SIP_RUN

class CORE_EXPORT QgsPreparedPointCloudRendererData
{
  public:
    virtual ~QgsPreparedPointCloudRendererData();

    virtual QSet< QString > usedAttributes() const = 0;

    virtual bool prepareBlock( const QgsPointCloudBlock *block ) = 0;

    virtual QColor pointColor( const QgsPointCloudBlock *block, int i, double z ) = 0;
};
 
#endif
 

class CORE_EXPORT QgsPointCloudRenderer
{
#ifdef SIP_RUN
    SIP_CONVERT_TO_SUBCLASS_CODE
 
    const QString type = sipCpp->type();
 
    if ( type == "rgb"_L1 )
      sipType = sipType_QgsPointCloudRgbRenderer;
    else if ( type == "ramp"_L1 )
      sipType = sipType_QgsPointCloudAttributeByRampRenderer;
    else if ( type == "classified"_L1 )
      sipType = sipType_QgsPointCloudClassifiedRenderer;
    else if ( type == "extent"_L1 )
      sipType = sipType_QgsPointCloudExtentRenderer;
    else
      sipType = 0;
  SIP_END
#endif
 
  public:

    enum class Property : int
    {
      Color = 0, 
    };
 
    QgsPointCloudRenderer();
 
    virtual ~QgsPointCloudRenderer() = default;

    virtual QString type() const = 0;

    virtual QgsPointCloudRenderer *clone() const = 0 SIP_FACTORY;

    QgsPointCloudRenderer( const QgsPointCloudRenderer &other ) = delete;

    QgsPointCloudRenderer &operator=( const QgsPointCloudRenderer &other ) = delete;

    virtual void renderBlock( const QgsPointCloudBlock *block, QgsPointCloudRenderContext &context ) = 0;

    QVector<QVariantMap> identify( QgsPointCloudLayer *layer, const QgsRenderContext &context, const QgsGeometry &geometry, double toleranceForPointIdentification = 0 ) SIP_SKIP;

    virtual bool willRenderPoint( const QMap<QString, QVariant> &pointAttributes )
    {
      Q_UNUSED( pointAttributes );
      return true;
    }

    static QgsPointCloudRenderer *load( QDomElement &element, const QgsReadWriteContext &context ) SIP_FACTORY;

    virtual QDomElement save( QDomDocument &doc, const QgsReadWriteContext &context ) const = 0;

    virtual QSet< QString > usedAttributes( const QgsPointCloudRenderContext &context ) const;

    virtual std::unique_ptr< QgsPreparedPointCloudRendererData > prepare() SIP_SKIP;

    virtual void startRender( QgsPointCloudRenderContext &context );

    virtual void stopRender( QgsPointCloudRenderContext &context );

    virtual bool legendItemChecked( const QString &key );

    virtual void checkLegendItem( const QString &key, bool state = true );

    void setPointSize( double size ) { mPointSize = size; }

    double pointSize() const { return mPointSize; }

    void setPointSizeUnit( const Qgis::RenderUnit units ) { mPointSizeUnit = units; }

    Qgis::RenderUnit pointSizeUnit() const { return mPointSizeUnit; }

    void setPointSizeMapUnitScale( const QgsMapUnitScale &scale ) { mPointSizeMapUnitScale = scale; }

    const QgsMapUnitScale &pointSizeMapUnitScale() const { return mPointSizeMapUnitScale; }

    Qgis::PointCloudDrawOrder drawOrder2d() const;

    void setDrawOrder2d( Qgis::PointCloudDrawOrder order );

    Qgis::PointCloudSymbol pointSymbol() const;

    void setPointSymbol( Qgis::PointCloudSymbol symbol );

    double maximumScreenError() const;

    void setMaximumScreenError( double error );

    Qgis::RenderUnit maximumScreenErrorUnit() const;

    void setMaximumScreenErrorUnit( Qgis::RenderUnit unit );

    bool renderAsTriangles() const { return mRenderAsTriangles; }

    void setRenderAsTriangles( bool asTriangles ) { mRenderAsTriangles = asTriangles; }

    bool horizontalTriangleFilter() const { return mHorizontalTriangleFilter; }

    void setHorizontalTriangleFilter( bool enabled ) { mHorizontalTriangleFilter = enabled; }

    double horizontalTriangleFilterThreshold() const { return mHorizontalTriangleFilterThreshold; }

    void setHorizontalTriangleFilterThreshold( double threshold ) { mHorizontalTriangleFilterThreshold = threshold; }

    Qgis::RenderUnit horizontalTriangleFilterUnit() const { return mHorizontalTriangleFilterUnit; }

    void setHorizontalTriangleFilterUnit( Qgis::RenderUnit unit ) { mHorizontalTriangleFilterUnit = unit; }

    virtual QList<QgsLayerTreeModelLegendNode *> createLegendNodes( QgsLayerTreeLayer *nodeLayer ) SIP_FACTORY;

    virtual QStringList legendRuleKeys() const;

    void setShowLabels( const bool show ) { mShowLabels = show; }

    bool showLabels() const { return mShowLabels; }

    void setLabelTextFormat( const QgsTextFormat &textFormat ) { mLabelTextFormat = textFormat; }

    QgsTextFormat labelTextFormat() const { return mLabelTextFormat; }

    void setZoomOutBehavior( const Qgis::PointCloudZoomOutRenderBehavior behavior ) { mZoomOutBehavior = behavior; }

    Qgis::PointCloudZoomOutRenderBehavior zoomOutBehavior() const { return mZoomOutBehavior; }

    void setOverviewSwitchingScale( const double value );

    double overviewSwitchingScale() const { return mOverviewSwitchingScale; }

    QgsElevationShadingRenderer elevationShadingRenderer() const;

    void setElevationShadingRenderer( const QgsElevationShadingRenderer &renderer ) { mElevationShadingRenderer = renderer; }

    static const QgsPropertiesDefinition &propertyDefinitions();

    const QgsPropertyCollection &dataDefinedProperties() const { return mDataDefinedProperties; }

    void setDataDefinedProperties( const QgsPropertyCollection &collection ) { mDataDefinedProperties = collection; }
 
  protected:
    static void pointXY( QgsPointCloudRenderContext &context, const char *ptr, int i, double &x, double &y )
    {
      // be wary when copying this code!! In the renderer we explicitly request x/y/z as qint32 values, but in other
      // situations these may be floats or doubles!
      const qint32 ix = *reinterpret_cast< const qint32 * >( ptr + i * context.pointRecordSize() + context.xOffset() );
      const qint32 iy = *reinterpret_cast< const qint32 * >( ptr + i * context.pointRecordSize() + context.yOffset() );
      x = context.offset().x() + context.scale().x() * ix;
      y = context.offset().y() + context.scale().y() * iy;
    }

    static double pointZ( QgsPointCloudRenderContext &context, const char *ptr, int i )
    {
      // be wary when copying this code!! In the renderer we explicitly request x/y/z as qint32 values, but in other
      // situations these may be floats or doubles!
      const qint32 iz = *reinterpret_cast<const qint32 * >( ptr + i * context.pointRecordSize() + context.zOffset() );
      return ( context.offset().z() + context.scale().z() * iz ) * context.zValueScale() + context.zValueFixedOffset();
    }

    void drawPoint( double x, double y, const QColor &color, QgsPointCloudRenderContext &context ) const { drawPoint( x, y, color, mDefaultPainterPenWidth, context ); }

    void drawPoint( double x, double y, const QColor &color, int width, QgsPointCloudRenderContext &context ) const
    {
      const QPointF originalXY( x, y );
      context.renderContext().mapToPixel().transformInPlace( x, y );
      QPainter *painter = context.renderContext().painter();
      switch ( mPointSymbol )
      {
        case Qgis::PointCloudSymbol::Square:
          painter->fillRect( QRectF( x - width * 0.5, y - width * 0.5, width, width ), color );
          break;
 
        case Qgis::PointCloudSymbol::Circle:
          painter->setBrush( QBrush( color ) );
          painter->setPen( Qt::NoPen );
          painter->drawEllipse( QRectF( x - width * 0.5, y - width * 0.5, width, width ) );
          break;
      };
    }
 
#ifndef SIP_RUN // intentionally left out from SIP to avoid API breaks in future when we move elevation post-processing elsewhere

    void drawPointToElevationMap( double x, double y, double z, QgsPointCloudRenderContext &context ) const;

    void drawPointToElevationMap( double x, double y, double z, int width, QgsPointCloudRenderContext &context ) const;
#endif

    void addPointToTriangulation( double x, double y, double z, const QColor &color, QgsPointCloudRenderContext &context )
    {
      QgsPointXY p = context.renderContext().mapToPixel().transform( x, y ) * context.renderContext().devicePixelRatio();
      QgsPointCloudRenderContext::TriangulationData &triangulation = context.triangulationData();
      triangulation.points.push_back( p.x() );
      triangulation.points.push_back( p.y() );
      triangulation.colors.push_back( color.rgb() );
      if ( context.renderContext().elevationMap() )
        triangulation.elevations.push_back( static_cast<float>( z ) );
    }

    void copyCommonProperties( QgsPointCloudRenderer *destination ) const;

    void restoreCommonProperties( const QDomElement &element, const QgsReadWriteContext &context );

    void saveCommonProperties( QDomElement &element, const QgsReadWriteContext &context ) const;

    QColor colorFromExpression( const QgsPointCloudBlock *block, int pointIndex, const QColor &rendererColor, QgsPointCloudRenderContext &context ) SIP_SKIP;
 
  private:
#ifdef SIP_RUN
    QgsPointCloudRenderer( const QgsPointCloudRenderer &other );
#endif
 
#ifdef QGISDEBUG
    QThread *mThread = nullptr;
#endif
 
    double mMaximumScreenError = 0.3;
    Qgis::RenderUnit mMaximumScreenErrorUnit = Qgis::RenderUnit::Millimeters;
 
    double mPointSize = 1;
    Qgis::RenderUnit mPointSizeUnit = Qgis::RenderUnit::Millimeters;
    QgsMapUnitScale mPointSizeMapUnitScale;
 
    Qgis::PointCloudSymbol mPointSymbol = Qgis::PointCloudSymbol::Square;
    int mDefaultPainterPenWidth = 1;
    Qgis::PointCloudDrawOrder mDrawOrder2d = Qgis::PointCloudDrawOrder::Default;
 
    bool mRenderAsTriangles = false;
    bool mHorizontalTriangleFilter = false;
    double mHorizontalTriangleFilterThreshold = 5.0;
    Qgis::RenderUnit mHorizontalTriangleFilterUnit = Qgis::RenderUnit::Millimeters;
 
    bool mShowLabels = false;
    QgsTextFormat mLabelTextFormat;
 
    Qgis::PointCloudZoomOutRenderBehavior mZoomOutBehavior = Qgis::PointCloudZoomOutRenderBehavior::RenderExtents;
    double mOverviewSwitchingScale = 1.0;
 
    QgsElevationShadingRenderer mElevationShadingRenderer;
 
    static void initPropertyDefinitions();
    static QgsPropertiesDefinition sPropertyDefinitions;
    QgsPropertyCollection mDataDefinedProperties;
 
    std::unique_ptr<QgsExpressionContextScope> mExpressionContextScope;
};
 
#endif // QGSPOINTCLOUDRENDERER_H