dox/Imaging/vtkImageWindowingSource.h

Go to the documentation of this file.

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

  Program:   vtkCNMRRLibrary
  Module:    $RCSfile: vtkImageWindowingSource.h,v $

  Copyright  2006  The Pennsylvania State University
  
          Notice
 
  The contents of this file are subject to The Pennsylvania State University 
  Open Source License (the "License"); you may not use this file except in 
  compliance with the License. You may obtain a copy of the License at H066 
  Radiology, NMR Building, 500 University Drive, Hershey, PA, 
  tel. (717) 531-6069 or via email at dcb210@psu.edu.
 
  Software distributed under the License is distributed on an "AS IS" basis, 
  WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License 
  for the specific language governing rights and limitations under the 
  License.
 
  The Original Code is listed under Exhibit A of the license.
 
  The Initial Developer of the Original Code is Don Bigler.
 
  Contributor(s):

=========================================================================*/
#ifndef __vtkImageWindowingSource_h
#define __vtkImageWindowingSource_h

// Windowing options.
#define VTK_RECTANGULAR             0
#define VTK_BARTLETT             1
#define VTK_HANNING                 2
#define VTK_HAMMING                 3
#define VTK_BLACKMAN                4
#define VTK_FERMI                   5
#define VTK_WELCH                6
#define VTK_BLACKMAN_HARRIS_ONE     7
#define VTK_BLACKMAN_HARRIS_TWO     8
#define VTK_BLACKMAN_HARRIS_THREE   9
#define VTK_CAUCHY               10
#define VTK_BOHMAN               11
#define VTK_FLATTOP              12
#define VTK_KAISER_BESSEL        13
#define VTK_HANNING_POISSON         14
#define VTK_GAUSSIAN          15
#define VTK_KAISER               16

#include "vtkImageAlgorithm.h"
#include "vtkCNMRRImagingWin32Header.h"

class VTK_CNMRR_IMAGING_EXPORT vtkImageWindowingSource : public vtkImageAlgorithm
{
public:
  static vtkImageWindowingSource *New();
  vtkTypeRevisionMacro(vtkImageWindowingSource,vtkImageAlgorithm);
  void PrintSelf(ostream& os, vtkIndent indent);   
  

  void SetWholeExtent(int extent[6]);
  void SetWholeExtent(int minX, int maxX, int minY, int maxY, 
                            int minZ, int maxZ);
  void GetWholeExtent(int extent[6]);
  int *GetWholeExtent() {return this->WholeExtent;}
  

  vtkSetVector3Macro(Center, int);
  vtkGetVector3Macro(Center, int);
  

  vtkSetVector3Macro(Size, int);
  vtkGetVector3Macro(Size, int);
  

  vtkSetMacro(WindowingType,int);
  vtkGetMacro(WindowingType,int);
  void SetWindowingTypeToRectangular() {this->SetWindowingType(VTK_RECTANGULAR);};
  void SetWindowingTypeToBartlett() {this->SetWindowingType(VTK_BARTLETT);};
  void SetWindowingTypeToHanning() {this->SetWindowingType(VTK_HANNING);};
  void SetWindowingTypeToHamming() {this->SetWindowingType(VTK_HAMMING);};
  void SetWindowingTypeToBlackman() {this->SetWindowingType(VTK_BLACKMAN);};
  void SetWindowingTypeToFermi() {this->SetWindowingType(VTK_FERMI);};
  void SetWindowingTypeToWelch() {this->SetWindowingType(VTK_WELCH);};
  void SetWindowingTypeToBlackmanHarrisOne() {this->SetWindowingType(VTK_BLACKMAN_HARRIS_ONE);};
  void SetWindowingTypeToBlackmanHarrisTwo() {this->SetWindowingType(VTK_BLACKMAN_HARRIS_TWO);};
  void SetWindowingTypeToBlackmanHarrisThree() {this->SetWindowingType(VTK_BLACKMAN_HARRIS_THREE);};
  void SetWindowingTypeToCauchy() {this->SetWindowingType(VTK_CAUCHY);};
  void SetWindowingTypeToBohman() {this->SetWindowingType(VTK_BOHMAN);};
  void SetWindowingTypeToFlattop() {this->SetWindowingType(VTK_FLATTOP);};
  void SetWindowingTypeToKaiserBessel() {this->SetWindowingType(VTK_KAISER_BESSEL);};
  void SetWindowingTypeToHanningPoisson() {this->SetWindowingType(VTK_HANNING_POISSON);};
  void SetWindowingTypeToGaussian() {this->SetWindowingType(VTK_GAUSSIAN);};
  void SetWindowingTypeToKaiser() {this->SetWindowingType(VTK_KAISER);};
  

  vtkSetMacro(FermiCutoff,double);
  vtkGetMacro(FermiCutoff,double);
  

  vtkSetMacro(FermiPass,double);
  vtkGetMacro(FermiPass,double);
  

  vtkSetMacro(CauchyAlpha,double);
  vtkGetMacro(CauchyAlpha,double);
  

  vtkSetMacro(HanningPoissonAlpha,double);
  vtkGetMacro(HanningPoissonAlpha,double);
  

  vtkSetMacro(GaussianVariance,double);
  vtkGetMacro(GaussianVariance,double);
  

  vtkSetMacro(KaiserCutoff,double);
  vtkGetMacro(KaiserCutoff,double);
  

  vtkSetMacro(KaiserPass,double);
  vtkGetMacro(KaiserPass,double);
  
  void SetSizeRelativeToKaiserDelta(double delta, int dimensions);
  

  vtkSetMacro(OutputScalarType,int);
  vtkGetMacro(OutputScalarType,int);
  void SetOutputScalarTypeToFloat()
    {this->SetOutputScalarType(VTK_FLOAT);}
  void SetOutputScalarTypeToDouble()
    {this->SetOutputScalarType(VTK_DOUBLE);}
   

  vtkSetMacro(OutputNumberOfScalarComponents,int);
  vtkGetMacro(OutputNumberOfScalarComponents,int);
   

  void SetDimensionality(int dim);
  vtkGetMacro(Dimensionality,int);
  
protected:
  vtkImageWindowingSource();
  ~vtkImageWindowingSource();

  int Dimensionality;
  int WholeExtent[6];
  int Center[3];
  int Size[3];
  int OutputScalarType;
  int OutputNumberOfScalarComponents;
  int WindowingType;
  double FermiCutoff;
  double FermiPass;
  double CauchyAlpha;
  double HanningPoissonAlpha;
  double GaussianVariance;
  double KaiserCutoff;
  double KaiserPass;
  
  virtual int RequestInformation (vtkInformation *, 
                                  vtkInformationVector **, 
                                  vtkInformationVector *);

  virtual int RequestData(vtkInformation *, 
                          vtkInformationVector **, vtkInformationVector *);
                    
private:
  vtkImageWindowingSource(const vtkImageWindowingSource&);  // Not implemented.
  void operator=(const vtkImageWindowingSource&);  // Not implemented.
};


#endif

---