X-Git-Url: https://git.creatis.insa-lyon.fr/pubgit/?a=blobdiff_plain;f=common%2FclitkImageCommon.txx;h=a07c66f0459eca0743c41c460937e48a484c75a0;hb=refs%2Fheads%2FextentSimon;hp=0f061942246f673e48b593e92a66467da1a15092;hpb=0083c3fb2c66812489631c7551709d121de51625;p=clitk.git

diff --git a/common/clitkImageCommon.txx b/common/clitkImageCommon.txx
index 0f06194..a07c66f 100644
--- a/common/clitkImageCommon.txx
+++ b/common/clitkImageCommon.txx
@@ -1,19 +1,29 @@
+/*=========================================================================
+  Program:   vv                     http://www.creatis.insa-lyon.fr/rio/vv
+
+  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
+
+  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.
+
+  It is distributed under dual licence
+
+  - BSD        See included LICENSE.txt file
+  - CeCILL-B   http://www.cecill.info/licences/Licence_CeCILL-B_V1-en.html
+===========================================================================**/
 #ifndef CLITKIMAGECOMMON_TXX
 #define CLITKIMAGECOMMON_TXX
-/**
-   -------------------------------------------------
-   * @file   clitkImageCommon.txx
-   * @author David Sarrut <david.sarrut@creatis.insa-lyon.fr>
-   * @date   07 Sep 2007 11:34:19
-   * 
-   * @brief  
-   * 
-   * 
-   -------------------------------------------------*/
+
 
 //--------------------------------------------------------------------
 template<class PixelType>
-typename itk::Image<PixelType,1>::Pointer NewImage1D(int vsize, double vspacing) {
+typename itk::Image<PixelType,1>::Pointer
+NewImage1D(int vsize, double vspacing)
+{
   typedef itk::Image<PixelType,1> ImageType;
   typename ImageType::Pointer g = ImageType::New();
   typename ImageType::SizeType size;
@@ -30,33 +40,44 @@ typename itk::Image<PixelType,1>::Pointer NewImage1D(int vsize, double vspacing)
 
 //--------------------------------------------------------------------
 template<class PixelType>
-typename itk::Image<PixelType,2>::Pointer NewImage2D(int sx, int sy, double dx, double dy) {
+typename itk::Image<PixelType,2>::Pointer
+NewImage2D(int sx, int sy, double dx, double dy)
+{
   typedef itk::Image<PixelType,2> ImageType;
   typename ImageType::Pointer g = ImageType::New();
   typename ImageType::SizeType size;
-  size[0] = sx; size[1] = sy;
+  size[0] = sx;
+  size[1] = sy;
   typename ImageType::RegionType region;
   region.SetSize(size);
   g->SetRegions(region);
   typename ImageType::SpacingType spacing;
-  spacing[0] = dx; spacing[1] = dy;
+  spacing[0] = dx;
+  spacing[1] = dy;
   g->SetSpacing(spacing);
   return g;
 }
 //--------------------------------------------------------------------
 
+
 //--------------------------------------------------------------------
 template<class PixelType>
-typename itk::Image<PixelType,3>::Pointer NewImage3D(int sx, int sy, int sz, double dx, double dy, double dz) {
+typename itk::Image<PixelType,3>::Pointer
+NewImage3D(int sx, int sy, int sz, double dx, double dy, double dz)
+{
   typedef itk::Image<PixelType,3> ImageType;
   typename ImageType::Pointer g = ImageType::New();
   typename ImageType::SizeType size;
-  size[0] = sx; size[1] = sy; size[2] = sz;
+  size[0] = sx;
+  size[1] = sy;
+  size[2] = sz;
   typename ImageType::RegionType region;
   region.SetSize(size);
   g->SetRegions(region);
   typename ImageType::SpacingType spacing;
-  spacing[0] = dx; spacing[1] = dy; spacing[2] = dz;
+  spacing[0] = dx;
+  spacing[1] = dy;
+  spacing[2] = dz;
   g->SetSpacing(spacing);
   return g;
 }
@@ -64,34 +85,75 @@ typename itk::Image<PixelType,3>::Pointer NewImage3D(int sx, int sy, int sz, dou
 
 //--------------------------------------------------------------------
 template<class PixelType>
-typename itk::Image<PixelType,4>::Pointer NewImage4D(int sx, int sy, int sz, int st, double dx, double dy, double dz, double dt) {
+typename itk::Image<PixelType,4>::Pointer NewImage4D(int sx, int sy, int sz, int st, double dx, double dy, double dz, double dt)
+{
   typedef itk::Image<PixelType,3> ImageType;
   typename ImageType::Pointer g = ImageType::New();
   typename ImageType::SizeType size;
-  size[0] = sx; size[1] = sy; size[2] = sz; size[3] = st;
+  size[0] = sx;
+  size[1] = sy;
+  size[2] = sz;
+  size[3] = st;
   typename ImageType::RegionType region;
   region.SetSize(size);
   g->SetRegions(region);
   typename ImageType::SpacingType spacing;
-  spacing[0] = dx; spacing[1] = dy; spacing[2] = dz; spacing[3] = dt;
+  spacing[0] = dx;
+  spacing[1] = dy;
+  spacing[2] = dz;
+  spacing[3] = dt;
   g->SetSpacing(spacing);
   return g;
 }
 //--------------------------------------------------------------------
 
+
+//--------------------------------------------------------------------
+template<class ImageType>
+typename ImageType::Pointer NewImageLike(const typename ImageType::Pointer input, bool allocate)
+{
+  typename ImageType::Pointer output = ImageType::New();
+  output->CopyInformation(input);
+  output->SetRegions(input->GetLargestPossibleRegion());
+  if (allocate) output->Allocate();
+  return output;
+}
+//--------------------------------------------------------------------
+
+
+//--------------------------------------------------------------------
+template<class ImageType>
+void CopyValues(const typename ImageType::Pointer input,
+                typename ImageType::Pointer output)
+{
+  typedef itk::ImageRegionConstIterator<ImageType> ConstIteratorType;
+  ConstIteratorType pi(input,input->GetLargestPossibleRegion());
+  pi.GoToBegin();
+  typedef itk::ImageRegionIterator<ImageType> IteratorType;
+  IteratorType po(output,input->GetLargestPossibleRegion());
+  po.GoToBegin();
+  while (!pi.IsAtEnd()) {
+    po.Set(pi.Get());
+    ++pi;
+    ++po;
+  }
+}
+//--------------------------------------------------------------------
+
+
 //--------------------------------------------------------------------
 template<class ImageType>
-typename ImageType::Pointer readImage(const std::string & filename, const bool verbose) {
+typename ImageType::Pointer readImage(const std::string & filename, const bool verbose)
+{
   typedef itk::ImageFileReader<ImageType> ReaderType;
   typename ReaderType::Pointer reader = ReaderType::New();
   reader->SetFileName(filename.c_str());
   if (verbose) {
     std::cout << "Reading [" << filename << "] ... " << std::endl;
   }
-  try { 
-    reader->Update(); 
-  }
-  catch(itk::ExceptionObject & err) {
+  try {
+    reader->Update();
+  } catch(itk::ExceptionObject & err) {
     std::cerr << "Exception while reading image [" << filename << "]" << std::endl;
     std::cerr << err << std::endl;
     exit(0);
@@ -102,8 +164,9 @@ typename ImageType::Pointer readImage(const std::string & filename, const bool v
 
 //--------------------------------------------------------------------
 template<typename ImageType>
-typename ImageType::Pointer readImage(const std::vector<std::string> & filenames, 
-				      const bool verbose) {
+typename ImageType::Pointer readImage(const std::vector<std::string> & filenames,
+                                      const bool verbose)
+{
   if (filenames.size() == 1) return readImage<ImageType>(filenames[0], verbose);
   typedef itk::ImageSeriesReader<ImageType> ReaderType;
   typename ReaderType::Pointer reader = ReaderType::New();
@@ -112,52 +175,41 @@ typename ImageType::Pointer readImage(const std::vector<std::string> & filenames
     std::cout << "Reading " << filenames[0] << " and others ..." << std::endl;
   }
   try {
-    reader->Update(); 
-  }
-  catch( itk::ExceptionObject & err ) {
+    reader->Update();
+  } catch( itk::ExceptionObject & err ) {
     std::cerr << "Error while reading " << filenames[0]
-	      << " or other files ..." << err << std::endl;
+              << " or other files ..." << err << std::endl;
     exit(0);
   }
   return reader->GetOutput();
 }
 //--------------------------------------------------------------------
 
+
 //--------------------------------------------------------------------
 template<class ImageType>
-void writeImage(const typename ImageType::Pointer image, const std::string & filename, const bool verbose) {
-  typedef itk::ImageFileWriter<ImageType> WriterType;
-  typename WriterType::Pointer writer = WriterType::New();
-  writer->SetFileName(filename.c_str());
-  writer->SetInput(image);
-  if (verbose) {
-    std::cout << "Writing [" << filename << "] ... " << std::endl;
-  }
-  try { 
-    writer->Update(); 
-  }
-  catch( itk::ExceptionObject & err ) {
-    std::cerr << "Exception while writing image [" << filename << "]" << std::endl;
-    std::cerr << err << std::endl;
-    exit(-1);
-  }
+void writeImage(const typename ImageType::Pointer image, const std::string & filename, const bool verbose, const bool compression)
+{
+  return writeImage(image.GetPointer(), filename, verbose, compression);
 }
 //--------------------------------------------------------------------
 
+
 //--------------------------------------------------------------------
 template<class ImageType>
-void writeImage(const ImageType* image, const std::string & filename, const bool verbose) {
+void writeImage(const ImageType* image, const std::string & filename, const bool verbose, const bool compression)
+{
   typedef itk::ImageFileWriter<ImageType> WriterType;
   typename WriterType::Pointer writer = WriterType::New();
   writer->SetFileName(filename.c_str());
   writer->SetInput(image);
+  writer->SetUseCompression(compression);
   if (verbose) {
     std::cout << "Writing [" << filename << "] ... " << std::endl;
   }
-  try { 
-    writer->Update(); 
-  }
-  catch( itk::ExceptionObject & err ) {
+  try {
+    writer->Update();
+  } catch( itk::ExceptionObject & err ) {
     std::cerr << "Exception while writing image [" << filename << "]" << std::endl;
     std::cerr << err << std::endl;
     exit(-1);
@@ -175,8 +227,8 @@ void writeImage(const ImageType* image, const std::string & filename, const bool
 //   if (verbose) {
 //     std::cout << "Writing [" << filename << "] ... " << std::endl;
 //   }
-//   try { 
-//     writer->Update(); 
+//   try {
+//     writer->Update();
 //   }
 //   catch( itk::ExceptionObject & err ) {
 //     std::cerr << "Exception while writing image [" << filename << "]" << std::endl;
@@ -190,8 +242,8 @@ void writeImage(const ImageType* image, const std::string & filename, const bool
 //--------------------------------------------------------------------
 // Compute the number of different intensities in an image
 template<class ImageType>
-int ComputeHowManyDifferentIntensity(const typename ImageType::Pointer & image, 
-				     std::vector<typename ImageType::PixelType> & l)
+int ComputeHowManyDifferentIntensity(const typename ImageType::Pointer & image,
+                                     std::vector<typename ImageType::PixelType> & l)
 {
   //std::set<typename ImageType::PixelType> listOfIntensities;
   std::map<typename ImageType::PixelType, bool> listOfIntensities;
@@ -201,14 +253,14 @@ int ComputeHowManyDifferentIntensity(const typename ImageType::Pointer & image,
   pi.Begin();
   while (!pi.IsAtEnd()) {
     if (!listOfIntensities[pi.Get()]) listOfIntensities[pi.Get()] = true;
-    // if (std::find(listOfIntensities.begin(), 
-    // 				  listOfIntensities.end(), 
+    // if (std::find(listOfIntensities.begin(),
+    // 				  listOfIntensities.end(),
     // 				  pi.Get()) == listOfIntensities.end()) {
     // 	  listOfIntensities.insert(pi.Get());
     // 	}
     ++pi;
   }
-  
+
   //typename std::set<typename ImageType::PixelType>::const_iterator ppi = listOfIntensities.begin();
   typename std::map<typename ImageType::PixelType, bool>::const_iterator ppi = listOfIntensities.begin();
   while (ppi != listOfIntensities.end()) {
@@ -219,21 +271,23 @@ int ComputeHowManyDifferentIntensity(const typename ImageType::Pointer & image,
   return listOfIntensities.size();
 }
 //--------------------------------------------------------------------
-  
+
+
 //--------------------------------------------------------------------
 template<class InputImageType, class MaskImageType>
-void ComputeWeightsOfEachClasses(const typename InputImageType::Pointer & input, 
-				 const typename MaskImageType::Pointer & mask,
-				 const std::vector<typename MaskImageType::PixelType> & listOfIntensities, 
-				 std::map<typename MaskImageType::PixelType, 
-				 std::map<typename InputImageType::PixelType, double> > & mapOfLabelsAndWeights) {
+void ComputeWeightsOfEachClasses(const typename InputImageType::Pointer & input,
+                                 const typename MaskImageType::Pointer & mask,
+                                 const std::vector<typename MaskImageType::PixelType> & listOfIntensities,
+                                 std::map<typename MaskImageType::PixelType,
+                                 std::map<typename InputImageType::PixelType, double> > & mapOfLabelsAndWeights)
+{
   // Check size
   if (input->GetLargestPossibleRegion() != mask->GetLargestPossibleRegion()) {
     itkGenericExceptionMacro(<< "Input and mask images have not the same size"
-			     << std::endl
-			     << "Input = " << input->GetLargestPossibleRegion()
-			     << std::endl
-			     << "Mask = " << mask->GetLargestPossibleRegion());
+                             << std::endl
+                             << "Input = " << input->GetLargestPossibleRegion()
+                             << std::endl
+                             << "Mask = " << mask->GetLargestPossibleRegion());
   }
 
   // reset weights list
@@ -254,5 +308,78 @@ void ComputeWeightsOfEachClasses(const typename InputImageType::Pointer & input,
 }
 //--------------------------------------------------------------------
 
+
+//--------------------------------------------------------------------
+template<class ImageType1, class ImageType2>
+bool HaveSameSpacing(typename ImageType1::ConstPointer A,
+                     typename ImageType2::ConstPointer B)
+{
+  if (A->GetImageDimension() != B->GetImageDimension()) return false;
+  for(unsigned int i=0; i<A->GetImageDimension(); i++) {
+    if (A->GetSpacing()[i] != B->GetSpacing()[i]) return false;
+  }
+  return true;
+}
+//--------------------------------------------------------------------
+
+//--------------------------------------------------------------------
+template<class ImageType1, class ImageType2>
+bool HaveSameSpacing(typename ImageType1::Pointer A,
+                     typename ImageType2::Pointer B)
+{
+  if (A->GetImageDimension() != B->GetImageDimension()) return false;
+  for(unsigned int i=0; i<A->GetImageDimension(); i++) {
+    if (A->GetSpacing()[i] != B->GetSpacing()[i]) return false;
+  }
+  return true;
+}
+//--------------------------------------------------------------------
+
+//--------------------------------------------------------------------
+template<class ImageType1, class ImageType2>
+bool HaveSameSize(typename ImageType1::ConstPointer A,
+                  typename ImageType2::ConstPointer B)
+{
+  if (A->GetImageDimension() != B->GetImageDimension()) return false;
+  for(unsigned int i=0; i<A->GetImageDimension(); i++) {
+    if (A->GetLargestPossibleRegion().GetSize()[i] != B->GetLargestPossibleRegion().GetSize()[i]) return false;
+  }
+  return true;
+}
+//--------------------------------------------------------------------
+
+//--------------------------------------------------------------------
+template<class ImageType1, class ImageType2>
+bool HaveSameSize(typename ImageType1::Pointer A,
+                  typename ImageType2::Pointer B)
+{
+  if (A->GetImageDimension() != B->GetImageDimension()) return false;
+  for(unsigned int i=0; i<A->GetImageDimension(); i++) {
+    if (A->GetLargestPossibleRegion().GetSize()[i] != B->GetLargestPossibleRegion().GetSize()[i]) return false;
+  }
+  return true;
+}
+//--------------------------------------------------------------------
+
+//--------------------------------------------------------------------
+template<class ImageType1, class ImageType2>
+bool HaveSameSizeAndSpacing(typename ImageType1::ConstPointer A,
+                            typename ImageType2::ConstPointer B)
+{
+  return ( HaveSameSize<ImageType1, ImageType2>(A, B) &&
+           HaveSameSpacing<ImageType1, ImageType2>(A, B) );
+}
+//--------------------------------------------------------------------
+
+//--------------------------------------------------------------------
+template<class ImageType1, class ImageType2>
+bool HaveSameSizeAndSpacing(typename ImageType1::Pointer A,
+                            typename ImageType2::Pointer B)
+{
+  return ( HaveSameSize<ImageType1, ImageType2>(A, B) &&
+           HaveSameSpacing<ImageType1, ImageType2>(A, B) );
+}
+//--------------------------------------------------------------------
+
 #endif /* end #define CLITKIMAGECOMMON_TXX */