Branch data Line data Source code
1 : : /***************************************************************************
2 : : qgsmeshmemorydataprovider.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 : : ///@cond PRIVATE
18 : :
19 : : #include "qgsmeshmemorydataprovider.h"
20 : : #include "qgsmeshdataprovidertemporalcapabilities.h"
21 : : #include "qgsmeshlayerutils.h"
22 : : #include "qgstriangularmesh.h"
23 : : #include <cstring>
24 : :
25 : : #define TEXT_PROVIDER_KEY QStringLiteral( "mesh_memory" )
26 : : #define TEXT_PROVIDER_DESCRIPTION QStringLiteral( "Mesh memory provider" )
27 : :
28 : 0 : bool QgsMeshMemoryDataProvider::isValid() const
29 : : {
30 : 0 : return true;
31 : : }
32 : :
33 : 0 : QString QgsMeshMemoryDataProvider::name() const
34 : : {
35 : 0 : return TEXT_PROVIDER_KEY;
36 : : }
37 : :
38 : 0 : QString QgsMeshMemoryDataProvider::description() const
39 : : {
40 : 0 : return TEXT_PROVIDER_DESCRIPTION;
41 : : }
42 : :
43 : 0 : QgsCoordinateReferenceSystem QgsMeshMemoryDataProvider::crs() const
44 : : {
45 : 0 : return QgsCoordinateReferenceSystem();
46 : : }
47 : :
48 : 0 : QgsMeshMemoryDataProvider::QgsMeshMemoryDataProvider( const QString &uri,
49 : : const ProviderOptions &options,
50 : : QgsDataProvider::ReadFlags flags )
51 : 0 : : QgsMeshDataProvider( uri, options, flags )
52 : 0 : {
53 : 0 : QString data( uri );
54 : : // see QgsMeshLayer::setDataProvider how mDataSource is created for memory layers
55 : 0 : if ( uri.contains( "&uid=" ) )
56 : : {
57 : 0 : data = uri.split( "&uid=" )[0];
58 : 0 : }
59 : 0 : mIsValid = splitMeshSections( data );
60 : :
61 : 0 : temporalCapabilities()->setTemporalUnit( QgsUnitTypes::TemporalHours );
62 : 0 : }
63 : :
64 : 6 : QString QgsMeshMemoryDataProvider::providerKey()
65 : : {
66 : 12 : return TEXT_PROVIDER_KEY;
67 : : }
68 : :
69 : 3 : QString QgsMeshMemoryDataProvider::providerDescription()
70 : : {
71 : 6 : return TEXT_PROVIDER_DESCRIPTION;
72 : : }
73 : :
74 : 0 : QgsMeshMemoryDataProvider *QgsMeshMemoryDataProvider::createProvider( const QString &uri,
75 : : const ProviderOptions &options,
76 : : QgsDataProvider::ReadFlags flags )
77 : : {
78 : 0 : return new QgsMeshMemoryDataProvider( uri, options, flags );
79 : 0 : }
80 : :
81 : 0 : bool QgsMeshMemoryDataProvider::splitMeshSections( const QString &uri )
82 : : {
83 : : #if QT_VERSION < QT_VERSION_CHECK(5, 15, 0)
84 : : const QStringList sections = uri.split( QStringLiteral( "---" ), QString::SkipEmptyParts );
85 : : #else
86 : 0 : const QStringList sections = uri.split( QStringLiteral( "---" ), Qt::SkipEmptyParts );
87 : : #endif
88 : 0 : if ( sections.size() != 2 )
89 : : {
90 : 0 : setError( QgsError( tr( "Invalid mesh definition, does not contain 2 sections" ),
91 : 0 : QStringLiteral( "Mesh Memory Provider" ) ) );
92 : 0 : return false;
93 : : }
94 : :
95 : 0 : if ( addMeshVertices( sections[0] ) )
96 : 0 : return addMeshFacesOrEdges( sections[1] );
97 : : else
98 : 0 : return false;
99 : 0 : }
100 : :
101 : 0 : bool QgsMeshMemoryDataProvider::addMeshVertices( const QString &def )
102 : : {
103 : 0 : QVector<QgsMeshVertex> vertices;
104 : :
105 : : #if QT_VERSION < QT_VERSION_CHECK(5, 15, 0)
106 : : const QStringList verticesCoords = def.split( '\n', QString::SkipEmptyParts );
107 : : #else
108 : 0 : const QStringList verticesCoords = def.split( '\n', Qt::SkipEmptyParts );
109 : : #endif
110 : 0 : for ( int i = 0; i < verticesCoords.size(); ++i )
111 : : {
112 : : #if QT_VERSION < QT_VERSION_CHECK(5, 15, 0)
113 : : const QStringList coords = verticesCoords[i].split( ',', QString::SkipEmptyParts );
114 : : #else
115 : 0 : const QStringList coords = verticesCoords[i].split( ',', Qt::SkipEmptyParts );
116 : : #endif
117 : 0 : if ( coords.size() != 2 )
118 : : {
119 : 0 : setError( QgsError( tr( "Invalid mesh definition, vertex definition does not contain x, y" ),
120 : 0 : QStringLiteral( "Mesh Memory Provider" ) ) );
121 : 0 : return false;
122 : : }
123 : 0 : double x = coords.at( 0 ).toDouble();
124 : 0 : double y = coords.at( 1 ).toDouble();
125 : 0 : QgsMeshVertex vertex( x, y );
126 : 0 : vertices.push_back( vertex );
127 : 0 : }
128 : :
129 : 0 : mVertices = vertices;
130 : 0 : return true;
131 : 0 : }
132 : :
133 : 0 : bool QgsMeshMemoryDataProvider::addMeshFacesOrEdges( const QString &def )
134 : : {
135 : 0 : QVector<QgsMeshFace> faces;
136 : 0 : QVector<QgsMeshEdge> edges;
137 : :
138 : : #if QT_VERSION < QT_VERSION_CHECK(5, 15, 0)
139 : : const QStringList elements = def.split( '\n', QString::SkipEmptyParts );
140 : : #else
141 : 0 : const QStringList elements = def.split( '\n', Qt::SkipEmptyParts );
142 : : #endif
143 : 0 : for ( int i = 0; i < elements.size(); ++i )
144 : : {
145 : : #if QT_VERSION < QT_VERSION_CHECK(5, 15, 0)
146 : : const QStringList vertices = elements[i].split( ',', QString::SkipEmptyParts );
147 : : #else
148 : 0 : const QStringList vertices = elements[i].split( ',', Qt::SkipEmptyParts );
149 : : #endif
150 : 0 : if ( vertices.size() < 2 )
151 : : {
152 : 0 : setError( QgsError( tr( "Invalid mesh definition, edge must contain at least 2 vertices" ),
153 : 0 : QStringLiteral( "Mesh Memory Provider" ) ) );
154 : 0 : return false;
155 : : }
156 : 0 : else if ( vertices.size() == 2 )
157 : : {
158 : 0 : QgsMeshEdge edge;
159 : 0 : edge.first = vertices[0].toInt();
160 : 0 : edge.second = vertices[1].toInt();
161 : 0 : if ( !checkVertexId( edge.first ) ) return false;
162 : 0 : if ( !checkVertexId( edge.second ) ) return false;
163 : 0 : edges.push_back( edge );
164 : 0 : }
165 : : else
166 : : {
167 : 0 : QgsMeshFace face;
168 : 0 : for ( int j = 0; j < vertices.size(); ++j )
169 : : {
170 : 0 : int vertex_id = vertices[j].toInt();
171 : 0 : if ( !checkVertexId( vertex_id ) ) return false;
172 : 0 : face.push_back( vertex_id );
173 : 0 : }
174 : 0 : faces.push_back( face );
175 : 0 : }
176 : 0 : }
177 : :
178 : 0 : mFaces = faces;
179 : 0 : mEdges = edges;
180 : :
181 : 0 : if ( mFaces.size() > 0 && mEdges.size() > 0 )
182 : : {
183 : 0 : setError( QgsError( tr( "Invalid mesh definition, unable to read mesh with both edges and faces" ),
184 : 0 : QStringLiteral( "Mesh Memory Provider" ) ) );
185 : 0 : return false;
186 : 0 : }
187 : :
188 : 0 : return true;
189 : 0 : }
190 : :
191 : :
192 : 0 : bool QgsMeshMemoryDataProvider::splitDatasetSections( const QString &uri, QgsMeshMemoryDatasetGroup &datasetGroup )
193 : : {
194 : : #if QT_VERSION < QT_VERSION_CHECK(5, 15, 0)
195 : : const QStringList sections = uri.split( QStringLiteral( "---" ), QString::SkipEmptyParts );
196 : : #else
197 : 0 : const QStringList sections = uri.split( QStringLiteral( "---" ), Qt::SkipEmptyParts );
198 : : #endif
199 : 0 : bool success = sections.size() > 2;
200 : 0 : if ( !success )
201 : : {
202 : 0 : setError( QgsError( tr( "Invalid dataset definition, does not contain 3+ sections" ),
203 : 0 : QStringLiteral( "Mesh Memory Provider" ) ) );
204 : 0 : }
205 : :
206 : 0 : if ( success )
207 : 0 : success = setDatasetGroupType( sections[0], datasetGroup );
208 : 0 : if ( success )
209 : 0 : success = addDatasetGroupMetadata( sections[1], datasetGroup );
210 : :
211 : 0 : for ( int i = 2; i < sections.size(); ++i )
212 : : {
213 : 0 : if ( !success )
214 : 0 : break;
215 : 0 : std::shared_ptr<QgsMeshMemoryDataset> dataset = std::make_shared<QgsMeshMemoryDataset>();
216 : 0 : success = addDatasetValues( sections[i], dataset, datasetGroup.isScalar() );
217 : 0 : if ( success )
218 : 0 : success = checkDatasetValidity( dataset, datasetGroup.dataType() );
219 : 0 : if ( success )
220 : 0 : datasetGroup.addDataset( dataset );
221 : 0 : }
222 : :
223 : 0 : return success;
224 : 0 : }
225 : :
226 : 0 : bool QgsMeshMemoryDataProvider::setDatasetGroupType( const QString &def, QgsMeshMemoryDatasetGroup &datasetGroup )
227 : : {
228 : : #if QT_VERSION < QT_VERSION_CHECK(5, 15, 0)
229 : : const QStringList types = def.split( ' ', QString::SkipEmptyParts );
230 : : #else
231 : 0 : const QStringList types = def.split( ' ', Qt::SkipEmptyParts );
232 : : #endif
233 : 0 : if ( types.size() != 3 )
234 : : {
235 : 0 : setError( QgsError( tr( "Invalid type definition, must be Vertex/Edge/Face Vector/Scalar Name" ),
236 : 0 : QStringLiteral( "Mesh Memory Provider" ) ) );
237 : 0 : return false;
238 : : }
239 : :
240 : : QgsMeshDatasetGroupMetadata::DataType type;
241 : 0 : if ( 0 == QString::compare( types[0].trimmed(), QStringLiteral( "vertex" ), Qt::CaseInsensitive ) )
242 : 0 : type = QgsMeshDatasetGroupMetadata::DataOnVertices;
243 : 0 : else if ( 0 == QString::compare( types[0].trimmed(), QStringLiteral( "edge" ), Qt::CaseInsensitive ) )
244 : 0 : type = QgsMeshDatasetGroupMetadata::DataOnEdges;
245 : : else
246 : 0 : type = QgsMeshDatasetGroupMetadata::DataOnFaces;
247 : :
248 : 0 : datasetGroup.setDataType( type );
249 : 0 : datasetGroup.setIsScalar( 0 == QString::compare( types[1].trimmed(), QStringLiteral( "scalar" ), Qt::CaseInsensitive ) );
250 : 0 : datasetGroup.setName( types[2].trimmed() );
251 : :
252 : 0 : return true;
253 : 0 : }
254 : :
255 : 0 : bool QgsMeshMemoryDataProvider::addDatasetGroupMetadata( const QString &def, QgsMeshMemoryDatasetGroup &datasetGroup )
256 : : {
257 : : #if QT_VERSION < QT_VERSION_CHECK(5, 15, 0)
258 : : const QStringList metadataLines = def.split( '\n', QString::SkipEmptyParts );
259 : : #else
260 : 0 : const QStringList metadataLines = def.split( '\n', Qt::SkipEmptyParts );
261 : : #endif
262 : 0 : for ( int i = 0; i < metadataLines.size(); ++i )
263 : : {
264 : : #if QT_VERSION < QT_VERSION_CHECK(5, 15, 0)
265 : : const QStringList keyVal = metadataLines[i].split( ':', QString::SkipEmptyParts );
266 : : #else
267 : 0 : const QStringList keyVal = metadataLines[i].split( ':', Qt::SkipEmptyParts );
268 : : #endif
269 : 0 : if ( keyVal.size() != 2 )
270 : : {
271 : 0 : setError( QgsError( tr( "Invalid dataset definition, dataset metadata does not contain key: value" ),
272 : 0 : QStringLiteral( "Mesh Memory Provider" ) ) );
273 : 0 : return false;
274 : : }
275 : :
276 : 0 : datasetGroup.addExtraMetadata( keyVal.at( 0 ).trimmed(), keyVal.at( 1 ).trimmed() );
277 : 0 : }
278 : 0 : return true;
279 : 0 : }
280 : :
281 : 0 : bool QgsMeshMemoryDataProvider::addDatasetValues( const QString &def, std::shared_ptr<QgsMeshMemoryDataset> &dataset, bool isScalar )
282 : : {
283 : : #if QT_VERSION < QT_VERSION_CHECK(5, 15, 0)
284 : : const QStringList valuesLines = def.split( '\n', QString::SkipEmptyParts );
285 : : #else
286 : 0 : const QStringList valuesLines = def.split( '\n', Qt::SkipEmptyParts );
287 : : #endif
288 : : // first line is time
289 : 0 : if ( valuesLines.size() < 2 )
290 : : {
291 : 0 : setError( QgsError( tr( "Invalid dataset definition, must contain at least 1 line (time)" ),
292 : 0 : QStringLiteral( "Mesh Memory Provider" ) ) );
293 : 0 : return false;
294 : : }
295 : :
296 : 0 : dataset->time = valuesLines[0].toDouble();
297 : :
298 : 0 : for ( int i = 1; i < valuesLines.size(); ++i )
299 : : {
300 : : #if QT_VERSION < QT_VERSION_CHECK(5, 15, 0)
301 : : const QStringList values = valuesLines[i].split( ',', QString::SkipEmptyParts );
302 : : #else
303 : 0 : const QStringList values = valuesLines[i].split( ',', Qt::SkipEmptyParts );
304 : : #endif
305 : 0 : QgsMeshDatasetValue point;
306 : :
307 : 0 : if ( isScalar )
308 : : {
309 : 0 : if ( values.size() != 1 )
310 : : {
311 : 0 : setError( QgsError( tr( "Invalid dataset definition, dataset scalar values must be x" ),
312 : 0 : QStringLiteral( "Mesh Memory Provider" ) ) );
313 : 0 : return false;
314 : : }
315 : : else
316 : : {
317 : 0 : point.setX( values[0].toDouble() );
318 : : }
319 : 0 : }
320 : : else
321 : : {
322 : 0 : if ( values.size() < 2 )
323 : : {
324 : 0 : setError( QgsError( tr( "Invalid dataset definition, dataset vector values must be x, y" ),
325 : 0 : QStringLiteral( "Mesh Memory Provider" ) ) );
326 : 0 : return false;
327 : : }
328 : : else
329 : : {
330 : 0 : point.setX( values[0].toDouble() );
331 : 0 : point.setY( values[1].toDouble() );
332 : : }
333 : : }
334 : :
335 : 0 : dataset->values.push_back( point );
336 : 0 : }
337 : 0 : return true;
338 : 0 : }
339 : :
340 : 0 : bool QgsMeshMemoryDataProvider::checkDatasetValidity( std::shared_ptr<QgsMeshMemoryDataset> &dataset, QgsMeshDatasetGroupMetadata::DataType dataType )
341 : : {
342 : 0 : bool valid = true;
343 : :
344 : 0 : if ( dataType == QgsMeshDatasetGroupMetadata::DataOnVertices )
345 : : {
346 : 0 : if ( dataset->values.count() != vertexCount() )
347 : : {
348 : 0 : valid = false;
349 : 0 : setError( QgsError( tr( "Dataset defined on vertices has {} values, but mesh {}" ).arg( dataset->values.count(), vertexCount() ),
350 : 0 : QStringLiteral( "Mesh Memory Provider" ) ) );
351 : 0 : }
352 : 0 : }
353 : 0 : else if ( dataType == QgsMeshDatasetGroupMetadata::DataOnFaces )
354 : : {
355 : : // on faces
356 : 0 : if ( dataset->values.count() != faceCount() )
357 : : {
358 : 0 : valid = false;
359 : 0 : setError( QgsError( tr( "Dataset defined on faces has {} values, but mesh {}" ).arg( dataset->values.count(), faceCount() ),
360 : 0 : QStringLiteral( "Mesh Memory Provider" ) ) );
361 : 0 : }
362 : 0 : }
363 : 0 : else if ( dataType == QgsMeshDatasetGroupMetadata::DataOnEdges )
364 : : {
365 : : // on edges
366 : 0 : if ( dataset->values.count() != edgeCount() )
367 : : {
368 : 0 : valid = false;
369 : 0 : setError( QgsError( tr( "Dataset defined on edges has {} values, but mesh {}" ).arg( dataset->values.count(), edgeCount() ),
370 : 0 : QStringLiteral( "Mesh Memory Provider" ) ) );
371 : 0 : }
372 : 0 : }
373 : 0 : dataset->valid = valid;
374 : 0 : return valid;
375 : 0 : }
376 : :
377 : 0 : bool QgsMeshMemoryDataProvider::checkVertexId( int vertexIndex )
378 : : {
379 : 0 : if ( vertexIndex < 0 )
380 : : {
381 : 0 : setError( QgsError( tr( "Invalid mesh definition, vertex index must be positive value" ),
382 : 0 : QStringLiteral( "Mesh Memory Provider" ) ) );
383 : 0 : return false;
384 : : }
385 : 0 : if ( mVertices.size() <= vertexIndex )
386 : : {
387 : 0 : setError( QgsError( tr( "Invalid mesh definition, missing vertex id defined in face" ),
388 : 0 : QStringLiteral( "Mesh Memory Provider" ) ) );
389 : 0 : return false;
390 : : }
391 : :
392 : 0 : return true;
393 : 0 : }
394 : :
395 : 0 : void QgsMeshMemoryDataProvider::addGroupToTemporalCapabilities( int groupIndex, const QgsMeshMemoryDatasetGroup &group )
396 : : {
397 : 0 : QgsMeshDataProviderTemporalCapabilities *tempCap = temporalCapabilities();
398 : 0 : if ( !tempCap )
399 : 0 : return;
400 : :
401 : 0 : if ( group.datasetCount() > 1 ) //non temporal dataset groups (count=1) have no time in the capabilities
402 : : {
403 : 0 : for ( int i = 0; i < group.memoryDatasets.count(); ++i )
404 : 0 : if ( group.memoryDatasets.at( i ) )
405 : 0 : tempCap->addDatasetTime( groupIndex, group.memoryDatasets.at( i )->time );
406 : 0 : }
407 : :
408 : 0 : }
409 : :
410 : 0 : int QgsMeshMemoryDataProvider::vertexCount() const
411 : : {
412 : 0 : return mVertices.size();
413 : : }
414 : :
415 : 0 : int QgsMeshMemoryDataProvider::faceCount() const
416 : : {
417 : 0 : return mFaces.size();
418 : : }
419 : :
420 : 0 : int QgsMeshMemoryDataProvider::edgeCount() const
421 : : {
422 : 0 : return mEdges.size();
423 : : }
424 : :
425 : 0 : void QgsMeshMemoryDataProvider::populateMesh( QgsMesh *mesh ) const
426 : : {
427 : 0 : if ( mesh )
428 : : {
429 : 0 : mesh->faces = mFaces;
430 : 0 : mesh->vertices = mVertices;
431 : 0 : mesh->edges = mEdges;
432 : 0 : }
433 : 0 : }
434 : :
435 : 0 : QgsRectangle QgsMeshMemoryDataProvider::extent() const
436 : : {
437 : 0 : return calculateExtent( );
438 : : }
439 : :
440 : 0 : bool QgsMeshMemoryDataProvider::addDataset( const QString &uri )
441 : : {
442 : 0 : QgsMeshMemoryDatasetGroup group;
443 : :
444 : 0 : bool valid = false;
445 : 0 : if ( mIsValid )
446 : : {
447 : 0 : valid = splitDatasetSections( uri, group );
448 : 0 : }
449 : : else
450 : : {
451 : 0 : setError( QgsError( tr( "Unable to add dataset group to invalid mesh" ),
452 : 0 : QStringLiteral( "Mesh Memory Provider" ) ) );
453 : : }
454 : :
455 : 0 : group.calculateStatistic();
456 : 0 : mDatasetGroups.push_back( group );
457 : 0 : addGroupToTemporalCapabilities( mDatasetGroups.count() - 1, group );
458 : :
459 : 0 : if ( valid )
460 : : {
461 : 0 : if ( !mExtraDatasetUris.contains( uri ) )
462 : 0 : mExtraDatasetUris << uri;
463 : 0 : temporalCapabilities()->setHasTemporalCapabilities( true );
464 : 0 : emit datasetGroupsAdded( 1 );
465 : 0 : emit dataChanged();
466 : 0 : }
467 : :
468 : 0 : return valid;
469 : 0 : }
470 : :
471 : 0 : QStringList QgsMeshMemoryDataProvider::extraDatasets() const
472 : : {
473 : 0 : return mExtraDatasetUris;
474 : : }
475 : :
476 : 0 : int QgsMeshMemoryDataProvider::datasetGroupCount() const
477 : : {
478 : 0 : return mDatasetGroups.count();
479 : : }
480 : :
481 : 0 : int QgsMeshMemoryDataProvider::datasetCount( int groupIndex ) const
482 : : {
483 : 0 : if ( ( groupIndex >= 0 ) && ( groupIndex < datasetGroupCount() ) )
484 : 0 : return mDatasetGroups[groupIndex].memoryDatasets.count();
485 : : else
486 : 0 : return 0;
487 : 0 : }
488 : :
489 : 0 : QgsMeshDatasetGroupMetadata QgsMeshMemoryDataProvider::datasetGroupMetadata( int groupIndex ) const
490 : : {
491 : 0 : if ( ( groupIndex >= 0 ) && ( groupIndex < datasetGroupCount() ) )
492 : : {
493 : 0 : return mDatasetGroups[groupIndex].groupMetadata();
494 : : }
495 : : else
496 : : {
497 : 0 : return QgsMeshDatasetGroupMetadata();
498 : : }
499 : 0 : }
500 : :
501 : :
502 : :
503 : 0 : QgsMeshDatasetMetadata QgsMeshMemoryDataProvider::datasetMetadata( QgsMeshDatasetIndex index ) const
504 : : {
505 : 0 : if ( ( index.group() >= 0 ) && ( index.group() < datasetGroupCount() ) &&
506 : 0 : ( index.dataset() >= 0 ) && ( index.dataset() < datasetCount( index.group() ) )
507 : : )
508 : : {
509 : 0 : const QgsMeshMemoryDatasetGroup &grp = mDatasetGroups.at( index.group() );
510 : 0 : QgsMeshDatasetMetadata metadata(
511 : 0 : grp.memoryDatasets[index.dataset()]->time,
512 : 0 : grp.memoryDatasets[index.dataset()]->valid,
513 : 0 : grp.memoryDatasets[index.dataset()]->minimum,
514 : 0 : grp.memoryDatasets[index.dataset()]->maximum,
515 : : 0
516 : : );
517 : 0 : return metadata;
518 : : }
519 : : else
520 : : {
521 : 0 : return QgsMeshDatasetMetadata();
522 : : }
523 : 0 : }
524 : :
525 : 0 : QgsMeshDatasetValue QgsMeshMemoryDataProvider::datasetValue( QgsMeshDatasetIndex index, int valueIndex ) const
526 : : {
527 : 0 : if ( ( index.group() >= 0 ) && ( index.group() < datasetGroupCount() ) &&
528 : 0 : ( index.dataset() >= 0 ) && ( index.dataset() < datasetCount( index.group() ) ) &&
529 : 0 : ( valueIndex >= 0 ) && ( valueIndex < mDatasetGroups[index.group()].memoryDatasets[index.dataset()]->values.count() ) )
530 : : {
531 : 0 : return mDatasetGroups[index.group()].memoryDatasets[index.dataset()]->values[valueIndex];
532 : : }
533 : : else
534 : : {
535 : 0 : return QgsMeshDatasetValue();
536 : : }
537 : 0 : }
538 : :
539 : 0 : QgsMeshDataBlock QgsMeshMemoryDataProvider::datasetValues( QgsMeshDatasetIndex index, int valueIndex, int count ) const
540 : : {
541 : 0 : if ( ( index.group() >= 0 ) && ( index.group() < datasetGroupCount() ) )
542 : : {
543 : 0 : const QgsMeshMemoryDatasetGroup group = mDatasetGroups[index.group()];
544 : 0 : bool isScalar = group.isScalar();
545 : 0 : if ( ( index.dataset() >= 0 ) && ( index.dataset() < group.memoryDatasets.size() ) )
546 : : {
547 : 0 : return group.memoryDatasets[index.dataset()]->datasetValues( isScalar, valueIndex, count );
548 : : }
549 : : else
550 : : {
551 : 0 : return QgsMeshDataBlock();
552 : : }
553 : 0 : }
554 : : else
555 : : {
556 : 0 : return QgsMeshDataBlock();
557 : : }
558 : 0 : }
559 : :
560 : 0 : QgsMesh3dDataBlock QgsMeshMemoryDataProvider::dataset3dValues( QgsMeshDatasetIndex, int, int ) const
561 : : {
562 : : // 3d stacked meshes are not supported by memory provider
563 : 0 : return QgsMesh3dDataBlock();
564 : : }
565 : :
566 : :
567 : :
568 : 0 : bool QgsMeshMemoryDataProvider::isFaceActive( QgsMeshDatasetIndex index, int faceIndex ) const
569 : : {
570 : 0 : if ( mDatasetGroups[index.group()].memoryDatasets[index.dataset()]->active.isEmpty() )
571 : 0 : return true;
572 : : else
573 : 0 : return mDatasetGroups[index.group()].memoryDatasets[index.dataset()]->active[faceIndex];
574 : 0 : }
575 : :
576 : 0 : QgsMeshDataBlock QgsMeshMemoryDataProvider::areFacesActive( QgsMeshDatasetIndex index, int faceIndex, int count ) const
577 : : {
578 : 0 : if ( ( index.group() >= 0 ) && ( index.group() < datasetGroupCount() ) )
579 : : {
580 : 0 : const QgsMeshMemoryDatasetGroup group = mDatasetGroups[index.group()];
581 : 0 : if ( ( index.dataset() >= 0 ) && ( index.dataset() < group.memoryDatasets.size() ) )
582 : : {
583 : 0 : return group.memoryDatasets[index.dataset()]->areFacesActive( faceIndex, count );
584 : : }
585 : : else
586 : : {
587 : 0 : return QgsMeshDataBlock();
588 : : }
589 : 0 : }
590 : : else
591 : : {
592 : 0 : return QgsMeshDataBlock();
593 : : }
594 : 0 : }
595 : :
596 : :
597 : :
598 : 0 : bool QgsMeshMemoryDataProvider::persistDatasetGroup( const QString &outputFilePath,
599 : : const QString &outputDriver,
600 : : const QgsMeshDatasetGroupMetadata &meta,
601 : : const QVector<QgsMeshDataBlock> &datasetValues,
602 : : const QVector<QgsMeshDataBlock> &datasetActive,
603 : : const QVector<double> × )
604 : : {
605 : 0 : Q_UNUSED( outputFilePath )
606 : 0 : Q_UNUSED( outputDriver )
607 : 0 : Q_UNUSED( meta )
608 : 0 : Q_UNUSED( datasetValues )
609 : 0 : Q_UNUSED( datasetActive )
610 : 0 : Q_UNUSED( times )
611 : 0 : return true; // not implemented/supported
612 : : }
613 : :
614 : 0 : bool QgsMeshMemoryDataProvider::persistDatasetGroup( const QString &outputFilePath,
615 : : const QString &outputDriver,
616 : : QgsMeshDatasetSourceInterface *source,
617 : : int datasetGroupIndex )
618 : : {
619 : 0 : Q_UNUSED( outputFilePath )
620 : 0 : Q_UNUSED( outputDriver )
621 : : Q_UNUSED( source )
622 : : Q_UNUSED( datasetGroupIndex )
623 : 0 : return true; // not implemented/supported
624 : : }
625 : :
626 : 0 : QgsRectangle QgsMeshMemoryDataProvider::calculateExtent() const
627 : : {
628 : 0 : QgsRectangle rec;
629 : 0 : rec.setMinimal();
630 : 0 : for ( const QgsMeshVertex &v : mVertices )
631 : : {
632 : 0 : rec.setXMinimum( std::min( rec.xMinimum(), v.x() ) );
633 : 0 : rec.setYMinimum( std::min( rec.yMinimum(), v.y() ) );
634 : 0 : rec.setXMaximum( std::max( rec.xMaximum(), v.x() ) );
635 : 0 : rec.setYMaximum( std::max( rec.yMaximum(), v.y() ) );
636 : : }
637 : 0 : return rec;
638 : : }
639 : :
640 : :
641 : :
642 : : ///@endcond
|
