QGIS API Documentation 3.30.0-'s-Hertogenbosch (f186b8efe0)
qgsprocessingparametermeshdataset.cpp
Go to the documentation of this file.
1/***************************************************************************
2 qgsprocessingparametermeshdataset.cpp
3 ---------------------
4 Date : October 2020
5 Copyright : (C) 2020 by Vincent Cloarec
6 Email : vcloarec at gmail dot com
7 ***************************************************************************
8 * *
9 * This program is free software; you can redistribute it and/or modify *
10 * it under the terms of the GNU General Public License as published by *
11 * the Free Software Foundation; either version 2 of the License, or *
12 * (at your option) any later version. *
13 * *
14 ***************************************************************************/
15
17
21 const QString &description,
22 const QString &meshLayerParameterName,
23 const QSet<int> supportedDataType,
24 bool optional ):
25 QgsProcessingParameterDefinition( name, description, QVariantList(), optional, QString() ),
26 mMeshLayerParameterName( meshLayerParameterName ),
27 mSupportedDataType( supportedDataType )
28{
29}
30
32{
33 return new QgsProcessingParameterMeshDatasetGroups( name(), description(), mMeshLayerParameterName, mSupportedDataType );
34}
35
37{
38 return typeName();
39}
40
42{
43 Q_UNUSED( context );
44 return valueIsAcceptable( input, mFlags & FlagOptional );
45}
46
48{
49 Q_UNUSED( context );
50 QStringList parts;
51 const QList<int> groups = valueAsDatasetGroup( value );
52 for ( const int g : groups )
53 parts.append( QString::number( g ) );
54
55 return parts.join( ',' ).prepend( '[' ).append( ']' );
56}
57
59{
60 switch ( outputType )
61 {
63 {
64 QString code = QStringLiteral( "QgsProcessingParameterMeshDatasetGroups('%1', %2" )
66 if ( !mMeshLayerParameterName.isEmpty() )
67 code += QStringLiteral( ", meshLayerParameterName=%1" ).arg( QgsProcessingUtils::stringToPythonLiteral( mMeshLayerParameterName ) );
68
69 QStringList dt;
70 if ( mSupportedDataType.contains( QgsMeshDatasetGroupMetadata::DataOnFaces ) )
71 dt.append( QStringLiteral( "QgsMeshDatasetGroupMetadata.DataOnFaces" ) );
72 if ( mSupportedDataType.contains( QgsMeshDatasetGroupMetadata::DataOnVertices ) )
73 dt.append( QStringLiteral( "QgsMeshDatasetGroupMetadata.DataOnVertices" ) );
74 if ( mSupportedDataType.contains( QgsMeshDatasetGroupMetadata::DataOnVolumes ) )
75 dt.append( QStringLiteral( "QgsMeshDatasetGroupMetadata.DataOnVolumes" ) );
76 if ( mSupportedDataType.contains( QgsMeshDatasetGroupMetadata::DataOnEdges ) )
77 dt.append( QStringLiteral( "QgsMeshDatasetGroupMetadata.DataOnEdges" ) );
78 if ( !dt.isEmpty() )
79 {
80 code += QLatin1String( ", supportedDataType=[" );
81 code += dt.join( ',' );
82 code += ']';
83 }
84
85 if ( mFlags & FlagOptional )
86 code += QLatin1String( ", optional=True" );
87 code += ')';
88 return code;
89 }
90 }
91 return QString();
92}
93
95{
96 if ( mMeshLayerParameterName.isEmpty() )
97 return QStringList();
98 else
99 return QStringList() << mMeshLayerParameterName;
100}
101
103{
104 return mMeshLayerParameterName;
105}
106
108{
109 return mSupportedDataType.contains( dataType );
110}
111
112QList<int> QgsProcessingParameterMeshDatasetGroups::valueAsDatasetGroup( const QVariant &value )
113{
114 if ( !valueIsAcceptable( value, true ) )
115 return QList<int>();
116
117 QList<int> ret;
118
119 if ( value.isValid() )
120 {
121 if ( value.type() == QVariant::List )
122 {
123 const QVariantList varList = value.toList();
124 for ( const QVariant &v : varList )
125 ret << v.toInt();
126 }
127 else
128 {
129 ret << value.toInt();
130 }
131 }
132
133 return ret;
134}
135
137{
139 map.insert( QStringLiteral( "mesh_layer" ), mMeshLayerParameterName );
140 QVariantList dataType;
141 for ( int v : mSupportedDataType )
142 dataType.append( v );
143 map.insert( QStringLiteral( "supported_data_type" ), dataType );
144 return map;
145}
146
148{
150 mMeshLayerParameterName = map.value( QStringLiteral( "mesh_layer" ) ).toString();
151 const QVariantList dataType = map.value( QStringLiteral( "supported_data_type" ) ).toList();
152 mSupportedDataType.clear();
153 for ( const QVariant &var : dataType )
154 mSupportedDataType.insert( var.toInt() );
155 return true;
156}
157
158bool QgsProcessingParameterMeshDatasetGroups::valueIsAcceptable( const QVariant &input, bool allowEmpty )
159{
160 if ( !input.isValid() )
161 return allowEmpty;
162
163 if ( input.type() != QVariant::List )
164 {
165 bool ok = false;
166 input.toInt( &ok );
167 return ok;
168 }
169 const QVariantList list = input.toList();
170
171 if ( !allowEmpty && list.isEmpty() )
172 return false;
173
174 for ( const QVariant &var : list )
175 {
176 bool ok = false;
177 var.toInt( &ok );
178 if ( !ok )
179 return false;
180 }
181
182 return true;
183}
184
186 const QString &description,
187 const QString &meshLayerParameterName,
188 const QString &datasetGroupParameterName )
189 : QgsProcessingParameterDefinition( name, description, QVariant() )
190 , mMeshLayerParameterName( meshLayerParameterName )
191 , mDatasetGroupParameterName( datasetGroupParameterName )
192{
193
194}
195
197{
198 return new QgsProcessingParameterMeshDatasetTime( name(), description(), mMeshLayerParameterName, mDatasetGroupParameterName );
199}
200
202{
203 return typeName();
204}
205
207{
208 Q_UNUSED( context );
209 return valueIsAcceptable( input, mFlags & FlagOptional );
210}
211
212QString QgsProcessingParameterMeshDatasetTime::valueAsPythonString( const QVariant &value, QgsProcessingContext &context ) const
213{
214 Q_UNUSED( context );
215 QStringList parts;
217 parts << QStringLiteral( "'type': " ) + type;
218
219 if ( value.toDateTime().isValid() )
220 {
221 QDateTime dateTime = value.toDateTime();
222 dateTime.setTimeSpec( Qt::UTC );
223 parts << QStringLiteral( "'value': " ) + QgsProcessingUtils::variantToPythonLiteral( dateTime );
224 }
225 else
226 {
227 const QVariantMap variantTimeDataset = value.toMap();
228 if ( variantTimeDataset.value( QStringLiteral( "type" ) ) == QLatin1String( "dataset-time-step" ) )
229 {
230 const QVariantList datasetIndex = variantTimeDataset.value( QStringLiteral( "value" ) ).toList();
231 parts << QStringLiteral( "'value': " ) + QString( "[%1,%2]" ).arg( datasetIndex.at( 0 ).toString(), datasetIndex.at( 1 ).toString() );
232 }
233 else if ( variantTimeDataset.value( QStringLiteral( "type" ) ) == QLatin1String( "defined-date-time" ) )
234 {
235 parts << QStringLiteral( "'value': " ) + QgsProcessingUtils::variantToPythonLiteral( variantTimeDataset.value( QStringLiteral( "value" ) ) );
236 }
237 }
238
239 return parts.join( ',' ).prepend( '{' ).append( '}' );
240}
241
243{
244 switch ( outputType )
245 {
247 {
248 QString code = QStringLiteral( "QgsProcessingParameterMeshDatasetTime('%1', '%2'" )
249 .arg( name(), description() );
250 if ( !mMeshLayerParameterName.isEmpty() )
251 code += QStringLiteral( ", meshLayerParameterName=%1" ).arg( QgsProcessingUtils::stringToPythonLiteral( mMeshLayerParameterName ) );
252
253 if ( !mDatasetGroupParameterName.isEmpty() )
254 code += QStringLiteral( ", datasetGroupParameterName=%1" ).arg( QgsProcessingUtils::stringToPythonLiteral( mDatasetGroupParameterName ) );
255
256 if ( mFlags & FlagOptional )
257 code += QLatin1String( ", optional=True" );
258 code += ')';
259 return code;
260 }
261 }
262 return QString();
263}
264
266{
267 QStringList otherParameters;
268 if ( !mMeshLayerParameterName.isEmpty() )
269 otherParameters << mMeshLayerParameterName;
270
271 if ( !mDatasetGroupParameterName.isEmpty() )
272 otherParameters << mMeshLayerParameterName << mDatasetGroupParameterName;
273
274 return otherParameters;
275}
276
278{
280 map.insert( QStringLiteral( "mesh_layer" ), mMeshLayerParameterName );
281 map.insert( QStringLiteral( "dataset_groups" ), mDatasetGroupParameterName );
282 return map;
283}
284
286{
288 mMeshLayerParameterName = map.value( QStringLiteral( "mesh_layer" ) ).toString();
289 mDatasetGroupParameterName = map.value( QStringLiteral( "dataset_groups" ) ).toString();
290 return true;
291}
292
294{
295 return mMeshLayerParameterName;
296}
297
299{
300 return mDatasetGroupParameterName;
301}
302
303QString QgsProcessingParameterMeshDatasetTime::valueAsTimeType( const QVariant &value )
304{
305 if ( !valueIsAcceptable( value, false ) )
306 return QString();
307
308 if ( value.toDateTime().isValid() )
309 return QStringLiteral( "defined-date-time" );
310
311 return value.toMap().value( QStringLiteral( "type" ) ).toString();
312}
313
315{
316 if ( !valueIsAcceptable( value, false ) || valueAsTimeType( value ) != QLatin1String( "dataset-time-step" ) )
317 return QgsMeshDatasetIndex( -1, -1 );
318
319 const QVariantList list = value.toMap().value( QStringLiteral( "value" ) ).toList();
320 return QgsMeshDatasetIndex( list.at( 0 ).toInt(), list.at( 1 ).toInt() );
321}
322
324{
325 if ( value.toDateTime().isValid() )
326 {
327 QDateTime dateTime = value.toDateTime();
328 dateTime.setTimeSpec( Qt::UTC );
329 return dateTime;
330 }
331
332 if ( !valueIsAcceptable( value, false ) && valueAsTimeType( value ) != QLatin1String( "defined-date-time" ) )
333 return QDateTime();
334
335 return value.toMap().value( QStringLiteral( "value" ) ).toDateTime();
336}
337
338bool QgsProcessingParameterMeshDatasetTime::valueIsAcceptable( const QVariant &input, bool allowEmpty )
339{
340 if ( !input.isValid() )
341 return allowEmpty;
342
343 if ( input.toDateTime().isValid() )
344 return true;
345
346 if ( input.type() != QVariant::Map )
347 return false;
348
349 const QVariantMap map = input.toMap();
350
351 if ( map.isEmpty() )
352 return allowEmpty;
353
354 if ( ! map.contains( QStringLiteral( "type" ) ) )
355 return false;
356
357 const QString type = map.value( QStringLiteral( "type" ) ).toString();
358 const QVariant value = map.value( QStringLiteral( "value" ) );
359
360 if ( type == QLatin1String( "static" ) || type == QLatin1String( "current-context-time" ) )
361 return true;
362
363 if ( type == QLatin1String( "dataset-time-step" ) )
364 {
365 if ( value.type() != QVariant::List )
366 return false;
367 const QVariantList list = value.toList();
368 if ( value.toList().count() != 2 )
369 return false;
370 if ( list.at( 0 ).type() != QVariant::Int || list.at( 1 ).type() != QVariant::Int )
371 return false;
372 }
373 else if ( type == QLatin1String( "defined-date-time" ) )
374 {
375 if ( value.type() != QVariant::DateTime )
376 return false;
377 }
378 else
379 return false;
380
381 return true;
382}
383
DataType
Location of where data is specified for datasets in the dataset group.
@ DataOnEdges
Data is defined on edges.
@ DataOnFaces
Data is defined on faces.
@ DataOnVertices
Data is defined on vertices.
@ DataOnVolumes
Data is defined on volumes.
QgsMeshDatasetIndex is index that identifies the dataset group (e.g.
Contains information about the context in which a processing algorithm is executed.
Base class for the definition of processing parameters.
QString description() const
Returns the description for the parameter.
virtual QVariantMap toVariantMap() const
Saves this parameter to a QVariantMap.
QString name() const
Returns the name of the parameter.
virtual bool fromVariantMap(const QVariantMap &map)
Restores this parameter to a QVariantMap.
QgsProcessingParameterMeshDatasetGroups(const QString &name, const QString &description=QString(), const QString &meshLayerParameterName=QString(), QSet< int > supportedDataType=QSet< int >(), bool optional=false)
Constructor.
static QString typeName()
Returns the type name for the parameter class.
static QList< int > valueAsDatasetGroup(const QVariant &value)
Returns the value as a list if dataset group indexes.
QStringList dependsOnOtherParameters() const override
Returns a list of other parameter names on which this parameter is dependent (e.g.
QString valueAsPythonString(const QVariant &value, QgsProcessingContext &context) const override
Returns a string version of the parameter input value, which is suitable for use as an input paramete...
QgsProcessingParameterDefinition * clone() const override
Creates a clone of the parameter definition.
bool checkValueIsAcceptable(const QVariant &input, QgsProcessingContext *context=nullptr) const override
Checks whether the specified input value is acceptable for the parameter.
QString type() const override
Unique parameter type name.
QString asPythonString(QgsProcessing::PythonOutputType outputType=QgsProcessing::PythonQgsProcessingAlgorithmSubclass) const override
Returns the parameter definition as a Python command which can be used within a Python Processing scr...
bool fromVariantMap(const QVariantMap &map) override
Restores this parameter to a QVariantMap.
QString meshLayerParameterName() const
Returns the name of the mesh layer parameter.
QVariantMap toVariantMap() const override
Saves this parameter to a QVariantMap.
bool isDataTypeSupported(QgsMeshDatasetGroupMetadata::DataType dataType) const
Returns whether the data type is supported by the parameter.
QgsProcessingParameterMeshDatasetTime(const QString &name, const QString &description=QString(), const QString &meshLayerParameterName=QString(), const QString &datasetGroupParameterName=QString())
Constructor.
QString valueAsPythonString(const QVariant &value, QgsProcessingContext &context) const override
Returns a string version of the parameter input value, which is suitable for use as an input paramete...
QgsProcessingParameterDefinition * clone() const override
Creates a clone of the parameter definition.
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...
QString asPythonString(QgsProcessing::PythonOutputType outputType=QgsProcessing::PythonQgsProcessingAlgorithmSubclass) const override
Returns the parameter definition as a Python command which can be used within a Python Processing scr...
bool fromVariantMap(const QVariantMap &map) override
Restores this parameter to a QVariantMap.
QString datasetGroupParameterName() const
Returns the name of the dataset groups parameter.
QString meshLayerParameterName() const
Returns the name of the mesh layer parameter.
static QgsMeshDatasetIndex timeValueAsDatasetIndex(const QVariant &value)
Returns the value as a QgsMeshDatasetIndex if the value has "dataset-time-step" type.
QVariantMap toVariantMap() const override
Saves this parameter to a QVariantMap.
QStringList dependsOnOtherParameters() const override
Returns a list of other parameter names on which this parameter is dependent (e.g.
static QString typeName()
Returns the type name for the parameter class.
bool checkValueIsAcceptable(const QVariant &input, QgsProcessingContext *context=nullptr) const override
Checks whether the specified input value is acceptable for the parameter.
static QDateTime timeValueAsDefinedDateTime(const QVariant &value)
Returns the value as a QDateTime if the value has "defined-date-time" type.
QString type() const override
Unique parameter type name.
static QString stringToPythonLiteral(const QString &string)
Converts a string to a Python string literal.
static QString variantToPythonLiteral(const QVariant &value)
Converts a variant to a Python literal.
PythonOutputType
Available Python output types.
Definition: qgsprocessing.h:64
@ PythonQgsProcessingAlgorithmSubclass
Full Python QgsProcessingAlgorithm subclass.
Definition: qgsprocessing.h:65