Separate arcMap generation from writing to file

ContourTree/ContourTree.cpp

@@ -99,23 +99,19 @@ void ContourTree::computeCT() {
     }
 }
 
-void ContourTree::output(std::string fileName) {
-    std::cout << "removing deg-2 nodes and computing segmentation" << std::endl;
-
-    // saving some memory
-    nodesJoin.clear();
-    nodesJoin.shrink_to_fit();
-    nodesSplit.clear();
-    nodesSplit.shrink_to_fit();
+std::tuple<uint32_t, std::vector<int64_t>, std::vector<scalar_t>, std::vector<char>,
+           std::vector<int64_t>>
+ContourTree::computeArcMap() {
 
+    uint32_t arcNo = 0;
     std::vector<int64_t> nodeids;
     std::vector<scalar_t> nodefns;
     std::vector<char> nodeTypes;
     std::vector<int64_t> arcs;
 
     arcMap.resize(nv, -1);
 
-    uint32_t arcNo = 0;
+    for (int64_t i = 0; i < nv; i++) {
     for(int64_t i = 0;i < nv;i ++) {
         // go in sorted order
         int64_t v = tree->sv[i];
@@ -147,6 +143,20 @@ void ContourTree::output(std::string fileName) {
         }
     }
 
+    return {arcNo, nodeids, nodefns, nodeTypes, arcs};
+}
+}
+void ContourTree::output(std::string fileName) {
+    std::cout << "removing deg-2 nodes and computing segmentation" << std::endl;
+
+    // saving some memory
+    nodesJoin.clear();
+    nodesJoin.shrink_to_fit();
+    nodesSplit.clear();
+    nodesSplit.shrink_to_fit();
+
+    auto [arcNo, nodeids, nodefns, nodeTypes, arcs] = computeArcMap();
+
     // write meta data
     std::cout << "Writing meta data" << std::endl;
     {

ContourTree/ContourTree.hpp

@@ -4,6 +4,7 @@
 #include <string>
 #include <vector>
 
+#include "constants.h"
 namespace contourtree {
 
 class MergeTree;
@@ -22,6 +23,9 @@ class ContourTree
 
     void setup(const MergeTree * tree);
     void computeCT();
+    std::tuple<uint32_t, std::vector<int64_t>, std::vector<scalar_t>, std::vector<char>,
+               std::vector<int64_t>>
+    computeArcMap();
     void output(std::string fileName);
 
 private:

ContourTree/MergeTree.cpp

@@ -124,18 +124,21 @@ void MergeTree::computeSplitTree() {
     newRoot = in;
 }
 
-void MergeTree::output(std::string fileName, TreeType tree)
-{
-    if(tree == TypeContourTree) {
-        ctree.output(fileName);
-        return;
+const std::vector<uint32_t>& MergeTree::getArcMap(TreeType type) const {
+
+    if (type == TypeContourTree) {
+        return ctree.arcMap;
     }
-    // assume size of contour tree fits within 4 bytes
-    std::vector<uint32_t> arcMap;
-    if(newVertex) {
-        arcMap.resize(noVertices + 1,-1);
+    return arcMap;
+}
+
+std::tuple<uint32_t, uint32_t, std::vector<int64_t>, std::vector<scalar_t>, std::vector<char>,
+           std::vector<int64_t>>
+MergeTree::computeArcMap(TreeType tree) {
+    if (newVertex) {
+        arcMap.resize(noVertices + 1, -1);
     } else {
-        arcMap .resize(noVertices,-1);
+        arcMap.resize(noVertices, -1);
     }
     uint32_t noArcs = 0;
     uint32_t noNodes = 0;
@@ -149,15 +152,6 @@ void MergeTree::output(std::string fileName, TreeType tree)
     }
     noArcs = noNodes - 1;
 
-    // write meta data
-    std::cout << "Writing meta data" << std::endl;
-    {
-        std::ofstream pr(fileName + ".rg.dat");
-        pr << noNodes << "\n";
-        pr << noArcs << "\n";
-        pr.close();
-    }
-
     std::cout << ("Creating required memory!") << std::endl;
     std::vector<int64_t> nodeids(noNodes);
     std::vector<scalar_t> nodefns(noNodes);
@@ -262,6 +256,25 @@ void MergeTree::output(std::string fileName, TreeType tree)
         assert(arcNo == noArcs);
     }
 
+    return {noArcs, noNodes, nodeids, nodefns, nodeTypes, arcs};
+}
+
+void MergeTree::output(std::string fileName, TreeType tree) {
+    if (tree == TypeContourTree) {
+        ctree.output(fileName);
+        return;
+    }
+
+    auto [noArcs, noNodes, nodeids, nodefns, nodeTypes, arcs] = computeArcMap(tree);
+
+    // write meta data
+    std::cout << "Writing meta data" << std::endl;
+    {
+        std::ofstream pr(fileName + ".rg.dat");
+        pr << noNodes << "\n";
+        pr << noArcs << "\n";
+        pr.close();
+    }
     std::cout << "writing tree output" << std::endl;
     std::string rgFile = fileName + ".rg.bin";
     std::ofstream of(rgFile,std::ios::binary);

ContourTree/MergeTree.hpp

@@ -29,6 +29,9 @@ class MergeTree
     void computeTree(ScalarFunction* data, TreeType type);
     void computeJoinTree();
     void computeSplitTree();
+    std::tuple<uint32_t, uint32_t, std::vector<int64_t>, std::vector<scalar_t>, std::vector<char>,
+        std::vector<int64_t>> computeArcMap(TreeType tree);
+    const std::vector<uint32_t>& getArcMap(TreeType type) const;
     void output(std::string fileName, TreeType tree);
 
 protected:
@@ -53,6 +56,7 @@ class MergeTree
 
     std::set<int64_t> set;
     ContourTree ctree;
+    std::vector<uint32_t> arcMap;
 
 private:
     std::vector<int64_t> star;