VTK  9.2.6
vtkMultiThreshold.h
Go to the documentation of this file.
1 /*=========================================================================
2 
3  Program: Visualization Toolkit
4  Module: vtkMultiThreshold.h
5 
6  Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
7  All rights reserved.
8  See Copyright.txt or http://www.kitware.com/Copyright.htm for details.
9 
10  This software is distributed WITHOUT ANY WARRANTY; without even
11  the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
12  PURPOSE. See the above copyright notice for more information.
13 
14 =========================================================================*/
15 /*----------------------------------------------------------------------------
16  Copyright (c) Sandia Corporation
17  See Copyright.txt or http://www.paraview.org/HTML/Copyright.html for details.
18 ----------------------------------------------------------------------------*/
19 
135 #ifndef vtkMultiThreshold_h
136 #define vtkMultiThreshold_h
137 
138 #include "vtkFiltersGeneralModule.h" // For export macro
139 #include "vtkMath.h" // for Inf() and NegInf()
141 
142 #include <map> // for IntervalRules map
143 #include <set> // for UpdateDependents()
144 #include <string> // for holding array names in NormKey
145 #include <vector> // for lists of threshold rules
146 
147 class vtkCell;
148 class vtkCellData;
149 class vtkDataArray;
150 class vtkGenericCell;
151 class vtkPointSet;
152 class vtkUnstructuredGrid;
153 
154 class VTKFILTERSGENERAL_EXPORT vtkMultiThreshold : public vtkMultiBlockDataSetAlgorithm
155 {
156 public:
159  void PrintSelf(ostream& os, vtkIndent indent) override;
160 
162  enum Closure
163  {
164  OPEN = 0,
165  CLOSED = 1
166  };
168  enum Norm
169  {
170  LINFINITY_NORM = -3,
171  L2_NORM = -2,
172  L1_NORM = -1
173  };
177  {
178  AND,
179  OR,
180  XOR,
181  WOR,
182  NAND
183  };
184 
186 
238  int AddIntervalSet(double xmin, double xmax, int omin, int omax, int assoc, const char* arrayName,
239  int component, int allScalars);
240  int AddIntervalSet(double xmin, double xmax, int omin, int omax, int assoc, int attribType,
241  int component, int allScalars);
243 
245 
252  int AddLowpassIntervalSet(
253  double xmax, int assoc, const char* arrayName, int component, int allScalars);
254  int AddHighpassIntervalSet(
255  double xmin, int assoc, const char* arrayName, int component, int allScalars);
256  int AddBandpassIntervalSet(
257  double xmin, double xmax, int assoc, const char* arrayName, int component, int allScalars);
258  int AddNotchIntervalSet(
259  double xlo, double xhi, int assoc, const char* arrayName, int component, int allScalars);
261 
265  int AddBooleanSet(int operation, int numInputs, int* inputs);
266 
270  int OutputSet(int setId);
271 
275  void Reset();
276 
279  typedef double (*TupleNorm)(vtkDataArray* arr, vtkIdType tuple, int component);
280 
281  // NormKey must be able to use TupleNorm typedef:
282  class NormKey;
283 
284  // Interval must be able to use NormKey typedef:
285  class Interval;
286 
287  // Set needs to refer to boolean set pointers
288  class BooleanSet;
289 
291  class NormKey
292  {
293  public:
294  int Association; // vtkDataObject::FIELD_ASSOCIATION_POINTS or
295  // vtkDataObject::FIELD_ASSOCIATION_CELLS
296  int Type; // -1 => use Name, otherwise: vtkDataSetAttributes::{SCALARS, VECTORS, TENSORS,
297  // NORMALS, TCOORDS, GLOBALIDS}
298  std::string Name; // Either empty or (when ArrayType == -1) an input array name
299  int Component; // LINFINITY_NORM, L1_NORM, L2_NORM or an integer component number
300  int AllScalars; // For Association == vtkDataObject::FIELD_ASSOCIATION_POINTS, must all points
301  // be in the interval?
302  int InputArrayIndex; // The number passed to vtkAlgorithm::SetInputArrayToProcess()
303  TupleNorm NormFunction; // A function pointer to compute the norm (or fetcht the correct
304  // component) of a tuple.
305 
309  vtkIdType cellId, vtkCell* cell, vtkDataArray* array, double cellNorm[2]) const;
310 
313  bool operator<(const NormKey& other) const
314  {
315  if (this->Association < other.Association)
316  return true;
317  else if (this->Association > other.Association)
318  return false;
319 
320  if (this->Component < other.Component)
321  return true;
322  else if (this->Component > other.Component)
323  return false;
324 
325  if ((!this->AllScalars) && other.AllScalars)
326  return true;
327  else if (this->AllScalars && (!other.AllScalars))
328  return false;
329 
330  if (this->Type == -1)
331  {
332  if (other.Type == -1)
333  return this->Name < other.Name;
334  return true;
335  }
336  else
337  {
338  return this->Type < other.Type;
339  }
340  }
341  };
342 
347  class Set
348  {
349  public:
350  int Id;
351  int OutputId;
353 
356  Set() { this->OutputId = -1; }
358  virtual ~Set() = default;
360  virtual void PrintNodeName(ostream& os);
362  virtual void PrintNode(ostream& os) = 0;
364  virtual BooleanSet* GetBooleanSetPointer();
365  virtual Interval* GetIntervalPointer();
366  };
367 
369  class Interval : public Set
370  {
371  public:
373  double EndpointValues[2];
375  int EndpointClosures[2];
378 
384  int Match(double cellNorm[2]);
385 
386  ~Interval() override = default;
387  void PrintNode(ostream& os) override;
388  Interval* GetIntervalPointer() override;
389  };
390 
392  class BooleanSet : public Set
393  {
394  public:
396  int Operator;
398  std::vector<int> Inputs;
399 
401  BooleanSet(int sId, int op, int* inBegin, int* inEnd)
402  : Inputs(inBegin, inEnd)
403  {
404  this->Id = sId;
405  this->Operator = op;
406  }
407  ~BooleanSet() override = default;
408  void PrintNode(ostream& os) override;
409  BooleanSet* GetBooleanSetPointer() override;
410  };
411 
412 protected:
414  ~vtkMultiThreshold() override;
415 
430  enum Ruling
431  {
432  INCONCLUSIVE = -1,
433  INCLUDE = -2,
434  EXCLUDE = -3
435  };
436 
441 
448 
455 
460 
462  typedef std::vector<Interval*> IntervalList;
464  typedef std::map<NormKey, IntervalList> RuleMap;
465 
466  typedef std::vector<int> TruthTreeValues;
467  typedef std::vector<TruthTreeValues> TruthTree;
468 
473 
479  std::vector<Set*> Sets;
480 
488 
492  void UpdateDependents(int id, std::set<int>& unresolvedOutputs, TruthTreeValues& setStates,
493  vtkCellData* inCellData, vtkIdType inCell, vtkGenericCell* cell,
494  std::vector<vtkUnstructuredGrid*>& outv);
495 
499  int AddIntervalSet(NormKey& nk, double xmin, double xmax, int omin, int omax);
500 
504  void PrintGraph(ostream& os);
505 
507  void operator=(const vtkMultiThreshold&) = delete;
508 };
509 
511  double xmax, int assoc, const char* arrayName, int component, int allScalars)
512 {
513  return this->AddIntervalSet(
514  vtkMath::NegInf(), xmax, CLOSED, CLOSED, assoc, arrayName, component, allScalars);
515 }
516 
518  double xmin, int assoc, const char* arrayName, int component, int allScalars)
519 {
520  return this->AddIntervalSet(
521  xmin, vtkMath::Inf(), CLOSED, CLOSED, assoc, arrayName, component, allScalars);
522 }
523 
525  double xmin, double xmax, int assoc, const char* arrayName, int component, int allScalars)
526 {
527  return this->AddIntervalSet(xmin, xmax, CLOSED, CLOSED, assoc, arrayName, component, allScalars);
528 }
529 
531  double xlo, double xhi, int assoc, const char* arrayName, int component, int allScalars)
532 {
533  int band =
534  this->AddIntervalSet(xlo, xhi, CLOSED, CLOSED, assoc, arrayName, component, allScalars);
535  if (band < 0)
536  {
537  return -1;
538  }
539  return this->AddBooleanSet(NAND, 1, &band);
540 }
541 
543 {
544  return nullptr;
545 }
546 
548 {
549  return nullptr;
550 }
551 
553 {
554  return this;
555 }
556 
558 {
559  return this;
560 }
561 
562 #endif // vtkMultiThreshold_h
represent and manipulate cell attribute data
Definition: vtkCellData.h:151
abstract class to specify cell behavior
Definition: vtkCell.h:150
abstract superclass for arrays of numeric data
Definition: vtkDataArray.h:165
provides thread-safe access to cells
a simple class to control print indentation
Definition: vtkIndent.h:119
Store zero or more vtkInformation instances.
Store vtkAlgorithm input/output information.
static double NegInf()
Special IEEE-754 number used to represent negative infinity.
static double Inf()
Special IEEE-754 number used to represent positive infinity.
Superclass for algorithms that produce only vtkMultiBlockDataSet as output.
A subset of a mesh represented as a boolean set operation.
int Operator
The boolean operation that will be performed on the inputs to obtain the output.
BooleanSet(int sId, int op, int *inBegin, int *inEnd)
Construct a new set with the given ID, operator, and inputs.
void PrintNode(ostream &os) override
Print a graphviz node name for use in an edge statement.
std::vector< int > Inputs
A list of input sets. These may be IntervalSets or BooleanSets.
~BooleanSet() override=default
BooleanSet * GetBooleanSetPointer() override
Avoid dynamic_casts. Subclasses must override.
A subset of a mesh represented by a range of acceptable attribute values.
void PrintNode(ostream &os) override
Print a graphviz node name for use in an edge statement.
~Interval() override=default
int Match(double cellNorm[2])
Does the specified range fall inside the interval? For cell-centered attributes, only cellNorm[0] is ...
NormKey Norm
This contains information about the attribute over which the interval is defined.
Interval * GetIntervalPointer() override
A class with comparison operator used to index input array norms used in threshold rules.
void ComputeNorm(vtkIdType cellId, vtkCell *cell, vtkDataArray *array, double cellNorm[2]) const
Compute the norm of a cell by calling NormFunction for all its points or for its single cell-centered...
bool operator<(const NormKey &other) const
A partial ordering of NormKey objects is required for them to serve as keys in the vtkMultiThreshold:...
A base class for representing threshold sets.
int OutputId
A unique identifier for this set.
virtual Interval * GetIntervalPointer()
virtual void PrintNodeName(ostream &os)
Print a graphviz node label statement (with fancy node name and shape).
virtual void PrintNode(ostream &os)=0
Print a graphviz node name for use in an edge statement.
virtual BooleanSet * GetBooleanSetPointer()
Avoid dynamic_casts. Subclasses must override.
Set()
The index of the output mesh that will hold this set or -1 if the set is not output.
virtual ~Set()=default
Virtual destructor since we have virtual members.
Threshold cells within multiple intervals.
~vtkMultiThreshold() override
TruthTree DependentSets
A list of boolean sets whose values depend on the given set.
int NumberOfOutputs
The number of output datasets.
vtkMultiThreshold(const vtkMultiThreshold &)=delete
void operator=(const vtkMultiThreshold &)=delete
Ruling
When an interval is evaluated, its value is used to update a truth table.
Norm
Norms that can be used to threshold vector attributes.
std::map< NormKey, IntervalList > RuleMap
A map describing the IntervalSets that share a common attribute and norm.
std::vector< Set * > Sets
A list of rules keyed by their unique integer ID.
std::vector< Interval * > IntervalList
A list of pointers to IntervalSets.
int NextArrayIndex
A variable used to store the next index to use when calling SetInputArrayToProcess.
RuleMap IntervalRules
A set of threshold rules sorted by the attribute+norm to which they are applied.
int AddBandpassIntervalSet(double xmin, double xmax, int assoc, const char *arrayName, int component, int allScalars)
These convenience members make it easy to insert closed intervals.
static vtkMultiThreshold * New()
std::vector< int > TruthTreeValues
void Reset()
Remove all the intervals currently defined.
int AddLowpassIntervalSet(double xmax, int assoc, const char *arrayName, int component, int allScalars)
These convenience members make it easy to insert closed intervals.
void PrintSelf(ostream &os, vtkIndent indent) override
Methods invoked by print to print information about the object including superclasses.
void PrintGraph(ostream &os)
Print out a graphviz-formatted text description of all the sets.
int RequestData(vtkInformation *, vtkInformationVector **, vtkInformationVector *) override
This function performs the actual thresholding.
int AddBooleanSet(int operation, int numInputs, int *inputs)
Create a new mesh subset using boolean operations on pre-existing sets.
int OutputSet(int setId)
Create an output mesh containing a boolean or interval subset of the input mesh.
void UpdateDependents(int id, std::set< int > &unresolvedOutputs, TruthTreeValues &setStates, vtkCellData *inCellData, vtkIdType inCell, vtkGenericCell *cell, std::vector< vtkUnstructuredGrid * > &outv)
Recursively update the setStates and unresolvedOutputs vectors based on this->DependentSets.
int AddIntervalSet(double xmin, double xmax, int omin, int omax, int assoc, int attribType, int component, int allScalars)
Add a mesh subset to be computed by thresholding an attribute of the input mesh.
int AddIntervalSet(double xmin, double xmax, int omin, int omax, int assoc, const char *arrayName, int component, int allScalars)
Add a mesh subset to be computed by thresholding an attribute of the input mesh.
int AddNotchIntervalSet(double xlo, double xhi, int assoc, const char *arrayName, int component, int allScalars)
These convenience members make it easy to insert closed intervals.
SetOperation
Operations that can be performed on sets to generate another set.
@ WOR
Include elements that belong to an odd number of input sets (a kind of "winding XOR")
@ XOR
Include an element if it belongs to exactly one input set.
@ NAND
Only include elements that don't belong to any input set.
@ AND
Only include an element if it belongs to all the input sets.
@ OR
Include an element if it belongs to any input set.
int AddHighpassIntervalSet(double xmin, int assoc, const char *arrayName, int component, int allScalars)
These convenience members make it easy to insert closed intervals.
Closure
Whether the endpoint value of an interval should be included or excluded.
@ CLOSED
Specify a closed interval.
int FillInputPortInformation(int port, vtkInformation *info) override
We accept any mesh that is descended from vtkPointSet.
std::vector< TruthTreeValues > TruthTree
int AddIntervalSet(NormKey &nk, double xmin, double xmax, int omin, int omax)
A utility method called by the public AddInterval members.
concrete class for storing a set of points
Definition: vtkPointSet.h:109
dataset represents arbitrary combinations of all possible cell types
@ component
Definition: vtkX3D.h:181
@ info
Definition: vtkX3D.h:382
@ port
Definition: vtkX3D.h:453
@ string
Definition: vtkX3D.h:496
int vtkIdType
Definition: vtkType.h:332