35static QgsFields createFields(
const QList<QgsMeshDatasetGroupMetadata> &groupMetadataList,
int vectorOption )
40 if ( meta.isVector() )
42 if ( vectorOption == 0 || vectorOption == 2 )
44 fields.
append(
QgsField( QStringLiteral(
"%1_x" ).arg( meta.name() ), QMetaType::Type::Double ) );
45 fields.
append(
QgsField( QStringLiteral(
"%1_y" ).arg( meta.name() ), QMetaType::Type::Double ) );
48 if ( vectorOption == 1 || vectorOption == 2 )
50 fields.
append(
QgsField( QStringLiteral(
"%1_mag" ).arg( meta.name() ), QMetaType::Type::Double ) );
51 fields.
append(
QgsField( QStringLiteral(
"%1_dir" ).arg( meta.name() ), QMetaType::Type::Double ) );
62 QVector<double> ret( exportOption == 2 ? 4 : 2 );
64 if ( exportOption == 0 || exportOption == 2 )
69 if ( exportOption == 1 || exportOption == 2 )
73 double magnitude = sqrt( x * x + y * y );
74 double direction = ( asin( x / magnitude ) ) / M_PI * 180;
76 direction = 180 - direction;
78 if ( exportOption == 1 )
83 if ( exportOption == 2 )
96 QVector<double> vectorValues = vectorValue( value, vectorOption );
97 for (
double v : vectorValues )
99 if ( v == std::numeric_limits<double>::quiet_NaN() )
100 attributes.append( QVariant() );
102 attributes.append( v );
107 if ( value.
scalar() == std::numeric_limits<double>::quiet_NaN() )
108 attributes.append( QVariant() );
110 attributes.append( value.
scalar() );
117 int triangularFaceIndex,
123 bool faceActive = activeFaces.
active( nativeFaceIndex );
135 value = datasetValues.
value( nativeFaceIndex );
142 const int v1 = face[0], v2 = face[1], v3 = face[2];
147 const double x = QgsMeshLayerUtils::interpolateFromVerticesData( p1, p2, p3, val1.
x(), val2.
x(), val3.
x(), point );
148 double y = std::numeric_limits<double>::quiet_NaN();
149 bool isVector = metadata.
isVector();
151 y = QgsMeshLayerUtils::interpolateFromVerticesData( p1, p2, p3, val1.
y(), val2.
y(), val3.
y(), point );
162QString QgsExportMeshOnElement::group()
const
164 return QObject::tr(
"Mesh" );
167QString QgsExportMeshOnElement::groupId()
const
169 return QStringLiteral(
"mesh" );
172QString QgsExportMeshVerticesAlgorithm::shortHelpString()
const
174 return QObject::tr(
"This algorithm exports a mesh layer's vertices to a point vector layer, with the dataset values on vertices as attribute values." );
177QString QgsExportMeshVerticesAlgorithm::shortDescription()
const
179 return QObject::tr(
"Exports mesh vertices to a point vector layer" );
182QString QgsExportMeshVerticesAlgorithm::name()
const
184 return QStringLiteral(
"exportmeshvertices" );
187QString QgsExportMeshVerticesAlgorithm::displayName()
const
189 return QObject::tr(
"Export mesh vertices" );
194 return new QgsExportMeshVerticesAlgorithm();
197QgsGeometry QgsExportMeshVerticesAlgorithm::meshElement(
int index )
const
202void QgsExportMeshOnElement::initAlgorithm(
const QVariantMap &configuration )
204 Q_UNUSED( configuration );
210 QStringLiteral(
"DATASET_GROUPS" ),
211 QObject::tr(
"Dataset groups" ),
212 QStringLiteral(
"INPUT" ),
213 supportedDataType(),
true ) );
216 QStringLiteral(
"DATASET_TIME" ),
217 QObject::tr(
"Dataset time" ),
218 QStringLiteral(
"INPUT" ),
219 QStringLiteral(
"DATASET_GROUPS" ) ) );
221 addParameter(
new QgsProcessingParameterCrs( QStringLiteral(
"CRS_OUTPUT" ), QObject::tr(
"Output coordinate system" ), QVariant(),
true ) );
223 QStringList exportVectorOptions;
224 exportVectorOptions << QObject::tr(
"Cartesian (x,y)" )
225 << QObject::tr(
"Polar (magnitude,degree)" )
226 << QObject::tr(
"Cartesian and Polar" );
227 addParameter(
new QgsProcessingParameterEnum( QStringLiteral(
"VECTOR_OPTION" ), QObject::tr(
"Export vector option" ), exportVectorOptions,
false, 0 ) );
237 if ( timeType == QLatin1String(
"dataset-time-step" ) )
242 else if ( timeType == QLatin1String(
"defined-date-time" ) )
245 if ( dateTime.isValid() )
246 relativeTime =
QgsInterval( layerReferenceTime.secsTo( dateTime ) );
248 else if ( timeType == QLatin1String(
"current-context-time" ) )
251 if ( dateTime.isValid() )
252 relativeTime =
QgsInterval( layerReferenceTime.secsTo( dateTime ) );
261 QgsMeshLayer *meshLayer = parameterAsMeshLayer( parameters, QStringLiteral(
"INPUT" ), context );
263 if ( !meshLayer || !meshLayer->
isValid() )
278 QList<int> datasetGroups =
287 QVariant parameterTimeVariant = parameters.value( QStringLiteral(
"DATASET_TIME" ) );
288 QgsInterval relativeTime = datasetRelativetime( parameterTimeVariant, meshLayer, context );
290 switch ( meshElementType() )
293 mElementCount = mNativeMesh.faceCount();
296 mElementCount = mNativeMesh.vertexCount();
299 mElementCount = mNativeMesh.edgeCount();
303 for (
int i = 0; i < datasetGroups.count(); ++i )
305 int groupIndex = datasetGroups.at( i );
310 if ( supportedDataType().contains( dataGroup.metadata.dataType() ) )
312 dataGroup.datasetValues = meshLayer->
datasetValues( datasetIndex, 0, mElementCount );
313 mDataPerGroup.append( dataGroup );
316 feedback->
setProgress( 100 * i / datasetGroups.count() );
319 mExportVectorOption = parameterAsInt( parameters, QStringLiteral(
"VECTOR_OPTION" ), context );
329 return QVariantMap();
331 feedback->
setProgressText( QObject::tr(
"Creating output vector layer" ) );
334 QList<QgsMeshDatasetGroupMetadata> metaList;
335 metaList.reserve( mDataPerGroup.size() );
336 for (
const DataGroup &dataGroup : std::as_const( mDataPerGroup ) )
337 metaList.append( dataGroup.metadata );
338 QgsFields fields = createFields( metaList, mExportVectorOption );
342 std::unique_ptr<QgsFeatureSink> sink( parameterAsSink( parameters,
343 QStringLiteral(
"OUTPUT" ),
350 return QVariantMap();
355 return QVariantMap();
357 feedback->
setProgressText( QObject::tr(
"Creating points for each vertices" ) );
360 for (
int i = 0; i < mElementCount; ++i )
363 for (
const DataGroup &dataGroup : std::as_const( mDataPerGroup ) )
366 addAttributes( value, attributes, dataGroup.metadata.isVector(), mExportVectorOption );
377 geom = meshElement( i );
379 feedback->
reportError( QObject::tr(
"Could not transform point to destination CRS" ) );
390 return QVariantMap();
396 ret[QStringLiteral(
"OUTPUT" )] = identifier;
401QString QgsExportMeshFacesAlgorithm::shortHelpString()
const
403 return QObject::tr(
"This algorithm exports a mesh layer's faces to a polygon vector layer, with the dataset values on faces as attribute values." );
406QString QgsExportMeshFacesAlgorithm::shortDescription()
const
408 return QObject::tr(
"Exports mesh faces to a polygon vector layer" );
411QString QgsExportMeshFacesAlgorithm::name()
const
413 return QStringLiteral(
"exportmeshfaces" );
416QString QgsExportMeshFacesAlgorithm::displayName()
const
418 return QObject::tr(
"Export mesh faces" );
423 return new QgsExportMeshFacesAlgorithm();
426QgsGeometry QgsExportMeshFacesAlgorithm::meshElement(
int index )
const
428 const QgsMeshFace &face = mNativeMesh.face( index );
429 QVector<QgsPoint> vertices( face.size() );
430 for (
int i = 0; i < face.size(); ++i )
431 vertices[i] = mNativeMesh.vertex( face.at( i ) );
432 std::unique_ptr<QgsPolygon> polygon = std::make_unique<QgsPolygon>();
437QString QgsExportMeshEdgesAlgorithm::shortHelpString()
const
439 return QObject::tr(
"This algorithm exports a mesh layer's edges to a line vector layer, with the dataset values on edges as attribute values." );
442QString QgsExportMeshEdgesAlgorithm::shortDescription()
const
444 return QObject::tr(
"Exports mesh edges to a line vector layer" );
447QString QgsExportMeshEdgesAlgorithm::name()
const
449 return QStringLiteral(
"exportmeshedges" );
452QString QgsExportMeshEdgesAlgorithm::displayName()
const
454 return QObject::tr(
"Export mesh edges" );
459 return new QgsExportMeshEdgesAlgorithm();
462QgsGeometry QgsExportMeshEdgesAlgorithm::meshElement(
int index )
const
464 const QgsMeshEdge &edge = mNativeMesh.edge( index );
465 QVector<QgsPoint> vertices( 2 );
466 vertices[0] = mNativeMesh.vertex( edge.first );
467 vertices[1] = mNativeMesh.vertex( edge.second );
472QString QgsExportMeshOnGridAlgorithm::name()
const {
return QStringLiteral(
"exportmeshongrid" );}
474QString QgsExportMeshOnGridAlgorithm::displayName()
const {
return QObject::tr(
"Export mesh on grid" );}
476QString QgsExportMeshOnGridAlgorithm::group()
const {
return QObject::tr(
"Mesh" );}
478QString QgsExportMeshOnGridAlgorithm::groupId()
const {
return QStringLiteral(
"mesh" );}
480QString QgsExportMeshOnGridAlgorithm::shortHelpString()
const
482 return QObject::tr(
"This algorithm exports a mesh layer's dataset values to a gridded point vector layer, with the dataset values on each point as attribute values.\n"
483 "For data on volume (3D stacked dataset values), the exported dataset values are averaged on faces using the method defined in the mesh layer properties (default is Multi level averaging method).\n"
484 "1D meshes are not supported." );
487QString QgsExportMeshOnGridAlgorithm::shortDescription()
const
489 return QObject::tr(
"Exports mesh dataset values to a gridded point vector layer" );
494 return new QgsExportMeshOnGridAlgorithm();
497void QgsExportMeshOnGridAlgorithm::initAlgorithm(
const QVariantMap &configuration )
499 Q_UNUSED( configuration );
504 QStringLiteral(
"DATASET_GROUPS" ),
505 QObject::tr(
"Dataset groups" ),
506 QStringLiteral(
"INPUT" ),
507 supportedDataType() ) );
510 QStringLiteral(
"DATASET_TIME" ),
511 QObject::tr(
"Dataset time" ),
512 QStringLiteral(
"INPUT" ),
513 QStringLiteral(
"DATASET_GROUPS" ) ) );
517 addParameter(
new QgsProcessingParameterDistance( QStringLiteral(
"GRID_SPACING" ), QObject::tr(
"Grid spacing" ), 10, QStringLiteral(
"INPUT" ),
false ) );
519 addParameter(
new QgsProcessingParameterCrs( QStringLiteral(
"CRS_OUTPUT" ), QObject::tr(
"Output coordinate system" ), QVariant(),
true ) );
521 QStringList exportVectorOptions;
522 exportVectorOptions << QObject::tr(
"Cartesian (x,y)" )
523 << QObject::tr(
"Polar (magnitude,degree)" )
524 << QObject::tr(
"Cartesian and Polar" );
525 addParameter(
new QgsProcessingParameterEnum( QStringLiteral(
"VECTOR_OPTION" ), QObject::tr(
"Export vector option" ), exportVectorOptions,
false, 0 ) );
529static void extractDatasetValues(
const QList<int> &datasetGroups,
533 const QSet<int> supportedDataType,
534 QList<DataGroup> &datasetPerGroup,
537 for (
int i = 0; i < datasetGroups.count(); ++i )
539 int groupIndex = datasetGroups.at( i );
544 if ( supportedDataType.contains( dataGroup.metadata.dataType() ) )
548 dataGroup.datasetValues = meshLayer->
datasetValues( datasetIndex, 0, valueCount );
552 dataGroup.dataset3dStakedValue = meshLayer->
dataset3dValues( datasetIndex, 0, valueCount );
554 datasetPerGroup.append( dataGroup );
557 feedback->
setProgress( 100 * i / datasetGroups.count() );
563 QgsMeshLayer *meshLayer = parameterAsMeshLayer( parameters, QStringLiteral(
"INPUT" ), context );
565 if ( !meshLayer || !meshLayer->
isValid() )
577 QList<int> datasetGroups =
586 QVariant parameterTimeVariant = parameters.value( QStringLiteral(
"DATASET_TIME" ) );
587 QgsInterval relativeTime = datasetRelativetime( parameterTimeVariant, meshLayer, context );
589 extractDatasetValues( datasetGroups, meshLayer, nativeMesh, relativeTime, supportedDataType(), mDataPerGroup, feedback );
590 mTriangularMesh.update( meshLayer->
nativeMesh(), mTransform );
592 mExportVectorOption = parameterAsInt( parameters, QStringLiteral(
"VECTOR_OPTION" ), context );
602 return QVariantMap();
604 feedback->
setProgressText( QObject::tr(
"Creating output vector layer" ) );
609 for ( DataGroup &dataGroup : mDataPerGroup )
611 if ( dataGroup.dataset3dStakedValue.isValid() )
612 dataGroup.datasetValues = avgMethod->
calculate( dataGroup.dataset3dStakedValue );
615 QList<QgsMeshDatasetGroupMetadata> metaList;
616 metaList.reserve( mDataPerGroup.size() );
617 for (
const DataGroup &dataGroup : std::as_const( mDataPerGroup ) )
618 metaList.append( dataGroup.metadata );
619 QgsFields fields = createFields( metaList, mExportVectorOption );
624 std::unique_ptr<QgsFeatureSink> sink( parameterAsSink( parameters,
625 QStringLiteral(
"OUTPUT" ),
632 return QVariantMap();
637 return QVariantMap();
643 double gridSpacing = parameterAsDouble( parameters, QStringLiteral(
"GRID_SPACING" ), context );
644 QgsRectangle extent = parameterAsExtent( parameters, QStringLiteral(
"EXTENT" ), context );
646 extent = mTriangularMesh.extent();
647 int pointXCount = int( extent.
width() / gridSpacing ) + 1;
648 int pointYCount = int( extent.
height() / gridSpacing ) + 1;
650 for (
int ix = 0; ix < pointXCount; ++ix )
652 for (
int iy = 0; iy < pointYCount; ++iy )
655 int triangularFaceIndex = mTriangularMesh.faceIndexForPoint_v2( point );
656 if ( triangularFaceIndex >= 0 )
660 int nativeFaceIndex = mTriangularMesh.trianglesToNativeFaces().at( triangularFaceIndex );
661 for (
int i = 0; i < mDataPerGroup.count(); ++i )
663 const DataGroup &dataGroup = mDataPerGroup.at( i );
664 bool faceActive = dataGroup.activeFaces.active( nativeFaceIndex );
672 dataGroup.activeFaces,
673 dataGroup.datasetValues,
674 dataGroup.metadata );
676 if ( dataGroup.metadata.isVector() )
678 QVector<double> vector = vectorValue( dataGroup.datasetValues.value( i ), mExportVectorOption );
679 for (
double v : vector )
681 attributes.append( v );
685 attributes.append( value.
scalar() );
696 feedback->
reportError( QObject::tr(
"Could not transform point to destination CRS" ) );
701 sink->addFeature( feat );
707 ret[QStringLiteral(
"OUTPUT" )] = identifier;
712QSet<int> QgsExportMeshOnGridAlgorithm::supportedDataType()
721QString QgsMeshRasterizeAlgorithm::name()
const
723 return QStringLiteral(
"meshrasterize" );
726QString QgsMeshRasterizeAlgorithm::displayName()
const
728 return QObject::tr(
"Rasterize mesh dataset" );
731QString QgsMeshRasterizeAlgorithm::group()
const
733 return QObject::tr(
"Mesh" );
736QString QgsMeshRasterizeAlgorithm::groupId()
const
738 return QStringLiteral(
"mesh" );
741QString QgsMeshRasterizeAlgorithm::shortHelpString()
const
743 return QObject::tr(
"This algorithm creates a raster layer from a mesh dataset.\n"
744 "For data on volume (3D stacked dataset values), the exported dataset values are averaged on faces using the method defined in the mesh layer properties (default is Multi level averaging method).\n"
745 "1D meshes are not supported." );
748QString QgsMeshRasterizeAlgorithm::shortDescription()
const
750 return QObject::tr(
"Creates a raster layer from a mesh dataset" );
755 return new QgsMeshRasterizeAlgorithm();
758void QgsMeshRasterizeAlgorithm::initAlgorithm(
const QVariantMap &configuration )
760 Q_UNUSED( configuration );
765 QStringLiteral(
"DATASET_GROUPS" ),
766 QObject::tr(
"Dataset groups" ),
767 QStringLiteral(
"INPUT" ),
772 QStringLiteral(
"DATASET_TIME" ),
773 QObject::tr(
"Dataset time" ),
774 QStringLiteral(
"INPUT" ),
775 QStringLiteral(
"DATASET_GROUPS" ) ) );
778 addParameter(
new QgsProcessingParameterDistance( QStringLiteral(
"PIXEL_SIZE" ), QObject::tr(
"Pixel size" ), 1, QStringLiteral(
"INPUT" ),
false ) );
779 addParameter(
new QgsProcessingParameterCrs( QStringLiteral(
"CRS_OUTPUT" ), QObject::tr(
"Output coordinate system" ), QVariant(),
true ) );
781 std::unique_ptr< QgsProcessingParameterString > createOptsParam = std::make_unique< QgsProcessingParameterString >( QStringLiteral(
"CREATE_OPTIONS" ), QObject::tr(
"Creation options" ), QVariant(),
false,
true );
782 createOptsParam->setMetadata( QVariantMap( {{QStringLiteral(
"widget_wrapper" ), QVariantMap( {{QStringLiteral(
"widget_type" ), QStringLiteral(
"rasteroptions" ) }} ) }} ) );
784 addParameter( createOptsParam.release() );
791 QgsMeshLayer *meshLayer = parameterAsMeshLayer( parameters, QStringLiteral(
"INPUT" ), context );
793 if ( !meshLayer || !meshLayer->
isValid() )
803 mTriangularMesh.update( meshLayer->
nativeMesh(), mTransform );
805 QList<int> datasetGroups =
814 QVariant parameterTimeVariant = parameters.value( QStringLiteral(
"DATASET_TIME" ) );
815 QgsInterval relativeTime = datasetRelativetime( parameterTimeVariant, meshLayer, context );
817 extractDatasetValues( datasetGroups, meshLayer, *meshLayer->
nativeMesh(), relativeTime, supportedDataType(), mDataPerGroup, feedback );
829 return QVariantMap();
836 for ( DataGroup &dataGroup : mDataPerGroup )
838 if ( dataGroup.dataset3dStakedValue.isValid() )
839 dataGroup.datasetValues = avgMethod->
calculate( dataGroup.dataset3dStakedValue );
843 double pixelSize = parameterAsDouble( parameters, QStringLiteral(
"PIXEL_SIZE" ), context );
844 QgsRectangle extent = parameterAsExtent( parameters, QStringLiteral(
"EXTENT" ), context );
846 extent = mTriangularMesh.extent();
848 int width = extent.
width() / pixelSize;
849 int height = extent.
height() / pixelSize;
851 const QString createOptions = parameterAsString( parameters, QStringLiteral(
"CREATE_OPTIONS" ), context ).trimmed();
852 const QString fileName = parameterAsOutputLayer( parameters, QStringLiteral(
"OUTPUT" ), context );
853 const QFileInfo fileInfo( fileName );
856 rasterFileWriter.setOutputProviderKey( QStringLiteral(
"gdal" ) );
857 if ( !createOptions.isEmpty() )
859 rasterFileWriter.setCreateOptions( createOptions.split(
'|' ) );
861 rasterFileWriter.setOutputFormat( outputFormat );
863 std::unique_ptr<QgsRasterDataProvider> rasterDataProvider(
864 rasterFileWriter.createMultiBandRaster(
Qgis::DataType::Float64, width, height, extent, mTransform.destinationCrs(), mDataPerGroup.count() ) );
865 rasterDataProvider->setEditable(
true );
867 for (
int i = 0; i < mDataPerGroup.count(); ++i )
869 const DataGroup &dataGroup = mDataPerGroup.at( i );
874 if ( dataGroup.datasetValues.isValid() )
878 dataGroup.datasetValues,
879 dataGroup.activeFaces,
880 dataGroup.metadata.dataType(),
884 &rasterBlockFeedBack ) );
886 rasterDataProvider->writeBlock( block.get(), i + 1 );
887 rasterDataProvider->setNoDataValue( i + 1, block->noDataValue() );
890 rasterDataProvider->setNoDataValue( i + 1, std::numeric_limits<double>::quiet_NaN() );
895 return QVariantMap();
896 feedback->
setProgress( 100 * i / mDataPerGroup.count() );
900 rasterDataProvider->setEditable(
false );
906 ret[QStringLiteral(
"OUTPUT" )] = fileName;
911QSet<int> QgsMeshRasterizeAlgorithm::supportedDataType()
920QString QgsMeshContoursAlgorithm::name()
const
922 return QStringLiteral(
"meshcontours" );
925QString QgsMeshContoursAlgorithm::displayName()
const
927 return QObject::tr(
"Export contours" );
930QString QgsMeshContoursAlgorithm::group()
const
932 return QObject::tr(
"Mesh" );
935QString QgsMeshContoursAlgorithm::groupId()
const
937 return QStringLiteral(
"mesh" );
940QString QgsMeshContoursAlgorithm::shortHelpString()
const
942 return QObject::tr(
"This algorithm creates contours as a vector layer from a mesh scalar dataset." );
945QString QgsMeshContoursAlgorithm::shortDescription()
const
947 return QObject::tr(
"Creates contours as vector layer from mesh scalar dataset" );
952 return new QgsMeshContoursAlgorithm();
955void QgsMeshContoursAlgorithm::initAlgorithm(
const QVariantMap &configuration )
957 Q_UNUSED( configuration );
962 QStringLiteral(
"DATASET_GROUPS" ),
963 QObject::tr(
"Dataset groups" ),
964 QStringLiteral(
"INPUT" ),
965 supportedDataType() ) );
968 QStringLiteral(
"DATASET_TIME" ),
969 QObject::tr(
"Dataset time" ),
970 QStringLiteral(
"INPUT" ),
971 QStringLiteral(
"DATASET_GROUPS" ) ) );
981 std::unique_ptr< QgsProcessingParameterString > contourLevelList = std::make_unique < QgsProcessingParameterString >(
982 QStringLiteral(
"CONTOUR_LEVEL_LIST" ), QObject::tr(
"List of contours level" ), QVariant(),
false,
true );
983 contourLevelList->setHelp( QObject::tr(
"Comma separated list of values to export. If filled, the increment, minimum and maximum settings are ignored." ) );
984 addParameter( contourLevelList.release() );
986 addParameter(
new QgsProcessingParameterCrs( QStringLiteral(
"CRS_OUTPUT" ), QObject::tr(
"Output coordinate system" ), QVariant(),
true ) );
995 QgsMeshLayer *meshLayer = parameterAsMeshLayer( parameters, QStringLiteral(
"INPUT" ), context );
997 if ( !meshLayer || !meshLayer->
isValid() )
1007 mTriangularMesh.update( meshLayer->
nativeMesh(), mTransform );
1013 QString levelsString = parameterAsString( parameters, QStringLiteral(
"CONTOUR_LEVEL_LIST" ), context );
1014 if ( ! levelsString.isEmpty() )
1016 QStringList levelStringList = levelsString.split(
',' );
1017 if ( !levelStringList.isEmpty() )
1019 for (
const QString &stringVal : levelStringList )
1022 double val = stringVal.toDouble( &ok );
1024 mLevels.append( val );
1026 throw QgsProcessingException( QObject::tr(
"Invalid format for level values, must be numbers separated with comma" ) );
1028 if ( mLevels.count() >= 2 )
1029 if ( mLevels.last() <= mLevels.at( mLevels.count() - 2 ) )
1030 throw QgsProcessingException( QObject::tr(
"Invalid format for level values, must be different numbers and in increasing order" ) );
1035 if ( mLevels.isEmpty() )
1037 double minimum = parameterAsDouble( parameters, QStringLiteral(
"MINIMUM" ), context );
1038 double maximum = parameterAsDouble( parameters, QStringLiteral(
"MAXIMUM" ), context );
1039 double interval = parameterAsDouble( parameters, QStringLiteral(
"INCREMENT" ), context );
1041 if ( interval <= 0 )
1044 if ( minimum >= maximum )
1045 throw QgsProcessingException( QObject::tr(
"Invalid minimum and maximum values, minimum must be lesser than maximum" ) );
1047 if ( interval > ( maximum - minimum ) )
1048 throw QgsProcessingException( QObject::tr(
"Invalid minimum, maximum and interval values, difference between minimum and maximum must be greater or equal than interval" ) );
1050 int intervalCount = ( maximum - minimum ) / interval;
1052 mLevels.reserve( intervalCount );
1053 for (
int i = 0; i < intervalCount; ++i )
1055 mLevels.append( minimum + i * interval );
1060 QList<int> datasetGroups =
1069 QVariant parameterTimeVariant = parameters.value( QStringLiteral(
"DATASET_TIME" ) );
1070 QgsInterval relativeTime = datasetRelativetime( parameterTimeVariant, meshLayer, context );
1074 extractDatasetValues( datasetGroups, meshLayer, mNativeMesh, relativeTime, supportedDataType(), mDataPerGroup, feedback );
1085 for ( DataGroup &dataGroup : mDataPerGroup )
1087 if ( dataGroup.dataset3dStakedValue.isValid() )
1088 dataGroup.datasetValues = avgMethod->
calculate( dataGroup.dataset3dStakedValue );
1094 polygonFields.
append(
QgsField( QObject::tr(
"group" ), QMetaType::Type::QString ) );
1095 polygonFields.
append(
QgsField( QObject::tr(
"time" ), QMetaType::Type::QString ) );
1096 polygonFields.
append(
QgsField( QObject::tr(
"min_value" ), QMetaType::Type::Double ) );
1097 polygonFields.
append(
QgsField( QObject::tr(
"max_value" ), QMetaType::Type::Double ) );
1098 lineFields.
append(
QgsField( QObject::tr(
"group" ), QMetaType::Type::QString ) );
1099 lineFields.
append(
QgsField( QObject::tr(
"time" ), QMetaType::Type::QString ) );
1100 lineFields.
append(
QgsField( QObject::tr(
"value" ), QMetaType::Type::Double ) );
1104 QString lineIdentifier;
1105 QString polygonIdentifier;
1106 std::unique_ptr<QgsFeatureSink> sinkPolygons( parameterAsSink(
1108 QStringLiteral(
"OUTPUT_POLYGONS" ),
1114 std::unique_ptr<QgsFeatureSink> sinkLines( parameterAsSink(
1116 QStringLiteral(
"OUTPUT_LINES" ),
1123 if ( !sinkLines || !sinkPolygons )
1124 return QVariantMap();
1127 for (
int i = 0; i < mDataPerGroup.count(); ++i )
1129 DataGroup dataGroup = mDataPerGroup.at( i );
1131 int count = scalarDataOnVertices ? mNativeMesh.vertices.count() : mNativeMesh.faces.count();
1133 QVector<double> values;
1134 if ( dataGroup.datasetValues.isValid() )
1137 values = QgsMeshLayerUtils::calculateMagnitudes( dataGroup.datasetValues );
1141 values = QVector<double>( count, std::numeric_limits<double>::quiet_NaN() );
1144 if ( ( !scalarDataOnVertices ) )
1146 values = QgsMeshLayerUtils::interpolateFromFacesData(
1149 &dataGroup.activeFaces,
1154 QgsMeshContours contoursExported( mTriangularMesh, mNativeMesh, values, dataGroup.activeFaces );
1157 firstAttributes.append( dataGroup.metadata.name() );
1158 firstAttributes.append( mDateTimeString );
1160 for (
double level : std::as_const( mLevels ) )
1162 QgsGeometry line = contoursExported.exportLines( level, feedback );
1164 return QVariantMap();
1168 lineAttributes.append( level );
1174 sinkLines->addFeature( lineFeat );
1178 for (
int l = 0; l < mLevels.count() - 1; ++l )
1180 QgsGeometry polygon = contoursExported.exportPolygons( mLevels.at( l ), mLevels.at( l + 1 ), feedback );
1182 return QVariantMap();
1187 polygonAttributes.append( mLevels.at( l ) );
1188 polygonAttributes.append( mLevels.at( l + 1 ) );
1193 sinkPolygons->addFeature( polygonFeature );
1198 feedback->
setProgress( 100 * i / mDataPerGroup.count() );
1203 ret[QStringLiteral(
"OUTPUT_LINES" )] = lineIdentifier;
1204 ret[QStringLiteral(
"OUTPUT_POLYGONS" )] = polygonIdentifier;
1209QString QgsMeshExportCrossSection::name()
const
1211 return QStringLiteral(
"meshexportcrosssection" );
1214QString QgsMeshExportCrossSection::displayName()
const
1216 return QObject::tr(
"Export cross section dataset values on lines from mesh" );
1219QString QgsMeshExportCrossSection::group()
const
1221 return QObject::tr(
"Mesh" );
1224QString QgsMeshExportCrossSection::groupId()
const
1226 return QStringLiteral(
"mesh" );
1229QString QgsMeshExportCrossSection::shortHelpString()
const
1231 return QObject::tr(
"This algorithm extracts mesh's dataset values from line contained in a vector layer.\n"
1232 "Each line is discretized with a resolution distance parameter for extraction of values on its vertices." );
1235QString QgsMeshExportCrossSection::shortDescription()
const
1237 return QObject::tr(
"Extracts a mesh dataset's values from lines contained in a vector layer" );
1242 return new QgsMeshExportCrossSection();
1245void QgsMeshExportCrossSection::initAlgorithm(
const QVariantMap &configuration )
1247 Q_UNUSED( configuration );
1252 QStringLiteral(
"DATASET_GROUPS" ),
1253 QObject::tr(
"Dataset groups" ),
1254 QStringLiteral(
"INPUT" ),
1255 supportedDataType() ) );
1258 QStringLiteral(
"DATASET_TIME" ),
1259 QObject::tr(
"Dataset time" ),
1260 QStringLiteral(
"INPUT" ),
1261 QStringLiteral(
"DATASET_GROUPS" ) ) );
1263 QList<int> datatype;
1266 QStringLiteral(
"INPUT_LINES" ), QObject::tr(
"Lines for data export" ), datatype, QVariant(),
false ) );
1269 QStringLiteral(
"RESOLUTION" ), QObject::tr(
"Line segmentation resolution" ), 10.0, QStringLiteral(
"INPUT_LINES" ),
false, 0 ) );
1278 QStringLiteral(
"OUTPUT" ), QObject::tr(
"Exported data CSV file" ), QObject::tr(
"CSV file (*.csv)" ) ) );
1283 QgsMeshLayer *meshLayer = parameterAsMeshLayer( parameters, QStringLiteral(
"INPUT" ), context );
1285 if ( !meshLayer || !meshLayer->
isValid() )
1288 mMeshLayerCrs = meshLayer->
crs();
1289 mTriangularMesh.update( meshLayer->
nativeMesh() );
1290 QList<int> datasetGroups =
1299 QVariant parameterTimeVariant = parameters.value( QStringLiteral(
"DATASET_TIME" ) );
1300 QgsInterval relativeTime = datasetRelativetime( parameterTimeVariant, meshLayer, context );
1302 extractDatasetValues( datasetGroups, meshLayer, *meshLayer->
nativeMesh(), relativeTime, supportedDataType(), mDataPerGroup, feedback );
1315 for ( DataGroup &dataGroup : mDataPerGroup )
1317 if ( dataGroup.dataset3dStakedValue.isValid() )
1318 dataGroup.datasetValues = avgMethod->
calculate( dataGroup.dataset3dStakedValue );
1320 double resolution = parameterAsDouble( parameters, QStringLiteral(
"RESOLUTION" ), context );
1321 int datasetDigits = parameterAsInt( parameters, QStringLiteral(
"DATASET_DIGITS" ), context );
1322 int coordDigits = parameterAsInt( parameters, QStringLiteral(
"COORDINATES_DIGITS" ), context );
1324 std::unique_ptr< QgsProcessingFeatureSource > featureSource( parameterAsSource( parameters, QStringLiteral(
"INPUT_LINES" ), context ) );
1325 if ( !featureSource )
1330 QString outputFileName = parameterAsFileOutput( parameters, QStringLiteral(
"OUTPUT" ), context );
1331 QFile file( outputFileName );
1332 if ( ! file.open( QIODevice::WriteOnly | QIODevice::Truncate ) )
1335 QTextStream textStream( &file );
1336#if QT_VERSION < QT_VERSION_CHECK(6, 0, 0)
1337 textStream.setCodec(
"UTF-8" );
1340 header << QStringLiteral(
"fid" ) << QStringLiteral(
"x" ) << QStringLiteral(
"y" ) << QObject::tr(
"offset" );
1341 for (
const DataGroup &datagroup : std::as_const( mDataPerGroup ) )
1342 header << datagroup.metadata.name();
1343 textStream << header.join(
',' ) << QStringLiteral(
"\n" );
1345 long long featCount = featureSource->featureCount();
1346 long long featCounter = 0;
1360 feedback->
reportError( QObject::tr(
"Could not transform line to mesh CRS" ) );
1366 while ( offset <= line.
length() )
1369 return QVariantMap();
1371 QStringList textLine;
1373 int triangularFaceIndex = mTriangularMesh.faceIndexForPoint_v2( point );
1374 textLine << QString::number( fid ) << QString::number( point.
x(),
'f', coordDigits ) << QString::number( point.
y(),
'f', coordDigits ) << QString::number( offset,
'f', coordDigits );
1375 if ( triangularFaceIndex >= 0 )
1379 int nativeFaceIndex = mTriangularMesh.trianglesToNativeFaces().at( triangularFaceIndex );
1380 for (
int i = 0; i < mDataPerGroup.count(); ++i )
1382 const DataGroup &dataGroup = mDataPerGroup.at( i );
1383 bool faceActive = dataGroup.activeFaces.active( nativeFaceIndex );
1389 triangularFaceIndex,
1391 dataGroup.activeFaces,
1392 dataGroup.datasetValues,
1393 dataGroup.metadata );
1395 if ( abs( value.
x() ) == std::numeric_limits<double>::quiet_NaN() )
1396 textLine << QString(
' ' );
1398 textLine << QString::number( value.
scalar(),
'f', datasetDigits );
1402 for (
int i = 0; i < mDataPerGroup.count(); ++i )
1403 textLine << QString(
' ' );
1405 textStream << textLine.join(
',' ) << QStringLiteral(
"\n" );
1407 offset += resolution;
1412 feedback->
setProgress( 100.0 * featCounter / featCount );
1414 return QVariantMap();
1421 ret[QStringLiteral(
"OUTPUT" )] = outputFileName;
1425QString QgsMeshExportTimeSeries::name()
const
1427 return QStringLiteral(
"meshexporttimeseries" );
1430QString QgsMeshExportTimeSeries::displayName()
const
1432 return QObject::tr(
"Export time series values from points of a mesh dataset" );
1435QString QgsMeshExportTimeSeries::group()
const
1437 return QObject::tr(
"Mesh" );
1440QString QgsMeshExportTimeSeries::groupId()
const
1442 return QStringLiteral(
"mesh" );
1445QString QgsMeshExportTimeSeries::shortHelpString()
const
1447 return QObject::tr(
"This algorithm extracts mesh's dataset time series values from points contained in a vector layer.\n"
1448 "If the time step is kept to its default value (0 hours), the time step used is the one of the two first datasets of the first selected dataset group." );
1451QString QgsMeshExportTimeSeries::shortDescription()
const
1453 return QObject::tr(
"Extracts a mesh dataset's time series values from points contained in a vector layer" );
1458 return new QgsMeshExportTimeSeries();
1461void QgsMeshExportTimeSeries::initAlgorithm(
const QVariantMap &configuration )
1463 Q_UNUSED( configuration );
1468 QStringLiteral(
"DATASET_GROUPS" ),
1469 QObject::tr(
"Dataset groups" ),
1470 QStringLiteral(
"INPUT" ),
1471 supportedDataType() ) );
1474 QStringLiteral(
"STARTING_TIME" ),
1475 QObject::tr(
"Starting time" ),
1476 QStringLiteral(
"INPUT" ),
1477 QStringLiteral(
"DATASET_GROUPS" ) ) );
1480 QStringLiteral(
"FINISHING_TIME" ),
1481 QObject::tr(
"Finishing time" ),
1482 QStringLiteral(
"INPUT" ),
1483 QStringLiteral(
"DATASET_GROUPS" ) ) );
1488 QList<int> datatype;
1491 QStringLiteral(
"INPUT_POINTS" ), QObject::tr(
"Points for data export" ), datatype, QVariant(),
false ) );
1500 QStringLiteral(
"OUTPUT" ), QObject::tr(
"Exported data CSV file" ), QObject::tr(
"CSV file (*.csv)" ) ) );
1505 QgsMeshLayer *meshLayer = parameterAsMeshLayer( parameters, QStringLiteral(
"INPUT" ), context );
1507 if ( !meshLayer || !meshLayer->
isValid() )
1510 mMeshLayerCrs = meshLayer->
crs();
1511 mTriangularMesh.update( meshLayer->
nativeMesh() );
1513 QList<int> datasetGroups =
1522 QVariant parameterStartTimeVariant = parameters.value( QStringLiteral(
"STARTING_TIME" ) );
1523 QgsInterval relativeStartTime = datasetRelativetime( parameterStartTimeVariant, meshLayer, context );
1525 QVariant parameterEndTimeVariant = parameters.value( QStringLiteral(
"FINISHING_TIME" ) );
1526 QgsInterval relativeEndTime = datasetRelativetime( parameterEndTimeVariant, meshLayer, context );
1529 qint64 timeStepInterval = parameterAsDouble( parameters, QStringLiteral(
"TIME_STEP" ), context ) * 1000 * 3600;
1530 if ( timeStepInterval == 0 )
1533 for (
int groupIndex : datasetGroups )
1547 mRelativeTimeSteps.clear();
1548 mTimeStepString.clear();
1549 if ( timeStepInterval != 0 )
1551 mRelativeTimeSteps.append( relativeStartTime.
seconds() * 1000 );
1552 while ( mRelativeTimeSteps.last() < relativeEndTime.
seconds() * 1000 )
1553 mRelativeTimeSteps.append( mRelativeTimeSteps.last() + timeStepInterval );
1555 for ( qint64 relativeTimeStep : std::as_const( mRelativeTimeSteps ) )
1557 mTimeStepString.append( meshLayer->
formatTime( relativeTimeStep / 3600.0 / 1000.0 ) );
1562 for (
int i = 0; i < datasetGroups.count(); ++i )
1564 int groupIndex = datasetGroups.at( i );
1566 if ( supportedDataType().contains( meta.
dataType() ) )
1568 mGroupIndexes.append( groupIndex );
1569 mGroupsMetadata[groupIndex] = meta;
1573 if ( !mRelativeTimeSteps.isEmpty() )
1577 for ( qint64 relativeTimeStep : std::as_const( mRelativeTimeSteps ) )
1579 QMap<int, int> &groupIndexToData = mRelativeTimeToData[relativeTimeStep];
1580 QgsInterval timeStepInterval( relativeTimeStep / 1000.0 );
1582 if ( !datasetIndex.
isValid() )
1584 if ( datasetIndex != lastDatasetIndex )
1586 DataGroup dataGroup;
1587 dataGroup.metadata = meta;
1588 dataGroup.datasetValues = meshLayer->
datasetValues( datasetIndex, 0, valueCount );
1592 dataGroup.dataset3dStakedValue = meshLayer->
dataset3dValues( datasetIndex, 0, valueCount );
1594 mDatasets.append( dataGroup );
1595 lastDatasetIndex = datasetIndex;
1597 groupIndexToData[groupIndex] = mDatasets.count() - 1;
1603 QMap<int, int> &groupIndexToData = mRelativeTimeToData[0];
1605 DataGroup dataGroup;
1606 dataGroup.metadata = meta;
1607 dataGroup.datasetValues = meshLayer->
datasetValues( datasetIndex, 0, valueCount );
1611 dataGroup.dataset3dStakedValue = meshLayer->
dataset3dValues( datasetIndex, 0, valueCount );
1613 mDatasets.append( dataGroup );
1614 groupIndexToData[groupIndex] = mDatasets.
count() - 1;
1619 feedback->
setProgress( 100 * i / datasetGroups.count() );
1635 for ( DataGroup &dataGroup : mDatasets )
1637 if ( dataGroup.dataset3dStakedValue.isValid() )
1638 dataGroup.datasetValues = avgMethod->
calculate( dataGroup.dataset3dStakedValue );
1641 int datasetDigits = parameterAsInt( parameters, QStringLiteral(
"DATASET_DIGITS" ), context );
1642 int coordDigits = parameterAsInt( parameters, QStringLiteral(
"COORDINATES_DIGITS" ), context );
1644 std::unique_ptr< QgsProcessingFeatureSource > featureSource( parameterAsSource( parameters, QStringLiteral(
"INPUT_POINTS" ), context ) );
1645 if ( !featureSource )
1650 QString outputFileName = parameterAsFileOutput( parameters, QStringLiteral(
"OUTPUT" ), context );
1651 QFile file( outputFileName );
1652 if ( ! file.open( QIODevice::WriteOnly | QIODevice::Truncate ) )
1655 QTextStream textStream( &file );
1656#if QT_VERSION < QT_VERSION_CHECK(6, 0, 0)
1657 textStream.setCodec(
"UTF-8" );
1660 header << QStringLiteral(
"fid" ) << QStringLiteral(
"x" ) << QStringLiteral(
"y" ) << QObject::tr(
"time" );
1662 for (
int gi : std::as_const( mGroupIndexes ) )
1663 header << mGroupsMetadata.value( gi ).name();
1665 textStream << header.join(
',' ) << QStringLiteral(
"\n" );
1667 long long featCount = featureSource->featureCount();
1668 long long featCounter = 0;
1682 feedback->
reportError( QObject::tr(
"Could not transform line to mesh CRS" ) );
1689 int triangularFaceIndex = mTriangularMesh.faceIndexForPoint_v2( point );
1691 if ( triangularFaceIndex >= 0 )
1693 int nativeFaceIndex = mTriangularMesh.trianglesToNativeFaces().at( triangularFaceIndex );
1694 if ( !mRelativeTimeSteps.isEmpty() )
1696 for (
int timeIndex = 0; timeIndex < mRelativeTimeSteps.count(); ++timeIndex )
1698 qint64 timeStep = mRelativeTimeSteps.at( timeIndex );
1699 QStringList textLine;
1700 textLine << QString::number( fid )
1701 << QString::number( point.
x(),
'f', coordDigits )
1702 << QString::number( point.
y(),
'f', coordDigits )
1703 << mTimeStepString.at( timeIndex );
1705 if ( mRelativeTimeToData.contains( timeStep ) )
1707 const QMap<int, int> &groupToData = mRelativeTimeToData.value( timeStep );
1708 for (
int groupIndex : std::as_const( mGroupIndexes ) )
1710 if ( !groupToData.contains( groupIndex ) )
1712 int dataIndex = groupToData.value( groupIndex );
1713 if ( dataIndex < 0 || dataIndex > mDatasets.count() - 1 )
1716 const DataGroup &dataGroup = mDatasets.at( dataIndex );
1719 triangularFaceIndex,
1721 dataGroup.activeFaces,
1722 dataGroup.datasetValues,
1723 dataGroup.metadata );
1724 if ( abs( value.
x() ) == std::numeric_limits<double>::quiet_NaN() )
1725 textLine << QString(
' ' );
1727 textLine << QString::number( value.
scalar(),
'f', datasetDigits ) ;
1730 textStream << textLine.join(
',' ) << QStringLiteral(
"\n" );
1735 QStringList textLine;
1736 textLine << QString::number( fid )
1737 << QString::number( point.
x(),
'f', coordDigits )
1738 << QString::number( point.
y(),
'f', coordDigits )
1739 << QObject::tr(
"static dataset" );
1740 const QMap<int, int> &groupToData = mRelativeTimeToData.value( 0 );
1741 for (
int groupIndex : std::as_const( mGroupIndexes ) )
1743 if ( !groupToData.contains( groupIndex ) )
1745 int dataIndex = groupToData.value( groupIndex );
1746 if ( dataIndex < 0 || dataIndex > mDatasets.count() - 1 )
1748 const DataGroup &dataGroup = mDatasets.at( dataIndex );
1751 triangularFaceIndex,
1753 dataGroup.activeFaces,
1754 dataGroup.datasetValues,
1755 dataGroup.metadata );
1756 if ( abs( value.
x() ) == std::numeric_limits<double>::quiet_NaN() )
1757 textLine << QString(
' ' );
1759 textLine << QString::number( value.
scalar(),
'f', datasetDigits );
1761 textStream << textLine.join(
',' ) << QStringLiteral(
"\n" );
1767 feedback->
setProgress( 100.0 * featCounter / featCount );
1769 return QVariantMap();
1776 ret[QStringLiteral(
"OUTPUT" )] = outputFileName;
@ VectorPoint
Vector point layers.
@ VectorPolygon
Vector polygon layers.
@ VectorLine
Vector line layers.
@ Float64
Sixty four bit floating point (double)
@ LineStringZ
LineStringZ.
@ Advanced
Parameter is an advanced parameter which should be hidden from users by default.
@ Double
Double/float values.
This class represents a coordinate reference system (CRS).
bool isValid() const
Returns whether this CRS is correctly initialized and usable.
Custom exception class for Coordinate Reference System related exceptions.
Wrapper for iterator of features from vector data provider or vector layer.
bool nextFeature(QgsFeature &f)
Fetch next feature and stores in f, returns true on success.
@ FastInsert
Use faster inserts, at the cost of updating the passed features to reflect changes made at the provid...
The feature class encapsulates a single feature including its unique ID, geometry and a list of field...
void setAttributes(const QgsAttributes &attrs)
Sets the feature's attributes.
void setGeometry(const QgsGeometry &geometry)
Set the feature's geometry.
bool isCanceled() const
Tells whether the operation has been canceled already.
void canceled()
Internal routines can connect to this signal if they use event loop.
void cancel()
Tells the internal routines that the current operation should be canceled. This should be run by the ...
void setProgress(double progress)
Sets the current progress for the feedback object.
Encapsulate a field in an attribute table or data source.
Container of fields for a vector layer.
bool append(const QgsField &field, Qgis::FieldOrigin origin=Qgis::FieldOrigin::Provider, int originIndex=-1)
Appends a field.
A geometry is the spatial representation of a feature.
double length() const
Returns the planar, 2-dimensional length of geometry.
Qgis::GeometryOperationResult transform(const QgsCoordinateTransform &ct, Qgis::TransformDirection direction=Qgis::TransformDirection::Forward, bool transformZ=false)
Transforms this geometry as described by the coordinate transform ct.
QgsGeometry interpolate(double distance) const
Returns an interpolated point on the geometry at the specified distance.
QgsPointXY asPoint() const
Returns the contents of the geometry as a 2-dimensional point.
bool isEmpty() const
Returns true if the geometry is empty (eg a linestring with no vertices, or a collection with no geom...
A representation of the interval between two datetime values.
double seconds() const
Returns the interval duration in seconds.
double hours() const
Returns the interval duration in hours.
Line string geometry type, with support for z-dimension and m-values.
QgsCoordinateReferenceSystem crs
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.
int count() const
Number of 2d faces for which the volume data is stored in the block.
Exporter of contours lines or polygons from a mesh layer.
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 active(int index) const
Returns a value for active flag by the index For scalar and vector 2d the behavior is undefined.
QgsMeshDatasetIndex is index that identifies the dataset group (e.g.
bool isValid() const
Returns whether index is valid, ie at least groups is set.
QgsMeshDatasetValue represents single dataset value.
double y() const
Returns y value.
double scalar() const
Returns magnitude of vector for vector data or scalar value for scalar data.
double x() const
Returns x value.
Implementation of map layer temporal properties for mesh layers.
Represents a mesh layer supporting display of data on structured or unstructured meshes.
int datasetCount(const QgsMeshDatasetIndex &index) const
Returns the dataset count in the dataset groups.
QgsMeshRendererSettings rendererSettings() const
Returns renderer settings.
void updateTriangularMesh(const QgsCoordinateTransform &transform=QgsCoordinateTransform())
Gets native mesh and updates (creates if it doesn't exist) the base triangular mesh.
QgsMesh * nativeMesh()
Returns native mesh (nullptr before rendering or calling to updateMesh)
QgsMeshDatasetIndex datasetIndexAtRelativeTime(const QgsInterval &relativeTime, int datasetGroupIndex) const
Returns dataset index from datasets group depending on the relative time from the layer reference tim...
QgsMeshDataBlock datasetValues(const QgsMeshDatasetIndex &index, int valueIndex, int count) const
Returns N vector/scalar values from the index from the dataset.
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.
QgsInterval datasetRelativeTime(const QgsMeshDatasetIndex &index)
Returns the relative time of the dataset from the reference time of its group.
QgsMapLayerTemporalProperties * temporalProperties() override
Returns the layer's temporal properties.
qint64 datasetRelativeTimeInMilliseconds(const QgsMeshDatasetIndex &index)
Returns the relative time (in milliseconds) of the dataset from the reference time of its group.
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.
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.
@ NeighbourAverage
Does a simple average of values defined for all surrounding faces/vertices.
A class to represent a 2D point.
Point geometry type, with support for z-dimension and m-values.
Abstract base class for processing algorithms.
Contains information about the context in which a processing algorithm is executed.
QgsDateTimeRange currentTimeRange() const
Returns the current time range to use for temporal operations.
QgsCoordinateTransformContext transformContext() const
Returns the coordinate transform context.
Custom exception class for processing related exceptions.
Base class for providing feedback from a processing algorithm.
virtual void reportError(const QString &error, bool fatalError=false)
Reports that the algorithm encountered an error while executing.
virtual void setProgressText(const QString &text)
Sets a progress report text string.
A coordinate reference system parameter for processing algorithms.
A double numeric parameter for distance values.
An enum based parameter for processing algorithms, allowing for selection from predefined values.
A rectangular map extent parameter for processing algorithms.
A feature sink output for processing algorithms.
An input feature source (such as vector layers) parameter for processing algorithms.
A generic file based destination parameter, for specifying the destination path for a file (non-map l...
A parameter for processing algorithms that need a list of mesh dataset groups.
static QList< int > valueAsDatasetGroup(const QVariant &value)
Returns the value as a list if dataset group indexes.
A parameter for processing algorithms that need a list of mesh dataset index from time parameter.
static QString valueAsTimeType(const QVariant &value)
Returns the dataset value time type as a string : current-context-time : the time is store in the pro...
static QgsMeshDatasetIndex timeValueAsDatasetIndex(const QVariant &value)
Returns the value as a QgsMeshDatasetIndex if the value has "dataset-time-step" type.
static QDateTime timeValueAsDefinedDateTime(const QVariant &value)
Returns the value as a QDateTime if the value has "defined-date-time" type.
A mesh layer parameter for processing algorithms.
A numeric parameter for processing algorithms.
A raster layer destination parameter, for specifying the destination path for a raster layer created ...
Feedback object tailored for raster block reading.
The raster file writer which allows you to save a raster to a new file.
static QString driverForExtension(const QString &extension)
Returns the GDAL driver name for a specified file extension.
A rectangle specified with double values.
double xMinimum() const
Returns the x minimum value (left side of rectangle).
double yMinimum() const
Returns the y minimum value (bottom side of rectangle).
double width() const
Returns the width of the rectangle.
bool isEmpty() const
Returns true if the rectangle has no area.
double height() const
Returns the height of the rectangle.
T begin() const
Returns the beginning of the range.
Triangular/Derived Mesh is mesh with vertices in map coordinates.
const QVector< QgsMeshFace > & triangles() const
Returns triangles.
const QVector< QgsMeshVertex > & vertices() const
Returns vertices in map coordinate system.
CORE_EXPORT QgsRasterBlock * exportRasterBlock(const QgsMeshLayer &layer, const QgsMeshDatasetIndex &datasetIndex, const QgsCoordinateReferenceSystem &destinationCrs, const QgsCoordinateTransformContext &transformContext, double mapUnitsPerPixel, const QgsRectangle &extent, QgsRasterBlockFeedback *feedback=nullptr)
Exports mesh layer's dataset values as raster block.
qint64 QgsFeatureId
64 bit feature ids negative numbers are used for uncommitted/newly added features
QVector< int > QgsMeshFace
List of vertex indexes.
QPair< int, int > QgsMeshEdge
Edge is a straight line seqment between 2 points.
const QgsCoordinateReferenceSystem & outputCrs
Mesh - vertices, edges and faces.
QVector< QgsMeshVertex > vertices
void clear()
Remove all vertices, edges and faces.
int faceCount() const
Returns number of faces.