vtkMultiThreshold.h

Go to the documentation of this file.

/*=========================================================================
 
  Program:   Visualization Toolkit
  Module:    vtkMultiThreshold.h
 
  Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
  All rights reserved.
  See Copyright.txt or http://www.kitware.com/Copyright.htm for details.
 
     This software is distributed WITHOUT ANY WARRANTY; without even
     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
     PURPOSE.  See the above copyright notice for more information.
 
=========================================================================*/
/*----------------------------------------------------------------------------
 Copyright (c) Sandia Corporation
 See Copyright.txt or http://www.paraview.org/HTML/Copyright.html for details.
----------------------------------------------------------------------------*/
 
#ifndef vtkMultiThreshold_h
#define vtkMultiThreshold_h
 
#include "vtkFiltersGeneralModule.h" // For export macro
#include "vtkMath.h"                 // for Inf() and NegInf()
#include "vtkMultiBlockDataSetAlgorithm.h"
 
#include <map>    // for IntervalRules map
#include <set>    // for UpdateDependents()
#include <string> // for holding array names in NormKey
#include <vector> // for lists of threshold rules
 
class vtkCell;
class vtkCellData;
class vtkDataArray;
class vtkGenericCell;
class vtkPointSet;
class vtkUnstructuredGrid;
 
class VTKFILTERSGENERAL_EXPORT vtkMultiThreshold : public vtkMultiBlockDataSetAlgorithm
{
public:
  vtkTypeMacro(vtkMultiThreshold, vtkMultiBlockDataSetAlgorithm);
  static vtkMultiThreshold* New();
  void PrintSelf(ostream& os, vtkIndent indent) override;
 
  enum Closure
  {
    OPEN = 0,  
    CLOSED = 1 
  };
  enum Norm
  {
    LINFINITY_NORM = -3, 
    L2_NORM = -2,        
    L1_NORM = -1         
  };
  enum SetOperation
  {
    AND, 
    OR,  
    XOR, 
    WOR, 
    NAND 
  };
 
 
  int AddIntervalSet(double xmin, double xmax, int omin, int omax, int assoc, const char* arrayName,
    int component, int allScalars);
  int AddIntervalSet(double xmin, double xmax, int omin, int omax, int assoc, int attribType,
    int component, int allScalars);
 
 
  int AddLowpassIntervalSet(
    double xmax, int assoc, const char* arrayName, int component, int allScalars);
  int AddHighpassIntervalSet(
    double xmin, int assoc, const char* arrayName, int component, int allScalars);
  int AddBandpassIntervalSet(
    double xmin, double xmax, int assoc, const char* arrayName, int component, int allScalars);
  int AddNotchIntervalSet(
    double xlo, double xhi, int assoc, const char* arrayName, int component, int allScalars);
 
  int AddBooleanSet(int operation, int numInputs, int* inputs);
 
  int OutputSet(int setId);
 
  void Reset();
 
  typedef double (*TupleNorm)(vtkDataArray* arr, vtkIdType tuple, int component);
 
  // NormKey must be able to use TupleNorm typedef:
  class NormKey;
 
  // Interval must be able to use NormKey typedef:
  class Interval;
 
  // Set needs to refer to boolean set pointers
  class BooleanSet;
 
  class NormKey
  {
  public:
    int Association; // vtkDataObject::FIELD_ASSOCIATION_POINTS or
                     // vtkDataObject::FIELD_ASSOCIATION_CELLS
    int Type;        // -1 => use Name, otherwise: vtkDataSetAttributes::{SCALARS, VECTORS, TENSORS,
                     // NORMALS, TCOORDS, GLOBALIDS}
    std::string Name; // Either empty or (when ArrayType == -1) an input array name
    int Component;    // LINFINITY_NORM, L1_NORM, L2_NORM or an integer component number
    int AllScalars;   // For Association == vtkDataObject::FIELD_ASSOCIATION_POINTS, must all points
                      // be in the interval?
    int InputArrayIndex;    // The number passed to vtkAlgorithm::SetInputArrayToProcess()
    TupleNorm NormFunction; // A function pointer to compute the norm (or fetcht the correct
                            // component) of a tuple.
 
    void ComputeNorm(
      vtkIdType cellId, vtkCell* cell, vtkDataArray* array, double cellNorm[2]) const;
 
    bool operator<(const NormKey& other) const
    {
      if (this->Association < other.Association)
        return true;
      else if (this->Association > other.Association)
        return false;
 
      if (this->Component < other.Component)
        return true;
      else if (this->Component > other.Component)
        return false;
 
      if ((!this->AllScalars) && other.AllScalars)
        return true;
      else if (this->AllScalars && (!other.AllScalars))
        return false;
 
      if (this->Type == -1)
      {
        if (other.Type == -1)
          return this->Name < other.Name;
        return true;
      }
      else
      {
        return this->Type < other.Type;
      }
    }
  };
 
  class Set
  {
  public:
    int Id;       
    int OutputId; 
 
    Set() { this->OutputId = -1; }
    virtual ~Set() = default;
    virtual void PrintNodeName(ostream& os);
    virtual void PrintNode(ostream& os) = 0;
    virtual BooleanSet* GetBooleanSetPointer();
    virtual Interval* GetIntervalPointer();
  };
 
  class Interval : public Set
  {
  public:
    double EndpointValues[2];
    int EndpointClosures[2];
    NormKey Norm;
 
    int Match(double cellNorm[2]);
 
    ~Interval() override = default;
    void PrintNode(ostream& os) override;
    Interval* GetIntervalPointer() override;
  };
 
  class BooleanSet : public Set
  {
  public:
    int Operator;
    std::vector<int> Inputs;
 
    BooleanSet(int sId, int op, int* inBegin, int* inEnd)
      : Inputs(inBegin, inEnd)
    {
      this->Id = sId;
      this->Operator = op;
    }
    ~BooleanSet() override = default;
    void PrintNode(ostream& os) override;
    BooleanSet* GetBooleanSetPointer() override;
  };
 
protected:
  vtkMultiThreshold();
  ~vtkMultiThreshold() override;
 
  enum Ruling
  {
    INCONCLUSIVE = -1,
    INCLUDE = -2,
    EXCLUDE = -3
  };
 
  int RequestData(vtkInformation*, vtkInformationVector**, vtkInformationVector*) override;
 
  int FillInputPortInformation(int port, vtkInformation* info) override;
 
  int NextArrayIndex;
 
  int NumberOfOutputs;
 
  typedef std::vector<Interval*> IntervalList;
  typedef std::map<NormKey, IntervalList> RuleMap;
 
  typedef std::vector<int> TruthTreeValues;
  typedef std::vector<TruthTreeValues> TruthTree;
 
  RuleMap IntervalRules;
 
  std::vector<Set*> Sets;
 
  TruthTree DependentSets;
 
  void UpdateDependents(int id, std::set<int>& unresolvedOutputs, TruthTreeValues& setStates,
    vtkCellData* inCellData, vtkIdType inCell, vtkGenericCell* cell,
    std::vector<vtkUnstructuredGrid*>& outv);
 
  int AddIntervalSet(NormKey& nk, double xmin, double xmax, int omin, int omax);
 
  void PrintGraph(ostream& os);
 
  vtkMultiThreshold(const vtkMultiThreshold&) = delete;
  void operator=(const vtkMultiThreshold&) = delete;
};
 
inline int vtkMultiThreshold::AddLowpassIntervalSet(
  double xmax, int assoc, const char* arrayName, int component, int allScalars)
{
  return this->AddIntervalSet(
    vtkMath::NegInf(), xmax, CLOSED, CLOSED, assoc, arrayName, component, allScalars);
}
 
inline int vtkMultiThreshold::AddHighpassIntervalSet(
  double xmin, int assoc, const char* arrayName, int component, int allScalars)
{
  return this->AddIntervalSet(
    xmin, vtkMath::Inf(), CLOSED, CLOSED, assoc, arrayName, component, allScalars);
}
 
inline int vtkMultiThreshold::AddBandpassIntervalSet(
  double xmin, double xmax, int assoc, const char* arrayName, int component, int allScalars)
{
  return this->AddIntervalSet(xmin, xmax, CLOSED, CLOSED, assoc, arrayName, component, allScalars);
}
 
inline int vtkMultiThreshold::AddNotchIntervalSet(
  double xlo, double xhi, int assoc, const char* arrayName, int component, int allScalars)
{
  int band =
    this->AddIntervalSet(xlo, xhi, CLOSED, CLOSED, assoc, arrayName, component, allScalars);
  if (band < 0)
  {
    return -1;
  }
  return this->AddBooleanSet(NAND, 1, &band);
}
 
inline vtkMultiThreshold::Interval* vtkMultiThreshold::Set::GetIntervalPointer()
{
  return nullptr;
}
 
inline vtkMultiThreshold::BooleanSet* vtkMultiThreshold::Set::GetBooleanSetPointer()
{
  return nullptr;
}
 
inline vtkMultiThreshold::Interval* vtkMultiThreshold::Interval::GetIntervalPointer()
{
  return this;
}
 
inline vtkMultiThreshold::BooleanSet* vtkMultiThreshold::BooleanSet::GetBooleanSetPointer()
{
  return this;
}
 
#endif // vtkMultiThreshold_h