44#include <Qt3DExtras/QPhongMaterial>
45#include <Qt3DRender/QRenderSettings>
46#include <QOpenGLContext>
47#include <QOpenGLFunctions>
48#include <Qt3DLogic/QFrameAction>
51#if QT_VERSION < QT_VERSION_CHECK( 6, 0, 0 )
52#include <Qt3DRender/QBuffer>
55#include <Qt3DCore/QBuffer>
65 Qt3DRender::QRenderSettings::RenderPolicy oldPolicy = engine.
renderSettings()->renderPolicy();
66 engine.
renderSettings()->setRenderPolicy( Qt3DRender::QRenderSettings::RenderPolicy::Always );
69 Qt3DLogic::QFrameAction *frameAction =
new Qt3DLogic::QFrameAction();
70 scene->addComponent( frameAction );
72 QObject::connect( frameAction, &Qt3DLogic::QFrameAction::triggered, &evLoop, &QEventLoop::quit );
74 scene->removeComponent( frameAction );
75 frameAction->deleteLater();
86 engine.
renderSettings()->setRenderPolicy( Qt3DRender::QRenderSettings::RenderPolicy::Always );
90 auto saveImageFcn = [&evLoop, &resImage](
const QImage &img ) {
96 QMetaObject::Connection conn2;
98 auto requestImageFcn = [&engine, scene] {
101 engine.
renderSettings()->setRenderPolicy( Qt3DRender::QRenderSettings::RenderPolicy::OnDemand );
118 QObject::disconnect( conn1 );
120 QObject::disconnect( conn2 );
122 engine.
renderSettings()->setRenderPolicy( Qt3DRender::QRenderSettings::RenderPolicy::OnDemand );
132 engine.
renderSettings()->setRenderPolicy( Qt3DRender::QRenderSettings::RenderPolicy::Always );
134 auto requestImageFcn = [&engine, scene] {
137 engine.
renderSettings()->setRenderPolicy( Qt3DRender::QRenderSettings::RenderPolicy::OnDemand );
142 auto saveImageFcn = [&evLoop, &resImage](
const QImage &img ) {
148 QMetaObject::Connection conn2;
164 QObject::disconnect( conn1 );
166 QObject::disconnect( conn2 );
168 engine.
renderSettings()->setRenderPolicy( Qt3DRender::QRenderSettings::RenderPolicy::OnDemand );
175 long long usedGpuMemory = 0;
178 usedGpuMemory += buffer->data().size();
180 for ( Qt3DRender::QTexture2D *tex : entity->findChildren<Qt3DRender::QTexture2D *>() )
183 usedGpuMemory += tex->width() * tex->height() * 4;
185 return usedGpuMemory / 1024.0 / 1024.0;
191 if ( animationSettings.
keyFrames().size() < 2 )
193 error = QObject::tr(
"Unable to export 3D animation. Add at least 2 keyframes" );
197 const float duration = animationSettings.
duration();
200 error = QObject::tr(
"Unable to export 3D animation (invalid duration)." );
206 const int totalFrames =
static_cast<int>( duration * framesPerSecond );
208 if ( fileNameTemplate.isEmpty() )
210 error = QObject::tr(
"Filename template is empty" );
214 const int numberOfDigits = fileNameTemplate.count( QLatin1Char(
'#' ) );
215 if ( numberOfDigits < 0 )
217 error = QObject::tr(
"Wrong filename template format (must contain #)" );
220 const QString token( numberOfDigits, QLatin1Char(
'#' ) );
221 if ( !fileNameTemplate.contains( token ) )
223 error = QObject::tr(
"Filename template must contain all # placeholders in one continuous group." );
227 if ( !QDir().exists( outputDirectory ) )
229 if ( !QDir().mkpath( outputDirectory ) )
231 error = QObject::tr(
"Output directory could not be created." );
241 engine.
renderSettings()->setRenderPolicy( Qt3DRender::QRenderSettings::RenderPolicy::Always );
243 while ( time <= duration )
249 error = QObject::tr(
"Export canceled" );
252 feedback->
setProgress( frameNo /
static_cast<double>( totalFrames ) * 100 );
259 QString fileName( fileNameTemplate );
260 const QString frameNoPaddedLeft( QStringLiteral(
"%1" ).arg( frameNo, numberOfDigits, 10, QChar(
'0' ) ) );
261 fileName.replace( token, frameNoPaddedLeft );
262 const QString path = QDir( outputDirectory ).filePath( fileName );
268 time += 1.0f /
static_cast<float>( framesPerSecond );
277 if ( maxError <= 0 || tileResolution <= 0 || tile0width <= 0 )
284 const double zoomLevel = -log( tileResolution * maxError / tile0width ) / log( 2 );
285 return round( zoomLevel );
293 return QStringLiteral(
"absolute" );
295 return QStringLiteral(
"relative" );
297 return QStringLiteral(
"terrain" );
305 if ( str == QLatin1String(
"absolute" ) )
307 else if ( str == QLatin1String(
"terrain" ) )
319 return QStringLiteral(
"vertex" );
321 return QStringLiteral(
"centroid" );
329 if ( str == QLatin1String(
"vertex" ) )
340 return QStringLiteral(
"no-culling" );
342 return QStringLiteral(
"front" );
344 return QStringLiteral(
"back" );
346 return QStringLiteral(
"front-and-back" );
353 if ( str == QLatin1String(
"front" ) )
355 else if ( str == QLatin1String(
"back" ) )
357 else if ( str == QLatin1String(
"front-and-back" ) )
413 pt.
setX( lineString->
xAt( i ) );
414 pt.
setY( lineString->
yAt( i ) );
418 pt.
set( centroid.
x(), centroid.
y() );
436 geomZ = lineString->
zAt( i );
444 lineString->
setZAt( i, z );
451 if ( !polygon->
is3D() )
466 QgsLineString *lineString = qgsgeometry_cast<QgsLineString *>( curve );
470 clampAltitudes( lineString, altClamp, altBind, centroid, offset, context );
475 QgsLineString *lineString = qgsgeometry_cast<QgsLineString *>( curve );
479 clampAltitudes( lineString, altClamp, altBind, centroid, offset, context );
487 const float *d = m.constData();
490 for (
int i = 0; i < 16; ++i )
491 elems << QString::number( d[i] );
492 return elems.join(
' ' );
499 QStringList elems = str.split(
' ' );
500 for (
int i = 0; i < 16; ++i )
501 d[i] = elems[i].toFloat();
527 h = terrainZ + geomZ;
530 positions.append( QVector3D(
531 static_cast<float>( pt.
x() - chunkOrigin.
x() ),
532 static_cast<float>( pt.
y() - chunkOrigin.
y() ),
535 QgsDebugMsgLevel( QStringLiteral(
"%1 %2 %3" ).arg( positions.last().x() ).arg( positions.last().y() ).arg( positions.last().z() ), 2 );
544static inline uint outcode( QVector4D v )
554 if ( v.x() < -v.w() )
558 if ( v.y() < -v.w() )
562 if ( v.z() < -v.w() )
584 for (
int i = 0; i < 8; ++i )
586 const QVector4D p( ( ( i >> 0 ) & 1 ) ? bbox.
xMin : bbox.
xMax, ( ( i >> 1 ) & 1 ) ? bbox.
yMin : bbox.
yMax, ( ( i >> 2 ) & 1 ) ? bbox.
zMin : bbox.
zMax, 1 );
587 const QVector4D pc = viewProjectionMatrix * p;
591 out = out & outcode( pc );
598 return QgsVector3D( mapCoords.
x() - origin.
x(), mapCoords.
y() - origin.
y(), mapCoords.
z() - origin.
z() );
603 return QgsVector3D( worldCoords.
x() + origin.
x(), worldCoords.
y() + origin.
y(), worldCoords.
z() + origin.
z() );
621 QgsDebugError( QStringLiteral(
"3D utils: transformation of extent failed: " ) + extentMapCrs.
toString( -1 ) );
645 QgsAABB rootBbox( worldExtentMin3D.
x(), worldExtentMin3D.
y(), worldExtentMin3D.
z(), worldExtentMax3D.
x(), worldExtentMax3D.
y(), worldExtentMax3D.
z() );
656 return QgsAABB(
static_cast<float>( worldExtentMin3D.
x() ),
static_cast<float>( worldExtentMin3D.
y() ),
static_cast<float>( worldExtentMin3D.
z() ),
static_cast<float>( worldExtentMax3D.
x() ),
static_cast<float>( worldExtentMax3D.
y() ),
static_cast<float>( worldExtentMax3D.
z() ) );
663 const QgsRectangle extentMap( worldExtentMin3D.
x(), worldExtentMin3D.
y(), worldExtentMax3D.
x(), worldExtentMax3D.
y() );
680 mapPoint2.
set( pt.
x(), pt.
y(), mapPoint1.
z() );
699 zMin = std::numeric_limits<double>::max();
700 zMax = std::numeric_limits<double>::lowest();
709 const double z = ( *vit ).z();
717 if ( zMin == std::numeric_limits<double>::max() && zMax == std::numeric_limits<double>::lowest() )
745 const QVector3D deviceCoords( point.x(), point.y(), 0.0 );
747 const QVector3D normDeviceCoords( 2.0 * deviceCoords.x() / windowSize.width() - 1.0f, 1.0f - 2.0 * deviceCoords.y() / windowSize.height(), camera->nearPlane() );
749 const QVector4D rayClip( normDeviceCoords.x(), normDeviceCoords.y(), -1.0, 0.0 );
751 const QMatrix4x4 invertedProjMatrix = camera->projectionMatrix().inverted();
752 const QMatrix4x4 invertedViewMatrix = camera->viewMatrix().inverted();
755 QVector4D rayDirView = invertedProjMatrix * rayClip;
757 const QVector4D rayOriginWorld = invertedViewMatrix * QVector4D( 0.0f, 0.0f, 0.0f, 1.0f );
760 rayDirView.setZ( -1.0f );
761 rayDirView.setW( 0.0f );
762 const QVector4D rayDirWorld4D = invertedViewMatrix * rayDirView;
763 QVector3D rayDirWorld( rayDirWorld4D.x(), rayDirWorld4D.y(), rayDirWorld4D.z() );
764 rayDirWorld = rayDirWorld.normalized();
766 return QgsRay3D( QVector3D( rayOriginWorld ), rayDirWorld );
771 double dNear = camera->nearPlane();
772 double dFar = camera->farPlane();
773 double distance = ( 2.0 * dNear * dFar ) / ( dFar + dNear - ( depth * 2 - 1 ) * ( dFar - dNear ) );
776 double dot = QVector3D::dotProduct( ray.
direction(), camera->viewVector().normalized() );
786 pitch = qRadiansToDegrees( qAcos( vect.y() ) );
787 yaw = qRadiansToDegrees( qAtan2( -vect.z(), vect.x() ) ) + 90;
792 return QVector2D( screenXY.x() / winSize.width(), 1 - screenXY.y() / winSize.width() );
797 return QVector2D( textureXY.x() * winSize.width(), ( 1 - textureXY.y() ) * winSize.height() );
805 std::unique_ptr<QgsPointCloud3DSymbol> symbol3D;
806 if ( renderer->
type() == QLatin1String(
"ramp" ) )
809 symbol3D = std::make_unique<QgsColorRampPointCloud3DSymbol>();
815 else if ( renderer->
type() == QLatin1String(
"rgb" ) )
818 symbol3D = std::make_unique<QgsRgbPointCloud3DSymbol>();
828 else if ( renderer->
type() == QLatin1String(
"classified" ) )
831 symbol3D = std::make_unique<QgsClassificationPointCloud3DSymbol>();
839 auto renderer3D = std::make_unique<QgsPointCloudLayer3DRenderer>();
840 renderer3D->setSymbol( symbol3D.release() );
849 QHash<QgsMapLayer *, QVector<QgsRayCastingUtils::RayHit>> results;
850 const QList<QgsMapLayer *> keys = scene->
layers();
853 Qt3DCore::QEntity *entity = scene->
layerEntity( layer );
855 if ( QgsChunkedEntity *chunkedEntity = qobject_cast<QgsChunkedEntity *>( entity ) )
857 const QVector<QgsRayCastingUtils::RayHit> result = chunkedEntity->rayIntersection( r, context );
858 if ( !result.isEmpty() )
859 results[layer] = result;
864 const QVector<QgsRayCastingUtils::RayHit> result = terrain->rayIntersection( r, context );
865 if ( !result.isEmpty() )
866 results[
nullptr] = result;
893 float phi = epsilon *
static_cast<float>( screenSize ) /
static_cast<float>( 2 * distance * tan( fov * M_PI / ( 2 * 180 ) ) );
902 for (
int i = 0; i < 8; ++i )
904 const QVector4D p( ( ( i >> 0 ) & 1 ) ? bbox.
xMin : bbox.
xMax, ( ( i >> 1 ) & 1 ) ? bbox.
yMin : bbox.
yMax, ( ( i >> 2 ) & 1 ) ? bbox.
zMin : bbox.
zMax, 1 );
906 const QVector4D pc = viewMatrix * p;
908 const float dst = -pc.z();
909 fnear = std::min( fnear, dst );
910 ffar = std::max( ffar, dst );
919 return Qt3DRender::QCullFace::NoCulling;
921 return Qt3DRender::QCullFace::Front;
923 return Qt3DRender::QCullFace::Back;
925 return Qt3DRender::QCullFace::FrontAndBack;
927 return Qt3DRender::QCullFace::NoCulling;
937 QStringList defineLines;
938 for (
const QString &define : defines )
939 defineLines +=
"#define " + define +
"\n";
941 QString definesText = defineLines.join( QString() );
943 QByteArray newShaderCode = shaderCode;
944 int versionIndex = shaderCode.indexOf(
"#version " );
945 int insertionIndex = versionIndex == -1 ? 0 : shaderCode.indexOf(
'\n', versionIndex + 1 ) + 1;
946 newShaderCode.insert( insertionIndex, definesText.toLatin1() );
947 return newShaderCode;
952 QByteArray newShaderCode = shaderCode;
954 for (
const QString &define : defines )
956 const QString defineLine =
"#define " + define +
"\n";
957 const int defineLineIndex = newShaderCode.indexOf( defineLine.toUtf8() );
958 if ( defineLineIndex != -1 )
960 newShaderCode.remove( defineLineIndex, defineLine.size() );
964 return newShaderCode;
972 const float *md = matrix.data();
973 const float sx = QVector3D( md[0], md[1], md[2] ).length();
974 const float sy = QVector3D( md[4], md[5], md[6] ).length();
975 const float sz = QVector3D( md[8], md[9], md[10] ).length();
987 const QMatrix3x3 rot3x3( rd );
989 scale = QVector3D( sx, sy, sz );
990 rotation = QQuaternion::fromRotationMatrix( rot3x3 );
991 translation = QVector3D( md[12], md[13], md[14] );
998 QOpenGLContext context;
999 context.setFormat( QSurfaceFormat::defaultFormat() );
1000 if ( context.create() )
1002 if ( context.makeCurrent( surface ) )
1004 QOpenGLFunctions *funcs = context.functions();
1005 funcs->glGetIntegerv( GL_MAX_CLIP_PLANES, &numPlanes );
1014 return QQuaternion::fromAxisAndAngle( QVector3D( 0, 0, 1 ), headingAngle ) * QQuaternion::fromAxisAndAngle( QVector3D( 1, 0, 0 ), pitchAngle );
AltitudeClamping
Altitude clamping.
@ Relative
Elevation is relative to terrain height (final elevation = terrain elevation + feature elevation)
@ Terrain
Elevation is clamped to terrain (final elevation = terrain elevation)
@ Absolute
Elevation is taken directly from feature and is independent of terrain height (final elevation = feat...
AltitudeBinding
Altitude binding.
@ Centroid
Clamp just centroid of feature.
@ Vertex
Clamp every vertex of feature.
Keyframe interpolate(float time) const
Interpolates camera position and rotation at the given point in time.
float duration() const
Returns duration of the whole animation in seconds.
Keyframes keyFrames() const
Returns keyframes of the animation.
QgsCameraController * cameraController() const
Returns camera controller.
@ Ready
The scene is fully loaded/updated.
QgsTerrainEntity * terrainEntity()
Returns terrain entity (may be temporarily nullptr)
Qt3DCore::QEntity * layerEntity(QgsMapLayer *layer) const
Returns the entity belonging to layer.
void sceneStateChanged()
Emitted when the scene's state has changed.
SceneState sceneState() const
Returns the current state of the scene.
QList< QgsMapLayer * > layers() const
Returns the layers that contain chunked entities.
const QgsAbstractTerrainSettings * terrainSettings() const
Returns the terrain settings.
QgsTerrainGenerator * terrainGenerator() const
Returns the terrain generator.
bool terrainRenderingEnabled() const
Returns whether the 2D terrain surface will be rendered.
static const char * PROP_NAME_3D_RENDERER_FLAG
Qt property name to hold the 3D geometry renderer flag.
CullingMode
Triangle culling mode.
@ FrontAndBack
Will not render anything.
@ NoCulling
Will render both front and back faces of triangles.
@ Front
Will render only back faces of triangles.
@ Back
Will render only front faces of triangles (recommended when input data are consistent)
static QgsVector3D transformWorldCoordinates(const QgsVector3D &worldPoint1, const QgsVector3D &origin1, const QgsCoordinateReferenceSystem &crs1, const QgsVector3D &origin2, const QgsCoordinateReferenceSystem &crs2, const QgsCoordinateTransformContext &context)
Transforms a world point from (origin1, crs1) to (origin2, crs2)
static QQuaternion rotationFromPitchHeadingAngles(float pitchAngle, float headingAngle)
Returns rotation quaternion that performs rotation around X axis by pitchAngle, followed by rotation ...
static QByteArray removeDefinesFromShaderCode(const QByteArray &shaderCode, const QStringList &defines)
Removes some define macros from a shader source code.
static Qt3DRender::QCullFace::CullingMode qt3DcullingMode(Qgs3DTypes::CullingMode mode)
Converts Qgs3DTypes::CullingMode mode into its Qt3D equivalent.
static Qgs3DTypes::CullingMode cullingModeFromString(const QString &str)
Converts a string to a value from CullingMode enum.
static Qgis::AltitudeClamping altClampingFromString(const QString &str)
Converts a string to a value from AltitudeClamping enum.
static QString matrix4x4toString(const QMatrix4x4 &m)
Converts a 4x4 transform matrix to a string.
static QgsRectangle worldToMapExtent(const QgsAABB &bbox, const QgsVector3D &mapOrigin)
Converts axis aligned bounding box in 3D world coordinates to extent in map coordinates.
static QgsRectangle worldToLayerExtent(const QgsAABB &bbox, const QgsCoordinateReferenceSystem &layerCrs, const QgsVector3D &mapOrigin, const QgsCoordinateReferenceSystem &mapCrs, const QgsCoordinateTransformContext &context)
Converts axis aligned bounding box in 3D world coordinates to extent in map layer CRS.
static void pitchAndYawFromViewVector(QVector3D vect, double &pitch, double &yaw)
Function used to extract the pitch and yaw (also known as heading) angles in degrees from the view ve...
static void decomposeTransformMatrix(const QMatrix4x4 &matrix, QVector3D &translation, QQuaternion &rotation, QVector3D &scale)
Tries to decompose a 4x4 transform matrix into translation, rotation and scale components.
static int maxZoomLevel(double tile0width, double tileResolution, double maxError)
Calculates the highest needed zoom level for tiles in quad-tree given width of the base tile (zoom le...
static QgsAABB mapToWorldExtent(const QgsRectangle &extent, double zMin, double zMax, const QgsVector3D &mapOrigin)
Converts map extent to axis aligned bounding box in 3D world coordinates.
static QgsAABB layerToWorldExtent(const QgsRectangle &extent, double zMin, double zMax, const QgsCoordinateReferenceSystem &layerCrs, const QgsVector3D &mapOrigin, const QgsCoordinateReferenceSystem &mapCrs, const QgsCoordinateTransformContext &context)
Converts extent (in map layer's CRS) to axis aligned bounding box in 3D world coordinates.
static Qgis::AltitudeBinding altBindingFromString(const QString &str)
Converts a string to a value from AltitudeBinding enum.
static double calculateEntityGpuMemorySize(Qt3DCore::QEntity *entity)
Calculates approximate usage of GPU memory by an entity.
static QString cullingModeToString(Qgs3DTypes::CullingMode mode)
Converts a value from CullingMode enum to a string.
static QHash< QgsMapLayer *, QVector< QgsRayCastingUtils::RayHit > > castRay(Qgs3DMapScene *scene, const QgsRay3D &ray, const QgsRayCastingUtils::RayCastContext &context)
Casts a ray through the scene and returns information about the intersecting entities (ray uses World...
static bool isCullable(const QgsAABB &bbox, const QMatrix4x4 &viewProjectionMatrix)
Returns true if bbox is completely outside the current viewing volume.
static QVector2D screenToTextureCoordinates(QVector2D screenXY, QSize winSize)
Converts from screen coordinates to texture coordinates.
static float screenSpaceError(float epsilon, float distance, int screenSize, float fov)
This routine approximately calculates how an error (epsilon) of an object in world coordinates at giv...
static void estimateVectorLayerZRange(QgsVectorLayer *layer, double &zMin, double &zMax)
Try to estimate range of Z values used in the given vector layer and store that in zMin and zMax.
static QgsPhongMaterialSettings phongMaterialFromQt3DComponent(Qt3DExtras::QPhongMaterial *material)
Returns phong material settings object based on the Qt3D material.
static QString altClampingToString(Qgis::AltitudeClamping altClamp)
Converts a value from AltitudeClamping enum to a string.
static QgsRectangle tryReprojectExtent2D(const QgsRectangle &extent, const QgsCoordinateReferenceSystem &crs1, const QgsCoordinateReferenceSystem &crs2, const QgsCoordinateTransformContext &context)
Reprojects extent from crs1 to crs2 coordinate reference system with context context.
static QByteArray addDefinesToShaderCode(const QByteArray &shaderCode, const QStringList &defines)
Inserts some define macros into a shader source code.
static QMatrix4x4 stringToMatrix4x4(const QString &str)
Convert a string to a 4x4 transform matrix.
static QgsVector3D worldToMapCoordinates(const QgsVector3D &worldCoords, const QgsVector3D &origin)
Converts 3D world coordinates to map coordinates (applies offset)
static QgsVector3D mapToWorldCoordinates(const QgsVector3D &mapCoords, const QgsVector3D &origin)
Converts map coordinates to 3D world coordinates (applies offset)
static QVector2D textureToScreenCoordinates(QVector2D textureXY, QSize winSize)
Converts from texture coordinates coordinates to screen coordinates.
static void computeBoundingBoxNearFarPlanes(const QgsAABB &bbox, const QMatrix4x4 &viewMatrix, float &fnear, float &ffar)
This routine computes nearPlane farPlane from the closest and farthest corners point of bounding box ...
static bool exportAnimation(const Qgs3DAnimationSettings &animationSettings, Qgs3DMapSettings &mapSettings, int framesPerSecond, const QString &outputDirectory, const QString &fileNameTemplate, const QSize &outputSize, QString &error, QgsFeedback *feedback=nullptr)
Captures 3D animation frames to the selected folder.
static QVector3D screenPointToWorldPos(const QPoint &screenPoint, double depth, const QSize &screenSize, Qt3DRender::QCamera *camera)
Converts the clicked mouse position to the corresponding 3D world coordinates.
static void waitForFrame(QgsAbstract3DEngine &engine, Qgs3DMapScene *scene)
Waits for a frame to be rendered.
static float clampAltitude(const QgsPoint &p, Qgis::AltitudeClamping altClamp, Qgis::AltitudeBinding altBind, float offset, const QgsPoint ¢roid, const Qgs3DRenderContext &context)
Clamps altitude of a vertex according to the settings, returns Z value.
static QString altBindingToString(Qgis::AltitudeBinding altBind)
Converts a value from AltitudeBinding enum to a string.
static void clampAltitudes(QgsLineString *lineString, Qgis::AltitudeClamping altClamp, Qgis::AltitudeBinding altBind, const QgsPoint ¢roid, float offset, const Qgs3DRenderContext &context)
Clamps altitude of vertices of a linestring according to the settings.
static QgsRay3D rayFromScreenPoint(const QPoint &point, const QSize &windowSize, Qt3DRender::QCamera *camera)
Convert from clicked point on the screen to a ray in world coordinates.
static QImage captureSceneImage(QgsAbstract3DEngine &engine, Qgs3DMapScene *scene)
Captures image of the current 3D scene of a 3D engine.
static std::unique_ptr< QgsPointCloudLayer3DRenderer > convert2DPointCloudRendererTo3D(QgsPointCloudRenderer *renderer)
Creates a QgsPointCloudLayer3DRenderer matching the symbol settings of a given QgsPointCloudRenderer.
static void extractPointPositions(const QgsFeature &f, const Qgs3DRenderContext &context, const QgsVector3D &chunkOrigin, Qgis::AltitudeClamping altClamp, QVector< QVector3D > &positions)
Calculates (x,y,z) positions of (multi)point from the given feature.
static QImage captureSceneDepthBuffer(QgsAbstract3DEngine &engine, Qgs3DMapScene *scene)
Captures the depth buffer of the current 3D scene of a 3D engine.
static int openGlMaxClipPlanes(QSurface *surface)
Gets the maximum number of clip planes that can be used.
static QgsExpressionContext globalProjectLayerExpressionContext(QgsVectorLayer *layer)
Returns expression context for use in preparation of 3D data of a layer.
void requestCaptureImage()
Starts a request for an image rendered by the engine.
void requestDepthBufferCapture()
Starts a request for an image containing the depth buffer data of the engine.
void imageCaptured(const QImage &image)
Emitted after a call to requestCaptureImage() to return the captured image.
void depthBufferCaptured(const QImage &image)
Emitted after a call to requestDepthBufferCapture() to return the captured depth buffer.
virtual Qt3DRender::QRenderSettings * renderSettings()=0
Returns access to the engine's render settings (the frame graph can be accessed from here)
Abstract base class for all geometries.
vertex_iterator vertices_end() const
Returns STL-style iterator pointing to the imaginary vertex after the last vertex of the geometry.
bool is3D() const
Returns true if the geometry is 3D and contains a z-value.
vertex_iterator vertices_begin() const
Returns STL-style iterator pointing to the first vertex of the geometry.
virtual QgsPoint centroid() const
Returns the centroid of the geometry.
double verticalScale() const
Returns the vertical scale (exaggeration) for terrain.
A 3-dimensional box composed of x, y, z coordinates.
double yMaximum() const
Returns the maximum y value.
double xMinimum() const
Returns the minimum x value.
double zMaximum() const
Returns the maximum z value.
double xMaximum() const
Returns the maximum x value.
double zMinimum() const
Returns the minimum z value.
double yMinimum() const
Returns the minimum y value.
void setLookingAtPoint(const QgsVector3D &point, float distance, float pitch, float yaw)
Sets the complete camera configuration: the point towards it is looking (in 3D world coordinates),...
void setCategoriesList(const QgsPointCloudCategoryList &categories)
Sets the list of categories of the classification.
void setAttribute(const QString &attribute)
Sets the attribute used to select the color of the point cloud.
void setAttribute(const QString &attribute)
Sets the attribute used to select the color of the point cloud.
void setColorRampShaderMinMax(double min, double max)
Sets the minimum and maximum values used when classifying colors in the color ramp shader.
void setColorRampShader(const QgsColorRampShader &colorRampShader)
Sets the color ramp shader used to render the point cloud.
Manipulates raster or point cloud pixel values so that they enhanceContrast or clip into a specified ...
This class represents a coordinate reference system (CRS).
Contains information about the context in which a coordinate transform is executed.
Custom exception class for Coordinate Reference System related exceptions.
int numInteriorRings() const
Returns the number of interior rings contained with the curve polygon.
bool addZValue(double zValue=0) override
Adds a z-dimension to the geometry, initialized to a preset value.
const QgsCurve * exteriorRing() const
Returns the curve polygon's exterior ring.
const QgsCurve * interiorRing(int i) const
Retrieves an interior ring from the curve polygon.
Abstract base class for curved geometry type.
static QgsExpressionContextScope * projectScope(const QgsProject *project)
Creates a new scope which contains variables and functions relating to a QGIS project.
static QgsExpressionContextScope * layerScope(const QgsMapLayer *layer)
Creates a new scope which contains variables and functions relating to a QgsMapLayer.
static QgsExpressionContextScope * globalScope()
Creates a new scope which contains variables and functions relating to the global QGIS context.
Expression contexts are used to encapsulate the parameters around which a QgsExpression should be eva...
Wrapper for iterator of features from vector data provider or vector layer.
bool nextFeature(QgsFeature &f)
Fetch next feature and stores in f, returns true on success.
This class wraps a request for features to a vector layer (or directly its vector data provider).
The feature class encapsulates a single feature including its unique ID, geometry and a list of field...
Base class for feedback objects to be used for cancellation of something running in a worker thread.
bool isCanceled() const
Tells whether the operation has been canceled already.
void setProgress(double progress)
Sets the current progress for the feedback object.
A geometry is the spatial representation of a feature.
const QgsAbstractGeometry * constGet() const
Returns a non-modifiable (const) reference to the underlying abstract geometry primitive.
QgsAbstractGeometry::vertex_iterator vertices_begin() const
Returns STL-style iterator pointing to the first vertex of the geometry.
QgsAbstractGeometry::vertex_iterator vertices_end() const
Returns STL-style iterator pointing to the imaginary vertex after the last vertex of the geometry.
Line string geometry type, with support for z-dimension and m-values.
int nCoordinates() const override
Returns the number of nodes contained in the geometry.
double yAt(int index) const override
Returns the y-coordinate of the specified node in the line string.
void setZAt(int index, double z)
Sets the z-coordinate of the specified node in the line string.
double zAt(int index) const override
Returns the z-coordinate of the specified node in the line string.
double xAt(int index) const override
Returns the x-coordinate of the specified node in the line string.
Base class for all map layer types.
void setSize(QSize s) override
Sets the size of the rendering area (in pixels)
void setRootEntity(Qt3DCore::QEntity *root) override
Sets root entity of the 3D scene.
Qt3DRender::QRenderSettings * renderSettings() override
Returns access to the engine's render settings (the frame graph can be accessed from here)
void setDiffuse(const QColor &diffuse)
Sets diffuse color component.
void setShininess(double shininess)
Sets shininess of the surface.
void setAmbient(const QColor &ambient)
Sets ambient color component.
void setSpecular(const QColor &specular)
Sets specular color component.
An RGB renderer for 2d visualisation of point clouds using embedded red, green and blue attributes.
double maximum() const
Returns the maximum value for attributes which will be used by the color ramp shader.
QgsColorRampShader colorRampShader() const
Returns the color ramp shader function used to visualize the attribute.
double minimum() const
Returns the minimum value for attributes which will be used by the color ramp shader.
QString attribute() const
Returns the attribute to use for the renderer.
Renders point clouds by a classification attribute.
QString attribute() const
Returns the attribute to use for the renderer.
QgsPointCloudCategoryList categories() const
Returns the classification categories used for rendering.
Abstract base class for 2d point cloud renderers.
virtual QString type() const =0
Returns the identifier of the renderer type.
An RGB renderer for 2d visualisation of point clouds using embedded red, green and blue attributes.
QString redAttribute() const
Returns the attribute to use for the red channel.
QString greenAttribute() const
Returns the attribute to use for the green channel.
const QgsContrastEnhancement * greenContrastEnhancement() const
Returns the contrast enhancement to use for the green channel.
QString blueAttribute() const
Returns the attribute to use for the blue channel.
const QgsContrastEnhancement * blueContrastEnhancement() const
Returns the contrast enhancement to use for the blue channel.
const QgsContrastEnhancement * redContrastEnhancement() const
Returns the contrast enhancement to use for the red channel.
A class to represent a 2D point.
void setY(double y)
Sets the y value of the point.
void set(double x, double y)
Sets the x and y value of the point.
void setX(double x)
Sets the x value of the point.
Point geometry type, with support for z-dimension and m-values.
static QgsProject * instance()
Returns the QgsProject singleton instance.
A representation of a ray in 3D.
QVector3D origin() const
Returns the origin of the ray.
QVector3D direction() const
Returns the direction of the ray see setDirection()
A rectangle specified with double values.
Q_INVOKABLE QString toString(int precision=16) const
Returns a string representation of form xmin,ymin : xmax,ymax Coordinates will be truncated to the sp...
void setBlueAttribute(const QString &attribute)
Sets the attribute to use for the blue channel.
void setGreenContrastEnhancement(QgsContrastEnhancement *enhancement SIP_TRANSFER)
Sets the contrast enhancement to use for the green channel.
void setGreenAttribute(const QString &attribute)
Sets the attribute to use for the green channel.
void setBlueContrastEnhancement(QgsContrastEnhancement *enhancement SIP_TRANSFER)
Sets the contrast enhancement to use for the blue channel.
void setRedContrastEnhancement(QgsContrastEnhancement *enhancement SIP_TRANSFER)
Sets the contrast enhancement to use for the red channel.
void setRedAttribute(const QString &attribute)
Sets the attribute to use for the red channel.
virtual float heightAt(double x, double y, const Qgs3DRenderContext &context) const
Returns height at (x,y) in map's CRS.
Class for storage of 3D vectors similar to QVector3D, with the difference that it uses double precisi...
double y() const
Returns Y coordinate.
double z() const
Returns Z coordinate.
double x() const
Returns X coordinate.
void set(double x, double y, double z)
Sets vector coordinates.
Represents a vector layer which manages a vector based data sets.
QgsFeatureIterator getFeatures(const QgsFeatureRequest &request=QgsFeatureRequest()) const FINAL
Queries the layer for features specified in request.
Q_INVOKABLE Qgis::WkbType wkbType() const FINAL
Returns the WKBType or WKBUnknown in case of error.
static bool hasZ(Qgis::WkbType type)
Tests whether a WKB type contains the z-dimension.
#define BUILTIN_UNREACHABLE
Qt3DCore::QBuffer Qt3DQBuffer
Qt3DCore::QBuffer Qt3DQBuffer
#define QgsDebugMsgLevel(str, level)
#define QgsDebugError(str)
float pitch
Tilt of the camera in degrees (0 = looking from the top, 90 = looking from the side,...
float yaw
Horizontal rotation around the focal point in degrees.
QgsVector3D point
Point towards which the camera is looking in 3D world coords.
float dist
Distance of the camera from the focal point.
Helper struct to store ray casting parameters.
float maxDistance
The maximum distance from ray origin to look for hits when casting a ray.