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