vtkBinCellDataFilter.h

Go to the documentation of this file.

/*=========================================================================

  Program:   Visualization Toolkit
  Module:    vtkBinCellDataFilter.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.

=========================================================================*/
#ifndef vtkBinCellDataFilter_h
#define vtkBinCellDataFilter_h

#include "vtkDataSetAlgorithm.h"
#include "vtkDataSetAttributes.h" // needed for vtkDataSetAttributes::FieldList
#include "vtkFiltersCoreModule.h" // For export macro

#include "vtkContourValues.h" // Needed for inline methods

class vtkAbstractCellLocator;

class VTKFILTERSCORE_EXPORT vtkBinCellDataFilter : public vtkDataSetAlgorithm
{
public:
  typedef vtkContourValues vtkBinValues;

  static vtkBinCellDataFilter* New();


  vtkTypeMacro(vtkBinCellDataFilter, vtkDataSetAlgorithm);
  void PrintSelf(ostream& os, vtkIndent indent) override;


  void SetValue(int i, double value);
  double GetValue(int i);
  double* GetValues();
  void GetValues(double* binValues);
  void SetNumberOfBins(int numBins);
  vtkIdType GetNumberOfBins();
  void GenerateValues(int numBins, double range[2]);
  void GenerateValues(int numBins, double rangeStart, double rangeEnd);


  void SetSourceData(vtkDataObject* source);
  vtkDataObject* GetSource();

  void SetSourceConnection(vtkAlgorithmOutput* algOutput);


  vtkSetMacro(SpatialMatch, vtkTypeBool);
  vtkGetMacro(SpatialMatch, vtkTypeBool);
  vtkBooleanMacro(SpatialMatch, vtkTypeBool);


  vtkSetMacro(StoreNumberOfNonzeroBins, bool);
  vtkBooleanMacro(StoreNumberOfNonzeroBins, bool);
  vtkGetMacro(StoreNumberOfNonzeroBins, bool);


  vtkSetStringMacro(NumberOfNonzeroBinsArrayName);
  vtkGetStringMacro(NumberOfNonzeroBinsArrayName);


  vtkSetMacro(Tolerance, double);
  vtkGetMacro(Tolerance, double);


  vtkSetMacro(ComputeTolerance, bool);
  vtkBooleanMacro(ComputeTolerance, bool);
  vtkGetMacro(ComputeTolerance, bool);


  vtkSetMacro(ArrayComponent, int);
  vtkGetMacro(ArrayComponent, int);

  enum CellOverlapCriterion
  {
    CELL_CENTROID = 0,
    CELL_POINTS = 1,
  };


  vtkSetClampMacro(CellOverlapMethod, int, CELL_CENTROID, CELL_POINTS);
  vtkGetMacro(CellOverlapMethod, int);


  virtual void SetCellLocator(vtkAbstractCellLocator* cellLocator);
  vtkGetObjectMacro(CellLocator, vtkAbstractCellLocator);

protected:
  vtkBinCellDataFilter();
  ~vtkBinCellDataFilter() override;

  vtkTypeBool SpatialMatch;

  bool StoreNumberOfNonzeroBins;
  double Tolerance;
  bool ComputeTolerance;
  int ArrayComponent;
  int CellOverlapMethod;

  vtkBinValues* BinValues;
  vtkAbstractCellLocator* CellLocator;
  virtual void CreateDefaultLocator();

  int RequestData(vtkInformation*, vtkInformationVector**, vtkInformationVector*) override;
  int RequestInformation(vtkInformation*, vtkInformationVector**, vtkInformationVector*) override;
  int RequestUpdateExtent(vtkInformation*, vtkInformationVector**, vtkInformationVector*) override;

  char* NumberOfNonzeroBinsArrayName;

private:
  vtkBinCellDataFilter(const vtkBinCellDataFilter&) = delete;
  void operator=(const vtkBinCellDataFilter&) = delete;
};

inline void vtkBinCellDataFilter::SetValue(int i, double value)
{
  this->BinValues->SetValue(i, value);
}

inline double vtkBinCellDataFilter::GetValue(int i)
{
  return this->BinValues->GetValue(i);
}

inline double* vtkBinCellDataFilter::GetValues()
{
  return this->BinValues->GetValues();
}

inline void vtkBinCellDataFilter::GetValues(double* binValues)
{
  this->BinValues->GetValues(binValues);
}

inline void vtkBinCellDataFilter::SetNumberOfBins(int number)
{
  this->BinValues->SetNumberOfContours(number);
}

inline vtkIdType vtkBinCellDataFilter::GetNumberOfBins()
{
  return this->BinValues->GetNumberOfContours();
}

inline void vtkBinCellDataFilter::GenerateValues(int numBins, double range[2])
{
  this->BinValues->GenerateValues(numBins, range);
}

inline void vtkBinCellDataFilter::GenerateValues(int numBins, double rangeStart, double rangeEnd)
{
  this->BinValues->GenerateValues(numBins, rangeStart, rangeEnd);
}

#endif