QGIS API Documentation 3.41.0-Master (88383c3d16f)
Loading...
Searching...
No Matches
qgsmeshlayer.cpp
Go to the documentation of this file.
1/***************************************************************************
2 qgsmeshlayer.cpp
3 ----------------
4 begin : April 2018
5 copyright : (C) 2018 by Peter Petrik
6 email : zilolv at gmail dot com
7 ***************************************************************************/
8
9/***************************************************************************
10 * *
11 * This program is free software; you can redistribute it and/or modify *
12 * it under the terms of the GNU General Public License as published by *
13 * the Free Software Foundation; either version 2 of the License, or *
14 * (at your option) any later version. *
15 * *
16 ***************************************************************************/
17
18#include <cstddef>
19#include <limits>
20
21#include <QUuid>
22#include <QUrl>
23
24#include "qgscolorrampimpl.h"
25#include "qgslogger.h"
26#include "qgsmaplayerlegend.h"
27#include "qgsmaplayerfactory.h"
28#include "qgsmeshdataprovider.h"
30#include "qgsmeshlayer.h"
31#include "moc_qgsmeshlayer.cpp"
34#include "qgsmeshlayerutils.h"
35#include "qgsmeshtimesettings.h"
36#include "qgspainting.h"
37#include "qgsproviderregistry.h"
38#include "qgsreadwritecontext.h"
39#include "qgsstyle.h"
40#include "qgstriangularmesh.h"
41#include "qgsmesh3daveraging.h"
43#include "qgsmesheditor.h"
44#include "qgsmessagelog.h"
48#include "qgsthreadingutils.h"
49#include "qgsapplication.h"
50#include "qgsruntimeprofiler.h"
52
53QgsMeshLayer::QgsMeshLayer( const QString &meshLayerPath,
54 const QString &baseName,
55 const QString &providerKey,
56 const QgsMeshLayer::LayerOptions &options )
57 : QgsMapLayer( Qgis::LayerType::Mesh, baseName, meshLayerPath )
58 , mDatasetGroupStore( new QgsMeshDatasetGroupStore( this ) )
59 , mTemporalProperties( new QgsMeshLayerTemporalProperties( this ) )
60 , mElevationProperties( new QgsMeshLayerElevationProperties( this ) )
61{
63
64 const QgsDataProvider::ProviderOptions providerOptions { options.transformContext };
66 if ( options.loadDefaultStyle )
67 {
69 }
70 QgsMeshLayer::setDataSourcePrivate( meshLayerPath, baseName, providerKey, providerOptions, flags );
73
74 if ( isValid() && options.loadDefaultStyle )
75 {
76 bool result = false;
77 loadDefaultStyle( result );
78 }
79
80 connect( mDatasetGroupStore.get(), &QgsMeshDatasetGroupStore::datasetGroupsAdded, this, &QgsMeshLayer::onDatasetGroupsAdded );
81}
82
83void QgsMeshLayer::createSimplifiedMeshes()
84{
86
87 if ( mSimplificationSettings.isEnabled() && !hasSimplifiedMeshes() )
88 {
89 const double reductionFactor = mSimplificationSettings.reductionFactor();
90
91 QVector<QgsTriangularMesh *> simplifyMeshes =
92 mTriangularMeshes[0]->simplifyMesh( reductionFactor );
93
94 for ( int i = 0; i < simplifyMeshes.count() ; ++i )
95 {
96 mTriangularMeshes.emplace_back( simplifyMeshes[i] );
97 }
98 }
99}
100
101bool QgsMeshLayer::hasSimplifiedMeshes() const
102{
104
105 //First mesh is the base mesh, so if size>1, there is no simplified meshes
106 return ( mTriangularMeshes.size() > 1 );
107}
108
110{
111 delete mLabeling;
112 delete mDataProvider;
113}
114
121
123{
125
126 return mDataProvider;
127}
128
130{
132
134 if ( mDataProvider )
135 {
136 options.transformContext = mDataProvider->transformContext();
137 }
138 QgsMeshLayer *layer = new QgsMeshLayer( source(), name(), mProviderKey, options );
139 QgsMapLayer::clone( layer );
140
141 layer->mElevationProperties = mElevationProperties->clone();
142 layer->mElevationProperties->setParent( layer );
143
144 if ( auto *lLabeling = labeling() )
145 {
146 layer->setLabeling( lLabeling->clone() );
147 }
149
150 return layer;
151}
152
154{
156
157 if ( mMeshEditor )
158 return mMeshEditor->extent();
159
160 if ( mDataProvider )
161 return mDataProvider->extent();
162 else
163 {
164 QgsRectangle rec;
165 rec.setNull();
166 return rec;
167 }
168}
169
171{
173
174 if ( !mDataProvider )
175 return false;
176
177 if ( mMeshEditor )
178 return true;
179
180 const QgsMeshDriverMetadata driverMetadata = mDataProvider->driverMetadata();
181
183}
184
185QString QgsMeshLayer::loadDefaultStyle( bool &resultFlag )
186{
188
189 const QList<int> groupsList = datasetGroupsIndexes();
190
191 for ( const int index : groupsList )
192 assignDefaultStyleToDatasetGroup( index );
193
194
195 QgsMeshRendererMeshSettings meshSettings;
196 if ( !groupsList.isEmpty() )
197 {
198 // Show data from the first dataset group
199 mRendererSettings.setActiveScalarDatasetGroup( 0 );
200 // If the first dataset group has nan min/max, display the mesh to avoid nothing displayed
202 if ( meta.maximum() == std::numeric_limits<double>::quiet_NaN() &&
203 meta.minimum() == std::numeric_limits<double>::quiet_NaN() )
204 meshSettings.setEnabled( true );
205 }
206 else
207 {
208 // show at least the mesh by default
209 meshSettings.setEnabled( true );
210 }
211
212 mRendererSettings.setNativeMeshSettings( meshSettings );
213
214 for ( const int i : groupsList )
215 {
216 assignDefaultStyleToDatasetGroup( i );
217
218 // Sets default resample method for scalar dataset
220 QgsMeshRendererScalarSettings scalarSettings = mRendererSettings.scalarSettings( i );
221 switch ( meta.dataType() )
222 {
224 case QgsMeshDatasetGroupMetadata::DataOnVolumes: // data on volumes are averaged to 2D data on faces
226 break;
229 break;
231 break;
232 }
233
234 //override color ramp if the values in the dataset group are classified
235 applyClassificationOnScalarSettings( meta, scalarSettings );
236
237 mRendererSettings.setScalarSettings( i, scalarSettings );
238 }
239
240 if ( !groupsList.isEmpty() )
241 {
242 emit rendererChanged();
244 }
245
246 return QgsMapLayer::loadDefaultStyle( resultFlag );
247}
248
249bool QgsMeshLayer::removeDatasets( const QString &name )
250{
251 const int index = mDatasetGroupStore->indexFromGroupName( name );
252
253 if ( index == -1 )
254 {
255 return false;
256 }
257
258 const QgsMeshDatasetGroupMetadata groupMetadata = datasetGroupMetadata( index );
259
260 mDatasetGroupStore->removeDatasetGroup( index );
261
262 if ( mExtraDatasetUri.contains( groupMetadata.uri() ) )
263 {
264 mExtraDatasetUri.removeOne( groupMetadata.uri() );
265 }
266
268
269 emit dataSourceChanged();
270 return true;
271}
272
273bool QgsMeshLayer::addDatasets( const QString &path, const QDateTime &defaultReferenceTime )
274{
276
278 const bool isTemporalBefore = temporalCapabilities->hasTemporalCapabilities();
279 if ( mDatasetGroupStore->addPersistentDatasets( path ) )
280 {
281 mExtraDatasetUri.append( path );
282 QgsMeshLayerTemporalProperties *temporalProperties = qobject_cast< QgsMeshLayerTemporalProperties * >( mTemporalProperties );
283 if ( !isTemporalBefore && temporalCapabilities->hasTemporalCapabilities() )
284 {
286 temporalCapabilities );
287
288 if ( ! temporalProperties->referenceTime().isValid() )
289 {
290 QDateTime referenceTime = defaultReferenceTime;
291 if ( !defaultReferenceTime.isValid() ) // If project reference time is invalid, use current date
292 referenceTime = QDateTime( QDate::currentDate(), QTime( 0, 0, 0 ), Qt::UTC );
293 temporalProperties->setReferenceTime( referenceTime, temporalCapabilities );
294 }
295
296 mTemporalProperties->setIsActive( true );
297 }
298 emit dataSourceChanged();
299 return true;
300 }
301
302 return false;
303}
304
306{
308
309 if ( mDatasetGroupStore->addDatasetGroup( datasetGroup ) )
310 {
311 emit dataChanged();
312 return true;
313 }
314 return false;
315}
316
317bool QgsMeshLayer::saveDataset( const QString &path, int datasetGroupIndex, QString driver )
318{
320
321 return mDatasetGroupStore->saveDatasetGroup( path, datasetGroupIndex, driver );
322}
323
325{
327
328 return mNativeMesh.get();
329}
330
332{
334
335 return mNativeMesh.get();
336}
337
338QgsTriangularMesh *QgsMeshLayer::triangularMesh( double minimumTriangleSize ) const
339{
341
342 for ( const std::unique_ptr<QgsTriangularMesh> &lod : mTriangularMeshes )
343 {
344 if ( lod && lod->averageTriangleSize() > minimumTriangleSize )
345 return lod.get();
346 }
347
348 if ( !mTriangularMeshes.empty() )
349 return mTriangularMeshes.back().get();
350 else
351 return nullptr;
352}
353
355{
357
358 return mTriangularMeshes.size();
359}
360
362{
364
365 if ( mTriangularMeshes.empty() )
366 return nullptr;
367 if ( lodIndex < 0 )
368 return mTriangularMeshes.front().get();
369
370 if ( lodIndex >= int( mTriangularMeshes.size() ) )
371 return mTriangularMeshes.back().get();
372
373 return mTriangularMeshes.at( lodIndex ).get();
374}
375
377{
379
380 // Native mesh
381 if ( !mNativeMesh )
382 {
383 // lazy loading of mesh data
384 fillNativeMesh();
385 }
386
387 // Triangular mesh
388 if ( mTriangularMeshes.empty() )
389 {
390 QgsTriangularMesh *baseMesh = new QgsTriangularMesh;
391 mTriangularMeshes.emplace_back( baseMesh );
392 }
393
394 if ( mTriangularMeshes[0].get()->update( mNativeMesh.get(), transform ) )
395 mTriangularMeshes.resize( 1 ); //if the base triangular mesh is effectivly updated, remove simplified meshes
396
397 createSimplifiedMeshes();
398}
399
400QgsMeshLayerRendererCache *QgsMeshLayer::rendererCache()
401{
403
404 return mRendererCache.get();
405}
406
413
414void QgsMeshLayer::setRendererSettings( const QgsMeshRendererSettings &settings, const bool repaint )
415{
417
418 const int oldActiveScalar = mRendererSettings.activeScalarDatasetGroup();
419 const int oldActiveVector = mRendererSettings.activeVectorDatasetGroup();
420 mRendererSettings = settings;
421
422 if ( oldActiveScalar != mRendererSettings.activeScalarDatasetGroup() )
424
425 if ( oldActiveVector != mRendererSettings.activeVectorDatasetGroup() )
427
428 emit rendererChanged();
429
430 if ( repaint )
431 {
433 }
434}
435
442
444{
446
447 mTimeSettings = settings;
448 emit timeSettingsChanged();
449}
450
451QString QgsMeshLayer::formatTime( double hours )
452{
454
455 if ( dataProvider() && dataProvider()->temporalCapabilities()->hasReferenceTime() )
456 return QgsMeshLayerUtils::formatTime( hours, mTemporalProperties->referenceTime(), mTimeSettings );
457 else
458 return QgsMeshLayerUtils::formatTime( hours, QDateTime(), mTimeSettings );
459}
460
462{
464
465 return mDatasetGroupStore->datasetGroupCount();
466}
467
469{
471
472 return mDatasetGroupStore->extraDatasetGroupCount();
473}
474
476{
478
479 return mDatasetGroupStore->datasetGroupIndexes();
480}
481
483{
485
486 return mDatasetGroupStore->enabledDatasetGroupIndexes();
487}
488
490{
492
493 return mDatasetGroupStore->datasetGroupMetadata( index );
494}
495
497{
499
500 return mDatasetGroupStore->datasetCount( index.group() );
501}
502
504{
506
507 return mDatasetGroupStore->datasetMetadata( index );
508}
509
511{
513
514 return mDatasetGroupStore->datasetValue( index, valueIndex );
515}
516
517QgsMeshDataBlock QgsMeshLayer::datasetValues( const QgsMeshDatasetIndex &index, int valueIndex, int count ) const
518{
520
521 return mDatasetGroupStore->datasetValues( index, valueIndex, count );
522}
523
524QgsMesh3DDataBlock QgsMeshLayer::dataset3dValues( const QgsMeshDatasetIndex &index, int faceIndex, int count ) const
525{
527
528 return mDatasetGroupStore->dataset3dValues( index, faceIndex, count );
529}
530
531QgsMeshDataBlock QgsMeshLayer::areFacesActive( const QgsMeshDatasetIndex &index, int faceIndex, int count ) const
532{
534
535 return mDatasetGroupStore->areFacesActive( index, faceIndex, count );
536}
537
538bool QgsMeshLayer::isFaceActive( const QgsMeshDatasetIndex &index, int faceIndex ) const
539{
541
542 return mDatasetGroupStore->isFaceActive( index, faceIndex );
543}
544
545QgsMeshDatasetValue QgsMeshLayer::datasetValue( const QgsMeshDatasetIndex &index, const QgsPointXY &point, double searchRadius ) const
546{
548
550 const QgsTriangularMesh *mesh = triangularMesh();
551
552 if ( mesh && index.isValid() )
553 {
555 {
556 const QgsRectangle searchRectangle( point.x() - searchRadius, point.y() - searchRadius, point.x() + searchRadius, point.y() + searchRadius );
557 return dataset1dValue( index, point, searchRadius );
558 }
559 const int faceIndex = mesh->faceIndexForPoint_v2( point ) ;
560 if ( faceIndex >= 0 )
561 {
562 const int nativeFaceIndex = mesh->trianglesToNativeFaces().at( faceIndex );
564 if ( isFaceActive( index, nativeFaceIndex ) )
565 {
566 switch ( dataType )
567 {
569 {
570 value = datasetValue( index, nativeFaceIndex );
571 }
572 break;
573
575 {
576 const QgsMeshFace &face = mesh->triangles()[faceIndex];
577 const int v1 = face[0], v2 = face[1], v3 = face[2];
578 const QgsPoint p1 = mesh->vertices()[v1], p2 = mesh->vertices()[v2], p3 = mesh->vertices()[v3];
579 const QgsMeshDatasetValue val1 = datasetValue( index, v1 );
580 const QgsMeshDatasetValue val2 = datasetValue( index, v2 );
581 const QgsMeshDatasetValue val3 = datasetValue( index, v3 );
582 const double x = QgsMeshLayerUtils::interpolateFromVerticesData( p1, p2, p3, val1.x(), val2.x(), val3.x(), point );
583 double y = std::numeric_limits<double>::quiet_NaN();
584 const bool isVector = datasetGroupMetadata( index ).isVector();
585 if ( isVector )
586 y = QgsMeshLayerUtils::interpolateFromVerticesData( p1, p2, p3, val1.y(), val2.y(), val3.y(), point );
587
588 value = QgsMeshDatasetValue( x, y );
589 }
590 break;
591
593 {
594 const QgsMesh3DAveragingMethod *avgMethod = mRendererSettings.averagingMethod();
595 if ( avgMethod )
596 {
597 const QgsMesh3DDataBlock block3d = dataset3dValues( index, nativeFaceIndex, 1 );
598 const QgsMeshDataBlock block2d = avgMethod->calculate( block3d );
599 if ( block2d.isValid() )
600 {
601 value = block2d.value( 0 );
602 }
603 }
604 }
605 break;
606
607 default:
608 break;
609 }
610 }
611 }
612 }
613
614 return value;
615}
616
618{
620
621 QgsMesh3DDataBlock block3d;
622
623 const QgsTriangularMesh *baseTriangularMesh = triangularMesh();
624
625 if ( baseTriangularMesh && dataProvider() && dataProvider()->isValid() && index.isValid() )
626 {
629 {
630 const int faceIndex = baseTriangularMesh->faceIndexForPoint_v2( point );
631 if ( faceIndex >= 0 )
632 {
633 const int nativeFaceIndex = baseTriangularMesh->trianglesToNativeFaces().at( faceIndex );
634 block3d = dataset3dValues( index, nativeFaceIndex, 1 );
635 }
636 }
637 }
638 return block3d;
639}
640
641QgsMeshDatasetValue QgsMeshLayer::dataset1dValue( const QgsMeshDatasetIndex &index, const QgsPointXY &point, double searchRadius ) const
642{
644
646 QgsPointXY projectedPoint;
647 const int selectedIndex = closestEdge( point, searchRadius, projectedPoint );
648 const QgsTriangularMesh *mesh = triangularMesh();
649 if ( selectedIndex >= 0 )
650 {
652 switch ( dataType )
653 {
655 {
656 value = datasetValue( index, selectedIndex );
657 }
658 break;
659
661 {
662 const QgsMeshEdge &edge = mesh->edges()[selectedIndex];
663 const int v1 = edge.first, v2 = edge.second;
664 const QgsPoint p1 = mesh->vertices()[v1], p2 = mesh->vertices()[v2];
665 const QgsMeshDatasetValue val1 = datasetValue( index, v1 );
666 const QgsMeshDatasetValue val2 = datasetValue( index, v2 );
667 const double edgeLength = p1.distance( p2 );
668 const double dist1 = p1.distance( projectedPoint.x(), projectedPoint.y() );
669 value = QgsMeshLayerUtils::interpolateFromVerticesData( dist1 / edgeLength, val1, val2 );
670 }
671 break;
672 default:
673 break;
674 }
675 }
676
677 return value;
678}
679
681{
683
684 if ( mDataProvider )
685 mDataProvider->setTransformContext( transformContext );
687}
688
689QgsMeshDatasetIndex QgsMeshLayer::datasetIndexAtTime( const QgsDateTimeRange &timeRange, int datasetGroupIndex ) const
690{
692
693 if ( ! mTemporalProperties->isActive() )
694 return QgsMeshDatasetIndex( datasetGroupIndex, -1 );
695
696 const QDateTime layerReferenceTime = mTemporalProperties->referenceTime();
697 QDateTime utcTime = timeRange.begin();
698 if ( utcTime.timeSpec() != Qt::UTC )
699 utcTime.setTimeSpec( Qt::UTC );
700 const qint64 startTime = layerReferenceTime.msecsTo( utcTime );
701
702 return mDatasetGroupStore->datasetIndexAtTime( startTime, datasetGroupIndex, mTemporalProperties->matchingMethod() );
703}
704
705QgsMeshDatasetIndex QgsMeshLayer::datasetIndexAtRelativeTime( const QgsInterval &relativeTime, int datasetGroupIndex ) const
706{
708
709 return mDatasetGroupStore->datasetIndexAtTime( relativeTime.seconds() * 1000, datasetGroupIndex, mTemporalProperties->matchingMethod() );
710}
711
712QList<QgsMeshDatasetIndex> QgsMeshLayer::datasetIndexInRelativeTimeInterval( const QgsInterval &startRelativeTime, const QgsInterval &endRelativeTime, int datasetGroupIndex ) const
713{
715
716 qint64 usedRelativeTime1 = startRelativeTime.seconds() * 1000;
717 qint64 usedRelativeTime2 = endRelativeTime.seconds() * 1000;
718
719 //adjust relative time if layer reference time is different from provider reference time
720 if ( mTemporalProperties->referenceTime().isValid() &&
721 mDataProvider &&
722 mDataProvider->isValid() &&
723 mTemporalProperties->referenceTime() != mDataProvider->temporalCapabilities()->referenceTime() )
724 {
725 usedRelativeTime1 = usedRelativeTime1 + mTemporalProperties->referenceTime().msecsTo( mDataProvider->temporalCapabilities()->referenceTime() );
726 usedRelativeTime2 = usedRelativeTime2 + mTemporalProperties->referenceTime().msecsTo( mDataProvider->temporalCapabilities()->referenceTime() );
727 }
728
729 return mDatasetGroupStore->datasetIndexInTimeInterval( usedRelativeTime1, usedRelativeTime2, datasetGroupIndex );
730}
731
732void QgsMeshLayer::applyClassificationOnScalarSettings( const QgsMeshDatasetGroupMetadata &meta, QgsMeshRendererScalarSettings &scalarSettings ) const
733{
735
736 if ( meta.extraOptions().contains( QStringLiteral( "classification" ) ) )
737 {
738 QgsColorRampShader colorRampShader = scalarSettings.colorRampShader();
739 QgsColorRamp *colorRamp = colorRampShader.sourceColorRamp();
740 const QStringList classes = meta.extraOptions()[QStringLiteral( "classification" )].split( QStringLiteral( ";;" ) );
741
742 QString units;
743 if ( meta.extraOptions().contains( QStringLiteral( "units" ) ) )
744 units = meta.extraOptions()[ QStringLiteral( "units" )];
745
746 QVector<QVector<double>> bounds;
747 for ( const QString &classe : classes )
748 {
749 const QStringList boundsStr = classe.split( ',' );
750 QVector<double> bound;
751 for ( const QString &boundStr : boundsStr )
752 bound.append( boundStr.toDouble() );
753 bounds.append( bound );
754 }
755
756 if ( ( bounds.count() == 1 && bounds.first().count() > 2 ) || // at least a class with two value
757 ( bounds.count() > 1 ) ) // or at least two classes
758 {
759 const QVector<double> firstClass = bounds.first();
760 const QVector<double> lastClass = bounds.last();
761 const double minValue = firstClass.count() > 1 ? ( firstClass.first() + firstClass.last() ) / 2 : firstClass.first();
762 const double maxValue = lastClass.count() > 1 ? ( lastClass.first() + lastClass.last() ) / 2 : lastClass.first();
763 const double diff = maxValue - minValue;
764 QList<QgsColorRampShader::ColorRampItem> colorRampItemlist;
765 for ( int i = 0; i < bounds.count(); ++i )
766 {
767 const QVector<double> &boundClass = bounds.at( i );
769 item.value = i + 1;
770 if ( !boundClass.isEmpty() )
771 {
772 const double scalarValue = ( boundClass.first() + boundClass.last() ) / 2;
773 item.color = colorRamp->color( ( scalarValue - minValue ) / diff );
774 if ( i != 0 && i < bounds.count() - 1 ) //The first and last labels are treated after
775 {
776 item.label = QString( ( "%1 - %2 %3" ) ).
777 arg( QString::number( boundClass.first() ) ).
778 arg( QString::number( boundClass.last() ) ).
779 arg( units );
780 }
781 }
782 colorRampItemlist.append( item );
783 }
784 //treat first and last labels
785 if ( firstClass.count() == 1 )
786 colorRampItemlist.first().label = QObject::tr( "below %1 %2" ).
787 arg( QString::number( firstClass.first() ) ).
788 arg( units );
789 else
790 {
791 colorRampItemlist.first().label = QString( ( "%1 - %2 %3" ) ).
792 arg( QString::number( firstClass.first() ) ).
793 arg( QString::number( firstClass.last() ) ).
794 arg( units );
795 }
796
797 if ( lastClass.count() == 1 )
798 colorRampItemlist.last().label = QObject::tr( "above %1 %2" ).
799 arg( QString::number( lastClass.first() ) ).
800 arg( units );
801 else
802 {
803 colorRampItemlist.last().label = QString( ( "%1 - %2 %3" ) ).
804 arg( QString::number( lastClass.first() ) ).
805 arg( QString::number( lastClass.last() ) ).
806 arg( units );
807 }
808
809 colorRampShader.setMinimumValue( 0 );
810 colorRampShader.setMaximumValue( colorRampItemlist.count() - 1 );
811 scalarSettings.setClassificationMinimumMaximum( 0, colorRampItemlist.count() - 1 );
812 colorRampShader.setColorRampItemList( colorRampItemlist );
815 }
816
817 scalarSettings.setColorRampShader( colorRampShader );
819 }
820}
821
823{
825
826 if ( mTemporalProperties->isActive() )
827 return datasetIndexAtTime( timeRange, group >= 0 ? group : mRendererSettings.activeScalarDatasetGroup() );
828 else
829 return QgsMeshDatasetIndex( group >= 0 ? group : mRendererSettings.activeScalarDatasetGroup(), mStaticScalarDatasetIndex );
830}
831
833{
835
836 if ( mTemporalProperties->isActive() )
837 return datasetIndexAtTime( timeRange, group >= 0 ? group : mRendererSettings.activeVectorDatasetGroup() );
838 else
839 return QgsMeshDatasetIndex( group >= 0 ? group : mRendererSettings.activeVectorDatasetGroup(), mStaticVectorDatasetIndex );
840}
841
842void QgsMeshLayer::fillNativeMesh()
843{
845
846 Q_ASSERT( !mNativeMesh );
847
848 mNativeMesh.reset( new QgsMesh() );
849
850 if ( !( dataProvider() && dataProvider()->isValid() ) )
851 return;
852
853 dataProvider()->populateMesh( mNativeMesh.get() );
854}
855
856void QgsMeshLayer::onDatasetGroupsAdded( const QList<int> &datasetGroupIndexes )
857{
859
860 // assign default style to new dataset groups
861 for ( int datasetGroupIndex : datasetGroupIndexes )
862 {
863 if ( !mRendererSettings.hasSettings( datasetGroupIndex ) )
864 assignDefaultStyleToDatasetGroup( datasetGroupIndex );
865 }
866
867 temporalProperties()->setIsActive( mDatasetGroupStore->hasTemporalCapabilities() );
868 emit rendererChanged();
869}
870
871void QgsMeshLayer::onMeshEdited()
872{
874
875 mRendererCache.reset( new QgsMeshLayerRendererCache() );
876 emit layerModified();
879}
880
882{
884
885 return mDatasetGroupStore->datasetGroupTreeItem();
886}
887
889{
891
892 mDatasetGroupStore->setDatasetGroupTreeItem( rootItem );
893 updateActiveDatasetGroups();
894}
895
896int QgsMeshLayer::closestEdge( const QgsPointXY &point, double searchRadius, QgsPointXY &projectedPoint ) const
897{
899
900 const QgsRectangle searchRectangle( point.x() - searchRadius, point.y() - searchRadius, point.x() + searchRadius, point.y() + searchRadius );
901 const QgsTriangularMesh *mesh = triangularMesh();
902 // search for the closest edge in search area from point
903 const QList<int> edgeIndexes = mesh->edgeIndexesForRectangle( searchRectangle );
904 int selectedIndex = -1;
905 if ( mesh->contains( QgsMesh::Edge ) &&
906 mDataProvider->isValid() )
907 {
908 double sqrMaxDistFromPoint = pow( searchRadius, 2 );
909 for ( const int edgeIndex : edgeIndexes )
910 {
911 const QgsMeshEdge &edge = mesh->edges().at( edgeIndex );
912 const QgsMeshVertex &vertex1 = mesh->vertices()[edge.first];
913 const QgsMeshVertex &vertex2 = mesh->vertices()[edge.second];
914 QgsPointXY projPoint;
915 const double sqrDist = point.sqrDistToSegment( vertex1.x(), vertex1.y(), vertex2.x(), vertex2.y(), projPoint, 0 );
916 if ( sqrDist < sqrMaxDistFromPoint )
917 {
918 selectedIndex = edgeIndex;
919 projectedPoint = projPoint;
920 sqrMaxDistFromPoint = sqrDist;
921 }
922 }
923 }
924
925 return selectedIndex;
926}
927
929{
931
932 return QgsMeshDatasetIndex( group >= 0 ? group : mRendererSettings.activeVectorDatasetGroup(), mStaticVectorDatasetIndex );
933}
934
935void QgsMeshLayer::setReferenceTime( const QDateTime &referenceTime )
936{
938
939 if ( auto *lDataProvider = dataProvider() )
940 mTemporalProperties->setReferenceTime( referenceTime, lDataProvider->temporalCapabilities() );
941 else
942 mTemporalProperties->setReferenceTime( referenceTime, nullptr );
943}
944
951
952QgsPointXY QgsMeshLayer::snapOnVertex( const QgsPointXY &point, double searchRadius )
953{
955
956 const QgsTriangularMesh *mesh = triangularMesh();
957 QgsPointXY exactPosition;
958 if ( !mesh )
959 return exactPosition;
960 const QgsRectangle rectangle( point.x() - searchRadius, point.y() - searchRadius, point.x() + searchRadius, point.y() + searchRadius );
961 double maxDistance = searchRadius;
962 //attempt to snap on edges's vertices
963 const QList<int> edgeIndexes = mesh->edgeIndexesForRectangle( rectangle );
964 for ( const int edgeIndex : edgeIndexes )
965 {
966 const QgsMeshEdge &edge = mesh->edges().at( edgeIndex );
967 const QgsMeshVertex &vertex1 = mesh->vertices()[edge.first];
968 const QgsMeshVertex &vertex2 = mesh->vertices()[edge.second];
969 const double dist1 = point.distance( vertex1 );
970 const double dist2 = point.distance( vertex2 );
971 if ( dist1 < maxDistance )
972 {
973 maxDistance = dist1;
974 exactPosition = vertex1;
975 }
976 if ( dist2 < maxDistance )
977 {
978 maxDistance = dist2;
979 exactPosition = vertex2;
980 }
981 }
982
983 //attempt to snap on face's vertices
984 const QList<int> faceIndexes = mesh->faceIndexesForRectangle( rectangle );
985 for ( const int faceIndex : faceIndexes )
986 {
987 const QgsMeshFace &face = mesh->triangles().at( faceIndex );
988 for ( int i = 0; i < 3; ++i )
989 {
990 const QgsMeshVertex &vertex = mesh->vertices()[face.at( i )];
991 const double dist = point.distance( vertex );
992 if ( dist < maxDistance )
993 {
994 maxDistance = dist;
995 exactPosition = vertex;
996 }
997 }
998 }
999
1000 return exactPosition;
1001}
1002
1003QgsPointXY QgsMeshLayer::snapOnEdge( const QgsPointXY &point, double searchRadius )
1004{
1006
1007 QgsPointXY projectedPoint;
1008 closestEdge( point, searchRadius, projectedPoint );
1009
1010 return projectedPoint;
1011}
1012
1013QgsPointXY QgsMeshLayer::snapOnFace( const QgsPointXY &point, double searchRadius )
1014{
1016
1017 const QgsTriangularMesh *mesh = triangularMesh();
1018 QgsPointXY centroidPosition;
1019 if ( !mesh )
1020 return centroidPosition;
1021 const QgsRectangle rectangle( point.x() - searchRadius, point.y() - searchRadius, point.x() + searchRadius, point.y() + searchRadius );
1022 double maxDistance = std::numeric_limits<double>::max();
1023
1024 const QList<int> faceIndexes = mesh->faceIndexesForRectangle( rectangle );
1025 for ( const int faceIndex : faceIndexes )
1026 {
1027 const int nativefaceIndex = mesh->trianglesToNativeFaces().at( faceIndex );
1028 if ( nativefaceIndex < 0 && nativefaceIndex >= mesh->faceCentroids().count() )
1029 continue;
1030 const QgsPointXY centroid = mesh->faceCentroids()[nativefaceIndex];
1031 const double dist = point.distance( centroid );
1032 if ( dist < maxDistance )
1033 {
1034 maxDistance = dist;
1035 centroidPosition = centroid;
1036 }
1037 }
1038
1039 return centroidPosition;
1040}
1041
1043{
1045
1046 mDatasetGroupStore->resetDatasetGroupTreeItem();
1047 updateActiveDatasetGroups();
1048}
1049
1051{
1053
1054 if ( !mDataProvider )
1055 return QgsInterval();
1056 const int groupCount = mDataProvider->datasetGroupCount();
1057 for ( int i = 0; i < groupCount; ++i )
1058 {
1059 const qint64 timeStep = mDataProvider->temporalCapabilities()->firstTimeStepDuration( i );
1060 if ( timeStep > 0 )
1062 }
1063
1064 return QgsInterval();
1065}
1066
1068{
1070
1071 const qint64 time = mDatasetGroupStore->datasetRelativeTime( index );
1072
1073 if ( time == INVALID_MESHLAYER_TIME )
1074 return QgsInterval();
1075 else
1077}
1078
1080{
1082
1083 return mDatasetGroupStore->datasetRelativeTime( index );
1084}
1085
1086static QString detailsErrorMessage( const QgsMeshEditingError &error )
1087{
1088 QString message;
1089
1090 switch ( error.errorType )
1091 {
1093 break;
1095 message = QObject::tr( "Face %1 invalid" ).arg( error.elementIndex );
1096 break;
1098 message = QObject::tr( "Too many vertices for face %1" ).arg( error.elementIndex );
1099 break;
1101 message = QObject::tr( "Face %1 is flat" ).arg( error.elementIndex );
1102 break;
1104 message = QObject::tr( "Vertex %1 is a unique shared vertex" ).arg( error.elementIndex );
1105 break;
1107 message = QObject::tr( "Vertex %1 is invalid" ).arg( error.elementIndex );
1108 break;
1110 message = QObject::tr( "Face %1 is manifold" ).arg( error.elementIndex );
1111 break;
1112 }
1113
1114 return message;
1115}
1116
1118{
1120
1122 return startFrameEditing( transform, error, false );
1123}
1124
1126{
1128
1129 if ( !supportsEditing() )
1130 {
1131 QgsMessageLog::logMessage( QObject::tr( "Mesh layer \"%1\" not support mesh editing" ).arg( name() ) );
1132 return false;
1133 }
1134
1135 if ( mMeshEditor )
1136 {
1137 QgsMessageLog::logMessage( QObject::tr( "Mesh layer \"%1\" already in editing mode" ).arg( name() ) );
1138 return false;
1139 }
1140
1141 mSimplificationSettings.setEnabled( false );
1142
1143 updateTriangularMesh( transform );
1144
1145 mMeshEditor = new QgsMeshEditor( this );
1146
1147 if ( fixErrors )
1148 {
1149 mRendererCache.reset(); // fixing errors could lead to remove faces/vertices
1150 error = mMeshEditor->initializeWithErrorsFix();
1151 }
1152 else
1153 error = mMeshEditor->initialize();
1154
1155 if ( error.errorType != Qgis::MeshEditingErrorType::NoError )
1156 {
1157 mMeshEditor->deleteLater();
1158 mMeshEditor = nullptr;
1159
1160 QgsMessageLog::logMessage( QObject::tr( "Unable to start editing of mesh layer \"%1\": %2" ).
1161 arg( name(), detailsErrorMessage( error ) ), QString(), Qgis::MessageLevel::Critical );
1162 return false;
1163 }
1164
1165 // During editing, we don't need anymore the provider data. Mesh frame data is stored in the mesh editor.
1166 mDataProvider->close();
1167
1168 // All dataset group are removed and replace by a unique virtual dataset group that provide vertices elevation value.
1169 mExtraDatasetUri.clear();
1170 mDatasetGroupStore.reset( new QgsMeshDatasetGroupStore( this ) );
1171
1172 std::unique_ptr<QgsMeshDatasetGroup> zValueDatasetGroup( mMeshEditor->createZValueDatasetGroup() );
1173 if ( mDatasetGroupStore->addDatasetGroup( zValueDatasetGroup.get() ) )
1174 zValueDatasetGroup.release();
1175
1177
1178 connect( mMeshEditor, &QgsMeshEditor::meshEdited, this, &QgsMeshLayer::onMeshEdited );
1179
1180 emit dataChanged();
1181 emit editingStarted();
1182
1183 return true;
1184}
1185
1186bool QgsMeshLayer::commitFrameEditing( const QgsCoordinateTransform &transform, bool continueEditing )
1187{
1189
1191 QString detailsError;
1192 if ( !mMeshEditor->checkConsistency( error ) )
1193 {
1194 if ( error.errorType == Qgis::MeshEditingErrorType::NoError )
1195 detailsError = tr( "Unknown inconsistent mesh error" );
1196 }
1197 else
1198 {
1199 error = QgsTopologicalMesh::checkTopology( *mNativeMesh, mMeshEditor->maximumVerticesPerFace() );
1200 detailsError = detailsErrorMessage( error );
1201 }
1202
1203 if ( !detailsError.isEmpty() )
1204 {
1205 QgsMessageLog::logMessage( QObject::tr( "Edited mesh layer \"%1\" can't be save due to an error: %2" ).
1206 arg( name(), detailsError ), QString(), Qgis::MessageLevel::Critical );
1207 return false;
1208 }
1209
1210 stopFrameEditing( transform );
1211
1212 if ( !mDataProvider )
1213 return false;
1214
1215 const bool res = mDataProvider->saveMeshFrame( *mNativeMesh.get() );
1216
1217 if ( continueEditing )
1218 {
1219 mMeshEditor->initialize();
1220 emit layerModified();
1221 return res;
1222 }
1223
1224 mMeshEditor->deleteLater();
1225 mMeshEditor = nullptr;
1226 emit editingStopped();
1227
1228 mDataProvider->reloadData();
1229 mDataProvider->populateMesh( mNativeMesh.get() );
1230 mDatasetGroupStore.reset( new QgsMeshDatasetGroupStore( this ) );
1231 mDatasetGroupStore->setPersistentProvider( mDataProvider, QStringList() );
1233 return true;
1234}
1235
1236bool QgsMeshLayer::rollBackFrameEditing( const QgsCoordinateTransform &transform, bool continueEditing )
1237{
1239
1240 stopFrameEditing( transform );
1241
1242 if ( !mDataProvider )
1243 return false;
1244
1245 mTriangularMeshes.clear();
1246 mDataProvider->reloadData();
1247 mDataProvider->populateMesh( mNativeMesh.get() );
1248 updateTriangularMesh( transform );
1249 mRendererCache.reset( new QgsMeshLayerRendererCache() );
1251
1252 if ( continueEditing )
1253 {
1254 mMeshEditor->resetTriangularMesh( triangularMesh() );
1255 return mMeshEditor->initialize() == QgsMeshEditingError();
1256 }
1257 else
1258 {
1259 mMeshEditor->deleteLater();
1260 mMeshEditor = nullptr;
1261 emit editingStopped();
1262
1263 mDatasetGroupStore.reset( new QgsMeshDatasetGroupStore( this ) );
1264 mDatasetGroupStore->setPersistentProvider( mDataProvider, QStringList() );
1266 emit dataChanged();
1267 return true;
1268 }
1269}
1270
1272{
1274
1275 if ( !mMeshEditor )
1276 return;
1277
1278 mMeshEditor->stopEditing();
1279 mTriangularMeshes.at( 0 )->update( mNativeMesh.get(), transform );
1280 mRendererCache.reset( new QgsMeshLayerRendererCache() );
1281}
1282
1283bool QgsMeshLayer::reindex( const QgsCoordinateTransform &transform, bool renumber )
1284{
1286
1287 if ( !mMeshEditor )
1288 return false;
1289
1290 if ( !mMeshEditor->reindex( renumber ) )
1291 return false;
1292
1293 mTriangularMeshes.clear();
1294 mTriangularMeshes.emplace_back( new QgsTriangularMesh );
1295 mTriangularMeshes.at( 0 )->update( mNativeMesh.get(), transform );
1296 mRendererCache.reset( new QgsMeshLayerRendererCache() );
1297 mMeshEditor->resetTriangularMesh( mTriangularMeshes.at( 0 ).get() );
1298
1299 return true;
1300}
1301
1303{
1305
1306 return mMeshEditor;
1307}
1308
1310{
1312
1313 if ( mMeshEditor )
1314 return mMeshEditor->isModified();
1315
1316 return false;
1317}
1318
1320{
1322
1323 switch ( type )
1324 {
1326 return meshVertexCount() != 0;
1328 return meshEdgeCount() != 0;
1330 return meshFaceCount() != 0;
1331 }
1332 return false;
1333}
1334
1336{
1338
1339 if ( mMeshEditor )
1340 return mMeshEditor->validVerticesCount();
1341 else if ( mDataProvider )
1342 return mDataProvider->vertexCount();
1343 else return 0;
1344}
1345
1347{
1349
1350 if ( mMeshEditor )
1351 return mMeshEditor->validFacesCount();
1352 else if ( mDataProvider )
1353 return mDataProvider->faceCount();
1354 else return 0;
1355}
1356
1358{
1360
1361 if ( mMeshEditor )
1362 return mNativeMesh->edgeCount();
1363 else if ( mDataProvider )
1364 return mDataProvider->edgeCount();
1365 else return 0;
1366}
1367
1368void QgsMeshLayer::updateActiveDatasetGroups()
1369{
1371
1372 QgsMeshDatasetGroupTreeItem *treeItem = mDatasetGroupStore->datasetGroupTreeItem();
1373
1374 if ( !mDatasetGroupStore->datasetGroupTreeItem() )
1375 return;
1376
1378 const int oldActiveScalar = settings.activeScalarDatasetGroup();
1379 const int oldActiveVector = settings.activeVectorDatasetGroup();
1380
1381 QgsMeshDatasetGroupTreeItem *activeScalarItem =
1382 treeItem->childFromDatasetGroupIndex( oldActiveScalar );
1383
1384 if ( !activeScalarItem && treeItem->childCount() > 0 && oldActiveScalar != -1 )
1385 activeScalarItem = treeItem->child( 0 );
1386
1387 if ( activeScalarItem && !activeScalarItem->isEnabled() )
1388 {
1389 for ( int i = 0; i < treeItem->childCount(); ++i )
1390 {
1391 activeScalarItem = treeItem->child( i );
1392 if ( activeScalarItem->isEnabled() )
1393 break;
1394 else
1395 activeScalarItem = nullptr;
1396 }
1397 }
1398
1399 if ( activeScalarItem )
1400 settings.setActiveScalarDatasetGroup( activeScalarItem->datasetGroupIndex() );
1401 else
1402 settings.setActiveScalarDatasetGroup( -1 );
1403
1404 QgsMeshDatasetGroupTreeItem *activeVectorItem =
1405 treeItem->childFromDatasetGroupIndex( oldActiveVector );
1406
1407 if ( !( activeVectorItem && activeVectorItem->isEnabled() ) )
1408 settings.setActiveVectorDatasetGroup( -1 );
1409
1410 setRendererSettings( settings );
1411
1412 if ( oldActiveScalar != settings.activeScalarDatasetGroup() )
1414 if ( oldActiveVector != settings.activeVectorDatasetGroup() )
1416}
1417
1418QgsMeshRendererSettings QgsMeshLayer::accordSymbologyWithGroupName( const QgsMeshRendererSettings &settings, const QMap<QString, int> &nameToIndex )
1419{
1420 QString activeScalarName;
1421 QString activeVectorName;
1422 QgsMeshRendererSettings consistentSettings = settings;
1423 int activeScalar = consistentSettings.activeScalarDatasetGroup();
1424 int activeVector = consistentSettings.activeVectorDatasetGroup();
1425
1426 for ( auto it = nameToIndex.constBegin(); it != nameToIndex.constEnd(); ++it )
1427 {
1428 int index = it.value();
1429 const QString name = it.key() ;
1430 int globalIndex = mDatasetGroupStore->indexFromGroupName( name );
1431 if ( globalIndex >= 0 )
1432 {
1433 QgsMeshRendererScalarSettings scalarSettings = settings.scalarSettings( index );
1434 consistentSettings.setScalarSettings( globalIndex, scalarSettings );
1435 if ( settings.hasVectorSettings( it.value() ) && mDatasetGroupStore->datasetGroupMetadata( globalIndex ).isVector() )
1436 {
1437 QgsMeshRendererVectorSettings vectorSettings = settings.vectorSettings( index );
1438 consistentSettings.setVectorSettings( globalIndex, vectorSettings );
1439 }
1440 }
1441 else
1442 {
1443 consistentSettings.removeScalarSettings( index );
1444 if ( settings.hasVectorSettings( it.value() ) )
1445 consistentSettings.removeVectorSettings( index );
1446 }
1447
1448 if ( index == activeScalar )
1449 activeScalarName = name;
1450 if ( index == activeVector )
1451 activeVectorName = name;
1452 }
1453
1454 const QList<int> globalIndexes = datasetGroupsIndexes();
1455 for ( int globalIndex : globalIndexes )
1456 {
1457 const QString name = mDatasetGroupStore->groupName( globalIndex );
1458 if ( !nameToIndex.contains( name ) )
1459 {
1460 consistentSettings.setScalarSettings( globalIndex, mRendererSettings.scalarSettings( globalIndex ) );
1461 if ( mDatasetGroupStore->datasetGroupMetadata( globalIndex ).isVector() )
1462 {
1463 consistentSettings.setVectorSettings( globalIndex, mRendererSettings.vectorSettings( globalIndex ) );
1464 }
1465 }
1466 }
1467
1468 if ( !activeScalarName.isEmpty() )
1469 consistentSettings.setActiveScalarDatasetGroup( mDatasetGroupStore->indexFromGroupName( activeScalarName ) );
1470 if ( !activeVectorName.isEmpty() )
1471 consistentSettings.setActiveVectorDatasetGroup( mDatasetGroupStore->indexFromGroupName( activeVectorName ) );
1472
1473 return consistentSettings;
1474}
1475
1476void QgsMeshLayer::setDataSourcePrivate( const QString &dataSource, const QString &baseName, const QString &provider, const QgsDataProvider::ProviderOptions &options, Qgis::DataProviderReadFlags flags )
1477{
1479
1480 mDataSource = dataSource;
1481 mLayerName = baseName;
1482 setProviderType( provider );
1483
1484 if ( !mDataSource.isEmpty() && !provider.isEmpty() )
1485 setDataProvider( provider, options, flags );
1486}
1487
1488QgsPointXY QgsMeshLayer::snapOnElement( QgsMesh::ElementType elementType, const QgsPointXY &point, double searchRadius )
1489{
1491
1492 switch ( elementType )
1493 {
1494 case QgsMesh::Vertex:
1495 return snapOnVertex( point, searchRadius );
1496 case QgsMesh::Edge:
1497 return snapOnEdge( point, searchRadius );
1498 case QgsMesh::Face:
1499 return snapOnFace( point, searchRadius );
1500 }
1501 return QgsPointXY(); // avoid warnings
1502}
1503
1505{
1507
1508 if ( !mNativeMesh )
1509 {
1510 // lazy loading of mesh data
1511 fillNativeMesh();
1512 }
1513
1514 QList<int> ret;
1515
1516 if ( !mNativeMesh )
1517 return ret;
1518
1519 QgsExpressionContext context;
1520 std::unique_ptr<QgsExpressionContextScope> expScope( QgsExpressionContextUtils::meshExpressionScope( QgsMesh::Vertex ) );
1521 context.appendScope( expScope.release() );
1522 context.lastScope()->setVariable( QStringLiteral( "_native_mesh" ), QVariant::fromValue( *mNativeMesh ) );
1523
1524 expression.prepare( &context );
1525
1526 for ( int i = 0; i < mNativeMesh->vertexCount(); ++i )
1527 {
1528 context.lastScope()->setVariable( QStringLiteral( "_mesh_vertex_index" ), i, false );
1529
1530 if ( expression.evaluate( &context ).toBool() )
1531 ret.append( i );
1532 }
1533
1534 return ret;
1535}
1536
1538{
1540
1541 if ( !mNativeMesh )
1542 {
1543 // lazy loading of mesh data
1544 fillNativeMesh();
1545 }
1546
1547 QList<int> ret;
1548
1549 if ( !mNativeMesh )
1550 return ret;
1551
1552 QgsExpressionContext context;
1553 std::unique_ptr<QgsExpressionContextScope> expScope( QgsExpressionContextUtils::meshExpressionScope( QgsMesh::Face ) );
1554 context.appendScope( expScope.release() );
1555 context.lastScope()->setVariable( QStringLiteral( "_native_mesh" ), QVariant::fromValue( *mNativeMesh ) );
1556
1557 expression.prepare( &context );
1558
1559 for ( int i = 0; i < mNativeMesh->faceCount(); ++i )
1560 {
1561 context.lastScope()->setVariable( QStringLiteral( "_mesh_face_index" ), i, false );
1562
1563 if ( expression.evaluate( &context ).toBool() )
1564 ret.append( i );
1565 }
1566
1567 return ret;
1568}
1569
1571{
1573
1574 return QgsMeshDatasetIndex( group >= 0 ? group : mRendererSettings.activeScalarDatasetGroup(), mStaticScalarDatasetIndex );
1575}
1576
1578{
1580
1581 const int oldActiveVector = mRendererSettings.activeVectorDatasetGroup();
1582
1583 mStaticVectorDatasetIndex = staticVectorDatasetIndex.dataset();
1585
1586 if ( oldActiveVector != mRendererSettings.activeVectorDatasetGroup() )
1588}
1589
1591{
1593
1594 const int oldActiveScalar = mRendererSettings.activeScalarDatasetGroup();
1595
1596 mStaticScalarDatasetIndex = staticScalarDatasetIndex.dataset();
1598
1599 if ( oldActiveScalar != mRendererSettings.activeScalarDatasetGroup() )
1601}
1602
1609
1611{
1613
1614 mSimplificationSettings = simplifySettings;
1615}
1616
1617static QgsColorRamp *_createDefaultColorRamp()
1618{
1619 QgsColorRamp *ramp = QgsStyle::defaultStyle()->colorRamp( QStringLiteral( "Plasma" ) );
1620 if ( ramp )
1621 return ramp;
1622
1623 // definition of "Plasma" color ramp (in case it is not available in the style for some reason)
1624 QVariantMap props;
1625 props["color1"] = "13,8,135,255";
1626 props["color2"] = "240,249,33,255";
1627 props["stops"] =
1628 "0.0196078;27,6,141,255:0.0392157;38,5,145,255:0.0588235;47,5,150,255:0.0784314;56,4,154,255:0.0980392;65,4,157,255:"
1629 "0.117647;73,3,160,255:0.137255;81,2,163,255:0.156863;89,1,165,255:0.176471;97,0,167,255:0.196078;105,0,168,255:"
1630 "0.215686;113,0,168,255:0.235294;120,1,168,255:0.254902;128,4,168,255:0.27451;135,7,166,255:0.294118;142,12,164,255:"
1631 "0.313725;149,17,161,255:0.333333;156,23,158,255:0.352941;162,29,154,255:0.372549;168,34,150,255:0.392157;174,40,146,255:"
1632 "0.411765;180,46,141,255:0.431373;186,51,136,255:0.45098;191,57,132,255:0.470588;196,62,127,255:0.490196;201,68,122,255:"
1633 "0.509804;205,74,118,255:0.529412;210,79,113,255:0.54902;214,85,109,255:0.568627;218,91,105,255:0.588235;222,97,100,255:"
1634 "0.607843;226,102,96,255:0.627451;230,108,92,255:0.647059;233,114,87,255:0.666667;237,121,83,255:0.686275;240,127,79,255:"
1635 "0.705882;243,133,75,255:0.72549;245,140,70,255:0.745098;247,147,66,255:0.764706;249,154,62,255:0.784314;251,161,57,255:"
1636 "0.803922;252,168,53,255:0.823529;253,175,49,255:0.843137;254,183,45,255:0.862745;254,190,42,255:0.882353;253,198,39,255:"
1637 "0.901961;252,206,37,255:0.921569;251,215,36,255:0.941176;248,223,37,255:0.960784;246,232,38,255:0.980392;243,240,39,255";
1638 return QgsGradientColorRamp::create( props );
1639}
1640
1641void QgsMeshLayer::assignDefaultStyleToDatasetGroup( int groupIndex )
1642{
1644
1646 const double groupMin = metadata.minimum();
1647 const double groupMax = metadata.maximum();
1648
1649 QgsColorRampShader fcn( groupMin, groupMax, _createDefaultColorRamp() );
1650 fcn.classifyColorRamp( 5, -1, QgsRectangle(), nullptr );
1651
1652 QgsMeshRendererScalarSettings scalarSettings;
1653 scalarSettings.setClassificationMinimumMaximum( groupMin, groupMax );
1654 scalarSettings.setColorRampShader( fcn );
1655 QgsInterpolatedLineWidth edgeStrokeWidth;
1656 edgeStrokeWidth.setMinimumValue( groupMin );
1657 edgeStrokeWidth.setMaximumValue( groupMax );
1658 const QgsInterpolatedLineColor edgeStrokeColor( fcn );
1659 const QgsInterpolatedLineRenderer edgeStrokePen;
1660 scalarSettings.setEdgeStrokeWidth( edgeStrokeWidth );
1661 mRendererSettings.setScalarSettings( groupIndex, scalarSettings );
1662
1663 if ( metadata.isVector() )
1664 {
1665 QgsMeshRendererVectorSettings vectorSettings;
1666 vectorSettings.setColorRampShader( fcn );
1667 mRendererSettings.setVectorSettings( groupIndex, vectorSettings );
1668 }
1669}
1670
1672{
1674
1675 // Triangular mesh
1676 updateTriangularMesh( rendererContext.coordinateTransform() );
1677
1678 // Build overview triangular meshes if needed
1679 createSimplifiedMeshes();
1680
1681 // Cache
1682 if ( !mRendererCache )
1683 mRendererCache.reset( new QgsMeshLayerRendererCache() );
1684
1685 return new QgsMeshLayerRenderer( this, rendererContext );
1686}
1687
1689{
1690 if ( rendererContext.isTemporal() )
1691 return activeScalarDatasetAtTime( rendererContext.temporalRange(), mRendererSettings.activeScalarDatasetGroup() );
1692 else
1693 return staticScalarDatasetIndex( mRendererSettings.activeScalarDatasetGroup() );
1694}
1695
1696bool QgsMeshLayer::minimumMaximumActiveScalarDataset( const QgsRectangle &extent, const QgsMeshDatasetIndex &datasetIndex, double &min, double &max )
1697{
1698
1699 if ( extent.isNull() || !this->extent().intersects( extent ) )
1700 return false;
1701
1703
1704 if ( ! tMesh )
1705 {
1706 return false;
1707 }
1708
1709 QVector<double> scalarDatasetValues;
1711
1712 if ( !metadata.isScalar() )
1713 {
1714 return false;
1715 }
1716
1717 QgsMeshDatasetGroupMetadata::DataType scalarDataType = QgsMeshLayerUtils::datasetValuesType( metadata.dataType() );
1718
1719 if ( !datasetIndex.isValid() )
1720 {
1721 return false;
1722 }
1723
1724 // populate scalar values
1725 const int count = QgsMeshLayerUtils::datasetValuesCount( mNativeMesh.get(), scalarDataType );
1726 const QgsMeshDataBlock vals = QgsMeshLayerUtils::datasetValues(
1727 this,
1728 datasetIndex,
1729 0,
1730 count );
1731
1732 if ( vals.isValid() )
1733 {
1734 // vals could be scalar or vectors, for contour rendering we want always magnitude
1735 scalarDatasetValues = QgsMeshLayerUtils::calculateMagnitudes( vals );
1736 }
1737 else
1738 {
1739 scalarDatasetValues = QVector<double>( count, std::numeric_limits<double>::quiet_NaN() );
1740 }
1741
1742 QList<int> intersectedFacesIndices = tMesh->faceIndexesForRectangle( extent );
1743
1744 if ( intersectedFacesIndices.isEmpty() )
1745 {
1746 return false;
1747 }
1748
1749 min = std::numeric_limits<double>::max();
1750 max = -std::numeric_limits<double>::max();
1751
1752 double value;
1753
1754 for ( int intersectedFaceIndex : intersectedFacesIndices )
1755 {
1756 QgsMeshFace face = tMesh->triangles().at( intersectedFaceIndex );
1757
1759 {
1760 value = scalarDatasetValues.at( tMesh->trianglesToNativeFaces().at( intersectedFaceIndex ) );
1761 min = std::min( min, value );
1762 max = std::max( max, value );
1763 }
1765 {
1766 QgsMeshVertex vertex;
1767
1768 for ( int vertexIndex : face )
1769 {
1770 value = scalarDatasetValues.at( vertexIndex );
1771 min = std::min( min, value );
1772 max = std::max( max, value );
1773 }
1774 }
1775 }
1776
1777 return true;
1778}
1779
1786
1787void QgsMeshLayer::checkSymbologyConsistency()
1788{
1790
1791 const QList<int> groupIndexes = mDatasetGroupStore->datasetGroupIndexes();
1792 if ( !groupIndexes.contains( mRendererSettings.activeScalarDatasetGroup() ) &&
1793 mRendererSettings.activeScalarDatasetGroup() != -1 )
1794 {
1795 if ( !groupIndexes.empty() )
1796 mRendererSettings.setActiveScalarDatasetGroup( groupIndexes.first() );
1797 else
1798 mRendererSettings.setActiveScalarDatasetGroup( -1 );
1799 }
1800
1801 if ( !groupIndexes.contains( mRendererSettings.activeVectorDatasetGroup() ) &&
1802 mRendererSettings.activeVectorDatasetGroup() != -1 )
1803 {
1804 mRendererSettings.setActiveVectorDatasetGroup( -1 );
1805 }
1806}
1807
1808bool QgsMeshLayer::readSymbology( const QDomNode &node, QString &errorMessage,
1810{
1812
1813 Q_UNUSED( errorMessage )
1814 // TODO: implement categories for raster layer
1815
1816 const QDomElement elem = node.toElement();
1817
1818 readCommonStyle( elem, context, categories );
1819
1821 const QDomElement elemRendererSettings = elem.firstChildElement( "mesh-renderer-settings" );
1822 if ( !elemRendererSettings.isNull() )
1823 rendererSettings.readXml( elemRendererSettings, context );
1824
1825 QMap<QString, int> groupNameToGlobalIndex;
1826 QDomElement nameToIndexElem = elem.firstChildElement( "name-to-global-index" );
1827 while ( !nameToIndexElem.isNull() )
1828 {
1829 const QString name = nameToIndexElem.attribute( QStringLiteral( "name" ) );
1830 int globalIndex = nameToIndexElem.attribute( QStringLiteral( "global-index" ) ).toInt();
1831 groupNameToGlobalIndex.insert( name, globalIndex );
1832 nameToIndexElem = nameToIndexElem.nextSiblingElement( QStringLiteral( "name-to-global-index" ) );
1833 }
1834
1835 mRendererSettings = accordSymbologyWithGroupName( rendererSettings, groupNameToGlobalIndex );
1836
1837 checkSymbologyConsistency();
1838
1839 const QDomElement elemSimplifySettings = elem.firstChildElement( "mesh-simplify-settings" );
1840 if ( !elemSimplifySettings.isNull() )
1841 mSimplificationSettings.readXml( elemSimplifySettings, context );
1842
1843 // get and set the blend mode if it exists
1844 const QDomNode blendModeNode = node.namedItem( QStringLiteral( "blendMode" ) );
1845 if ( !blendModeNode.isNull() )
1846 {
1847 const QDomElement e = blendModeNode.toElement();
1848 setBlendMode( QgsPainting::getCompositionMode( static_cast< Qgis::BlendMode >( e.text().toInt() ) ) );
1849 }
1850
1851 // read labeling definition
1852 if ( categories.testFlag( Labeling ) )
1853 {
1854 QgsReadWriteContextCategoryPopper p = context.enterCategory( tr( "Labeling" ) );
1855
1856 QDomElement labelingElement = node.firstChildElement( QStringLiteral( "labeling" ) );
1857 if ( !labelingElement.isNull() )
1858 {
1860 mLabelsEnabled = node.toElement().attribute( QStringLiteral( "labelsEnabled" ), QStringLiteral( "0" ) ).toInt();
1862 }
1863 }
1864
1865 // get and set the layer transparency
1866 if ( categories.testFlag( Rendering ) )
1867 {
1868 const QDomNode layerOpacityNode = node.namedItem( QStringLiteral( "layerOpacity" ) );
1869 if ( !layerOpacityNode.isNull() )
1870 {
1871 const QDomElement e = layerOpacityNode.toElement();
1872 setOpacity( e.text().toDouble() );
1873 }
1874 }
1875
1876 return true;
1877}
1878
1879bool QgsMeshLayer::writeSymbology( QDomNode &node, QDomDocument &doc, QString &errorMessage,
1880 const QgsReadWriteContext &context, QgsMapLayer::StyleCategories categories ) const
1881{
1883
1884 Q_UNUSED( errorMessage )
1885 // TODO: implement categories for raster layer
1886
1887 QDomElement elem = node.toElement();
1888
1889 writeCommonStyle( elem, doc, context, categories );
1890
1891 const QDomElement elemRendererSettings = mRendererSettings.writeXml( doc, context );
1892 elem.appendChild( elemRendererSettings );
1893
1894 const QList<int> groupIndexes = datasetGroupsIndexes();
1895 // we store the relation between name and indexes to be able to retrieve the consistency between name and symbology
1896 for ( int index : groupIndexes )
1897 {
1898 QDomElement elemNameToIndex = doc.createElement( QStringLiteral( "name-to-global-index" ) );
1899 elemNameToIndex.setAttribute( QStringLiteral( "name" ), mDatasetGroupStore->groupName( index ) );
1900 elemNameToIndex.setAttribute( QStringLiteral( "global-index" ), index );
1901 elem.appendChild( elemNameToIndex );
1902 }
1903
1904 const QDomElement elemSimplifySettings = mSimplificationSettings.writeXml( doc, context );
1905 elem.appendChild( elemSimplifySettings );
1906
1907 // add blend mode node
1908 QDomElement blendModeElement = doc.createElement( QStringLiteral( "blendMode" ) );
1909 const QDomText blendModeText = doc.createTextNode( QString::number( static_cast< int >( QgsPainting::getBlendModeEnum( blendMode() ) ) ) );
1910 blendModeElement.appendChild( blendModeText );
1911 node.appendChild( blendModeElement );
1912
1913 if ( categories.testFlag( Labeling ) )
1914 {
1915 if ( mLabeling )
1916 {
1917 QDomElement labelingElement = mLabeling->save( doc, context );
1918 elem.appendChild( labelingElement );
1919 }
1920 elem.setAttribute( QStringLiteral( "labelsEnabled" ), mLabelsEnabled ? QStringLiteral( "1" ) : QStringLiteral( "0" ) );
1921 }
1922
1923 // add the layer opacity
1924 if ( categories.testFlag( Rendering ) )
1925 {
1926 QDomElement layerOpacityElem = doc.createElement( QStringLiteral( "layerOpacity" ) );
1927 const QDomText layerOpacityText = doc.createTextNode( QString::number( opacity() ) );
1928 layerOpacityElem.appendChild( layerOpacityText );
1929 node.appendChild( layerOpacityElem );
1930 }
1931
1932 return true;
1933}
1934
1935bool QgsMeshLayer::writeStyle( QDomNode &node, QDomDocument &doc, QString &errorMessage, const QgsReadWriteContext &context, QgsMapLayer::StyleCategories categories ) const
1936{
1938
1939 return writeSymbology( node, doc, errorMessage, context, categories );
1940}
1941
1942bool QgsMeshLayer::readStyle( const QDomNode &node, QString &errorMessage, QgsReadWriteContext &context, QgsMapLayer::StyleCategories categories )
1943{
1945
1946 return readSymbology( node, errorMessage, context, categories );
1947}
1948
1949QString QgsMeshLayer::decodedSource( const QString &source, const QString &provider, const QgsReadWriteContext &context ) const
1950{
1952
1953 return QgsProviderRegistry::instance()->relativeToAbsoluteUri( provider, source, context );
1954}
1955
1956QString QgsMeshLayer::encodedSource( const QString &source, const QgsReadWriteContext &context ) const
1957{
1959
1961}
1962
1963bool QgsMeshLayer::readXml( const QDomNode &layer_node, QgsReadWriteContext &context )
1964{
1966
1967 QgsDebugMsgLevel( QStringLiteral( "Datasource in QgsMeshLayer::readXml: %1" ).arg( mDataSource.toLocal8Bit().data() ), 3 );
1968
1969 //process provider key
1970 const QDomNode pkeyNode = layer_node.namedItem( QStringLiteral( "provider" ) );
1971
1972 if ( pkeyNode.isNull() )
1973 {
1974 mProviderKey.clear();
1975 }
1976 else
1977 {
1978 const QDomElement pkeyElt = pkeyNode.toElement();
1979 mProviderKey = pkeyElt.text();
1980 }
1981
1983 {
1984 return false;
1985 }
1986
1987 const QgsDataProvider::ProviderOptions providerOptions;
1989
1990 const QDomElement elemExtraDatasets = layer_node.firstChildElement( QStringLiteral( "extra-datasets" ) );
1991 if ( !elemExtraDatasets.isNull() )
1992 {
1993 QDomElement elemUri = elemExtraDatasets.firstChildElement( QStringLiteral( "uri" ) );
1994 while ( !elemUri.isNull() )
1995 {
1996 const QString uri = context.pathResolver().readPath( elemUri.text() );
1997 mExtraDatasetUri.append( uri );
1998 elemUri = elemUri.nextSiblingElement( QStringLiteral( "uri" ) );
1999 }
2000 }
2001
2002 if ( pkeyNode.toElement().hasAttribute( QStringLiteral( "time-unit" ) ) )
2003 mTemporalUnit = static_cast<Qgis::TemporalUnit>( pkeyNode.toElement().attribute( QStringLiteral( "time-unit" ) ).toInt() );
2004
2005 // read dataset group store
2006 const QDomElement elemDatasetGroupsStore = layer_node.firstChildElement( QStringLiteral( "mesh-dataset-groups-store" ) );
2007 if ( elemDatasetGroupsStore.isNull() )
2009 else
2010 mDatasetGroupStore->readXml( elemDatasetGroupsStore, context );
2011
2012 setDataProvider( mProviderKey, providerOptions, flags );
2013
2014 QString errorMsg;
2015 readSymbology( layer_node, errorMsg, context );
2016
2017 if ( !mTemporalProperties->timeExtent().begin().isValid() || mTemporalProperties->alwaysLoadReferenceTimeFromSource() )
2019
2020 // read static dataset
2021 const QDomElement elemStaticDataset = layer_node.firstChildElement( QStringLiteral( "static-active-dataset" ) );
2022 if ( elemStaticDataset.hasAttribute( QStringLiteral( "scalar" ) ) )
2023 {
2024 mStaticScalarDatasetIndex = elemStaticDataset.attribute( QStringLiteral( "scalar" ) ).toInt();
2025 }
2026 if ( elemStaticDataset.hasAttribute( QStringLiteral( "vector" ) ) )
2027 {
2028 mStaticVectorDatasetIndex = elemStaticDataset.attribute( QStringLiteral( "vector" ) ).toInt();
2029 }
2030
2031 return isValid(); // should be true if read successfully
2032}
2033
2034bool QgsMeshLayer::writeXml( QDomNode &layer_node, QDomDocument &document, const QgsReadWriteContext &context ) const
2035{
2037
2038 // first get the layer element so that we can append the type attribute
2039 QDomElement mapLayerNode = layer_node.toElement();
2040
2041 if ( mapLayerNode.isNull() || ( QLatin1String( "maplayer" ) != mapLayerNode.nodeName() ) )
2042 {
2043 QgsDebugMsgLevel( QStringLiteral( "can't find <maplayer>" ), 2 );
2044 return false;
2045 }
2046
2047 mapLayerNode.setAttribute( QStringLiteral( "type" ), QgsMapLayerFactory::typeToString( Qgis::LayerType::Mesh ) );
2048
2049 // add provider node
2050 if ( mDataProvider )
2051 {
2052 QDomElement provider = document.createElement( QStringLiteral( "provider" ) );
2053 const QDomText providerText = document.createTextNode( providerType() );
2054 provider.appendChild( providerText );
2055 layer_node.appendChild( provider );
2056 provider.setAttribute( QStringLiteral( "time-unit" ), static_cast< int >( mDataProvider->temporalCapabilities()->temporalUnit() ) );
2057
2058 const QStringList extraDatasetUris = mDataProvider->extraDatasets();
2059 QDomElement elemExtraDatasets = document.createElement( QStringLiteral( "extra-datasets" ) );
2060 for ( const QString &uri : extraDatasetUris )
2061 {
2062 const QString path = context.pathResolver().writePath( uri );
2063 QDomElement elemUri = document.createElement( QStringLiteral( "uri" ) );
2064 elemUri.appendChild( document.createTextNode( path ) );
2065 elemExtraDatasets.appendChild( elemUri );
2066 }
2067 layer_node.appendChild( elemExtraDatasets );
2068 }
2069
2070 QDomElement elemStaticDataset = document.createElement( QStringLiteral( "static-active-dataset" ) );
2071 elemStaticDataset.setAttribute( QStringLiteral( "scalar" ), mStaticScalarDatasetIndex );
2072 elemStaticDataset.setAttribute( QStringLiteral( "vector" ), mStaticVectorDatasetIndex );
2073 layer_node.appendChild( elemStaticDataset );
2074
2075 // write dataset group store if not in edting mode
2076 if ( !isEditable() )
2077 layer_node.appendChild( mDatasetGroupStore->writeXml( document, context ) );
2078
2079 // renderer specific settings
2080 QString errorMsg;
2081 return writeSymbology( layer_node, document, errorMsg, context );
2082}
2083
2085{
2087
2088 if ( !mMeshEditor && mDataProvider && mDataProvider->isValid() )
2089 {
2090 mDataProvider->reloadData();
2091 mDatasetGroupStore->setPersistentProvider( mDataProvider, QStringList() ); //extra dataset are already loaded
2092
2093 //reload the mesh structure
2094 if ( !mNativeMesh )
2095 mNativeMesh.reset( new QgsMesh );
2096
2097 dataProvider()->populateMesh( mNativeMesh.get() );
2098
2099 if ( mTemporalProperties->alwaysLoadReferenceTimeFromSource() )
2100 mTemporalProperties->setDefaultsFromDataProviderTemporalCapabilities( mDataProvider->temporalCapabilities() );
2101
2102 //clear the TriangularMeshes
2103 mTriangularMeshes.clear();
2104
2105 //clear the rendererCache
2106 mRendererCache.reset( new QgsMeshLayerRendererCache() );
2107
2108 checkSymbologyConsistency();
2109
2110 emit reloaded();
2111 }
2112}
2113
2114QStringList QgsMeshLayer::subLayers() const
2115{
2117
2118 if ( mDataProvider )
2119 return mDataProvider->subLayers();
2120 else
2121 return QStringList();
2122}
2123
2125{
2127
2128 const QgsLayerMetadataFormatter htmlFormatter( metadata() );
2129 QString myMetadata = QStringLiteral( "<html>\n<body>\n" );
2130
2131 myMetadata += generalHtmlMetadata();
2132
2133 // Begin Provider section
2134 myMetadata += QStringLiteral( "<h1>" ) + tr( "Information from provider" ) + QStringLiteral( "</h1>\n<hr>\n" );
2135 myMetadata += QLatin1String( "<table class=\"list-view\">\n" );
2136
2137 // Extent
2138 myMetadata += QStringLiteral( "<tr><td class=\"highlight\">" ) + tr( "Extent" ) + QStringLiteral( "</td><td>" ) + extent().toString() + QStringLiteral( "</td></tr>\n" );
2139
2140 // feature count
2141 QLocale locale = QLocale();
2142 locale.setNumberOptions( locale.numberOptions() &= ~QLocale::NumberOption::OmitGroupSeparator );
2143
2144 if ( const QgsMeshDataProvider *provider = dataProvider() )
2145 {
2146 myMetadata += QStringLiteral( "<tr><td class=\"highlight\">" )
2147 + tr( "Vertex count" ) + QStringLiteral( "</td><td>" )
2148 + ( locale.toString( static_cast<qlonglong>( meshVertexCount() ) ) )
2149 + QStringLiteral( "</td></tr>\n" );
2150 myMetadata += QStringLiteral( "<tr><td class=\"highlight\">" )
2151 + tr( "Face count" ) + QStringLiteral( "</td><td>" )
2152 + ( locale.toString( static_cast<qlonglong>( meshFaceCount() ) ) )
2153 + QStringLiteral( "</td></tr>\n" );
2154 myMetadata += QStringLiteral( "<tr><td class=\"highlight\">" )
2155 + tr( "Edge count" ) + QStringLiteral( "</td><td>" )
2156 + ( locale.toString( static_cast<qlonglong>( meshEdgeCount() ) ) )
2157 + QStringLiteral( "</td></tr>\n" );
2158 myMetadata += QStringLiteral( "<tr><td class=\"highlight\">" )
2159 + tr( "Dataset groups count" ) + QStringLiteral( "</td><td>" )
2160 + ( locale.toString( static_cast<qlonglong>( datasetGroupCount() ) ) )
2161 + QStringLiteral( "</td></tr>\n" );
2162 myMetadata += provider->htmlMetadata();
2163 }
2164
2165 // End Provider section
2166 myMetadata += QLatin1String( "</table>\n<br><br>" );
2167
2168 // CRS
2169 myMetadata += crsHtmlMetadata();
2170
2171 // identification section
2172 myMetadata += QStringLiteral( "<h1>" ) + tr( "Identification" ) + QStringLiteral( "</h1>\n<hr>\n" );
2173 myMetadata += htmlFormatter.identificationSectionHtml( );
2174 myMetadata += QLatin1String( "<br><br>\n" );
2175
2176 // extent section
2177 myMetadata += QStringLiteral( "<h1>" ) + tr( "Extent" ) + QStringLiteral( "</h1>\n<hr>\n" );
2178 myMetadata += htmlFormatter.extentSectionHtml( isSpatial() );
2179 myMetadata += QLatin1String( "<br><br>\n" );
2180
2181 // Start the Access section
2182 myMetadata += QStringLiteral( "<h1>" ) + tr( "Access" ) + QStringLiteral( "</h1>\n<hr>\n" );
2183 myMetadata += htmlFormatter.accessSectionHtml( );
2184 myMetadata += QLatin1String( "<br><br>\n" );
2185
2186 // Start the contacts section
2187 myMetadata += QStringLiteral( "<h1>" ) + tr( "Contacts" ) + QStringLiteral( "</h1>\n<hr>\n" );
2188 myMetadata += htmlFormatter.contactsSectionHtml( );
2189 myMetadata += QLatin1String( "<br><br>\n" );
2190
2191 // Start the links section
2192 myMetadata += QStringLiteral( "<h1>" ) + tr( "Links" ) + QStringLiteral( "</h1>\n<hr>\n" );
2193 myMetadata += htmlFormatter.linksSectionHtml( );
2194 myMetadata += QLatin1String( "<br><br>\n" );
2195
2196 // Start the history section
2197 myMetadata += QStringLiteral( "<h1>" ) + tr( "History" ) + QStringLiteral( "</h1>\n<hr>\n" );
2198 myMetadata += htmlFormatter.historySectionHtml( );
2199 myMetadata += QLatin1String( "<br><br>\n" );
2200
2201 myMetadata += customPropertyHtmlMetadata();
2202
2203 myMetadata += QLatin1String( "\n</body>\n</html>\n" );
2204 return myMetadata;
2205}
2206
2208{
2210
2211 return mMeshEditor;
2212}
2213
2214bool QgsMeshLayer::setDataProvider( QString const &provider, const QgsDataProvider::ProviderOptions &options, Qgis::DataProviderReadFlags flags )
2215{
2217
2218 mDatasetGroupStore->setPersistentProvider( nullptr, QStringList() );
2219
2220 delete mDataProvider;
2221 mProviderKey = provider;
2222 const QString dataSource = mDataSource;
2223
2224 if ( mPreloadedProvider )
2225 {
2226 mDataProvider = qobject_cast< QgsMeshDataProvider * >( mPreloadedProvider.release() );
2227 }
2228 else
2229 {
2230 std::unique_ptr< QgsScopedRuntimeProfile > profile;
2231 if ( QgsApplication::profiler()->groupIsActive( QStringLiteral( "projectload" ) ) )
2232 profile = std::make_unique< QgsScopedRuntimeProfile >( tr( "Create %1 provider" ).arg( provider ), QStringLiteral( "projectload" ) );
2233
2234 mDataProvider = qobject_cast<QgsMeshDataProvider *>( QgsProviderRegistry::instance()->createProvider( provider, dataSource, options, flags ) );
2235 }
2236
2237 if ( !mDataProvider )
2238 {
2239 QgsDebugMsgLevel( QStringLiteral( "Unable to get mesh data provider" ), 2 );
2240 return false;
2241 }
2242
2243 mDataProvider->setParent( this );
2244 QgsDebugMsgLevel( QStringLiteral( "Instantiated the mesh data provider plugin" ), 2 );
2245
2246 setValid( mDataProvider->isValid() );
2247 if ( !isValid() )
2248 {
2249 QgsDebugMsgLevel( QStringLiteral( "Invalid mesh provider plugin %1" ).arg( QString( mDataSource.toUtf8() ) ), 2 );
2250 return false;
2251 }
2252
2253 if ( !mTemporalProperties->isValid() )
2254 {
2255 mTemporalProperties->setDefaultsFromDataProviderTemporalCapabilities( dataProvider()->temporalCapabilities() );
2256 }
2257
2258 mDataProvider->setTemporalUnit( mTemporalUnit );
2259
2260 mDatasetGroupStore->setPersistentProvider( mDataProvider, mExtraDatasetUri );
2261
2262 setCrs( mDataProvider->crs() );
2263
2264 if ( provider == QLatin1String( "mesh_memory" ) )
2265 {
2266 // required so that source differs between memory layers
2267 mDataSource = mDataSource + QStringLiteral( "&uid=%1" ).arg( QUuid::createUuid().toString() );
2268 }
2269
2270 // set default style if required by flags or if the dataset group does not has a style yet
2271 for ( int i = 0; i < mDataProvider->datasetGroupCount(); ++i )
2272 {
2273 int globalIndex = mDatasetGroupStore->globalDatasetGroupIndexInSource( mDataProvider, i );
2274 if ( globalIndex != -1 &&
2275 ( !mRendererSettings.hasSettings( globalIndex ) || ( flags & Qgis::DataProviderReadFlag::LoadDefaultStyle ) ) )
2276 assignDefaultStyleToDatasetGroup( globalIndex );
2277 }
2278
2279 emit rendererChanged();
2281
2282 connect( mDataProvider, &QgsMeshDataProvider::dataChanged, this, &QgsMeshLayer::dataChanged );
2283
2284 return true;
2285}
2286
2293
2300
2302{
2304
2305 return mLabelsEnabled && static_cast< bool >( mLabeling );
2306}
2307
2309{
2311
2312 mLabelsEnabled = enabled;
2313}
2314
2316{
2318
2319 if ( mLabeling == labeling )
2320 return;
2321
2322 delete mLabeling;
2323 mLabeling = labeling;
2325}
2326
2327bool QgsMeshLayer::datasetsPathUnique( const QString &path )
2328{
2329 if ( ! mDataProvider )
2330 {
2331 QgsDebugMsgLevel( QStringLiteral( "Unable to get mesh data provider" ), 2 );
2332 return false;
2333 }
2334
2335 if ( mDataProvider->dataSourceUri().contains( path ) )
2336 return false;
2337
2338 return !mExtraDatasetUri.contains( path );
2339}
The Qgis class provides global constants for use throughout the application.
Definition qgis.h:54
@ Exact
Assigns the color of the exact matching value in the color ramp item list.
@ Critical
Critical/error message.
Definition qgis.h:157
@ TooManyVerticesInFace
A face has more vertices than the maximum number supported per face.
@ InvalidFace
An error occurs due to an invalid face (for example, vertex indexes are unordered)
@ UniqueSharedVertex
A least two faces share only one vertices.
@ ManifoldFace
ManifoldFace.
@ InvalidVertex
An error occurs due to an invalid vertex (for example, vertex index is out of range the available ver...
@ FlatFace
A flat face is present.
BlendMode
Blending modes defining the available composition modes that can be used when painting.
Definition qgis.h:4677
TemporalUnit
Temporal units.
Definition qgis.h:4906
@ Milliseconds
Milliseconds.
QFlags< DataProviderReadFlag > DataProviderReadFlags
Flags which control data provider construction.
Definition qgis.h:450
@ EqualInterval
Uses equal interval.
@ Mesh
Mesh layer. Added in QGIS 3.2.
@ LoadDefaultStyle
Reset the layer's style to the default for the datasource.
QgsVertexIterator vertices() const
Returns a read-only, Java-style iterator for traversal of vertices of all the geometry,...
Abstract base class - its implementations define different approaches to the labeling of a mesh layer...
static QgsAbstractMeshLayerLabeling * create(const QDomElement &element, const QgsReadWriteContext &context)
Try to create instance of an implementation based on the XML data.
virtual QDomElement save(QDomDocument &doc, const QgsReadWriteContext &context) const =0
Returns labeling configuration as XML element.
Abstract base class for objects which generate elevation profiles.
static QgsRuntimeProfiler * profiler()
Returns the application runtime profiler.
A ramp shader will color a raster pixel based on a list of values ranges in a ramp.
void setClassificationMode(Qgis::ShaderClassificationMethod classificationMode)
Sets the classification mode.
QgsColorRamp * sourceColorRamp() const
Returns the source color ramp.
void setColorRampType(Qgis::ShaderInterpolationMethod colorRampType)
Sets the color ramp interpolation method.
void setColorRampItemList(const QList< QgsColorRampShader::ColorRampItem > &list)
Sets a custom color map.
Abstract base class for color ramps.
virtual QColor color(double value) const =0
Returns the color corresponding to a specified value.
Contains information about the context in which a coordinate transform is executed.
Class for doing transforms between two map coordinate systems.
Base class for handling properties relating to a data provider's temporal capabilities.
bool hasTemporalCapabilities() const
Returns true if the provider has temporal capabilities available.
QgsCoordinateTransformContext transformContext() const
Returns data provider coordinate transform context.
virtual QgsCoordinateReferenceSystem crs() const =0
Returns the coordinate system for the data source.
void dataChanged()
Emitted whenever a change is made to the data provider which may have caused changes in the provider'...
virtual bool isValid() const =0
Returns true if this is a valid layer.
virtual QString dataSourceUri(bool expandAuthConfig=false) const
Gets the data source specification.
virtual QStringList subLayers() const
Sub-layers handled by this provider, in order from bottom to top.
virtual void reloadData()
Reloads the data from the source for providers with data caches to synchronize, changes in the data s...
virtual QgsRectangle extent() const =0
Returns the extent of the layer.
virtual void setTransformContext(const QgsCoordinateTransformContext &transformContext)
Sets data coordinate transform context to transformContext.
void setVariable(const QString &name, const QVariant &value, bool isStatic=false)
Convenience method for setting a variable in the context scope by name name and value.
static QgsExpressionContextScope * meshExpressionScope(QgsMesh::ElementType elementType)
Creates a new scope which contains functions relating to mesh layer element elementType.
Expression contexts are used to encapsulate the parameters around which a QgsExpression should be eva...
QgsExpressionContextScope * lastScope()
Returns the last scope added to the context.
void appendScope(QgsExpressionContextScope *scope)
Appends a scope to the end of the context.
Class for parsing and evaluation of expressions (formerly called "search strings").
bool prepare(const QgsExpressionContext *context)
Gets the expression ready for evaluation - find out column indexes.
QVariant evaluate()
Evaluate the feature and return the result.
static QgsColorRamp * create(const QVariantMap &properties=QVariantMap())
Creates a new QgsColorRamp from a map of properties.
Class defining color to render mesh datasets.
Represents a simple line renderer with width and color varying depending on values.
Represents a width than can vary depending on values.
void setMaximumValue(double maximumValue)
Sets the maximum value used to defined the variable width.
void setMinimumValue(double minimumValue)
Sets the minimum value used to defined the variable width.
A representation of the interval between two datetime values.
Definition qgsinterval.h:46
double seconds() const
Returns the interval duration in seconds.
Class for metadata formatter.
Base class for storage of map layer elevation properties.
static QString typeToString(Qgis::LayerType type)
Converts a map layer type to a string value.
static QgsMapLayerLegend * defaultMeshLegend(QgsMeshLayer *ml)
Create new legend implementation for mesh layer.
Base class for utility classes that encapsulate information necessary for rendering of map layers.
Base class for storage of map layer temporal properties.
virtual void setDefaultsFromDataProviderTemporalCapabilities(const QgsDataProviderTemporalCapabilities *capabilities)=0
Sets the layers temporal settings to appropriate defaults based on a provider's temporal capabilities...
Base class for all map layer types.
Definition qgsmaplayer.h:76
QString name
Definition qgsmaplayer.h:80
virtual bool isSpatial() const
Returns true if the layer is considered a spatial layer, ie it has some form of geometry associated w...
void editingStopped()
Emitted when edited changes have been successfully written to the data provider.
QString source() const
Returns the source for the layer.
QString providerType() const
Returns the provider type (provider key) for this layer.
void setBlendMode(QPainter::CompositionMode blendMode)
Set the blending mode used for rendering a layer.
void trigger3DUpdate()
Will advise any 3D maps that this layer requires to be updated in the scene.
static Qgis::DataProviderReadFlags providerReadFlags(const QDomNode &layerNode, QgsMapLayer::ReadFlags layerReadFlags)
Returns provider read flag deduced from layer read flags layerReadFlags and a dom node layerNode that...
QgsMapLayer::LayerFlags flags() const
Returns the flags for this layer.
void editingStarted()
Emitted when editing on this layer has started.
virtual QString loadDefaultStyle(bool &resultFlag)
Retrieve the default style for this layer if one exists (either as a .qml file on disk or as a record...
QString mLayerName
Name of the layer - used for display.
void triggerRepaint(bool deferredUpdate=false)
Will advise the map canvas (and any other interested party) that this layer requires to be repainted.
QString crsHtmlMetadata() const
Returns a HTML fragment containing the layer's CRS metadata, for use in the htmlMetadata() method.
QgsLayerMetadata metadata
Definition qgsmaplayer.h:82
Qgis::LayerType type
Definition qgsmaplayer.h:86
QPainter::CompositionMode blendMode() const
Returns the current blending mode for a layer.
virtual void setOpacity(double opacity)
Sets the opacity for the layer, where opacity is a value between 0 (totally transparent) and 1....
QFlags< StyleCategory > StyleCategories
QString mProviderKey
Data provider key (name of the data provider)
QgsCoordinateTransformContext transformContext() const
Returns the layer data provider coordinate transform context or a default transform context if the la...
std::unique_ptr< QgsDataProvider > mPreloadedProvider
Optionally used when loading a project, it is released when the layer is effectively created.
void rendererChanged()
Signal emitted when renderer is changed.
virtual QgsError error() const
Gets current status error.
void dataSourceChanged()
Emitted whenever the layer's data source has been changed.
void emitStyleChanged()
Triggers an emission of the styleChanged() signal.
void dataChanged()
Data of layer changed.
virtual QgsMapLayer * clone() const =0
Returns a new instance equivalent to this one except for the id which is still unique.
QString mDataSource
Data source description string, varies by layer type.
@ FlagDontResolveLayers
Don't resolve layer paths or create data providers for layers.
void setValid(bool valid)
Sets whether layer is valid or not.
void readCommonStyle(const QDomElement &layerElement, const QgsReadWriteContext &context, StyleCategories categories=AllStyleCategories)
Read style data common to all layer types.
QgsMapLayer::ReadFlags mReadFlags
Read flags. It's up to the subclass to respect these when restoring state from XML.
void setLegend(QgsMapLayerLegend *legend)
Assign a legend controller to the map layer.
double opacity
Definition qgsmaplayer.h:88
@ Rendering
Rendering: scale visibility, simplify method, opacity.
@ Labeling
Labeling.
void layerModified()
Emitted when modifications has been done on layer.
void setProviderType(const QString &providerType)
Sets the providerType (provider key)
QString customPropertyHtmlMetadata() const
Returns an HTML fragment containing custom property information, for use in the htmlMetadata() method...
QString generalHtmlMetadata() const
Returns an HTML fragment containing general metadata information, for use in the htmlMetadata() metho...
void writeCommonStyle(QDomElement &layerElement, QDomDocument &document, const QgsReadWriteContext &context, StyleCategories categories=AllStyleCategories) const
Write style data common to all layer types.
void invalidateWgs84Extent()
Invalidates the WGS84 extent.
bool mShouldValidateCrs
true if the layer's CRS should be validated and invalid CRSes are not permitted.
void setCrs(const QgsCoordinateReferenceSystem &srs, bool emitSignal=true)
Sets layer's spatial reference system.
Abstract class to interpolate 3d stacked mesh data to 2d data.
QgsMeshDataBlock calculate(const QgsMesh3DDataBlock &block3d, QgsFeedback *feedback=nullptr) const
Calculated 2d block values from 3d stacked mesh values.
QgsMesh3DDataBlock is a block of 3d stacked mesh data related N faces defined on base mesh frame.
QgsMeshDataBlock is a block of integers/doubles that can be used to retrieve: active flags (e....
QgsMeshDatasetValue value(int index) const
Returns a value represented by the index For active flag the behavior is undefined.
bool isValid() const
Whether the block is valid.
QDateTime referenceTime() const
Returns the reference time.
Qgis::TemporalUnit temporalUnit() const
Returns the temporal unit used to read data by the data provider.
MatchingTemporalDatasetMethod
Method for selection of temporal mesh dataset from a range time.
qint64 firstTimeStepDuration(int group) const
Returns the duration of the first time step of the dataset group with index group.
Base class for providing data for QgsMeshLayer.
virtual QgsMeshDriverMetadata driverMetadata() const
Returns the mesh driver metadata of the provider.
void setTemporalUnit(Qgis::TemporalUnit unit)
Sets the temporal unit of the provider and reload data if it changes.
QgsMeshDataProviderTemporalCapabilities * temporalCapabilities() override
Returns the provider's temporal capabilities.
virtual void close()=0
Closes the data provider and free every resources used.
virtual int vertexCount() const =0
Returns number of vertices in the native mesh.
virtual void populateMesh(QgsMesh *mesh) const =0
Populates the mesh vertices, edges and faces.
virtual bool saveMeshFrame(const QgsMesh &mesh)=0
Saves the mesh frame to the source.
virtual int edgeCount() const =0
Returns number of edges in the native mesh.
virtual int faceCount() const =0
Returns number of faces in the native mesh.
QgsMeshDatasetGroupMetadata is a collection of dataset group metadata such as whether the data is vec...
QMap< QString, QString > extraOptions() const
Returns extra metadata options, for example description.
bool isVector() const
Returns whether dataset group has vector data.
DataType dataType() const
Returns whether dataset group data is defined on vertices or faces or volumes.
double minimum() const
Returns minimum scalar value/vector magnitude present for whole dataset group.
double maximum() const
Returns maximum scalar value/vector magnitude present for whole dataset group.
DataType
Location of where data is specified for datasets in the dataset group.
@ DataOnEdges
Data is defined on edges.
@ DataOnFaces
Data is defined on faces.
@ DataOnVertices
Data is defined on vertices.
@ DataOnVolumes
Data is defined on volumes.
QString uri() const
Returns the uri of the source.
Class used to register and access all the dataset groups related to a mesh layer.
void datasetGroupsAdded(QList< int > indexes)
Emitted after dataset groups are added.
Tree item for display of the mesh dataset groups.
QgsMeshDatasetGroupTreeItem * childFromDatasetGroupIndex(int index)
Returns the child with dataset group index Searches as depper as needed on the child hierarchy.
QgsMeshDatasetGroupTreeItem * child(int row) const
Returns a child.
Abstract class that represents a dataset group.
QgsMeshDatasetIndex is index that identifies the dataset group (e.g.
bool isValid() const
Returns whether index is valid, ie at least groups is set.
int group() const
Returns a group index.
int dataset() const
Returns a dataset index within group()
QgsMeshDatasetMetadata is a collection of mesh dataset metadata such as whether the data is valid or ...
virtual int datasetGroupCount() const =0
Returns number of datasets groups loaded.
virtual QStringList extraDatasets() const =0
Returns list of additional dataset file URIs added using addDataset() calls.
QgsMeshDatasetValue represents single dataset value.
double y() const
Returns y value.
double x() const
Returns x value.
Holds metadata about mesh driver.
@ CanWriteMeshData
If the driver can write mesh data on file.
MeshDriverCapabilities capabilities() const
Returns the capabilities for this driver.
Class that represents an error during mesh editing.
Qgis::MeshEditingErrorType errorType
Class that makes edit operation on a mesh.
QgsMeshEditingError initialize()
Initializes the mesh editor and returns first error if the internal native mesh has topological error...
int validFacesCount() const
Returns the count of valid faces, that is non void faces in the mesh.
bool checkConsistency(QgsMeshEditingError &error) const
Return true if the edited mesh is consistent.
QgsRectangle extent() const
Returns the extent of the edited mesh.
QgsMeshEditingError initializeWithErrorsFix()
Initializes the mesh editor.
int maximumVerticesPerFace() const
Returns the maximum count of vertices per face that the mesh can support.
void stopEditing()
Stops editing.
void meshEdited()
Emitted when the mesh is edited.
void resetTriangularMesh(QgsTriangularMesh *triangularMesh)
Resets the triangular mesh.
bool isModified() const
Returns whether the mesh has been modified.
int validVerticesCount() const
Returns the count of valid vertices, that is non void vertices in the mesh.
bool reindex(bool renumbering)
Reindexes the mesh, that is remove unusued index of face and vertices, this operation void the undo/r...
QgsMeshDatasetGroup * createZValueDatasetGroup()
Creates and returns a scalar dataset group with value on vertex that is can be used to access the Z v...
Mesh layer specific subclass of QgsMapLayerElevationProperties.
QgsMeshLayerElevationProperties * clone() const override
Creates a clone of the properties.
Implementation of QgsAbstractProfileGenerator for mesh layers.
Implementation of threaded rendering for mesh layers.
Implementation of map layer temporal properties for mesh layers.
QDateTime referenceTime() const
Returns the reference time.
bool isValid() const
Returns whether the instance is valid.
void setMatchingMethod(const QgsMeshDataProviderTemporalCapabilities::MatchingTemporalDatasetMethod &matchingMethod)
Sets the method used to match dataset from temporal capabilities.
QgsMeshDataProviderTemporalCapabilities::MatchingTemporalDatasetMethod matchingMethod() const
Returns the method used to match dataset from temporal capabilities.
void setReferenceTime(const QDateTime &referenceTime, const QgsDataProviderTemporalCapabilities *capabilities)
Sets the reference time and update the time extent from the temporal capabilities,...
void setDefaultsFromDataProviderTemporalCapabilities(const QgsDataProviderTemporalCapabilities *capabilities) override
Sets the layers temporal settings to appropriate defaults based on a provider's temporal capabilities...
bool alwaysLoadReferenceTimeFromSource() const
Returns whether the time proporties are automatically reloaded from provider when project is opened o...
QgsDateTimeRange timeExtent() const
Returns the time extent.
Represents a mesh layer supporting display of data on structured or unstructured meshes.
~QgsMeshLayer() override
QList< int > selectVerticesByExpression(QgsExpression expression)
Returns a list of vertex indexes that meet the condition defined by expression with the context expre...
void setMeshSimplificationSettings(const QgsMeshSimplificationSettings &meshSimplificationSettings)
Sets mesh simplification settings.
int datasetCount(const QgsMeshDatasetIndex &index) const
Returns the dataset count in the dataset groups.
QList< int > datasetGroupsIndexes() const
Returns the list of indexes of dataset groups handled by the layer.
void stopFrameEditing(const QgsCoordinateTransform &transform)
Stops editing of the mesh, re-indexes the faces and vertices, rebuilds the triangular mesh and its sp...
QgsRectangle extent() const override
Returns the extent of the layer.
void setStaticVectorDatasetIndex(const QgsMeshDatasetIndex &staticVectorDatasetIndex)
Sets the static vector dataset index that is rendered if the temporal properties is not active.
void setStaticScalarDatasetIndex(const QgsMeshDatasetIndex &staticScalarDatasetIndex)
Sets the static scalar dataset index that is rendered if the temporal properties is not active.
bool contains(const QgsMesh::ElementType &type) const
Returns whether the mesh contains at mesh elements of given type.
QgsMeshRendererSettings rendererSettings() const
Returns renderer settings.
QgsMeshDatasetIndex activeScalarDatasetIndex(QgsRenderContext &rendererContext)
Returns current active scalar dataset index for current renderer context.
QgsMeshDatasetIndex activeVectorDatasetAtTime(const QgsDateTimeRange &timeRange, int group=-1) const
Returns dataset index from active vector group depending on the time range If the temporal properties...
QList< QgsMeshDatasetIndex > datasetIndexInRelativeTimeInterval(const QgsInterval &startRelativeTime, const QgsInterval &endRelativeTime, int datasetGroupIndex) const
Returns a list of dataset indexes from datasets group that are in a interval time from the layer refe...
void activeScalarDatasetGroupChanged(int index)
Emitted when active scalar group dataset is changed.
int datasetGroupCount() const
Returns the dataset groups count handle by the layer.
void updateTriangularMesh(const QgsCoordinateTransform &transform=QgsCoordinateTransform())
Gets native mesh and updates (creates if it doesn't exist) the base triangular mesh.
bool addDatasets(const QString &path, const QDateTime &defaultReferenceTime=QDateTime())
Adds datasets to the mesh from file with path.
bool isModified() const override
Returns whether the mesh frame has been modified since the last save.
void activeVectorDatasetGroupChanged(int index)
Emitted when active vector group dataset is changed.
void reload() override
Synchronises with changes in the datasource.
QgsPointXY snapOnElement(QgsMesh::ElementType elementType, const QgsPointXY &point, double searchRadius)
Returns the position of the snapped point on the mesh element closest to point intersecting with the ...
bool readXml(const QDomNode &layer_node, QgsReadWriteContext &context) override
Called by readLayerXML(), used by children to read state specific to them from project files.
QStringList subLayers() const override
Returns the sublayers of this layer.
QgsMeshEditor * meshEditor()
Returns a pointer to the mesh editor own by the mesh layer.
const QgsAbstractMeshLayerLabeling * labeling() const
Access to const labeling configuration.
void setDatasetGroupTreeRootItem(QgsMeshDatasetGroupTreeItem *rootItem)
Sets the root items of the dataset group tree item.
QgsMeshDatasetValue dataset1dValue(const QgsMeshDatasetIndex &index, const QgsPointXY &point, double searchRadius) const
Returns the value of 1D mesh dataset defined on edge that are in the search area defined by point ans...
QgsMeshDatasetIndex staticVectorDatasetIndex(int group=-1) const
Returns the static vector dataset index that is rendered if the temporal properties is not active.
QgsMesh * nativeMesh()
Returns native mesh (nullptr before rendering or calling to updateMesh)
QString loadDefaultStyle(bool &resultFlag) FINAL
Retrieve the default style for this layer if one exists (either as a .qml file on disk or as a record...
bool minimumMaximumActiveScalarDataset(const QgsRectangle &extent, const QgsMeshDatasetIndex &datasetIndex, double &min, double &max)
Extracts minimum and maximum value for active scalar dataset on mesh faces.
QgsTriangularMesh * triangularMeshByLodIndex(int lodIndex) const
Returns triangular corresponding to the index of level of details.
QString htmlMetadata() const override
Obtain a formatted HTML string containing assorted metadata for this layer.
int meshFaceCount() const
Returns the faces count of the mesh frame.
QList< int > selectFacesByExpression(QgsExpression expression)
Returns a list of faces indexes that meet the condition defined by expression with the context expres...
void setRendererSettings(const QgsMeshRendererSettings &settings, const bool repaint=true)
Sets new renderer settings.
QgsMapLayerElevationProperties * elevationProperties() override
Returns the layer's elevation properties.
QgsMeshLayer * clone() const override
Returns a new instance equivalent to this one except for the id which is still unique.
void timeSettingsChanged()
Emitted when time format is changed.
QList< int > enabledDatasetGroupsIndexes() const
Returns the list of indexes of enables dataset groups handled by the layer.
void resetDatasetGroupTreeItem()
Reset the dataset group tree item to default from provider.
int triangularMeshLevelOfDetailCount() const
Returns the count of levels of detail of the mesh simplification.
bool rollBackFrameEditing(const QgsCoordinateTransform &transform, bool continueEditing=true)
Rolls Back editing of the mesh frame.
QString encodedSource(const QString &source, const QgsReadWriteContext &context) const override
Called by writeLayerXML(), used by derived classes to encode provider's specific data source to proje...
QgsMeshDatasetIndex datasetIndexAtRelativeTime(const QgsInterval &relativeTime, int datasetGroupIndex) const
Returns dataset index from datasets group depending on the relative time from the layer reference tim...
bool writeXml(QDomNode &layer_node, QDomDocument &doc, const QgsReadWriteContext &context) const override
Called by writeLayerXML(), used by children to write state specific to them to project files.
bool commitFrameEditing(const QgsCoordinateTransform &transform, bool continueEditing=true)
Commits editing of the mesh frame, Rebuilds the triangular mesh and its spatial index with transform,...
QgsAbstractProfileGenerator * createProfileGenerator(const QgsProfileRequest &request) override
Given a profile request, returns a new profile generator ready for generating elevation profiles.
QgsMeshDataBlock datasetValues(const QgsMeshDatasetIndex &index, int valueIndex, int count) const
Returns N vector/scalar values from the index from the dataset.
bool writeStyle(QDomNode &node, QDomDocument &doc, QString &errorMessage, const QgsReadWriteContext &context, StyleCategories categories=AllStyleCategories) const override
Write just the symbology information for the layer into the document.
void setLabeling(QgsAbstractMeshLayerLabeling *labeling)
Sets labeling configuration.
void setTransformContext(const QgsCoordinateTransformContext &transformContext) override
Sets the coordinate transform context to transformContext.
int meshEdgeCount() const
Returns the edges count of the mesh frame.
QgsMeshSimplificationSettings meshSimplificationSettings() const
Returns mesh simplification settings.
QgsMapLayerRenderer * createMapRenderer(QgsRenderContext &rendererContext) override
Returns new instance of QgsMapLayerRenderer that will be used for rendering of given context.
bool isEditable() const override
Returns true if the layer can be edited.
QgsMeshDataBlock areFacesActive(const QgsMeshDatasetIndex &index, int faceIndex, int count) const
Returns whether the faces are active for particular dataset.
void setLabelsEnabled(bool enabled)
Sets whether labels should be enabled for the layer.
bool isFaceActive(const QgsMeshDatasetIndex &index, int faceIndex) const
Returns N vector/scalar values from the face index from the dataset for 3d stacked meshes.
QgsMeshDatasetMetadata datasetMetadata(const QgsMeshDatasetIndex &index) const
Returns the dataset metadata.
bool saveDataset(const QString &path, int datasetGroupIndex, QString driver)
Saves datasets group on file with the specified driver.
bool supportsEditing() const override
Returns whether the layer supports editing or not.
QgsMeshDataProvider * dataProvider() override
Returns the layer's data provider, it may be nullptr.
QgsInterval firstValidTimeStep() const
Returns the first valid time step of the dataset groups, invalid QgInterval if no time step is presen...
QgsInterval datasetRelativeTime(const QgsMeshDatasetIndex &index)
Returns the relative time of the dataset from the reference time of its group.
QgsMeshDatasetIndex datasetIndexAtTime(const QgsDateTimeRange &timeRange, int datasetGroupIndex) const
Returns dataset index from datasets group depending on the time range.
Q_DECL_DEPRECATED bool startFrameEditing(const QgsCoordinateTransform &transform)
Starts editing of the mesh frame.
bool reindex(const QgsCoordinateTransform &transform, bool renumber)
Re-indexes the faces and vertices, and renumber the indexes if renumber is true.
QgsMeshDatasetValue datasetValue(const QgsMeshDatasetIndex &index, int valueIndex) const
Returns vector/scalar value associated with the index from the dataset To read multiple continuous va...
QgsMeshTimeSettings timeSettings() const
Returns time format settings.
QgsMapLayerTemporalProperties * temporalProperties() override
Returns the layer's temporal properties.
bool writeSymbology(QDomNode &node, QDomDocument &doc, QString &errorMessage, const QgsReadWriteContext &context, QgsMapLayer::StyleCategories categories=QgsMapLayer::AllStyleCategories) const override
Write the style for the layer into the document provided.
int meshVertexCount() const
Returns the vertices count of the mesh frame.
bool labelsEnabled() const
Returns whether the layer contains labels which are enabled and should be drawn.
void setReferenceTime(const QDateTime &referenceTime)
Sets the reference time of the layer.
bool readStyle(const QDomNode &node, QString &errorMessage, QgsReadWriteContext &context, StyleCategories categories=AllStyleCategories) override
Read the style for the current layer from the DOM node supplied.
int extraDatasetGroupCount() const
Returns the extra dataset groups count handle by the layer.
bool datasetsPathUnique(const QString &path)
Checks whether that datasets path is already added to this mesh layer.
qint64 datasetRelativeTimeInMilliseconds(const QgsMeshDatasetIndex &index)
Returns the relative time (in milliseconds) of the dataset from the reference time of its group.
QgsMeshDatasetIndex activeScalarDatasetAtTime(const QgsDateTimeRange &timeRange, int group=-1) const
Returns dataset index from active scalar group depending on the time range.
QgsTriangularMesh * triangularMesh(double minimumTriangleSize=0) const
Returns triangular mesh (nullptr before rendering or calling to updateMesh).
QgsMeshDatasetIndex staticScalarDatasetIndex(int group=-1) const
Returns the static scalar dataset index that is rendered if the temporal properties is not active.
void setTemporalMatchingMethod(const QgsMeshDataProviderTemporalCapabilities::MatchingTemporalDatasetMethod &matchingMethod)
Sets the method used to match the temporal dataset from a requested time, see activeVectorDatasetAtTi...
bool removeDatasets(const QString &name)
Removes datasets from the mesh with given name.
QgsMeshDatasetGroupTreeItem * datasetGroupTreeRootItem() const
Returns the root items of the dataset group tree item.
QgsMesh3DDataBlock dataset3dValues(const QgsMeshDatasetIndex &index, int faceIndex, int count) const
Returns N vector/scalar values from the face index from the dataset for 3d stacked meshes.
QgsMesh3DDataBlock dataset3dValue(const QgsMeshDatasetIndex &index, const QgsPointXY &point) const
Returns the 3d values of stacked 3d mesh defined by the given point.
bool readSymbology(const QDomNode &node, QString &errorMessage, QgsReadWriteContext &context, QgsMapLayer::StyleCategories categories=QgsMapLayer::AllStyleCategories) override
Read the symbology for the current layer from the DOM node supplied.
QString decodedSource(const QString &source, const QString &provider, const QgsReadWriteContext &context) const override
Called by readLayerXML(), used by derived classes to decode provider's specific data source from proj...
void reloaded()
Emitted when the mesh layer is reloaded, see reload()
QString formatTime(double hours)
Returns (date) time in hours formatted to human readable form.
QgsMeshDatasetGroupMetadata datasetGroupMetadata(const QgsMeshDatasetIndex &index) const
Returns the dataset groups metadata.
QgsMeshLayerRendererCache * rendererCache()
Returns native mesh (nullptr before rendering)
void setTimeSettings(const QgsMeshTimeSettings &settings)
Sets time format settings.
QgsMeshLayer(const QString &path=QString(), const QString &baseName=QString(), const QString &providerLib=QStringLiteral("mesh_memory"), const QgsMeshLayer::LayerOptions &options=QgsMeshLayer::LayerOptions())
Constructor - creates a mesh layer.
Represents a mesh renderer settings for mesh object.
void setEnabled(bool enabled)
Sets whether mesh structure rendering is enabled.
Represents a mesh renderer settings for scalar datasets.
void setClassificationMinimumMaximum(double minimum, double maximum)
Sets min/max values used for creation of the color ramp shader.
void setColorRampShader(const QgsColorRampShader &shader)
Sets color ramp shader function.
QgsColorRampShader colorRampShader() const
Returns color ramp shader function.
@ NoResampling
Does not use resampling.
@ NeighbourAverage
Does a simple average of values defined for all surrounding faces/vertices.
void setEdgeStrokeWidth(const QgsInterpolatedLineWidth &strokeWidth)
Sets the stroke width used to render edges scalar dataset.
void setDataResamplingMethod(const DataResamplingMethod &dataResamplingMethod)
Sets data interpolation method.
Represents all mesh renderer settings.
void setActiveVectorDatasetGroup(int activeVectorDatasetGroup)
Sets the active vector dataset group.
QgsMeshRendererScalarSettings scalarSettings(int groupIndex) const
Returns renderer settings.
int activeVectorDatasetGroup() const
Returns the active vector dataset group.
bool hasVectorSettings(int groupIndex) const
Returns whether groupIndex has existing vector settings.
QgsMesh3DAveragingMethod * averagingMethod() const
Returns averaging method for conversion of 3d stacked mesh data to 2d data.
bool removeVectorSettings(int groupIndex)
Removes vector settings for groupIndex.
bool hasSettings(int datasetGroupIndex) const
Returns whether the group with index has render settings (scalar or vector)
int activeScalarDatasetGroup() const
Returns the active scalar dataset group.
QgsMeshRendererVectorSettings vectorSettings(int groupIndex) const
Returns renderer settings.
void setActiveScalarDatasetGroup(int activeScalarDatasetGroup)
Sets the active scalar dataset group.
void readXml(const QDomElement &elem, const QgsReadWriteContext &context=QgsReadWriteContext())
Reads configuration from the given DOM element.
void setVectorSettings(int groupIndex, const QgsMeshRendererVectorSettings &settings)
Sets new renderer settings.
QDomElement writeXml(QDomDocument &doc, const QgsReadWriteContext &context=QgsReadWriteContext()) const
Writes configuration to a new DOM element.
bool removeScalarSettings(int groupIndex)
Removes scalar settings with groupIndex.
void setScalarSettings(int groupIndex, const QgsMeshRendererScalarSettings &settings)
Sets new renderer settings.
void setNativeMeshSettings(const QgsMeshRendererMeshSettings &settings)
Sets new native mesh renderer settings, triggers repaint.
Represents a renderer settings for vector datasets.
void setColorRampShader(const QgsColorRampShader &colorRampShader)
Returns the color ramp shader used to render vector datasets.
Represents an overview renderer settings.
QDomElement writeXml(QDomDocument &doc, const QgsReadWriteContext &context) const
Writes configuration to a new DOM element.
void setEnabled(bool isEnabled)
Sets if the overview is active.
double reductionFactor() const
Returns the reduction factor used to build simplified mesh.
bool isEnabled() const
Returns if the overview is active.
void readXml(const QDomElement &elem, const QgsReadWriteContext &context)
Reads configuration from the given DOM element.
Represents a mesh time settings for mesh datasets.
static void logMessage(const QString &message, const QString &tag=QString(), Qgis::MessageLevel level=Qgis::MessageLevel::Warning, bool notifyUser=true, const char *file=__builtin_FILE(), const char *function=__builtin_FUNCTION(), int line=__builtin_LINE())
Adds a message to the log instance (and creates it if necessary).
static Qgis::BlendMode getBlendModeEnum(QPainter::CompositionMode blendMode)
Returns a Qgis::BlendMode corresponding to a QPainter::CompositionMode.
static QPainter::CompositionMode getCompositionMode(Qgis::BlendMode blendMode)
Returns a QPainter::CompositionMode corresponding to a Qgis::BlendMode.
QString writePath(const QString &filename) const
Prepare a filename to save it to the project file.
QString readPath(const QString &filename) const
Turn filename read from the project file to an absolute path.
A class to represent a 2D point.
Definition qgspointxy.h:60
double distance(double x, double y) const
Returns the distance between this point and a specified x, y coordinate.
Definition qgspointxy.h:206
double y
Definition qgspointxy.h:64
double sqrDistToSegment(double x1, double y1, double x2, double y2, QgsPointXY &minDistPoint, double epsilon=DEFAULT_SEGMENT_EPSILON) const
Returns the minimum distance between this point and a segment.
double x
Definition qgspointxy.h:63
Point geometry type, with support for z-dimension and m-values.
Definition qgspoint.h:49
double x
Definition qgspoint.h:52
double distance(double x, double y) const
Returns the Cartesian 2D distance between this point and a specified x, y coordinate.
Definition qgspoint.h:393
double y
Definition qgspoint.h:53
Encapsulates properties and constraints relating to fetching elevation profiles from different source...
QString absoluteToRelativeUri(const QString &providerKey, const QString &uri, const QgsReadWriteContext &context) const
Converts absolute path(s) to relative path(s) in the given provider-specific URI.
static QgsProviderRegistry * instance(const QString &pluginPath=QString())
Means of accessing canonical single instance.
QString relativeToAbsoluteUri(const QString &providerKey, const QString &uri, const QgsReadWriteContext &context) const
Converts relative path(s) to absolute path(s) in the given provider-specific URI.
virtual void setMaximumValue(double value)
Sets the maximum value for the raster shader.
virtual void setMinimumValue(double value)
Sets the minimum value for the raster shader.
Allows entering a context category and takes care of leaving this category on deletion of the class.
The class is used as a container of context for various read/write operations on other objects.
MAYBE_UNUSED NODISCARD QgsReadWriteContextCategoryPopper enterCategory(const QString &category, const QString &details=QString()) const
Push a category to the stack.
const QgsPathResolver & pathResolver() const
Returns path resolver for conversion between relative and absolute paths.
A rectangle specified with double values.
Q_INVOKABLE QString toString(int precision=16) const
Returns a string representation of form xmin,ymin : xmax,ymax Coordinates will be truncated to the sp...
void setNull()
Mark a rectangle as being null (holding no spatial information).
Contains information about the context of a rendering operation.
QgsCoordinateTransform coordinateTransform() const
Returns the current coordinate transform for the context.
QgsColorRamp * colorRamp(const QString &name) const
Returns a new copy of the specified color ramp.
Definition qgsstyle.cpp:495
static QgsStyle * defaultStyle(bool initialize=true)
Returns the default application-wide style.
Definition qgsstyle.cpp:146
bool isActive() const
Returns true if the temporal property is active.
void setIsActive(bool active)
Sets whether the temporal property is active.
const QgsDateTimeRange & temporalRange() const
Returns the datetime range for the object.
bool isTemporal() const
Returns true if the object's temporal range is enabled, and the object will be filtered when renderin...
T begin() const
Returns the beginning of the range.
Definition qgsrange.h:446
static QgsMeshEditingError checkTopology(const QgsMesh &mesh, int maxVerticesPerFace)
Checks the topology of the mesh mesh, if error occurs, this mesh can't be edited.
Triangular/Derived Mesh is mesh with vertices in map coordinates.
const QVector< QgsMeshFace > & triangles() const
Returns triangles.
QList< int > edgeIndexesForRectangle(const QgsRectangle &rectangle) const
Finds indexes of edges intersecting given bounding box It uses spatial indexing.
const QVector< QgsMeshVertex > & vertices() const
Returns vertices in map coordinate system.
const QVector< QgsMeshEdge > & edges() const
Returns edges.
bool contains(const QgsMesh::ElementType &type) const
Returns whether the mesh contains mesh elements of given type.
const QVector< int > & trianglesToNativeFaces() const
Returns mapping between triangles and original faces.
QList< int > faceIndexesForRectangle(const QgsRectangle &rectangle) const
Finds indexes of triangles intersecting given bounding box It uses spatial indexing.
int faceIndexForPoint_v2(const QgsPointXY &point) const
Finds index of triangle at given point It uses spatial indexing and don't use geos to be faster.
#define QgsDebugMsgLevel(str, level)
Definition qgslogger.h:41
QVector< int > QgsMeshFace
List of vertex indexes.
QPair< int, int > QgsMeshEdge
Edge is a straight line seqment between 2 points.
#define QGIS_PROTECT_QOBJECT_THREAD_ACCESS
Setting options for creating vector data providers.
Setting options for loading mesh layers.
QgsCoordinateTransformContext transformContext
Coordinate transform context.
bool loadDefaultStyle
Set to true if the default layer style should be loaded.
bool skipCrsValidation
Controls whether the layer is allowed to have an invalid/unknown CRS.
Mesh - vertices, edges and faces.
ElementType
Defines type of mesh elements.