X-Git-Url: https://git.creatis.insa-lyon.fr/pubgit/?a=blobdiff_plain;f=itk%2FclitkSegmentationUtils.h;h=6972d154ab8f4436a672247090da66efff9eb331;hb=4f6aadc0552db99c03057d4aa40a7fc4a1697350;hp=77270d1a542b4d2c1bb7bc3346bcb91967b49f2c;hpb=11b92682c7b52e3920c733aeb2c97721359898e3;p=clitk.git

diff --git a/itk/clitkSegmentationUtils.h b/itk/clitkSegmentationUtils.h
index 77270d1..6972d15 100644
--- a/itk/clitkSegmentationUtils.h
+++ b/itk/clitkSegmentationUtils.h
@@ -23,32 +23,21 @@
 #include "clitkCommon.h"
 #include "clitkAutoCropFilter.h"
 #include "clitkLabelizeParameters.h"
+#include "clitkExtractSliceFilter.h"
 
 // itk
 #include <itkBoundingBox.h>
+#include <itkJoinSeriesImageFilter.h>
 
-namespace clitk {
+/*
+  According to 
+  http://answerpot.com/showthread.php?357451-Itk::SmartPointer%20-%20problem%20making%20code%20const-correct
+  it is better to take raw pointer as argument instead of SmartPointer.
+*/
 
-  //--------------------------------------------------------------------
-  template<class ImageType>
-  void ComputeBBFromImageRegion(typename ImageType::Pointer image, 
-                                typename ImageType::RegionType region,
-                                typename itk::BoundingBox<unsigned long, 
-                                                          ImageType::ImageDimension>::Pointer bb);
-  
-  //--------------------------------------------------------------------
-  template<int Dimension>
-  void ComputeBBIntersection(typename itk::BoundingBox<unsigned long, Dimension>::Pointer bbo, 
-                             typename itk::BoundingBox<unsigned long, Dimension>::Pointer bbi1, 
-                             typename itk::BoundingBox<unsigned long, Dimension>::Pointer bbi2);
+namespace clitk {
 
   //--------------------------------------------------------------------
-  template<class ImageType>
-  void ComputeRegionFromBB(typename ImageType::Pointer image, 
-                           const typename itk::BoundingBox<unsigned long, 
-                           ImageType::ImageDimension>::Pointer bb, 
-                           typename ImageType::RegionType & region);
-  //--------------------------------------------------------------------
   template<class TInternalImageType, class TMaskInternalImageType>
   typename TInternalImageType::Pointer
   SetBackground(const TInternalImageType * input,
@@ -61,7 +50,7 @@ namespace clitk {
 
   //--------------------------------------------------------------------
   template<class ImageType>
-  int GetNumberOfConnectedComponentLabels(typename ImageType::Pointer input, 
+  int GetNumberOfConnectedComponentLabels(const ImageType * input, 
                                           typename ImageType::PixelType BG, 
                                           bool isFullyConnected);
   //--------------------------------------------------------------------
@@ -70,17 +59,22 @@ namespace clitk {
   //-------------------------------------------------------------------- 
   template<class TImageType>
   typename TImageType::Pointer
-  Labelize(const TImageType * input, 
-           typename TImageType::PixelType BG, 
-           bool isFullyConnected, 
-           int minimalComponentSize);
+  Labelize(const TImageType * input, typename TImageType::PixelType BG, 
+           bool isFullyConnected, int minimalComponentSize);
+  template<class TImageType>
+  typename TImageType::Pointer
+  LabelizeAndCountNumberOfObjects(const TImageType * input, 
+                                  typename TImageType::PixelType BG, 
+                                  bool isFullyConnected, 
+                                  int minimalComponentSize, 
+                                  int & nb);
   //--------------------------------------------------------------------
 
 
   //--------------------------------------------------------------------
   template<class ImageType>
   typename ImageType::Pointer
-  RemoveLabels(typename ImageType::Pointer input, 
+  RemoveLabels(const ImageType * input, 
                typename ImageType::PixelType BG, 
                std::vector<typename ImageType::PixelType> & labelsToRemove);
   //--------------------------------------------------------------------
@@ -89,7 +83,7 @@ namespace clitk {
   //--------------------------------------------------------------------
   template<class ImageType>
   typename ImageType::Pointer
-  AutoCrop(typename ImageType::Pointer input, 
+  AutoCrop(const ImageType * input, 
            typename ImageType::PixelType BG) {
     typedef clitk::AutoCropFilter<ImageType> AutoCropFilterType;
     typename AutoCropFilterType::Pointer autoCropFilter = AutoCropFilterType::New();
@@ -116,20 +110,13 @@ namespace clitk {
   //--------------------------------------------------------------------
   template<class TImageType>
   typename TImageType::Pointer
-  LabelizeAndSelectLabels(typename TImageType::Pointer input,
+  LabelizeAndSelectLabels(const TImageType * input,
                           typename TImageType::PixelType BG, 
                           typename TImageType::PixelType FG, 
                           bool isFullyConnected,
                           int minimalComponentSize,
                           LabelizeParameters<typename TImageType::PixelType> * param);
 
-  //--------------------------------------------------------------------
-  template<class ImageType>
-  typename ImageType::Pointer
-  ResizeImageLike(typename ImageType::Pointer input,
-                  typename ImageType::Pointer like, 
-                  typename ImageType::PixelType BG);
-
 
   //--------------------------------------------------------------------
   template<class MaskImageType>
@@ -141,7 +128,20 @@ namespace clitk {
 			       std::string orientation, 
                                bool uniqueConnectedComponent=false, 
                                double spacing=-1, 
-			       bool notflag=false);
+                               bool autocropflag=true, 
+                               bool singleObjectCCL=true);
+  template<class MaskImageType>
+  typename MaskImageType::Pointer
+  SliceBySliceRelativePosition(const MaskImageType * input,
+			       const MaskImageType * object,
+			       int direction, 
+			       double threshold, 
+			       double angle, 
+                               bool inverseflag,
+                               bool uniqueConnectedComponent=false, 
+                               double spacing=-1, 
+                               bool autocropflag=true, 
+                               bool singleObjectCCL=true);
 
   //--------------------------------------------------------------------
   // In a binary image, search for the point belonging to the FG that
@@ -173,29 +173,37 @@ namespace clitk {
   //--------------------------------------------------------------------
   template<class ImageType>
   typename ImageType::Pointer
-  CropImageAlongOneAxis(typename ImageType::Pointer image, 
+  CropImageAlongOneAxis(const ImageType * image, 
                         int dim, double min, double max, 
                         bool autoCrop = false,
                         typename ImageType::PixelType BG=0);
   template<class ImageType>
   typename ImageType::Pointer
-  CropImageAbove(typename ImageType::Pointer image, 
-                 int dim, double min, 
-                 bool autoCrop = false,
-                 typename ImageType::PixelType BG=0);
+  CropImageRemoveGreaterThan(const ImageType * image, 
+                             int dim, double min, bool autoCrop = false,
+                             typename ImageType::PixelType BG=0);
   template<class ImageType>
   typename ImageType::Pointer
-  CropImageBelow(typename ImageType::Pointer image, 
-                 int dim, double max,
-                 bool autoCrop = false,
-                 typename ImageType::PixelType BG=0);
+  CropImageRemoveLowerThan(const ImageType * image, 
+                           int dim, double max,bool autoCrop = false,
+                           typename ImageType::PixelType BG=0);
   //--------------------------------------------------------------------
 
 
   //--------------------------------------------------------------------
+  template<class ImageType, class LabelType>
+  typename itk::LabelMap< itk::ShapeLabelObject<LabelType, ImageType::ImageDimension> >::Pointer
+  ComputeLabelMap(const ImageType * image, 
+                  typename ImageType::PixelType BG,                   
+                  bool computePerimeterFlag=false);
+  template<class ImageType>
+  void
+  ComputeCentroids(const ImageType * image, 
+                   typename ImageType::PixelType BG, 
+                   std::vector<typename ImageType::PointType> & centroids);
   template<class ImageType>
   void
-  ComputeCentroids(typename ImageType::Pointer image, 
+  ComputeCentroids2(const ImageType * image, 
                    typename ImageType::PixelType BG, 
                    std::vector<typename ImageType::PointType> & centroids);
   //--------------------------------------------------------------------
@@ -204,10 +212,19 @@ namespace clitk {
   //--------------------------------------------------------------------
   template<class ImageType>
   void
-  ExtractSlices(typename ImageType::Pointer image, 
-		int dim, 
-		std::vector< typename itk::Image<typename ImageType::PixelType, 
-		ImageType::ImageDimension-1>::Pointer > & slices);
+  ExtractSlices(const ImageType * image, int direction,
+                std::vector<typename itk::Image<typename ImageType::PixelType,
+                                                ImageType::ImageDimension-1>::Pointer > & slices)
+  {
+    typedef ExtractSliceFilter<ImageType> ExtractSliceFilterType;
+    typedef typename ExtractSliceFilterType::SliceType SliceType;
+    typename ExtractSliceFilterType::Pointer
+      extractSliceFilter = ExtractSliceFilterType::New();
+    extractSliceFilter->SetInput(image);
+    extractSliceFilter->SetDirection(direction);
+    extractSliceFilter->Update();
+    extractSliceFilter->GetOutputSlices(slices);
+  }
   //--------------------------------------------------------------------
 
 
@@ -215,9 +232,20 @@ namespace clitk {
   template<class ImageType>
   typename ImageType::Pointer
   JoinSlices(std::vector<typename itk::Image<typename ImageType::PixelType, 
-	     ImageType::ImageDimension-1>::Pointer > & slices, 
-	     typename ImageType::Pointer input, 
-	     int dim);
+                                             ImageType::ImageDimension-1>::Pointer > & slices, 
+             const itk::ImageBase<ImageType::ImageDimension> * input, //const ImageType * input, 
+             int direction) {
+    typedef typename itk::Image<typename ImageType::PixelType, ImageType::ImageDimension-1> SliceType;
+    typedef itk::JoinSeriesImageFilter<SliceType, ImageType> JoinSeriesFilterType;
+    typename JoinSeriesFilterType::Pointer joinFilter = JoinSeriesFilterType::New();
+    joinFilter->SetOrigin(input->GetOrigin()[direction]);
+    joinFilter->SetSpacing(input->GetSpacing()[direction]);
+    for(unsigned int i=0; i<slices.size(); i++) {
+      joinFilter->PushBackInput(slices[i]);
+    }
+    joinFilter->Update();
+    return joinFilter->GetOutput();
+  }
   //--------------------------------------------------------------------
 
 
@@ -227,22 +255,30 @@ namespace clitk {
   class PointsUtils
   {
     typedef typename ImageType::PointType PointType3D;
+    typedef typename ImageType::IndexType IndexType3D;
     typedef typename ImageType::PixelType PixelType;
     typedef typename ImageType::Pointer ImagePointer;
     typedef typename ImageType::ConstPointer ImageConstPointer;
     typedef itk::Image<PixelType, 2> SliceType;
     typedef typename SliceType::PointType PointType2D;
+    typedef typename SliceType::IndexType IndexType2D;
     
     typedef std::map<int, PointType2D> MapPoint2DType;
     typedef std::vector<PointType3D> VectorPoint3DType;
+    typedef std::vector<PointType2D> VectorPoint2DType;
+
   public:
     static void Convert2DTo3D(const PointType2D & p2D, 
-                              ImagePointer image, 
+                              const ImageType * image, 
                               const int slice, 
                               PointType3D & p3D);
-    static void Convert2DTo3DList(const MapPoint2DType & map, 
-                                  ImagePointer image, 
+    static void Convert2DMapTo3DList(const MapPoint2DType & map, 
+                                  const ImageType * image, 
                                   VectorPoint3DType & list);
+    static void Convert2DListTo3DList(const VectorPoint2DType & p, 
+                                      int slice,
+                                      const ImageType * image, 
+                                      VectorPoint3DType & list);
   };
 
   //--------------------------------------------------------------------
@@ -256,36 +292,203 @@ namespace clitk {
   //--------------------------------------------------------------------
   template<class ImageType>
   typename ImageType::Pointer
-  Dilate(typename ImageType::Pointer image, 
-              double radiusInMM,               
-              typename ImageType::PixelType BG, 
-              typename ImageType::PixelType FG, 
-              bool extendSupport);
+  Dilate(const ImageType * image, double radiusInMM,               
+         typename ImageType::PixelType BG, 
+         typename ImageType::PixelType FG, 
+         bool extendSupport);
   template<class ImageType>
   typename ImageType::Pointer
-  Dilate(typename ImageType::Pointer image, 
-              typename ImageType::SizeType radius, 
-              typename ImageType::PixelType BG, 
-              typename ImageType::PixelType FG, 
-              bool extendSupport);
+  Dilate(const ImageType * image, typename ImageType::SizeType radius, 
+         typename ImageType::PixelType BG, 
+         typename ImageType::PixelType FG, 
+         bool extendSupport);
   template<class ImageType>
   typename ImageType::Pointer  
-  Dilate(typename ImageType::Pointer image, 
-              typename ImageType::PointType radiusInMM, 
-              typename ImageType::PixelType BG, 
-              typename ImageType::PixelType FG, 
-              bool extendSupport);
+  Dilate(const ImageType * image, typename ImageType::PointType radiusInMM, 
+         typename ImageType::PixelType BG, 
+         typename ImageType::PixelType FG, 
+         bool extendSupport);
   //--------------------------------------------------------------------
 
+
+  //--------------------------------------------------------------------
+  template<class ImageType>
+  typename ImageType::Pointer 
+  Opening(const ImageType * image, typename ImageType::SizeType radius,
+          typename ImageType::PixelType BG, typename ImageType::PixelType FG);
+  //--------------------------------------------------------------------
+
+
   //--------------------------------------------------------------------
   template<class ValueType, class VectorType>
   void ConvertOption(std::string optionName, uint given, 
                      ValueType * values, VectorType & p, 
                      uint dim, bool required);
-#define ConvertOptionMacro(OPTIONNAME, VAR, DIM, REQUIRED)         \
+#define ConvertOptionMacro(OPTIONNAME, VAR, DIM, REQUIRED)              \
   ConvertOption(#OPTIONNAME, OPTIONNAME##_given, OPTIONNAME##_arg, VAR, DIM, REQUIRED);
+  //--------------------------------------------------------------------
+
+  //--------------------------------------------------------------------
+  template<class ImageType>
+  void 
+  SliceBySliceSetBackgroundFromLineSeparation(ImageType * input, 
+                                              std::vector<typename ImageType::PointType> & lA, 
+                                              std::vector<typename ImageType::PointType> & lB, 
+                                              typename ImageType::PixelType BG, 
+                                              int mainDirection, 
+                                              double offsetToKeep);
+  //--------------------------------------------------------------------
+
+
+  //--------------------------------------------------------------------
+  template<class ImageType>
+  void AndNot(ImageType * input, 
+              const ImageType * object, 
+              typename ImageType::PixelType BG=0);
+  template<class ImageType>
+  void And(ImageType * input, 
+           const ImageType * object, 
+           typename ImageType::PixelType BG=0);
+  template<class ImageType>
+  void Or(ImageType * input, 
+          const ImageType * object, 
+          typename ImageType::PixelType BG=0);
+  //--------------------------------------------------------------------
+ 
+
+  //--------------------------------------------------------------------
+  template<class ImageType>
+  typename ImageType::Pointer
+  Binarize(const ImageType * input, 
+           typename ImageType::PixelType lower, 
+           typename ImageType::PixelType upper, 
+           typename ImageType::PixelType BG=0,
+           typename ImageType::PixelType FG=1);
+  //--------------------------------------------------------------------
+ 
+  
+  //--------------------------------------------------------------------
+  template<class ImageType>
+  void
+  GetMinMaxPointPosition(const ImageType * input, 
+                         typename ImageType::PointType & min,
+                         typename ImageType::PointType & max);
+  //--------------------------------------------------------------------
+
+  //--------------------------------------------------------------------
+  template<class ImageType>
+  typename ImageType::PointType
+  FindExtremaPointInAGivenLine(const ImageType * input, 
+                               int dimension, bool inverse, 
+                               typename ImageType::PointType p, 
+                               typename ImageType::PixelType BG, 
+                               double distanceMax);
+  //--------------------------------------------------------------------
+
+  
+  //--------------------------------------------------------------------
+  template<class PointType>
+  bool
+  IsOnTheSameLineSide(PointType C, PointType A, PointType B, PointType like);
+  //--------------------------------------------------------------------
+
+
+  //--------------------------------------------------------------------
+  template<class ImageType>
+  void 
+  SliceBySliceBuildLineSegmentAccordingToExtremaPosition(const ImageType * input, 
+                                                         typename ImageType::PixelType BG, 
+                                                         int sliceDimension, 
+                                                         int extremaDirection, 
+                                                         bool extremaOppositeFlag, 
+                                                         int lineDirection,
+                                                         double margin,
+                                                         std::vector<typename ImageType::PointType> & A, 
+                                                         std::vector<typename ImageType::PointType> & B);  
+  template<class ImageType>
+  void 
+  SliceBySliceBuildLineSegmentAccordingToMinimalDistanceBetweenStructures(const ImageType * S1, 
+                                                                          const ImageType * S2, 
+                                                                          typename ImageType::PixelType BG, 
+                                                                          int sliceDimension, 
+                                                                          std::vector<typename ImageType::PointType> & A, 
+                                                                          std::vector<typename ImageType::PointType> & B);  
+  //--------------------------------------------------------------------
+
+
+  //--------------------------------------------------------------------
+  template<class ImageType>
+  typename ImageType::Pointer
+  SliceBySliceKeepMainCCL(const ImageType * input, 
+                          typename ImageType::PixelType BG,
+                          typename ImageType::PixelType FG);
+  //--------------------------------------------------------------------
+  
+
+  //--------------------------------------------------------------------
+  template<class ImageType>
+  typename ImageType::Pointer
+  Clone(const ImageType * input);
+  //--------------------------------------------------------------------
+  
+
+  //--------------------------------------------------------------------
+  template<class ImageType>
+  typename ImageType::Pointer
+  SliceBySliceSetBackgroundFromSingleLine(const ImageType * input, 
+                                          typename ImageType::PixelType BG, 
+                                          typename ImageType::PointType & A, 
+                                          typename ImageType::PointType & B, 
+                                          int dim1, int dim2, bool removeLowerPartFlag);
+  //--------------------------------------------------------------------
+  
+
+  //--------------------------------------------------------------------
+  template<class ImageType>
+  typename ImageType::Pointer
+  SliceBySliceSetBackgroundFromPoints(const ImageType * input, 
+                                      typename ImageType::PixelType BG, 
+                                      int sliceDim,
+                                      std::vector<typename ImageType::PointType> & A, 
+                                      bool removeGreaterThanXFlag,
+                                      bool removeGreaterThanYFlag);
+  //--------------------------------------------------------------------
+
+
+  //--------------------------------------------------------------------
+  template<class ImageType>
+  void
+  FillRegionWithValue(ImageType * input, typename ImageType::PixelType value, 
+                      typename ImageType::RegionType & region);
+  //--------------------------------------------------------------------
+
+
+  //--------------------------------------------------------------------
+  template<class ImageType>
+  void
+  GetMinMaxBoundary(ImageType * input, typename ImageType::PointType & min, 
+                    typename ImageType::PointType & max);
+  //--------------------------------------------------------------------
+
+
+  //--------------------------------------------------------------------
+  template<class ImageType>
+  typename itk::Image<float, ImageType::ImageDimension>::Pointer//void
+  DistanceMap(const ImageType * input, typename ImageType::PixelType BG);//, 
+  //--------------------------------------------------------------------
+
+
+  //--------------------------------------------------------------------
+  template<class ImageType>
+  typename ImageType::PointType
+  ComputeClosestPoint(const ImageType * input, 
+                      const itk::Image<float, ImageType::ImageDimension> * dmap, 
+                      typename ImageType::PixelType & BG);
+  //--------------------------------------------------------------------
+  
+
 
-}
+} // end clitk namespace
 
 #include "clitkSegmentationUtils.txx"