QGIS API Documentation  3.23.0-Master (eb871beae0)
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 
47 QString QgsProcessingParameterMeshDatasetGroups::valueAsPythonString( const QVariant &value, QgsProcessingContext &context ) const
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( ", dataType=[" );
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 
112 QList<int> QgsProcessingParameterMeshDatasetGroups::valueAsDatasetGroup( const QVariant &value )
113 {
114  if ( !valueIsAcceptable( value, true ) )
115  return QList<int>();
116 
117  QList<int> ret;
118 
119  // if invalid or empty, return only the group 0
120  if ( !value.isValid() )
121  ret << 0;
122  else
123  {
124  if ( value.type() == QVariant::List )
125  {
126  const QVariantList varList = value.toList();
127  if ( varList.isEmpty() )
128  ret << 0;
129  else
130  for ( const QVariant &v : varList )
131  ret << v.toInt();
132  }
133  else
134  {
135  ret << value.toInt();
136  }
137  }
138 
139  return ret;
140 }
141 
142 bool QgsProcessingParameterMeshDatasetGroups::valueIsAcceptable( const QVariant &input, bool allowEmpty )
143 {
144  if ( !input.isValid() )
145  return allowEmpty;
146 
147  if ( input.type() != QVariant::List )
148  {
149  bool ok = false;
150  input.toInt( &ok );
151  return ok;
152  }
153  const QVariantList list = input.toList();
154 
155  if ( !allowEmpty && list.isEmpty() )
156  return false;
157 
158  for ( const QVariant &var : list )
159  {
160  bool ok = false;
161  var.toInt( &ok );
162  if ( !ok )
163  return false;
164  }
165 
166  return true;
167 }
168 
170  const QString &description,
171  const QString &meshLayerParameterName,
172  const QString &datasetGroupParameterName )
173  : QgsProcessingParameterDefinition( name, description, QVariant() )
174  , mMeshLayerParameterName( meshLayerParameterName )
175  , mDatasetGroupParameterName( datasetGroupParameterName )
176 {
177 
178 }
179 
181 {
182  return new QgsProcessingParameterMeshDatasetTime( name(), description(), mMeshLayerParameterName, mDatasetGroupParameterName );
183 }
184 
186 {
187  return typeName();
188 }
189 
191 {
192  Q_UNUSED( context );
193  return valueIsAcceptable( input, mFlags & FlagOptional );
194 }
195 
196 QString QgsProcessingParameterMeshDatasetTime::valueAsPythonString( const QVariant &value, QgsProcessingContext &context ) const
197 {
198  Q_UNUSED( context );
199  QStringList parts;
201  parts << QStringLiteral( "'type': " ) + type;
202 
203  if ( value.toDateTime().isValid() )
204  {
205  QDateTime dateTime = value.toDateTime();
206  dateTime.setTimeSpec( Qt::UTC );
207  parts << QStringLiteral( "'value': " ) + QgsProcessingUtils::variantToPythonLiteral( dateTime );
208  }
209  else
210  {
211  const QVariantMap variantTimeDataset = value.toMap();
212  if ( variantTimeDataset.value( QStringLiteral( "type" ) ) == QLatin1String( "dataset-time-step" ) )
213  {
214  const QVariantList datasetIndex = variantTimeDataset.value( QStringLiteral( "value" ) ).toList();
215  parts << QStringLiteral( "'value': " ) + QString( "[%1,%2]" ).arg( datasetIndex.at( 0 ).toString(), datasetIndex.at( 1 ).toString() );
216  }
217  else if ( variantTimeDataset.value( QStringLiteral( "type" ) ) == QLatin1String( "defined-date-time" ) )
218  {
219  parts << QStringLiteral( "'value': " ) + QgsProcessingUtils::variantToPythonLiteral( variantTimeDataset.value( QStringLiteral( "value" ) ) );
220  }
221  }
222 
223  return parts.join( ',' ).prepend( '{' ).append( '}' );
224 }
225 
227 {
228  switch ( outputType )
229  {
231  {
232  QString code = QStringLiteral( "QgsProcessingParameterMeshDatasetTime('%1', '%2'" )
233  .arg( name(), description() );
234  if ( !mMeshLayerParameterName.isEmpty() )
235  code += QStringLiteral( ", meshLayerParameterName=%1" ).arg( QgsProcessingUtils::stringToPythonLiteral( mMeshLayerParameterName ) );
236 
237  if ( !mDatasetGroupParameterName.isEmpty() )
238  code += QStringLiteral( ", datasetGroupParameterName=%1" ).arg( QgsProcessingUtils::stringToPythonLiteral( mDatasetGroupParameterName ) );
239 
240  if ( mFlags & FlagOptional )
241  code += QLatin1String( ", optional=True" );
242  code += ')';
243  return code;
244  }
245  }
246  return QString();
247 }
248 
250 {
251  QStringList otherParameters;
252  if ( !mMeshLayerParameterName.isEmpty() )
253  otherParameters << mMeshLayerParameterName;
254 
255  if ( !mDatasetGroupParameterName.isEmpty() )
256  otherParameters << mMeshLayerParameterName << mDatasetGroupParameterName;
257 
258  return otherParameters;
259 }
260 
262 {
263  return mMeshLayerParameterName;
264 }
265 
267 {
268  return mDatasetGroupParameterName;
269 }
270 
271 QString QgsProcessingParameterMeshDatasetTime::valueAsTimeType( const QVariant &value )
272 {
273  if ( !valueIsAcceptable( value, false ) )
274  return QString();
275 
276  if ( value.toDateTime().isValid() )
277  return QStringLiteral( "defined-date-time" );
278 
279  return value.toMap().value( QStringLiteral( "type" ) ).toString();
280 }
281 
283 {
284  if ( !valueIsAcceptable( value, false ) || valueAsTimeType( value ) != QLatin1String( "dataset-time-step" ) )
285  return QgsMeshDatasetIndex( -1, -1 );
286 
287  const QVariantList list = value.toMap().value( QStringLiteral( "value" ) ).toList();
288  return QgsMeshDatasetIndex( list.at( 0 ).toInt(), list.at( 1 ).toInt() );
289 }
290 
292 {
293  if ( value.toDateTime().isValid() )
294  {
295  QDateTime dateTime = value.toDateTime();
296  dateTime.setTimeSpec( Qt::UTC );
297  return dateTime;
298  }
299 
300  if ( !valueIsAcceptable( value, false ) && valueAsTimeType( value ) != QLatin1String( "defined-date-time" ) )
301  return QDateTime();
302 
303  return value.toMap().value( QStringLiteral( "value" ) ).toDateTime();
304 }
305 
306 bool QgsProcessingParameterMeshDatasetTime::valueIsAcceptable( const QVariant &input, bool allowEmpty )
307 {
308  if ( !input.isValid() )
309  return allowEmpty;
310 
311  if ( input.toDateTime().isValid() )
312  return true;
313 
314  if ( input.type() != QVariant::Map )
315  return false;
316 
317  const QVariantMap map = input.toMap();
318 
319  if ( map.isEmpty() )
320  return allowEmpty;
321 
322  if ( ! map.contains( QStringLiteral( "type" ) ) )
323  return false;
324 
325  const QString type = map.value( QStringLiteral( "type" ) ).toString();
326  const QVariant value = map.value( QStringLiteral( "value" ) );
327 
328  if ( type == QLatin1String( "static" ) || type == QLatin1String( "current-context-time" ) )
329  return true;
330 
331  if ( type == QLatin1String( "dataset-time-step" ) )
332  {
333  if ( value.type() != QVariant::List )
334  return false;
335  const QVariantList list = value.toList();
336  if ( value.toList().count() != 2 )
337  return false;
338  if ( list.at( 0 ).type() != QVariant::Int || list.at( 1 ).type() != QVariant::Int )
339  return false;
340  }
341  else if ( type == QLatin1String( "defined-date-time" ) )
342  {
343  if ( value.type() != QVariant::DateTime )
344  return false;
345  }
346  else
347  return false;
348 
349  return true;
350 }
351 
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.
QString name() const
Returns the name of the parameter.
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...
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...
QString meshLayerParameterName() const
Returns the name of the mesh layer parameter.
bool isDataTypeSupported(QgsMeshDatasetGroupMetadata::DataType dataType) const
Returns whether the data type is supported by the parameter.
QgsProcessingParameterDefinition * clone() const override
Creates a clone of the parameter definition.
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...
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.
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:63
@ PythonQgsProcessingAlgorithmSubclass
Full Python QgsProcessingAlgorithm subclass.
Definition: qgsprocessing.h:64