QGIS API Documentation 3.27.0-Master (1c05421486)
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"
27#include "qgsexpression.h"
28#include "qgsexpressionutils.h"
30
31#include "qgs3dmapscene.h"
32#include "qgsabstract3dengine.h"
33#include "qgsterraingenerator.h"
34#include "qgscameracontroller.h"
35
36#include "qgsline3dsymbol.h"
37#include "qgspoint3dsymbol.h"
38#include "qgspolygon3dsymbol.h"
39
46
47#include <QtMath>
48#include <Qt3DExtras/QPhongMaterial>
49#include <Qt3DRender/QRenderSettings>
50
52{
53 QImage resImage;
54 QEventLoop evLoop;
55
56 // We need to change render policy to RenderPolicy::Always, since otherwise render capture node won't work
57 engine.renderSettings()->setRenderPolicy( Qt3DRender::QRenderSettings::RenderPolicy::Always );
58
59 auto requestImageFcn = [&engine, scene]
60 {
61 if ( scene->sceneState() == Qgs3DMapScene::Ready )
62 {
63 engine.requestCaptureImage();
64 }
65 };
66
67 auto saveImageFcn = [&evLoop, &resImage]( const QImage & img )
68 {
69 resImage = img;
70 evLoop.quit();
71 };
72
73 const QMetaObject::Connection conn1 = QObject::connect( &engine, &QgsAbstract3DEngine::imageCaptured, saveImageFcn );
74 QMetaObject::Connection conn2;
75
76 if ( scene->sceneState() == Qgs3DMapScene::Ready )
77 {
78 requestImageFcn();
79 }
80 else
81 {
82 // first wait until scene is loaded
83 conn2 = QObject::connect( scene, &Qgs3DMapScene::sceneStateChanged, requestImageFcn );
84 }
85
86 evLoop.exec();
87
88 QObject::disconnect( conn1 );
89 if ( conn2 )
90 QObject::disconnect( conn2 );
91
92 engine.renderSettings()->setRenderPolicy( Qt3DRender::QRenderSettings::RenderPolicy::OnDemand );
93 return resImage;
94}
95
97{
98 QImage resImage;
99 QEventLoop evLoop;
100
101 // We need to change render policy to RenderPolicy::Always, since otherwise render capture node won't work
102 engine.renderSettings()->setRenderPolicy( Qt3DRender::QRenderSettings::RenderPolicy::Always );
103
104 auto requestImageFcn = [&engine, scene]
105 {
106 if ( scene->sceneState() == Qgs3DMapScene::Ready )
107 {
108 engine.requestCaptureImage();
109 }
110 };
111
112 auto saveImageFcn = [&evLoop, &resImage]( const QImage & img )
113 {
114 resImage = img;
115 evLoop.quit();
116 };
117
118 QMetaObject::Connection conn1 = QObject::connect( &engine, &QgsAbstract3DEngine::imageCaptured, saveImageFcn );
119 QMetaObject::Connection conn2;
120
121 if ( scene->sceneState() == Qgs3DMapScene::Ready )
122 {
123 requestImageFcn();
124 }
125 else
126 {
127 // first wait until scene is loaded
128 conn2 = QObject::connect( scene, &Qgs3DMapScene::sceneStateChanged, requestImageFcn );
129 }
130
131 evLoop.exec();
132
133 QObject::disconnect( conn1 );
134 if ( conn2 )
135 QObject::disconnect( conn2 );
136
137 engine.renderSettings()->setRenderPolicy( Qt3DRender::QRenderSettings::RenderPolicy::OnDemand );
138 return resImage;
139}
140
142 Qgs3DMapSettings &mapSettings,
143 int framesPerSecond,
144 const QString &outputDirectory,
145 const QString &fileNameTemplate,
146 const QSize &outputSize,
147 QString &error,
148 QgsFeedback *feedback
149 )
150{
152 engine.setSize( outputSize );
153 Qgs3DMapScene *scene = new Qgs3DMapScene( mapSettings, &engine );
154 engine.setRootEntity( scene );
155 // We need to change render policy to RenderPolicy::Always, since otherwise render capture node won't work
156 engine.renderSettings()->setRenderPolicy( Qt3DRender::QRenderSettings::RenderPolicy::Always );
157
158 if ( animationSettings.keyFrames().size() < 2 )
159 {
160 error = QObject::tr( "Unable to export 3D animation. Add at least 2 keyframes" );
161 return false;
162 }
163
164 const float duration = animationSettings.duration(); //in seconds
165 if ( duration <= 0 )
166 {
167 error = QObject::tr( "Unable to export 3D animation (invalid duration)." );
168 return false;
169 }
170
171 float time = 0;
172 int frameNo = 0;
173 const int totalFrames = static_cast<int>( duration * framesPerSecond );
174
175 if ( fileNameTemplate.isEmpty() )
176 {
177 error = QObject::tr( "Filename template is empty" );
178 return false;
179 }
180
181 const int numberOfDigits = fileNameTemplate.count( QLatin1Char( '#' ) );
182 if ( numberOfDigits < 0 )
183 {
184 error = QObject::tr( "Wrong filename template format (must contain #)" );
185 return false;
186 }
187 const QString token( numberOfDigits, QLatin1Char( '#' ) );
188 if ( !fileNameTemplate.contains( token ) )
189 {
190 error = QObject::tr( "Filename template must contain all # placeholders in one continuous group." );
191 return false;
192 }
193
194 while ( time <= duration )
195 {
196
197 if ( feedback )
198 {
199 if ( feedback->isCanceled() )
200 {
201 error = QObject::tr( "Export canceled" );
202 return false;
203 }
204 feedback->setProgress( frameNo / static_cast<double>( totalFrames ) * 100 );
205 }
206 ++frameNo;
207
208 const Qgs3DAnimationSettings::Keyframe kf = animationSettings.interpolate( time );
209 scene->cameraController()->setLookingAtPoint( kf.point, kf.dist, kf.pitch, kf.yaw );
210
211 QString fileName( fileNameTemplate );
212 const QString frameNoPaddedLeft( QStringLiteral( "%1" ).arg( frameNo, numberOfDigits, 10, QChar( '0' ) ) ); // e.g. 0001
213 fileName.replace( token, frameNoPaddedLeft );
214 const QString path = QDir( outputDirectory ).filePath( fileName );
215
216 const QImage img = Qgs3DUtils::captureSceneImage( engine, scene );
217
218 img.save( path );
219
220 time += 1.0f / static_cast<float>( framesPerSecond );
221 }
222
223 return true;
224}
225
226
227int Qgs3DUtils::maxZoomLevel( double tile0width, double tileResolution, double maxError )
228{
229 if ( maxError <= 0 || tileResolution <= 0 || tile0width <= 0 )
230 return 0; // invalid input
231
232 // derived from:
233 // tile width [map units] = tile0width / 2^zoomlevel
234 // tile error [map units] = tile width / tile resolution
235 // + re-arranging to get zoom level if we know tile error we want to get
236 const double zoomLevel = -log( tileResolution * maxError / tile0width ) / log( 2 );
237 return round( zoomLevel ); // we could use ceil() here if we wanted to always get to the desired error
238}
239
241{
242 switch ( altClamp )
243 {
245 return QStringLiteral( "absolute" );
247 return QStringLiteral( "relative" );
249 return QStringLiteral( "terrain" );
250 }
252}
253
254
256{
257 if ( str == QLatin1String( "absolute" ) )
259 else if ( str == QLatin1String( "terrain" ) )
261 else // "relative" (default)
263}
264
265
267{
268 switch ( altBind )
269 {
271 return QStringLiteral( "vertex" );
273 return QStringLiteral( "centroid" );
274 }
276}
277
278
280{
281 if ( str == QLatin1String( "vertex" ) )
283 else // "centroid" (default)
285}
286
288{
289 switch ( mode )
290 {
292 return QStringLiteral( "no-culling" );
294 return QStringLiteral( "front" );
295 case Qgs3DTypes::Back:
296 return QStringLiteral( "back" );
298 return QStringLiteral( "front-and-back" );
299 }
301}
302
304{
305 if ( str == QLatin1String( "front" ) )
306 return Qgs3DTypes::Front;
307 else if ( str == QLatin1String( "back" ) )
308 return Qgs3DTypes::Back;
309 else if ( str == QLatin1String( "front-and-back" ) )
311 else
313}
314
315float Qgs3DUtils::clampAltitude( const QgsPoint &p, Qgis::AltitudeClamping altClamp, Qgis::AltitudeBinding altBind, float height, const QgsPoint &centroid, const Qgs3DMapSettings &map )
316{
317 float terrainZ = 0;
318 switch ( altClamp )
319 {
322 {
323 const QgsPointXY pt = altBind == Qgis::AltitudeBinding::Vertex ? p : centroid;
324 terrainZ = map.terrainRenderingEnabled() && map.terrainGenerator() ? map.terrainGenerator()->heightAt( pt.x(), pt.y(), map ) : 0;
325 break;
326 }
327
329 break;
330 }
331
332 float geomZ = 0;
333 if ( p.is3D() )
334 {
335 switch ( altClamp )
336 {
339 geomZ = p.z();
340 break;
341
343 break;
344 }
345 }
346
347 const float z = ( terrainZ + geomZ ) * map.terrainVerticalScale() + height;
348 return z;
349}
350
351void Qgs3DUtils::clampAltitudes( QgsLineString *lineString, Qgis::AltitudeClamping altClamp, Qgis::AltitudeBinding altBind, const QgsPoint &centroid, float height, const Qgs3DMapSettings &map )
352{
353 for ( int i = 0; i < lineString->nCoordinates(); ++i )
354 {
355 float terrainZ = 0;
356 switch ( altClamp )
357 {
360 {
361 QgsPointXY pt;
362 switch ( altBind )
363 {
365 pt.setX( lineString->xAt( i ) );
366 pt.setY( lineString->yAt( i ) );
367 break;
368
370 pt.set( centroid.x(), centroid.y() );
371 break;
372 }
373
374 terrainZ = map.terrainRenderingEnabled() && map.terrainGenerator() ? map.terrainGenerator()->heightAt( pt.x(), pt.y(), map ) : 0;
375 break;
376 }
377
379 break;
380 }
381
382 float geomZ = 0;
383
384 switch ( altClamp )
385 {
388 geomZ = lineString->zAt( i );
389 break;
390
392 break;
393 }
394
395 const float z = ( terrainZ + geomZ ) * map.terrainVerticalScale() + height;
396 lineString->setZAt( i, z );
397 }
398}
399
400
401bool Qgs3DUtils::clampAltitudes( QgsPolygon *polygon, Qgis::AltitudeClamping altClamp, Qgis::AltitudeBinding altBind, float height, const Qgs3DMapSettings &map )
402{
403 if ( !polygon->is3D() )
404 polygon->addZValue( 0 );
405
407 switch ( altBind )
408 {
410 break;
411
413 centroid = polygon->centroid();
414 break;
415 }
416
417 QgsCurve *curve = const_cast<QgsCurve *>( polygon->exteriorRing() );
418 QgsLineString *lineString = qgsgeometry_cast<QgsLineString *>( curve );
419 if ( !lineString )
420 return false;
421
422 clampAltitudes( lineString, altClamp, altBind, centroid, height, map );
423
424 for ( int i = 0; i < polygon->numInteriorRings(); ++i )
425 {
426 QgsCurve *curve = const_cast<QgsCurve *>( polygon->interiorRing( i ) );
427 QgsLineString *lineString = qgsgeometry_cast<QgsLineString *>( curve );
428 if ( !lineString )
429 return false;
430
431 clampAltitudes( lineString, altClamp, altBind, centroid, height, map );
432 }
433 return true;
434}
435
436
437QString Qgs3DUtils::matrix4x4toString( const QMatrix4x4 &m )
438{
439 const float *d = m.constData();
440 QStringList elems;
441 elems.reserve( 16 );
442 for ( int i = 0; i < 16; ++i )
443 elems << QString::number( d[i] );
444 return elems.join( ' ' );
445}
446
447QMatrix4x4 Qgs3DUtils::stringToMatrix4x4( const QString &str )
448{
449 QMatrix4x4 m;
450 float *d = m.data();
451 QStringList elems = str.split( ' ' );
452 for ( int i = 0; i < 16; ++i )
453 d[i] = elems[i].toFloat();
454 return m;
455}
456
457void Qgs3DUtils::extractPointPositions( const QgsFeature &f, const Qgs3DMapSettings &map, Qgis::AltitudeClamping altClamp, QVector<QVector3D> &positions )
458{
459 const QgsAbstractGeometry *g = f.geometry().constGet();
460 for ( auto it = g->vertices_begin(); it != g->vertices_end(); ++it )
461 {
462 const QgsPoint pt = *it;
463 float geomZ = 0;
464 if ( pt.is3D() )
465 {
466 geomZ = pt.z();
467 }
468 const float terrainZ = map.terrainRenderingEnabled() && map.terrainGenerator() ? map.terrainGenerator()->heightAt( pt.x(), pt.y(), map ) * map.terrainVerticalScale() : 0;
469 float h = 0.0f;
470 switch ( altClamp )
471 {
473 h = geomZ;
474 break;
476 h = terrainZ;
477 break;
479 h = terrainZ + geomZ;
480 break;
481 }
482 positions.append( QVector3D( pt.x() - map.origin().x(), h, -( pt.y() - map.origin().y() ) ) );
483 QgsDebugMsgLevel( QStringLiteral( "%1 %2 %3" ).arg( positions.last().x() ).arg( positions.last().y() ).arg( positions.last().z() ), 2 );
484 }
485}
486
492static inline uint outcode( QVector4D v )
493{
494 // For a discussion of outcodes see pg 388 Dunn & Parberry.
495 // For why you can't just test if the point is in a bounding box
496 // consider the case where a view frustum with view-size 1.5 x 1.5
497 // is tested against a 2x2 box which encloses the near-plane, while
498 // all the points in the box are outside the frustum.
499 // TODO: optimise this with assembler - according to D&P this can
500 // be done in one line of assembler on some platforms
501 uint code = 0;
502 if ( v.x() < -v.w() ) code |= 0x01;
503 if ( v.x() > v.w() ) code |= 0x02;
504 if ( v.y() < -v.w() ) code |= 0x04;
505 if ( v.y() > v.w() ) code |= 0x08;
506 if ( v.z() < -v.w() ) code |= 0x10;
507 if ( v.z() > v.w() ) code |= 0x20;
508 return code;
509}
510
511
522bool Qgs3DUtils::isCullable( const QgsAABB &bbox, const QMatrix4x4 &viewProjectionMatrix )
523{
524 uint out = 0xff;
525
526 for ( int i = 0; i < 8; ++i )
527 {
528 const QVector4D p( ( ( i >> 0 ) & 1 ) ? bbox.xMin : bbox.xMax,
529 ( ( i >> 1 ) & 1 ) ? bbox.yMin : bbox.yMax,
530 ( ( i >> 2 ) & 1 ) ? bbox.zMin : bbox.zMax, 1 );
531 const QVector4D pc = viewProjectionMatrix * p;
532
533 // if the logical AND of all the outcodes is non-zero then the BB is
534 // definitely outside the view frustum.
535 out = out & outcode( pc );
536 }
537 return out;
538}
539
541{
542 return QgsVector3D( mapCoords.x() - origin.x(),
543 mapCoords.z() - origin.z(),
544 -( mapCoords.y() - origin.y() ) );
545
546}
547
549{
550 return QgsVector3D( worldCoords.x() + origin.x(),
551 -worldCoords.z() + origin.y(),
552 worldCoords.y() + origin.z() );
553}
554
555static QgsRectangle _tryReprojectExtent2D( const QgsRectangle &extent, const QgsCoordinateReferenceSystem &crs1, const QgsCoordinateReferenceSystem &crs2, const QgsCoordinateTransformContext &context )
556{
557 QgsRectangle extentMapCrs( extent );
558 if ( crs1 != crs2 )
559 {
560 // reproject if necessary
561 QgsCoordinateTransform ct( crs1, crs2, context );
562 ct.setBallparkTransformsAreAppropriate( true );
563 try
564 {
565 extentMapCrs = ct.transformBoundingBox( extentMapCrs );
566 }
567 catch ( const QgsCsException & )
568 {
569 // bad luck, can't reproject for some reason
570 QgsDebugMsg( QStringLiteral( "3D utils: transformation of extent failed: " ) + extentMapCrs.toString( -1 ) );
571 }
572 }
573 return extentMapCrs;
574}
575
576QgsAABB Qgs3DUtils::layerToWorldExtent( const QgsRectangle &extent, double zMin, double zMax, const QgsCoordinateReferenceSystem &layerCrs, const QgsVector3D &mapOrigin, const QgsCoordinateReferenceSystem &mapCrs, const QgsCoordinateTransformContext &context )
577{
578 const QgsRectangle extentMapCrs( _tryReprojectExtent2D( extent, layerCrs, mapCrs, context ) );
579 return mapToWorldExtent( extentMapCrs, zMin, zMax, mapOrigin );
580}
581
583{
584 const QgsRectangle extentMap = worldToMapExtent( bbox, mapOrigin );
585 return _tryReprojectExtent2D( extentMap, mapCrs, layerCrs, context );
586}
587
588QgsAABB Qgs3DUtils::mapToWorldExtent( const QgsRectangle &extent, double zMin, double zMax, const QgsVector3D &mapOrigin )
589{
590 const QgsVector3D extentMin3D( extent.xMinimum(), extent.yMinimum(), zMin );
591 const QgsVector3D extentMax3D( extent.xMaximum(), extent.yMaximum(), zMax );
592 const QgsVector3D worldExtentMin3D = mapToWorldCoordinates( extentMin3D, mapOrigin );
593 const QgsVector3D worldExtentMax3D = mapToWorldCoordinates( extentMax3D, mapOrigin );
594 QgsAABB rootBbox( worldExtentMin3D.x(), worldExtentMin3D.y(), worldExtentMin3D.z(),
595 worldExtentMax3D.x(), worldExtentMax3D.y(), worldExtentMax3D.z() );
596 return rootBbox;
597}
598
600{
601 const QgsVector3D worldExtentMin3D = Qgs3DUtils::worldToMapCoordinates( QgsVector3D( bbox.xMin, bbox.yMin, bbox.zMin ), mapOrigin );
602 const QgsVector3D worldExtentMax3D = Qgs3DUtils::worldToMapCoordinates( QgsVector3D( bbox.xMax, bbox.yMax, bbox.zMax ), mapOrigin );
603 const QgsRectangle extentMap( worldExtentMin3D.x(), worldExtentMin3D.y(), worldExtentMax3D.x(), worldExtentMax3D.y() );
604 // we discard zMin/zMax here because we don't need it
605 return extentMap;
606}
607
608
610{
611 const QgsVector3D mapPoint1 = worldToMapCoordinates( worldPoint1, origin1 );
612 QgsVector3D mapPoint2 = mapPoint1;
613 if ( crs1 != crs2 )
614 {
615 // reproject if necessary
616 const QgsCoordinateTransform ct( crs1, crs2, context );
617 try
618 {
619 const QgsPointXY pt = ct.transform( QgsPointXY( mapPoint1.x(), mapPoint1.y() ) );
620 mapPoint2.set( pt.x(), pt.y(), mapPoint1.z() );
621 }
622 catch ( const QgsCsException & )
623 {
624 // bad luck, can't reproject for some reason
625 }
626 }
627 return mapToWorldCoordinates( mapPoint2, origin2 );
628}
629
630void Qgs3DUtils::estimateVectorLayerZRange( QgsVectorLayer *layer, double &zMin, double &zMax )
631{
632 if ( !QgsWkbTypes::hasZ( layer->wkbType() ) )
633 {
634 zMin = 0;
635 zMax = 0;
636 return;
637 }
638
639 zMin = std::numeric_limits<double>::max();
640 zMax = std::numeric_limits<double>::lowest();
641
642 QgsFeature f;
643 QgsFeatureIterator it = layer->getFeatures( QgsFeatureRequest().setNoAttributes().setLimit( 100 ) );
644 while ( it.nextFeature( f ) )
645 {
646 const QgsGeometry g = f.geometry();
647 for ( auto vit = g.vertices_begin(); vit != g.vertices_end(); ++vit )
648 {
649 const double z = ( *vit ).z();
650 if ( z < zMin ) zMin = z;
651 if ( z > zMax ) zMax = z;
652 }
653 }
654
655 if ( zMin == std::numeric_limits<double>::max() && zMax == std::numeric_limits<double>::lowest() )
656 {
657 zMin = 0;
658 zMax = 0;
659 }
660}
661
663{
664 QgsExpressionContext exprContext;
668 return exprContext;
669}
670
672{
674 settings.setAmbient( material->ambient() );
675 settings.setDiffuse( material->diffuse() );
676 settings.setSpecular( material->specular() );
677 settings.setShininess( material->shininess() );
678 return settings;
679}
680
681QgsRay3D Qgs3DUtils::rayFromScreenPoint( const QPoint &point, const QSize &windowSize, Qt3DRender::QCamera *camera )
682{
683 const QVector3D deviceCoords( point.x(), point.y(), 0.0 );
684 // normalized device coordinates
685 const QVector3D normDeviceCoords( 2.0 * deviceCoords.x() / windowSize.width() - 1.0f, 1.0f - 2.0 * deviceCoords.y() / windowSize.height(), camera->nearPlane() );
686 // clip coordinates
687 const QVector4D rayClip( normDeviceCoords.x(), normDeviceCoords.y(), -1.0, 0.0 );
688
689 const QMatrix4x4 invertedProjMatrix = camera->projectionMatrix().inverted();
690 const QMatrix4x4 invertedViewMatrix = camera->viewMatrix().inverted();
691
692 // ray direction in view coordinates
693 QVector4D rayDirView = invertedProjMatrix * rayClip;
694 // ray origin in world coordinates
695 const QVector4D rayOriginWorld = invertedViewMatrix * QVector4D( 0.0f, 0.0f, 0.0f, 1.0f );
696
697 // ray direction in world coordinates
698 rayDirView.setZ( -1.0f );
699 rayDirView.setW( 0.0f );
700 const QVector4D rayDirWorld4D = invertedViewMatrix * rayDirView;
701 QVector3D rayDirWorld( rayDirWorld4D.x(), rayDirWorld4D.y(), rayDirWorld4D.z() );
702 rayDirWorld = rayDirWorld.normalized();
703
704 return QgsRay3D( QVector3D( rayOriginWorld ), rayDirWorld );
705}
706
707QVector3D Qgs3DUtils::screenPointToWorldPos( const QPoint &screenPoint, double depth, const QSize &screenSize, Qt3DRender::QCamera *camera )
708{
709 double dNear = camera->nearPlane();
710 double dFar = camera->farPlane();
711 double distance = ( 2.0 * dNear * dFar ) / ( dFar + dNear - ( depth * 2 - 1 ) * ( dFar - dNear ) );
712
713 QgsRay3D ray = Qgs3DUtils::rayFromScreenPoint( screenPoint, screenSize, camera );
714 double dot = QVector3D::dotProduct( ray.direction(), camera->viewVector().normalized() );
715 distance /= dot;
716
717 return ray.origin() + distance * ray.direction();
718}
719
720void Qgs3DUtils::pitchAndYawFromViewVector( QVector3D vect, double &pitch, double &yaw )
721{
722 vect.normalize();
723
724 pitch = qRadiansToDegrees( qAcos( vect.y() ) );
725 yaw = qRadiansToDegrees( qAtan2( -vect.z(), vect.x() ) ) + 90;
726}
727
728QVector2D Qgs3DUtils::screenToTextureCoordinates( QVector2D screenXY, QSize winSize )
729{
730 return QVector2D( screenXY.x() / winSize.width(), 1 - screenXY.y() / winSize.width() );
731}
732
733QVector2D Qgs3DUtils::textureToScreenCoordinates( QVector2D textureXY, QSize winSize )
734{
735 return QVector2D( textureXY.x() * winSize.width(), ( 1 - textureXY.y() ) * winSize.height() );
736}
737
738std::unique_ptr<QgsPointCloudLayer3DRenderer> Qgs3DUtils::convert2DPointCloudRendererTo3D( QgsPointCloudRenderer *renderer )
739{
740 if ( !renderer )
741 return nullptr;
742
743 std::unique_ptr< QgsPointCloud3DSymbol > symbol3D;
744 if ( renderer->type() == QLatin1String( "ramp" ) )
745 {
746 const QgsPointCloudAttributeByRampRenderer *renderer2D = dynamic_cast< const QgsPointCloudAttributeByRampRenderer * >( renderer );
747 symbol3D = std::make_unique< QgsColorRampPointCloud3DSymbol >();
748 QgsColorRampPointCloud3DSymbol *symbol = static_cast< QgsColorRampPointCloud3DSymbol * >( symbol3D.get() );
749 symbol->setAttribute( renderer2D->attribute() );
750 symbol->setColorRampShaderMinMax( renderer2D->minimum(), renderer2D->maximum() );
751 symbol->setColorRampShader( renderer2D->colorRampShader() );
752 }
753 else if ( renderer->type() == QLatin1String( "rgb" ) )
754 {
755 const QgsPointCloudRgbRenderer *renderer2D = dynamic_cast< const QgsPointCloudRgbRenderer * >( renderer );
756 symbol3D = std::make_unique< QgsRgbPointCloud3DSymbol >();
757 QgsRgbPointCloud3DSymbol *symbol = static_cast< QgsRgbPointCloud3DSymbol * >( symbol3D.get() );
758 symbol->setRedAttribute( renderer2D->redAttribute() );
759 symbol->setGreenAttribute( renderer2D->greenAttribute() );
760 symbol->setBlueAttribute( renderer2D->blueAttribute() );
761
762 symbol->setRedContrastEnhancement( renderer2D->redContrastEnhancement() ? new QgsContrastEnhancement( *renderer2D->redContrastEnhancement() ) : nullptr );
763 symbol->setGreenContrastEnhancement( renderer2D->greenContrastEnhancement() ? new QgsContrastEnhancement( *renderer2D->greenContrastEnhancement() ) : nullptr );
764 symbol->setBlueContrastEnhancement( renderer2D->blueContrastEnhancement() ? new QgsContrastEnhancement( *renderer2D->blueContrastEnhancement() ) : nullptr );
765 }
766 else if ( renderer->type() == QLatin1String( "classified" ) )
767 {
768
769 const QgsPointCloudClassifiedRenderer *renderer2D = dynamic_cast< const QgsPointCloudClassifiedRenderer * >( renderer );
770 symbol3D = std::make_unique< QgsClassificationPointCloud3DSymbol >();
771 QgsClassificationPointCloud3DSymbol *symbol = static_cast< QgsClassificationPointCloud3DSymbol * >( symbol3D.get() );
772 symbol->setAttribute( renderer2D->attribute() );
773 symbol->setCategoriesList( renderer2D->categories() );
774 }
775
776 if ( symbol3D )
777 {
778 std::unique_ptr< QgsPointCloudLayer3DRenderer > renderer3D = std::make_unique< QgsPointCloudLayer3DRenderer >();
779 renderer3D->setSymbol( symbol3D.release() );
780 return renderer3D;
781 }
782 return nullptr;
783}
AltitudeClamping
Altitude clamping.
Definition: qgis.h:1907
@ 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:1920
@ 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.
@ Ready
The scene is fully loaded/updated.
void sceneStateChanged()
Emitted when the scene's state has changed.
SceneState sceneState() const
Returns the current state of the scene.
QgsCameraController * cameraController()
Returns camera controller.
Definition: qgs3dmapscene.h:78
double terrainVerticalScale() const
Returns vertical scale (exaggeration) of terrain.
QgsTerrainGenerator * terrainGenerator() const
Returns the terrain generator.
bool terrainRenderingEnabled() const
Returns whether the 2D terrain surface will be rendered.
QgsVector3D origin() const
Returns coordinates in map CRS at which 3D scene has origin (0,0,0)
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)
Definition: qgs3dutils.cpp:609
static Qgs3DTypes::CullingMode cullingModeFromString(const QString &str)
Converts a string to a value from CullingMode enum.
Definition: qgs3dutils.cpp:303
static Qgis::AltitudeClamping altClampingFromString(const QString &str)
Converts a string to a value from AltitudeClamping enum.
Definition: qgs3dutils.cpp:255
static QString matrix4x4toString(const QMatrix4x4 &m)
Converts a 4x4 transform matrix to a string.
Definition: qgs3dutils.cpp:437
static QgsRectangle worldToMapExtent(const QgsAABB &bbox, const QgsVector3D &mapOrigin)
Converts axis aligned bounding box in 3D world coordinates to extent in map coordinates.
Definition: qgs3dutils.cpp:599
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.
Definition: qgs3dutils.cpp:582
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...
Definition: qgs3dutils.cpp:720
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...
Definition: qgs3dutils.cpp:227
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.
Definition: qgs3dutils.cpp:588
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.
Definition: qgs3dutils.cpp:576
static Qgis::AltitudeBinding altBindingFromString(const QString &str)
Converts a string to a value from AltitudeBinding enum.
Definition: qgs3dutils.cpp:279
static QString cullingModeToString(Qgs3DTypes::CullingMode mode)
Converts a value from CullingMode enum to a string.
Definition: qgs3dutils.cpp:287
static void extractPointPositions(const QgsFeature &f, const Qgs3DMapSettings &map, Qgis::AltitudeClamping altClamp, QVector< QVector3D > &positions)
Calculates (x,y,z) positions of (multi)point from the given feature.
Definition: qgs3dutils.cpp:457
static bool isCullable(const QgsAABB &bbox, const QMatrix4x4 &viewProjectionMatrix)
Returns true if bbox is completely outside the current viewing volume.
Definition: qgs3dutils.cpp:522
static QVector2D screenToTextureCoordinates(QVector2D screenXY, QSize winSize)
Converts from screen coordinates to texture coordinates.
Definition: qgs3dutils.cpp:728
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.
Definition: qgs3dutils.cpp:630
static QgsPhongMaterialSettings phongMaterialFromQt3DComponent(Qt3DExtras::QPhongMaterial *material)
Returns phong material settings object based on the Qt3D material.
Definition: qgs3dutils.cpp:671
static QString altClampingToString(Qgis::AltitudeClamping altClamp)
Converts a value from AltitudeClamping enum to a string.
Definition: qgs3dutils.cpp:240
static void clampAltitudes(QgsLineString *lineString, Qgis::AltitudeClamping altClamp, Qgis::AltitudeBinding altBind, const QgsPoint &centroid, float height, const Qgs3DMapSettings &map)
Clamps altitude of vertices of a linestring according to the settings.
Definition: qgs3dutils.cpp:351
static QMatrix4x4 stringToMatrix4x4(const QString &str)
Convert a string to a 4x4 transform matrix.
Definition: qgs3dutils.cpp:447
static QgsVector3D worldToMapCoordinates(const QgsVector3D &worldCoords, const QgsVector3D &origin)
Converts 3D world coordinates to map coordinates (applies offset and turns (x,y,z) into (x,...
Definition: qgs3dutils.cpp:548
static QgsVector3D mapToWorldCoordinates(const QgsVector3D &mapCoords, const QgsVector3D &origin)
Converts map coordinates to 3D world coordinates (applies offset and turns (x,y,z) into (x,...
Definition: qgs3dutils.cpp:540
static QVector2D textureToScreenCoordinates(QVector2D textureXY, QSize winSize)
Converts from texture coordinates coordinates to screen coordinates.
Definition: qgs3dutils.cpp:733
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.
Definition: qgs3dutils.cpp:141
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.
Definition: qgs3dutils.cpp:707
static QString altBindingToString(Qgis::AltitudeBinding altBind)
Converts a value from AltitudeBinding enum to a string.
Definition: qgs3dutils.cpp:266
static float clampAltitude(const QgsPoint &p, Qgis::AltitudeClamping altClamp, Qgis::AltitudeBinding altBind, float height, const QgsPoint &centroid, const Qgs3DMapSettings &map)
Clamps altitude of a vertex according to the settings, returns Z value.
Definition: qgs3dutils.cpp:315
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.
Definition: qgs3dutils.cpp:681
static QImage captureSceneImage(QgsAbstract3DEngine &engine, Qgs3DMapScene *scene)
Captures image of the current 3D scene of a 3D engine.
Definition: qgs3dutils.cpp:51
static std::unique_ptr< QgsPointCloudLayer3DRenderer > convert2DPointCloudRendererTo3D(QgsPointCloudRenderer *renderer)
Creates a QgsPointCloudLayer3DRenderer matching the symbol settings of a given QgsPointCloudRenderer.
Definition: qgs3dutils.cpp:738
static QImage captureSceneDepthBuffer(QgsAbstract3DEngine &engine, Qgs3DMapScene *scene)
Captures the depth buffer of the current 3D scene of a 3D engine.
Definition: qgs3dutils.cpp:96
static QgsExpressionContext globalProjectLayerExpressionContext(QgsVectorLayer *layer)
Returns expression context for use in preparation of 3D data of a layer.
Definition: qgs3dutils.cpp:662
3
Definition: qgsaabb.h:34
float yMax
Definition: qgsaabb.h:85
float xMax
Definition: qgsaabb.h:84
float xMin
Definition: qgsaabb.h:81
float zMax
Definition: qgsaabb.h:86
float yMin
Definition: qgsaabb.h:82
float zMin
Definition: qgsaabb.h:83
void requestCaptureImage()
Starts a request for an image rendered by the engine.
void imageCaptured(const QImage &image)
Emitted after a call to requestCaptureImage() to return the captured image.
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 SIP_HOLDGIL
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.
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.
QgsPointXY transform(const QgsPointXY &point, Qgis::TransformDirection direction=Qgis::TransformDirection::Forward) const SIP_THROW(QgsCsException)
Transform the point from the source CRS to the destination CRS.
Custom exception class for Coordinate Reference System related exceptions.
Definition: qgsexception.h:66
bool addZValue(double zValue=0) override
Adds a z-dimension to the geometry, initialized to a preset value.
const QgsCurve * interiorRing(int i) const SIP_HOLDGIL
Retrieves an interior ring from the curve polygon.
const QgsCurve * exteriorRing() const SIP_HOLDGIL
Returns the curve polygon's exterior ring.
int numInteriorRings() const SIP_HOLDGIL
Returns the number of interior rings contained with the curve polygon.
Abstract base class for curved geometry type.
Definition: qgscurve.h:36
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)
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:56
QgsGeometry geometry
Definition: qgsfeature.h:67
Base class for feedback objects to be used for cancellation of something running in a worker thread.
Definition: qgsfeedback.h:45
bool isCanceled() const SIP_HOLDGIL
Tells whether the operation has been canceled already.
Definition: qgsfeedback.h:54
void setProgress(double progress)
Sets the current progress for the feedback object.
Definition: qgsfeedback.h:63
A geometry is the spatial representation of a feature.
Definition: qgsgeometry.h:164
const QgsAbstractGeometry * constGet() const SIP_HOLDGIL
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.
Definition: qgslinestring.h:45
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.
int nCoordinates() const override SIP_HOLDGIL
Returns the number of nodes contained in the geometry.
double zAt(int index) const
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.
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 setAmbient(const QColor &ambient)
Sets ambient color component.
void setShininess(float shininess)
Sets shininess of the surface.
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:59
void set(double x, double y) SIP_HOLDGIL
Sets the x and y value of the point.
Definition: qgspointxy.h:139
void setX(double x) SIP_HOLDGIL
Sets the x value of the point.
Definition: qgspointxy.h:122
double y
Definition: qgspointxy.h:63
Q_GADGET double x
Definition: qgspointxy.h:62
void setY(double y) SIP_HOLDGIL
Sets the y value of the point.
Definition: qgspointxy.h:132
Point geometry type, with support for z-dimension and m-values.
Definition: qgspoint.h:49
Q_GADGET double x
Definition: qgspoint.h:52
double z
Definition: qgspoint.h:54
double y
Definition: qgspoint.h:53
Polygon geometry type.
Definition: qgspolygon.h:34
static QgsProject * instance()
Returns the QgsProject singleton instance.
Definition: qgsproject.cpp:477
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.
Definition: qgsrectangle.h:42
double yMaximum() const SIP_HOLDGIL
Returns the y maximum value (top side of rectangle).
Definition: qgsrectangle.h:193
double xMaximum() const SIP_HOLDGIL
Returns the x maximum value (right side of rectangle).
Definition: qgsrectangle.h:183
double xMinimum() const SIP_HOLDGIL
Returns the x minimum value (left side of rectangle).
Definition: qgsrectangle.h:188
double yMinimum() const SIP_HOLDGIL
Returns the y minimum value (bottom side of rectangle).
Definition: qgsrectangle.h:198
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 Qgs3DMapSettings &map) const
Returns height at (x,y) in terrain's CRS.
double y() const
Returns Y coordinate.
Definition: qgsvector3d.h:51
double z() const
Returns Z coordinate.
Definition: qgsvector3d.h:53
double x() const
Returns X coordinate.
Definition: qgsvector3d.h:49
void set(double x, double y, double z)
Sets vector coordinates.
Definition: qgsvector3d.h:56
Represents a vector layer which manages a vector based data sets.
Q_INVOKABLE QgsWkbTypes::Type wkbType() const FINAL
Returns the WKBType or WKBUnknown in case of error.
QgsFeatureIterator getFeatures(const QgsFeatureRequest &request=QgsFeatureRequest()) const FINAL
Queries the layer for features specified in request.
static bool hasZ(Type type) SIP_HOLDGIL
Tests whether a WKB type contains the z-dimension.
Definition: qgswkbtypes.h:1080
CORE_EXPORT QgsMeshVertex centroid(const QgsMeshFace &face, const QVector< QgsMeshVertex > &vertices)
Returns the centroid of the face.
#define str(x)
Definition: qgis.cpp:37
#define BUILTIN_UNREACHABLE
Definition: qgis.h:3128
#define QgsDebugMsgLevel(str, level)
Definition: qgslogger.h:39
#define QgsDebugMsg(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.