30 #include <QTextStream>
35 static QgsFields createFields(
const QList<QgsMeshDatasetGroupMetadata> &groupMetadataList,
int vectorOption )
40 if ( meta.isVector() )
42 if ( vectorOption == 0 || vectorOption == 2 )
44 fields.
append( QStringLiteral(
"%1_x" ).arg( meta.name() ) );
45 fields.
append( QStringLiteral(
"%1_y" ).arg( meta.name() ) );
48 if ( vectorOption == 1 || vectorOption == 2 )
50 fields.
append( QStringLiteral(
"%1_mag" ).arg( meta.name() ) );
51 fields.
append( QStringLiteral(
"%1_dir" ).arg( meta.name() ) );
55 fields.
append( meta.name() );
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 );
162 QString QgsExportMeshOnElement::group()
const
164 return QObject::tr(
"Mesh" );
167 QString QgsExportMeshOnElement::groupId()
const
169 return QStringLiteral(
"mesh" );
172 QString 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." );
177 QString QgsExportMeshVerticesAlgorithm::shortDescription()
const
179 return QObject::tr(
"Exports mesh vertices to a point vector layer" );
182 QString QgsExportMeshVerticesAlgorithm::name()
const
184 return QStringLiteral(
"exportmeshvertices" );
187 QString QgsExportMeshVerticesAlgorithm::displayName()
const
189 return QObject::tr(
"Export mesh vertices" );
194 return new QgsExportMeshVerticesAlgorithm();
197 QgsGeometry QgsExportMeshVerticesAlgorithm::meshElement(
int index )
const
202 void 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 : mDataPerGroup )
337 metaList.append( dataGroup.metadata );
338 QgsFields fields = createFields( metaList, mExportVectorOption );
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;
401 QString 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." );
406 QString QgsExportMeshFacesAlgorithm::shortDescription()
const
408 return QObject::tr(
"Exports mesh faces to a polygon vector layer" );
411 QString QgsExportMeshFacesAlgorithm::name()
const
413 return QStringLiteral(
"exportmeshfaces" );
416 QString QgsExportMeshFacesAlgorithm::displayName()
const
418 return QObject::tr(
"Export mesh faces" );
423 return new QgsExportMeshFacesAlgorithm();
426 QgsGeometry 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>();
437 QString 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." );
442 QString QgsExportMeshEdgesAlgorithm::shortDescription()
const
444 return QObject::tr(
"Exports mesh edges to a line vector layer" );
447 QString QgsExportMeshEdgesAlgorithm::name()
const
449 return QStringLiteral(
"exportmeshedges" );
452 QString QgsExportMeshEdgesAlgorithm::displayName()
const
454 return QObject::tr(
"Export mesh edges" );
459 return new QgsExportMeshEdgesAlgorithm();
462 QgsGeometry 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 );
472 QString QgsExportMeshOnGridAlgorithm::name()
const {
return QStringLiteral(
"exportmeshongrid" );}
474 QString QgsExportMeshOnGridAlgorithm::displayName()
const {
return QObject::tr(
"Export mesh on grid" );}
476 QString QgsExportMeshOnGridAlgorithm::group()
const {
return QObject::tr(
"Mesh" );}
478 QString QgsExportMeshOnGridAlgorithm::groupId()
const {
return QStringLiteral(
"mesh" );}
480 QString 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." );
487 QString QgsExportMeshOnGridAlgorithm::shortDescription()
const
489 return QObject::tr(
"Exports mesh dataset values to a gridded point vector layer" );
494 return new QgsExportMeshOnGridAlgorithm();
497 void 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 ) );
529 static 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 );
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" ) );
707 ret[QStringLiteral(
"OUTPUT" )] = identifier;
712 QSet<int> QgsExportMeshOnGridAlgorithm::supportedDataType()
721 QString QgsMeshRasterizeAlgorithm::name()
const
723 return QStringLiteral(
"meshrasterize" );
726 QString QgsMeshRasterizeAlgorithm::displayName()
const
728 return QObject::tr(
"Rasterize mesh dataset" );
731 QString QgsMeshRasterizeAlgorithm::group()
const
733 return QObject::tr(
"Mesh" );
736 QString QgsMeshRasterizeAlgorithm::groupId()
const
738 return QStringLiteral(
"mesh" );
741 QString 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." );
748 QString QgsMeshRasterizeAlgorithm::shortDescription()
const
750 return QObject::tr(
"Creates a raster layer from a mesh dataset" );
755 return new QgsMeshRasterizeAlgorithm();
758 void 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" ) ) );
779 addParameter(
new QgsProcessingParameterDistance( QStringLiteral(
"PIXEL_SIZE" ), QObject::tr(
"Pixel size" ), 1, QStringLiteral(
"INPUT" ),
false ) );
781 addParameter(
new QgsProcessingParameterCrs( QStringLiteral(
"CRS_OUTPUT" ), QObject::tr(
"Output coordinate system" ), QVariant(),
true ) );
788 QgsMeshLayer *meshLayer = parameterAsMeshLayer( parameters, QStringLiteral(
"INPUT" ), context );
790 if ( !meshLayer || !meshLayer->
isValid() )
800 mTriangularMesh.update( meshLayer->
nativeMesh(), mTransform );
802 QList<int> datasetGroups =
811 QVariant parameterTimeVariant = parameters.value( QStringLiteral(
"DATASET_TIME" ) );
812 QgsInterval relativeTime = datasetRelativetime( parameterTimeVariant, meshLayer, context );
814 extractDatasetValues( datasetGroups, meshLayer, *meshLayer->
nativeMesh(), relativeTime, supportedDataType(), mDataPerGroup, feedback );
826 return QVariantMap();
833 for ( DataGroup &dataGroup : mDataPerGroup )
835 if ( dataGroup.dataset3dStakedValue.isValid() )
836 dataGroup.datasetValues = avgMethod->
calculate( dataGroup.dataset3dStakedValue );
840 double pixelSize = parameterAsDouble( parameters, QStringLiteral(
"PIXEL_SIZE" ), context );
841 QgsRectangle extent = parameterAsExtent( parameters, QStringLiteral(
"EXTENT" ), context );
843 extent = mTriangularMesh.extent();
845 int width = extent.
width() / pixelSize;
846 int height = extent.
height() / pixelSize;
848 QString fileName = parameterAsOutputLayer( parameters, QStringLiteral(
"OUTPUT" ), context );
849 QFileInfo fileInfo( fileName );
852 rasterFileWriter.setOutputProviderKey( QStringLiteral(
"gdal" ) );
853 rasterFileWriter.setOutputFormat( outputFormat );
855 std::unique_ptr<QgsRasterDataProvider> rasterDataProvider(
856 rasterFileWriter.createMultiBandRaster(
Qgis::DataType::Float64, width, height, extent, mTransform.destinationCrs(), mDataPerGroup.count() ) );
857 rasterDataProvider->setEditable(
true );
859 for (
int i = 0; i < mDataPerGroup.count(); ++i )
861 const DataGroup &dataGroup = mDataPerGroup.at( i );
866 if ( dataGroup.datasetValues.isValid() )
870 dataGroup.datasetValues,
871 dataGroup.activeFaces,
872 dataGroup.metadata.dataType(),
876 &rasterBlockFeedBack ) );
878 rasterDataProvider->writeBlock( block.get(), i + 1 );
879 rasterDataProvider->setNoDataValue( i + 1, block->noDataValue() );
882 rasterDataProvider->setNoDataValue( i + 1, std::numeric_limits<double>::quiet_NaN() );
887 return QVariantMap();
888 feedback->
setProgress( 100 * i / mDataPerGroup.count() );
892 rasterDataProvider->setEditable(
false );
898 ret[QStringLiteral(
"OUTPUT" )] = fileName;
903 QSet<int> QgsMeshRasterizeAlgorithm::supportedDataType()
912 QString QgsMeshContoursAlgorithm::name()
const
914 return QStringLiteral(
"meshcontours" );
917 QString QgsMeshContoursAlgorithm::displayName()
const
919 return QObject::tr(
"Export contours" );
922 QString QgsMeshContoursAlgorithm::group()
const
924 return QObject::tr(
"Mesh" );
927 QString QgsMeshContoursAlgorithm::groupId()
const
929 return QStringLiteral(
"mesh" );
932 QString QgsMeshContoursAlgorithm::shortHelpString()
const
934 return QObject::tr(
"This algorithm creates contours as a vector layer from a mesh scalar dataset." );
937 QString QgsMeshContoursAlgorithm::shortDescription()
const
939 return QObject::tr(
"Creates contours as vector layer from mesh scalar dataset" );
944 return new QgsMeshContoursAlgorithm();
947 void QgsMeshContoursAlgorithm::initAlgorithm(
const QVariantMap &configuration )
949 Q_UNUSED( configuration );
954 QStringLiteral(
"DATASET_GROUPS" ),
955 QObject::tr(
"Dataset groups" ),
956 QStringLiteral(
"INPUT" ),
957 supportedDataType() ) );
960 QStringLiteral(
"DATASET_TIME" ),
961 QObject::tr(
"Dataset time" ),
962 QStringLiteral(
"INPUT" ),
963 QStringLiteral(
"DATASET_GROUPS" ) ) );
974 QStringLiteral(
"CONTOUR_LEVEL_LIST" ), QObject::tr(
"List of contours level" ), QVariant(),
false,
true ) );
976 addParameter(
new QgsProcessingParameterCrs( QStringLiteral(
"CRS_OUTPUT" ), QObject::tr(
"Output coordinate system" ), QVariant(),
true ) );
985 QgsMeshLayer *meshLayer = parameterAsMeshLayer( parameters, QStringLiteral(
"INPUT" ), context );
987 if ( !meshLayer || !meshLayer->
isValid() )
997 mTriangularMesh.update( meshLayer->
nativeMesh(), mTransform );
1003 QString levelsString = parameterAsString( parameters, QStringLiteral(
"CONTOUR_LEVEL_LIST" ), context );
1004 if ( ! levelsString.isEmpty() )
1006 QStringList levelStringList = levelsString.split(
',' );
1007 if ( !levelStringList.isEmpty() )
1009 for (
const QString &stringVal : levelStringList )
1012 double val = stringVal.toDouble( &ok );
1014 mLevels.append( val );
1016 throw QgsProcessingException( QObject::tr(
"Invalid format for level values, must be numbers separated with comma" ) );
1018 if ( mLevels.count() >= 2 )
1019 if ( mLevels.last() <= mLevels.at( mLevels.count() - 2 ) )
1020 throw QgsProcessingException( QObject::tr(
"Invalid format for level values, must be different numbers and in increasing order" ) );
1025 if ( mLevels.isEmpty() )
1027 double minimum = parameterAsDouble( parameters, QStringLiteral(
"MINIMUM" ), context );
1028 double maximum = parameterAsDouble( parameters, QStringLiteral(
"MAXIMUM" ), context );
1029 double interval = parameterAsDouble( parameters, QStringLiteral(
"INCREMENT" ), context );
1031 if ( interval <= 0 )
1034 if ( minimum >= maximum )
1035 throw QgsProcessingException( QObject::tr(
"Invalid minimum and maximum values, minimum must be lesser than maximum" ) );
1037 if ( interval > ( maximum - minimum ) )
1038 throw QgsProcessingException( QObject::tr(
"Invalid minimum, maximum and interval values, difference between minimum and maximum must be greater or equal than interval" ) );
1040 int intervalCount = ( maximum - minimum ) / interval;
1042 mLevels.reserve( intervalCount );
1043 for (
int i = 0; i < intervalCount; ++i )
1045 mLevels.append( minimum + i * interval );
1050 QList<int> datasetGroups =
1059 QVariant parameterTimeVariant = parameters.value( QStringLiteral(
"DATASET_TIME" ) );
1060 QgsInterval relativeTime = datasetRelativetime( parameterTimeVariant, meshLayer, context );
1064 extractDatasetValues( datasetGroups, meshLayer, mNativeMesh, relativeTime, supportedDataType(), mDataPerGroup, feedback );
1075 for ( DataGroup &dataGroup : mDataPerGroup )
1077 if ( dataGroup.dataset3dStakedValue.isValid() )
1078 dataGroup.datasetValues = avgMethod->
calculate( dataGroup.dataset3dStakedValue );
1084 polygonFields.
append( QObject::tr(
"group" ) );
1085 polygonFields.
append( QObject::tr(
"time" ) );
1086 polygonFields.
append( QObject::tr(
"min_value" ) );
1087 polygonFields.
append( QObject::tr(
"max_value" ) );
1088 lineFields.
append( QObject::tr(
"group" ) );
1089 lineFields.
append( QObject::tr(
"time" ) );
1090 lineFields.
append( QObject::tr(
"value" ) );
1094 QString lineIdentifier;
1095 QString polygonIdentifier;
1097 QStringLiteral(
"OUTPUT_POLYGONS" ),
1104 QStringLiteral(
"OUTPUT_LINES" ),
1111 if ( !sinkLines || !sinkPolygons )
1112 return QVariantMap();
1115 for (
int i = 0; i < mDataPerGroup.count(); ++i )
1117 DataGroup dataGroup = mDataPerGroup.at( i );
1119 int count = scalarDataOnVertices ? mNativeMesh.vertices.count() : mNativeMesh.faces.count();
1121 QVector<double> values;
1122 if ( dataGroup.datasetValues.isValid() )
1125 values = QgsMeshLayerUtils::calculateMagnitudes( dataGroup.datasetValues );
1129 values = QVector<double>( count, std::numeric_limits<double>::quiet_NaN() );
1132 if ( ( !scalarDataOnVertices ) )
1134 values = QgsMeshLayerUtils::interpolateFromFacesData(
1137 &dataGroup.activeFaces,
1142 QgsMeshContours contoursExported( mTriangularMesh, mNativeMesh, values, dataGroup.activeFaces );
1145 firstAttributes.append( dataGroup.metadata.name() );
1146 firstAttributes.append( mDateTimeString );
1148 for (
double level : std::as_const( mLevels ) )
1150 QgsGeometry line = contoursExported.exportLines( level, feedback );
1152 return QVariantMap();
1156 lineAttributes.append( level );
1166 for (
int l = 0; l < mLevels.count() - 1; ++l )
1168 QgsGeometry polygon = contoursExported.exportPolygons( mLevels.at( l ), mLevels.at( l + 1 ), feedback );
1170 return QVariantMap();
1175 polygonAttributes.append( mLevels.at( l ) );
1176 polygonAttributes.append( mLevels.at( l + 1 ) );
1186 feedback->
setProgress( 100 * i / mDataPerGroup.count() );
1191 ret[QStringLiteral(
"OUTPUT_LINES" )] = lineIdentifier;
1192 ret[QStringLiteral(
"OUTPUT_POLYGONS" )] = polygonIdentifier;
1197 QString QgsMeshExportCrossSection::name()
const
1199 return QStringLiteral(
"meshexportcrosssection" );
1202 QString QgsMeshExportCrossSection::displayName()
const
1204 return QObject::tr(
"Export cross section dataset values on lines from mesh" );
1207 QString QgsMeshExportCrossSection::group()
const
1209 return QObject::tr(
"Mesh" );
1212 QString QgsMeshExportCrossSection::groupId()
const
1214 return QStringLiteral(
"mesh" );
1217 QString QgsMeshExportCrossSection::shortHelpString()
const
1219 return QObject::tr(
"This algorithm extracts mesh's dataset values from line contained in a vector layer.\n"
1220 "Each line is discretized with a resolution distance parameter for extraction of values on its vertices." );
1223 QString QgsMeshExportCrossSection::shortDescription()
const
1225 return QObject::tr(
"Extracts a mesh dataset's values from lines contained in a vector layer" );
1230 return new QgsMeshExportCrossSection();
1233 void QgsMeshExportCrossSection::initAlgorithm(
const QVariantMap &configuration )
1235 Q_UNUSED( configuration );
1240 QStringLiteral(
"DATASET_GROUPS" ),
1241 QObject::tr(
"Dataset groups" ),
1242 QStringLiteral(
"INPUT" ),
1243 supportedDataType() ) );
1246 QStringLiteral(
"DATASET_TIME" ),
1247 QObject::tr(
"Dataset time" ),
1248 QStringLiteral(
"INPUT" ),
1249 QStringLiteral(
"DATASET_GROUPS" ) ) );
1251 QList<int> datatype;
1254 QStringLiteral(
"INPUT_LINES" ), QObject::tr(
"Lines for data export" ), datatype, QVariant(),
false ) );
1257 QStringLiteral(
"RESOLUTION" ), QObject::tr(
"Line segmentation resolution" ), 10.0, QStringLiteral(
"INPUT_LINES" ),
false, 0 ) );
1266 QStringLiteral(
"OUTPUT" ), QObject::tr(
"Exported data CSV file" ), QObject::tr(
"CSV file (*.csv)" ) ) );
1271 QgsMeshLayer *meshLayer = parameterAsMeshLayer( parameters, QStringLiteral(
"INPUT" ), context );
1273 if ( !meshLayer || !meshLayer->
isValid() )
1276 mMeshLayerCrs = meshLayer->
crs();
1277 mTriangularMesh.update( meshLayer->
nativeMesh() );
1278 QList<int> datasetGroups =
1287 QVariant parameterTimeVariant = parameters.value( QStringLiteral(
"DATASET_TIME" ) );
1288 QgsInterval relativeTime = datasetRelativetime( parameterTimeVariant, meshLayer, context );
1290 extractDatasetValues( datasetGroups, meshLayer, *meshLayer->
nativeMesh(), relativeTime, supportedDataType(), mDataPerGroup, feedback );
1303 for ( DataGroup &dataGroup : mDataPerGroup )
1305 if ( dataGroup.dataset3dStakedValue.isValid() )
1306 dataGroup.datasetValues = avgMethod->
calculate( dataGroup.dataset3dStakedValue );
1308 double resolution = parameterAsDouble( parameters, QStringLiteral(
"RESOLUTION" ), context );
1309 int datasetDigits = parameterAsInt( parameters, QStringLiteral(
"DATASET_DIGITS" ), context );
1310 int coordDigits = parameterAsInt( parameters, QStringLiteral(
"COORDINATES_DIGITS" ), context );
1313 if ( !featureSource )
1318 QString outputFileName = parameterAsFileOutput( parameters, QStringLiteral(
"OUTPUT" ), context );
1319 QFile file( outputFileName );
1320 if ( ! file.open( QIODevice::WriteOnly | QIODevice::Truncate ) )
1323 QTextStream textStream( &file );
1324 #if QT_VERSION < QT_VERSION_CHECK(6, 0, 0)
1325 textStream.setCodec(
"UTF-8" );
1328 header << QStringLiteral(
"fid" ) << QStringLiteral(
"x" ) << QStringLiteral(
"y" ) << QObject::tr(
"offset" );
1329 for (
const DataGroup &datagroup : std::as_const( mDataPerGroup ) )
1330 header << datagroup.metadata.name();
1331 textStream << header.join(
',' ) << QStringLiteral(
"\n" );
1334 long long featCounter = 0;
1348 feedback->
reportError( QObject::tr(
"Could not transform line to mesh CRS" ) );
1354 while ( offset <= line.
length() )
1357 return QVariantMap();
1359 QStringList textLine;
1361 int triangularFaceIndex = mTriangularMesh.faceIndexForPoint_v2( point );
1362 textLine << QString::number( fid ) << QString::number( point.
x(),
'f', coordDigits ) << QString::number( point.
y(),
'f', coordDigits ) << QString::number( offset,
'f', coordDigits );
1363 if ( triangularFaceIndex >= 0 )
1367 int nativeFaceIndex = mTriangularMesh.trianglesToNativeFaces().at( triangularFaceIndex );
1368 for (
int i = 0; i < mDataPerGroup.count(); ++i )
1370 const DataGroup &dataGroup = mDataPerGroup.at( i );
1371 bool faceActive = dataGroup.activeFaces.active( nativeFaceIndex );
1377 triangularFaceIndex,
1379 dataGroup.activeFaces,
1380 dataGroup.datasetValues,
1381 dataGroup.metadata );
1383 if ( abs( value.
x() ) == std::numeric_limits<double>::quiet_NaN() )
1384 textLine << QString(
' ' );
1386 textLine << QString::number( value.
scalar(),
'f', datasetDigits );
1390 for (
int i = 0; i < mDataPerGroup.count(); ++i )
1391 textLine << QString(
' ' );
1393 textStream << textLine.join(
',' ) << QStringLiteral(
"\n" );
1395 offset += resolution;
1400 feedback->
setProgress( 100.0 * featCounter / featCount );
1402 return QVariantMap();
1409 ret[QStringLiteral(
"OUTPUT" )] = outputFileName;
1413 QString QgsMeshExportTimeSeries::name()
const
1415 return QStringLiteral(
"meshexporttimeseries" );
1418 QString QgsMeshExportTimeSeries::displayName()
const
1420 return QObject::tr(
"Export time series values from points of a mesh dataset" );
1423 QString QgsMeshExportTimeSeries::group()
const
1425 return QObject::tr(
"Mesh" );
1428 QString QgsMeshExportTimeSeries::groupId()
const
1430 return QStringLiteral(
"mesh" );
1433 QString QgsMeshExportTimeSeries::shortHelpString()
const
1435 return QObject::tr(
"This algorithm extracts mesh's dataset time series values from points contained in a vector layer.\n"
1436 "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." );
1439 QString QgsMeshExportTimeSeries::shortDescription()
const
1441 return QObject::tr(
"Extracts a mesh dataset's time series values from points contained in a vector layer" );
1446 return new QgsMeshExportTimeSeries();
1449 void QgsMeshExportTimeSeries::initAlgorithm(
const QVariantMap &configuration )
1451 Q_UNUSED( configuration );
1456 QStringLiteral(
"DATASET_GROUPS" ),
1457 QObject::tr(
"Dataset groups" ),
1458 QStringLiteral(
"INPUT" ),
1459 supportedDataType() ) );
1462 QStringLiteral(
"STARTING_TIME" ),
1463 QObject::tr(
"Starting time" ),
1464 QStringLiteral(
"INPUT" ),
1465 QStringLiteral(
"DATASET_GROUPS" ) ) );
1468 QStringLiteral(
"FINISHING_TIME" ),
1469 QObject::tr(
"Finishing time" ),
1470 QStringLiteral(
"INPUT" ),
1471 QStringLiteral(
"DATASET_GROUPS" ) ) );
1476 QList<int> datatype;
1479 QStringLiteral(
"INPUT_POINTS" ), QObject::tr(
"Points for data export" ), datatype, QVariant(),
false ) );
1488 QStringLiteral(
"OUTPUT" ), QObject::tr(
"Exported data CSV file" ), QObject::tr(
"CSV file (*.csv)" ) ) );
1493 QgsMeshLayer *meshLayer = parameterAsMeshLayer( parameters, QStringLiteral(
"INPUT" ), context );
1495 if ( !meshLayer || !meshLayer->
isValid() )
1498 mMeshLayerCrs = meshLayer->
crs();
1499 mTriangularMesh.update( meshLayer->
nativeMesh() );
1501 QList<int> datasetGroups =
1510 QVariant parameterStartTimeVariant = parameters.value( QStringLiteral(
"STARTING_TIME" ) );
1511 QgsInterval relativeStartTime = datasetRelativetime( parameterStartTimeVariant, meshLayer, context );
1513 QVariant parameterEndTimeVariant = parameters.value( QStringLiteral(
"FINISHING_TIME" ) );
1514 QgsInterval relativeEndTime = datasetRelativetime( parameterEndTimeVariant, meshLayer, context );
1517 qint64 timeStepInterval = parameterAsDouble( parameters, QStringLiteral(
"TIME_STEP" ), context ) * 1000 * 3600;
1518 if ( timeStepInterval == 0 )
1521 for (
int groupIndex : datasetGroups )
1535 mRelativeTimeSteps.clear();
1536 mTimeStepString.clear();
1537 if ( timeStepInterval != 0 )
1539 mRelativeTimeSteps.append( relativeStartTime.
seconds() * 1000 );
1540 while ( mRelativeTimeSteps.last() < relativeEndTime.
seconds() * 1000 )
1541 mRelativeTimeSteps.append( mRelativeTimeSteps.last() + timeStepInterval );
1543 for ( qint64 relativeTimeStep : std::as_const( mRelativeTimeSteps ) )
1545 mTimeStepString.append( meshLayer->
formatTime( relativeTimeStep / 3600.0 / 1000.0 ) );
1550 for (
int i = 0; i < datasetGroups.count(); ++i )
1552 int groupIndex = datasetGroups.at( i );
1554 if ( supportedDataType().contains( meta.
dataType() ) )
1556 mGroupIndexes.append( groupIndex );
1557 mGroupsMetadata[groupIndex] = meta;
1561 if ( !mRelativeTimeSteps.isEmpty() )
1565 for ( qint64 relativeTimeStep : mRelativeTimeSteps )
1567 QMap<int, int> &groupIndexToData = mRelativeTimeToData[relativeTimeStep];
1568 QgsInterval timeStepInterval( relativeTimeStep / 1000.0 );
1570 if ( !datasetIndex.
isValid() )
1572 if ( datasetIndex != lastDatasetIndex )
1574 DataGroup dataGroup;
1575 dataGroup.metadata = meta;
1576 dataGroup.datasetValues = meshLayer->
datasetValues( datasetIndex, 0, valueCount );
1580 dataGroup.dataset3dStakedValue = meshLayer->
dataset3dValues( datasetIndex, 0, valueCount );
1582 mDatasets.append( dataGroup );
1583 lastDatasetIndex = datasetIndex;
1585 groupIndexToData[groupIndex] = mDatasets.count() - 1;
1591 QMap<int, int> &groupIndexToData = mRelativeTimeToData[0];
1593 DataGroup dataGroup;
1594 dataGroup.metadata = meta;
1595 dataGroup.datasetValues = meshLayer->
datasetValues( datasetIndex, 0, valueCount );
1599 dataGroup.dataset3dStakedValue = meshLayer->
dataset3dValues( datasetIndex, 0, valueCount );
1601 mDatasets.append( dataGroup );
1602 groupIndexToData[groupIndex] = mDatasets.
count() - 1;
1607 feedback->
setProgress( 100 * i / datasetGroups.count() );
1623 for ( DataGroup &dataGroup : mDatasets )
1625 if ( dataGroup.dataset3dStakedValue.isValid() )
1626 dataGroup.datasetValues = avgMethod->
calculate( dataGroup.dataset3dStakedValue );
1629 int datasetDigits = parameterAsInt( parameters, QStringLiteral(
"DATASET_DIGITS" ), context );
1630 int coordDigits = parameterAsInt( parameters, QStringLiteral(
"COORDINATES_DIGITS" ), context );
1633 if ( !featureSource )
1638 QString outputFileName = parameterAsFileOutput( parameters, QStringLiteral(
"OUTPUT" ), context );
1639 QFile file( outputFileName );
1640 if ( ! file.open( QIODevice::WriteOnly | QIODevice::Truncate ) )
1643 QTextStream textStream( &file );
1644 #if QT_VERSION < QT_VERSION_CHECK(6, 0, 0)
1645 textStream.setCodec(
"UTF-8" );
1648 header << QStringLiteral(
"fid" ) << QStringLiteral(
"x" ) << QStringLiteral(
"y" ) << QObject::tr(
"time" );
1650 for (
int gi : std::as_const( mGroupIndexes ) )
1651 header << mGroupsMetadata.value( gi ).name();
1653 textStream << header.join(
',' ) << QStringLiteral(
"\n" );
1656 long long featCounter = 0;
1670 feedback->
reportError( QObject::tr(
"Could not transform line to mesh CRS" ) );
1677 int triangularFaceIndex = mTriangularMesh.faceIndexForPoint_v2( point );
1679 if ( triangularFaceIndex >= 0 )
1681 int nativeFaceIndex = mTriangularMesh.trianglesToNativeFaces().at( triangularFaceIndex );
1682 if ( !mRelativeTimeSteps.isEmpty() )
1684 for (
int timeIndex = 0; timeIndex < mRelativeTimeSteps.count(); ++timeIndex )
1686 qint64 timeStep = mRelativeTimeSteps.at( timeIndex );
1687 QStringList textLine;
1688 textLine << QString::number( fid )
1689 << QString::number( point.
x(),
'f', coordDigits )
1690 << QString::number( point.
y(),
'f', coordDigits )
1691 << mTimeStepString.at( timeIndex );
1693 if ( mRelativeTimeToData.contains( timeStep ) )
1695 const QMap<int, int> &groupToData = mRelativeTimeToData.value( timeStep );
1696 for (
int groupIndex : std::as_const( mGroupIndexes ) )
1698 if ( !groupToData.contains( groupIndex ) )
1700 int dataIndex = groupToData.value( groupIndex );
1701 if ( dataIndex < 0 || dataIndex > mDatasets.count() - 1 )
1704 const DataGroup &dataGroup = mDatasets.at( dataIndex );
1707 triangularFaceIndex,
1709 dataGroup.activeFaces,
1710 dataGroup.datasetValues,
1711 dataGroup.metadata );
1712 if ( abs( value.
x() ) == std::numeric_limits<double>::quiet_NaN() )
1713 textLine << QString(
' ' );
1715 textLine << QString::number( value.
scalar(),
'f', datasetDigits ) ;
1718 textStream << textLine.join(
',' ) << QStringLiteral(
"\n" );
1723 QStringList textLine;
1724 textLine << QString::number( fid )
1725 << QString::number( point.
x(),
'f', coordDigits )
1726 << QString::number( point.
y(),
'f', coordDigits )
1727 << QObject::tr(
"static dataset" );
1728 const QMap<int, int> &groupToData = mRelativeTimeToData.value( 0 );
1729 for (
int groupIndex : std::as_const( mGroupIndexes ) )
1731 if ( !groupToData.contains( groupIndex ) )
1733 int dataIndex = groupToData.value( groupIndex );
1734 if ( dataIndex < 0 || dataIndex > mDatasets.count() - 1 )
1736 const DataGroup &dataGroup = mDatasets.at( dataIndex );
1739 triangularFaceIndex,
1741 dataGroup.activeFaces,
1742 dataGroup.datasetValues,
1743 dataGroup.metadata );
1744 if ( abs( value.
x() ) == std::numeric_limits<double>::quiet_NaN() )
1745 textLine << QString(
' ' );
1747 textLine << QString::number( value.
scalar(),
'f', datasetDigits );
1749 textStream << textLine.join(
',' ) << QStringLiteral(
"\n" );
1755 feedback->
setProgress( 100.0 * featCounter / featCount );
1757 return QVariantMap();
1764 ret[QStringLiteral(
"OUTPUT" )] = outputFileName;
@ Float64
Sixty four bit floating point (double)
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)
An interface for objects which accept features via addFeature(s) methods.
virtual bool addFeature(QgsFeature &feature, QgsFeatureSink::Flags flags=QgsFeatureSink::Flags())
Adds a single feature to the sink.
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.
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 ...
bool isCanceled() const SIP_HOLDGIL
Tells whether the operation has been canceled already.
void setProgress(double progress)
Sets the current progress for the feedback object.
Container of fields for a vector layer.
bool append(const QgsField &field, FieldOrigin origin=OriginProvider, int originIndex=-1)
Appends a field. The field must have unique name, otherwise it is rejected (returns false)
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) SIP_THROW(QgsCsException)
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.
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.
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.
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.
QgsFeatureSource subclass which proxies methods to an underlying QgsFeatureSource,...
QgsFeatureIterator getFeatures(const QgsFeatureRequest &request, Flags flags) const
Returns an iterator for the features in the source, respecting the supplied feature flags.
QgsCoordinateReferenceSystem sourceCrs() const override
Returns the coordinate reference system for features in the source.
long long featureCount() const override
Returns the number of features contained in the source, or -1 if the feature count is unknown.
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.
@ Double
Double/float values.
A raster layer destination parameter, for specifying the destination path for a raster layer created ...
A string parameter for processing algorithms.
@ TypeVectorLine
Vector line layers.
@ TypeVectorPolygon
Vector polygon layers.
@ TypeVectorPoint
Vector point layers.
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 SIP_HOLDGIL
Returns the x minimum value (left side of rectangle).
double yMinimum() const SIP_HOLDGIL
Returns the y minimum value (bottom side of rectangle).
double height() const SIP_HOLDGIL
Returns the height of the rectangle.
double width() const SIP_HOLDGIL
Returns the width of the rectangle.
bool isEmpty() const
Returns true if the rectangle is empty.
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.