dox/IO/Image/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