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"
#include "qgselevationmap.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   // intentionally left out from SIP to avoid API breaks in future when we move elevation post-processing elsewhere
 
    void setElevationMap( QgsElevationMap *elevationMap SIP_TRANSFER );
 
    QgsElevationMap *elevationMap() { return mElevationMap.get(); }
#endif
 
#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
 
  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;
    std::unique_ptr<QgsElevationMap> mElevationMap;
 
    QgsFeedback *mFeedback = nullptr;
};
 
#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 QgsUnitTypes::RenderUnit units ) { mPointSizeUnit = units; }
 
    QgsUnitTypes::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 );
 
    QgsUnitTypes::RenderUnit maximumScreenErrorUnit() const;
 
    void setMaximumScreenErrorUnit( QgsUnitTypes::RenderUnit unit );
 
    virtual QList<QgsLayerTreeModelLegendNode *> createLegendNodes( QgsLayerTreeLayer *nodeLayer ) SIP_FACTORY;
 
    virtual QStringList legendRuleKeys() const;
 
    bool eyeDomeLightingEnabled() const { return mEyeDomeLightingEnabled; }
 
    void setEyeDomeLightingEnabled( bool enabled ) { mEyeDomeLightingEnabled = enabled; }
 
    double eyeDomeLightingStrength() const { return mEyeDomeLightingStrength; }
 
    void setEyeDomeLightingStrength( double strength ) { mEyeDomeLightingStrength = strength; }
 
    double eyeDomeLightingDistance() const { return mEyeDomeLightingDistance; }
 
    void setEyeDomeLightingDistance( double distance ) { mEyeDomeLightingDistance = distance; }
 
    QgsUnitTypes::RenderUnit eyeDomeLightingDistanceUnit() const { return mEyeDomeLightingDistanceUnit; }
 
    void setEyeDomeLightingDistanceUnit( QgsUnitTypes::RenderUnit unit ) { mEyeDomeLightingDistanceUnit = unit; }
 
  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
    {
      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 - mPainterPenWidth * 0.5,
                                     y - mPainterPenWidth * 0.5,
                                     mPainterPenWidth, mPainterPenWidth ), color );
          break;
 
        case Qgis::PointCloudSymbol::Circle:
          painter->setBrush( QBrush( color ) );
          painter->setPen( Qt::NoPen );
          painter->drawEllipse( QRectF( x - mPainterPenWidth * 0.5,
                                        y - mPainterPenWidth * 0.5,
                                        mPainterPenWidth, mPainterPenWidth ) );
          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;
#endif
 
    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;
    QgsUnitTypes::RenderUnit mMaximumScreenErrorUnit = QgsUnitTypes::RenderMillimeters;
 
    double mPointSize = 1;
    QgsUnitTypes::RenderUnit mPointSizeUnit = QgsUnitTypes::RenderMillimeters;
    QgsMapUnitScale mPointSizeMapUnitScale;
 
    Qgis::PointCloudSymbol mPointSymbol = Qgis::PointCloudSymbol::Square;
    int mPainterPenWidth = 1;
    Qgis::PointCloudDrawOrder mDrawOrder2d = Qgis::PointCloudDrawOrder::Default;
 
    bool mEyeDomeLightingEnabled = false;
    double mEyeDomeLightingStrength = 1000.0;
    double mEyeDomeLightingDistance = 0.5;
    QgsUnitTypes::RenderUnit mEyeDomeLightingDistanceUnit = QgsUnitTypes::RenderMillimeters;
};
 
#endif // QGSPOINTCLOUDRENDERER_H