itkTIFFImageIO.h

Go to the documentation of this file.

/*=========================================================================
 *
 *  Copyright NumFOCUS
 *
 *  Licensed under the Apache License, Version 2.0 (the "License");
 *  you may not use this file except in compliance with the License.
 *  You may obtain a copy of the License at
 *
 *         https://www.apache.org/licenses/LICENSE-2.0.txt
 *
 *  Unless required by applicable law or agreed to in writing, software
 *  distributed under the License is distributed on an "AS IS" BASIS,
 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *  See the License for the specific language governing permissions and
 *  limitations under the License.
 *
 *=========================================================================*/
#ifndef itkTIFFImageIO_h
#define itkTIFFImageIO_h
#include "ITKIOTIFFExport.h"
 
#include "itkImageIOBase.h"
#include <fstream>
 
namespace itk
{
// BTX
class TIFFReaderInternal;
// ETX

class ITKIOTIFF_EXPORT TIFFImageIO : public ImageIOBase
{
public:
  ITK_DISALLOW_COPY_AND_MOVE(TIFFImageIO);

  using Self = TIFFImageIO;
  using Superclass = ImageIOBase;
  using Pointer = SmartPointer<Self>;
 
  using RGBPixelType = RGBPixel<unsigned short>;
  using PaletteType = std::vector<RGBPixelType>;

  itkNewMacro(Self);

  itkOverrideGetNameOfClassMacro(TIFFImageIO);
 
  /*-------- This part of the interface deals with reading data. ------ */

  bool
  CanReadFile(const char *) override;

  void
  ReadImageInformation() override;

  void
  Read(void * buffer) override;

  virtual void
  ReadVolume(void * buffer);
 
  /*-------- This part of the interfaces deals with writing data. ----- */

  bool
  CanWriteFile(const char *) override;

  void
  WriteImageInformation() override;

  void
  Write(const void * buffer) override;
 
  enum
  {
    NOFORMAT,
    RGB_,
    GRAYSCALE,
    PALETTE_RGB,
    PALETTE_GRAYSCALE,
    OTHER
  };
 
  // BTX
  enum
  { // Compression types
    NoCompression,
    PackBits,
    JPEG,
    Deflate,
    AdobeDeflate,
    LZW
  };
  // ETX

  void
  SetCompressionToNoCompression()
  {
    this->UseCompressionOff();
    this->SetCompressor("NoCompression");
  }
  void
  SetCompressionToPackBits()
  {
    this->UseCompressionOn();
    this->SetCompressor("PackBits");
  }
  void
  SetCompressionToJPEG()
  {
    this->UseCompressionOn();
    this->SetCompressor("JPEG");
  }
  void
  SetCompressionToDeflate()
  {
    this->UseCompressionOn();
    this->SetCompressor("Deflate");
  }
  void
  SetCompressionToAdobeDeflate()
  {
    this->UseCompressionOn();
    this->SetCompressor("AdobeDeflate");
  }
  void
  SetCompressionToLZW()
  {
    this->UseCompressionOn();
    this->SetCompressor("LZW");
  }
 

  virtual void
  SetJPEGQuality(int jpegQuality)
  {
    this->SetCompressionLevel(jpegQuality);
  }
  virtual int
  GetJPEGQuality() const
  {
    return this->GetCompressionLevel();
  }


  itkGetConstReferenceMacro(ColorPalette, PaletteType);

  void
  SetColorPalette(const PaletteType _arg)
  {
    if (this->m_ColorPalette != _arg)
    {
      this->m_ColorPalette = _arg;
      this->Modified();
    }
  }
 
protected:
  TIFFImageIO();
  ~TIFFImageIO() override;
  void
  PrintSelf(std::ostream & os, Indent indent) const override;
 
  void
  InternalSetCompressor(const std::string & _compressor) override;
 
  // This method is protected because it does not keep
  // ImageIO::m_Compressor and TIFFImageIO::m_Compression in sync.
  void
  SetCompression(int compression)
  {
    m_Compression = compression;
  }
 
  void
  InternalWrite(const void * buffer);
 
  void
  InitializeColors();
 
  void
  ReadGenericImage(void * out, unsigned int width, unsigned int height);
 
  // To support Zeiss images
  void
  ReadTwoSamplesPerPixelImage(void * out, unsigned int width, unsigned int height);
 
  unsigned int
  GetFormat();
 
  void
  GetColor(uint64_t index, uint16_t * red, uint16_t * green, uint16_t * blue);
 
  // Check that tag t can be found
  bool
  CanFindTIFFTag(unsigned int t);
 
  // Read and returns the raw bytes of tag t
  void *
  ReadRawByteFromTag(unsigned int t, unsigned int & value_count);
 
  // Populate m_ColorPalette from the file palette
  // The palette corresponds to the one of the first page in case of multipage tiff
  void
  PopulateColorPalette();
 
  TIFFReaderInternal * m_InternalImage{};
 
  void
  ReadTIFFTags();
 
  int m_Compression{};
 
  PaletteType m_ColorPalette{};
 
private:
  void
  AllocateTiffPalette(uint16_t bps);
 
  void
  ReadCurrentPage(void * buffer, size_t pixelOffset);
 
  template <typename TComponent>
  void
  ReadGenericImage(void * _out, unsigned int width, unsigned int height);
 
  template <typename TComponent>
  void
  RGBAImageToBuffer(void * out, const uint32_t * tempImage);
 
  template <typename TType>
  void
  PutRow(TType * to, void * from, unsigned int xsize);
 
  template <typename TType>
  void
  PutGrayscale(TType *      to,
               TType *      from,
               unsigned int xsize,
               unsigned int ysize,
               unsigned int toskew,
               unsigned int fromskew);
 
  template <typename TType>
  void
  PutRGB_(TType * to, TType * from, unsigned int xsize, unsigned int ysize, unsigned int toskew, unsigned int fromskew);
 
 
  template <typename TType, typename TFromType>
  void
  PutPaletteGrayscale(TType *      to,
                      TFromType *  from,
                      unsigned int xsize,
                      unsigned int ysize,
                      unsigned int toskew,
                      unsigned int fromskew);
 
  template <typename TType, typename TFromType>
  void
  PutPaletteRGB(TType *      to,
                TFromType *  from,
                unsigned int xsize,
                unsigned int ysize,
                unsigned int toskew,
                unsigned int fromskew);
 
  template <typename TType, typename TFromType>
  void
  PutPaletteScalar(TType *      to,
                   TFromType *  from,
                   unsigned int xsize,
                   unsigned int ysize,
                   unsigned int toskew,
                   unsigned int fromskew);
 
  uint16_t *   m_ColorRed{};
  uint16_t *   m_ColorGreen{};
  uint16_t *   m_ColorBlue{};
  uint64_t     m_TotalColors{ 0 };
  unsigned int m_ImageFormat{ TIFFImageIO::NOFORMAT };
};
} // end namespace itk
 
#endif // itkTIFFImageIO_h