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() ), QVariant::Double ) );
45 fields.
append(
QgsField( QStringLiteral(
"%1_y" ).arg( meta.name() ), QVariant::Double ) );
48 if ( vectorOption == 1 || vectorOption == 2 )
50 fields.
append(
QgsField( QStringLiteral(
"%1_mag" ).arg( meta.name() ), QVariant::Double ) );
51 fields.
append(
QgsField( QStringLiteral(
"%1_dir" ).arg( meta.name() ), QVariant::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" ) ) );
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;
903QSet<int> QgsMeshRasterizeAlgorithm::supportedDataType()
912QString QgsMeshContoursAlgorithm::name()
const
914 return QStringLiteral(
"meshcontours" );
917QString QgsMeshContoursAlgorithm::displayName()
const
919 return QObject::tr(
"Export contours" );
922QString QgsMeshContoursAlgorithm::group()
const
924 return QObject::tr(
"Mesh" );
927QString QgsMeshContoursAlgorithm::groupId()
const
929 return QStringLiteral(
"mesh" );
932QString QgsMeshContoursAlgorithm::shortHelpString()
const
934 return QObject::tr(
"This algorithm creates contours as a vector layer from a mesh scalar dataset." );
937QString QgsMeshContoursAlgorithm::shortDescription()
const
939 return QObject::tr(
"Creates contours as vector layer from mesh scalar dataset" );
944 return new QgsMeshContoursAlgorithm();
947void 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" ) ) );
973 std::unique_ptr< QgsProcessingParameterString > contourLevelList = std::make_unique < QgsProcessingParameterString >(
974 QStringLiteral(
"CONTOUR_LEVEL_LIST" ), QObject::tr(
"List of contours level" ), QVariant(),
false,
true );
975 contourLevelList->setHelp( QObject::tr(
"Comma separated list of values to export. If filled, the increment, minimum and maximum settings are ignored." ) );
976 addParameter( contourLevelList.release() );
978 addParameter(
new QgsProcessingParameterCrs( QStringLiteral(
"CRS_OUTPUT" ), QObject::tr(
"Output coordinate system" ), QVariant(),
true ) );
987 QgsMeshLayer *meshLayer = parameterAsMeshLayer( parameters, QStringLiteral(
"INPUT" ), context );
989 if ( !meshLayer || !meshLayer->
isValid() )
999 mTriangularMesh.update( meshLayer->
nativeMesh(), mTransform );
1005 QString levelsString = parameterAsString( parameters, QStringLiteral(
"CONTOUR_LEVEL_LIST" ), context );
1006 if ( ! levelsString.isEmpty() )
1008 QStringList levelStringList = levelsString.split(
',' );
1009 if ( !levelStringList.isEmpty() )
1011 for (
const QString &stringVal : levelStringList )
1014 double val = stringVal.toDouble( &ok );
1016 mLevels.append( val );
1018 throw QgsProcessingException( QObject::tr(
"Invalid format for level values, must be numbers separated with comma" ) );
1020 if ( mLevels.count() >= 2 )
1021 if ( mLevels.last() <= mLevels.at( mLevels.count() - 2 ) )
1022 throw QgsProcessingException( QObject::tr(
"Invalid format for level values, must be different numbers and in increasing order" ) );
1027 if ( mLevels.isEmpty() )
1029 double minimum = parameterAsDouble( parameters, QStringLiteral(
"MINIMUM" ), context );
1030 double maximum = parameterAsDouble( parameters, QStringLiteral(
"MAXIMUM" ), context );
1031 double interval = parameterAsDouble( parameters, QStringLiteral(
"INCREMENT" ), context );
1033 if ( interval <= 0 )
1036 if ( minimum >= maximum )
1037 throw QgsProcessingException( QObject::tr(
"Invalid minimum and maximum values, minimum must be lesser than maximum" ) );
1039 if ( interval > ( maximum - minimum ) )
1040 throw QgsProcessingException( QObject::tr(
"Invalid minimum, maximum and interval values, difference between minimum and maximum must be greater or equal than interval" ) );
1042 int intervalCount = ( maximum - minimum ) / interval;
1044 mLevels.reserve( intervalCount );
1045 for (
int i = 0; i < intervalCount; ++i )
1047 mLevels.append( minimum + i * interval );
1052 QList<int> datasetGroups =
1061 QVariant parameterTimeVariant = parameters.value( QStringLiteral(
"DATASET_TIME" ) );
1062 QgsInterval relativeTime = datasetRelativetime( parameterTimeVariant, meshLayer, context );
1066 extractDatasetValues( datasetGroups, meshLayer, mNativeMesh, relativeTime, supportedDataType(), mDataPerGroup, feedback );
1077 for ( DataGroup &dataGroup : mDataPerGroup )
1079 if ( dataGroup.dataset3dStakedValue.isValid() )
1080 dataGroup.datasetValues = avgMethod->
calculate( dataGroup.dataset3dStakedValue );
1086 polygonFields.
append(
QgsField( QObject::tr(
"group" ), QVariant::String ) );
1087 polygonFields.
append(
QgsField( QObject::tr(
"time" ), QVariant::String ) );
1088 polygonFields.
append(
QgsField( QObject::tr(
"min_value" ), QVariant::Double ) );
1089 polygonFields.
append(
QgsField( QObject::tr(
"max_value" ), QVariant::Double ) );
1090 lineFields.
append(
QgsField( QObject::tr(
"group" ), QVariant::String ) );
1091 lineFields.
append(
QgsField( QObject::tr(
"time" ), QVariant::String ) );
1092 lineFields.
append(
QgsField( QObject::tr(
"value" ), QVariant::Double ) );
1096 QString lineIdentifier;
1097 QString polygonIdentifier;
1098 std::unique_ptr<QgsFeatureSink> sinkPolygons( parameterAsSink(
1100 QStringLiteral(
"OUTPUT_POLYGONS" ),
1106 std::unique_ptr<QgsFeatureSink> sinkLines( parameterAsSink(
1108 QStringLiteral(
"OUTPUT_LINES" ),
1115 if ( !sinkLines || !sinkPolygons )
1116 return QVariantMap();
1119 for (
int i = 0; i < mDataPerGroup.count(); ++i )
1121 DataGroup dataGroup = mDataPerGroup.at( i );
1123 int count = scalarDataOnVertices ? mNativeMesh.vertices.count() : mNativeMesh.faces.count();
1125 QVector<double> values;
1126 if ( dataGroup.datasetValues.isValid() )
1129 values = QgsMeshLayerUtils::calculateMagnitudes( dataGroup.datasetValues );
1133 values = QVector<double>( count, std::numeric_limits<double>::quiet_NaN() );
1136 if ( ( !scalarDataOnVertices ) )
1138 values = QgsMeshLayerUtils::interpolateFromFacesData(
1141 &dataGroup.activeFaces,
1146 QgsMeshContours contoursExported( mTriangularMesh, mNativeMesh, values, dataGroup.activeFaces );
1149 firstAttributes.append( dataGroup.metadata.name() );
1150 firstAttributes.append( mDateTimeString );
1152 for (
double level : std::as_const( mLevels ) )
1154 QgsGeometry line = contoursExported.exportLines( level, feedback );
1156 return QVariantMap();
1160 lineAttributes.append( level );
1166 sinkLines->addFeature( lineFeat );
1170 for (
int l = 0; l < mLevels.count() - 1; ++l )
1172 QgsGeometry polygon = contoursExported.exportPolygons( mLevels.at( l ), mLevels.at( l + 1 ), feedback );
1174 return QVariantMap();
1179 polygonAttributes.append( mLevels.at( l ) );
1180 polygonAttributes.append( mLevels.at( l + 1 ) );
1185 sinkPolygons->addFeature( polygonFeature );
1190 feedback->
setProgress( 100 * i / mDataPerGroup.count() );
1195 ret[QStringLiteral(
"OUTPUT_LINES" )] = lineIdentifier;
1196 ret[QStringLiteral(
"OUTPUT_POLYGONS" )] = polygonIdentifier;
1201QString QgsMeshExportCrossSection::name()
const
1203 return QStringLiteral(
"meshexportcrosssection" );
1206QString QgsMeshExportCrossSection::displayName()
const
1208 return QObject::tr(
"Export cross section dataset values on lines from mesh" );
1211QString QgsMeshExportCrossSection::group()
const
1213 return QObject::tr(
"Mesh" );
1216QString QgsMeshExportCrossSection::groupId()
const
1218 return QStringLiteral(
"mesh" );
1221QString QgsMeshExportCrossSection::shortHelpString()
const
1223 return QObject::tr(
"This algorithm extracts mesh's dataset values from line contained in a vector layer.\n"
1224 "Each line is discretized with a resolution distance parameter for extraction of values on its vertices." );
1227QString QgsMeshExportCrossSection::shortDescription()
const
1229 return QObject::tr(
"Extracts a mesh dataset's values from lines contained in a vector layer" );
1234 return new QgsMeshExportCrossSection();
1237void QgsMeshExportCrossSection::initAlgorithm(
const QVariantMap &configuration )
1239 Q_UNUSED( configuration );
1244 QStringLiteral(
"DATASET_GROUPS" ),
1245 QObject::tr(
"Dataset groups" ),
1246 QStringLiteral(
"INPUT" ),
1247 supportedDataType() ) );
1250 QStringLiteral(
"DATASET_TIME" ),
1251 QObject::tr(
"Dataset time" ),
1252 QStringLiteral(
"INPUT" ),
1253 QStringLiteral(
"DATASET_GROUPS" ) ) );
1255 QList<int> datatype;
1258 QStringLiteral(
"INPUT_LINES" ), QObject::tr(
"Lines for data export" ), datatype, QVariant(),
false ) );
1261 QStringLiteral(
"RESOLUTION" ), QObject::tr(
"Line segmentation resolution" ), 10.0, QStringLiteral(
"INPUT_LINES" ),
false, 0 ) );
1270 QStringLiteral(
"OUTPUT" ), QObject::tr(
"Exported data CSV file" ), QObject::tr(
"CSV file (*.csv)" ) ) );
1275 QgsMeshLayer *meshLayer = parameterAsMeshLayer( parameters, QStringLiteral(
"INPUT" ), context );
1277 if ( !meshLayer || !meshLayer->
isValid() )
1280 mMeshLayerCrs = meshLayer->
crs();
1281 mTriangularMesh.update( meshLayer->
nativeMesh() );
1282 QList<int> datasetGroups =
1291 QVariant parameterTimeVariant = parameters.value( QStringLiteral(
"DATASET_TIME" ) );
1292 QgsInterval relativeTime = datasetRelativetime( parameterTimeVariant, meshLayer, context );
1294 extractDatasetValues( datasetGroups, meshLayer, *meshLayer->
nativeMesh(), relativeTime, supportedDataType(), mDataPerGroup, feedback );
1307 for ( DataGroup &dataGroup : mDataPerGroup )
1309 if ( dataGroup.dataset3dStakedValue.isValid() )
1310 dataGroup.datasetValues = avgMethod->
calculate( dataGroup.dataset3dStakedValue );
1312 double resolution = parameterAsDouble( parameters, QStringLiteral(
"RESOLUTION" ), context );
1313 int datasetDigits = parameterAsInt( parameters, QStringLiteral(
"DATASET_DIGITS" ), context );
1314 int coordDigits = parameterAsInt( parameters, QStringLiteral(
"COORDINATES_DIGITS" ), context );
1316 std::unique_ptr< QgsProcessingFeatureSource > featureSource( parameterAsSource( parameters, QStringLiteral(
"INPUT_LINES" ), context ) );
1317 if ( !featureSource )
1322 QString outputFileName = parameterAsFileOutput( parameters, QStringLiteral(
"OUTPUT" ), context );
1323 QFile file( outputFileName );
1324 if ( ! file.open( QIODevice::WriteOnly | QIODevice::Truncate ) )
1327 QTextStream textStream( &file );
1328#if QT_VERSION < QT_VERSION_CHECK(6, 0, 0)
1329 textStream.setCodec(
"UTF-8" );
1332 header << QStringLiteral(
"fid" ) << QStringLiteral(
"x" ) << QStringLiteral(
"y" ) << QObject::tr(
"offset" );
1333 for (
const DataGroup &datagroup : std::as_const( mDataPerGroup ) )
1334 header << datagroup.metadata.name();
1335 textStream << header.join(
',' ) << QStringLiteral(
"\n" );
1337 long long featCount = featureSource->featureCount();
1338 long long featCounter = 0;
1352 feedback->
reportError( QObject::tr(
"Could not transform line to mesh CRS" ) );
1358 while ( offset <= line.
length() )
1361 return QVariantMap();
1363 QStringList textLine;
1365 int triangularFaceIndex = mTriangularMesh.faceIndexForPoint_v2( point );
1366 textLine << QString::number( fid ) << QString::number( point.
x(),
'f', coordDigits ) << QString::number( point.
y(),
'f', coordDigits ) << QString::number( offset,
'f', coordDigits );
1367 if ( triangularFaceIndex >= 0 )
1371 int nativeFaceIndex = mTriangularMesh.trianglesToNativeFaces().at( triangularFaceIndex );
1372 for (
int i = 0; i < mDataPerGroup.count(); ++i )
1374 const DataGroup &dataGroup = mDataPerGroup.at( i );
1375 bool faceActive = dataGroup.activeFaces.active( nativeFaceIndex );
1381 triangularFaceIndex,
1383 dataGroup.activeFaces,
1384 dataGroup.datasetValues,
1385 dataGroup.metadata );
1387 if ( abs( value.
x() ) == std::numeric_limits<double>::quiet_NaN() )
1388 textLine << QString(
' ' );
1390 textLine << QString::number( value.
scalar(),
'f', datasetDigits );
1394 for (
int i = 0; i < mDataPerGroup.count(); ++i )
1395 textLine << QString(
' ' );
1397 textStream << textLine.join(
',' ) << QStringLiteral(
"\n" );
1399 offset += resolution;
1404 feedback->
setProgress( 100.0 * featCounter / featCount );
1406 return QVariantMap();
1413 ret[QStringLiteral(
"OUTPUT" )] = outputFileName;
1417QString QgsMeshExportTimeSeries::name()
const
1419 return QStringLiteral(
"meshexporttimeseries" );
1422QString QgsMeshExportTimeSeries::displayName()
const
1424 return QObject::tr(
"Export time series values from points of a mesh dataset" );
1427QString QgsMeshExportTimeSeries::group()
const
1429 return QObject::tr(
"Mesh" );
1432QString QgsMeshExportTimeSeries::groupId()
const
1434 return QStringLiteral(
"mesh" );
1437QString QgsMeshExportTimeSeries::shortHelpString()
const
1439 return QObject::tr(
"This algorithm extracts mesh's dataset time series values from points contained in a vector layer.\n"
1440 "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." );
1443QString QgsMeshExportTimeSeries::shortDescription()
const
1445 return QObject::tr(
"Extracts a mesh dataset's time series values from points contained in a vector layer" );
1450 return new QgsMeshExportTimeSeries();
1453void QgsMeshExportTimeSeries::initAlgorithm(
const QVariantMap &configuration )
1455 Q_UNUSED( configuration );
1460 QStringLiteral(
"DATASET_GROUPS" ),
1461 QObject::tr(
"Dataset groups" ),
1462 QStringLiteral(
"INPUT" ),
1463 supportedDataType() ) );
1466 QStringLiteral(
"STARTING_TIME" ),
1467 QObject::tr(
"Starting time" ),
1468 QStringLiteral(
"INPUT" ),
1469 QStringLiteral(
"DATASET_GROUPS" ) ) );
1472 QStringLiteral(
"FINISHING_TIME" ),
1473 QObject::tr(
"Finishing time" ),
1474 QStringLiteral(
"INPUT" ),
1475 QStringLiteral(
"DATASET_GROUPS" ) ) );
1480 QList<int> datatype;
1483 QStringLiteral(
"INPUT_POINTS" ), QObject::tr(
"Points for data export" ), datatype, QVariant(),
false ) );
1492 QStringLiteral(
"OUTPUT" ), QObject::tr(
"Exported data CSV file" ), QObject::tr(
"CSV file (*.csv)" ) ) );
1497 QgsMeshLayer *meshLayer = parameterAsMeshLayer( parameters, QStringLiteral(
"INPUT" ), context );
1499 if ( !meshLayer || !meshLayer->
isValid() )
1502 mMeshLayerCrs = meshLayer->
crs();
1503 mTriangularMesh.update( meshLayer->
nativeMesh() );
1505 QList<int> datasetGroups =
1514 QVariant parameterStartTimeVariant = parameters.value( QStringLiteral(
"STARTING_TIME" ) );
1515 QgsInterval relativeStartTime = datasetRelativetime( parameterStartTimeVariant, meshLayer, context );
1517 QVariant parameterEndTimeVariant = parameters.value( QStringLiteral(
"FINISHING_TIME" ) );
1518 QgsInterval relativeEndTime = datasetRelativetime( parameterEndTimeVariant, meshLayer, context );
1521 qint64 timeStepInterval = parameterAsDouble( parameters, QStringLiteral(
"TIME_STEP" ), context ) * 1000 * 3600;
1522 if ( timeStepInterval == 0 )
1525 for (
int groupIndex : datasetGroups )
1539 mRelativeTimeSteps.clear();
1540 mTimeStepString.clear();
1541 if ( timeStepInterval != 0 )
1543 mRelativeTimeSteps.append( relativeStartTime.
seconds() * 1000 );
1544 while ( mRelativeTimeSteps.last() < relativeEndTime.
seconds() * 1000 )
1545 mRelativeTimeSteps.append( mRelativeTimeSteps.last() + timeStepInterval );
1547 for ( qint64 relativeTimeStep : std::as_const( mRelativeTimeSteps ) )
1549 mTimeStepString.append( meshLayer->
formatTime( relativeTimeStep / 3600.0 / 1000.0 ) );
1554 for (
int i = 0; i < datasetGroups.count(); ++i )
1556 int groupIndex = datasetGroups.at( i );
1558 if ( supportedDataType().contains( meta.
dataType() ) )
1560 mGroupIndexes.append( groupIndex );
1561 mGroupsMetadata[groupIndex] = meta;
1565 if ( !mRelativeTimeSteps.isEmpty() )
1569 for ( qint64 relativeTimeStep : std::as_const( mRelativeTimeSteps ) )
1571 QMap<int, int> &groupIndexToData = mRelativeTimeToData[relativeTimeStep];
1572 QgsInterval timeStepInterval( relativeTimeStep / 1000.0 );
1574 if ( !datasetIndex.
isValid() )
1576 if ( datasetIndex != lastDatasetIndex )
1578 DataGroup dataGroup;
1579 dataGroup.metadata = meta;
1580 dataGroup.datasetValues = meshLayer->
datasetValues( datasetIndex, 0, valueCount );
1584 dataGroup.dataset3dStakedValue = meshLayer->
dataset3dValues( datasetIndex, 0, valueCount );
1586 mDatasets.append( dataGroup );
1587 lastDatasetIndex = datasetIndex;
1589 groupIndexToData[groupIndex] = mDatasets.count() - 1;
1595 QMap<int, int> &groupIndexToData = mRelativeTimeToData[0];
1597 DataGroup dataGroup;
1598 dataGroup.metadata = meta;
1599 dataGroup.datasetValues = meshLayer->
datasetValues( datasetIndex, 0, valueCount );
1603 dataGroup.dataset3dStakedValue = meshLayer->
dataset3dValues( datasetIndex, 0, valueCount );
1605 mDatasets.append( dataGroup );
1606 groupIndexToData[groupIndex] = mDatasets.
count() - 1;
1611 feedback->
setProgress( 100 * i / datasetGroups.count() );
1627 for ( DataGroup &dataGroup : mDatasets )
1629 if ( dataGroup.dataset3dStakedValue.isValid() )
1630 dataGroup.datasetValues = avgMethod->
calculate( dataGroup.dataset3dStakedValue );
1633 int datasetDigits = parameterAsInt( parameters, QStringLiteral(
"DATASET_DIGITS" ), context );
1634 int coordDigits = parameterAsInt( parameters, QStringLiteral(
"COORDINATES_DIGITS" ), context );
1636 std::unique_ptr< QgsProcessingFeatureSource > featureSource( parameterAsSource( parameters, QStringLiteral(
"INPUT_POINTS" ), context ) );
1637 if ( !featureSource )
1642 QString outputFileName = parameterAsFileOutput( parameters, QStringLiteral(
"OUTPUT" ), context );
1643 QFile file( outputFileName );
1644 if ( ! file.open( QIODevice::WriteOnly | QIODevice::Truncate ) )
1647 QTextStream textStream( &file );
1648#if QT_VERSION < QT_VERSION_CHECK(6, 0, 0)
1649 textStream.setCodec(
"UTF-8" );
1652 header << QStringLiteral(
"fid" ) << QStringLiteral(
"x" ) << QStringLiteral(
"y" ) << QObject::tr(
"time" );
1654 for (
int gi : std::as_const( mGroupIndexes ) )
1655 header << mGroupsMetadata.value( gi ).name();
1657 textStream << header.join(
',' ) << QStringLiteral(
"\n" );
1659 long long featCount = featureSource->featureCount();
1660 long long featCounter = 0;
1674 feedback->
reportError( QObject::tr(
"Could not transform line to mesh CRS" ) );
1681 int triangularFaceIndex = mTriangularMesh.faceIndexForPoint_v2( point );
1683 if ( triangularFaceIndex >= 0 )
1685 int nativeFaceIndex = mTriangularMesh.trianglesToNativeFaces().at( triangularFaceIndex );
1686 if ( !mRelativeTimeSteps.isEmpty() )
1688 for (
int timeIndex = 0; timeIndex < mRelativeTimeSteps.count(); ++timeIndex )
1690 qint64 timeStep = mRelativeTimeSteps.at( timeIndex );
1691 QStringList textLine;
1692 textLine << QString::number( fid )
1693 << QString::number( point.
x(),
'f', coordDigits )
1694 << QString::number( point.
y(),
'f', coordDigits )
1695 << mTimeStepString.at( timeIndex );
1697 if ( mRelativeTimeToData.contains( timeStep ) )
1699 const QMap<int, int> &groupToData = mRelativeTimeToData.value( timeStep );
1700 for (
int groupIndex : std::as_const( mGroupIndexes ) )
1702 if ( !groupToData.contains( groupIndex ) )
1704 int dataIndex = groupToData.value( groupIndex );
1705 if ( dataIndex < 0 || dataIndex > mDatasets.count() - 1 )
1708 const DataGroup &dataGroup = mDatasets.at( dataIndex );
1711 triangularFaceIndex,
1713 dataGroup.activeFaces,
1714 dataGroup.datasetValues,
1715 dataGroup.metadata );
1716 if ( abs( value.
x() ) == std::numeric_limits<double>::quiet_NaN() )
1717 textLine << QString(
' ' );
1719 textLine << QString::number( value.
scalar(),
'f', datasetDigits ) ;
1722 textStream << textLine.join(
',' ) << QStringLiteral(
"\n" );
1727 QStringList textLine;
1728 textLine << QString::number( fid )
1729 << QString::number( point.
x(),
'f', coordDigits )
1730 << QString::number( point.
y(),
'f', coordDigits )
1731 << QObject::tr(
"static dataset" );
1732 const QMap<int, int> &groupToData = mRelativeTimeToData.value( 0 );
1733 for (
int groupIndex : std::as_const( mGroupIndexes ) )
1735 if ( !groupToData.contains( groupIndex ) )
1737 int dataIndex = groupToData.value( groupIndex );
1738 if ( dataIndex < 0 || dataIndex > mDatasets.count() - 1 )
1740 const DataGroup &dataGroup = mDatasets.at( dataIndex );
1743 triangularFaceIndex,
1745 dataGroup.activeFaces,
1746 dataGroup.datasetValues,
1747 dataGroup.metadata );
1748 if ( abs( value.
x() ) == std::numeric_limits<double>::quiet_NaN() )
1749 textLine << QString(
' ' );
1751 textLine << QString::number( value.
scalar(),
'f', datasetDigits );
1753 textStream << textLine.join(
',' ) << QStringLiteral(
"\n" );
1759 feedback->
setProgress( 100.0 * featCounter / featCount );
1761 return QVariantMap();
1768 ret[QStringLiteral(
"OUTPUT" )] = outputFileName;
@ Float64
Sixty four bit floating point (double)
@ LineStringZ
LineStringZ.
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)
@ 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, 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)
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.
@ Double
Double/float values.
A raster layer destination parameter, for specifying the destination path for a raster layer created ...
@ 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
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.