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