QGIS API Documentation 3.41.0-Master (88383c3d16f)
Loading...
Searching...
No Matches
qgs3dutils.cpp
Go to the documentation of this file.
1/***************************************************************************
2 qgs3dutils.cpp
3 --------------------------------------
4 Date : July 2017
5 Copyright : (C) 2017 by Martin Dobias
6 Email : wonder dot sk at gmail dot com
7 ***************************************************************************
8 * *
9 * This program is free software; you can redistribute it and/or modify *
10 * it under the terms of the GNU General Public License as published by *
11 * the Free Software Foundation; either version 2 of the License, or *
12 * (at your option) any later version. *
13 * *
14 ***************************************************************************/
15
16#include "qgs3dutils.h"
17
18#include "qgslinestring.h"
19#include "qgspolygon.h"
20#include "qgsfeaturerequest.h"
21#include "qgsfeatureiterator.h"
22#include "qgsfeature.h"
23#include "qgsabstractgeometry.h"
24#include "qgsvectorlayer.h"
26#include "qgsfeedback.h"
28#include "qgs3dmapscene.h"
29#include "qgsabstract3dengine.h"
30#include "qgsterraingenerator.h"
31#include "qgscameracontroller.h"
32#include "qgschunkedentity.h"
33#include "qgsterrainentity.h"
42
43#include <QtMath>
44#include <Qt3DExtras/QPhongMaterial>
45#include <Qt3DRender/QRenderSettings>
46#include <QOpenGLContext>
47#include <QOpenGLFunctions>
48#include <Qt3DLogic/QFrameAction>
49
50
51#if QT_VERSION < QT_VERSION_CHECK( 6, 0, 0 )
52#include <Qt3DRender/QBuffer>
53typedef Qt3DRender::QBuffer Qt3DQBuffer;
54#else
55#include <Qt3DCore/QBuffer>
56typedef Qt3DCore::QBuffer Qt3DQBuffer;
57#endif
58
59// declared here as Qgs3DTypes has no cpp file
60const char *Qgs3DTypes::PROP_NAME_3D_RENDERER_FLAG = "PROP_NAME_3D_RENDERER_FLAG";
61
63{
64 // Set policy to always render frame, so we don't wait forever.
65 Qt3DRender::QRenderSettings::RenderPolicy oldPolicy = engine.renderSettings()->renderPolicy();
66 engine.renderSettings()->setRenderPolicy( Qt3DRender::QRenderSettings::RenderPolicy::Always );
67
68 // Wait for at least one frame to render
69 Qt3DLogic::QFrameAction *frameAction = new Qt3DLogic::QFrameAction();
70 scene->addComponent( frameAction );
71 QEventLoop evLoop;
72 QObject::connect( frameAction, &Qt3DLogic::QFrameAction::triggered, &evLoop, &QEventLoop::quit );
73 evLoop.exec();
74 scene->removeComponent( frameAction );
75 frameAction->deleteLater();
76
77 engine.renderSettings()->setRenderPolicy( oldPolicy );
78}
79
81{
82 QImage resImage;
83 QEventLoop evLoop;
84
85 // We need to change render policy to RenderPolicy::Always, since otherwise render capture node won't work
86 engine.renderSettings()->setRenderPolicy( Qt3DRender::QRenderSettings::RenderPolicy::Always );
87
88 waitForFrame( engine, scene );
89
90 auto saveImageFcn = [&evLoop, &resImage]( const QImage &img ) {
91 resImage = img;
92 evLoop.quit();
93 };
94
95 const QMetaObject::Connection conn1 = QObject::connect( &engine, &QgsAbstract3DEngine::imageCaptured, saveImageFcn );
96 QMetaObject::Connection conn2;
97
98 auto requestImageFcn = [&engine, scene] {
99 if ( scene->sceneState() == Qgs3DMapScene::Ready )
100 {
101 engine.renderSettings()->setRenderPolicy( Qt3DRender::QRenderSettings::RenderPolicy::OnDemand );
102 engine.requestCaptureImage();
103 }
104 };
105
106 if ( scene->sceneState() == Qgs3DMapScene::Ready )
107 {
108 requestImageFcn();
109 }
110 else
111 {
112 // first wait until scene is loaded
113 conn2 = QObject::connect( scene, &Qgs3DMapScene::sceneStateChanged, requestImageFcn );
114 }
115
116 evLoop.exec();
117
118 QObject::disconnect( conn1 );
119 if ( conn2 )
120 QObject::disconnect( conn2 );
121
122 engine.renderSettings()->setRenderPolicy( Qt3DRender::QRenderSettings::RenderPolicy::OnDemand );
123 return resImage;
124}
125
127{
128 QImage resImage;
129 QEventLoop evLoop;
130
131 // We need to change render policy to RenderPolicy::Always, since otherwise render capture node won't work
132 engine.renderSettings()->setRenderPolicy( Qt3DRender::QRenderSettings::RenderPolicy::Always );
133
134 auto requestImageFcn = [&engine, scene] {
135 if ( scene->sceneState() == Qgs3DMapScene::Ready )
136 {
137 engine.renderSettings()->setRenderPolicy( Qt3DRender::QRenderSettings::RenderPolicy::OnDemand );
139 }
140 };
141
142 auto saveImageFcn = [&evLoop, &resImage]( const QImage &img ) {
143 resImage = img;
144 evLoop.quit();
145 };
146
147 QMetaObject::Connection conn1 = QObject::connect( &engine, &QgsAbstract3DEngine::depthBufferCaptured, saveImageFcn );
148 QMetaObject::Connection conn2;
149
150 // Make sure once-per-frame functions run
151 waitForFrame( engine, scene );
152 if ( scene->sceneState() == Qgs3DMapScene::Ready )
153 {
154 requestImageFcn();
155 }
156 else
157 {
158 // first wait until scene is loaded
159 conn2 = QObject::connect( scene, &Qgs3DMapScene::sceneStateChanged, requestImageFcn );
160 }
161
162 evLoop.exec();
163
164 QObject::disconnect( conn1 );
165 if ( conn2 )
166 QObject::disconnect( conn2 );
167
168 engine.renderSettings()->setRenderPolicy( Qt3DRender::QRenderSettings::RenderPolicy::OnDemand );
169 return resImage;
170}
171
172
173double Qgs3DUtils::calculateEntityGpuMemorySize( Qt3DCore::QEntity *entity )
174{
175 long long usedGpuMemory = 0;
176 for ( Qt3DQBuffer *buffer : entity->findChildren<Qt3DQBuffer *>() )
177 {
178 usedGpuMemory += buffer->data().size();
179 }
180 for ( Qt3DRender::QTexture2D *tex : entity->findChildren<Qt3DRender::QTexture2D *>() )
181 {
182 // TODO : lift the assumption that the texture is RGBA
183 usedGpuMemory += tex->width() * tex->height() * 4;
184 }
185 return usedGpuMemory / 1024.0 / 1024.0;
186}
187
188
189bool Qgs3DUtils::exportAnimation( const Qgs3DAnimationSettings &animationSettings, Qgs3DMapSettings &mapSettings, int framesPerSecond, const QString &outputDirectory, const QString &fileNameTemplate, const QSize &outputSize, QString &error, QgsFeedback *feedback )
190{
191 if ( animationSettings.keyFrames().size() < 2 )
192 {
193 error = QObject::tr( "Unable to export 3D animation. Add at least 2 keyframes" );
194 return false;
195 }
196
197 const float duration = animationSettings.duration(); //in seconds
198 if ( duration <= 0 )
199 {
200 error = QObject::tr( "Unable to export 3D animation (invalid duration)." );
201 return false;
202 }
203
204 float time = 0;
205 int frameNo = 0;
206 const int totalFrames = static_cast<int>( duration * framesPerSecond );
207
208 if ( fileNameTemplate.isEmpty() )
209 {
210 error = QObject::tr( "Filename template is empty" );
211 return false;
212 }
213
214 const int numberOfDigits = fileNameTemplate.count( QLatin1Char( '#' ) );
215 if ( numberOfDigits < 0 )
216 {
217 error = QObject::tr( "Wrong filename template format (must contain #)" );
218 return false;
219 }
220 const QString token( numberOfDigits, QLatin1Char( '#' ) );
221 if ( !fileNameTemplate.contains( token ) )
222 {
223 error = QObject::tr( "Filename template must contain all # placeholders in one continuous group." );
224 return false;
225 }
226
227 if ( !QDir().exists( outputDirectory ) )
228 {
229 if ( !QDir().mkpath( outputDirectory ) )
230 {
231 error = QObject::tr( "Output directory could not be created." );
232 return false;
233 }
234 }
235
237 engine.setSize( outputSize );
238 Qgs3DMapScene *scene = new Qgs3DMapScene( mapSettings, &engine );
239 engine.setRootEntity( scene );
240 // We need to change render policy to RenderPolicy::Always, since otherwise render capture node won't work
241 engine.renderSettings()->setRenderPolicy( Qt3DRender::QRenderSettings::RenderPolicy::Always );
242
243 while ( time <= duration )
244 {
245 if ( feedback )
246 {
247 if ( feedback->isCanceled() )
248 {
249 error = QObject::tr( "Export canceled" );
250 return false;
251 }
252 feedback->setProgress( frameNo / static_cast<double>( totalFrames ) * 100 );
253 }
254 ++frameNo;
255
256 const Qgs3DAnimationSettings::Keyframe kf = animationSettings.interpolate( time );
257 scene->cameraController()->setLookingAtPoint( kf.point, kf.dist, kf.pitch, kf.yaw );
258
259 QString fileName( fileNameTemplate );
260 const QString frameNoPaddedLeft( QStringLiteral( "%1" ).arg( frameNo, numberOfDigits, 10, QChar( '0' ) ) ); // e.g. 0001
261 fileName.replace( token, frameNoPaddedLeft );
262 const QString path = QDir( outputDirectory ).filePath( fileName );
263
264 const QImage img = Qgs3DUtils::captureSceneImage( engine, scene );
265
266 img.save( path );
267
268 time += 1.0f / static_cast<float>( framesPerSecond );
269 }
270
271 return true;
272}
273
274
275int Qgs3DUtils::maxZoomLevel( double tile0width, double tileResolution, double maxError )
276{
277 if ( maxError <= 0 || tileResolution <= 0 || tile0width <= 0 )
278 return 0; // invalid input
279
280 // derived from:
281 // tile width [map units] = tile0width / 2^zoomlevel
282 // tile error [map units] = tile width / tile resolution
283 // + re-arranging to get zoom level if we know tile error we want to get
284 const double zoomLevel = -log( tileResolution * maxError / tile0width ) / log( 2 );
285 return round( zoomLevel ); // we could use ceil() here if we wanted to always get to the desired error
286}
287
289{
290 switch ( altClamp )
291 {
293 return QStringLiteral( "absolute" );
295 return QStringLiteral( "relative" );
297 return QStringLiteral( "terrain" );
298 }
300}
301
302
304{
305 if ( str == QLatin1String( "absolute" ) )
307 else if ( str == QLatin1String( "terrain" ) )
309 else // "relative" (default)
311}
312
313
315{
316 switch ( altBind )
317 {
319 return QStringLiteral( "vertex" );
321 return QStringLiteral( "centroid" );
322 }
324}
325
326
328{
329 if ( str == QLatin1String( "vertex" ) )
331 else // "centroid" (default)
333}
334
336{
337 switch ( mode )
338 {
340 return QStringLiteral( "no-culling" );
342 return QStringLiteral( "front" );
343 case Qgs3DTypes::Back:
344 return QStringLiteral( "back" );
346 return QStringLiteral( "front-and-back" );
347 }
349}
350
352{
353 if ( str == QLatin1String( "front" ) )
354 return Qgs3DTypes::Front;
355 else if ( str == QLatin1String( "back" ) )
356 return Qgs3DTypes::Back;
357 else if ( str == QLatin1String( "front-and-back" ) )
359 else
361}
362
363float Qgs3DUtils::clampAltitude( const QgsPoint &p, Qgis::AltitudeClamping altClamp, Qgis::AltitudeBinding altBind, float offset, const QgsPoint &centroid, const Qgs3DRenderContext &context )
364{
365 float terrainZ = 0;
366 switch ( altClamp )
367 {
370 {
371 const QgsPointXY pt = altBind == Qgis::AltitudeBinding::Vertex ? p : centroid;
372 terrainZ = context.terrainRenderingEnabled() && context.terrainGenerator() ? context.terrainGenerator()->heightAt( pt.x(), pt.y(), context ) : 0;
373 break;
374 }
375
377 break;
378 }
379
380 float geomZ = 0;
381 if ( p.is3D() )
382 {
383 switch ( altClamp )
384 {
387 geomZ = p.z();
388 break;
389
391 break;
392 }
393 }
394
395 const float z = ( terrainZ + geomZ ) * static_cast<float>( context.terrainSettings()->verticalScale() ) + offset;
396 return z;
397}
398
399void Qgs3DUtils::clampAltitudes( QgsLineString *lineString, Qgis::AltitudeClamping altClamp, Qgis::AltitudeBinding altBind, const QgsPoint &centroid, float offset, const Qgs3DRenderContext &context )
400{
401 for ( int i = 0; i < lineString->nCoordinates(); ++i )
402 {
403 float terrainZ = 0;
404 switch ( altClamp )
405 {
408 {
409 QgsPointXY pt;
410 switch ( altBind )
411 {
413 pt.setX( lineString->xAt( i ) );
414 pt.setY( lineString->yAt( i ) );
415 break;
416
418 pt.set( centroid.x(), centroid.y() );
419 break;
420 }
421
422 terrainZ = context.terrainRenderingEnabled() && context.terrainGenerator() ? context.terrainGenerator()->heightAt( pt.x(), pt.y(), context ) : 0;
423 break;
424 }
425
427 break;
428 }
429
430 float geomZ = 0;
431
432 switch ( altClamp )
433 {
436 geomZ = lineString->zAt( i );
437 break;
438
440 break;
441 }
442
443 const float z = ( terrainZ + geomZ ) * static_cast<float>( context.terrainSettings()->verticalScale() ) + offset;
444 lineString->setZAt( i, z );
445 }
446}
447
448
449bool Qgs3DUtils::clampAltitudes( QgsPolygon *polygon, Qgis::AltitudeClamping altClamp, Qgis::AltitudeBinding altBind, float offset, const Qgs3DRenderContext &context )
450{
451 if ( !polygon->is3D() )
452 polygon->addZValue( 0 );
453
454 QgsPoint centroid;
455 switch ( altBind )
456 {
458 break;
459
461 centroid = polygon->centroid();
462 break;
463 }
464
465 QgsCurve *curve = const_cast<QgsCurve *>( polygon->exteriorRing() );
466 QgsLineString *lineString = qgsgeometry_cast<QgsLineString *>( curve );
467 if ( !lineString )
468 return false;
469
470 clampAltitudes( lineString, altClamp, altBind, centroid, offset, context );
471
472 for ( int i = 0; i < polygon->numInteriorRings(); ++i )
473 {
474 QgsCurve *curve = const_cast<QgsCurve *>( polygon->interiorRing( i ) );
475 QgsLineString *lineString = qgsgeometry_cast<QgsLineString *>( curve );
476 if ( !lineString )
477 return false;
478
479 clampAltitudes( lineString, altClamp, altBind, centroid, offset, context );
480 }
481 return true;
482}
483
484
485QString Qgs3DUtils::matrix4x4toString( const QMatrix4x4 &m )
486{
487 const float *d = m.constData();
488 QStringList elems;
489 elems.reserve( 16 );
490 for ( int i = 0; i < 16; ++i )
491 elems << QString::number( d[i] );
492 return elems.join( ' ' );
493}
494
495QMatrix4x4 Qgs3DUtils::stringToMatrix4x4( const QString &str )
496{
497 QMatrix4x4 m;
498 float *d = m.data();
499 QStringList elems = str.split( ' ' );
500 for ( int i = 0; i < 16; ++i )
501 d[i] = elems[i].toFloat();
502 return m;
503}
504
505void Qgs3DUtils::extractPointPositions( const QgsFeature &f, const Qgs3DRenderContext &context, const QgsVector3D &chunkOrigin, Qgis::AltitudeClamping altClamp, QVector<QVector3D> &positions )
506{
507 const QgsAbstractGeometry *g = f.geometry().constGet();
508 for ( auto it = g->vertices_begin(); it != g->vertices_end(); ++it )
509 {
510 const QgsPoint pt = *it;
511 float geomZ = 0;
512 if ( pt.is3D() )
513 {
514 geomZ = pt.z();
515 }
516 const float terrainZ = context.terrainRenderingEnabled() && context.terrainGenerator() ? static_cast<float>( context.terrainGenerator()->heightAt( pt.x(), pt.y(), context ) * context.terrainSettings()->verticalScale() ) : 0.f;
517 float h = 0.0f;
518 switch ( altClamp )
519 {
521 h = geomZ;
522 break;
524 h = terrainZ;
525 break;
527 h = terrainZ + geomZ;
528 break;
529 }
530 positions.append( QVector3D(
531 static_cast<float>( pt.x() - chunkOrigin.x() ),
532 static_cast<float>( pt.y() - chunkOrigin.y() ),
533 h
534 ) );
535 QgsDebugMsgLevel( QStringLiteral( "%1 %2 %3" ).arg( positions.last().x() ).arg( positions.last().y() ).arg( positions.last().z() ), 2 );
536 }
537}
538
544static inline uint outcode( QVector4D v )
545{
546 // For a discussion of outcodes see pg 388 Dunn & Parberry.
547 // For why you can't just test if the point is in a bounding box
548 // consider the case where a view frustum with view-size 1.5 x 1.5
549 // is tested against a 2x2 box which encloses the near-plane, while
550 // all the points in the box are outside the frustum.
551 // TODO: optimise this with assembler - according to D&P this can
552 // be done in one line of assembler on some platforms
553 uint code = 0;
554 if ( v.x() < -v.w() )
555 code |= 0x01;
556 if ( v.x() > v.w() )
557 code |= 0x02;
558 if ( v.y() < -v.w() )
559 code |= 0x04;
560 if ( v.y() > v.w() )
561 code |= 0x08;
562 if ( v.z() < -v.w() )
563 code |= 0x10;
564 if ( v.z() > v.w() )
565 code |= 0x20;
566 return code;
567}
568
569
580bool Qgs3DUtils::isCullable( const QgsAABB &bbox, const QMatrix4x4 &viewProjectionMatrix )
581{
582 uint out = 0xff;
583
584 for ( int i = 0; i < 8; ++i )
585 {
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;
588
589 // if the logical AND of all the outcodes is non-zero then the BB is
590 // definitely outside the view frustum.
591 out = out & outcode( pc );
592 }
593 return out;
594}
595
597{
598 return QgsVector3D( mapCoords.x() - origin.x(), mapCoords.y() - origin.y(), mapCoords.z() - origin.z() );
599}
600
602{
603 return QgsVector3D( worldCoords.x() + origin.x(), worldCoords.y() + origin.y(), worldCoords.z() + origin.z() );
604}
605
607{
608 QgsRectangle extentMapCrs( extent );
609 if ( crs1 != crs2 )
610 {
611 // reproject if necessary
612 QgsCoordinateTransform ct( crs1, crs2, context );
614 try
615 {
616 extentMapCrs = ct.transformBoundingBox( extentMapCrs );
617 }
618 catch ( const QgsCsException & )
619 {
620 // bad luck, can't reproject for some reason
621 QgsDebugError( QStringLiteral( "3D utils: transformation of extent failed: " ) + extentMapCrs.toString( -1 ) );
622 }
623 }
624 return extentMapCrs;
625}
626
627QgsAABB Qgs3DUtils::layerToWorldExtent( const QgsRectangle &extent, double zMin, double zMax, const QgsCoordinateReferenceSystem &layerCrs, const QgsVector3D &mapOrigin, const QgsCoordinateReferenceSystem &mapCrs, const QgsCoordinateTransformContext &context )
628{
629 const QgsRectangle extentMapCrs( Qgs3DUtils::tryReprojectExtent2D( extent, layerCrs, mapCrs, context ) );
630 return mapToWorldExtent( extentMapCrs, zMin, zMax, mapOrigin );
631}
632
634{
635 const QgsRectangle extentMap = worldToMapExtent( bbox, mapOrigin );
636 return Qgs3DUtils::tryReprojectExtent2D( extentMap, mapCrs, layerCrs, context );
637}
638
639QgsAABB Qgs3DUtils::mapToWorldExtent( const QgsRectangle &extent, double zMin, double zMax, const QgsVector3D &mapOrigin )
640{
641 const QgsVector3D extentMin3D( extent.xMinimum(), extent.yMinimum(), zMin );
642 const QgsVector3D extentMax3D( extent.xMaximum(), extent.yMaximum(), zMax );
643 const QgsVector3D worldExtentMin3D = mapToWorldCoordinates( extentMin3D, mapOrigin );
644 const QgsVector3D worldExtentMax3D = mapToWorldCoordinates( extentMax3D, mapOrigin );
645 QgsAABB rootBbox( worldExtentMin3D.x(), worldExtentMin3D.y(), worldExtentMin3D.z(), worldExtentMax3D.x(), worldExtentMax3D.y(), worldExtentMax3D.z() );
646 return rootBbox;
647}
648
650{
651 const QgsVector3D extentMin3D( box3D.xMinimum(), box3D.yMinimum(), box3D.zMinimum() );
652 const QgsVector3D extentMax3D( box3D.xMaximum(), box3D.yMaximum(), box3D.zMaximum() );
653 const QgsVector3D worldExtentMin3D = mapToWorldCoordinates( extentMin3D, mapOrigin );
654 const QgsVector3D worldExtentMax3D = mapToWorldCoordinates( extentMax3D, mapOrigin );
655 // casting to float should be ok, assuming that the map origin is not too far from the box
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() ) );
657}
658
660{
661 const QgsVector3D worldExtentMin3D = Qgs3DUtils::worldToMapCoordinates( QgsVector3D( bbox.xMin, bbox.yMin, bbox.zMin ), mapOrigin );
662 const QgsVector3D worldExtentMax3D = Qgs3DUtils::worldToMapCoordinates( QgsVector3D( bbox.xMax, bbox.yMax, bbox.zMax ), mapOrigin );
663 const QgsRectangle extentMap( worldExtentMin3D.x(), worldExtentMin3D.y(), worldExtentMax3D.x(), worldExtentMax3D.y() );
664 // we discard zMin/zMax here because we don't need it
665 return extentMap;
666}
667
668
670{
671 const QgsVector3D mapPoint1 = worldToMapCoordinates( worldPoint1, origin1 );
672 QgsVector3D mapPoint2 = mapPoint1;
673 if ( crs1 != crs2 )
674 {
675 // reproject if necessary
676 const QgsCoordinateTransform ct( crs1, crs2, context );
677 try
678 {
679 const QgsPointXY pt = ct.transform( QgsPointXY( mapPoint1.x(), mapPoint1.y() ) );
680 mapPoint2.set( pt.x(), pt.y(), mapPoint1.z() );
681 }
682 catch ( const QgsCsException & )
683 {
684 // bad luck, can't reproject for some reason
685 }
686 }
687 return mapToWorldCoordinates( mapPoint2, origin2 );
688}
689
690void Qgs3DUtils::estimateVectorLayerZRange( QgsVectorLayer *layer, double &zMin, double &zMax )
691{
692 if ( !QgsWkbTypes::hasZ( layer->wkbType() ) )
693 {
694 zMin = 0;
695 zMax = 0;
696 return;
697 }
698
699 zMin = std::numeric_limits<double>::max();
700 zMax = std::numeric_limits<double>::lowest();
701
702 QgsFeature f;
703 QgsFeatureIterator it = layer->getFeatures( QgsFeatureRequest().setNoAttributes().setLimit( 100 ) );
704 while ( it.nextFeature( f ) )
705 {
706 const QgsGeometry g = f.geometry();
707 for ( auto vit = g.vertices_begin(); vit != g.vertices_end(); ++vit )
708 {
709 const double z = ( *vit ).z();
710 if ( z < zMin )
711 zMin = z;
712 if ( z > zMax )
713 zMax = z;
714 }
715 }
716
717 if ( zMin == std::numeric_limits<double>::max() && zMax == std::numeric_limits<double>::lowest() )
718 {
719 zMin = 0;
720 zMax = 0;
721 }
722}
723
732
734{
736 settings.setAmbient( material->ambient() );
737 settings.setDiffuse( material->diffuse() );
738 settings.setSpecular( material->specular() );
739 settings.setShininess( material->shininess() );
740 return settings;
741}
742
743QgsRay3D Qgs3DUtils::rayFromScreenPoint( const QPoint &point, const QSize &windowSize, Qt3DRender::QCamera *camera )
744{
745 const QVector3D deviceCoords( point.x(), point.y(), 0.0 );
746 // normalized device coordinates
747 const QVector3D normDeviceCoords( 2.0 * deviceCoords.x() / windowSize.width() - 1.0f, 1.0f - 2.0 * deviceCoords.y() / windowSize.height(), camera->nearPlane() );
748 // clip coordinates
749 const QVector4D rayClip( normDeviceCoords.x(), normDeviceCoords.y(), -1.0, 0.0 );
750
751 const QMatrix4x4 invertedProjMatrix = camera->projectionMatrix().inverted();
752 const QMatrix4x4 invertedViewMatrix = camera->viewMatrix().inverted();
753
754 // ray direction in view coordinates
755 QVector4D rayDirView = invertedProjMatrix * rayClip;
756 // ray origin in world coordinates
757 const QVector4D rayOriginWorld = invertedViewMatrix * QVector4D( 0.0f, 0.0f, 0.0f, 1.0f );
758
759 // ray direction in world coordinates
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();
765
766 return QgsRay3D( QVector3D( rayOriginWorld ), rayDirWorld );
767}
768
769QVector3D Qgs3DUtils::screenPointToWorldPos( const QPoint &screenPoint, double depth, const QSize &screenSize, Qt3DRender::QCamera *camera )
770{
771 double dNear = camera->nearPlane();
772 double dFar = camera->farPlane();
773 double distance = ( 2.0 * dNear * dFar ) / ( dFar + dNear - ( depth * 2 - 1 ) * ( dFar - dNear ) );
774
775 QgsRay3D ray = Qgs3DUtils::rayFromScreenPoint( screenPoint, screenSize, camera );
776 double dot = QVector3D::dotProduct( ray.direction(), camera->viewVector().normalized() );
777 distance /= dot;
778
779 return ray.origin() + distance * ray.direction();
780}
781
782void Qgs3DUtils::pitchAndYawFromViewVector( QVector3D vect, double &pitch, double &yaw )
783{
784 vect.normalize();
785
786 pitch = qRadiansToDegrees( qAcos( vect.y() ) );
787 yaw = qRadiansToDegrees( qAtan2( -vect.z(), vect.x() ) ) + 90;
788}
789
790QVector2D Qgs3DUtils::screenToTextureCoordinates( QVector2D screenXY, QSize winSize )
791{
792 return QVector2D( screenXY.x() / winSize.width(), 1 - screenXY.y() / winSize.width() );
793}
794
795QVector2D Qgs3DUtils::textureToScreenCoordinates( QVector2D textureXY, QSize winSize )
796{
797 return QVector2D( textureXY.x() * winSize.width(), ( 1 - textureXY.y() ) * winSize.height() );
798}
799
800std::unique_ptr<QgsPointCloudLayer3DRenderer> Qgs3DUtils::convert2DPointCloudRendererTo3D( QgsPointCloudRenderer *renderer )
801{
802 if ( !renderer )
803 return nullptr;
804
805 std::unique_ptr<QgsPointCloud3DSymbol> symbol3D;
806 if ( renderer->type() == QLatin1String( "ramp" ) )
807 {
808 const QgsPointCloudAttributeByRampRenderer *renderer2D = dynamic_cast<const QgsPointCloudAttributeByRampRenderer *>( renderer );
809 symbol3D = std::make_unique<QgsColorRampPointCloud3DSymbol>();
810 QgsColorRampPointCloud3DSymbol *symbol = static_cast<QgsColorRampPointCloud3DSymbol *>( symbol3D.get() );
811 symbol->setAttribute( renderer2D->attribute() );
812 symbol->setColorRampShaderMinMax( renderer2D->minimum(), renderer2D->maximum() );
813 symbol->setColorRampShader( renderer2D->colorRampShader() );
814 }
815 else if ( renderer->type() == QLatin1String( "rgb" ) )
816 {
817 const QgsPointCloudRgbRenderer *renderer2D = dynamic_cast<const QgsPointCloudRgbRenderer *>( renderer );
818 symbol3D = std::make_unique<QgsRgbPointCloud3DSymbol>();
819 QgsRgbPointCloud3DSymbol *symbol = static_cast<QgsRgbPointCloud3DSymbol *>( symbol3D.get() );
820 symbol->setRedAttribute( renderer2D->redAttribute() );
821 symbol->setGreenAttribute( renderer2D->greenAttribute() );
822 symbol->setBlueAttribute( renderer2D->blueAttribute() );
823
824 symbol->setRedContrastEnhancement( renderer2D->redContrastEnhancement() ? new QgsContrastEnhancement( *renderer2D->redContrastEnhancement() ) : nullptr );
825 symbol->setGreenContrastEnhancement( renderer2D->greenContrastEnhancement() ? new QgsContrastEnhancement( *renderer2D->greenContrastEnhancement() ) : nullptr );
826 symbol->setBlueContrastEnhancement( renderer2D->blueContrastEnhancement() ? new QgsContrastEnhancement( *renderer2D->blueContrastEnhancement() ) : nullptr );
827 }
828 else if ( renderer->type() == QLatin1String( "classified" ) )
829 {
830 const QgsPointCloudClassifiedRenderer *renderer2D = dynamic_cast<const QgsPointCloudClassifiedRenderer *>( renderer );
831 symbol3D = std::make_unique<QgsClassificationPointCloud3DSymbol>();
832 QgsClassificationPointCloud3DSymbol *symbol = static_cast<QgsClassificationPointCloud3DSymbol *>( symbol3D.get() );
833 symbol->setAttribute( renderer2D->attribute() );
834 symbol->setCategoriesList( renderer2D->categories() );
835 }
836
837 if ( symbol3D )
838 {
839 auto renderer3D = std::make_unique<QgsPointCloudLayer3DRenderer>();
840 renderer3D->setSymbol( symbol3D.release() );
841 return renderer3D;
842 }
843 return nullptr;
844}
845
846QHash<QgsMapLayer *, QVector<QgsRayCastingUtils::RayHit>> Qgs3DUtils::castRay( Qgs3DMapScene *scene, const QgsRay3D &ray, const QgsRayCastingUtils::RayCastContext &context )
847{
848 QgsRayCastingUtils::Ray3D r( ray.origin(), ray.direction(), context.maxDistance );
849 QHash<QgsMapLayer *, QVector<QgsRayCastingUtils::RayHit>> results;
850 const QList<QgsMapLayer *> keys = scene->layers();
851 for ( QgsMapLayer *layer : keys )
852 {
853 Qt3DCore::QEntity *entity = scene->layerEntity( layer );
854
855 if ( QgsChunkedEntity *chunkedEntity = qobject_cast<QgsChunkedEntity *>( entity ) )
856 {
857 const QVector<QgsRayCastingUtils::RayHit> result = chunkedEntity->rayIntersection( r, context );
858 if ( !result.isEmpty() )
859 results[layer] = result;
860 }
861 }
862 if ( QgsTerrainEntity *terrain = scene->terrainEntity() )
863 {
864 const QVector<QgsRayCastingUtils::RayHit> result = terrain->rayIntersection( r, context );
865 if ( !result.isEmpty() )
866 results[nullptr] = result; // Terrain hits are not tied to a layer so we use nullptr as their key here
867 }
868 return results;
869}
870
871float Qgs3DUtils::screenSpaceError( float epsilon, float distance, int screenSize, float fov )
872{
873 /* This routine approximately calculates how an error (epsilon) of an object in world coordinates
874 * at given distance (between camera and the object) will look like in screen coordinates.
875 *
876 * the math below simply uses triangle similarity:
877 *
878 * epsilon phi
879 * ----------------------------- = ----------------
880 * [ frustum width at distance ] [ screen width ]
881 *
882 * Then we solve for phi, substituting [frustum width at distance] = 2 * distance * tan(fov / 2)
883 *
884 * ________xxx__ xxx = real world error (epsilon)
885 * \ | / x = screen space error (phi)
886 * \ | /
887 * \___|_x_/ near plane (screen space)
888 * \ | /
889 * \ | /
890 * \|/ angle = field of view
891 * camera
892 */
893 float phi = epsilon * static_cast<float>( screenSize ) / static_cast<float>( 2 * distance * tan( fov * M_PI / ( 2 * 180 ) ) );
894 return phi;
895}
896
897void Qgs3DUtils::computeBoundingBoxNearFarPlanes( const QgsAABB &bbox, const QMatrix4x4 &viewMatrix, float &fnear, float &ffar )
898{
899 fnear = 1e9;
900 ffar = 0;
901
902 for ( int i = 0; i < 8; ++i )
903 {
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 );
905
906 const QVector4D pc = viewMatrix * p;
907
908 const float dst = -pc.z(); // in camera coordinates, x grows right, y grows down, z grows to the back
909 fnear = std::min( fnear, dst );
910 ffar = std::max( ffar, dst );
911 }
912}
913
914Qt3DRender::QCullFace::CullingMode Qgs3DUtils::qt3DcullingMode( Qgs3DTypes::CullingMode mode )
915{
916 switch ( mode )
917 {
919 return Qt3DRender::QCullFace::NoCulling;
921 return Qt3DRender::QCullFace::Front;
922 case Qgs3DTypes::Back:
923 return Qt3DRender::QCullFace::Back;
925 return Qt3DRender::QCullFace::FrontAndBack;
926 }
927 return Qt3DRender::QCullFace::NoCulling;
928}
929
930
931QByteArray Qgs3DUtils::addDefinesToShaderCode( const QByteArray &shaderCode, const QStringList &defines )
932{
933 // There is one caveat to take care of - GLSL source code needs to start with #version as
934 // a first directive, otherwise we get the old GLSL 100 version. So we can't just prepend the
935 // shader source code, but insert our defines at the right place.
936
937 QStringList defineLines;
938 for ( const QString &define : defines )
939 defineLines += "#define " + define + "\n";
940
941 QString definesText = defineLines.join( QString() );
942
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;
948}
949
950QByteArray Qgs3DUtils::removeDefinesFromShaderCode( const QByteArray &shaderCode, const QStringList &defines )
951{
952 QByteArray newShaderCode = shaderCode;
953
954 for ( const QString &define : defines )
955 {
956 const QString defineLine = "#define " + define + "\n";
957 const int defineLineIndex = newShaderCode.indexOf( defineLine.toUtf8() );
958 if ( defineLineIndex != -1 )
959 {
960 newShaderCode.remove( defineLineIndex, defineLine.size() );
961 }
962 }
963
964 return newShaderCode;
965}
966
967void Qgs3DUtils::decomposeTransformMatrix( const QMatrix4x4 &matrix, QVector3D &translation, QQuaternion &rotation, QVector3D &scale )
968{
969 // decompose the transform matrix
970 // assuming the last row has values [0 0 0 1]
971 // see https://math.stackexchange.com/questions/237369/given-this-transformation-matrix-how-do-i-decompose-it-into-translation-rotati
972 const float *md = matrix.data(); // returns data in column-major order
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();
976 float rd[9] = {
977 md[0] / sx,
978 md[4] / sy,
979 md[8] / sz,
980 md[1] / sx,
981 md[5] / sy,
982 md[9] / sz,
983 md[2] / sx,
984 md[6] / sy,
985 md[10] / sz,
986 };
987 const QMatrix3x3 rot3x3( rd ); // takes data in row-major order
988
989 scale = QVector3D( sx, sy, sz );
990 rotation = QQuaternion::fromRotationMatrix( rot3x3 );
991 translation = QVector3D( md[12], md[13], md[14] );
992}
993
994int Qgs3DUtils::openGlMaxClipPlanes( QSurface *surface )
995{
996 int numPlanes = 6;
997
998 QOpenGLContext context;
999 context.setFormat( QSurfaceFormat::defaultFormat() );
1000 if ( context.create() )
1001 {
1002 if ( context.makeCurrent( surface ) )
1003 {
1004 QOpenGLFunctions *funcs = context.functions();
1005 funcs->glGetIntegerv( GL_MAX_CLIP_PLANES, &numPlanes );
1006 }
1007 }
1008
1009 return numPlanes;
1010}
1011
1012QQuaternion Qgs3DUtils::rotationFromPitchHeadingAngles( float pitchAngle, float headingAngle )
1013{
1014 return QQuaternion::fromAxisAndAngle( QVector3D( 0, 0, 1 ), headingAngle ) * QQuaternion::fromAxisAndAngle( QVector3D( 1, 0, 0 ), pitchAngle );
1015}
AltitudeClamping
Altitude clamping.
Definition qgis.h:3782
@ 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.
Definition qgis.h:3795
@ 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.
Definition qgs3dtypes.h:43
CullingMode
Triangle culling mode.
Definition qgs3dtypes.h:35
@ FrontAndBack
Will not render anything.
Definition qgs3dtypes.h:39
@ NoCulling
Will render both front and back faces of triangles.
Definition qgs3dtypes.h:36
@ Front
Will render only back faces of triangles.
Definition qgs3dtypes.h:37
@ Back
Will render only front faces of triangles (recommended when input data are consistent)
Definition qgs3dtypes.h:38
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 &centroid, 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 &centroid, 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.
float yMax
Definition qgsaabb.h:102
float xMax
Definition qgsaabb.h:101
float xMin
Definition qgsaabb.h:98
float zMax
Definition qgsaabb.h:103
float yMin
Definition qgsaabb.h:99
float zMin
Definition qgsaabb.h:100
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.
Definition qgsbox3d.h:43
double yMaximum() const
Returns the maximum y value.
Definition qgsbox3d.h:246
double xMinimum() const
Returns the minimum x value.
Definition qgsbox3d.h:211
double zMaximum() const
Returns the maximum z value.
Definition qgsbox3d.h:274
double xMaximum() const
Returns the maximum x value.
Definition qgsbox3d.h:218
double zMinimum() const
Returns the minimum z value.
Definition qgsbox3d.h:267
double yMinimum() const
Returns the minimum y value.
Definition qgsbox3d.h:239
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.
Class for doing transforms between two map coordinate systems.
void setBallparkTransformsAreAppropriate(bool appropriate)
Sets whether approximate "ballpark" results are appropriate for this coordinate transform.
QgsPointXY transform(const QgsPointXY &point, Qgis::TransformDirection direction=Qgis::TransformDirection::Forward) const
Transform the point from the source CRS to the destination CRS.
QgsRectangle transformBoundingBox(const QgsRectangle &rectangle, Qgis::TransformDirection direction=Qgis::TransformDirection::Forward, bool handle180Crossover=false) const
Transforms a rectangle from the source CRS to the destination CRS.
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.
Definition qgscurve.h:35
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...
Definition qgsfeature.h:58
QgsGeometry geometry
Definition qgsfeature.h:69
Base class for feedback objects to be used for cancellation of something running in a worker thread.
Definition qgsfeedback.h:44
bool isCanceled() const
Tells whether the operation has been canceled already.
Definition qgsfeedback.h:53
void setProgress(double progress)
Sets the current progress for the feedback object.
Definition qgsfeedback.h:61
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.
Definition qgsmaplayer.h:76
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.
Definition qgspointxy.h:60
void setY(double y)
Sets the y value of the point.
Definition qgspointxy.h:129
void set(double x, double y)
Sets the x and y value of the point.
Definition qgspointxy.h:136
double y
Definition qgspointxy.h:64
double x
Definition qgspointxy.h:63
void setX(double x)
Sets the x value of the point.
Definition qgspointxy.h:119
Point geometry type, with support for z-dimension and m-values.
Definition qgspoint.h:49
double z
Definition qgspoint.h:54
double x
Definition qgspoint.h:52
double y
Definition qgspoint.h:53
Polygon geometry type.
Definition qgspolygon.h:33
static QgsProject * instance()
Returns the QgsProject singleton instance.
A representation of a ray in 3D.
Definition qgsray3d.h:31
QVector3D origin() const
Returns the origin of the ray.
Definition qgsray3d.h:44
QVector3D direction() const
Returns the direction of the ray see setDirection()
Definition qgsray3d.h:50
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...
double xMinimum
double yMinimum
double xMaximum
double yMaximum
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...
Definition qgsvector3d.h:31
double y() const
Returns Y coordinate.
Definition qgsvector3d.h:50
double z() const
Returns Z coordinate.
Definition qgsvector3d.h:52
double x() const
Returns X coordinate.
Definition qgsvector3d.h:48
void set(double x, double y, double z)
Sets vector coordinates.
Definition qgsvector3d.h:73
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
Definition qgis.h:6779
Qt3DCore::QBuffer Qt3DQBuffer
Qt3DCore::QBuffer Qt3DQBuffer
#define QgsDebugMsgLevel(str, level)
Definition qgslogger.h:41
#define QgsDebugError(str)
Definition qgslogger.h:40
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.