vtkCriticalTime.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
// SPDX-License-Identifier: BSD-3-Clause
#ifndef vtkCriticalTime_h
#define vtkCriticalTime_h

#include "vtkFiltersTemporalModule.h" // For export macro
#include "vtkPassInputTypeAlgorithm.h"
#include "vtkTemporalAlgorithm.h" // For temporal algorithm

#include <limits> // For std::numeric_limits<>::infinity()
#include <memory> // For unique_pointer

#ifndef __VTK_WRAP__
#define vtkPassInputTypeAlgorithm vtkTemporalAlgorithm<vtkPassInputTypeAlgorithm>
#endif

VTK_ABI_NAMESPACE_BEGIN
class vtkCompositeDataSet;
class vtkDataSet;
class vtkFieldData;

class VTKFILTERSTEMPORAL_EXPORT vtkCriticalTime : public vtkPassInputTypeAlgorithm
{
public:

  vtkTypeMacro(vtkCriticalTime, vtkPassInputTypeAlgorithm);
#ifndef __VTK_WRAP__
#undef vtkPassInputTypeAlgorithm
#endif
  static vtkCriticalTime* New();
  void PrintSelf(ostream& os, vtkIndent indent) override;

#if defined(__VTK_WRAP__) || defined(__WRAP_GCCXML)
  vtkCreateWrappedTemporalAlgorithmInterface();
#endif


  vtkGetMacro(LowerThreshold, double);
  vtkSetMacro(LowerThreshold, double);


  vtkGetMacro(UpperThreshold, double);
  vtkSetMacro(UpperThreshold, double);

  enum ThresholdType
  {
    THRESHOLD_BETWEEN = 0,
    THRESHOLD_LOWER,
    THRESHOLD_UPPER
  };


  vtkSetClampMacro(ThresholdCriterion, int, THRESHOLD_BETWEEN, THRESHOLD_UPPER);
  vtkGetMacro(ThresholdCriterion, int);
  void SetThresholdCriterionToBetween() { this->SetComponentMode(THRESHOLD_BETWEEN); }
  void SetThresholdCriterionToLower() { this->SetComponentMode(THRESHOLD_LOWER); }
  void SetThresholdCriterionToUpper() { this->SetComponentMode(THRESHOLD_UPPER); }

  std::string GetThresholdFunctionAsString() const;

  enum ComponentModeType
  {
    COMPONENT_MODE_USE_SELECTED = 0,
    COMPONENT_MODE_USE_ALL,
    COMPONENT_MODE_USE_ANY
  };


  vtkSetClampMacro(ComponentMode, int, COMPONENT_MODE_USE_SELECTED, COMPONENT_MODE_USE_ANY);
  vtkGetMacro(ComponentMode, int);
  void SetComponentModeToUseSelected() { this->SetComponentMode(COMPONENT_MODE_USE_SELECTED); }
  void SetComponentModeToUseAll() { this->SetComponentMode(COMPONENT_MODE_USE_ALL); }
  void SetComponentModeToUseAny() { this->SetComponentMode(COMPONENT_MODE_USE_ANY); }

  std::string GetComponentModeAsString() const;


  vtkSetClampMacro(SelectedComponent, int, 0, VTK_INT_MAX);
  vtkGetMacro(SelectedComponent, int);

protected:
  vtkCriticalTime();
  ~vtkCriticalTime() override = default;

  int FillInputPortInformation(int port, vtkInformation* info) override;

  int RequestDataObject(vtkInformation* request, vtkInformationVector** inputVector,
    vtkInformationVector* outputVector) override;

  int Initialize(vtkInformation* request, vtkInformationVector** inputVector,
    vtkInformationVector* outputVector) override;
  int Execute(vtkInformation* request, vtkInformationVector** inputVector,
    vtkInformationVector* outputVector) override;
  int Finalize(vtkInformation* request, vtkInformationVector** inputVector,
    vtkInformationVector* outputVector) override;

private:
  vtkCriticalTime(const vtkCriticalTime&) = delete;
  void operator=(const vtkCriticalTime&) = delete;

  double LowerThreshold = -std::numeric_limits<double>::infinity();
  double UpperThreshold = std::numeric_limits<double>::infinity();
  int ThresholdCriterion = THRESHOLD_BETWEEN;
  int ComponentMode = COMPONENT_MODE_USE_SELECTED;
  int SelectedComponent = 0;

  struct vtkCriticalTimeInternals;
  std::unique_ptr<vtkCriticalTimeInternals> Internals;
};

VTK_ABI_NAMESPACE_END
#endif //_vtkCriticalTime_h