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 ITKIOImageBase_EXPORT ImageSeriesWriterException:public ExceptionObject
{
public:
  ~ImageSeriesWriterException() noexcept override;

  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 ITK_TEMPLATE_EXPORT ImageSeriesWriter:public ProcessObject
{
public:
  ITK_DISALLOW_COPY_AND_ASSIGN(ImageSeriesWriter);

  using Self = ImageSeriesWriter;
  using Superclass = ProcessObject;
  using Pointer = SmartPointer< Self >;
  using ConstPointer = SmartPointer< const Self >;

  itkNewMacro(Self);

  itkTypeMacro(ImageSeriesWriter, ProcessObject);

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

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

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

  const InputImageType * GetInput();

  const InputImageType * GetInput(unsigned int idx);

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

  virtual void Write();

  void Update() 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() override = default;
  void PrintSelf(std::ostream & os, Indent indent) const override;

  void GenerateData() override;

  void GenerateNumericFileNamesAndWrite();

  ImageIOBase::Pointer m_ImageIO;

  //track whether the ImageIO is user specified
  bool m_UserSpecifiedImageIO{false};

private:
  FileNamesContainer m_FileNames;

  std::string   m_SeriesFormat;
  SizeValueType m_StartIndex{1};
  SizeValueType m_IncrementIndex{1};

  bool m_UseCompression;

  DictionaryArrayRawPointer m_MetaDataDictionaryArray{nullptr};

  // 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 WriteFiles();
};
} // end namespace itk

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

#endif // itkImageSeriesWriter_h