itkImageSeriesWriter.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 __itkImageSeriesWriter_h
#define __itkImageSeriesWriter_h
#include "ITKIOImageBaseExport.h"

#include "itkImageRegion.h"
#include "itkImageFileWriter.h"
#include <vector>
#include <string>

namespace itk
{
class ITK_ABI_EXPORT ImageSeriesWriterException:public ExceptionObject
{
public:
  virtual ~ImageSeriesWriterException() throw( ) {};

  itkTypeMacro(ImageSeriesWriterException, ExceptionObject);

  ImageSeriesWriterException(char *file, unsigned int line,
                             const char *message = "Error in IO"):
    ExceptionObject(file, line)
  {
    SetDescription(message);
  }

  ImageSeriesWriterException(const std::string & file, unsigned int line,
                             const char *message = "Error in IO"):
    ExceptionObject(file, line)
  {
    SetDescription(message);
  }
};

template< typename TInputImage, typename TOutputImage >
class ITKIOImageBase_HIDDEN ImageSeriesWriter:public ProcessObject
{
public:
  typedef ImageSeriesWriter          Self;
  typedef ProcessObject              Superclass;
  typedef SmartPointer< Self >       Pointer;
  typedef SmartPointer< const Self > ConstPointer;

  itkNewMacro(Self);

  itkTypeMacro(ImageSeriesWriter, ProcessObject);

  typedef TInputImage                          InputImageType;
  typedef typename InputImageType::RegionType  InputImageRegionType;
  typedef TOutputImage                         OutputImageType;
  typedef typename OutputImageType::RegionType OutputImageRegionType;
  typedef ImageFileWriter< TOutputImage >      WriterType;
  typedef std::vector< std::string >           FileNamesContainer;

  typedef MetaDataDictionary                  DictionaryType;
  typedef MetaDataDictionary *                DictionaryRawPointer;
  typedef std::vector< DictionaryRawPointer > DictionaryArrayType;
  typedef const DictionaryArrayType *         DictionaryArrayRawPointer;

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

  const InputImageType * GetInput(void);

  const InputImageType * GetInput(unsigned int idx);

  itkSetObjectMacro(ImageIO, ImageIOBase);
  itkGetModifiableObjectMacro(ImageIO, ImageIOBase);

  virtual void Write(void);

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

  itkSetMacro(StartIndex, SizeValueType);
  itkGetConstMacro(StartIndex, SizeValueType);

  itkSetMacro(IncrementIndex, SizeValueType);
  itkGetConstMacro(IncrementIndex, SizeValueType);

  itkSetStringMacro(SeriesFormat);
  itkGetStringMacro(SeriesFormat);

  void SetFileNames(const FileNamesContainer & name)
  {
    if ( m_FileNames != name )
      {
      m_FileNames = name;
      this->Modified();
      }
  }

  const FileNamesContainer & GetFileNames() const
  {
    return m_FileNames;
  }

  void SetFileName(std::string const & name)
  {
    m_FileNames.clear();
    m_FileNames.push_back(name);
    this->Modified();
  }

  void AddFileName(std::string const & name)
  {
    m_FileNames.push_back(name);
    this->Modified();
  }

  itkSetMacro(MetaDataDictionaryArray, DictionaryArrayRawPointer);

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

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

  virtual void GenerateData(void) ITK_OVERRIDE;

  void GenerateNumericFileNamesAndWrite(void);

  ImageIOBase::Pointer m_ImageIO;

  //track whether the ImageIO is user specified
  bool m_UserSpecifiedImageIO;

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

  FileNamesContainer m_FileNames;

  std::string   m_SeriesFormat;
  SizeValueType m_StartIndex;
  SizeValueType m_IncrementIndex;

  bool m_UseCompression;

  DictionaryArrayRawPointer m_MetaDataDictionaryArray;

  // These two methods provide now a common implementation for the
  // GenerateNumericFileNamesAndWrite() and avoid the duplication of code that
  // was leaving one of the code branches out of date.
  void GenerateNumericFileNames(void);

  void WriteFiles();
};
} // end namespace itk

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

#endif // __itkImageSeriesWriter_h