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) override;


  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,vtkTypeBool);
  virtual vtkTypeBool GetSwapBytes() {return this->SwapBytes;}
  vtkBooleanMacro(SwapBytes,vtkTypeBool);

  ifstream *GetFile() {return this->File;}
  vtkGetVectorMacro(DataIncrements,unsigned long,4);

  virtual int OpenFile();
  virtual void SeekFile(int i, int j, int k);


  vtkBooleanMacro(FileLowerLeft, vtkTypeBool);
  vtkGetMacro(FileLowerLeft, vtkTypeBool);
  vtkSetMacro(FileLowerLeft, vtkTypeBool);


  virtual void ComputeInternalFileName(int slice);
  vtkGetStringMacro(InternalFileName);

  virtual int CanReadFile(const char* vtkNotUsed(fname))
  {
      return 0;
  }

  virtual const char* GetFileExtensions()
  {
      return nullptr;
  }


  virtual const char* GetDescriptiveName()
  {
      return nullptr;
  }
protected:
  vtkImageReader2();
  ~vtkImageReader2() override;

  vtkStringArray *FileNames;

  char *InternalFileName;
  char *FileName;
  char *FilePrefix;
  char *FilePattern;
  int NumberOfScalarComponents;
  vtkTypeBool FileLowerLeft;

  void *MemoryBuffer;
  vtkIdType MemoryBufferLength;

  ifstream *File;
  unsigned long DataIncrements[4];
  int DataExtent[6];
  vtkTypeBool SwapBytes;

  int FileDimensionality;
  unsigned long HeaderSize;
  int DataScalarType;
  unsigned long ManualHeaderSize;

  double DataSpacing[3];
  double DataOrigin[3];

  int FileNameSliceOffset;
  int FileNameSliceSpacing;

  int RequestInformation(vtkInformation* request,
                                 vtkInformationVector** inputVector,
                                 vtkInformationVector* outputVector) override;
  virtual void ExecuteInformation();
  void ExecuteDataWithInformation(vtkDataObject *data, vtkInformation *outInfo) override;
  virtual void ComputeDataIncrements();
private:
  vtkImageReader2(const vtkImageReader2&) = delete;
  void operator=(const vtkImageReader2&) = delete;
};

#endif