itk/clitkSegmentationUtils.txx

   1 /*=========================================================================
   2   Program:   vv                     http://www.creatis.insa-lyon.fr/rio/vv
   3
   4   Authors belong to:
   5   - University of LYON              http://www.universite-lyon.fr/
   6   - Léon Bérard cancer center       http://oncora1.lyon.fnclcc.fr
   7   - CREATIS CNRS laboratory         http://www.creatis.insa-lyon.fr
   8
   9   This software is distributed WITHOUT ANY WARRANTY; without even
  10   the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
  11   PURPOSE.  See the copyright notices for more information.
  12
  13   It is distributed under dual licence
  14
  15   - BSD        See included LICENSE.txt file
  16   - CeCILL-B   http://www.cecill.info/licences/Licence_CeCILL-B_V1-en.html
  17   ======================================================================-====*/
  18
  19 // clitk
  20 #include "clitkSetBackgroundImageFilter.h"
  21
  22 // itk
  23 #include <itkConnectedComponentImageFilter.h>
  24 #include <itkRelabelComponentImageFilter.h>
  25 #include <itkBinaryThresholdImageFilter.h>
  26 #include <itkPasteImageFilter.h>
  27
  28 //--------------------------------------------------------------------
  29 template<class ImageType>
  30 void clitk::ComputeBBFromImageRegion(typename ImageType::Pointer image,
  31                                      typename ImageType::RegionType region,
  32                                      typename itk::BoundingBox<unsigned long,
  33                                      ImageType::ImageDimension>::Pointer bb) {
  34   typedef typename ImageType::IndexType IndexType;
  35   IndexType firstIndex;
  36   IndexType lastIndex;
  37   for(unsigned int i=0; i<image->GetImageDimension(); i++) {
  38     firstIndex[i] = region.GetIndex()[i];
  39     lastIndex[i] = region.GetSize()[i];
  40   }
  41
  42   typedef itk::BoundingBox<unsigned long,
  43     ImageType::ImageDimension> BBType;
  44   typedef typename BBType::PointType PointType;
  45   PointType lastPoint;
  46   PointType firstPoint;
  47   image->TransformIndexToPhysicalPoint(firstIndex, firstPoint);
  48   image->TransformIndexToPhysicalPoint(lastIndex, lastPoint);
  49
  50   bb->SetMaximum(lastPoint);
  51   bb->SetMinimum(firstPoint);
  52 }
  53 //--------------------------------------------------------------------
  54
  55
  56 //--------------------------------------------------------------------
  57 template<int Dimension>
  58 void clitk::ComputeBBIntersection(typename itk::BoundingBox<unsigned long, Dimension>::Pointer bbo,
  59                                   typename itk::BoundingBox<unsigned long, Dimension>::Pointer bbi1,
  60                                   typename itk::BoundingBox<unsigned long, Dimension>::Pointer bbi2) {
  61
  62   typedef itk::BoundingBox<unsigned long, Dimension> BBType;
  63   typedef typename BBType::PointType PointType;
  64   PointType lastPoint;
  65   PointType firstPoint;
  66
  67   for(unsigned int i=0; i<Dimension; i++) {
  68     firstPoint[i] = std::max(bbi1->GetMinimum()[i],
  69                              bbi2->GetMinimum()[i]);
  70     lastPoint[i] = std::min(bbi1->GetMaximum()[i],
  71                             bbi2->GetMaximum()[i]);
  72   }
  73
  74   bbo->SetMaximum(lastPoint);
  75   bbo->SetMinimum(firstPoint);
  76 }
  77 //--------------------------------------------------------------------
  78
  79
  80 //--------------------------------------------------------------------
  81 template<class ImageType>
  82 void clitk::ComputeRegionFromBB(typename ImageType::Pointer image,
  83                                 const typename itk::BoundingBox<unsigned long,
  84                                 ImageType::ImageDimension>::Pointer bb,
  85                                 typename ImageType::RegionType & region) {
  86   // Types
  87   typedef typename ImageType::IndexType  IndexType;
  88   typedef typename ImageType::PointType  PointType;
  89   typedef typename ImageType::RegionType RegionType;
  90   typedef typename ImageType::SizeType   SizeType;
  91
  92   // Region starting point
  93   IndexType regionStart;
  94   PointType start = bb->GetMinimum();
  95   image->TransformPhysicalPointToIndex(start, regionStart);
  96
  97   // Region size
  98   SizeType regionSize;
  99   PointType maxs = bb->GetMaximum();
 100   PointType mins = bb->GetMinimum();
 101   for(unsigned int i=0; i<ImageType::ImageDimension; i++) {
 102     regionSize[i] = floor((maxs[i] - mins[i])/image->GetSpacing()[i]);
 103   }
 104
 105   // Create region
 106   region.SetIndex(regionStart);
 107   region.SetSize(regionSize);
 108 }
 109 //--------------------------------------------------------------------
 110
 111 //--------------------------------------------------------------------
 112 template<class ImageType, class TMaskImageType>
 113 typename ImageType::Pointer
 114 clitk::SetBackground(typename ImageType::ConstPointer input,
 115                      typename TMaskImageType::ConstPointer mask,
 116                      typename TMaskImageType::PixelType maskBG,
 117                      typename ImageType::PixelType outValue) {
 118   typedef clitk::SetBackgroundImageFilter<ImageType, TMaskImageType, ImageType> SetBackgroundImageFilterType;
 119   typename SetBackgroundImageFilterType::Pointer setBackgroundFilter = SetBackgroundImageFilterType::New();
 120   setBackgroundFilter->SetInput(input);
 121   setBackgroundFilter->SetInput2(mask);
 122   setBackgroundFilter->SetMaskValue(maskBG);
 123   setBackgroundFilter->SetOutsideValue(outValue);
 124   setBackgroundFilter->Update();
 125   return setBackgroundFilter->GetOutput();
 126 }
 127 //--------------------------------------------------------------------
 128
 129
 130 //--------------------------------------------------------------------
 131 template<class ImageType>
 132 typename ImageType::Pointer
 133 clitk::Labelize(typename ImageType::Pointer input,
 134                 typename ImageType::PixelType BG,
 135                 bool isFullyConnected,
 136                 int minimalComponentSize) {
 137
 138   // Connected Component label
 139   typedef itk::ConnectedComponentImageFilter<ImageType, ImageType> ConnectFilterType;
 140   typename ConnectFilterType::Pointer connectFilter = ConnectFilterType::New();
 141   connectFilter->SetInput(input);
 142   connectFilter->SetBackgroundValue(BG);
 143   connectFilter->SetFullyConnected(isFullyConnected);
 144
 145   // Sort by size and remove too small area.
 146   typedef itk::RelabelComponentImageFilter<ImageType, ImageType> RelabelFilterType;
 147   typename RelabelFilterType::Pointer relabelFilter = RelabelFilterType::New();
 148   relabelFilter->InPlaceOn();
 149   relabelFilter->SetInput(connectFilter->GetOutput());
 150   relabelFilter->SetMinimumObjectSize(minimalComponentSize);
 151   relabelFilter->Update();
 152
 153   // Return result
 154   return relabelFilter->GetOutput();
 155 }
 156 //--------------------------------------------------------------------
 157
 158
 159 //--------------------------------------------------------------------
 160 template<class ImageType>
 161 typename ImageType::Pointer
 162 clitk::RemoveLabels(typename ImageType::Pointer input,
 163                     typename ImageType::PixelType BG,
 164                     std::vector<typename ImageType::PixelType> & labelsToRemove) {
 165   typename ImageType::Pointer working_image = input;
 166   for (unsigned int i=0; i <labelsToRemove.size(); i++) {
 167     typedef clitk::SetBackgroundImageFilter<ImageType, ImageType> SetBackgroundImageFilterType;
 168     typename SetBackgroundImageFilterType::Pointer setBackgroundFilter = SetBackgroundImageFilterType::New();
 169     setBackgroundFilter->SetInput(input);
 170     setBackgroundFilter->SetInput2(input);
 171     setBackgroundFilter->SetMaskValue(labelsToRemove[i]);
 172     setBackgroundFilter->SetOutsideValue(BG);
 173     setBackgroundFilter->Update();
 174     working_image = setBackgroundFilter->GetOutput();
 175   }
 176   return working_image;
 177 }
 178 //--------------------------------------------------------------------
 179
 180
 181 //--------------------------------------------------------------------
 182 template<class ImageType>
 183 typename ImageType::Pointer
 184 clitk::KeepLabels(typename ImageType::Pointer input,
 185                   typename ImageType::PixelType BG,
 186                   typename ImageType::PixelType FG,
 187                   typename ImageType::PixelType firstKeep,
 188                   typename ImageType::PixelType lastKeep,
 189                   bool useLastKeep) {
 190   typedef itk::BinaryThresholdImageFilter<ImageType, ImageType> BinarizeFilterType;
 191   typename BinarizeFilterType::Pointer binarizeFilter = BinarizeFilterType::New();
 192   binarizeFilter->SetInput(input);
 193   binarizeFilter->SetLowerThreshold(firstKeep);
 194   if (useLastKeep) binarizeFilter->SetUpperThreshold(lastKeep);
 195   binarizeFilter->SetInsideValue(FG);
 196   binarizeFilter->SetOutsideValue(BG);
 197   binarizeFilter->Update();
 198   return binarizeFilter->GetOutput();
 199 }
 200 //--------------------------------------------------------------------
 201
 202
 203 //--------------------------------------------------------------------
 204 template<class ImageType>
 205 typename ImageType::Pointer
 206 clitk::LabelizeAndSelectLabels(typename ImageType::Pointer input,
 207                                typename ImageType::PixelType BG,
 208                                typename ImageType::PixelType FG,
 209                                bool isFullyConnected,
 210                                int minimalComponentSize,
 211                                LabelizeParameters<typename ImageType::PixelType> * param)
 212 {
 213   typename ImageType::Pointer working_image;
 214   working_image = Labelize<ImageType>(input, BG, isFullyConnected, minimalComponentSize);
 215   working_image = RemoveLabels<ImageType>(working_image, BG, param->GetLabelsToRemove());
 216   working_image = KeepLabels<ImageType>(working_image,
 217                                         BG, FG,
 218                                         param->GetFirstKeep(),
 219                                         param->GetLastKeep(),
 220                                         param->GetUseLastKeep());
 221   return working_image;
 222 }
 223 //--------------------------------------------------------------------
 224
 225
 226 //--------------------------------------------------------------------
 227 template<class ImageType>
 228 typename ImageType::Pointer
 229 clitk::EnlargeImageLike(typename ImageType::Pointer input,
 230                         typename ImageType::Pointer like,
 231                         typename ImageType::PixelType backgroundValue)
 232 {
 233   if (!HaveSameSpacing<ImageType, ImageType>(input, like)) {
 234     FATAL("Images must have the same spacing");
 235   }
 236
 237   typename ImageType::Pointer output = ImageType::New();
 238   typename ImageType::SizeType size;
 239   for(unsigned int i=0; i<ImageType::ImageDimension; i++) {
 240     size[i] = lrint((like->GetLargestPossibleRegion().GetSize()[i]*like->GetSpacing()[i])/
 241                     (double)like->GetSpacing()[i]);
 242   }
 243   // DD(size);
 244   typename ImageType::RegionType region;
 245   region.SetSize(size);
 246   output->SetRegions(region);
 247   output->SetSpacing(like->GetSpacing());
 248   output->SetOrigin(like->GetOrigin());
 249   output->Allocate();
 250   output->FillBuffer(backgroundValue);
 251   typedef itk::PasteImageFilter<ImageType,ImageType> PasteFilterType;
 252   typename PasteFilterType::Pointer pasteFilter = PasteFilterType::New();
 253   typename PasteFilterType::InputImageIndexType index;
 254   for(unsigned int i=0; i<ImageType::ImageDimension; i++) {
 255     index[i] = lrint((input->GetOrigin()[i] - like->GetOrigin()[i])/(double)input->GetSpacing()[i]);
 256   }
 257   // DD(index);
 258   pasteFilter->SetSourceImage(input);
 259   pasteFilter->SetDestinationImage(output);
 260   pasteFilter->SetDestinationIndex(index);
 261   pasteFilter->SetSourceRegion(input->GetLargestPossibleRegion());
 262   pasteFilter->Update();
 263   return pasteFilter->GetOutput();
 264 }
 265 //--------------------------------------------------------------------