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 "qgsrendercontext.h"
 
#include "qgis_core.h"
#include "qgis_sip.h"
#include "qgsvector3d.h"
#include "qgspointcloudattribute.h"
 
class QgsPointCloudBlock;
class QgsLayerTreeLayer;
class QgsLayerTreeModelLegendNode;
class QgsPointCloudLayer;
class QgsElevationMap;
 
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 { return mRenderContext; } SIP_SKIP
 
    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 == QLatin1String( "rgb" ) )
      sipType = sipType_QgsPointCloudRgbRenderer;
    else if ( type == QLatin1String( "ramp" ) )
      sipType = sipType_QgsPointCloudAttributeByRampRenderer;
    else if ( type == QLatin1String( "classified" ) )
      sipType = sipType_QgsPointCloudClassifiedRenderer;
    else if ( type == QLatin1String( "extent" ) )
      sipType = sipType_QgsPointCloudExtentRenderer;
    else
      sipType = 0;
    SIP_END
#endif
 
  public:
 
    QgsPointCloudRenderer() = default;
 
    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;
 
  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;
 
  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;
};
 
#endif // QGSPOINTCLOUDRENDERER_H