itkImageFileWriter.h

Go to the documentation of this file.

/*=========================================================================
 *
 *  Copyright Insight Software Consortium
 *
 *  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
 *
 *         http://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 __itkImageFileWriter_h
#define __itkImageFileWriter_h

#include "itkProcessObject.h"
#include "itkImageIOBase.h"
#include "itkMacro.h"

namespace itk
{
class ITK_ABI_EXPORT ImageFileWriterException:public ExceptionObject
{
public:
  itkTypeMacro(ImageFileWriterException, ExceptionObject);

  ImageFileWriterException(const char *file, unsigned int line,
                           const char *message = "Error in IO",
                           const char *loc = "Unknown"):
    ExceptionObject(file, line, message, loc)
  {}

  ImageFileWriterException(const std::string & file, unsigned int line,
                           const char *message = "Error in IO",
                           const char *loc = "Unknown"):
    ExceptionObject(file, line, message, loc)
  {}

  virtual ~ImageFileWriterException() throw( )
  {}
};

template< class TInputImage >
class ITK_EXPORT ImageFileWriter:public ProcessObject
{
public:
  typedef ImageFileWriter            Self;
  typedef ProcessObject              Superclass;
  typedef SmartPointer< Self >       Pointer;
  typedef SmartPointer< const Self > ConstPointer;

  itkNewMacro(Self);

  itkTypeMacro(ImageFileWriter, ProcessObject);

  typedef TInputImage                         InputImageType;
  typedef typename InputImageType::Pointer    InputImagePointer;
  typedef typename InputImageType::RegionType InputImageRegionType;
  typedef typename InputImageType::PixelType  InputImagePixelType;

  using Superclass::SetInput;
  void SetInput(const InputImageType *input);

  const InputImageType * GetInput(void);

  const InputImageType * GetInput(unsigned int idx);

  itkSetStringMacro(FileName);
  itkGetStringMacro(FileName);

  void SetImageIO(ImageIOBase *io)
  {
    if ( this->m_ImageIO != io )
      {
      this->Modified();
      this->m_ImageIO = io;
      }
    m_FactorySpecifiedImageIO = false;
  }

  itkGetObjectMacro(ImageIO, ImageIOBase);

  virtual void Write(void);

  void SetIORegion(const ImageIORegion & region);

  const ImageIORegion & GetIORegion(void) const
  {
    return m_PasteIORegion;
  }

  itkSetMacro(NumberOfStreamDivisions, unsigned int);
  itkGetConstReferenceMacro(NumberOfStreamDivisions, unsigned int);

  virtual void Update()
  {
    this->Write();
  }

  virtual void UpdateLargestPossibleRegion()
  {
    m_PasteIORegion = ImageIORegion(TInputImage::ImageDimension);
    m_UserSpecifiedIORegion = false;
    this->Write();
  }

  itkSetMacro(UseCompression, bool);
  itkGetConstReferenceMacro(UseCompression, bool);
  itkBooleanMacro(UseCompression);

  itkSetMacro(UseInputMetaDataDictionary, bool);
  itkGetConstReferenceMacro(UseInputMetaDataDictionary, bool);
  itkBooleanMacro(UseInputMetaDataDictionary);

protected:
  ImageFileWriter();
  ~ImageFileWriter();
  void PrintSelf(std::ostream & os, Indent indent) const;

  void GenerateData(void);

private:
  ImageFileWriter(const Self &); //purposely not implemented
  void operator=(const Self &);  //purposely not implemented

  std::string m_FileName;

  ImageIOBase::Pointer m_ImageIO;
  bool                 m_UserSpecifiedImageIO; // track whether the ImageIO
                                               // is user specified

  ImageIORegion m_PasteIORegion;
  unsigned int  m_NumberOfStreamDivisions;
  bool          m_UserSpecifiedIORegion;    // track whether the region
                                            // is user specified
  bool m_FactorySpecifiedImageIO;           //track whether the factory
                                            //  mechanism set the ImageIO
  bool m_UseCompression;
  bool m_UseInputMetaDataDictionary;        // whether to use the
                                            // MetaDataDictionary from the
                                            // input or not.
};
} // end namespace itk

#ifndef ITK_MANUAL_INSTANTIATION
#include "itkImageFileWriter.hxx"
#endif

#ifdef ITK_IO_FACTORY_REGISTER_MANAGER
#include "itkImageIOFactoryRegisterManager.h"
#endif

#endif // __itkImageFileWriter_h