REFAC: functions use ProcesingTiles instead of many numeric and string variables

include/lsgrmController.h

@@ -49,13 +49,12 @@ public:
   typename LabelImageType::Pointer GetLabeledClusteredOutput();
 
   itkGetMacro(Margin, unsigned int);
-  itkGetMacro(TemporaryFilesList, std::vector<std::string>);
 
-  itkGetMacro(CleanTemporaryDirectory, bool);
-  itkSetMacro(CleanTemporaryDirectory, bool);
+  itkGetMacro(CleanTemporaryFiles, bool);
+  itkSetMacro(CleanTemporaryFiles, bool);
 
-  itkGetMacro(TemporaryDirectory, std::string);
-  itkSetMacro(TemporaryDirectory, std::string);
+  itkGetMacro(TemporaryFilesPrefix, std::string);
+  itkSetMacro(TemporaryFilesPrefix, std::string);
 
   itkGetMacro(Threshold, float);
   itkSetMacro(Threshold, float);
@@ -94,8 +93,8 @@ private:
   long unsigned int GetMaximumNumberOfNodesInMemory();
 
   /* Parameters given by the user */
-  std::string m_TemporaryDirectory;      // Directory used to store intermediate files during the process.
-  bool        m_CleanTemporaryDirectory; // Clean the temporary directory.
+  std::string m_TemporaryFilesPrefix;    // Path used to store intermediate files during the process.
+  bool        m_CleanTemporaryFiles;     // Clean temporary files
   ImageType * m_InputImage;              // Input image
 
   /* Segmentation parameters */
@@ -117,7 +116,6 @@ 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
-  std::vector<std::string>           m_TemporaryFilesList; // list of temporary files
   typename LabelImageType::Pointer   m_LabelImage;         // output label image
 };
 } // end of namespace lsgrm

include/lsgrmController.txx

@@ -14,7 +14,7 @@ Controller<TSegmenter>::Controller()
   m_TileWidth = 0;
   m_NbTilesX = 0;
   m_NbTilesY = 0;
-  m_CleanTemporaryDirectory = true;
+  m_CleanTemporaryFiles = true;
   m_Threshold = 75;
   m_Memory = 0;
 }
@@ -53,8 +53,8 @@ void Controller<TSegmenter>::RunSegmentation()
         "\n\tTiling layout: " << m_NbTilesX << " x " << m_NbTilesY << std::endl;
 
     // Compute the splitting scheme
-    SplitOTBImage<ImageType>(m_InputImage, m_TileWidth, m_TileHeight, m_Margin,
-        m_NbTilesX, m_NbTilesY, m_Tiles);
+    m_Tiles = SplitOTBImage<ImageType>(m_InputImage, m_TileWidth, m_TileHeight, m_Margin,
+        m_NbTilesX, m_NbTilesY, m_TemporaryFilesPrefix);
 
     // Boolean indicating if there are remaining fusions
     bool isFusion = false;
@@ -72,9 +72,7 @@ void Controller<TSegmenter>::RunSegmentation()
         m_NbTilesY,
         m_TileWidth,
         m_TileHeight,
-        m_TemporaryDirectory,
         isFusion);
-    //    long long unsigned int accumulatedMemory = 19373051714;
 
     // Update the given number of iterations
     numberOfIterationsRemaining -= m_NumberOfFirstIterations;
@@ -96,7 +94,6 @@ void Controller<TSegmenter>::RunSegmentation()
           m_Threshold,
           numberOfIterationsForPartialSegmentations,
           m_Tiles,
-          m_TemporaryDirectory,
           m_NbTilesX,
           m_NbTilesY,
           m_InputImage->GetLargestPossibleRegion().GetSize()[0],
@@ -127,7 +124,6 @@ void Controller<TSegmenter>::RunSegmentation()
           m_SpecificParameters,
           m_Threshold,
           m_Tiles,
-          m_TemporaryDirectory,
           m_NbTilesX,
           m_NbTilesY,
           m_InputImage->GetLargestPossibleRegion().GetSize()[0],
@@ -176,7 +172,7 @@ unsigned int Controller<TSegmenter>::GetNodeMemory()
   lsrm::GraphOperations<TSegmenter>::InitNodes(onePixelImage,segmenter,FOUR);
 
   unsigned int memory = segmenter.GetGraphMemory() / (n*n);
-  itkWarningMacro(<<"Size of a node is " << memory);
+  itkDebugMacro(<<"Size of a node is " << memory);
   return memory;
 }
 
@@ -198,7 +194,8 @@ long unsigned int Controller<TSegmenter>::GetMaximumNumberOfNodesInMemory()
 }
 
 template<class TSegmenter>
-void Controller<TSegmenter>::ComputeMaximumStabilityMargin(unsigned int width,
+void
+Controller<TSegmenter>::ComputeMaximumStabilityMargin(unsigned int width,
     unsigned int height, unsigned int &niter, unsigned int &margin)
     {
   itkDebugMacro(<< "Computing maximum stability margin");
@@ -331,7 +328,7 @@ void Controller<TSegmenter>::GetAutomaticConfiguration()
   long long unsigned int memoryUsed = GetNodeMemory();
   memoryUsed *= static_cast<long long unsigned int>(m_TileHeight + 2*m_Margin);
   memoryUsed *= static_cast<long long unsigned int>(m_TileWidth + 2*m_Margin);
-  itkWarningMacro(<< "An amount of " << memoryUsed/(1024.0*1024.0) << " Mbytes of RAM will be used for regular tiles of size "
+  itkDebugMacro(<< "An amount of " << memoryUsed/(1024.0*1024.0) << " Mbytes of RAM will be used for regular tiles of size "
       << (m_TileWidth + 2*m_Margin) << "x" << (m_TileHeight + 2*m_Margin) );
 
 }

include/lsgrmGraphOperations.h

@@ -16,6 +16,12 @@ struct ProcessingTile
   long int tileNeighbors[8]; // tile Neighbors at (top, top right, right, bottom right, bottom, bottom left, left, top left)
   long int margin[4]; // Is there a margin at top, left, bottom or right
   otb::VectorImage<double>::RegionType region; // The image region
+
+  // Temporary files
+  std::string nodeFileName;
+  std::string edgeFileName;
+  std::string nodeMarginFileName;
+  std::string edgeMarginFileName;
 };
 
 // Read an image region
@@ -30,7 +36,6 @@ MergeAllGraphsAndAchieveSegmentation(
     const typename TSegmenter::ParameterType& params,
     const float& threshold,
     std::vector<ProcessingTile>& tiles,
-    const std::string& tmpDir,
     const unsigned int nbTilesX,
     const unsigned int nbTilesY,
     const unsigned int imageWidth,
@@ -50,7 +55,6 @@ long long unsigned int RunFirstPartialSegmentation(
     const unsigned int nbTilesY,
     const unsigned int tileWidth,
     const unsigned int tileHeight,
-    const std::string& tmpDir,
     bool& isFusion);
 
 template<class TSegmenter>
@@ -59,7 +63,6 @@ long long unsigned int RunPartialSegmentation(
     const float& threshold,
     const unsigned int niter,
     std::vector<ProcessingTile>& tiles,
-    const std::string& tmpDir,
     const unsigned int nbTilesX,
     const unsigned int nbTilesY,
     const unsigned int imageWidth,
@@ -101,9 +104,13 @@ void BuildBorderPixelMap(typename TSegmenter::GraphType& graph,
     std::vector<typename TSegmenter::NodePointerType> >& borderPixelMap,
     const unsigned int imageWidth);
 
+template<class TSegmenter>
+void InsertNodesFromTile(typename TSegmenter::GraphType& graph,
+    ProcessingTile& tile, bool margin = true);
+
 template<class TSegmenter>
 void AddStabilityMargin(typename TSegmenter::GraphType& graph,
-    const std::string& tmpDir,
+    std::vector<ProcessingTile>& tiles,
     const unsigned int row,
     const unsigned int col,
     const unsigned int nbTilesX,
@@ -134,18 +141,19 @@ void DetectBorderNodes(typename TSegmenter::GraphType& graph,
     const unsigned int imageHeight);
 
 template<class TSegmenter>
-void ReadGraph(typename TSegmenter::GraphType& graph,
+void ReadGraph(TSegmenter& segmenter,
     const std::string& nodesPath,
     const std::string& edgesPath);
 
 template<class TSegmenter>
-void WriteGraph(typename TSegmenter::GraphType& graph,
-    const std::string& tmpDir,
-    const unsigned int row,
-    const unsigned int col);
+void ReadGraph(typename TSegmenter::GraphType& graph,
+    const std::string& nodesPath,
+    const std::string& edgesPath);
 
 template<class TSegmenter>
-long long unsigned int GetGraphMemory(TSegmenter segmenter);
+void WriteGraph(typename TSegmenter::GraphType& graph,
+    const std::string& nodesFile,
+    const std::string& edgesFile);
 
 template<class TSegmenter>
 void RemoveUnstableSegments(typename TSegmenter::GraphType& graph,

include/lsgrmGraphOperations.txx

@@ -27,7 +27,6 @@ MergeAllGraphsAndAchieveSegmentation(
     const typename TSegmenter::ParameterType& params,
     const float& threshold,
     std::vector<ProcessingTile>& tiles,
-    const std::string& tmpDir,
     const unsigned int nbTilesX,
     const unsigned int nbTilesY,
     const unsigned int imageWidth,
@@ -36,16 +35,16 @@ MergeAllGraphsAndAchieveSegmentation(
     unsigned int numberOfIterations)
 {
 
-  // TODO parallelize this ...
+  std::cout << "--- Graph aggregation...\n" << std::endl;
+
+  // TODO parallelize this ?
 #ifdef OTB_USE_MPI
   if (otb::MPIConfig::Instance()->GetMyRank() != 0)
     return;
 #endif
 
   TSegmenter segmenter;
-  std::string nodesPath, edgesPath;
 
-  std::cout << "--- Graph aggregation...\n" << std::endl;
 
   std::cout << "Reading graphs" << std::endl;
 
@@ -55,16 +54,7 @@ MergeAllGraphsAndAchieveSegmentation(
       {
       std::cout << "\tImporting graph of tile " << (row*nbTilesX + col) << " / " << (nbTilesX*nbTilesY) << std::endl;
 
-      typename TSegmenter::GraphType graph;
-
-      // Load the graph
-      nodesPath = tmpDir + "tile_nodes_" + std::to_string(row) + "_" + std::to_string(col) + ".bin";
-      edgesPath = tmpDir + "tile_edges_" + std::to_string(row) + "_" + std::to_string(col) + ".bin";
-      ReadGraph<TSegmenter>(graph, nodesPath, edgesPath);
-
-      segmenter.m_Graph.m_Nodes.insert(segmenter.m_Graph.m_Nodes.end(),
-          graph.m_Nodes.begin(),
-          graph.m_Nodes.end());
+      InsertNodesFromTile<TSegmenter>(segmenter.m_Graph, tiles[row*nbTilesX + col], false);
       }
     }
 
@@ -95,7 +85,6 @@ MergeAllGraphsAndAchieveSegmentation(
       }
     }
 
-
   std::cout << "Achieve segmentation process" ;
 
   // Segmentation of the graph
@@ -121,7 +110,6 @@ long long unsigned int RunPartialSegmentation(const typename TSegmenter::Paramet
     const float& threshold,
     const unsigned int niter,
     std::vector<ProcessingTile>& tiles,
-    const std::string& tmpDir,
     const unsigned int nbTilesX,
     const unsigned int nbTilesY,
     const unsigned int imageWidth,
@@ -130,7 +118,6 @@ long long unsigned int RunPartialSegmentation(const typename TSegmenter::Paramet
     bool& isFusion)
 {
   long long unsigned int accumulatedMemory = 0;
-  std::string nodesPath, edgesPath;
   isFusion = false;
 
   const unsigned int numberOfNeighborLayers = static_cast<unsigned int>(pow(2, niter + 1) - 2);
@@ -143,28 +130,27 @@ long long unsigned int RunPartialSegmentation(const typename TSegmenter::Paramet
       {
       if (MyTurn(row*nbTilesX + col))
         {
+        // Get the current tile
+        ProcessingTile currentTile = tiles[row*nbTilesX + col];
+
         TSegmenter segmenter;
         std::cout << "Processing tile " << row << ", " << col << std::endl;
         std::cout << "\tLoad graph..." << std::endl;
 
         // Load the graph
-        nodesPath = tmpDir + "tile_nodes_" + std::to_string(row) + "_" + std::to_string(col) + ".bin";
-        edgesPath = tmpDir + "tile_edges_" + std::to_string(row) + "_" + std::to_string(col) + ".bin";
-        ReadGraph<TSegmenter>(segmenter.m_Graph, nodesPath, edgesPath);
-
+        ReadGraph<TSegmenter>(segmenter.m_Graph, currentTile.nodeFileName, currentTile.edgeFileName);
 
         // Add stability margin to the graph
         {
           std::cout << "\tAdd stability margin..." << std::endl;
-          AddStabilityMargin<TSegmenter>(segmenter.m_Graph, tmpDir,
+          AddStabilityMargin<TSegmenter>(segmenter.m_Graph, tiles,
               row, col, nbTilesX, nbTilesY);
 
-
           std::unordered_map<long unsigned int,
           std::vector<typename TSegmenter::NodePointerType> > borderPixelMap;
 
           std::cout << "\tBuild border pixel map..." << std::endl;
-          BuildBorderPixelMap<TSegmenter>(segmenter.m_Graph, tiles[row*nbTilesX + col], row, col,
+          BuildBorderPixelMap<TSegmenter>(segmenter.m_Graph, currentTile, row, col,
               nbTilesX, nbTilesY, borderPixelMap, imageWidth);
 
           std::cout << "\tRemove duplicated nodes..." << std::endl;
@@ -176,7 +162,7 @@ long long unsigned int RunPartialSegmentation(const typename TSegmenter::Paramet
               imageHeight);
 
           std::cout << "\tRemove useless.." << std::endl;
-          RemoveUselessNodes<TSegmenter>(tiles[row*nbTilesX + col], segmenter.m_Graph,
+          RemoveUselessNodes<TSegmenter>(currentTile, segmenter.m_Graph,
               row, col, nbTilesX, nbTilesY, imageWidth, numberOfNeighborLayers);
 
         }
@@ -198,15 +184,15 @@ long long unsigned int RunPartialSegmentation(const typename TSegmenter::Paramet
 
         // Remove unstable segments
         std::cout << "\tRemove unstable segments..." << std::endl;
-        RemoveUnstableSegments<TSegmenter>(segmenter.m_Graph, tiles[row*nbTilesX + col], imageWidth);
+        RemoveUnstableSegments<TSegmenter>(segmenter.m_Graph, currentTile, imageWidth);
 
         // Retrieve the amount of memory to store this graph
         std::cout << "\tGet graph memory..." << std::endl;
-        accumulatedMemory += GetGraphMemory<TSegmenter>(segmenter);
+        accumulatedMemory += segmenter.GetGraphMemory();
 
-        // Write graph to temporay directory (warning specific to Baatz & Schape !!!)
+        // Write graph to temporay directory
         std::cout << "\tWrite graph..." << std::endl;
-        WriteGraph<TSegmenter>(segmenter.m_Graph, tmpDir, row, col);
+        WriteGraph<TSegmenter>(segmenter.m_Graph, currentTile.nodeFileName, currentTile.edgeFileName);
         }
       }
     }
@@ -224,32 +210,24 @@ long long unsigned int RunPartialSegmentation(const typename TSegmenter::Paramet
       {
       if (MyTurn(row*nbTilesX + col))
         {
-        //                  std::cout << "*" << std::flush;
-        typename TSegmenter::GraphType graph;
+        // Get current tile
+        ProcessingTile currentTile = tiles[row*nbTilesX + col];
 
         // Load the graph
-        nodesPath = tmpDir + "tile_nodes_" + std::to_string(row) + "_" + std::to_string(col) + ".bin";
-        edgesPath = tmpDir + "tile_edges_" + std::to_string(row) + "_" + std::to_string(col) + ".bin";
-        ReadGraph<TSegmenter>(graph, nodesPath, edgesPath);
+        typename TSegmenter::GraphType graph;
+        ReadGraph<TSegmenter>(graph, currentTile.nodeFileName, currentTile.edgeFileName);
 
         // Extract stability margin for all borders different from 0 imageWidth-1 et imageHeight -
         // and write them to the stability margin
         {
           std::unordered_map<typename TSegmenter::NodePointerType, unsigned int> borderNodeMap;
 
-          DetectBorderNodes<TSegmenter>(graph, tiles[row*nbTilesX + col],
+          DetectBorderNodes<TSegmenter>(graph, currentTile,
               borderNodeMap, imageWidth, imageHeight);
 
-
           ExtractStabilityMargin<TSegmenter>(borderNodeMap, numberOfNeighborLayers);
 
-          std::string nodesPath = tmpDir + "tile_nodes_margin_" +
-              std::to_string(row) + "_" + std::to_string(col) + ".bin";
-          std::string edgesPath = tmpDir + "tile_edges_margin_" +
-              std::to_string(row) + "_" + std::to_string(col) + ".bin";
-
-
-          WriteStabilityMargin<TSegmenter>(borderNodeMap, nodesPath, edgesPath);
+          WriteStabilityMargin<TSegmenter>(borderNodeMap, currentTile.nodeMarginFileName, currentTile.edgeMarginFileName);
         }
         std::cout << "Process finished on tile " << (row*nbTilesX + col) << std::endl;
         }
@@ -529,156 +507,79 @@ void BuildBorderPixelMap(typename TSegmenter::GraphType& graph,
     }
 }
 
+template<class TSegmenter>
+void InsertNodesFromTile(typename TSegmenter::GraphType& graph,
+    ProcessingTile& tile, bool margin = true)
+{
+  typename TSegmenter::GraphType subgraph;
+  if (margin)
+    {
+    ReadGraph<TSegmenter>(subgraph, tile.nodeMarginFileName, tile.edgeMarginFileName);
+    }
+  else
+    {
+    ReadGraph<TSegmenter>(subgraph, tile.nodeFileName, tile.edgeFileName);
+    }
+
+  graph.m_Nodes.insert(graph.m_Nodes.end(), subgraph.m_Nodes.begin(), subgraph.m_Nodes.end());
+
+}
+
 template<class TSegmenter>
 void AddStabilityMargin(typename TSegmenter::GraphType& graph,
-    const std::string& tmpDir,
+    std::vector<ProcessingTile>& tiles,
     const unsigned int row,
     const unsigned int col,
     const unsigned int nbTilesX,
     const unsigned int nbTilesY)
 {
-  std::string nodesPath;
-  std::string edgesPath;
-  unsigned int rowNeigh;
-  unsigned int colNeigh;
 
   // Margin to retrieve at top
   if(row > 0)
     {
-    colNeigh = col;
-    rowNeigh = row-1;
-
-    nodesPath = tmpDir + "tile_nodes_margin_" +
-        std::to_string(rowNeigh) + "_" + std::to_string(colNeigh) + ".bin";
-
-    edgesPath = tmpDir + "tile_edges_margin_" +
-        std::to_string(rowNeigh) + "_" + std::to_string(colNeigh) + ".bin";
-
-    typename TSegmenter::GraphType subgraph;
-    ReadGraph<TSegmenter>(subgraph, nodesPath, edgesPath);
-    graph.m_Nodes.insert(graph.m_Nodes.end(), subgraph.m_Nodes.begin(), subgraph.m_Nodes.end());
+    InsertNodesFromTile<TSegmenter>(graph, tiles[(row-1) * nbTilesX + col]);
     }
 
   // Margin to retrieve at right
   if(col < nbTilesX - 1)
     {
-    colNeigh = col + 1;
-    rowNeigh = row;
-
-    nodesPath = tmpDir + "tile_nodes_margin_" +
-        std::to_string(rowNeigh) + "_" + std::to_string(colNeigh) + ".bin";
-
-    edgesPath = tmpDir + "tile_edges_margin_" +
-        std::to_string(rowNeigh) + "_" + std::to_string(colNeigh) + ".bin";
-
-    typename TSegmenter::GraphType subgraph;
-    ReadGraph<TSegmenter>(subgraph, nodesPath, edgesPath);
-
-    graph.m_Nodes.insert(graph.m_Nodes.end(), subgraph.m_Nodes.begin(), subgraph.m_Nodes.end());
-
+    InsertNodesFromTile<TSegmenter>(graph, tiles[row * nbTilesX + (col+1)]);
     }
 
   // Margin to retrieve at bottom
   if(row < nbTilesY - 1)
     {
-    colNeigh = col;
-    rowNeigh = row + 1;
-
-    nodesPath = tmpDir + "tile_nodes_margin_" +
-        std::to_string(rowNeigh) + "_" + std::to_string(colNeigh) + ".bin";
-
-    edgesPath = tmpDir + "tile_edges_margin_" +
-        std::to_string(rowNeigh) + "_" + std::to_string(colNeigh) + ".bin";
-
-    typename TSegmenter::GraphType subgraph;
-    ReadGraph<TSegmenter>(subgraph, nodesPath, edgesPath);
-    graph.m_Nodes.insert(graph.m_Nodes.end(), subgraph.m_Nodes.begin(), subgraph.m_Nodes.end());
-
+    InsertNodesFromTile<TSegmenter>(graph, tiles[(row+1) * nbTilesX + col]);
     }
 
   // Margin to retrieve at left
   if(col > 0)
     {
-    colNeigh = col-1;
-    rowNeigh = row;
-
-    nodesPath = tmpDir + "tile_nodes_margin_" +
-        std::to_string(rowNeigh) + "_" + std::to_string(colNeigh) + ".bin";
-
-    edgesPath = tmpDir + "tile_edges_margin_" +
-        std::to_string(rowNeigh) + "_" + std::to_string(colNeigh) + ".bin";
+    InsertNodesFromTile<TSegmenter>(graph, tiles[row * nbTilesX + (col-1)]);