QGIS API Documentation 4.3.0-Master (0cef2469b72)
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 "qgs3d.h"
19#include "qgs3dmapcanvas.h"
20#include "qgs3dmapscene.h"
21#include "qgsabstract3dengine.h"
22#include "qgsabstractgeometry.h"
24#include "qgsapplication.h"
25#include "qgscameracontroller.h"
26#include "qgschunkedentity.h"
27#include "qgsfeature.h"
28#include "qgsfeatureiterator.h"
29#include "qgsfeaturerequest.h"
30#include "qgsfeedback.h"
32#include "qgslinestring.h"
41#include "qgspolygon.h"
42#include "qgsraycastcontext.h"
43#include "qgsraycastresult.h"
44#include "qgsterrainentity.h"
45#include "qgsterraingenerator.h"
46#include "qgsvectorlayer.h"
47
48#include <QOpenGLContext>
49#include <QOpenGLFunctions>
50#include <QString>
51#include <Qt3DCore/QBuffer>
52#include <Qt3DExtras/QPhongMaterial>
53#include <Qt3DLogic/QFrameAction>
54#include <Qt3DRender/QRenderSettings>
55#include <QtMath>
56
57using namespace Qt::StringLiterals;
58
59#if !defined( Q_OS_MAC )
60#include <GL/gl.h>
61#endif
62
63
64// declared here as Qgs3DTypes has no cpp file
65const char *Qgs3DTypes::PROP_NAME_3D_RENDERER_FLAG = "PROP_NAME_3D_RENDERER_FLAG";
66
68{
69 // Set policy to always render frame, so we don't wait forever.
70 Qt3DRender::QRenderSettings::RenderPolicy oldPolicy = engine.renderSettings()->renderPolicy();
71 engine.renderSettings()->setRenderPolicy( Qt3DRender::QRenderSettings::RenderPolicy::Always );
72
73 // Wait for at least one frame to render
74 Qt3DLogic::QFrameAction *frameAction = new Qt3DLogic::QFrameAction();
75 scene->addComponent( frameAction );
76 QEventLoop evLoop;
77 QObject::connect( frameAction, &Qt3DLogic::QFrameAction::triggered, &evLoop, &QEventLoop::quit );
78 evLoop.exec();
79 scene->removeComponent( frameAction );
80 frameAction->deleteLater();
81
82 engine.renderSettings()->setRenderPolicy( oldPolicy );
83}
84
86{
87 while ( scene->totalPendingJobsCount() > 0 )
88 {
89 QgsApplication::processEvents();
90 }
91}
92
94{
95 QImage resImage;
96 QEventLoop evLoop;
97
98 // We need to change render policy to RenderPolicy::Always, since otherwise render capture node won't work
99 engine.renderSettings()->setRenderPolicy( Qt3DRender::QRenderSettings::RenderPolicy::Always );
100
101 waitForFrame( engine, scene );
102
103 auto saveImageFcn = [&evLoop, &resImage]( const QImage &img ) {
104 resImage = img;
105 evLoop.quit();
106 };
107
108 const QMetaObject::Connection conn1 = QObject::connect( &engine, &QgsAbstract3DEngine::imageCaptured, saveImageFcn );
109 QMetaObject::Connection conn2;
110
111 auto requestImageFcn = [&engine, scene] {
112 if ( scene->sceneState() == Qgs3DMapScene::Ready )
113 {
114 engine.renderSettings()->setRenderPolicy( Qt3DRender::QRenderSettings::RenderPolicy::OnDemand );
115 engine.requestCaptureImage();
116 }
117 };
118
119 if ( scene->sceneState() == Qgs3DMapScene::Ready )
120 {
121 requestImageFcn();
122 }
123 else
124 {
125 // first wait until scene is loaded
126 conn2 = QObject::connect( scene, &Qgs3DMapScene::sceneStateChanged, requestImageFcn );
127 }
128
129 evLoop.exec();
130
131 QObject::disconnect( conn1 );
132 if ( conn2 )
133 QObject::disconnect( conn2 );
134
135 engine.renderSettings()->setRenderPolicy( Qt3DRender::QRenderSettings::RenderPolicy::OnDemand );
136 return resImage;
137}
138
140{
141 QImage resImage;
142 QEventLoop evLoop;
143
144 // We need to change render policy to RenderPolicy::Always, since otherwise render capture node won't work
145 engine.renderSettings()->setRenderPolicy( Qt3DRender::QRenderSettings::RenderPolicy::Always );
146
147 auto requestImageFcn = [&engine, scene] {
148 if ( scene->sceneState() == Qgs3DMapScene::Ready )
149 {
150 engine.renderSettings()->setRenderPolicy( Qt3DRender::QRenderSettings::RenderPolicy::OnDemand );
152 }
153 };
154
155 auto saveImageFcn = [&evLoop, &resImage]( const QImage &img ) {
156 resImage = img;
157 evLoop.quit();
158 };
159
160 QMetaObject::Connection conn1 = QObject::connect( &engine, &QgsAbstract3DEngine::depthBufferCaptured, saveImageFcn );
161 QMetaObject::Connection conn2;
162
163 // Make sure once-per-frame functions run
164 waitForFrame( engine, scene );
165 if ( scene->sceneState() == Qgs3DMapScene::Ready )
166 {
167 requestImageFcn();
168 }
169 else
170 {
171 // first wait until scene is loaded
172 conn2 = QObject::connect( scene, &Qgs3DMapScene::sceneStateChanged, requestImageFcn );
173 }
174
175 evLoop.exec();
176
177 QObject::disconnect( conn1 );
178 if ( conn2 )
179 QObject::disconnect( conn2 );
180
181 engine.renderSettings()->setRenderPolicy( Qt3DRender::QRenderSettings::RenderPolicy::OnDemand );
182 return resImage;
183}
184
185
186double Qgs3DUtils::calculateEntityGpuMemorySize( Qt3DCore::QEntity *entity )
187{
188 long long usedGpuMemory = 0;
189 for ( Qt3DCore::QBuffer *buffer : entity->findChildren<Qt3DCore::QBuffer *>() )
190 {
191 usedGpuMemory += buffer->data().size();
192 }
193 for ( Qt3DRender::QTexture2D *tex : entity->findChildren<Qt3DRender::QTexture2D *>() )
194 {
195 // TODO : lift the assumption that the texture is RGBA
196 usedGpuMemory += static_cast< long long >( tex->width() ) * static_cast< long long >( tex->height() ) * 4;
197 }
198 return usedGpuMemory / 1024.0 / 1024.0;
199}
200
201
203 const Qgs3DAnimationSettings &animationSettings,
204 Qgs3DMapSettings &mapSettings,
205 int framesPerSecond,
206 const QString &outputDirectory,
207 const QString &fileNameTemplate,
208 const QSize &outputSize,
209 QString &error,
210 QgsFeedback *feedback
211)
212{
213 if ( animationSettings.keyFrames().size() < 2 )
214 {
215 error = QObject::tr( "Unable to export 3D animation. Add at least 2 keyframes" );
216 return false;
217 }
218
219 const float duration = animationSettings.duration(); //in seconds
220 if ( duration <= 0 )
221 {
222 error = QObject::tr( "Unable to export 3D animation (invalid duration)." );
223 return false;
224 }
225
226 float time = 0;
227 int frameNo = 0;
228 const int totalFrames = static_cast<int>( duration * framesPerSecond );
229
230 if ( fileNameTemplate.isEmpty() )
231 {
232 error = QObject::tr( "Filename template is empty" );
233 return false;
234 }
235
236 const int numberOfDigits = fileNameTemplate.count( '#'_L1 );
237 if ( numberOfDigits < 0 )
238 {
239 error = QObject::tr( "Wrong filename template format (must contain #)" );
240 return false;
241 }
242 const QString token( numberOfDigits, '#'_L1 );
243 if ( !fileNameTemplate.contains( token ) )
244 {
245 error = QObject::tr( "Filename template must contain all # placeholders in one continuous group." );
246 return false;
247 }
248
249 if ( !QDir().exists( outputDirectory ) )
250 {
251 if ( !QDir().mkpath( outputDirectory ) )
252 {
253 error = QObject::tr( "Output directory could not be created." );
254 return false;
255 }
256 }
257
259 engine.setSize( outputSize );
260 Qgs3DMapScene *scene = new Qgs3DMapScene( mapSettings, &engine );
261 engine.setRootEntity( scene );
262 // We need to change render policy to RenderPolicy::Always, since otherwise render capture node won't work
263 engine.renderSettings()->setRenderPolicy( Qt3DRender::QRenderSettings::RenderPolicy::Always );
264
265 while ( time <= duration )
266 {
267 if ( feedback )
268 {
269 if ( feedback->isCanceled() )
270 {
271 error = QObject::tr( "Export canceled" );
272 return false;
273 }
274 feedback->setProgress( frameNo / static_cast<double>( totalFrames ) * 100 );
275 }
276 ++frameNo;
277
278 const Qgs3DAnimationSettings::Keyframe kf = animationSettings.interpolate( time );
279 scene->cameraController()->setLookingAtMapPoint( kf.point, kf.dist, kf.pitch, kf.yaw );
280
281 QString fileName( fileNameTemplate );
282 const QString frameNoPaddedLeft( u"%1"_s.arg( frameNo, numberOfDigits, 10, QChar( '0' ) ) ); // e.g. 0001
283 fileName.replace( token, frameNoPaddedLeft );
284 const QString path = QDir( outputDirectory ).filePath( fileName );
285
286 const QImage img = Qgs3DUtils::captureSceneImage( engine, scene );
287
288 img.save( path );
289
290 time += 1.0f / static_cast<float>( framesPerSecond );
291 }
292
293 return true;
294}
295
296
297int Qgs3DUtils::maxZoomLevel( double tile0width, double tileResolution, double maxError )
298{
299 if ( maxError <= 0 || tileResolution <= 0 || tile0width <= 0 )
300 return 0; // invalid input
301
302 // derived from:
303 // tile width [map units] = tile0width / 2^zoomlevel
304 // tile error [map units] = tile width / tile resolution
305 // + re-arranging to get zoom level if we know tile error we want to get
306 const double zoomLevel = -log( tileResolution * maxError / tile0width ) / log( 2 );
307 return std::max<int>( 0, round( zoomLevel ) ); // we could use ceil() here if we wanted to always get to the desired error
308}
309
311{
312 switch ( altClamp )
313 {
315 return u"absolute"_s;
317 return u"relative"_s;
319 return u"terrain"_s;
320 }
322}
323
324
326{
327 if ( str == "absolute"_L1 )
329 else if ( str == "terrain"_L1 )
331 else // "relative" (default)
333}
334
335
337{
338 switch ( altBind )
339 {
341 return u"vertex"_s;
343 return u"centroid"_s;
344 }
346}
347
348
350{
351 if ( str == "vertex"_L1 )
353 else // "centroid" (default)
355}
356
358{
359 switch ( mode )
360 {
362 return u"no-culling"_s;
364 return u"front"_s;
365 case Qgs3DTypes::Back:
366 return u"back"_s;
368 return u"front-and-back"_s;
369 }
371}
372
374{
375 if ( str == "front"_L1 )
376 return Qgs3DTypes::Front;
377 else if ( str == "back"_L1 )
378 return Qgs3DTypes::Back;
379 else if ( str == "front-and-back"_L1 )
381 else
383}
384
385float Qgs3DUtils::clampAltitude( const QgsPoint &p, Qgis::AltitudeClamping altClamp, Qgis::AltitudeBinding altBind, float offset, const QgsPoint &centroid, const Qgs3DRenderContext &context )
386{
387 float terrainZ = 0;
388 switch ( altClamp )
389 {
392 {
393 const QgsPointXY pt = altBind == Qgis::AltitudeBinding::Vertex ? p : centroid;
394 terrainZ = context.terrainRenderingEnabled() && context.terrainGenerator() ? context.terrainGenerator()->heightAt( pt.x(), pt.y(), context ) : 0;
395 break;
396 }
397
399 break;
400 }
401
402 float geomZ = 0;
403 if ( p.is3D() )
404 {
405 switch ( altClamp )
406 {
409 geomZ = p.z();
410 break;
411
413 break;
414 }
415 }
416
417 const float z = ( terrainZ + geomZ ) * ( context.terrainSettings() ? static_cast<float>( context.terrainSettings()->verticalScale() ) : 1 ) + offset;
418 return z;
419}
420
421void Qgs3DUtils::clampAltitudes( QgsLineString *lineString, Qgis::AltitudeClamping altClamp, Qgis::AltitudeBinding altBind, const QgsPoint &centroid, float offset, const Qgs3DRenderContext &context )
422{
423 for ( int i = 0; i < lineString->nCoordinates(); ++i )
424 {
425 float terrainZ = 0;
426 switch ( altClamp )
427 {
430 {
431 QgsPointXY pt;
432 switch ( altBind )
433 {
435 pt.setX( lineString->xAt( i ) );
436 pt.setY( lineString->yAt( i ) );
437 break;
438
440 pt.set( centroid.x(), centroid.y() );
441 break;
442 }
443
444 terrainZ = context.terrainRenderingEnabled() && context.terrainGenerator() ? context.terrainGenerator()->heightAt( pt.x(), pt.y(), context ) : 0;
445 break;
446 }
447
449 break;
450 }
451
452 float geomZ = 0;
453
454 switch ( altClamp )
455 {
458 geomZ = lineString->zAt( i );
459 break;
460
462 break;
463 }
464
465 const float z = ( terrainZ + geomZ ) * ( context.terrainSettings() ? static_cast<float>( context.terrainSettings()->verticalScale() ) : 1 ) + offset;
466 lineString->setZAt( i, z );
467 }
468}
469
470
471bool Qgs3DUtils::clampAltitudes( QgsPolygon *polygon, Qgis::AltitudeClamping altClamp, Qgis::AltitudeBinding altBind, float offset, const Qgs3DRenderContext &context )
472{
473 if ( !polygon->is3D() )
474 polygon->addZValue( 0 );
475
476 QgsPoint centroid;
477 switch ( altBind )
478 {
480 break;
481
483 centroid = polygon->centroid();
484 break;
485 }
486
487 QgsCurve *curve = const_cast<QgsCurve *>( polygon->exteriorRing() );
489 if ( !lineString )
490 return false;
491
492 clampAltitudes( lineString, altClamp, altBind, centroid, offset, context );
493
494 for ( int i = 0; i < polygon->numInteriorRings(); ++i )
495 {
496 QgsCurve *curve = const_cast<QgsCurve *>( polygon->interiorRing( i ) );
498 if ( !lineString )
499 return false;
500
501 clampAltitudes( lineString, altClamp, altBind, centroid, offset, context );
502 }
503 return true;
504}
505
506
507QString Qgs3DUtils::matrix4x4toString( const QMatrix4x4 &m )
508{
509 const float *d = m.constData();
510 QStringList elems;
511 elems.reserve( 16 );
512 for ( int i = 0; i < 16; ++i )
513 elems << QString::number( d[i] );
514 return elems.join( ' ' );
515}
516
517QMatrix4x4 Qgs3DUtils::stringToMatrix4x4( const QString &str )
518{
519 QMatrix4x4 m;
520 float *d = m.data();
521 QStringList elems = str.split( ' ' );
522 for ( int i = 0; i < 16; ++i )
523 d[i] = elems[i].toFloat();
524 return m;
525}
526
527float srgbFloatToLinear( float srgb )
528{
529 // from https://www.w3.org/TR/WCAG21/#dfn-relative-luminance
530 return srgb <= 0.04045f ? srgb / 12.92f : std::pow( ( srgb + 0.055f ) / 1.055f, 2.4f );
531}
532
533QColor Qgs3DUtils::srgbToLinear( const QColor &color )
534{
535 return QColor::fromRgbF( srgbFloatToLinear( color.redF() ), srgbFloatToLinear( color.greenF() ), srgbFloatToLinear( color.blueF() ), color.alphaF() );
536}
537
538void Qgs3DUtils::extractPointPositions( const QgsFeature &f, const Qgs3DRenderContext &context, const QgsVector3D &chunkOrigin, Qgis::AltitudeClamping altClamp, QVector<QVector3D> &positions )
539{
540 const bool isGeocentric = context.crs().type() == Qgis::CrsType::Geocentric;
541 const bool useTerrainHeight = !isGeocentric && context.terrainRenderingEnabled() && context.terrainGenerator();
542 const QgsAbstractGeometry *g = f.geometry().constGet();
543 for ( auto it = g->vertices_begin(); it != g->vertices_end(); ++it )
544 {
545 const QgsPoint pt = *it;
546 float geomZ = 0;
547 if ( pt.is3D() )
548 {
549 geomZ = pt.z();
550 }
551
552 float h = 0.0f;
553 if ( isGeocentric )
554 {
555 // keep the original Z from geocentric coordinates
556 // (we do not support terrains in globe mode yet)
557 h = geomZ;
558 }
559 else
560 {
561 const float terrainZ = useTerrainHeight
562 ? static_cast<float>( context.terrainGenerator()->heightAt( pt.x(), pt.y(), context ) * ( context.terrainSettings() ? context.terrainSettings()->verticalScale() : 1 ) )
563 : 0.f;
564 switch ( altClamp )
565 {
567 h = geomZ;
568 break;
570 h = terrainZ;
571 break;
573 h = terrainZ + geomZ;
574 break;
575 }
576 }
577
578 // clang-format off
579 positions.append( QVector3D(
580 static_cast<float>( pt.x() - chunkOrigin.x() ),
581 static_cast<float>( pt.y() - chunkOrigin.y() ),
582 static_cast<float>( h - chunkOrigin.z() )
583 ) );
584 // clang-format on
585 QgsDebugMsgLevel( u"%1 %2 %3"_s.arg( positions.last().x() ).arg( positions.last().y() ).arg( positions.last().z() ), 2 );
586 }
587}
588
594static inline uint outcode( QVector4D v )
595{
596 // For a discussion of outcodes see pg 388 Dunn & Parberry.
597 // For why you can't just test if the point is in a bounding box
598 // consider the case where a view frustum with view-size 1.5 x 1.5
599 // is tested against a 2x2 box which encloses the near-plane, while
600 // all the points in the box are outside the frustum.
601 // TODO: optimise this with assembler - according to D&P this can
602 // be done in one line of assembler on some platforms
603 uint code = 0;
604 if ( v.x() < -v.w() )
605 code |= 0x01;
606 if ( v.x() > v.w() )
607 code |= 0x02;
608 if ( v.y() < -v.w() )
609 code |= 0x04;
610 if ( v.y() > v.w() )
611 code |= 0x08;
612 if ( v.z() < -v.w() )
613 code |= 0x10;
614 if ( v.z() > v.w() )
615 code |= 0x20;
616 return code;
617}
618
619
630bool Qgs3DUtils::isCullable( const QgsAABB &bbox, const QMatrix4x4 &viewProjectionMatrix )
631{
632 uint out = 0xff;
633
634 for ( int i = 0; i < 8; ++i )
635 {
636 const QVector4D p( ( ( i >> 0 ) & 1 ) ? bbox.xMin : bbox.xMax, ( ( i >> 1 ) & 1 ) ? bbox.yMin : bbox.yMax, ( ( i >> 2 ) & 1 ) ? bbox.zMin : bbox.zMax, 1 );
637 const QVector4D pc = viewProjectionMatrix * p;
638
639 // if the logical AND of all the outcodes is non-zero then the BB is
640 // definitely outside the view frustum.
641 out = out & outcode( pc );
642 }
643 return out;
644}
645
647{
648 return QgsVector3D( mapCoords.x() - origin.x(), mapCoords.y() - origin.y(), mapCoords.z() - origin.z() );
649}
650
652{
653 return QgsVector3D( worldCoords.x() + origin.x(), worldCoords.y() + origin.y(), worldCoords.z() + origin.z() );
654}
655
657{
658 QgsRectangle extentMapCrs( extent );
659 if ( crs1 != crs2 )
660 {
661 // reproject if necessary
662 QgsCoordinateTransform ct( crs1, crs2, context );
664 try
665 {
666 extentMapCrs = ct.transformBoundingBox( extentMapCrs );
667 }
668 catch ( const QgsCsException & )
669 {
670 // bad luck, can't reproject for some reason
671 QgsDebugError( u"3D utils: transformation of extent failed: "_s + extentMapCrs.toString( -1 ) );
672 }
673 }
674 return extentMapCrs;
675}
676
678 const QgsRectangle &extent,
679 double zMin,
680 double zMax,
681 const QgsCoordinateReferenceSystem &layerCrs,
682 const QgsVector3D &mapOrigin,
683 const QgsCoordinateReferenceSystem &mapCrs,
684 const QgsCoordinateTransformContext &context
685)
686{
687 const QgsRectangle extentMapCrs( Qgs3DUtils::tryReprojectExtent2D( extent, layerCrs, mapCrs, context ) );
688 return mapToWorldExtent( extentMapCrs, zMin, zMax, mapOrigin );
689}
690
692 const QgsAABB &bbox, const QgsCoordinateReferenceSystem &layerCrs, const QgsVector3D &mapOrigin, const QgsCoordinateReferenceSystem &mapCrs, const QgsCoordinateTransformContext &context
693)
694{
695 const QgsRectangle extentMap = worldToMapExtent( bbox, mapOrigin );
696 return Qgs3DUtils::tryReprojectExtent2D( extentMap, mapCrs, layerCrs, context );
697}
698
699QgsAABB Qgs3DUtils::mapToWorldExtent( const QgsRectangle &extent, double zMin, double zMax, const QgsVector3D &mapOrigin )
700{
701 const QgsVector3D extentMin3D( extent.xMinimum(), extent.yMinimum(), zMin );
702 const QgsVector3D extentMax3D( extent.xMaximum(), extent.yMaximum(), zMax );
703 const QgsVector3D worldExtentMin3D = mapToWorldCoordinates( extentMin3D, mapOrigin );
704 const QgsVector3D worldExtentMax3D = mapToWorldCoordinates( extentMax3D, mapOrigin );
705 QgsAABB rootBbox( worldExtentMin3D.x(), worldExtentMin3D.y(), worldExtentMin3D.z(), worldExtentMax3D.x(), worldExtentMax3D.y(), worldExtentMax3D.z() );
706 return rootBbox;
707}
708
710{
711 const QgsVector3D extentMin3D( box3D.xMinimum(), box3D.yMinimum(), box3D.zMinimum() );
712 const QgsVector3D extentMax3D( box3D.xMaximum(), box3D.yMaximum(), box3D.zMaximum() );
713 const QgsVector3D worldExtentMin3D = mapToWorldCoordinates( extentMin3D, mapOrigin );
714 const QgsVector3D worldExtentMax3D = mapToWorldCoordinates( extentMax3D, mapOrigin );
715 // casting to float should be ok, assuming that the map origin is not too far from the box
716 // clang-format off
717 return QgsAABB( static_cast<float>( worldExtentMin3D.x() ), static_cast<float>( worldExtentMin3D.y() ), static_cast<float>( worldExtentMin3D.z() ),
718 static_cast<float>( worldExtentMax3D.x() ), static_cast<float>( worldExtentMax3D.y() ), static_cast<float>( worldExtentMax3D.z() )
719 );
720 // clang-format on
721}
722
724{
725 const QgsVector3D worldExtentMin3D = Qgs3DUtils::worldToMapCoordinates( QgsVector3D( bbox.xMin, bbox.yMin, bbox.zMin ), mapOrigin );
726 const QgsVector3D worldExtentMax3D = Qgs3DUtils::worldToMapCoordinates( QgsVector3D( bbox.xMax, bbox.yMax, bbox.zMax ), mapOrigin );
727 const QgsRectangle extentMap( worldExtentMin3D.x(), worldExtentMin3D.y(), worldExtentMax3D.x(), worldExtentMax3D.y() );
728 // we discard zMin/zMax here because we don't need it
729 return extentMap;
730}
731
732
734 const QgsVector3D &worldPoint1,
735 const QgsVector3D &origin1,
737 const QgsVector3D &origin2,
739 const QgsCoordinateTransformContext &context
740)
741{
742 const QgsVector3D mapPoint1 = worldToMapCoordinates( worldPoint1, origin1 );
743 QgsVector3D mapPoint2 = mapPoint1;
744 if ( crs1 != crs2 )
745 {
746 // reproject if necessary
747 const QgsCoordinateTransform ct( crs1, crs2, context );
748 try
749 {
750 const QgsPointXY pt = ct.transform( QgsPointXY( mapPoint1.x(), mapPoint1.y() ) );
751 mapPoint2.set( pt.x(), pt.y(), mapPoint1.z() );
752 }
753 catch ( const QgsCsException & )
754 {
755 // bad luck, can't reproject for some reason
756 }
757 }
758 return mapToWorldCoordinates( mapPoint2, origin2 );
759}
760
761void Qgs3DUtils::estimateVectorLayerZRange( QgsVectorLayer *layer, double &zMin, double &zMax )
762{
763 if ( !QgsWkbTypes::hasZ( layer->wkbType() ) )
764 {
765 zMin = 0;
766 zMax = 0;
767 return;
768 }
769
770 zMin = std::numeric_limits<double>::max();
771 zMax = std::numeric_limits<double>::lowest();
772
773 QgsFeature f;
774 QgsFeatureIterator it = layer->getFeatures( QgsFeatureRequest().setNoAttributes().setLimit( 100 ) );
775 while ( it.nextFeature( f ) )
776 {
777 const QgsGeometry g = f.geometry();
778 for ( auto vit = g.vertices_begin(); vit != g.vertices_end(); ++vit )
779 {
780 const double z = ( *vit ).z();
781 if ( z < zMin )
782 zMin = z;
783 if ( z > zMax )
784 zMax = z;
785 }
786 }
787
788 if ( zMin == std::numeric_limits<double>::max() && zMax == std::numeric_limits<double>::lowest() )
789 {
790 zMin = 0;
791 zMax = 0;
792 }
793}
794
796{
798 settings.setAmbient( material->ambient() );
799 settings.setDiffuse( material->diffuse() );
800 settings.setSpecular( material->specular() );
801 settings.setShininess( material->shininess() );
802 return settings;
803}
804
805QgsRay3D Qgs3DUtils::rayFromScreenPoint( const QPoint &point, const QSize &windowSize, Qt3DRender::QCamera *camera )
806{
807 const QVector3D deviceCoords( point.x(), point.y(), 0.0 );
808 // normalized device coordinates
809 const QVector3D normDeviceCoords( 2.0 * deviceCoords.x() / windowSize.width() - 1.0f, 1.0f - 2.0 * deviceCoords.y() / windowSize.height(), camera->nearPlane() );
810 // clip coordinates of point on ray (its "end")
811 const QVector4D rayEndClip( normDeviceCoords.x(), normDeviceCoords.y(), 0.0, 1.0 );
812
813 const QMatrix4x4 invertedProjMatrix = camera->projectionMatrix().inverted();
814 const QMatrix4x4 invertedViewMatrix = camera->viewMatrix().inverted();
815
816 QVector3D rayOriginWorld; // ray origin in world coordinates
817 switch ( camera->projectionType() )
818 {
819 case Qt3DRender::QCameraLens::PerspectiveProjection:
820 {
821 // In perspective projection, the ray always comes from the camera centre.
822 rayOriginWorld = QVector3D( invertedViewMatrix * QVector4D( 0.0f, 0.0f, 0.0f, 1.0f ) );
823 break;
824 }
825 case Qt3DRender::QCameraLens::OrthographicProjection:
826 {
827 // In orthographic projection, the ray centre shifts with the cursor, the
828 // ray is always perpendicular to the projection plane.
829 QVector4D rayOriginView = invertedProjMatrix * rayEndClip;
830 rayOriginView.setZ( 0.0f );
831 rayOriginWorld = QVector3D( invertedViewMatrix * rayOriginView );
832 break;
833 }
834 default:
835 QgsDebugError( "Unhandled 3D projection type" );
836 }
837
838 // Find ray direction by first unprojecting the ray end's position
839 const QVector4D rayEndView = invertedProjMatrix * rayEndClip;
840 const QVector4D rayEndWorld4D = invertedViewMatrix * rayEndView;
841 const QVector3D rayEndWorld = rayEndWorld4D.toVector3DAffine();
842 QVector3D rayDirWorld = rayEndWorld - rayOriginWorld;
843 rayDirWorld = rayDirWorld.normalized();
844
845 return QgsRay3D( rayOriginWorld, rayDirWorld );
846}
847
848QVector3D Qgs3DUtils::screenPointToWorldPos( const QPoint &screenPoint, double depth, const QSize &screenSize, Qt3DRender::QCamera *camera )
849{
850 // Transform pixel coordinates and [0.0, 1.0]-range sampled depth to [-1.0, 1.0]
851 // normalised device coordinates used by projection matrix.
852 QVector3D screenPointNdc {
853 ( static_cast<float>( screenPoint.x() ) / ( static_cast<float>( screenSize.width() ) / 2.0f ) - 1.0f ),
854 -( static_cast<float>( screenPoint.y() ) / ( static_cast<float>( screenSize.height() ) / 2.0f ) - 1.0f ),
855 static_cast<float>( depth * 2 - 1 ),
856 };
857
858 // Apply inverse of projection matrix, then view matrix, to get from NDC to world coords.
859 return camera->viewMatrix().inverted() * camera->projectionMatrix().inverted() * screenPointNdc;
860}
861
862void Qgs3DUtils::pitchAndYawFromViewVector( QVector3D vect, double &pitch, double &yaw )
863{
864 vect.normalize();
865
866 pitch = qRadiansToDegrees( qAcos( vect.y() ) );
867 yaw = qRadiansToDegrees( qAtan2( -vect.z(), vect.x() ) ) + 90;
868}
869
870QVector2D Qgs3DUtils::screenToTextureCoordinates( QVector2D screenXY, QSize winSize )
871{
872 return QVector2D( screenXY.x() / winSize.width(), 1 - screenXY.y() / winSize.width() );
873}
874
875QVector2D Qgs3DUtils::textureToScreenCoordinates( QVector2D textureXY, QSize winSize )
876{
877 return QVector2D( textureXY.x() * winSize.width(), ( 1 - textureXY.y() ) * winSize.height() );
878}
879
880std::unique_ptr<QgsPointCloudLayer3DRenderer> Qgs3DUtils::convert2DPointCloudRendererTo3D( QgsPointCloudRenderer *renderer )
881{
882 if ( !renderer )
883 return nullptr;
884
885 std::unique_ptr<QgsPointCloud3DSymbol> symbol3D;
886 if ( renderer->type() == "ramp"_L1 )
887 {
888 const QgsPointCloudAttributeByRampRenderer *renderer2D = qgis::down_cast<const QgsPointCloudAttributeByRampRenderer *>( renderer );
889 symbol3D = std::make_unique<QgsColorRampPointCloud3DSymbol>();
890 QgsColorRampPointCloud3DSymbol *symbol = static_cast<QgsColorRampPointCloud3DSymbol *>( symbol3D.get() );
891 symbol->setAttribute( renderer2D->attribute() );
892 symbol->setColorRampShaderMinMax( renderer2D->minimum(), renderer2D->maximum() );
893 symbol->setColorRampShader( renderer2D->colorRampShader() );
894 }
895 else if ( renderer->type() == "rgb"_L1 )
896 {
897 const QgsPointCloudRgbRenderer *renderer2D = qgis::down_cast<const QgsPointCloudRgbRenderer *>( renderer );
898 symbol3D = std::make_unique<QgsRgbPointCloud3DSymbol>();
899 QgsRgbPointCloud3DSymbol *symbol = static_cast<QgsRgbPointCloud3DSymbol *>( symbol3D.get() );
900 symbol->setRedAttribute( renderer2D->redAttribute() );
901 symbol->setGreenAttribute( renderer2D->greenAttribute() );
902 symbol->setBlueAttribute( renderer2D->blueAttribute() );
903
904 symbol->setRedContrastEnhancement( renderer2D->redContrastEnhancement() ? new QgsContrastEnhancement( *renderer2D->redContrastEnhancement() ) : nullptr );
905 symbol->setGreenContrastEnhancement( renderer2D->greenContrastEnhancement() ? new QgsContrastEnhancement( *renderer2D->greenContrastEnhancement() ) : nullptr );
906 symbol->setBlueContrastEnhancement( renderer2D->blueContrastEnhancement() ? new QgsContrastEnhancement( *renderer2D->blueContrastEnhancement() ) : nullptr );
907 }
908 else if ( renderer->type() == "classified"_L1 )
909 {
910 const QgsPointCloudClassifiedRenderer *renderer2D = qgis::down_cast<const QgsPointCloudClassifiedRenderer *>( renderer );
911 symbol3D = std::make_unique<QgsClassificationPointCloud3DSymbol>();
912 QgsClassificationPointCloud3DSymbol *symbol = static_cast<QgsClassificationPointCloud3DSymbol *>( symbol3D.get() );
913 symbol->setAttribute( renderer2D->attribute() );
914 symbol->setCategoriesList( renderer2D->categories() );
915 }
916
917 if ( symbol3D )
918 {
919 auto renderer3D = std::make_unique<QgsPointCloudLayer3DRenderer>();
920 renderer3D->setSymbol( symbol3D.release() );
921 return renderer3D;
922 }
923 return nullptr;
924}
925
927{
928 QgsRayCastResult results;
929 const QList<QgsMapLayer *> keys = scene->layers();
930 for ( QgsMapLayer *layer : keys )
931 {
932 Qt3DCore::QEntity *entity = scene->layerEntity( layer );
933
934 if ( QgsChunkedEntity *chunkedEntity = qobject_cast<QgsChunkedEntity *>( entity ) )
935 {
936 const QList<QgsRayCastHit> hits = chunkedEntity->rayIntersection( ray, context );
937
938 if ( !hits.isEmpty() )
939 results.addLayerHits( layer, hits );
940 }
941 }
942 if ( QgsTerrainEntity *terrain = scene->terrainEntity() )
943 {
944 const QList<QgsRayCastHit> hits = terrain->rayIntersection( ray, context );
945
946 if ( !hits.isEmpty() )
947 results.addTerrainHits( hits );
948 }
949 if ( QgsGlobeEntity *globe = scene->globeEntity() )
950 {
951 const QList<QgsRayCastHit> hits = globe->rayIntersection( ray, context );
952
953 if ( !hits.isEmpty() )
954 results.addTerrainHits( hits );
955 }
956 return results;
957}
958
959float Qgs3DUtils::screenSpaceError( float epsilon, float distance, int screenSize, float fov )
960{
961 /* This routine approximately calculates how an error (epsilon) of an object in world coordinates
962 * at given distance (between camera and the object) will look like in screen coordinates.
963 *
964 * the math below simply uses triangle similarity:
965 *
966 * epsilon phi
967 * ----------------------------- = ----------------
968 * [ frustum width at distance ] [ screen width ]
969 *
970 * Then we solve for phi, substituting [frustum width at distance] = 2 * distance * tan(fov / 2)
971 *
972 * ________xxx__ xxx = real world error (epsilon)
973 * \ | / x = screen space error (phi)
974 * \ | /
975 * \___|_x_/ near plane (screen space)
976 * \ | /
977 * \ | /
978 * \|/ angle = field of view
979 * camera
980 */
981 float phi = epsilon * static_cast<float>( screenSize ) / static_cast<float>( 2 * distance * tan( fov * M_PI / ( 2 * 180 ) ) );
982 return phi;
983}
984
985void Qgs3DUtils::computeBoundingBoxNearFarPlanes( const QgsAABB &bbox, const QMatrix4x4 &viewMatrix, float &fnear, float &ffar )
986{
987 fnear = 1e9;
988 ffar = 0;
989
990 for ( int i = 0; i < 8; ++i )
991 {
992 const QVector4D p( ( ( i >> 0 ) & 1 ) ? bbox.xMin : bbox.xMax, ( ( i >> 1 ) & 1 ) ? bbox.yMin : bbox.yMax, ( ( i >> 2 ) & 1 ) ? bbox.zMin : bbox.zMax, 1 );
993
994 const QVector4D pc = viewMatrix * p;
995
996 const float dst = -pc.z(); // in camera coordinates, x grows right, y grows down, z grows to the back
997 fnear = std::min( fnear, dst );
998 ffar = std::max( ffar, dst );
999 }
1000}
1001
1002Qt3DRender::QCullFace::CullingMode Qgs3DUtils::qt3DcullingMode( Qgs3DTypes::CullingMode mode )
1003{
1004 switch ( mode )
1005 {
1007 return Qt3DRender::QCullFace::NoCulling;
1008 case Qgs3DTypes::Front:
1009 return Qt3DRender::QCullFace::Front;
1010 case Qgs3DTypes::Back:
1011 return Qt3DRender::QCullFace::Back;
1013 return Qt3DRender::QCullFace::FrontAndBack;
1014 }
1015 return Qt3DRender::QCullFace::NoCulling;
1016}
1017
1018
1019QByteArray Qgs3DUtils::addDefinesToShaderCode( const QByteArray &shaderCode, const QStringList &defines )
1020{
1021 // There is one caveat to take care of - GLSL source code needs to start with #version as
1022 // a first directive, otherwise we get the old GLSL 100 version. So we can't just prepend the
1023 // shader source code, but insert our defines at the right place.
1024
1025 QStringList defineLines;
1026 for ( const QString &define : defines )
1027 defineLines += "#define " + define + "\n";
1028
1029 QString definesText = defineLines.join( QString() );
1030
1031 QByteArray newShaderCode = shaderCode;
1032 int versionIndex = shaderCode.indexOf( "#version " );
1033 int insertionIndex = versionIndex == -1 ? 0 : shaderCode.indexOf( '\n', versionIndex + 1 ) + 1;
1034 newShaderCode.insert( insertionIndex, definesText.toLatin1() );
1035 return newShaderCode;
1036}
1037
1038QVector3D Qgs3DUtils::axisStringToVector( const QString &axis )
1039{
1040 if ( axis == "x"_L1 )
1041 return QVector3D( 1.0f, 0.0f, 0.0f );
1042 if ( axis == "-x"_L1 )
1043 return QVector3D( -1.0f, 0.0f, 0.0f );
1044 if ( axis == "y"_L1 )
1045 return QVector3D( 0.0f, 1.0f, 0.0f );
1046 if ( axis == "-y"_L1 )
1047 return QVector3D( 0.0f, -1.0f, 0.0f );
1048 if ( axis == "z"_L1 )
1049 return QVector3D( 0.0f, 0.0f, 1.0f );
1050 if ( axis == "-z"_L1 )
1051 return QVector3D( 0.0f, 0.0f, -1.0f );
1052 return QVector3D();
1053}
1054
1055QMatrix4x4 Qgs3DUtils::axisTransformMatrix( const QString &upAxis, const QString &forwardAxis )
1056{
1057 const QVector3D up = axisStringToVector( upAxis );
1058 const QVector3D forward = axisStringToVector( forwardAxis );
1059
1060 if ( up.isNull() || forward.isNull() )
1061 return QMatrix4x4();
1062
1063 const QVector3D right = QVector3D::crossProduct( forward, up );
1064 if ( right.isNull() )
1065 return QMatrix4x4();
1066
1067 const float data[9] = {
1068 right.x(),
1069 right.y(),
1070 right.z(),
1071 forward.x(),
1072 forward.y(),
1073 forward.z(),
1074 up.x(),
1075 up.y(),
1076 up.z(),
1077 };
1078 return QMatrix4x4( QMatrix3x3( data ) );
1079}
1080
1081QByteArray Qgs3DUtils::removeDefinesFromShaderCode( const QByteArray &shaderCode, const QStringList &defines )
1082{
1083 QByteArray newShaderCode = shaderCode;
1084
1085 for ( const QString &define : defines )
1086 {
1087 const QString defineLine = "#define " + define + "\n";
1088 const int defineLineIndex = newShaderCode.indexOf( defineLine.toUtf8() );
1089 if ( defineLineIndex != -1 )
1090 {
1091 newShaderCode.remove( defineLineIndex, defineLine.size() );
1092 }
1093 }
1094
1095 return newShaderCode;
1096}
1097
1098void Qgs3DUtils::decomposeTransformMatrix( const QMatrix4x4 &matrix, QVector3D &translation, QQuaternion &rotation, QVector3D &scale )
1099{
1100 // decompose the transform matrix
1101 // assuming the last row has values [0 0 0 1]
1102 // see https://math.stackexchange.com/questions/237369/given-this-transformation-matrix-how-do-i-decompose-it-into-translation-rotati
1103 const float *md = matrix.data(); // returns data in column-major order
1104 const float sx = QVector3D( md[0], md[1], md[2] ).length();
1105 const float sy = QVector3D( md[4], md[5], md[6] ).length();
1106 const float sz = QVector3D( md[8], md[9], md[10] ).length();
1107 float rd[9] = {
1108 md[0] / sx,
1109 md[4] / sy,
1110 md[8] / sz,
1111 md[1] / sx,
1112 md[5] / sy,
1113 md[9] / sz,
1114 md[2] / sx,
1115 md[6] / sy,
1116 md[10] / sz,
1117 };
1118 const QMatrix3x3 rot3x3( rd ); // takes data in row-major order
1119
1120 scale = QVector3D( sx, sy, sz );
1121 rotation = QQuaternion::fromRotationMatrix( rot3x3 );
1122 translation = QVector3D( md[12], md[13], md[14] );
1123}
1124
1125int Qgs3DUtils::openGlMaxClipPlanes( QSurface *surface )
1126{
1127 int numPlanes = 6;
1128
1129 QOpenGLContext context;
1130 context.setFormat( QSurfaceFormat::defaultFormat() );
1131 if ( context.create() )
1132 {
1133 if ( context.makeCurrent( surface ) )
1134 {
1135 QOpenGLFunctions *funcs = context.functions();
1136 funcs->glGetIntegerv( GL_MAX_CLIP_PLANES, &numPlanes );
1137 }
1138 }
1139
1140 return numPlanes;
1141}
1142
1143QQuaternion Qgs3DUtils::rotationFromPitchHeadingAngles( float pitchAngle, float headingAngle )
1144{
1145 return QQuaternion::fromAxisAndAngle( QVector3D( 0, 0, 1 ), headingAngle ) * QQuaternion::fromAxisAndAngle( QVector3D( 1, 0, 0 ), pitchAngle );
1146}
1147
1148QgsPoint Qgs3DUtils::screenPointToMapCoordinates( const QPoint &screenPoint, const QSize size, const QgsCameraController *cameraController, const Qgs3DMapSettings *mapSettings )
1149{
1150 const QgsRay3D ray = rayFromScreenPoint( screenPoint, size, cameraController->camera() );
1151
1152 // pick an arbitrary point mid-way between near and far plane
1153 const float pointDistance = ( cameraController->camera()->farPlane() + cameraController->camera()->nearPlane() ) / 2;
1154 const QVector3D worldPoint = ray.point( pointDistance );
1155 const QgsVector3D mapTransform = worldToMapCoordinates( worldPoint, mapSettings->origin() );
1156 const QgsPoint mapPoint( mapTransform.x(), mapTransform.y(), mapTransform.z() );
1157 return mapPoint;
1158}
1159
1160QVector3D Qgs3DUtils::calculateDirectionalLightUpVector( const QVector3D &lightDirection )
1161{
1162 QVector3D up( 0.0f, 1.0f, 0.0f );
1163 if ( std::abs( QVector3D::dotProduct( lightDirection, up ) ) > 0.99f )
1164 up = QVector3D( 0.0f, 0.0f, 1.0f );
1165 return up;
1166}
1167
1168std::vector<float> Qgs3DUtils::calculateCascadeSplits( int numberCascades, float nearPlane, float farPlane, float lambda )
1169{
1170 // prevent division by zero if nearPlane is 0 or negative
1171 const float safeNearPlane = std::max( nearPlane, 0.0001f );
1172
1173 std::vector<float> cascadeSplits( numberCascades + 1 );
1174
1175 // "Practical Split Scheme" for cascading shadow maps.
1176 for ( int i = 0; i <= numberCascades; ++i )
1177 {
1178 const float p = static_cast<float>( i ) / static_cast<float>( numberCascades );
1179 const float logSplit = safeNearPlane * std::pow( farPlane / safeNearPlane, p );
1180 const float uniSplit = safeNearPlane + ( farPlane - safeNearPlane ) * p;
1181 cascadeSplits[i] = lambda * logSplit + ( 1.0f - lambda ) * uniSplit;
1182 }
1183 return cascadeSplits;
1184}
1185
1186void Qgs3DUtils::calculateFrustumSliceCorners( float zNear, float zFar, float fov, float aspectRatio, const QMatrix4x4 &invertedCameraView, QVector3D ( &corners )[8], QVector3D &center )
1187{
1188 const float fovC = static_cast< float >( std::tan( fov * M_PI / 360.0 ) );
1189 const float halfYNear = zNear * fovC;
1190 const float halfXNear = halfYNear * aspectRatio;
1191 const float halfYFar = zFar * fovC;
1192 const float halfXFar = halfYFar * aspectRatio;
1193
1194 // calculate the 8 corners of the camera frustum slice in camera view space, and transform to world space
1195 corners[0] = invertedCameraView.map( QVector3D( -halfXNear, -halfYNear, -zNear ) );
1196 corners[1] = invertedCameraView.map( QVector3D( halfXNear, -halfYNear, -zNear ) );
1197 corners[2] = invertedCameraView.map( QVector3D( halfXNear, halfYNear, -zNear ) );
1198 corners[3] = invertedCameraView.map( QVector3D( -halfXNear, halfYNear, -zNear ) );
1199 corners[4] = invertedCameraView.map( QVector3D( -halfXFar, -halfYFar, -zFar ) );
1200 corners[5] = invertedCameraView.map( QVector3D( halfXFar, -halfYFar, -zFar ) );
1201 corners[6] = invertedCameraView.map( QVector3D( halfXFar, halfYFar, -zFar ) );
1202 corners[7] = invertedCameraView.map( QVector3D( -halfXFar, halfYFar, -zFar ) );
1203
1204 // find the center
1205 center = QVector3D( 0, 0, 0 );
1206 for ( int j = 0; j < 8; ++j )
1207 {
1208 center += corners[j];
1209 }
1210 center /= 8.0f;
1211}
1212
1214 const QVector3D ( &worldCorners )[8], const QMatrix4x4 &viewMatrix, float &left, float &right, float &bottom, float &top, float &nearPlane, float &farPlane
1215)
1216{
1217 // transform corners to find the bounding box
1218 left = std::numeric_limits<float>::max();
1219 right = std::numeric_limits<float>::lowest();
1220 bottom = std::numeric_limits<float>::max();
1221 top = std::numeric_limits<float>::lowest();
1222 nearPlane = std::numeric_limits<float>::max();
1223 farPlane = std::numeric_limits<float>::lowest();
1224 for ( int j = 0; j < 8; ++j )
1225 {
1226 const QVector3D lightSpaceCorner = viewMatrix.map( worldCorners[j] );
1227 left = std::min( left, lightSpaceCorner.x() );
1228 right = std::max( right, lightSpaceCorner.x() );
1229 bottom = std::min( bottom, lightSpaceCorner.y() );
1230 top = std::max( top, lightSpaceCorner.y() );
1231 const float zDistance = -lightSpaceCorner.z();
1232 nearPlane = std::min( nearPlane, zDistance );
1233 farPlane = std::max( farPlane, zDistance );
1234 }
1235}
1236
1237QList<QVector4D> Qgs3DUtils::lineSegmentToClippingPlanes( const QgsVector3D &startPoint, const QgsVector3D &endPoint, const double distance, const QgsVector3D &origin )
1238{
1239 // return empty vector if distance is negative
1240 if ( distance < 0 )
1241 return QList<QVector4D>();
1242
1243 QgsVector3D lineDirection( endPoint - startPoint );
1244 lineDirection.normalize();
1245 const QgsVector lineDirection2DPerp = QgsVector( lineDirection.x(), lineDirection.y() ).perpVector();
1246 const QgsVector3D linePerp( lineDirection2DPerp.x(), lineDirection2DPerp.y(), 0 );
1247
1248 QList<QVector4D> clippingPlanes;
1249 QgsVector3D planePoint;
1250 double originDistance;
1251
1252 // the naming is assigned according to line direction
1254 planePoint = startPoint;
1255 originDistance = QgsVector3D::dotProduct( planePoint - origin, lineDirection );
1256 clippingPlanes << QVector4D( static_cast<float>( lineDirection.x() ), static_cast<float>( lineDirection.y() ), 0, static_cast<float>( -originDistance ) );
1257
1259 planePoint = startPoint + linePerp * distance;
1260 originDistance = QgsVector3D::dotProduct( planePoint - origin, -linePerp );
1261 clippingPlanes << QVector4D( static_cast<float>( -linePerp.x() ), static_cast<float>( -linePerp.y() ), 0, static_cast<float>( -originDistance ) );
1262
1264 planePoint = endPoint;
1265 originDistance = QgsVector3D::dotProduct( planePoint - origin, -lineDirection );
1266 clippingPlanes << QVector4D( static_cast<float>( -lineDirection.x() ), static_cast<float>( -lineDirection.y() ), 0, static_cast<float>( -originDistance ) );
1267
1269 planePoint = startPoint - linePerp * distance;
1270 originDistance = QgsVector3D::dotProduct( planePoint - origin, linePerp );
1271 clippingPlanes << QVector4D( static_cast<float>( linePerp.x() ), static_cast<float>( linePerp.y() ), 0, static_cast<float>( -originDistance ) );
1272
1273 return clippingPlanes;
1274}
1275
1276QgsCameraPose Qgs3DUtils::lineSegmentToCameraPose( const QgsVector3D &startPoint, const QgsVector3D &endPoint, const QgsDoubleRange &elevationRange, const float fieldOfView, const QgsVector3D &worldOrigin )
1277{
1278 QgsCameraPose cameraPose;
1279 // we tilt the view slightly to see flat layers if the elevationRange is infinite (scene has flat terrain, vector layers...)
1280 elevationRange.isInfinite() ? cameraPose.setPitchAngle( 89 ) : cameraPose.setPitchAngle( 90 );
1281
1282 // calculate the middle of the front side defined by clipping planes
1283 QgsVector linePerpVec( ( endPoint - startPoint ).x(), ( endPoint - startPoint ).y() );
1284 linePerpVec = -linePerpVec.normalized().perpVector();
1285 const QgsVector3D linePerpVec3D( linePerpVec.x(), linePerpVec.y(), 0 );
1286 QgsVector3D middle( startPoint + ( endPoint - startPoint ) / 2 );
1287
1288 double elevationRangeHalf;
1289 elevationRange.isInfinite() ? elevationRangeHalf = 0 : elevationRangeHalf = ( elevationRange.upper() - elevationRange.lower() ) / 2;
1290 const double side = std::max( middle.distance( startPoint ), elevationRangeHalf );
1291 const double distance = ( side / std::tan( fieldOfView / 2 * M_PI / 180 ) ) * 1.05;
1292 cameraPose.setDistanceFromCenterPoint( static_cast<float>( distance ) );
1293
1294 elevationRange.isInfinite() ? middle.setZ( 0 ) : middle.setZ( elevationRange.lower() + ( elevationRange.upper() - elevationRange.lower() ) / 2 );
1295 cameraPose.setCenterPoint( mapToWorldCoordinates( middle, worldOrigin ) );
1296
1297 const QgsVector3D northDirectionVec( 0, -1, 0 );
1298 // calculate the angle between vector pointing to the north and vector pointing from the front side of clipped area
1299 float yawAngle = static_cast<float>( acos( QgsVector3D::dotProduct( linePerpVec3D, northDirectionVec ) ) * 180 / M_PI );
1300 // check if the angle between the view point is to the left or right of the scene north, apply angle offset if necessary for camera
1301 if ( QgsVector3D::crossProduct( linePerpVec3D, northDirectionVec ).z() > 0 )
1302 {
1303 yawAngle = 360 - yawAngle;
1304 }
1305 cameraPose.setHeadingAngle( yawAngle );
1306
1307 return cameraPose;
1308}
1309
1310std::unique_ptr<Qt3DRender::QCamera> Qgs3DUtils::copyCamera( Qt3DRender::QCamera *cam )
1311{
1312 auto copy = std::make_unique<Qt3DRender::QCamera>();
1313 copy->setPosition( cam->position() );
1314 copy->setViewCenter( cam->viewCenter() );
1315 copy->setUpVector( cam->upVector() );
1316
1317 switch ( cam->projectionType() )
1318 {
1319 case Qt3DRender::QCameraLens::OrthographicProjection:
1320 copy->lens()->setOrthographicProjection( cam->left(), cam->right(), cam->bottom(), cam->top(), cam->nearPlane(), cam->farPlane() );
1321 break;
1322 case Qt3DRender::QCameraLens::FrustumProjection:
1323 copy->lens()->setFrustumProjection( cam->left(), cam->right(), cam->bottom(), cam->top(), cam->nearPlane(), cam->farPlane() );
1324 break;
1325 case Qt3DRender::QCameraLens::PerspectiveProjection:
1326 copy->lens()->setPerspectiveProjection( cam->fieldOfView(), cam->aspectRatio(), cam->nearPlane(), cam->farPlane() );
1327 break;
1328 case Qt3DRender::QCameraLens::CustomProjection:
1329 copy->setProjectionMatrix( cam->projectionMatrix() );
1330 break;
1331 }
1332 return copy;
1333}
1334
1335void Qgs3DUtils::setTextureFiltering( Qt3DRender::QAbstractTexture *texture, const QgsMaterialContext &context )
1336{
1337 texture->setGenerateMipMaps( true );
1338 texture->setMagnificationFilter( Qt3DRender::QTexture2D::Linear );
1339 texture->setMinificationFilter( Qt3DRender::QTexture2D::LinearMipMapLinear );
1340
1341 switch ( context.textureFilterQuality() )
1342 {
1344 texture->setMaximumAnisotropy( 1 );
1345 break;
1347 texture->setMaximumAnisotropy( 2 );
1348 break;
1350 texture->setMaximumAnisotropy( 4 );
1351 break;
1353 texture->setMaximumAnisotropy( 8 );
1354 break;
1356 texture->setMaximumAnisotropy( 16 );
1357 break;
1358 }
1359}
1360
1361Qt3DRender::QAbstractTexture::TextureFormat Qgs3DUtils::determineTextureFormat( QImage::Format imageFormat, bool isSrgb, bool &requiresConversionToRgb )
1362{
1363 requiresConversionToRgb = false;
1364 switch ( imageFormat )
1365 {
1366 case QImage::Format_RGBA32FPx4:
1367 case QImage::Format_RGBA32FPx4_Premultiplied:
1368 return Qt3DRender::QAbstractTexture::RGBA32F;
1369
1370 case QImage::Format_RGBX32FPx4:
1371 return Qt3DRender::QAbstractTexture::RGB32F;
1372
1373 case QImage::Format_RGBA16FPx4:
1374 case QImage::Format_RGBA16FPx4_Premultiplied:
1375 return Qt3DRender::QAbstractTexture::RGBA16F;
1376
1377 case QImage::Format_RGBX16FPx4:
1378 return Qt3DRender::QAbstractTexture::RGB16F;
1379
1380 case QImage::Format_RGBA8888:
1381 case QImage::Format_RGBA8888_Premultiplied:
1382 case QImage::Format_ARGB32:
1383 case QImage::Format_ARGB32_Premultiplied:
1384 return isSrgb ? Qt3DRender::QAbstractTexture::SRGB8_Alpha8 : Qt3DRender::QAbstractTexture::RGBA8_UNorm;
1385
1386 case QImage::Format_RGB32:
1387 case QImage::Format_RGB888:
1388 return isSrgb ? Qt3DRender::QAbstractTexture::SRGB8 : Qt3DRender::QAbstractTexture::RGB8_UNorm;
1389
1390 case QImage::Format_Grayscale8:
1391 case QImage::Format_Alpha8:
1392 return Qt3DRender::QAbstractTexture::R8_UNorm;
1393 case QImage::Format_Grayscale16:
1394 return Qt3DRender::QAbstractTexture::R16_UNorm;
1395
1396 case QImage::Format_Invalid:
1397 case QImage::Format_Mono:
1398 case QImage::Format_MonoLSB:
1399 case QImage::Format_Indexed8:
1400 case QImage::Format_RGB16:
1401 case QImage::Format_ARGB8565_Premultiplied:
1402 case QImage::Format_RGB666:
1403 case QImage::Format_ARGB6666_Premultiplied:
1404 case QImage::Format_RGB555:
1405 case QImage::Format_ARGB8555_Premultiplied:
1406 case QImage::Format_RGB444:
1407 case QImage::Format_ARGB4444_Premultiplied:
1408 case QImage::Format_RGBX8888:
1409 case QImage::Format_BGR30:
1410 case QImage::Format_A2BGR30_Premultiplied:
1411 case QImage::Format_RGB30:
1412 case QImage::Format_A2RGB30_Premultiplied:
1413 case QImage::Format_RGBX64:
1414 case QImage::Format_RGBA64:
1415 case QImage::Format_RGBA64_Premultiplied:
1416 case QImage::Format_BGR888:
1417#if QT_VERSION >= QT_VERSION_CHECK( 6, 8, 0 )
1418 case QImage::Format_CMYK8888:
1419#endif
1420 case QImage::NImageFormats:
1421 // image format isn't compatible, it needs converting by caller
1422 requiresConversionToRgb = true;
1423 break;
1424 }
1425 return isSrgb ? Qt3DRender::QAbstractTexture::SRGB8_Alpha8 : Qt3DRender::QAbstractTexture::RGBA8_UNorm;
1426}
AltitudeClamping
Altitude clamping.
Definition qgis.h:4257
@ Relative
Elevation is relative to terrain height (final elevation = terrain elevation + feature elevation).
Definition qgis.h:4259
@ Terrain
Elevation is clamped to terrain (final elevation = terrain elevation).
Definition qgis.h:4260
@ Absolute
Elevation is taken directly from feature and is independent of terrain height (final elevation = feat...
Definition qgis.h:4258
@ Anisotropic8x
Anisotropic filtering (8x).
Definition qgis.h:4525
@ Anisotropic2x
Anisotropic filtering (2x).
Definition qgis.h:4523
@ Anisotropic4x
Anisotropic filtering (4x).
Definition qgis.h:4524
@ Trilinear
Trilinear (LinearMipmapLinear).
Definition qgis.h:4522
@ Anisotropic16x
Anisotropic filtering (16x).
Definition qgis.h:4526
@ Geocentric
Geocentric CRS.
Definition qgis.h:2516
AltitudeBinding
Altitude binding.
Definition qgis.h:4270
@ Centroid
Clamp just centroid of feature.
Definition qgis.h:4272
@ Vertex
Clamp every vertex of feature.
Definition qgis.h:4271
Holds information about animation in 3D view.
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.
Entity that encapsulates our 3D scene - contains all other entities (such as terrain) as children.
QgsTerrainEntity * terrainEntity() SIP_SKIP
Returns terrain entity (may be nullptr if using globe scene, terrain rendering is disabled or when te...
QgsCameraController * cameraController() const
Returns camera controller.
@ Ready
The scene is fully loaded/updated.
int totalPendingJobsCount() const
Returns number of pending jobs for all chunked entities.
QList< QgsMapLayer * > layers() const SIP_SKIP
Returns the layers that contain chunked entities.
void sceneStateChanged()
Emitted when the scene's state has changed.
SceneState sceneState() const
Returns the current state of the scene.
Qt3DCore::QEntity * layerEntity(QgsMapLayer *layer) const SIP_SKIP
Returns the entity belonging to layer.
QgsGlobeEntity * globeEntity() SIP_SKIP
Returns globe entity (may be nullptr if not using globe scene, terrain rendering is disabled or when ...
Definition of the world.
QgsVector3D origin() const
Returns coordinates in map CRS at which 3D scene has origin (0,0,0).
Rendering context for preparation of 3D entities.
QgsCoordinateReferenceSystem crs() const
Returns the coordinate reference system used in the 3D scene.
const QgsAbstractTerrainSettings * terrainSettings() const
Returns the terrain settings.
QgsTerrainGenerator * terrainGenerator() const
Returns the terrain generator.
bool terrainRenderingEnabled() const
Returns whether the 2D terrain surface will be rendered.
static const char * PROP_NAME_3D_RENDERER_FLAG
Qt property name to hold the 3D geometry renderer flag.
Definition qgs3dtypes.h:43
CullingMode
Triangle culling mode.
Definition qgs3dtypes.h:35
@ FrontAndBack
Will not render anything.
Definition qgs3dtypes.h:39
@ NoCulling
Will render both front and back faces of triangles.
Definition qgs3dtypes.h:36
@ Front
Will render only back faces of triangles.
Definition qgs3dtypes.h:37
@ Back
Will render only front faces of triangles (recommended when input data are consistent).
Definition qgs3dtypes.h:38
static QgsVector3D transformWorldCoordinates(const QgsVector3D &worldPoint1, const QgsVector3D &origin1, const QgsCoordinateReferenceSystem &crs1, const QgsVector3D &origin2, const QgsCoordinateReferenceSystem &crs2, const QgsCoordinateTransformContext &context)
Transforms a world point from (origin1, crs1) to (origin2, crs2).
static QQuaternion rotationFromPitchHeadingAngles(float pitchAngle, float headingAngle)
Returns rotation quaternion that performs rotation around X axis by pitchAngle, followed by rotation ...
static QByteArray removeDefinesFromShaderCode(const QByteArray &shaderCode, const QStringList &defines)
Removes some define macros from a shader source code.
static Qt3DRender::QCullFace::CullingMode qt3DcullingMode(Qgs3DTypes::CullingMode mode)
Converts Qgs3DTypes::CullingMode mode into its Qt3D equivalent.
static QList< QVector4D > lineSegmentToClippingPlanes(const QgsVector3D &startPoint, const QgsVector3D &endPoint, double distance, const QgsVector3D &origin)
Returns a list of 4 planes derived from a line extending from startPoint to endPoint.
static Qgs3DTypes::CullingMode cullingModeFromString(const QString &str)
Converts a string to a value from CullingMode enum.
static Qgis::AltitudeClamping altClampingFromString(const QString &str)
Converts a string to a value from AltitudeClamping enum.
static QString matrix4x4toString(const QMatrix4x4 &m)
Converts a 4x4 transform matrix to a string.
static QgsRectangle worldToMapExtent(const QgsAABB &bbox, const QgsVector3D &mapOrigin)
Converts axis aligned bounding box in 3D world coordinates to extent in map coordinates.
static void setTextureFiltering(Qt3DRender::QAbstractTexture *texture, const QgsMaterialContext &context)
Sets the default filtering options for a texture.
static QgsRectangle worldToLayerExtent(const QgsAABB &bbox, const QgsCoordinateReferenceSystem &layerCrs, const QgsVector3D &mapOrigin, const QgsCoordinateReferenceSystem &mapCrs, const QgsCoordinateTransformContext &context)
Converts axis aligned bounding box in 3D world coordinates to extent in map layer CRS.
static void pitchAndYawFromViewVector(QVector3D vect, double &pitch, double &yaw)
Function used to extract the pitch and yaw (also known as heading) angles in degrees from the view ve...
static void decomposeTransformMatrix(const QMatrix4x4 &matrix, QVector3D &translation, QQuaternion &rotation, QVector3D &scale)
Tries to decompose a 4x4 transform matrix into translation, rotation and scale components.
static int maxZoomLevel(double tile0width, double tileResolution, double maxError)
Calculates the highest needed zoom level for tiles in quad-tree given width of the base tile (zoom le...
static QgsAABB mapToWorldExtent(const QgsRectangle &extent, double zMin, double zMax, const QgsVector3D &mapOrigin)
Converts map extent to axis aligned bounding box in 3D world coordinates.
static QgsAABB layerToWorldExtent(const QgsRectangle &extent, double zMin, double zMax, const QgsCoordinateReferenceSystem &layerCrs, const QgsVector3D &mapOrigin, const QgsCoordinateReferenceSystem &mapCrs, const QgsCoordinateTransformContext &context)
Converts extent (in map layer's CRS) to axis aligned bounding box in 3D world coordinates.
static Qgis::AltitudeBinding altBindingFromString(const QString &str)
Converts a string to a value from AltitudeBinding enum.
static double calculateEntityGpuMemorySize(Qt3DCore::QEntity *entity)
Calculates approximate usage of GPU memory by an entity.
static std::unique_ptr< Qt3DRender::QCamera > copyCamera(Qt3DRender::QCamera *cam)
Returns new camera object with copied properties.
static void calculateViewSpaceOrthographicBounds(const QVector3D(&worldCorners)[8], const QMatrix4x4 &viewMatrix, float &left, float &right, float &bottom, float &top, float &nearPlane, float &farPlane)
Calculates the orthographic projection bounds required to tightly enclose a set of 8 world-space corn...
static QString cullingModeToString(Qgs3DTypes::CullingMode mode)
Converts a value from CullingMode enum to a string.
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 QgsPoint screenPointToMapCoordinates(const QPoint &screenPoint, QSize size, const QgsCameraController *cameraController, const Qgs3DMapSettings *mapSettings)
Transform the given screen point to QgsPoint in map coordinates.
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 QVector3D calculateDirectionalLightUpVector(const QVector3D &lightDirection)
Calculates an appropriate up vector for a directional light.
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 QgsRayCastResult castRay(Qgs3DMapScene *scene, const QgsRay3D &ray, const QgsRayCastContext &context)
Casts a ray through the scene and returns information about the intersecting entities (ray uses World...
static Qt3DRender::QAbstractTexture::TextureFormat determineTextureFormat(QImage::Format format, bool isSrgb, bool &requiresConversionToRgb)
Given a QImage format, returns the most appropriate corresponding texture format.
static QMatrix4x4 stringToMatrix4x4(const QString &str)
Convert a string to a 4x4 transform matrix.
static QgsVector3D worldToMapCoordinates(const QgsVector3D &worldCoords, const QgsVector3D &origin)
Converts 3D world coordinates to map coordinates (applies offset).
static QgsVector3D mapToWorldCoordinates(const QgsVector3D &mapCoords, const QgsVector3D &origin)
Converts map coordinates to 3D world coordinates (applies offset).
static QVector2D textureToScreenCoordinates(QVector2D textureXY, QSize winSize)
Converts from texture coordinates coordinates to screen coordinates.
static void computeBoundingBoxNearFarPlanes(const QgsAABB &bbox, const QMatrix4x4 &viewMatrix, float &fnear, float &ffar)
This routine computes nearPlane farPlane from the closest and farthest corners point of bounding box ...
static bool exportAnimation(const Qgs3DAnimationSettings &animationSettings, Qgs3DMapSettings &mapSettings, int framesPerSecond, const QString &outputDirectory, const QString &fileNameTemplate, const QSize &outputSize, QString &error, QgsFeedback *feedback=nullptr)
Captures 3D animation frames to the selected folder.
static QVector3D screenPointToWorldPos(const QPoint &screenPoint, double depth, const QSize &screenSize, Qt3DRender::QCamera *camera)
Converts the clicked mouse position to the corresponding 3D world coordinates.
static void waitForFrame(QgsAbstract3DEngine &engine, Qgs3DMapScene *scene)
Waits for a frame to be rendered.
static float clampAltitude(const QgsPoint &p, Qgis::AltitudeClamping altClamp, Qgis::AltitudeBinding altBind, float offset, const QgsPoint &centroid, const Qgs3DRenderContext &context)
Clamps altitude of a vertex according to the settings, returns Z value.
static QString altBindingToString(Qgis::AltitudeBinding altBind)
Converts a value from AltitudeBinding enum to a string.
static void clampAltitudes(QgsLineString *lineString, Qgis::AltitudeClamping altClamp, Qgis::AltitudeBinding altBind, const QgsPoint &centroid, float offset, const Qgs3DRenderContext &context)
Clamps altitude of vertices of a linestring according to the settings.
static std::vector< float > calculateCascadeSplits(int numberCascades, float nearPlane, float farPlane, float lambda=0.9f)
Calculates the split distances for cascading shadow maps using the "Practical Split Scheme".
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 QColor srgbToLinear(const QColor &color)
Converts a SRGB color to a linear color.
static QgsCameraPose lineSegmentToCameraPose(const QgsVector3D &startPoint, const QgsVector3D &endPoint, const QgsDoubleRange &elevationRange, float fieldOfView, const QgsVector3D &worldOrigin)
Returns the camera pose for a camera looking at mid-point between startPoint and endPoint.
static QMatrix4x4 axisTransformMatrix(const QString &upAxis, const QString &forwardAxis)
Computes a 3x3 orientation matrix from the given up and forward axis strings.
static void waitForEntitiesLoaded(Qgs3DMapScene *scene)
Waits for all entities in the scene to be loaded.
static std::unique_ptr< QgsPointCloudLayer3DRenderer > convert2DPointCloudRendererTo3D(QgsPointCloudRenderer *renderer)
Creates a QgsPointCloudLayer3DRenderer matching the symbol settings of a given QgsPointCloudRenderer.
static void calculateFrustumSliceCorners(float zNear, float zFar, float fov, float aspectRatio, const QMatrix4x4 &invertedCameraView, QVector3D(&corners)[8], QVector3D &center)
Calculates the 8 corners of a camera frustum slice in world space and its center point.
static void extractPointPositions(const QgsFeature &f, const Qgs3DRenderContext &context, const QgsVector3D &chunkOrigin, Qgis::AltitudeClamping altClamp, QVector< QVector3D > &positions)
Calculates (x,y,z) positions of (multi)point from the given feature.
static QImage captureSceneDepthBuffer(QgsAbstract3DEngine &engine, Qgs3DMapScene *scene)
Captures the depth buffer of the current 3D scene of a 3D engine.
static int openGlMaxClipPlanes(QSurface *surface)
Gets the maximum number of clip planes that can be used.
Axis-aligned bounding box - in world coords.
Definition qgsaabb.h:33
float yMax
Definition qgsaabb.h:104
float xMax
Definition qgsaabb.h:103
float xMin
Definition qgsaabb.h:100
float zMax
Definition qgsaabb.h:105
float yMin
Definition qgsaabb.h:101
float zMin
Definition qgsaabb.h:102
Base class for 3D engine implementation.
void requestCaptureImage()
Starts a request for an image rendered by the engine.
void requestDepthBufferCapture()
Starts a request for an image containing the depth buffer data of the engine.
void imageCaptured(const QImage &image)
Emitted after a call to requestCaptureImage() to return the captured image.
void depthBufferCaptured(const QImage &image)
Emitted after a call to requestDepthBufferCapture() to return the captured depth buffer.
virtual Qt3DRender::QRenderSettings * renderSettings()=0
Returns access to the engine's render settings (the frame graph can be accessed from here).
Abstract base class for all geometries.
vertex_iterator vertices_end() const
Returns STL-style iterator pointing to the imaginary vertex after the last vertex of the geometry.
bool is3D() const
Returns true if the geometry is 3D and contains a z-value.
vertex_iterator vertices_begin() const
Returns STL-style iterator pointing to the first vertex of the geometry.
virtual QgsPoint centroid() const
Returns the centroid of the geometry.
double verticalScale() const
Returns the vertical scale (exaggeration) for terrain.
A 3-dimensional box composed of x, y, z coordinates.
Definition qgsbox3d.h:45
double yMaximum() const
Returns the maximum y value.
Definition qgsbox3d.h:240
double xMinimum() const
Returns the minimum x value.
Definition qgsbox3d.h:205
double zMaximum() const
Returns the maximum z value.
Definition qgsbox3d.h:268
double xMaximum() const
Returns the maximum x value.
Definition qgsbox3d.h:212
double zMinimum() const
Returns the minimum z value.
Definition qgsbox3d.h:261
double yMinimum() const
Returns the minimum y value.
Definition qgsbox3d.h:233
Object that controls camera movement based on user input.
void setLookingAtMapPoint(const QgsVector3D &point, float distance, float pitch, float yaw)
Sets camera configuration like setLookingAtPoint(), but the point is given in map coordinates.
Qt3DRender::QCamera * camera() const
Returns camera that is being controlled.
Encapsulates camera pose in a 3D scene.
void setPitchAngle(float pitch)
Sets pitch angle in degrees.
void setCenterPoint(const QgsVector3D &point)
Sets center point (towards which point the camera is looking).
void setHeadingAngle(float heading)
Sets heading (yaw) angle in degrees.
void setDistanceFromCenterPoint(float distance)
Sets distance of the camera from the center point.
3D symbol that draws point cloud geometries as 3D objects using classification of the dataset.
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.
3D symbol that draws point cloud geometries as 3D objects using color ramp shader.
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.
Handles contrast enhancement and clipping.
Represents a coordinate reference system (CRS).
Qgis::CrsType type() const
Returns the type of the CRS.
Contains information about the context in which a coordinate transform is executed.
Handles coordinate transforms between two 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:36
QgsRange which stores a range of double values.
Definition qgsrange.h:217
bool isInfinite() const
Returns true if the range consists of all possible values.
Definition qgsrange.h:266
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.
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:60
QgsGeometry geometry
Definition qgsfeature.h:66
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:56
void setProgress(double progress)
Sets the current progress for the feedback object.
Definition qgsfeedback.h:65
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.
Base class for all map layer types.
Definition qgsmaplayer.h:84
Context settings for a material.
Qgis::TextureFilterQuality textureFilterQuality() const
Returns the texture filtering quality.
Off-screen 3D engine implementation.
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).
Basic shading material used for rendering based on the Phong shading model with three color component...
void setDiffuse(const QColor &diffuse)
Sets diffuse color component.
void setShininess(double shininess)
Sets shininess of the surface.
void setAmbient(const QColor &ambient)
Sets ambient color component.
void setSpecular(const QColor &specular)
Sets specular color component.
An RGB renderer for 2d visualisation of point clouds using embedded red, green and blue attributes.
double maximum() const
Returns the maximum value for attributes which will be used by the color ramp shader.
QgsColorRampShader colorRampShader() const
Returns the color ramp shader function used to visualize the attribute.
double minimum() const
Returns the minimum value for attributes which will be used by the color ramp shader.
QString attribute() const
Returns the attribute to use for the renderer.
Renders point clouds by a classification attribute.
QString attribute() const
Returns the attribute to use for the renderer.
QgsPointCloudCategoryList categories() const
Returns the classification categories used for rendering.
Abstract base class for 2d point cloud renderers.
virtual QString type() const =0
Returns the identifier of the renderer type.
An RGB renderer for 2d visualisation of point clouds using embedded red, green and blue attributes.
QString redAttribute() const
Returns the attribute to use for the red channel.
QString greenAttribute() const
Returns the attribute to use for the green channel.
const QgsContrastEnhancement * greenContrastEnhancement() const
Returns the contrast enhancement to use for the green channel.
QString blueAttribute() const
Returns the attribute to use for the blue channel.
const QgsContrastEnhancement * blueContrastEnhancement() const
Returns the contrast enhancement to use for the blue channel.
const QgsContrastEnhancement * redContrastEnhancement() const
Returns the contrast enhancement to use for the red channel.
Represents a 2D point.
Definition qgspointxy.h:62
void setY(double y)
Sets the y value of the point.
Definition qgspointxy.h:132
void set(double x, double y)
Sets the x and y value of the point.
Definition qgspointxy.h:139
double y
Definition qgspointxy.h:66
double x
Definition qgspointxy.h:65
void setX(double x)
Sets the x value of the point.
Definition qgspointxy.h:122
Point geometry type, with support for z-dimension and m-values.
Definition qgspoint.h:53
double z
Definition qgspoint.h:58
double x
Definition qgspoint.h:56
double y
Definition qgspoint.h:57
Polygon geometry type.
Definition qgspolygon.h:37
T lower() const
Returns the lower bound of the range.
Definition qgsrange.h:79
T upper() const
Returns the upper bound of the range.
Definition qgsrange.h:86
A representation of a ray in 3D.
Definition qgsray3d.h:31
QVector3D point(float distance) const
Returns the point along the ray with the specified distance from the ray's origin.
Definition qgsray3d.cpp:62
Responsible for defining parameters of the ray casting operations in 3D map canvases.
Contains the results of ray casting operations in a 3D map canvas.
void addLayerHits(QgsMapLayer *layer, const QList< QgsRayCastHit > &hits)
Adds all hits from layer to the result.
void addTerrainHits(const QList< QgsRayCastHit > &hits)
Adds all terrain hits to the result.
A rectangle specified with double values.
Q_INVOKABLE QString toString(int precision=16) const
Returns a string representation of form xmin,ymin : xmax,ymax Coordinates will be rounded to the spec...
double xMinimum
double yMinimum
double xMaximum
double yMaximum
3D symbol that draws point cloud geometries as 3D objects using RGB colors in the dataset.
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.
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 simple curve.
int nCoordinates() const override
Returns the number of nodes contained in the geometry.
double xAt(int index) const override
Returns the x-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 simple curve.
virtual float heightAt(double x, double y, const Qgs3DRenderContext &context) const =0
Returns height at (x,y) in map's CRS.
A 3D vector (similar to QVector3D) with the difference that it uses double precision instead of singl...
Definition qgsvector3d.h:33
double y() const
Returns Y coordinate.
Definition qgsvector3d.h:60
double z() const
Returns Z coordinate.
Definition qgsvector3d.h:62
void setZ(double z)
Sets Z coordinate.
Definition qgsvector3d.h:80
double distance(const QgsVector3D &other) const
Returns the distance with the other QgsVector3D.
static double dotProduct(const QgsVector3D &v1, const QgsVector3D &v2)
Returns the dot product of two vectors.
double x() const
Returns X coordinate.
Definition qgsvector3d.h:58
void normalize()
Normalizes the current vector in place.
static QgsVector3D crossProduct(const QgsVector3D &v1, const QgsVector3D &v2)
Returns the cross product of two vectors.
void set(double x, double y, double z)
Sets vector coordinates.
Definition qgsvector3d.h:83
Represents a vector layer which manages a vector based dataset.
Q_INVOKABLE Qgis::WkbType 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.
Represent a 2-dimensional vector.
Definition qgsvector.h:34
double y() const
Returns the vector's y-component.
Definition qgsvector.h:155
QgsVector normalized() const
Returns the vector's normalized (or "unit") vector (ie same angle but length of 1....
Definition qgsvector.cpp:33
QgsVector perpVector() const
Returns the perpendicular vector to this vector (rotated 90 degrees counter-clockwise).
Definition qgsvector.h:163
double x() const
Returns the vector's x-component.
Definition qgsvector.h:146
static Q_INVOKABLE bool hasZ(Qgis::WkbType type)
Tests whether a WKB type contains the z-dimension.
#define BUILTIN_UNREACHABLE
Definition qgis.h:8483
float srgbFloatToLinear(float srgb)
T qgsgeometry_cast(QgsAbstractGeometry *geom)
#define QgsDebugMsgLevel(str, level)
Definition qgslogger.h:80
#define QgsDebugError(str)
Definition qgslogger.h:71
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 map coords.
float dist
Distance of the camera from the focal point.