vtkImageReader2.h

Go to the documentation of this file.

/*=========================================================================
 
  Program:   Visualization Toolkit
  Module:    vtkImageReader2.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 vtkImageReader2_h
#define vtkImageReader2_h
 
#include "vtkIOImageModule.h" // For export macro
#include "vtkImageAlgorithm.h"
 
class vtkStringArray;
 
#define VTK_FILE_BYTE_ORDER_BIG_ENDIAN 0
#define VTK_FILE_BYTE_ORDER_LITTLE_ENDIAN 1
 
class VTKIOIMAGE_EXPORT vtkImageReader2 : public vtkImageAlgorithm
{
public:
  static vtkImageReader2 *New();
  vtkTypeMacro(vtkImageReader2,vtkImageAlgorithm);
  void PrintSelf(ostream& os, vtkIndent indent);
 
 
  virtual void SetFileName(const char *);
  vtkGetStringMacro(FileName);
 
 
  virtual void SetFileNames(vtkStringArray *);
  vtkGetObjectMacro(FileNames, vtkStringArray);
 
 
  virtual void SetFilePrefix(const char *);
  vtkGetStringMacro(FilePrefix);
 
 
  virtual void SetFilePattern(const char *);
  vtkGetStringMacro(FilePattern);
 
 
  virtual void SetMemoryBuffer(void *);
  virtual void *GetMemoryBuffer() { return this->MemoryBuffer; }
 
 
  virtual void SetMemoryBufferLength(vtkIdType buflen);
  vtkIdType GetMemoryBufferLength() { return this->MemoryBufferLength; }
 
 
  virtual void SetDataScalarType(int type);
  virtual void SetDataScalarTypeToFloat(){this->SetDataScalarType(VTK_FLOAT);}
  virtual void SetDataScalarTypeToDouble(){this->SetDataScalarType(VTK_DOUBLE);}
  virtual void SetDataScalarTypeToInt(){this->SetDataScalarType(VTK_INT);}
  virtual void SetDataScalarTypeToUnsignedInt(){this->SetDataScalarType(VTK_UNSIGNED_INT);}
  virtual void SetDataScalarTypeToShort(){this->SetDataScalarType(VTK_SHORT);}
  virtual void SetDataScalarTypeToUnsignedShort()
    {this->SetDataScalarType(VTK_UNSIGNED_SHORT);}
  virtual void SetDataScalarTypeToChar()
    {this->SetDataScalarType(VTK_CHAR);}
  virtual void SetDataScalarTypeToSignedChar()
    {this->SetDataScalarType(VTK_SIGNED_CHAR);}
  virtual void SetDataScalarTypeToUnsignedChar()
    {this->SetDataScalarType(VTK_UNSIGNED_CHAR);}
 
 
  vtkGetMacro(DataScalarType, int);
 
 
  vtkSetMacro(NumberOfScalarComponents,int);
  vtkGetMacro(NumberOfScalarComponents,int);
 
 
  vtkSetVector6Macro(DataExtent,int);
  vtkGetVector6Macro(DataExtent,int);
 
 
  vtkSetMacro(FileDimensionality, int);
  int GetFileDimensionality() {return this->FileDimensionality;}
 
 
  vtkSetVector3Macro(DataSpacing,double);
  vtkGetVector3Macro(DataSpacing,double);
 
 
  vtkSetVector3Macro(DataOrigin,double);
  vtkGetVector3Macro(DataOrigin,double);
 
 
  unsigned long GetHeaderSize();
  unsigned long GetHeaderSize(unsigned long slice);
 
  virtual void SetHeaderSize(unsigned long size);
 
 
  virtual void SetDataByteOrderToBigEndian();
  virtual void SetDataByteOrderToLittleEndian();
  virtual int GetDataByteOrder();
  virtual void SetDataByteOrder(int);
  virtual const char *GetDataByteOrderAsString();
 
 
  vtkSetMacro(FileNameSliceOffset,int);
  vtkGetMacro(FileNameSliceOffset,int);
 
 
  vtkSetMacro(FileNameSliceSpacing,int);
  vtkGetMacro(FileNameSliceSpacing,int);
 
 
 
  vtkSetMacro(SwapBytes,int);
  virtual int GetSwapBytes() {return this->SwapBytes;}
  vtkBooleanMacro(SwapBytes,int);
 
//BTX
  ifstream *GetFile() {return this->File;}
  vtkGetVectorMacro(DataIncrements,unsigned long,4);
//ETX
 
  virtual int OpenFile();
  virtual void SeekFile(int i, int j, int k);
 
 
  vtkBooleanMacro(FileLowerLeft, int);
  vtkGetMacro(FileLowerLeft, int);
  vtkSetMacro(FileLowerLeft, int);
 
 
  virtual void ComputeInternalFileName(int slice);
  vtkGetStringMacro(InternalFileName);
 
 
  virtual int CanReadFile(const char* vtkNotUsed(fname))
    {
      return 0;
    }
 
 
  virtual const char* GetFileExtensions()
    {
      return 0;
    }
 
 
  virtual const char* GetDescriptiveName()
    {
      return 0;
    }
protected:
  vtkImageReader2();
  ~vtkImageReader2();
 
  vtkStringArray *FileNames;
 
  char *InternalFileName;
  char *FileName;
  char *FilePrefix;
  char *FilePattern;
  int NumberOfScalarComponents;
  int FileLowerLeft;
 
  void *MemoryBuffer;
  vtkIdType MemoryBufferLength;
 
  ifstream *File;
  unsigned long DataIncrements[4];
  int DataExtent[6];
  int SwapBytes;
 
  int FileDimensionality;
  unsigned long HeaderSize;
  int DataScalarType;
  unsigned long ManualHeaderSize;
 
  double DataSpacing[3];
  double DataOrigin[3];
 
  int FileNameSliceOffset;
  int FileNameSliceSpacing;
 
  virtual int RequestInformation(vtkInformation* request,
                                 vtkInformationVector** inputVector,
                                 vtkInformationVector* outputVector);
  virtual void ExecuteInformation();
  virtual void ExecuteDataWithInformation(vtkDataObject *data, vtkInformation *outInfo);
  virtual void ComputeDataIncrements();
private:
  vtkImageReader2(const vtkImageReader2&);  // Not implemented.
  void operator=(const vtkImageReader2&);  // Not implemented.
};
 
#endif