X-Git-Url: https://git.creatis.insa-lyon.fr/pubgit/?a=blobdiff_plain;f=common%2FclitkImageToImageGenericFilterBase.cxx;h=c538ac0d196a3773508918f110b093785a8be7e8;hb=d55f025b18f68066a52b8f33c2dc6481e82c2580;hp=2c445bc7b2180f4e42e44557b3f75648b09a6b1c;hpb=34490f432219fe05c7ae19c4cf012b5529d784dc;p=clitk.git

diff --git a/common/clitkImageToImageGenericFilterBase.cxx b/common/clitkImageToImageGenericFilterBase.cxx
index 2c445bc..c538ac0 100644
--- a/common/clitkImageToImageGenericFilterBase.cxx
+++ b/common/clitkImageToImageGenericFilterBase.cxx
@@ -1,32 +1,26 @@
 /*=========================================================================
+  Program:   vv                     http://www.creatis.insa-lyon.fr/rio/vv
 
-  Program:   vv
-  Module:    $RCSfile: clitkImageToImageGenericFilterBase.cxx,v $
-  Language:  C++
-  Date:      $Date: 2010/03/24 10:48:05 $
-  Version:   $Revision: 1.3 $
-  Author :   Joel Schaerer <joel.schaerer@creatis.insa-lyon.fr>
-  David Sarrut <david.sarrut@creatis.insa-lyon.fr>
+  Authors belong to:
+  - University of LYON              http://www.universite-lyon.fr/
+  - Léon Bérard cancer center       http://www.centreleonberard.fr
+  - CREATIS CNRS laboratory         http://www.creatis.insa-lyon.fr
 
-  Copyright (C) 2008
-  Léon Bérard cancer center http://oncora1.lyon.fnclcc.fr
-  CREATIS-LRMN http://www.creatis.insa-lyon.fr
+  This software is distributed WITHOUT ANY WARRANTY; without even
+  the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+  PURPOSE.  See the copyright notices for more information.
 
-  This program is free software: you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation, version 3 of the License.
+  It is distributed under dual licence
 
-  This program is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with this program.  If not, see <http://www.gnu.org/licenses/>.
-
-  =========================================================================*/
+  - BSD        See included LICENSE.txt file
+  - CeCILL-B   http://www.cecill.info/licences/Licence_CeCILL-B_V1-en.html
+===========================================================================**/
 
+// clitk
 #include "clitkImageToImageGenericFilterBase.h"
+#include "clitkExceptionObject.h"
+
+// itk
 #include <itkImage.h>
 
 //--------------------------------------------------------------------
@@ -36,56 +30,98 @@ clitk::ImageToImageGenericFilterBase::~ImageToImageGenericFilterBase() {}
 
 //--------------------------------------------------------------------
 clitk::ImageToImageGenericFilterBase::ImageToImageGenericFilterBase(std::string n)
-  :mIOVerbose(false) {
-  mFilterName = n;
-  mFailOnImageTypeError = true;
-  mReadOnDisk = true;
+  :m_IOVerbose(false)
+{
+  m_FilterName = n;
+  m_FailOnImageTypeError = true;
+  m_ReadOnDisk = true;
+  m_WriteOnDisk = true;
+  m_WriteCompression = false;
+  // m_LastError = "";
+  // StopOnErrorOn();
+  SetFilterBase(NULL);
+}
+//--------------------------------------------------------------------
+
+
+//--------------------------------------------------------------------
+void clitk::ImageToImageGenericFilterBase::SetInputFilenames(const std::vector<std::string> & filenames)
+{
+  m_InputFilenames = filenames;
+  // in this case, assume by default that we DO want to write/read on
+  // disk (rather a command line tool, but not a vvTool. Can be
+  // changed with EnableReadOnDisk and EnableWriteOnDisk)
+  EnableReadOnDisk(true);
+  EnableWriteOnDisk(true);
 }
 //--------------------------------------------------------------------
 
 
 //--------------------------------------------------------------------
-void clitk::ImageToImageGenericFilterBase::SetInputFilenames(const std::vector<std::string> & filenames) {
-    mInputFilenames=filenames;
+void clitk::ImageToImageGenericFilterBase::EnableReadOnDisk(bool b)
+{
+  m_ReadOnDisk = b;
 }
 //--------------------------------------------------------------------
 
 
 //--------------------------------------------------------------------
-void clitk::ImageToImageGenericFilterBase::EnableReadOnDisk(bool b) {
-  mReadOnDisk = b;
+void clitk::ImageToImageGenericFilterBase::EnableWriteOnDisk(bool b)
+{
+  m_WriteOnDisk = b;
 }
 //--------------------------------------------------------------------
 
 
 //--------------------------------------------------------------------
-void clitk::ImageToImageGenericFilterBase::SetInputFilename(const std::string & filename) {
+void clitk::ImageToImageGenericFilterBase::EnableWriteCompression(bool b)
+{
+  m_WriteCompression = b;
+}
+//--------------------------------------------------------------------
+
+
+//--------------------------------------------------------------------
+void clitk::ImageToImageGenericFilterBase::SetInputFilename(const std::string & filename)
+{
   std::vector<std::string> f;
   f.push_back(filename);
   SetInputFilenames(f);
+  // in this case, assume by default that we DO want to write/read on
+  // disk (rather a command line tool, but not a vvTool. Can be
+  // changed with EnableReadOnDisk and EnableWriteOnDisk)
+  EnableReadOnDisk(true);
+  EnableWriteOnDisk(true);
 }
 //--------------------------------------------------------------------
 
 
 //--------------------------------------------------------------------
-void clitk::ImageToImageGenericFilterBase::AddInputFilename(const std::string & filename) {
-  mInputFilenames.push_back(filename);
+void clitk::ImageToImageGenericFilterBase::AddInputFilename(const std::string & filename)
+{
+  m_InputFilenames.push_back(filename);
+  // in this case, assume by default that we DO want to write/read on
+  // disk (rather a command line tool, but not a vvTool. Can be
+  // changed with EnableReadOnDisk and EnableWriteOnDisk)
+  EnableReadOnDisk(true);
+  EnableWriteOnDisk(true);
 }
 //--------------------------------------------------------------------
 
 
 //--------------------------------------------------------------------
-void clitk::ImageToImageGenericFilterBase::SetOutputFilename(const std::string & filename) {
-  mOutputFilenames.clear();
-  mOutputFilenames.push_back(filename);
+void clitk::ImageToImageGenericFilterBase::SetOutputFilename(const std::string & filename)
+{
+  m_OutputFilenames.clear();
+  m_OutputFilenames.push_back(filename);
 }
 //--------------------------------------------------------------------
 
 
 //--------------------------------------------------------------------
-void clitk::ImageToImageGenericFilterBase::AddOutputFilename(const std::string & filename)
+void clitk::ImageToImageGenericFilterBase::AddOutputFilename(const std::string filename)
 {
-  mOutputFilenames.push_back(filename);
+  m_OutputFilenames.push_back(filename);
 }
 //--------------------------------------------------------------------
 
@@ -93,8 +129,8 @@ void clitk::ImageToImageGenericFilterBase::AddOutputFilename(const std::string &
 //--------------------------------------------------------------------
 void clitk::ImageToImageGenericFilterBase::SetOutputFilenames(const std::vector<std::string> & filenames)
 {
-    mOutputFilenames.clear();
-    std::copy(filenames.begin(),filenames.end(),mOutputFilenames.begin());
+  m_OutputFilenames.clear();
+  std::copy(filenames.begin(),filenames.end(),m_OutputFilenames.begin());
 }
 //--------------------------------------------------------------------
 
@@ -102,32 +138,33 @@ void clitk::ImageToImageGenericFilterBase::SetOutputFilenames(const std::vector<
 //--------------------------------------------------------------------
 std::string clitk::ImageToImageGenericFilterBase::GetOutputFilename()
 {
-    assert(mOutputFilenames.size() == 1);
-    return mOutputFilenames.front();
+  assert(m_OutputFilenames.size() == 1);
+  return m_OutputFilenames.front();
 }
 //--------------------------------------------------------------------
 
 
 //--------------------------------------------------------------------
 void clitk::ImageToImageGenericFilterBase::GetInputImageDimensionAndPixelType(unsigned int& dim, \
-        std::string& pixeltype,unsigned int& components)
+    std::string& pixeltype,unsigned int& components)
 {
-  if (mReadOnDisk && mInputFilenames.size()) {
+  if (m_ReadOnDisk && m_InputFilenames.size()) {
     int comp_temp,dim_temp; //clitkCommonImage takes ints
-    ReadImageDimensionAndPixelType(mInputFilenames[0], dim_temp, pixeltype,comp_temp);
-    components=comp_temp; dim=dim_temp;
-  }
-  else {
-    if (mInputVVImages.size()) {
-      pixeltype=mInputVVImages[0]->GetScalarTypeAsString();
-      dim=mInputVVImages[0]->GetNumberOfDimensions();
-      components=mInputVVImages[0]->GetNumberOfScalarComponents();
+    ReadImageDimensionAndPixelType(m_InputFilenames[0], dim_temp, pixeltype,comp_temp);
+    components=comp_temp;
+    dim=dim_temp;
+  } else {
+    if (m_InputVVImages.size()) {
+      pixeltype = m_InputVVImages[0]->GetScalarTypeAsITKString();
+      dim = m_InputVVImages[0]->GetNumberOfDimensions();
+      components = m_InputVVImages[0]->GetNumberOfScalarComponents();
+    } else {
+      clitkExceptionMacro("No input given in this ImageToImageGenericFilter.");
+      assert(false); //No input image, shouldn't happen
     }
-    else
-    assert(false); //No input image, shouldn't happen
   }
-  if (mIOVerbose) {
-    std::cout << "Input is " << mDim << "D " << mPixelTypeName << "." << std::endl;
+  if (m_IOVerbose) {
+    std::cout << "Input is " << m_Dim << "D " << m_PixelTypeName << "." << std::endl;
   }
 }
 //--------------------------------------------------------------------
@@ -136,8 +173,8 @@ void clitk::ImageToImageGenericFilterBase::GetInputImageDimensionAndPixelType(un
 //--------------------------------------------------------------------
 vvImage::Pointer clitk::ImageToImageGenericFilterBase::GetOutputVVImage ()
 {
-    assert(mOutputVVImages.size());
-    return mOutputVVImages[0];
+  assert(m_OutputVVImages.size());
+  return m_OutputVVImages[0];
 }
 //--------------------------------------------------------------------
 
@@ -145,7 +182,7 @@ vvImage::Pointer clitk::ImageToImageGenericFilterBase::GetOutputVVImage ()
 //--------------------------------------------------------------------
 std::vector<vvImage::Pointer> clitk::ImageToImageGenericFilterBase::GetOutputVVImages()
 {
-    return mOutputVVImages;
+  return m_OutputVVImages;
 }
 //--------------------------------------------------------------------
 
@@ -153,8 +190,13 @@ std::vector<vvImage::Pointer> clitk::ImageToImageGenericFilterBase::GetOutputVVI
 //--------------------------------------------------------------------
 void clitk::ImageToImageGenericFilterBase::SetInputVVImage (vvImage::Pointer input)
 {
-    mInputVVImages.clear();
-    mInputVVImages.push_back(input);
+  m_InputVVImages.clear();
+  m_InputVVImages.push_back(input);
+  // in this case, assume by default that we do not want to write/read
+  // on disk (not a command line tool, but rather a vvTool. Can be
+  // changed with EnableReadOnDisk and EnableWriteOnDisk)
+  EnableReadOnDisk(false);
+  EnableWriteOnDisk(false);
 }
 //--------------------------------------------------------------------
 
@@ -162,7 +204,7 @@ void clitk::ImageToImageGenericFilterBase::SetInputVVImage (vvImage::Pointer inp
 //--------------------------------------------------------------------
 void clitk::ImageToImageGenericFilterBase::AddInputVVImage (vvImage::Pointer input)
 {
-    mInputVVImages.push_back(input);
+  m_InputVVImages.push_back(input);
 }
 //--------------------------------------------------------------------
 
@@ -170,13 +212,19 @@ void clitk::ImageToImageGenericFilterBase::AddInputVVImage (vvImage::Pointer inp
 //--------------------------------------------------------------------
 void clitk::ImageToImageGenericFilterBase::SetInputVVImages (std::vector<vvImage::Pointer> input)
 {
-    mInputVVImages=input;
+  m_InputVVImages=input;
+  // in this case, assume by default that we do not want to write/read
+  // on disk (not a command line tool, but rather a vvTool. Can be
+  // changed with EnableReadOnDisk and EnableWriteOnDisk)
+  EnableReadOnDisk(false);
+  EnableWriteOnDisk(false);
 }
 //--------------------------------------------------------------------
 
 
 //--------------------------------------------------------------------
-void clitk::ImageToImageGenericFilterBase::PrintAvailableImageTypes() {
+void clitk::ImageToImageGenericFilterBase::PrintAvailableImageTypes()
+{
   std::cout << GetAvailableImageTypes();
 }
 //--------------------------------------------------------------------
@@ -184,19 +232,23 @@ void clitk::ImageToImageGenericFilterBase::PrintAvailableImageTypes() {
 
 
 //--------------------------------------------------------------------
-void clitk::ImageToImageGenericFilterBase::ImageTypeError() {
-  std::cerr << "**Error** The filter <" << mFilterName << "> is not available for " 
-            << mDim << "D images with pixel=" 
-            << mPixelTypeName << " and "
-            << mNbOfComponents << " component." << std::endl;
-  std::cerr << GetAvailableImageTypes();
-  exit(0);
+void clitk::ImageToImageGenericFilterBase::ImageTypeError()
+{
+  std::ostringstream os;
+  os << "**Error** The filter <" << m_FilterName << "> is not available for "
+     << m_Dim << "D images with pixel="
+     << m_PixelTypeName << " and "
+     << m_NbOfComponents << " component." << std::endl;
+  os << GetAvailableImageTypes();
+  clitkExceptionMacro(os.str());
+  //  exit(0);
 }
 //--------------------------------------------------------------------
 
 
 //--------------------------------------------------------------------
-void clitk::ImageToImageGenericFilterBase::SetImageTypeError() {
+void clitk::ImageToImageGenericFilterBase::SetImageTypeError()
+{
   std::cerr << "TODO ! " << std::endl;
   exit(0);
 }
@@ -204,22 +256,25 @@ void clitk::ImageToImageGenericFilterBase::SetImageTypeError() {
 
 
 //--------------------------------------------------------------------
-const std::string & clitk::ImageToImageGenericFilterBase::GetFilterName() { 
-  return mFilterName; 
+const std::string & clitk::ImageToImageGenericFilterBase::GetFilterName()
+{
+  return m_FilterName;
 }
 //--------------------------------------------------------------------
 
 
 //--------------------------------------------------------------------
-void clitk::ImageToImageGenericFilterBase::SetFilterName(std::string & n) { 
-  mFilterName = n; 
+void clitk::ImageToImageGenericFilterBase::SetFilterName(std::string & n)
+{
+  m_FilterName = n;
 }
 //--------------------------------------------------------------------
 
 
 //--------------------------------------------------------------------
-void clitk::ImageToImageGenericFilterBase::SetIOVerbose(bool b) { 
-  mIOVerbose = b; 
+void clitk::ImageToImageGenericFilterBase::SetIOVerbose(bool b)
+{
+  m_IOVerbose = b;
 }
 //--------------------------------------------------------------------
 
@@ -229,11 +284,11 @@ void clitk::ImageToImageGenericFilterBase::SetNextOutput<itk::Image<PixelType, D
   template \
    itk::Image<PixelType, Dim>::Pointer clitk::ImageToImageGenericFilterBase::GetInput<itk::Image<PixelType, Dim> >(unsigned int n);
 
-#define DEF_SetNextOutput_And_GetInput_WithCompo(Compo, Dim)   \
+#define DEF_SetNextOutput_And_GetInput_WithCompo(PixelType, Compo, Dim)   \
   template \
-  void clitk::ImageToImageGenericFilterBase::SetNextOutput<itk::Image<itk::Vector<float, Compo>, Dim> >(itk::Image<itk::Vector<float, Compo>,Dim>::Pointer output); \
+  void clitk::ImageToImageGenericFilterBase::SetNextOutput<itk::Image<itk::Vector<PixelType, Compo>, Dim> >(itk::Image<itk::Vector<PixelType, Compo>,Dim>::Pointer output); \
   template \
-  itk::Image<itk::Vector<float,Compo>, Dim>::Pointer clitk::ImageToImageGenericFilterBase::GetInput<itk::Image<itk::Vector<float, Compo>, Dim> >(unsigned int n);
+  itk::Image<itk::Vector<PixelType,Compo>, Dim>::Pointer clitk::ImageToImageGenericFilterBase::GetInput<itk::Image<itk::Vector<PixelType, Compo>, Dim> >(unsigned int n);
 
 DEF_SetNextOutput_And_GetInput(char, 2);
 DEF_SetNextOutput_And_GetInput(unsigned char, 2);
@@ -251,15 +306,77 @@ DEF_SetNextOutput_And_GetInput(int, 3);
 DEF_SetNextOutput_And_GetInput(float, 3);
 DEF_SetNextOutput_And_GetInput(double, 3);
 
-DEF_SetNextOutput_And_GetInput_WithCompo(2, 2);
-DEF_SetNextOutput_And_GetInput_WithCompo(2, 3);
-DEF_SetNextOutput_And_GetInput_WithCompo(2, 4);
-DEF_SetNextOutput_And_GetInput_WithCompo(3, 2);
-DEF_SetNextOutput_And_GetInput_WithCompo(3, 3);
-DEF_SetNextOutput_And_GetInput_WithCompo(3, 4);
-DEF_SetNextOutput_And_GetInput_WithCompo(4, 2);
-DEF_SetNextOutput_And_GetInput_WithCompo(4, 3);
-DEF_SetNextOutput_And_GetInput_WithCompo(4, 4);
+/*
+DEF_SetNextOutput_And_GetInput_WithCompo(unsigned char, 2, 2);
+DEF_SetNextOutput_And_GetInput_WithCompo(unsigned char, 2, 3);
+DEF_SetNextOutput_And_GetInput_WithCompo(unsigned char, 2, 4);
+DEF_SetNextOutput_And_GetInput_WithCompo(unsigned char, 3, 2);
+DEF_SetNextOutput_And_GetInput_WithCompo(unsigned char, 3, 3);
+DEF_SetNextOutput_And_GetInput_WithCompo(unsigned char, 3, 4);
+DEF_SetNextOutput_And_GetInput_WithCompo(unsigned char, 4, 2);
+DEF_SetNextOutput_And_GetInput_WithCompo(unsigned char, 4, 3);
+DEF_SetNextOutput_And_GetInput_WithCompo(unsigned char, 4, 4);
+
+DEF_SetNextOutput_And_GetInput_WithCompo(char, 2, 2);
+DEF_SetNextOutput_And_GetInput_WithCompo(char, 2, 3);
+DEF_SetNextOutput_And_GetInput_WithCompo(char, 2, 4);
+DEF_SetNextOutput_And_GetInput_WithCompo(char, 3, 2);
+DEF_SetNextOutput_And_GetInput_WithCompo(char, 3, 3);
+DEF_SetNextOutput_And_GetInput_WithCompo(char, 3, 4);
+DEF_SetNextOutput_And_GetInput_WithCompo(char, 4, 2);
+DEF_SetNextOutput_And_GetInput_WithCompo(char, 4, 3);
+DEF_SetNextOutput_And_GetInput_WithCompo(char, 4, 4);
+
+DEF_SetNextOutput_And_GetInput_WithCompo(unsigned short, 2, 2);
+DEF_SetNextOutput_And_GetInput_WithCompo(unsigned short, 2, 3);
+DEF_SetNextOutput_And_GetInput_WithCompo(unsigned short, 2, 4);
+DEF_SetNextOutput_And_GetInput_WithCompo(unsigned short, 3, 2);
+DEF_SetNextOutput_And_GetInput_WithCompo(unsigned short, 3, 3);
+DEF_SetNextOutput_And_GetInput_WithCompo(unsigned short, 3, 4);
+DEF_SetNextOutput_And_GetInput_WithCompo(unsigned short, 4, 2);
+DEF_SetNextOutput_And_GetInput_WithCompo(unsigned short, 4, 3);
+DEF_SetNextOutput_And_GetInput_WithCompo(unsigned short, 4, 4);
+
+DEF_SetNextOutput_And_GetInput_WithCompo(short, 2, 2);
+DEF_SetNextOutput_And_GetInput_WithCompo(short, 2, 3);
+DEF_SetNextOutput_And_GetInput_WithCompo(short, 2, 4);
+DEF_SetNextOutput_And_GetInput_WithCompo(short, 3, 2);
+DEF_SetNextOutput_And_GetInput_WithCompo(short, 3, 3);
+DEF_SetNextOutput_And_GetInput_WithCompo(short, 3, 4);
+DEF_SetNextOutput_And_GetInput_WithCompo(short, 4, 2);
+DEF_SetNextOutput_And_GetInput_WithCompo(short, 4, 3);
+DEF_SetNextOutput_And_GetInput_WithCompo(short, 4, 4);
+
+DEF_SetNextOutput_And_GetInput_WithCompo(int, 2, 2);
+DEF_SetNextOutput_And_GetInput_WithCompo(int, 2, 3);
+DEF_SetNextOutput_And_GetInput_WithCompo(int, 2, 4);
+DEF_SetNextOutput_And_GetInput_WithCompo(int, 3, 2);
+DEF_SetNextOutput_And_GetInput_WithCompo(int, 3, 3);
+DEF_SetNextOutput_And_GetInput_WithCompo(int, 3, 4);
+DEF_SetNextOutput_And_GetInput_WithCompo(int, 4, 2);
+DEF_SetNextOutput_And_GetInput_WithCompo(int, 4, 3);
+DEF_SetNextOutput_And_GetInput_WithCompo(int, 4, 4);
+*/
+
+DEF_SetNextOutput_And_GetInput_WithCompo(float, 2, 2);
+DEF_SetNextOutput_And_GetInput_WithCompo(float, 2, 3);
+DEF_SetNextOutput_And_GetInput_WithCompo(float, 2, 4);
+DEF_SetNextOutput_And_GetInput_WithCompo(float, 3, 2);
+DEF_SetNextOutput_And_GetInput_WithCompo(float, 3, 3);
+DEF_SetNextOutput_And_GetInput_WithCompo(float, 3, 4);
+DEF_SetNextOutput_And_GetInput_WithCompo(float, 4, 2);
+DEF_SetNextOutput_And_GetInput_WithCompo(float, 4, 3);
+DEF_SetNextOutput_And_GetInput_WithCompo(float, 4, 4);
+
+DEF_SetNextOutput_And_GetInput_WithCompo(double, 2, 2);
+DEF_SetNextOutput_And_GetInput_WithCompo(double, 2, 3);
+DEF_SetNextOutput_And_GetInput_WithCompo(double, 2, 4);
+DEF_SetNextOutput_And_GetInput_WithCompo(double, 3, 2);
+DEF_SetNextOutput_And_GetInput_WithCompo(double, 3, 3);
+DEF_SetNextOutput_And_GetInput_WithCompo(double, 3, 4);
+DEF_SetNextOutput_And_GetInput_WithCompo(double, 4, 2);
+DEF_SetNextOutput_And_GetInput_WithCompo(double, 4, 3);
+DEF_SetNextOutput_And_GetInput_WithCompo(double, 4, 4);
 
 DEF_SetNextOutput_And_GetInput(char, 4);
 DEF_SetNextOutput_And_GetInput(unsigned char, 4);
@@ -271,36 +388,57 @@ DEF_SetNextOutput_And_GetInput(double, 4);
 
 
 //--------------------------------------------------------------------
-template<class ImageType> 
-void clitk::ImageToImageGenericFilterBase::SetNextOutput(typename ImageType::Pointer output) {
-  if (mOutputFilenames.size())
-    {
-      clitk::writeImage<ImageType>(output, mOutputFilenames.front(), mIOVerbose);
-      mOutputFilenames.pop_front();
-    }
-  if (mInputVVImages.size()) //We assume that if a vv image is set as input, we want one as the output
-    mOutputVVImages.push_back(vvImageFromITK<ImageType::ImageDimension,typename ImageType::PixelType>(output));
+template<class ImageType>
+void clitk::ImageToImageGenericFilterBase::SetNextOutput(typename ImageType::Pointer output)
+{
+  if (m_WriteOnDisk && m_OutputFilenames.size()) {
+    clitk::writeImage<ImageType>(output, m_OutputFilenames.front(), m_IOVerbose, m_WriteCompression);
+    m_OutputFilenames.pop_front();
+  }
+  if (m_InputVVImages.size()) //We assume that if a vv image is set as input, we want one as the output
+    m_OutputVVImages.push_back(vvImageFromITK<ImageType::ImageDimension,typename ImageType::PixelType>(output));
 }
 //--------------------------------------------------------------------
 
 
 //--------------------------------------------------------------------
-template<class ImageType> 
-typename ImageType::Pointer clitk::ImageToImageGenericFilterBase::GetInput(unsigned int n) {
-  if (mReadOnDisk && mInputFilenames.size() > n) {
-    return clitk::readImage<ImageType>(mInputFilenames[n], mIOVerbose);
+template<class ImageType>
+typename ImageType::Pointer clitk::ImageToImageGenericFilterBase::GetInput(unsigned int n)
+{
+  if (m_ReadOnDisk && m_InputFilenames.size() > n) {
+    return clitk::readImage<ImageType>(m_InputFilenames[n], m_IOVerbose);
+  } else {
+    if (m_InputVVImages.size() > n)
+      return typename ImageType::Pointer(const_cast<ImageType*>(vvImageToITK<ImageType>(m_InputVVImages[n]).GetPointer()));
+    else {
+      assert(false); //No input, this shouldn't happen
+      return typename ImageType::Pointer((ImageType*)ITK_NULLPTR);
+    }
   }
-  else {
-    if (mInputVVImages.size() > n)
-      return typename ImageType::Pointer(const_cast<ImageType*>(vvImageToITK<ImageType>(mInputVVImages[n]).GetPointer()));
-    else
-      {
-        assert(false); //No input, this shouldn't happen
-        return typename ImageType::Pointer(NULL);
-      }
+}
+//--------------------------------------------------------------------
+
+
+//--------------------------------------------------------------------
+// void clitk::ImageToImageGenericFilterBase::MustStop()
+// {
+//   if (m_FilterBase != NULL) {
+//     m_FilterBase->SetMustStop(true);
+//   }
+// }
+//--------------------------------------------------------------------
+
+
+//--------------------------------------------------------------------
+void clitk::ImageToImageGenericFilterBase::DeleteLastOutputImage()
+{
+  if (m_OutputVVImages.size()>1) {
+   m_OutputVVImages.pop_back();
   }
 }
 //--------------------------------------------------------------------
 
 
+//--------------------------------------------------------------------
+