dox/Imaging/vtkImageComparison.h

Go to the documentation of this file.

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

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


// Operation options.
#define VTK_GREATER_THAN       0
#define VTK_LESS_THAN          1
#define VTK_GREATER_THAN_EQUAL 2
#define VTK_LESS_THAN_EQUAL    3
#define VTK_EQUAL              4

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

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


  vtkSetMacro(Operation,int);
  vtkGetMacro(Operation,int);
  void SetOperationToGreaterThan() 
    {this->SetOperation(VTK_GREATER_THAN);}
  void SetOperationToLessThan() 
    {this->SetOperation(VTK_LESS_THAN);}
  void SetOperationToGreaterThanEqual() 
    {this->SetOperation(VTK_GREATER_THAN_EQUAL);}
  void SetOperationToLessThanEqual() 
    {this->SetOperation(VTK_LESS_THAN_EQUAL);}
  void SetOperationToEqual() 
    {this->SetOperation(VTK_EQUAL);}
  
  vtkSetMacro(ConstantC,double);
  vtkGetMacro(ConstantC,double);
  

  vtkSetMacro(OutputTrueValue, double);
  vtkGetMacro(OutputTrueValue, double);
  

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

  vtkSetMacro(OutputScalarType, int);
  vtkGetMacro(OutputScalarType, int);
  void SetOutputScalarTypeToDouble()
    {this->SetOutputScalarType(VTK_DOUBLE);}
  void SetOutputScalarTypeToFloat()
    {this->SetOutputScalarType(VTK_FLOAT);}
  void SetOutputScalarTypeToLong()
    {this->SetOutputScalarType(VTK_LONG);}
  void SetOutputScalarTypeToUnsignedLong()
    {this->SetOutputScalarType(VTK_UNSIGNED_LONG);}
  void SetOutputScalarTypeToInt()
    {this->SetOutputScalarType(VTK_INT);}
  void SetOutputScalarTypeToUnsignedInt()
    {this->SetOutputScalarType(VTK_UNSIGNED_INT);}
  void SetOutputScalarTypeToShort()
    {this->SetOutputScalarType(VTK_SHORT);}
  void SetOutputScalarTypeToUnsignedShort()
    {this->SetOutputScalarType(VTK_UNSIGNED_SHORT);}
  void SetOutputScalarTypeToChar()
    {this->SetOutputScalarType(VTK_CHAR);}
  void SetOutputScalarTypeToSignedChar()
    {this->SetOutputScalarType(VTK_SIGNED_CHAR);}
  void SetOutputScalarTypeToUnsignedChar()
    {this->SetOutputScalarType(VTK_UNSIGNED_CHAR);}

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

  int     Operation;
  double  ConstantC;
  double  OutputTrueValue;
  int     OutputScalarType;
  
  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:
  vtkImageComparison(const vtkImageComparison&);  // Not implemented.
  void operator=(const vtkImageComparison&);  // Not implemented.
};

#endif

---