Merge branch 'msbuild_portability'

app/otbLSGRM.cxx

@@ -17,6 +17,10 @@
 #include "lsgrmFullLambdaScheduleSegmenter.h"
 #include "lsgrmController.h"
 
+// Graph to label image (streaming version)
+#include "otbStreamingGraphToImageFilter.h"
+#include "otbStreamingImageVirtualWriter.h"
+
 // system tools
 #include <itksys/SystemTools.hxx>
 
@@ -65,6 +69,7 @@ private:
 
   void DoInit()
   {
+
     SetName("GenericRegionMerging");
     SetDescription("This application allows to use the Large Scale Generic Region Merging library "
         "(LSGRM) and provides currently 3 homogeneity criteria: Euclidean Distance, "
@@ -107,6 +112,7 @@ private:
     AddChoice("tiling.none", "No tiling layout");
 
     AddParameter(ParameterType_Int, "memory", "Restrict memory use (mb)");
+
     MandatoryOff("memory");
   }
 
@@ -128,28 +134,28 @@ private:
     std::string tmpdir;
     if (HasValue("tmpdir"))
       {
-      tmpdir= GetParameterAsString("tmpdir");
+        tmpdir= GetParameterAsString("tmpdir");
       }
     else
       {
-      tmpdir = itksys::SystemTools::GetFilenamePath(outfname);
+        tmpdir = itksys::SystemTools::GetFilenamePath(outfname);
       }
 
     if (!tmpdir.empty())
       {
-      // A temporary directory is specified: we check that it ends with a POSIX separator
-      if (tmpdir[tmpdir.size()-1] != '/')
-        {
-        // If not, we add the separator
-        tmpdir.append("/");
-        }
-
-      // Check that the directory exists
-      if (!itksys::SystemTools::FileExists(tmpdir.c_str(),false))
-        {
-        otbAppLogFATAL("The directory " << tmpdir << " does not exist.");
-        }
-      otbAppLogINFO("Using temporary directory " << tmpdir);
+        // A temporary directory is specified: we check that it ends with a POSIX separator
+        if (tmpdir[tmpdir.size()-1] != '/')
+          {
+            // If not, we add the separator
+            tmpdir.append("/");
+          }
+
+        // Check that the directory exists
+        if (!itksys::SystemTools::FileExists(tmpdir.c_str(),false))
+          {
+            otbAppLogFATAL("The directory " << tmpdir << " does not exist.");
+          }
+        otbAppLogINFO("Using temporary directory " << tmpdir);
       }
 
 
@@ -162,17 +168,20 @@ private:
    * This function sets the generic parameters of a controller and runs the segmentation
    */
   template<class TSegmenter>
-  UInt32ImageType::Pointer SetGenericParametersAndRunSegmentation(const typename TSegmenter::ParamType params){
+  void
+  SetGenericParametersAndRunSegmentation(const typename TSegmenter::ParamType params){
 
     // Instantiate the controller
     typedef typename lsgrm::Controller<TSegmenter> ControlerType;
     typename ControlerType::Pointer controller = ControlerType::New();
+    using GraphType = typename ControlerType::GraphType;
 
     // Set specific parameters
     controller->SetSpecificParameters(params);
 
     // Set input image
-    controller->SetInputImage(GetParameterFloatVectorImage("in"));
+    ImageType::Pointer inputImage = GetParameterFloatVectorImage("in");
+    controller->SetInputImage(inputImage);
 
     // Set threshold
     float thres = GetParameterFloat("threshold");
@@ -188,86 +197,92 @@ private:
     int inputTilingMode = GetParameterInt("tiling");
     if (inputTilingMode == TILING_AUTO)
       {
-      // Automatic mode
-      controller->SetTilingModeAuto();
+        // Automatic mode
+        controller->SetTilingModeAuto();
       }
     else if (inputTilingMode == TILING_USER)
       {
-      // User mode
-      controller->SetTilingModeUser();
-      controller->SetTileWidth(GetParameterInt("tiling.user.sizex"));
-      controller->SetTileHeight(GetParameterInt("tiling.user.sizey"));
-      controller->SetNumberOfFirstIterations(GetParameterInt("tiling.user.nfirstiter"));
+        // User mode
+        controller->SetTilingModeUser();
+        controller->SetTileWidth(GetParameterInt("tiling.user.sizex"));
+        controller->SetTileHeight(GetParameterInt("tiling.user.sizey"));
+        controller->SetNumberOfFirstIterations(GetParameterInt("tiling.user.nfirstiter"));
       }
     else if (inputTilingMode == TILING_NONE)
       {
-      // None mode
-      controller->SetTilingModeNone();
+        // None mode
+        controller->SetTilingModeNone();
       }
     else
       {
-      otbAppLogFATAL("Unknown tiling mode!");
+        otbAppLogFATAL("Unknown tiling mode!");
       }
 
     // Input RAM value?
     if (HasValue("memory"))
       {
-      otbAppLogINFO("Setting maximum memory to " << GetParameterInt("memory") << " MBytes");
-      controller->SetInternalMemoryAvailable(GetParameterInt("memory"));
+        otbAppLogINFO("Setting maximum memory to " << GetParameterInt("memory") << " MBytes");
+        controller->SetInternalMemoryAvailable(GetParameterInt("memory"));
       }
 
     // Run the segmentation
     controller->RunSegmentation();
 
+    // Prepare the label image source
+    typedef lsgrm::StreamingGraphToImageFilter<GraphType, UInt32ImageType> LabelImageSourceType;
+    typename LabelImageSourceType::Pointer labelImageSource = LabelImageSourceType::New();
+    labelImageSource->SetGraph(controller->GetOutputGraph());
+    labelImageSource->SetOutputSize(inputImage->GetLargestPossibleRegion().GetSize());
+    labelImageSource->SetOutputOrigin(inputImage->GetOrigin());
+    labelImageSource->SetOutputSpacing(inputImage->GetSpacing());
+    labelImageSource->SetOutputProjectionRef(inputImage->GetProjectionRef());
+    labelImageSource->GenerateOutputInformation();
+
+    m_LabelImageSource = static_cast<itk::ImageSource<UInt32ImageType>*>(labelImageSource);
+
+    SetParameterOutputImage<UInt32ImageType>("out", m_LabelImageSource->GetOutput());
+
+    // TODO: find an intelligent value of RAM
+    if (dynamic_cast<OutputImageParameter*>(GetParameterByKey("out")))
+      {
+      OutputImageParameter* paramDown = dynamic_cast<OutputImageParameter*>(GetParameterByKey("out"));
+      paramDown->SetRAMValue(256);
+      }
+
     // Get temporary files list
     m_TemporaryFilesList = controller->GetTemporaryFilesList();
 
-    // Return the label image
-    return controller->GetLabeledClusteredOutput();
   }
 
   void DoExecute()
   {
-    /*
-        TODO: the output directory in case the global graph cannot fit in memory (lsgrmController.txx)
-     */
 
-    // Input image
     ImageType::Pointer inputImage = GetParameterFloatVectorImage("in");
 
-    // Output image
-    UInt32ImageType::Pointer labelImage = UInt32ImageType::New();
-
     // Switch criterion
     int inputCriterion = GetParameterInt("criterion");
     if (inputCriterion == CRITERION_BAATZ)
       {
-      grm::BaatzParam params;
-      params.m_SpectralWeight = GetParameterFloat("criterion.bs.cw");
-      params.m_ShapeWeight = GetParameterFloat("criterion.bs.sw");
-      labelImage = SetGenericParametersAndRunSegmentation<BaatzSegmenterType>(params);
+        grm::BaatzParam params;
+        params.m_SpectralWeight = GetParameterFloat("criterion.bs.cw");
+        params.m_ShapeWeight = GetParameterFloat("criterion.bs.sw");
+        SetGenericParametersAndRunSegmentation<BaatzSegmenterType>(params);
       }
     else if (inputCriterion == CRITERION_SPRING)
       {
-      grm::SpringParam params;
-      labelImage = SetGenericParametersAndRunSegmentation<SpringSegmenterType>(params);
+        grm::SpringParam params;
+        SetGenericParametersAndRunSegmentation<SpringSegmenterType>(params);
       }
     else if (inputCriterion == CRITERION_FLS)
       {
-      grm::FLSParam params;
-      labelImage = SetGenericParametersAndRunSegmentation<FLSSegmenterType>(params);
+        grm::FLSParam params;
+        SetGenericParametersAndRunSegmentation<FLSSegmenterType>(params);
       }
     else
       {
-      otbAppLogFATAL("Unknow criterion!")
+        otbAppLogFATAL("Unknow criterion!")
       }
 
-    // Set output image projection, origin and spacing for labelImage
-    labelImage->SetProjectionRef(inputImage->GetProjectionRef());
-    labelImage->SetOrigin(inputImage->GetOrigin());
-    labelImage->SetSpacing(inputImage->GetSpacing());
-    SetParameterOutputImage<UInt32ImageType>("out", labelImage);
-
   }
 
   void AfterExecuteAndWriteOutputs()
@@ -282,15 +297,16 @@ private:
     // Delete temporary files
     for (unsigned int i = 0 ; i < m_TemporaryFilesList.size() ; i++)
       {
-      if( remove(m_TemporaryFilesList.at(i).c_str() ) != 0  )
-        {
-        otbAppLogWARNING( "Error deleting file " << m_TemporaryFilesList.at(i) );
-        }
+        if( remove(m_TemporaryFilesList.at(i).c_str() ) != 0  )
+          {
+            otbAppLogWARNING( "Error deleting file " << m_TemporaryFilesList.at(i) );
+          }
       }
   }
 
 private:
   std::vector<std::string> m_TemporaryFilesList;
+  itk::ImageSource<UInt32ImageType>::Pointer m_LabelImageSource;
 
 }; // app class
 } // end of namespace wrapper

include/lsgrmController.h

@@ -6,6 +6,7 @@
 #include "itkObject.h"
 #include "itkMacro.h"
 
+
 namespace lsgrm
 {
 template<class TSegmenter>
@@ -30,6 +31,7 @@ public:
   using ImageType = typename SegmenterType::ImageType;
   using LabelImageType = typename SegmenterType::LabelImageType;
   using SegmentationParameterType = typename SegmenterType::ParamType;
+  using GraphType = typename SegmenterType::GraphType;
 
   /* Default constructor and destructor. */
   Controller();
@@ -48,7 +50,6 @@ public:
   void SetTilingModeUser(){m_TilingMode = LSGRM_TILING_USER; Modified();};
   void SetTilingModeAuto(){m_TilingMode = LSGRM_TILING_AUTO; Modified();};
 
-  typename LabelImageType::Pointer GetLabeledClusteredOutput();
   std::vector<std::string> GetTemporaryFilesList();
 
   itkGetMacro(Margin, unsigned int);
@@ -77,6 +78,8 @@ public:
   itkGetMacro(TileHeight, unsigned int);
   itkSetMacro(TileHeight, unsigned int);
 
+  itkGetMacro(OutputGraph, GraphType);
+
 private:
 
   /** Enum for tiling mode */
@@ -91,7 +94,7 @@ private:
   void ComputeMaximumStabilityMargin(unsigned int width, unsigned int height, unsigned int &iter, unsigned int &margin);
   void CheckMemorySize();
   unsigned int GetNodeMemory();
-  long unsigned int GetMaximumNumberOfNodesInMemory();
+  std::size_t GetMaximumNumberOfNodesInMemory();
 
   /* Parameters given by the user */
   std::string m_TemporaryFilesPrefix;    // Path used to store intermediate files during the process.
@@ -116,7 +119,8 @@ private:
   LSGRMTilingMode                    m_TilingMode;         // tiling mode (none/user/auto)
   unsigned int                       m_Margin;             // stability margin related to m_NumberOfFirstIterations
   std::vector<ProcessingTile>        m_Tiles;              // list of tiles
-  typename LabelImageType::Pointer   m_LabelImage;         // output label image
+  GraphType                          m_OutputGraph;        // Output graph
+
 };
 } // end of namespace lsgrm
 

include/lsgrmController.txx

@@ -18,6 +18,7 @@ Controller<TSegmenter>::Controller()
   m_NbTilesY = 0;
   m_Threshold = 75;
   m_Memory = 0;
+
 }
 
 template<class TSegmenter>
@@ -87,6 +88,7 @@ void Controller<TSegmenter>::RunSegmentation()
 
     // Run first partial segmentation
     boost::timer t; t.restart();
+	
     auto accumulatedMemory = RunFirstPartialSegmentation<TSegmenter>(
         m_InputImage,
         m_SpecificParameters,
@@ -139,7 +141,7 @@ void Controller<TSegmenter>::RunSegmentation()
         numberOfIterationsRemaining -= numberOfIterationsForPartialSegmentations;
         }
       }
-
+	
 #ifdef OTB_USE_MPI
     // Only the master process is doing the next part
     // TODO: Use the MPI process wich has the largest amount of memory
@@ -150,7 +152,7 @@ void Controller<TSegmenter>::RunSegmentation()
     if(accumulatedMemory <= m_Memory)
       {
       // Merge all the graphs
-      m_LabelImage = MergeAllGraphsAndAchieveSegmentation<TSegmenter>(
+        m_OutputGraph = MergeAllGraphsAndAchieveSegmentation<TSegmenter>(
           m_SpecificParameters,
           m_Threshold,
           m_Tiles,
@@ -195,14 +197,15 @@ void Controller<TSegmenter>::RunSegmentation()
     segmenter.SetInput(m_InputImage);
     segmenter.Update();
 
-    // Get label image
-    m_LabelImage = segmenter.GetLabeledClusteredOutput();
+    m_OutputGraph = segmenter.m_Graph;
     }
   else
     {
     itkExceptionMacro(<<"Unknow tiling mode!");
     }
 
+  // TODO: [MPI] broadcast the graph to other nodes
+
 }
 
 /*
@@ -264,7 +267,7 @@ void Controller<TSegmenter>::CheckMemorySize()
  * Compute the maximum number of nodes which can fit in the memory
  */
 template<class TSegmenter>
-long unsigned int Controller<TSegmenter>::GetMaximumNumberOfNodesInMemory()
+std::size_t Controller<TSegmenter>::GetMaximumNumberOfNodesInMemory()
 {
   itkDebugMacro(<< "Computing maximum number of nodes in memory");
 
@@ -433,16 +436,16 @@ void Controller<TSegmenter>::SetSpecificParameters(const SegmentationParameterTy
   m_SpecificParameters = params;
 }
 
-template<class TSegmenter>
-typename Controller<TSegmenter>::LabelImageType::Pointer
-Controller<TSegmenter>::GetLabeledClusteredOutput()
-{
-#ifdef OTB_USE_MPI
-  // Get the label image from the master process (the one which achieves segmentation)
-  BroadcastImage<typename TSegmenter::LabelImageType>(m_LabelImage);
-#endif
-  return m_LabelImage;
-}
+//template<class TSegmenter>
+//typename Controller<TSegmenter>::LabelImageType::Pointer
+//Controller<TSegmenter>::GetLabeledClusteredOutput()
+//{
+//#ifdef OTB_USE_MPI
+//  // Get the label image from the master process (the one which achieves segmentation)
+//  BroadcastImage<typename TSegmenter::LabelImageType>(m_LabelImage);
+//#endif
+//  return m_LabelImage;
+//}
 
 template <class TSegmenter>
 std::vector<std::string> Controller<TSegmenter>::GetTemporaryFilesList()

include/lsgrmGraphOperations.h

@@ -5,7 +5,6 @@
 #include "grmGraphOperations.h"
 #include "otbVectorImage.h"
 #include "otbMultiChannelExtractROI.h"
-#include "itkGrayscaleFillholeImageFilter.h"
 
 namespace lsgrm
 {
@@ -32,7 +31,7 @@ typename TSegmenter::ImageType::Pointer ReadImageRegion(
     typename TSegmenter::ImageType::RegionType region);
 
 template<class TSegmenter>
-typename TSegmenter::LabelImageType::Pointer
+typename TSegmenter::GraphType
 MergeAllGraphsAndAchieveSegmentation(
     const typename TSegmenter::ParamType& params,
     const float& threshold,
@@ -79,13 +78,13 @@ void RemoveUselessNodes(ProcessingTile& tile,
 
 
 template<class TSegmenter>
-void UpdateNeighborsOfNoneDuplicatedNodes(std::unordered_map<long unsigned int,
+void UpdateNeighborsOfNoneDuplicatedNodes(std::unordered_map<std::size_t,
     std::vector<typename TSegmenter::NodePointerType> >& borderPixelMap,
     const unsigned int imageWidth,
     const unsigned int imageHeight);
 
 template<class TSegmenter>
-void RemoveDuplicatedNodes(std::unordered_map<long unsigned int,
+void RemoveDuplicatedNodes(std::unordered_map<std::size_t,
     std::vector<typename TSegmenter::NodePointerType> >& borderPixelMap,
     typename TSegmenter::GraphType& graph,
     const unsigned int imageWidth);
@@ -97,9 +96,10 @@ void BuildBorderPixelMap(typename TSegmenter::GraphType& graph,
     const unsigned int colTile,
     const unsigned int nbTilesX,
     const unsigned int nbTilesY,
-    std::unordered_map<long unsigned int,
+    std::unordered_map<std::size_t,
     std::vector<typename TSegmenter::NodePointerType> >& borderPixelMap,
-    const unsigned int imageWidth);
+    const unsigned int imageWidth,
+	bool merging = false);
 
 template<class TSegmenter>
 void InsertNodesFromTile(typename TSegmenter::GraphType& graph,

include/lsgrmGraphOperations.txx

@@ -25,7 +25,7 @@ typename TSegmenter::ImageType::Pointer ReadImageRegion(
 }
 
 template<class TSegmenter>
-typename TSegmenter::LabelImageType::Pointer
+typename TSegmenter::GraphType
 MergeAllGraphsAndAchieveSegmentation(
     const typename TSegmenter::ParamType& params,
     const float& threshold,
@@ -63,13 +63,13 @@ MergeAllGraphsAndAchieveSegmentation(
       {
       std::cout << "Cleaning nodes of tile " << (row*nbTilesX + col) << " / " << (nbTilesX*nbTilesY) << std::endl;
 
-      std::unordered_map<long unsigned int,
+      std::unordered_map<std::size_t,
       std::vector<typename TSegmenter::NodePointerType> > borderPixelMap;
 
       std::cout << "\tBuildBorderPixelMap..." << std::endl;
 
       BuildBorderPixelMap<TSegmenter>(segmenter.m_Graph, tiles[row*nbTilesX + col], row, col,
-          nbTilesX, nbTilesY, borderPixelMap, imageWidth);
+          nbTilesX, nbTilesY, borderPixelMap, imageWidth, true);
 
       std::cout << "\tRemoveDuplicatedNodes..." << std::endl;
 
@@ -91,69 +91,42 @@ MergeAllGraphsAndAchieveSegmentation(
   segmenter.SetThreshold(threshold);
   segmenter.SetDoFastSegmentation(false); // was true
   segmenter.SetNumberOfIterations(numberOfIterations);
-
   grm::GraphOperations<TSegmenter>::PerfomAllIterationsWithLMBFAndConstThreshold(segmenter);
 
-  //  // Write output graph to the output graph directory
-  //  WriteGraph<TSegmenter>(segmenter.m_Graph, tmpDir, 0, 0);
-
-  // Generate the label image
-  typename TSegmenter::LabelImageType::IndexType index;
-  index.Fill(0);
-  typename TSegmenter::LabelImageType::SizeType size;
-  size[0] = imageWidth;
-  size[1] = imageHeight;
-  typename TSegmenter::LabelImageType::RegionType region(index, size);
-  const typename TSegmenter::LabelImageType::InternalPixelType noDataLabel = 0;
-  typename TSegmenter::LabelImageType::Pointer labelImage = TSegmenter::LabelImageType::New();
-  labelImage->SetRegions(region);
-  labelImage->Allocate();
-  labelImage->FillBuffer(noDataLabel);
-
-  using LabelImageIterator = itk::ImageRegionIterator<typename TSegmenter::LabelImageType>;
-  LabelImageIterator it(labelImage, labelImage->GetLargestPossibleRegion());
-
-  // Start at 1 (value 0 can be used for invalid pixels)
-  unsigned int label = 1;
-  for(auto& node : segmenter.m_Graph.m_Nodes)
-    {
-    lp::CellLists borderPixels;
-    lp::ContourOperations::GenerateBorderCells(borderPixels, node->m_Contour, node->m_Id, imageWidth);
-
-    for (auto& pix: borderPixels)
-      {
-      index[0] = pix % imageWidth;
-      index[1] = pix / imageWidth;
-      labelImage->SetPixel(index, label);
-      }
-    ++label;
-    }
-
-  // Re-order nodes labels (left->right to top->bottom)
-  vnl_vector<typename TSegmenter::LabelImageType::InternalPixelType> lut(label,noDataLabel);
-  label = 1;
-  for(it.GoToBegin();!it.IsAtEnd(); ++it)
-    {
-    unsigned int inputLabel = it.Get();
-    if (lut[ inputLabel ] == noDataLabel && inputLabel != noDataLabel)
-      {
-      lut[ inputLabel ] = label;
-      label++;
-      }
-    }
-
-  // Apply LUT
-  for(it.GoToBegin();!it.IsAtEnd(); ++it)
-    it.Set(lut[it.Get()]);
-
-  // Fill holes
-  typedef itk::GrayscaleFillholeImageFilter<typename TSegmenter::LabelImageType,
-      typename TSegmenter::LabelImageType> FillholeFilterType;
-  typename FillholeFilterType::Pointer fillFilter = FillholeFilterType::New();
-  fillFilter->SetInput(labelImage);
-  fillFilter->Update();
-
-  return fillFilter->GetOutput();}
+  // patch raf (sort using node id directly --> seems ok)
+  // Sort the nodes top-->down and left-->right
+  /*
+  std::sort(segmenter.m_Graph.m_Nodes.begin(), segmenter.m_Graph.m_Nodes.end(),
+      [imageWidth](const auto & a, const auto & b) -> bool
+  {
+    lp::CellLists borderPixelsA, borderPixelsB;
+    lp::ContourOperations::GenerateBorderCells(borderPixelsA, a->m_Contour, a->m_Id, imageWidth);
+    lp::ContourOperations::GenerateBorderCells(borderPixelsB, b->m_Contour, b->m_Id, imageWidth);
+
+	// patch raf (were unsigned int)
+    std::size_t offA = 0;
+    std::size_t offB = 0;
+	// end patch
+    for (auto& pix: borderPixelsA)
+      if (pix>offA)
+        offA=pix;
+
+    for (auto& pix: borderPixelsB)
+      if (pix>offB)
+        offB=pix;
+
+      return offA > offB;
+  });
+  */
+  std::sort(segmenter.m_Graph.m_Nodes.begin(), segmenter.m_Graph.m_Nodes.end(),
+      [](const auto & a, const auto & b) -> bool
+  {
+      return a->m_Id < b->m_Id;
+  });
+  // end patch
+
+  return segmenter.m_Graph;
+}
 
 template<class TSegmenter>
 long long unsigned int RunPartialSegmentation(const typename TSegmenter::ParamType& params,
@@ -198,7 +171,7 @@ long long unsigned int RunPartialSegmentation(const typename TSegmenter::ParamTy
               row, col, nbTilesX, nbTilesY);
 
           std::cout << "\tBuild border pixel map..." << std::endl;
-          std::unordered_map<long unsigned int, std::vector<typename TSegmenter::NodePointerType> > borderPixelMap;
+          std::unordered_map<std::size_t, std::vector<typename TSegmenter::NodePointerType> > borderPixelMap;
           BuildBorderPixelMap<TSegmenter>(segmenter.m_Graph, currentTile, row, col,
               nbTilesX, nbTilesY, borderPixelMap, imageWidth);
 
@@ -366,7 +339,7 @@ void RemoveUselessNodes(ProcessingTile& tile,
 }
 
 template<class TSegmenter>
-void UpdateNeighborsOfNoneDuplicatedNodes(std::unordered_map<long unsigned int,
+void UpdateNeighborsOfNoneDuplicatedNodes(std::unordered_map<std::size_t,
     std::vector<typename TSegmenter::NodePointerType> >& borderPixelMap,
     const unsigned int imageWidth,
     const unsigned int imageHeight)
@@ -376,7 +349,7 @@ void UpdateNeighborsOfNoneDuplicatedNodes(std::unordered_map<long unsigned int,
 
   for(auto& pn : borderPixelMap)
     {
-    long int neighborhood[4];
+    NeighIDType neighborhood[4];
     grm::FOURNeighborhood(neighborhood, pn.first, imageWidth, imageHeight);
 
     for(short j = 0; j < 4; ++j)
@@ -404,7 +377,7 @@ void UpdateNeighborsOfNoneDuplicatedNodes(std::unordered_map<long unsigned int,
                 {
                 if(borderPixelMap.find(pix) != borderPixelMap.end())
                   {
-                  long int pixNeighborhood[4];
+                  NeighIDType pixNeighborhood[4];
                   grm::FOURNeighborhood(pixNeighborhood, pix, imageWidth, imageHeight);
 
                   for(short k = 0; k < 4; k++)
@@ -431,7 +404,7 @@ void UpdateNeighborsOfNoneDuplicatedNodes(std::unordered_map<long unsigned int,
 }
 
 template<class TSegmenter>
-void RemoveDuplicatedNodes(std::unordered_map<long unsigned int,
+void RemoveDuplicatedNodes(std::unordered_map<std::size_t,
     std::vector<typename TSegmenter::NodePointerType> >& borderPixelMap,
     typename TSegmenter::GraphType& graph,
     const unsigned int imageWidth)
@@ -502,9 +475,10 @@ void BuildBorderPixelMap(typename TSegmenter::GraphType& graph,
     const unsigned int colTile,
     const unsigned int nbTilesX,
     const unsigned int nbTilesY,
-    std::unordered_map<long unsigned int,
+    std::unordered_map<std::size_t,
     std::vector<typename TSegmenter::NodePointerType> >& borderPixelMap,
-    const unsigned int imageWidth)
+    const unsigned int imageWidth,
+	bool merging)
 {
   unsigned int rowPixel, colPixel;
   unsigned int rowMin = (tile.rows[0] > 0) ? tile.rows[0] - 1 : tile.rows[0];
@@ -521,6 +495,15 @@ void BuildBorderPixelMap(typename TSegmenter::GraphType& graph,
       {
       continue;
       }
+	// patch raf (exclude nodes all outside tiles - on merging stage only)
+	else if(merging && (node->m_Bbox.m_UX > tile.columns[1] ||
+        node->m_Bbox.m_UY > tile.rows[1] ||
+        node->m_Bbox.m_UX + node->m_Bbox.m_W - 1 < tile.columns[0] ||
+        node->m_Bbox.m_UY + node->m_Bbox.m_H - 1 < tile.rows[0]))
+      {
+      continue;
+      }  
+	// end patch
     else
       {
       lp::CellLists borderPixels;
@@ -683,7 +666,7 @@ long long unsigned int RunFirstPartialSegmentation(
         segmenter.SetNumberOfIterations(niter);
         segmenter.SetInput(imageTile);
         segmenter.Update();
-
+		
         if(segmenter.GetComplete() == false)
           isFusion = true;
 
@@ -696,7 +679,7 @@ long long unsigned int RunFirstPartialSegmentation(
             tileWidth,
             tileHeight,
             imageWidth);
-
+			
         // Remove unstable segments
         std::cout << "\tRemoving unstable segments..." << std::endl;
         RemoveUnstableSegments<TSegmenter>(segmenter.m_Graph, currentTile, imageWidth);
@@ -1029,7 +1012,7 @@ void RescaleGraph(typename TSegmenter::GraphType& graph,
     // Start pixel index of the node (in the image)
     rowNodeImg = rowTile * tileHeight + rowNodeTile - tile.margin[0];
     colNodeImg = colTile * tileWidth + colNodeTile - tile.margin[3];
-    node->m_Id = rowNodeImg * imageWidth + colNodeImg;
+    node->m_Id = (std::size_t)rowNodeImg * (std::size_t)imageWidth + (std::size_t)colNodeImg;