-
-
Notifications
You must be signed in to change notification settings - Fork 3k
/
qgsmeshdataset.h
1018 lines (852 loc) · 29.1 KB
/
qgsmeshdataset.h
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
/***************************************************************************
qgsmeshdataset.h
---------------------
begin : April 2018
copyright : (C) 2018 by Peter Petrik
email : zilolv at gmail dot com
***************************************************************************/
/***************************************************************************
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation; either version 2 of the License, or *
* (at your option) any later version. *
* *
***************************************************************************/
#ifndef QGSMESHDATASET_H
#define QGSMESHDATASET_H
#include <QVector>
#include <QString>
#include <QMap>
#include <QPair>
#include <limits>
#include "qgis_core.h"
#include "qgspoint.h"
#include "qgsdataprovider.h"
class QgsMeshLayer;
class QgsMeshDatasetGroup;
class QgsRectangle;
/**
* \ingroup core
*
* \brief QgsMeshDatasetIndex is index that identifies the dataset group (e.g. wind speed)
* and a dataset in this group (e.g. magnitude of wind speed in particular time)
*
* \note The API is considered EXPERIMENTAL and can be changed without a notice
*
* \since QGIS 3.4
*/
class CORE_EXPORT QgsMeshDatasetIndex
{
public:
//! Creates an index. -1 represents invalid group/dataset
QgsMeshDatasetIndex( int group = -1, int dataset = -1 );
//! Returns a group index
int group() const;
//! Returns a dataset index within group()
int dataset() const;
//! Returns whether index is valid, ie at least groups is set
bool isValid() const;
//! Equality operator
bool operator == ( QgsMeshDatasetIndex other ) const;
//! Inequality operator
bool operator != ( QgsMeshDatasetIndex other ) const;
private:
int mGroupIndex = -1;
int mDatasetIndex = -1;
};
/**
* \ingroup core
*
* \brief QgsMeshDatasetValue represents single dataset value.
*
* Values may be scalar or vector. Nodata values are represented by NaNs.
*
* \note The API is considered EXPERIMENTAL and can be changed without a notice
*
* \since QGIS 3.2
*/
class CORE_EXPORT QgsMeshDatasetValue
{
public:
//! Constructor for vector value
QgsMeshDatasetValue( double x,
double y );
//! Constructor for scalar value
QgsMeshDatasetValue( double scalar );
//! Default Ctor, initialize to NaN
QgsMeshDatasetValue() = default;
//! Dtor
~QgsMeshDatasetValue() = default;
//! Sets scalar value
void set( double scalar );
//! Sets X value
void setX( double x );
//! Sets Y value
void setY( double y ) ;
//! Returns magnitude of vector for vector data or scalar value for scalar data
double scalar() const;
//! Returns x value
double x() const;
//! Returns y value
double y() const;
bool operator==( QgsMeshDatasetValue other ) const;
private:
double mX = std::numeric_limits<double>::quiet_NaN();
double mY = std::numeric_limits<double>::quiet_NaN();
};
/**
* \ingroup core
*
* \brief QgsMeshDataBlock is a block of integers/doubles that can be used
* to retrieve:
* active flags (e.g. face's active integer flag)
* scalars (e.g. scalar dataset double values)
* vectors (e.g. vector dataset doubles x,y values)
*
* data are implicitly shared, so the class can be quickly copied
* std::numeric_limits<double>::quiet_NaN() represents NODATA value
*
* Data can be accessed all at once with values() (faster) or
* value by value (slower) with active() or value()
*
* \since QGIS 3.6
*/
class CORE_EXPORT QgsMeshDataBlock
{
public:
//! Type of data stored in the block
enum DataType
{
ActiveFlagInteger, //!< Integer boolean flag whether face is active
ScalarDouble, //!< Scalar double values
Vector2DDouble, //!< Vector double pairs (x1, y1, x2, y2, ... )
};
//! Constructs an invalid block
QgsMeshDataBlock();
//! Constructs a new block
QgsMeshDataBlock( DataType type, int count );
//! Type of data stored in the block
DataType type() const;
//! Number of items stored in the block
int count() const;
//! Whether the block is valid
bool isValid() const;
/**
* Returns a value represented by the index
* For active flag the behavior is undefined
*/
QgsMeshDatasetValue value( int index ) const;
/**
* Returns a value for active flag by the index
* For scalar and vector 2d the behavior is undefined
*/
bool active( int index ) const;
/**
* Sets active flag values.
*
* If the data provider/datasets does not have active
* flag capability (== all values are valid), just
* set block validity by setValid( TRUE )
*
* \param vals value vector with size count()
*
* For scalar and vector 2d the behavior is undefined
*
* \since QGIS 3.12
*/
void setActive( const QVector<int> &vals );
/**
* Returns active flag array
*
* Even for active flag valid dataset, the returned array could be empty.
* This means that the data provider/dataset does not support active flag
* capability, so all faces are active by default.
*
* For scalar and vector 2d the behavior is undefined
*
* \since QGIS 3.12
*/
QVector<int> active() const;
/**
* Returns buffer to the array with values
* For vector it is pairs (x1, y1, x2, y2, ... )
*
* \since QGIS 3.12
*/
QVector<double> values() const;
/**
* Sets values
*
* For scalar datasets, it must have size count()
* For vector datasets, it must have size 2 * count()
* For active flag the behavior is undefined
*
* \since QGIS 3.12
*/
void setValues( const QVector<double> &vals );
//! Sets block validity
void setValid( bool valid );
private:
QVector<double> mDoubleBuffer;
QVector<int> mIntegerBuffer;
DataType mType;
int mSize = 0;
bool mIsValid = false;
};
/**
* \ingroup core
*
* \brief QgsMesh3dDataBlock is a block of 3d stacked mesh data related N
* faces defined on base mesh frame.
*
* Data are implicitly shared, so the class can be quickly copied
* std::numeric_limits<double>::quiet_NaN() represents NODATA value
*
* \note The API is considered EXPERIMENTAL and can be changed without a notice
*
* \since QGIS 3.12
*/
class CORE_EXPORT QgsMesh3dDataBlock
{
public:
//! Constructs an invalid block
QgsMesh3dDataBlock();
//! Dtor
~QgsMesh3dDataBlock();
//! Constructs a new block for count faces
QgsMesh3dDataBlock( int count, bool isVector );
//! Sets block validity
void setValid( bool valid );
//! Whether the block is valid
bool isValid() const;
//! Whether we store vector values
bool isVector() const;
//! Number of 2d faces for which the volume data is stored in the block
int count() const;
//! Index of the first volume stored in the buffer (absolute)
int firstVolumeIndex() const;
//! Index of the last volume stored in the buffer (absolute)
int lastVolumeIndex() const;
//! Returns number of volumes stored in the buffer
int volumesCount() const;
/**
* Returns number of vertical level above 2d faces
*/
QVector<int> verticalLevelsCount() const;
/**
* Sets the vertical level counts
*/
void setVerticalLevelsCount( const QVector<int> &verticalLevelsCount );
/**
* Returns the vertical levels height
*/
QVector<double> verticalLevels() const;
/**
* Sets the vertical levels height
*/
void setVerticalLevels( const QVector<double> &verticalLevels );
/**
* Returns the indexing between faces and volumes
*/
QVector<int> faceToVolumeIndex() const;
/**
* Sets the indexing between faces and volumes
*/
void setFaceToVolumeIndex( const QVector<int> &faceToVolumeIndex );
/**
* Returns the values at volume centers
*
* For vector datasets the number of values is doubled (x1, y1, x2, y2, ... )
*/
QVector<double> values() const;
/**
* Returns the value at volume centers
*
* \param volumeIndex volume index relative to firstVolumeIndex()
* \returns value (scalar or vector)
*/
QgsMeshDatasetValue value( int volumeIndex ) const;
/**
* Sets the values at volume centers
*
* For vector datasets the number of values is doubled (x1, y1, x2, y2, ... )
*/
void setValues( const QVector<double> &doubleBuffer );
private:
int mSize = 0;
bool mIsValid = false;
bool mIsVector = false;
QVector<int> mVerticalLevelsCount;
QVector<double> mVerticalLevels;
QVector<int> mFaceToVolumeIndex;
QVector<double> mDoubleBuffer; // for scalar/vector values
};
/**
* \ingroup core
*
* \brief QgsMeshDatasetGroupMetadata is a collection of dataset group metadata
* such as whether the data is vector or scalar, name
*
* \note The API is considered EXPERIMENTAL and can be changed without a notice
*
* \since QGIS 3.4
*/
class CORE_EXPORT QgsMeshDatasetGroupMetadata
{
public:
//! Location of where data is specified for datasets in the dataset group
enum DataType
{
DataOnFaces = 0, //!< Data is defined on faces
DataOnVertices, //!< Data is defined on vertices
DataOnVolumes, //!< Data is defined on volumes \since QGIS 3.12
DataOnEdges //!< Data is defined on edges \since QGIS 3.14
};
//! Constructs an empty metadata object
QgsMeshDatasetGroupMetadata() = default;
/**
* Constructs a valid metadata object
*
* \param name name of the dataset group
* \param isScalar dataset contains scalar data, specifically the y-value of QgsMeshDatasetValue is NaN
* \param dataType where the data are defined on (vertices, faces or volumes)
* \param minimum minimum value (magnitude for vectors) present among all group's dataset values
* \param maximum maximum value (magnitude for vectors) present among all group's dataset values
* \param maximumVerticalLevels maximum number of vertical levels for 3d stacked meshes, 0 for 2d meshes
* \param referenceTime reference time of the dataset group
* \param isTemporal weither the dataset group is temporal (contains time-related dataset)
* \param extraOptions dataset's extra options stored by the provider. Usually contains the name, time value, time units, data file vendor, ...
* \param uri The uri of the dataset
*/
QgsMeshDatasetGroupMetadata( const QString &name,
const QString uri,
bool isScalar,
DataType dataType,
double minimum,
double maximum,
int maximumVerticalLevels,
const QDateTime &referenceTime,
bool isTemporal,
const QMap<QString, QString> &extraOptions );
/**
* Returns name of the dataset group
*/
QString name() const;
/**
* Returns the uri of the source
*
* \since QGIS 3.16
*/
QString uri() const;
/**
* Returns extra metadata options, for example description
*/
QMap<QString, QString> extraOptions() const;
/**
* \brief Returns whether dataset group has vector data
*/
bool isVector() const;
/**
* \brief Returns whether dataset group has scalar data
*/
bool isScalar() const;
/**
* \brief Returns whether the dataset group is temporal (contains time-related dataset)
*/
bool isTemporal() const;
/**
* Returns whether dataset group data is defined on vertices or faces or volumes
*
* \since QGIS 3.12
*/
DataType dataType() const;
/**
* \brief Returns minimum scalar value/vector magnitude present for whole dataset group
*/
double minimum() const;
/**
* \brief Returns maximum scalar value/vector magnitude present for whole dataset group
*/
double maximum() const;
/**
* Returns maximum number of vertical levels for 3d stacked meshes
*
* \since QGIS 3.12
*/
int maximumVerticalLevelsCount() const;
/**
* Returns the reference time
*
* \since QGIS 3.12
*/
QDateTime referenceTime() const;
private:
QString mName;
QString mUri;
bool mIsScalar = false;
DataType mDataType = DataType::DataOnFaces;
double mMinimumValue = std::numeric_limits<double>::quiet_NaN();
double mMaximumValue = std::numeric_limits<double>::quiet_NaN();
QMap<QString, QString> mExtraOptions;
int mMaximumVerticalLevelsCount = 0; // for 3d stacked meshes
QDateTime mReferenceTime;
bool mIsTemporal = false;
};
/**
* \ingroup core
*
* \brief QgsMeshDatasetMetadata is a collection of mesh dataset metadata such
* as whether the data is valid or associated time for the dataset
*
* \note The API is considered EXPERIMENTAL and can be changed without a notice
*
* \since QGIS 3.2
*/
class CORE_EXPORT QgsMeshDatasetMetadata
{
public:
//! Constructs an empty metadata object
QgsMeshDatasetMetadata() = default;
/**
* Constructs a valid metadata object
*
* \param time a time which this dataset represents in the dataset group
* \param isValid dataset is loadad and valid for fetching the data
* \param minimum minimum value (magnitude for vectors) present among dataset values
* \param maximum maximum value (magnitude for vectors) present among dataset values
* \param maximumVerticalLevels maximum number of vertical levels for 3d stacked meshes, 0 for 2d meshes
*/
QgsMeshDatasetMetadata( double time,
bool isValid,
double minimum,
double maximum,
int maximumVerticalLevels
);
/**
* Returns the time value for this dataset
*/
double time() const;
/**
* Returns whether dataset is valid
*/
bool isValid() const;
/**
* Returns minimum scalar value/vector magnitude present for the dataset
*/
double minimum() const;
/**
* Returns maximum scalar value/vector magnitude present for the dataset
*/
double maximum() const;
/**
* Returns maximum number of vertical levels for 3d stacked meshes
*
* \since QGIS 3.12
*/
int maximumVerticalLevelsCount() const;
private:
double mTime = std::numeric_limits<double>::quiet_NaN();
bool mIsValid = false;
double mMinimumValue = std::numeric_limits<double>::quiet_NaN();
double mMaximumValue = std::numeric_limits<double>::quiet_NaN();
int mMaximumVerticalLevelsCount = 0; // for 3d stacked meshes
};
/**
* \ingroup core
*
* \brief Abstract class that represents a dataset
*
* \since QGIS 3.16
*/
class CORE_EXPORT QgsMeshDataset
{
public:
//! Constructor
QgsMeshDataset() = default;
//! Destructor
virtual ~QgsMeshDataset() = default;
//! Returns the value with index \a valueIndex
virtual QgsMeshDatasetValue datasetValue( int valueIndex ) const = 0;
//! Returns \a count values from \a valueIndex
virtual QgsMeshDataBlock datasetValues( bool isScalar, int valueIndex, int count ) const = 0;
//! Returns whether faces are active
virtual QgsMeshDataBlock areFacesActive( int faceIndex, int count ) const = 0;
//! Returns whether the face is active
virtual bool isActive( int faceIndex ) const = 0;
//! Returns the metadata of the dataset
virtual QgsMeshDatasetMetadata metadata() const = 0;
//! Returns the values count
virtual int valuesCount() const = 0;
};
/**
* \ingroup core
*
* \brief Abstract class that represents a dataset group
*
* \since QGIS 3.16
*/
class CORE_EXPORT QgsMeshDatasetGroup
{
public:
/**
* Type of the dataset group
*
* \since QGIS 3.16
*/
enum Type
{
None, //! Generic type used for non typed dataset group
Persistent, //! Dataset group store in a file
Memory, //! Temporary dataset group in memory
Virtual, //! Virtual Dataset group defined by a formula
};
//! Default constructor
QgsMeshDatasetGroup() = default;
virtual ~QgsMeshDatasetGroup();
//! Constructor with the \a name of the dataset group
QgsMeshDatasetGroup( const QString &name );
//! Constructor with the \a name of the dataset group and the \a dataTYpe
QgsMeshDatasetGroup( const QString &name, QgsMeshDatasetGroupMetadata::DataType dataType );
//! Initialize the dataset group
virtual void initialize() = 0;
//! Returns the metadata of the dataset group
QgsMeshDatasetGroupMetadata groupMetadata() const;
//! Returns the metadata of the dataset with index \a datasetIndex
virtual QgsMeshDatasetMetadata datasetMetadata( int datasetIndex ) const = 0 ;
//! Returns the count of datasets in the group
virtual int datasetCount() const = 0;
//! Returns the dataset with \a index
virtual QgsMeshDataset *dataset( int index ) const = 0;
//! Returns the type of dataset group
virtual QgsMeshDatasetGroup::Type type() const = 0;
//! Returns the minimum value of the whole dataset group
double minimum() const;
//! Returns the maximum value of the whole dataset group
double maximum() const;
//! Overrides the minimum and the maximum value of the whole dataset group
void setMinimumMaximum( double min, double max );
//! Returns the name of the dataset group
QString name() const;
//! Sets the name of the dataset group
void setName( const QString &name );
//! Returns the data type of the dataset group
QgsMeshDatasetGroupMetadata::DataType dataType() const;
//! Sets the data type of the dataset group
void setDataType( const QgsMeshDatasetGroupMetadata::DataType &dataType );
//! Adds extra metadata to the group
void addExtraMetadata( QString key, QString value );
//! Returns all the extra metadata of the group
QMap<QString, QString> extraMetadata() const;
//! Returns whether the group contain scalar values
bool isScalar() const;
//! Sets whether the group contain scalar values
void setIsScalar( bool isScalar );
//! Returns whether all the datasets contain \a count values
bool checkValueCountPerDataset( int count ) const;
//! Calculates the statistics (minimum and maximum)
void calculateStatistic();
//! Returns the dataset group variable name which this dataset group depends on
virtual QStringList datasetGroupNamesDependentOn() const;
//! Write dataset group information in a DOM element
virtual QDomElement writeXml( QDomDocument &doc, const QgsReadWriteContext &context ) const = 0;
//! Returns some information about the dataset group
virtual QString description() const;
//! Sets the reference time of the dataset group
void setReferenceTime( const QDateTime &referenceTime );
protected:
QString mName;
QgsMeshDatasetGroupMetadata::DataType mDataType = QgsMeshDatasetGroupMetadata::DataOnVertices;
QMap<QString, QString> mMetadata;
bool mIsScalar = true;
private:
double mMinimum = std::numeric_limits<double>::quiet_NaN();
double mMaximum = std::numeric_limits<double>::quiet_NaN();
QDateTime mReferenceTime;
};
#ifndef SIP_RUN
/**
* \ingroup core
*
* \brief Class to store memory dataset.
*
* The QgsMeshDatasetValue objects and whether the faces are active are stored in QVector containers that are exposed for efficiency
*
* \since QGIS 3.16
*/
class CORE_EXPORT QgsMeshMemoryDataset: public QgsMeshDataset
{
public:
//! Constructor
QgsMeshMemoryDataset() = default;
QgsMeshDatasetValue datasetValue( int valueIndex ) const override;
QgsMeshDataBlock datasetValues( bool isScalar, int valueIndex, int count ) const override;
QgsMeshDataBlock areFacesActive( int faceIndex, int count ) const override;
QgsMeshDatasetMetadata metadata() const override;
bool isActive( int faceIndex ) const override;
int valuesCount() const override;
//! Calculates the minimum and the maximum of this group
void calculateMinMax();
QVector<QgsMeshDatasetValue> values;
QVector<int> active;
double time = -1;
bool valid = false;
double minimum = std::numeric_limits<double>::quiet_NaN();
double maximum = std::numeric_limits<double>::quiet_NaN();
};
/**
* \ingroup core
*
* \brief Class that represents a dataset group stored in memory.
*
* The QgsMeshMemoryDataset objects stores in a QVector container that are exposed for efficiency
*
* \since QGIS 3.16
*/
class CORE_EXPORT QgsMeshMemoryDatasetGroup: public QgsMeshDatasetGroup
{
public:
//! Constructor
QgsMeshMemoryDatasetGroup() = default;
//! Constructor with the \a name of the group
QgsMeshMemoryDatasetGroup( const QString &name );
//! Constructor with the \a name of the group and the type of data \a dataType
QgsMeshMemoryDatasetGroup( const QString &name, QgsMeshDatasetGroupMetadata::DataType dataType );
void initialize() override;
int datasetCount() const override;
QgsMeshDatasetMetadata datasetMetadata( int datasetIndex ) const override;
QgsMeshDataset *dataset( int index ) const override;
virtual QgsMeshDatasetGroup::Type type() const override {return QgsMeshDatasetGroup::Memory;}
//! Returns a invalid DOM element
QDomElement writeXml( QDomDocument &doc, const QgsReadWriteContext &context ) const override;
//! Adds a memory dataset to the group
void addDataset( std::shared_ptr<QgsMeshMemoryDataset> dataset );
//! Removes all the datasets from the group
void clearDatasets();
//! Returns the dataset with \a index
std::shared_ptr<const QgsMeshMemoryDataset> constDataset( int index ) const;
//! Contains all the memory datasets
QVector<std::shared_ptr<QgsMeshMemoryDataset>> memoryDatasets;
};
#endif //SIP_RUN
/**
* \ingroup core
*
* \brief Tree item for display of the mesh dataset groups.
* Dataset group is set of datasets with the same name,
* but different control variable (e.g. time)
*
* Support for multiple levels, because groups can have
* subgroups, for example
*
* Groups:
* Depth
* Minimum
* Maximum
* Velocity
* Wind speed
* Minimum
* Maximum
*
* Tree items handle also the dependencies between dataset groups represented by these items
*
* \since QGIS 3.14 in core API
*/
class CORE_EXPORT QgsMeshDatasetGroupTreeItem
{
public:
/**
* Constructor for an empty dataset group tree item
*/
QgsMeshDatasetGroupTreeItem();
/**
* Constructor
*
* \param defaultName the name that will be used to display the item if iot not overrides (\see setName())
* \param sourceName the name used by the source (provider, dataset group store,...)
* \param isVector whether the dataset group is a vector dataset group
* \param index index of the dataset group
*/
QgsMeshDatasetGroupTreeItem( const QString &defaultName,
const QString &sourceName,
bool isVector,
int index );
/**
* Constructor from a DOM element, constructs also the children
*
* \param itemElement the DOM element
* \param context writing context (e.g. for conversion between relative and absolute paths)
*/
QgsMeshDatasetGroupTreeItem( const QDomElement &itemElement, const QgsReadWriteContext &context );
/**
* Destructor, destructs also the children
*
*/
~QgsMeshDatasetGroupTreeItem();
/**
* Clones the item
*
* \return the cloned item
*/
QgsMeshDatasetGroupTreeItem *clone() const SIP_FACTORY;
/**
* Appends a child \a item.
*
* \note takes ownership of item
*/
void appendChild( QgsMeshDatasetGroupTreeItem *item SIP_TRANSFER );
/**
* Removes a item child if exists
* \param item the item to append
*
* \note takes ownership of item
*
* \since QGIS 3.16
*/
void removeChild( QgsMeshDatasetGroupTreeItem *item SIP_TRANSFER );
/**
* Returns a child
* \param row the position of the child
* \return the item at the position \a row
*/
QgsMeshDatasetGroupTreeItem *child( int row ) const;
/**
* Returns the child with dataset group \a index
* Searches as depper as needed on the child hierarchy
*
* \param index the index of the dataset group index
* \return the item with index as dataset group index, nullptr if no item is found
*/
QgsMeshDatasetGroupTreeItem *childFromDatasetGroupIndex( int index );
/**
* Returns the count of children
* \return the children's count
*/
int childCount() const;
/**
* Returns the total count of children, that is included deeper children and disabled items
* \return the total children's count
*/
int totalChildCount() const;
/**
* Returns a list of enabled dataset group indexes, included deeper children
* \return the list of dataset group indexes
*
* \since QGIS 3.16.3
*/
QList<int> enabledDatasetGroupIndexes() const;
/**
* Returns the parent item, nullptr if it is root item
* \return the parent item
*/
QgsMeshDatasetGroupTreeItem *parentItem() const;
/**
* Returns the position of the item in the parent
* \return tow position of the item
*/
int row() const;
/**
* Returns the name of the item
* This name is the default name if the name has not been overridden (\see setName())
* \return the name to display
*/
QString name() const;
/**
* Overrides the default name with the name to display.
* The default name is still stored in the item
* but will not be displayed anymore except if the empty string is set.
* \param name to display
*/
void setName( const QString &name );
/**
* Returns the name used by the provider to identify the dataset
*
* \return the provider name
*
* \since QGIS 3.16
*/
QString providerName() const;
/**
* \return whether the dataset group is vector
*/
bool isVector() const;
/**
* \return the dataset group index
*/
int datasetGroupIndex() const;
/**
* \return whether the item is enabled, that is if it is displayed in view
*/
bool isEnabled() const;
/**
* Sets whether the item is enabled, that is if it is displayed in view
* \param isEnabled whether the item is enabled
*/
void setIsEnabled( bool isEnabled );
/**
* \return the default name
*/
QString defaultName() const;
/**
* \return the dataset group type
*
* \since QGIS 3.16
*/
QgsMeshDatasetGroup::Type datasetGroupType() const;
/**
* Returns a list of group index corresponding to dataset group that depends on the dataset group represented by this item
*
* \return list of group index
*
*/
QList<int> groupIndexDependencies() const;
/**
* Returns description about the dataset group (URI, formula,...)
*
* \since QGIS 3.16
*/
QString description() const;
/**
* Set parameters of the item in accordance with the dataset group
*
* \param datasetGroup pointer to the dataset group to accord with
*
* \since QGIS 3.16
*/
void setDatasetGroup( QgsMeshDatasetGroup *datasetGroup );
/**
* Set parameters of the item in accordance with the persistent dataset group with \a uri
*
* \param uri uri of the persistent dataset group
*
* \since QGIS 3.16
*/
void setPersistentDatasetGroup( const QString &uri );
/**
* Writes the item and its children in a DOM document
* \param doc the DOM document
* \param context writing context (e.g. for conversion between relative and absolute paths)
* \return the dom element where the item is written
*/
QDomElement writeXml( QDomDocument &doc, const QgsReadWriteContext &context );
private:
QgsMeshDatasetGroupTreeItem *mParent = nullptr;
QList< QgsMeshDatasetGroupTreeItem * > mChildren;
QMap<int, QgsMeshDatasetGroupTreeItem *> mDatasetGroupIndexToChild;
// Data
QString mUserName;
QString mOriginalName;