qgsmesh3geometry: Limit geometry to 3d scenes' 2d extent

ptitjano · nyalldawson · commit 4cf834499bce · 2023-09-23T07:34:14.000+10:00
This is a follow-up of #51304 which did not handle mesh layers. This commit adds this support. The meshes displayed in a 3d view do not take into account the scene 2d extent. This issue is fixed by filtering the faces which are used to build the Qt3D geometry. By using `mesh.faceIndexesForRectangle( extent )`, it is possible to keep the faces inside `extent`. This list is then used to populate the `IndexAttribute` of the qt3d geometry. This way, only the faces inside the extent are displayed.
diff --git a/src/3d/mesh/qgsmesh3dentity_p.cpp b/src/3d/mesh/qgsmesh3dentity_p.cpp
@@ -54,7 +54,7 @@ void QgsMeshDataset3DEntity::buildGeometry()
     return;
 
   Qt3DRender::QGeometryRenderer *mesh = new Qt3DRender::QGeometryRenderer;
-  mesh->setGeometry( new QgsMeshDataset3DGeometry( mTriangularMesh, layer(), mMapSettings.temporalRange(), mMapSettings.origin(), mSymbol.get(), mesh ) );
+  mesh->setGeometry( new QgsMeshDataset3DGeometry( mTriangularMesh, layer(), mMapSettings.temporalRange(), mMapSettings.origin(), mMapSettings.extent(), mSymbol.get(), mesh ) );
   addComponent( mesh );
 }
 
@@ -89,7 +89,7 @@ QgsMesh3DTerrainTileEntity::QgsMesh3DTerrainTileEntity(
 void QgsMesh3DTerrainTileEntity::buildGeometry()
 {
   Qt3DRender::QGeometryRenderer *mesh = new Qt3DRender::QGeometryRenderer;
-  mesh->setGeometry( new QgsMeshTerrain3DGeometry( mTriangularMesh, mMapSettings.origin(), mSymbol.get()->verticalScale(), mesh ) );
+  mesh->setGeometry( new QgsMeshTerrain3DGeometry( mTriangularMesh, mMapSettings.origin(), mMapSettings.extent(), mSymbol.get()->verticalScale(), mesh ) );
   addComponent( mesh );
 }
 
diff --git a/src/3d/mesh/qgsmesh3dgeometry_p.cpp b/src/3d/mesh/qgsmesh3dgeometry_p.cpp
@@ -132,25 +132,25 @@ static QByteArray createDatasetVertexData(
   return bufferBytes;
 }
 
-static QByteArray createIndexData( const QgsTriangularMesh &mesh )
+static QByteArray createIndexData( const QgsTriangularMesh &mesh, const QgsRectangle &extent )
 {
-  const int faces = mesh.triangles().count();
-  const quint32 indices = static_cast<quint32>( 3 * faces );
+  const QList<int> facesInExtent = mesh.faceIndexesForRectangle( extent );
+  const quint32 indices = static_cast<quint32>( 3 * facesInExtent.count() );
   Q_ASSERT( indices < std::numeric_limits<quint32>::max() );
 
   // count non void faces
   int nonVoidFaces = 0;
-  for ( int i = 0; i < faces; ++i )
-    if ( !mesh.triangles().at( i ).isEmpty() )
+  for ( const int nativeFaceIndex : facesInExtent )
+    if ( !mesh.triangles().at( nativeFaceIndex ).isEmpty() )
       nonVoidFaces++;
 
   QByteArray indexBytes;
   indexBytes.resize( int( nonVoidFaces * 3 * sizeof( quint32 ) ) );
   quint32 *indexPtr = reinterpret_cast<quint32 *>( indexBytes.data() );
 
-  for ( int i = 0; i < faces; ++i )
+  for ( const int nativeFaceIndex : facesInExtent )
   {
-    const QgsMeshFace &face = mesh.triangles().at( i );
+    const QgsMeshFace &face = mesh.triangles().at( nativeFaceIndex );
     if ( face.isEmpty() )
       continue;
     for ( int j = 0; j < 3; ++j )
@@ -160,36 +160,34 @@ static QByteArray createIndexData( const QgsTriangularMesh &mesh )
   return indexBytes;
 }
 
-static QByteArray createDatasetIndexData( const QgsTriangularMesh &mesh, const QgsMeshDataBlock &mActiveFaceFlagValues )
+static QByteArray createDatasetIndexData( const QgsTriangularMesh &mesh, const QgsMeshDataBlock &mActiveFaceFlagValues, const QgsRectangle &extent )
 {
+  const QList<int> facesInExtent = mesh.faceIndexesForRectangle( extent );
   int activeFaceCount = 0;
 
   // First we need to know about the count of active faces
   if ( mActiveFaceFlagValues.active().isEmpty() )
-    activeFaceCount = mesh.triangles().count();
+    activeFaceCount = facesInExtent.count();
   else
   {
-    for ( int i = 0; i < mesh.triangles().count(); ++i )
+    for ( const int nativeFaceIndex : facesInExtent )
     {
-      const int nativeIndex = mesh.trianglesToNativeFaces()[i];
-      if ( mActiveFaceFlagValues.active( nativeIndex ) )
+      if ( mActiveFaceFlagValues.active( nativeFaceIndex ) )
         activeFaceCount++;
     }
   }
 
-  const int trianglesCount = mesh.triangles().count();
   const quint32 indices = static_cast<quint32>( 3 * activeFaceCount );
   QByteArray indexBytes;
   indexBytes.resize( int( indices * sizeof( quint32 ) ) );
   quint32 *indexPtr = reinterpret_cast<quint32 *>( indexBytes.data() );
 
-  for ( int i = 0; i < trianglesCount; ++i )
+  for ( const int nativeFaceIndex : facesInExtent )
   {
-    const int nativeFaceIndex = mesh.trianglesToNativeFaces()[i];
     const bool isActive = mActiveFaceFlagValues.active().isEmpty() || mActiveFaceFlagValues.active( nativeFaceIndex );
     if ( !isActive )
       continue;
-    const QgsMeshFace &face = mesh.triangles().at( i );
+    const QgsMeshFace &face = mesh.triangles().at( nativeFaceIndex );
     for ( int j = 0; j < 3; ++j )
       *indexPtr++ = quint32( face.at( j ) );
   }
@@ -199,6 +197,7 @@ static QByteArray createDatasetIndexData( const QgsTriangularMesh &mesh, const Q
 
 QgsMesh3DGeometry::QgsMesh3DGeometry( const QgsTriangularMesh &triangularMesh,
                                       const QgsVector3D &origin,
+                                      const QgsRectangle &extent,
                                       double verticalScale,
                                       Qt3DCore::QNode *parent )
 #if QT_VERSION < QT_VERSION_CHECK(6, 0, 0)
@@ -207,6 +206,7 @@ QgsMesh3DGeometry::QgsMesh3DGeometry( const QgsTriangularMesh &triangularMesh,
   : Qt3DCore::QGeometry( parent )
 #endif
   , mOrigin( origin )
+  , mExtent( extent )
   , mVertScale( verticalScale )
   , mTriangulaMesh( triangularMesh )
 {
@@ -219,9 +219,10 @@ QgsMeshDataset3DGeometry::QgsMeshDataset3DGeometry(
   QgsMeshLayer *layer,
   const QgsDateTimeRange &timeRange,
   const QgsVector3D &origin,
+  const QgsRectangle &extent,
   const QgsMesh3DSymbol *symbol,
   Qt3DCore::QNode *parent )
-  : QgsMesh3DGeometry( triangularMesh, origin, symbol->verticalScale(), parent )
+  : QgsMesh3DGeometry( triangularMesh, origin, extent, symbol->verticalScale(), parent )
   , mIsVerticalMagnitudeRelative( symbol->isVerticalMagnitudeRelative() )
   , mVerticalGroupDatasetIndex( symbol->verticalDatasetGroupIndex() )
   , mTimeRange( timeRange )
@@ -310,7 +311,7 @@ void QgsMeshDataset3DGeometry::prepareData()
   data.activeFaceFlagValues = layer->areFacesActive( scalarDatasetIndex, 0, nativeMesh.faces.count() );
   data.isVerticalMagnitudeRelative = mIsVerticalMagnitudeRelative;
 
-  mBuilder = new QgsMeshDataset3DGeometryBuilder( mTriangulaMesh, nativeMesh, mOrigin, mVertScale, data, this );
+  mBuilder = new QgsMeshDataset3DGeometryBuilder( mTriangulaMesh, nativeMesh, mOrigin, mExtent, mVertScale, data, this );
   connect( mBuilder, &QgsMeshDataset3DGeometryBuilder::dataIsReady, this, &QgsMeshDataset3DGeometry::getData );
 
   mBuilder->start();
@@ -319,9 +320,10 @@ void QgsMeshDataset3DGeometry::prepareData()
 
 QgsMeshTerrain3DGeometry::QgsMeshTerrain3DGeometry( const QgsTriangularMesh &triangularMesh,
     const QgsVector3D &origin,
+    const QgsRectangle &extent,
     double verticalScale,
     Qt3DCore::QNode *parent )
-  : QgsMesh3DGeometry( triangularMesh, origin, verticalScale, parent )
+  : QgsMesh3DGeometry( triangularMesh, origin, extent, verticalScale, parent )
 {
 
   const int stride = ( 3 /*position*/ +
@@ -331,7 +333,7 @@ QgsMeshTerrain3DGeometry::QgsMeshTerrain3DGeometry( const QgsTriangularMesh &tri
   prepareVerticesNormalAttribute( mVertexBuffer,  stride, 3 );
   prepareIndexesAttribute( mIndexBuffer );
 
-  mBuilder = new QgsMesh3DGeometryBuilder( triangularMesh, origin, mVertScale, this );
+  mBuilder = new QgsMesh3DGeometryBuilder( triangularMesh, origin, extent, mVertScale, this );
   connect( mBuilder, &QgsMesh3DGeometryBuilder::dataIsReady, this, &QgsMeshTerrain3DGeometry::getData );
   mBuilder->start();
 }
@@ -416,10 +418,11 @@ void QgsMesh3DGeometry::prepareIndexesAttribute( Qt3DQBuffer *buffer )
 }
 
 
-QgsMesh3DGeometryBuilder::QgsMesh3DGeometryBuilder( const QgsTriangularMesh &mesh, const QgsVector3D &origin, float vertScale, QObject *parent ):
+QgsMesh3DGeometryBuilder::QgsMesh3DGeometryBuilder( const QgsTriangularMesh &mesh, const QgsVector3D &origin, const QgsRectangle &extent, float vertScale, QObject *parent ):
   QObject( parent )
   , mMesh( mesh )
   , mOrigin( origin )
+  , mExtent( extent )
   , mVertScale( vertScale )
 {}
 
@@ -434,7 +437,7 @@ void QgsMesh3DGeometryBuilder::start()
 
   mWatcherIndex = new QFutureWatcher<QByteArray>( this );
   connect( mWatcherIndex, &QFutureWatcher<int>::finished, this, &QgsMesh3DGeometryBuilder::indexFinished );
-  mFutureIndex = QtConcurrent::run( createIndexData, mMesh );
+  mFutureIndex = QtConcurrent::run( createIndexData, mMesh, mExtent );
   mWatcherIndex->setFuture( mFutureIndex );
 }
 
@@ -462,10 +465,11 @@ QgsMeshDataset3DGeometryBuilder::QgsMeshDataset3DGeometryBuilder
 ( const QgsTriangularMesh &mesh,
   const QgsMesh &nativeMesh,
   const QgsVector3D &origin,
+  const QgsRectangle &extent,
   float vertScale,
   const QgsMeshDataset3DGeometry::VertexData &vertexData,
   QObject *parent ):
-  QgsMesh3DGeometryBuilder( mesh, origin, vertScale, parent )
+  QgsMesh3DGeometryBuilder( mesh, origin, extent, vertScale, parent )
   , mNativeMesh( nativeMesh )
   , mVertexData( vertexData )
 {}
@@ -482,6 +486,6 @@ void QgsMeshDataset3DGeometryBuilder::start()
   mWatcherIndex = new QFutureWatcher<QByteArray>( this );
   connect( mWatcherIndex, &QFutureWatcher<int>::finished, this, &QgsMeshDataset3DGeometryBuilder::indexFinished );
 
-  mFutureIndex = QtConcurrent::run( createDatasetIndexData, mMesh, mVertexData.activeFaceFlagValues );
+  mFutureIndex = QtConcurrent::run( createDatasetIndexData, mMesh, mVertexData.activeFaceFlagValues, mExtent );
   mWatcherIndex->setFuture( mFutureIndex );
 }
diff --git a/src/3d/mesh/qgsmesh3dgeometry_p.h b/src/3d/mesh/qgsmesh3dgeometry_p.h
@@ -32,6 +32,7 @@
 
 #include "qgsmaplayerref.h"
 #include "qgsmesh3dsymbol.h"
+#include "qgsrectangle.h"
 #include "qgstriangularmesh.h"
 
 ///@cond PRIVATE
@@ -72,6 +73,7 @@ class QgsMesh3DGeometryBuilder: public QObject
   public:
     QgsMesh3DGeometryBuilder( const QgsTriangularMesh &mesh,
                               const QgsVector3D &origin,
+                              const QgsRectangle &extent,
                               float vertScale,
                               QObject *parent );
 
@@ -95,6 +97,7 @@ class QgsMesh3DGeometryBuilder: public QObject
 
     QgsTriangularMesh mMesh;
     QgsVector3D mOrigin;
+    QgsRectangle mExtent;
     float mVertScale;
 
     mutable QMutex mMutex;
@@ -118,6 +121,7 @@ class QgsMesh3DGeometry: public Qt3DCore::QGeometry
     //! Constructor
     explicit QgsMesh3DGeometry( const QgsTriangularMesh &triangularMesh,
                                 const QgsVector3D &origin,
+                                const QgsRectangle &extent,
                                 double verticalScale,
                                 QNode *parent );
 
@@ -134,6 +138,7 @@ class QgsMesh3DGeometry: public Qt3DCore::QGeometry
 #endif
 
     QgsVector3D mOrigin;
+    QgsRectangle mExtent;
     float mVertScale;
     QgsTriangularMesh mTriangulaMesh;
 
@@ -179,6 +184,7 @@ class QgsMeshDataset3DGeometry: public QgsMesh3DGeometry
                                        QgsMeshLayer *layer,
                                        const QgsDateTimeRange &timeRange,
                                        const QgsVector3D &origin,
+                                       const QgsRectangle &extent,
                                        const QgsMesh3DSymbol *symbol,
                                        QNode *parent );
 
@@ -230,6 +236,7 @@ class QgsMeshDataset3DGeometryBuilder: public QgsMesh3DGeometryBuilder
     QgsMeshDataset3DGeometryBuilder( const QgsTriangularMesh &mesh,
                                      const QgsMesh &nativeMesh,
                                      const QgsVector3D &origin,
+                                     const QgsRectangle &extent,
                                      float vertScale,
                                      const QgsMeshDataset3DGeometry::VertexData &vertexData,
                                      QObject *parent );
@@ -253,6 +260,7 @@ class QgsMeshTerrain3DGeometry: public  QgsMesh3DGeometry
     //! Constructs a mesh layer geometry from triangular mesh.
     explicit QgsMeshTerrain3DGeometry( const QgsTriangularMesh &triangularMesh,
                                        const QgsVector3D &origin,
+                                       const QgsRectangle &extent,
                                        double verticalScale,
                                        QNode *parent );
 };
diff --git a/tests/src/3d/testqgs3drendering.cpp b/tests/src/3d/testqgs3drendering.cpp
@@ -95,6 +95,7 @@ class TestQgs3DRendering : public QgsTest
     void testFilteredFlatTerrain();
     void testFilteredDemTerrain();
     void testFilteredExtrudedPolygons();
+    void testFilteredMesh();
     void testDepthBuffer();
     void testAmbientOcclusion();
     void testDebugMap();
@@ -1456,6 +1457,51 @@ void TestQgs3DRendering::testFilteredExtrudedPolygons()
   QVERIFY( imageCheck( "polygon3d_extrusion_filtered", "polygon3d_extrusion_filtered", img, QString(), 40, QSize( 0, 0 ), 2 ) );
 }
 
+void TestQgs3DRendering::testFilteredMesh()
+{
+  const QgsRectangle fullExtent = mLayerMeshDataset->extent();
+  const QgsRectangle filteredExtent = QgsRectangle( fullExtent.xMinimum(), fullExtent.yMinimum(),
+                                      fullExtent.xMinimum() + fullExtent.width() / 3.0, fullExtent.yMinimum() + fullExtent.height() / 4.0 );
+
+  QgsMesh3DSymbol *symbolMesh3d = new QgsMesh3DSymbol;
+  symbolMesh3d->setVerticalDatasetGroupIndex( 0 );
+  symbolMesh3d->setVerticalScale( 10 );
+  symbolMesh3d->setRenderingStyle( QgsMesh3DSymbol::ColorRamp2DRendering );
+  symbolMesh3d->setArrowsEnabled( true );
+  symbolMesh3d->setArrowsSpacing( 300 );
+  QgsMeshLayer3DRenderer *meshDatasetRenderer3d = new QgsMeshLayer3DRenderer( symbolMesh3d );
+  mLayerMeshDataset->setRenderer3D( meshDatasetRenderer3d );
+
+  Qgs3DMapSettings *map = new Qgs3DMapSettings;
+  map->setCrs( mProject->crs() );
+  map->setExtent( filteredExtent );
+  map->setLayers( QList<QgsMapLayer *>() << mLayerMeshDataset );
+  QgsPointLightSettings defaultLight;
+  defaultLight.setIntensity( 0.5 );
+  defaultLight.setPosition( QgsVector3D( 0, 1000, 0 ) );
+  map->setLightSources( { defaultLight.clone() } );
+
+  QgsFlatTerrainGenerator *flatTerrain = new QgsFlatTerrainGenerator;
+  flatTerrain->setCrs( map->crs() );
+  map->setTerrainGenerator( flatTerrain );
+
+  QgsOffscreen3DEngine engine;
+  Qgs3DMapScene *scene = new Qgs3DMapScene( *map, &engine );
+  engine.setRootEntity( scene );
+  scene->cameraController()->setLookingAtPoint( QgsVector3D( 0, 0, 0 ), 3000, 25, 45 );
+
+  // When running the test on Travis, it would initially return empty rendered image.
+  // Capturing the initial image and throwing it away fixes that. Hopefully we will
+  // find a better fix in the future.
+  Qgs3DUtils::captureSceneImage( engine, scene );
+
+  QImage img = Qgs3DUtils::captureSceneImage( engine, scene );
+  delete scene;
+  delete map;
+
+  QVERIFY( imageCheck( "mesh3d_filtered", "mesh3d_filtered", img, QString(), 40, QSize( 0, 0 ), 2 ) );
+}
+
 void TestQgs3DRendering::testAmbientOcclusion()
 {
   // =============================================
diff --git a/tests/testdata/control_images/3d/expected_mesh3d_filtered/expected_mesh3d_filtered.png b/tests/testdata/control_images/3d/expected_mesh3d_filtered/expected_mesh3d_filtered.png

Original file line number	Diff line number	Diff line change
`@@ -54,7 +54,7 @@ void QgsMeshDataset3DEntity::buildGeometry()`
`54`	`54`	`return;`
`55`	`55`
`56`	`56`	`Qt3DRender::QGeometryRenderer *mesh = new Qt3DRender::QGeometryRenderer;`
`57`		`- mesh->setGeometry( new QgsMeshDataset3DGeometry( mTriangularMesh, layer(), mMapSettings.temporalRange(), mMapSettings.origin(), mSymbol.get(), mesh ) );`
	`57`	`+ mesh->setGeometry( new QgsMeshDataset3DGeometry( mTriangularMesh, layer(), mMapSettings.temporalRange(), mMapSettings.origin(), mMapSettings.extent(), mSymbol.get(), mesh ) );`
`58`	`58`	`addComponent( mesh );`
`59`	`59`	`}`
`60`	`60`
`@@ -89,7 +89,7 @@ QgsMesh3DTerrainTileEntity::QgsMesh3DTerrainTileEntity(`
`89`	`89`	`void QgsMesh3DTerrainTileEntity::buildGeometry()`
`90`	`90`	`{`
`91`	`91`	`Qt3DRender::QGeometryRenderer *mesh = new Qt3DRender::QGeometryRenderer;`
`92`		`- mesh->setGeometry( new QgsMeshTerrain3DGeometry( mTriangularMesh, mMapSettings.origin(), mSymbol.get()->verticalScale(), mesh ) );`
	`92`	`+ mesh->setGeometry( new QgsMeshTerrain3DGeometry( mTriangularMesh, mMapSettings.origin(), mMapSettings.extent(), mSymbol.get()->verticalScale(), mesh ) );`
`93`	`93`	`addComponent( mesh );`
`94`	`94`	`}`
`95`	`95`