vtkBivariateLinearTableThreshold.h

Go to the documentation of this file.

/*=========================================================================
 
Program:   Visualization Toolkit
Module:    vtkBivariateLinearTableThreshold.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 2009 Sandia Corporation.
  Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
  the U.S. Government retains certain rights in this software.
-------------------------------------------------------------------------*/
#ifndef vtkBivariateLinearTableThreshold_h
#define vtkBivariateLinearTableThreshold_h
 
#include "vtkFiltersStatisticsModule.h" // For export macro
#include "vtkSmartPointer.h"            //Required for smart pointer internal ivars
#include "vtkTableAlgorithm.h"
 
class vtkDataArrayCollection;
class vtkDoubleArray;
class vtkIdTypeArray;
class vtkTable;
 
class VTKFILTERSSTATISTICS_EXPORT vtkBivariateLinearTableThreshold : public vtkTableAlgorithm
{
public:
  static vtkBivariateLinearTableThreshold* New();
  vtkTypeMacro(vtkBivariateLinearTableThreshold, vtkTableAlgorithm);
  void PrintSelf(ostream& os, vtkIndent indent) override;
 
 
  vtkSetMacro(Inclusive, int);
  vtkGetMacro(Inclusive, int);
 
  void AddColumnToThreshold(vtkIdType column, vtkIdType component);
 
  int GetNumberOfColumnsToThreshold();
 
  void GetColumnToThreshold(vtkIdType idx, vtkIdType& column, vtkIdType& component);
 
  void ClearColumnsToThreshold();
 
  vtkIdTypeArray* GetSelectedRowIds(int selection = 0);
 
  enum OutputPorts
  {
    OUTPUT_ROW_IDS = 0,
    OUTPUT_ROW_DATA
  };
  enum LinearThresholdType
  {
    BLT_ABOVE = 0,
    BLT_BELOW,
    BLT_NEAR,
    BLT_BETWEEN
  };
 
  void Initialize();
 
  void AddLineEquation(double* p1, double* p2);
 
  void AddLineEquation(double* p, double slope);
 
  void AddLineEquation(double a, double b, double c);
 
  void ClearLineEquations();
 
 
  vtkGetMacro(LinearThresholdType, int);
  vtkSetMacro(LinearThresholdType, int);
  void SetLinearThresholdTypeToAbove()
  {
    this->SetLinearThresholdType(vtkBivariateLinearTableThreshold::BLT_ABOVE);
  }
  void SetLinearThresholdTypeToBelow()
  {
    this->SetLinearThresholdType(vtkBivariateLinearTableThreshold::BLT_BELOW);
  }
  void SetLinearThresholdTypeToNear()
  {
    this->SetLinearThresholdType(vtkBivariateLinearTableThreshold::BLT_NEAR);
  }
  void SetLinearThresholdTypeToBetween()
  {
    this->SetLinearThresholdType(vtkBivariateLinearTableThreshold::BLT_BETWEEN);
  }
 
 
  vtkSetVector2Macro(ColumnRanges, double);
  vtkGetVector2Macro(ColumnRanges, double);
 
 
  vtkSetMacro(DistanceThreshold, double);
  vtkGetMacro(DistanceThreshold, double);
 
 
  vtkSetMacro(UseNormalizedDistance, vtkTypeBool);
  vtkGetMacro(UseNormalizedDistance, vtkTypeBool);
  vtkBooleanMacro(UseNormalizedDistance, vtkTypeBool);
 
  static void ComputeImplicitLineFunction(double* p1, double* p2, double* abc);
 
  static void ComputeImplicitLineFunction(double* p, double slope, double* abc);
 
protected:
  vtkBivariateLinearTableThreshold();
  ~vtkBivariateLinearTableThreshold() override;
 
  double ColumnRanges[2];
  double DistanceThreshold;
  int Inclusive;
  int LinearThresholdType;
  int NumberOfLineEquations;
  vtkTypeBool UseNormalizedDistance;
 
  vtkSmartPointer<vtkDoubleArray> LineEquations;
  class Internals;
  Internals* Implementation;
 
  int RequestData(vtkInformation*, vtkInformationVector**, vtkInformationVector*) override;
 
  int FillInputPortInformation(int port, vtkInformation* info) override;
  int FillOutputPortInformation(int port, vtkInformation* info) override;
 
  virtual int ApplyThreshold(vtkTable* tableToThreshold, vtkIdTypeArray* acceptedIds);
 
 
  int ThresholdAbove(double x, double y);
 
  int ThresholdBelow(double x, double y);
 
  int ThresholdNear(double x, double y);
 
  int ThresholdBetween(double x, double y);
 
private:
  vtkBivariateLinearTableThreshold(const vtkBivariateLinearTableThreshold&) = delete;
  void operator=(const vtkBivariateLinearTableThreshold&) = delete;
};
 
#endif