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