vtkImageHistogram.h

Go to the documentation of this file.

/*=========================================================================
 
  Program:   Visualization Toolkit
  Module:    vtkImageHistogram.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 vtkImageHistogram_h
#define vtkImageHistogram_h
 
#include "vtkImagingStatisticsModule.h" // For export macro
#include "vtkThreadedImageAlgorithm.h"
 
class vtkImageStencilData;
class vtkIdTypeArray;
 
class VTKIMAGINGSTATISTICS_EXPORT vtkImageHistogram : public vtkThreadedImageAlgorithm
{
public:
  static vtkImageHistogram *New();
  vtkTypeMacro(vtkImageHistogram,vtkThreadedImageAlgorithm);
 
  void PrintSelf(ostream& os, vtkIndent indent);
 
 
  enum {
    Linear = 0,
    Log = 1,
    Sqrt = 2
    };
 
 
  vtkSetMacro(ActiveComponent, int);
  vtkGetMacro(ActiveComponent, int);
 
 
  vtkSetMacro(AutomaticBinning, int);
  vtkBooleanMacro(AutomaticBinning, int);
  vtkGetMacro(AutomaticBinning, int);
 
 
  vtkSetMacro(MaximumNumberOfBins, int);
  vtkGetMacro(MaximumNumberOfBins, int);
 
 
  vtkSetMacro(NumberOfBins, int);
  vtkGetMacro(NumberOfBins, int);
 
 
  vtkSetMacro(BinOrigin, double);
  vtkGetMacro(BinOrigin, double);
 
 
  vtkSetMacro(BinSpacing, double);
  vtkGetMacro(BinSpacing, double);
 
 
  void SetStencilData(vtkImageStencilData *stencil);
  vtkImageStencilData *GetStencil();
 
  void SetStencilConnection(vtkAlgorithmOutput* algOutput);
 
 
  vtkSetMacro(GenerateHistogramImage, int);
  vtkBooleanMacro(GenerateHistogramImage, int);
  vtkGetMacro(GenerateHistogramImage, int);
 
 
  vtkSetVector2Macro(HistogramImageSize, int);
  vtkGetVector2Macro(HistogramImageSize, int);
 
 
  vtkSetClampMacro(HistogramImageScale, int,
    vtkImageHistogram::Linear, vtkImageHistogram::Sqrt);
  void SetHistogramImageScaleToLinear() {
    this->SetHistogramImageScale(vtkImageHistogram::Linear); }
  void SetHistogramImageScaleToLog() {
    this->SetHistogramImageScale(vtkImageHistogram::Log); }
  void SetHistogramImageScaleToSqrt() {
    this->SetHistogramImageScale(vtkImageHistogram::Sqrt); }
  vtkGetMacro(HistogramImageScale, int);
  const char *GetHistogramImageScaleAsString();
 
  vtkIdTypeArray *GetHistogram();
 
  vtkIdType GetTotal() { return this->Total; }
 
 
  virtual void ThreadedRequestData(vtkInformation *request,
                                   vtkInformationVector **inputVector,
                                   vtkInformationVector *outputVector,
                                   vtkImageData ***inData,
                                   vtkImageData **outData, int ext[6], int id);
protected:
  vtkImageHistogram();
  ~vtkImageHistogram();
 
  virtual int RequestUpdateExtent(vtkInformation *vtkNotUsed(request),
                                 vtkInformationVector **inInfo,
                                 vtkInformationVector *vtkNotUsed(outInfo));
  virtual int RequestInformation(vtkInformation *vtkNotUsed(request),
                                 vtkInformationVector **inInfo,
                                 vtkInformationVector *vtkNotUsed(outInfo));
  virtual int RequestData(vtkInformation *,
                          vtkInformationVector **,
                          vtkInformationVector *);
 
  virtual int FillInputPortInformation(int port, vtkInformation *info);
  virtual int FillOutputPortInformation(int port, vtkInformation *info);
 
  void ComputeImageScalarRange(vtkImageData *data, double range[2]);
 
  int ActiveComponent;
  int AutomaticBinning;
  int MaximumNumberOfBins;
 
  int HistogramImageSize[2];
  int HistogramImageScale;
  int GenerateHistogramImage;
 
  int NumberOfBins;
  double BinOrigin;
  double BinSpacing;
 
  vtkIdTypeArray *Histogram;
  vtkIdType Total;
 
  vtkIdType *ThreadOutput[VTK_MAX_THREADS];
  int ThreadBinRange[VTK_MAX_THREADS][2];
 
private:
  vtkImageHistogram(const vtkImageHistogram&);  // Not implemented.
  void operator=(const vtkImageHistogram&);  // Not implemented.
};
 
#endif