X-Git-Url: https://git.creatis.insa-lyon.fr/pubgit/?a=blobdiff_plain;f=common%2FclitkImageCommon.txx;h=9d8d6e131b62c47bdedd20b599a0b77f8ba56f46;hb=762d3a97e3b271e5f76536e115a945cb5c950741;hp=45e8c2e90ecac46fafa0bcf5f0d6bfbfda03296a;hpb=931a42358442f4ee4f314613c991c838d4b4e3b7;p=clitk.git

diff --git a/common/clitkImageCommon.txx b/common/clitkImageCommon.txx
index 45e8c2e..9d8d6e1 100644
--- a/common/clitkImageCommon.txx
+++ b/common/clitkImageCommon.txx
@@ -1,20 +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;
@@ -31,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;
 }
@@ -65,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 readImage(const std::string & filename, const bool verbose) {
+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)
+{
   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);
@@ -103,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();
@@ -113,20 +175,21 @@ 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=false) {
+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());
@@ -134,10 +197,9 @@ void writeImage(const typename ImageType::Pointer image, const std::string & fil
   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);
@@ -145,9 +207,11 @@ void writeImage(const typename ImageType::Pointer image, const std::string & fil
 }
 //--------------------------------------------------------------------
 
+
 //--------------------------------------------------------------------
 template<class ImageType>
-void writeImage(const ImageType* image, const std::string & filename, const bool verbose=false) {
+void writeImage(const ImageType* image, const std::string & filename, const bool verbose)
+{
   typedef itk::ImageFileWriter<ImageType> WriterType;
   typename WriterType::Pointer writer = WriterType::New();
   writer->SetFileName(filename.c_str());
@@ -155,10 +219,9 @@ void writeImage(const ImageType* image, const std::string & filename, const bool
   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);
@@ -176,8 +239,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;
@@ -191,8 +254,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;
@@ -202,14 +265,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()) {
@@ -220,21 +283,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
@@ -255,5 +320,60 @@ void ComputeWeightsOfEachClasses(const typename InputImageType::Pointer & input,
 }
 //--------------------------------------------------------------------
 
+
+//--------------------------------------------------------------------
+template<class ImageType1, class ImageType2>
+bool HaveSameSizeAndSpacing(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;
+    if (A->GetLargestPossibleRegion().GetSize()[i] != B->GetLargestPossibleRegion().GetSize()[i]) return false;
+  }
+  return true;
+}
+//--------------------------------------------------------------------
+
+//--------------------------------------------------------------------
+template<class ImageType1, class ImageType2>
+bool HaveSameSizeAndSpacing(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;
+    if (A->GetLargestPossibleRegion().GetSize()[i] != B->GetLargestPossibleRegion().GetSize()[i]) return false;
+  }
+  return true;
+}
+//--------------------------------------------------------------------
+
+//--------------------------------------------------------------------
+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;
+}
+//--------------------------------------------------------------------
+
 #endif /* end #define CLITKIMAGECOMMON_TXX */