dox/Imaging/vtkImageComplexMathematics.h

Go to the documentation of this file.

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

  Program:   vtkCNMRRLibrary
  Module:    $RCSfile: vtkImageComplexMathematics.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 __vtkImageComplexMathematics_h
#define __vtkImageComplexMathematics_h


// Operation options.
#define VTK_COMPLEX_DIVIDE        0
#define VTK_COMPLEX_MULT          1
#define VTK_COMPLEX_ADD           2
#define VTK_COMPLEX_SUBTRACT      3
#define VTK_COMPLEX_INVERT        4
#define VTK_COMPLEX_CONJUGATE     5
#define VTK_COMPLEX_PHASESHIFTBYK 6
#define VTK_COMPLEX_MAGNITUDE     7
#define VTK_COMPLEX_PHASE90       8
#define VTK_COMPLEX_PHASE180      9
#define VTK_COMPLEX_PHASE360      10


#include "vtkThreadedImageAlgorithm.h"
#include "vtkCNMRRImagingWin32Header.h"

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


  vtkSetMacro(Operation,int);
  vtkGetMacro(Operation,int);
  void SetOperationToComplexDivide() {this->SetOperation(VTK_COMPLEX_DIVIDE);};
  void SetOperationToComplexMultiply() {this->SetOperation(VTK_COMPLEX_MULT);};
  void SetOperationToComplexAdd() {this->SetOperation(VTK_COMPLEX_ADD);};
  void SetOperationToComplexSubtract() {this->SetOperation(VTK_COMPLEX_SUBTRACT);};
  void SetOperationToComplexInvert() {this->SetOperation(VTK_COMPLEX_INVERT);};
  void SetOperationToComplexConjugate() {this->SetOperation(VTK_COMPLEX_CONJUGATE);};
  void SetOperationToComplexPhaseShiftByK() {this->SetOperation(VTK_COMPLEX_PHASESHIFTBYK);};
  void SetOperationToComplexMagnitude() {this->SetOperation(VTK_COMPLEX_MAGNITUDE);};
  void SetOperationToComplexPhase90() {this->SetOperation(VTK_COMPLEX_PHASE90);};
  void SetOperationToComplexPhase180() {this->SetOperation(VTK_COMPLEX_PHASE180);};
  void SetOperationToComplexPhase360() {this->SetOperation(VTK_COMPLEX_PHASE360);};
  vtkSetMacro(ConstantC,double);
  vtkGetMacro(ConstantC,double);
  vtkSetMacro(ConstantK,double);
  vtkGetMacro(ConstantK,double);

  // How to handle divide by zero
  vtkSetMacro(DivideByZeroToC,int);
  vtkGetMacro(DivideByZeroToC,int);
  vtkBooleanMacro(DivideByZeroToC,int);
  

  virtual void SetInput1(vtkDataObject *in) { this->SetInput(0,in); }
  virtual void SetInput2(vtkDataObject *in) { this->SetInput(1,in); }

protected:
  vtkImageComplexMathematics();
  ~vtkImageComplexMathematics() {};

  int Operation;
  double ConstantC;
  double ConstantK;
  int DivideByZeroToC;
  
  virtual int RequestInformation (vtkInformation *, 
                                  vtkInformationVector **,
                                  vtkInformationVector *);
  
  virtual void ThreadedRequestData(vtkInformation *request, 
                                   vtkInformationVector **inputVector, 
                                   vtkInformationVector *outputVector,
                                   vtkImageData ***inData, 
                                   vtkImageData **outData,
                                   int extent[6], int threadId);

  virtual int FillInputPortInformation(int port, vtkInformation* info);
     
private:
  vtkImageComplexMathematics(const vtkImageComplexMathematics&);  // Not implemented.
  void operator=(const vtkImageComplexMathematics&);  // Not implemented.
};

#endif

---