qgs3dutils.h

Go to the documentation of this file.

/***************************************************************************
  qgs3dutils.h
  --------------------------------------
  Date                 : July 2017
  Copyright            : (C) 2017 by Martin Dobias
  Email                : wonder dot sk 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 QGS3DUTILS_H
#define QGS3DUTILS_H
 
#include <memory>
 
#include "qgs3danimationsettings.h"
#include "qgs3dmapcanvas.h"
#include "qgs3dmapsettings.h"
#include "qgs3dtypes.h"
#include "qgsaabb.h"
#include "qgsmaterial.h"
#include "qgsray3d.h"
#include "qgsraycastresult.h"
 
#include <QMatrix3x3>
#include <QMatrix4x4>
#include <Qt3DCore/QGeometry>
#include <Qt3DRender/QCamera>
#include <Qt3DRender/QCullFace>
 
#define SIP_NO_FILE
 
class QgsCameraPose;
class QgsLineString;
class QgsPolygon;
class QgsFeedback;
 
class QgsAbstract3DEngine;
class QgsAbstract3DSymbol;
class Qgs3DMapScene;
class QgsPointCloudRenderer;
class QgsPointCloudLayer3DRenderer;
 
namespace Qt3DExtras
{
  class QPhongMaterial;
}
 
namespace Qt3DRender
{
  class QAbstractTexture;
}
 
class QSurface;
class Qgs3DRenderContext;
class QgsRayCastContext;
class QgsMaterialContext;

struct _3D_EXPORT QgsMeshNodeData
{
    std::unique_ptr<Qt3DCore::QGeometry> geometry; 
    std::unique_ptr<QgsMaterial> material;         
    QMatrix4x4 meshTransform;                      
};

class _3D_EXPORT Qgs3DUtils
{
  public:
    static QImage captureSceneImage( QgsAbstract3DEngine &engine, Qgs3DMapScene *scene );

    static void waitForFrame( QgsAbstract3DEngine &engine, Qgs3DMapScene *scene );

    static void waitForEntitiesLoaded( Qgs3DMapScene *scene );

    static QImage captureSceneDepthBuffer( QgsAbstract3DEngine &engine, Qgs3DMapScene *scene );

    static double calculateEntityGpuMemorySize( Qt3DCore::QEntity *entity );

    static bool exportAnimation(
      const Qgs3DAnimationSettings &animationSettings,
      Qgs3DMapSettings &mapSettings,
      int framesPerSecond,
      const QString &outputDirectory,
      const QString &fileNameTemplate,
      const QSize &outputSize,
      QString &error,
      QgsFeedback *feedback = nullptr
    );

    static int maxZoomLevel( double tile0width, double tileResolution, double maxError );

    static QString altClampingToString( Qgis::AltitudeClamping altClamp );
    static Qgis::AltitudeClamping altClampingFromString( const QString &str );

    static QString altBindingToString( Qgis::AltitudeBinding altBind );
    static Qgis::AltitudeBinding altBindingFromString( const QString &str );

    static QString cullingModeToString( Qgs3DTypes::CullingMode mode );
    static Qgs3DTypes::CullingMode cullingModeFromString( const QString &str );

    static float clampAltitude( const QgsPoint &p, Qgis::AltitudeClamping altClamp, Qgis::AltitudeBinding altBind, float offset, const QgsPoint &centroid, const Qgs3DRenderContext &context );
    static void clampAltitudes( QgsLineString *lineString, Qgis::AltitudeClamping altClamp, Qgis::AltitudeBinding altBind, const QgsPoint &centroid, float offset, const Qgs3DRenderContext &context );
    static bool clampAltitudes( QgsPolygon *polygon, Qgis::AltitudeClamping altClamp, Qgis::AltitudeBinding altBind, float offset, const Qgs3DRenderContext &context );

    static QString matrix4x4toString( const QMatrix4x4 &m );
    static QMatrix4x4 stringToMatrix4x4( const QString &str );

    static QColor srgbToLinear( const QColor &color );

    static void extractPointPositions(
      const QgsFeature &f,
      const Qgs3DRenderContext &context,
      const QgsVector3D &chunkOrigin,
      Qgis::AltitudeClamping altClamp,
      QVector<QVector3D> &positions,
      const QgsVector3D &translation = QgsVector3D( 0, 0, 0 )
    );

    static bool isCullable( const QgsAABB &bbox, const QMatrix4x4 &viewProjectionMatrix );

    static QgsVector3D mapToWorldCoordinates( const QgsVector3D &mapCoords, const QgsVector3D &origin );
    static QgsVector3D worldToMapCoordinates( const QgsVector3D &worldCoords, const QgsVector3D &origin );

    static QgsAABB layerToWorldExtent(
      const QgsRectangle &extent,
      double zMin,
      double zMax,
      const QgsCoordinateReferenceSystem &layerCrs,
      const QgsVector3D &mapOrigin,
      const QgsCoordinateReferenceSystem &mapCrs,
      const QgsCoordinateTransformContext &context
    );

    static QgsRectangle worldToLayerExtent(
      const QgsAABB &bbox, const QgsCoordinateReferenceSystem &layerCrs, const QgsVector3D &mapOrigin, const QgsCoordinateReferenceSystem &mapCrs, const QgsCoordinateTransformContext &context
    );

    static QgsAABB mapToWorldExtent( const QgsRectangle &extent, double zMin, double zMax, const QgsVector3D &mapOrigin );

    static QgsAABB mapToWorldExtent( const QgsBox3D &box3D, const QgsVector3D &mapOrigin );

    static QgsRectangle worldToMapExtent( const QgsAABB &bbox, const QgsVector3D &mapOrigin );

    static QgsVector3D transformWorldCoordinates(
      const QgsVector3D &worldPoint1,
      const QgsVector3D &origin1,
      const QgsCoordinateReferenceSystem &crs1,
      const QgsVector3D &origin2,
      const QgsCoordinateReferenceSystem &crs2,
      const QgsCoordinateTransformContext &context
    );

    static void estimateVectorLayerZRange( QgsVectorLayer *layer, double &zMin, double &zMax );

    static QgsPhongMaterialSettings phongMaterialFromQt3DComponent( Qt3DExtras::QPhongMaterial *material );

    static QgsRay3D rayFromScreenPoint( const QPoint &point, const QSize &windowSize, Qt3DRender::QCamera *camera );

    static QVector3D screenPointToWorldPos( const QPoint &screenPoint, double depth, const QSize &screenSize, Qt3DRender::QCamera *camera );

    static void pitchAndYawFromViewVector( QVector3D vect, double &pitch, double &yaw );

    static QVector2D screenToTextureCoordinates( QVector2D screenXY, QSize winSize );

    static QVector2D textureToScreenCoordinates( QVector2D textureXY, QSize winSize );

    static double decodeDepth( const QRgb &pixel ) { return ( ( qRed( pixel ) / 255.0 + qGreen( pixel ) ) / 255.0 + qBlue( pixel ) ) / 255.0; }

    static std::unique_ptr<QgsPointCloudLayer3DRenderer> convert2DPointCloudRendererTo3D( QgsPointCloudRenderer *renderer );

    static QgsRayCastResult castRay( Qgs3DMapScene *scene, const QgsRay3D &ray, const QgsRayCastContext &context );

    static QgsRectangle tryReprojectExtent2D( const QgsRectangle &extent, const QgsCoordinateReferenceSystem &crs1, const QgsCoordinateReferenceSystem &crs2, const QgsCoordinateTransformContext &context );

    static float screenSpaceError( float epsilon, float distance, int screenSize, float fov );

    static void computeBoundingBoxNearFarPlanes( const QgsAABB &bbox, const QMatrix4x4 &viewMatrix, float &fnear, float &ffar );

    static Qt3DRender::QCullFace::CullingMode qt3DcullingMode( Qgs3DTypes::CullingMode mode );

    static QByteArray addDefinesToShaderCode( const QByteArray &shaderCode, const QStringList &defines );

    static QMatrix4x4 axisTransformMatrix( const QString &upAxis, const QString &forwardAxis );

    static QByteArray removeDefinesFromShaderCode( const QByteArray &shaderCode, const QStringList &defines );

    static void decomposeTransformMatrix( const QMatrix4x4 &matrix, QVector3D &translation, QQuaternion &rotation, QVector3D &scale );

    static int openGlMaxClipPlanes( QSurface *surface );

    static QQuaternion rotationFromPitchHeadingAngles( float pitchAngle, float headingAngle );

    static QgsPoint screenPointToMapCoordinates( const QPoint &screenPoint, QSize size, const QgsCameraController *cameraController, const Qgs3DMapSettings *mapSettings );

    static QVector3D calculateDirectionalLightUpVector( const QVector3D &lightDirection );

    static std::vector<float> calculateCascadeSplits( int numberCascades, float nearPlane, float farPlane, float lambda = 0.9f );

    static void calculateFrustumSliceCorners( float zNear, float zFar, float fov, float aspectRatio, const QMatrix4x4 &invertedCameraView, QVector3D ( &corners )[8], QVector3D &center );

    static void calculateViewSpaceOrthographicBounds(
      const QVector3D ( &worldCorners )[8], const QMatrix4x4 &viewMatrix, float &left, float &right, float &bottom, float &top, float &nearPlane, float &farPlane
    );

    static QList<QVector4D> lineSegmentToClippingPlanes( const QgsVector3D &startPoint, const QgsVector3D &endPoint, double distance, const QgsVector3D &origin );

    static QgsCameraPose lineSegmentToCameraPose( const QgsVector3D &startPoint, const QgsVector3D &endPoint, const QgsDoubleRange &elevationRange, float fieldOfView, const QgsVector3D &worldOrigin );

    static std::unique_ptr<Qt3DRender::QCamera> copyCamera( Qt3DRender::QCamera *cam ) SIP_SKIP;

    static void setTextureFiltering( Qt3DRender::QAbstractTexture *texture, const QgsMaterialContext &context );
 
    // we start with a maximal z range because we can't know this upfront. There's too many
    // factors to consider eg vertex z data, terrain heights, data defined offsets and extrusion heights,...
    // This range will be refined after populating the nodes to the actual z range of the generated chunks nodes.
    // Assuming the vertical height is in meter, then it's extremely unlikely that a real vertical
    // height will exceed this amount!
    static constexpr double MINIMUM_VECTOR_Z_ESTIMATE = -100000;
    static constexpr double MAXIMUM_VECTOR_Z_ESTIMATE = 100000;
 
  private:
    static QVector3D axisStringToVector( const QString &axis );
};
 
#endif // QGS3DUTILS_H