Added the copy_graph() routine.

dlib/graph_utils/graph_utils.h

@@ -351,6 +351,67 @@ namespace dlib
         }
     }
 
+// ----------------------------------------------------------------------------------------
+
+    template <
+        typename graph_type1,
+        typename graph_type2
+        >
+    typename enable_if<is_graph<graph_type1> >::type copy_graph (
+        const graph_type1& src,
+        graph_type2& dest
+    )
+    {
+        COMPILE_TIME_ASSERT(is_graph<graph_type1>::value);
+        COMPILE_TIME_ASSERT(is_graph<graph_type2>::value);
+        if (graph_helpers::is_same_object(src,dest))
+            return;
+
+        copy_graph_structure(src,dest);
+
+        // copy all the node and edge content 
+        for (unsigned long i = 0; i < src.number_of_nodes(); ++i)
+        {
+            dest.node(i).data = src.node(i).data;
+
+            for (unsigned long j = 0; j < src.node(i).number_of_neighbors(); ++j)
+            {
+                const unsigned long nidx = src.node(i).neighbor(j).index();
+                if (nidx >= i)
+                {
+                    dest.node(i).edge(j) = src.node(i).edge(j);
+                }
+            }
+        }
+    }
+
+    template <
+        typename graph_type1,
+        typename graph_type2
+        >
+    typename enable_if<is_directed_graph<graph_type1> >::type copy_graph (
+        const graph_type1& src,
+        graph_type2& dest
+    )
+    {
+        COMPILE_TIME_ASSERT(is_directed_graph<graph_type1>::value);
+        COMPILE_TIME_ASSERT(is_directed_graph<graph_type2>::value);
+        if (graph_helpers::is_same_object(src,dest))
+            return;
+
+        copy_graph_structure(src,dest);
+
+        // copy all the node and edge content 
+        for (unsigned long i = 0; i < src.number_of_nodes(); ++i)
+        {
+            dest.node(i).data = src.node(i).data;
+            for (unsigned long j = 0; j < src.node(i).number_of_children(); ++j)
+            {
+                dest.node(i).child_edge(j) = src.node(i).child_edge(j);
+            }
+        }
+    }
+
 // ----------------------------------------------------------------------------------------
 
     template <

dlib/graph_utils/graph_utils_abstract.h

@@ -183,6 +183,29 @@ namespace dlib
                     - #dest.has_edge(i,j) == true
     !*/
 
+// ----------------------------------------------------------------------------------------
+
+    template <
+        typename src_type,
+        typename dest_type 
+        >
+    void copy_graph (
+        const src_type& src,
+        dest_type& dest
+    );
+    /*!
+        requires
+            - src_type is an implementation of directed_graph/directed_graph_kernel_abstract.h or
+              src_type is an implementation of graph/graph_kernel_abstract.h
+            - dest_type is an implementation of directed_graph/directed_graph_kernel_abstract.h or
+              dest_type is an implementation of graph/graph_kernel_abstract.h
+            - src_type and dest_type are both the same kind of graph.  That is, they
+              are either both directed or both undirected.
+            - the node and edge data in the graphs are copyable via operator=().
+        ensures
+            - #dest is a complete duplicate of src.
+    !*/
+
 // ----------------------------------------------------------------------------------------
 
     template <

dlib/test/directed_graph.cpp

@@ -445,6 +445,66 @@ namespace
     }
 
 
+    void test_copy()
+    {
+        {
+            directed_graph<int,int>::kernel_1a_c a,b;
+
+            a.set_number_of_nodes(3);
+            a.node(0).data = 1;
+            a.node(1).data = 2;
+            a.node(2).data = 3;
+            a.add_edge(0,1);
+            a.add_edge(1,0);
+            a.add_edge(0,2);
+            edge(a,0,1) = 4;
+            edge(a,1,0) = 3;
+            edge(a,0,2) = 5;
+
+            a.add_edge(0,0);
+            edge(a,0,0) = 9;
+            copy_graph(a, b);
+
+            DLIB_TEST(b.number_of_nodes() == 3);
+            DLIB_TEST(b.node(0).data == 1);
+            DLIB_TEST(b.node(1).data == 2);
+            DLIB_TEST(b.node(2).data == 3);
+            DLIB_TEST(edge(b,0,1) == 4);
+            DLIB_TEST(edge(b,1,0) == 3);
+            DLIB_TEST(edge(b,0,2) == 5);
+            DLIB_TEST(edge(b,0,0) == 9);
+        }
+        {
+            directed_graph<int,int>::kernel_1a_c a,b;
+
+            a.set_number_of_nodes(4);
+            a.node(0).data = 1;
+            a.node(1).data = 2;
+            a.node(2).data = 3;
+            a.node(3).data = 8;
+            a.add_edge(0,1);
+            a.add_edge(0,2);
+            a.add_edge(2,3);
+            a.add_edge(3,2);
+            edge(a,0,1) = 4;
+            edge(a,0,2) = 5;
+            edge(a,2,3) = 6;
+            edge(a,3,2) = 3;
+
+            copy_graph(a, b);
+
+            DLIB_TEST(b.number_of_nodes() == 4);
+            DLIB_TEST(b.node(0).data == 1);
+            DLIB_TEST(b.node(1).data == 2);
+            DLIB_TEST(b.node(2).data == 3);
+            DLIB_TEST(b.node(3).data == 8);
+            DLIB_TEST(edge(b,0,1) == 4);
+            DLIB_TEST(edge(b,0,2) == 5);
+            DLIB_TEST(edge(b,2,3) == 6);
+            DLIB_TEST(edge(b,3,2) == 3);
+        }
+    }
+
 
 
     class directed_graph_tester : public tester
@@ -465,6 +525,8 @@ namespace
         void perform_test (
         )
         {
+            test_copy();
+
             dlog << LINFO << "testing kernel_1a_c";
             directed_graph_test<directed_graph<int,unsigned short>::kernel_1a_c>();
 

dlib/test/graph.cpp

@@ -323,6 +323,59 @@ namespace
     }
 
 
+    void test_copy()
+    {
+        {
+            graph<int,int>::kernel_1a_c a,b;
+
+            a.set_number_of_nodes(3);
+            a.node(0).data = 1;
+            a.node(1).data = 2;
+            a.node(2).data = 3;
+            a.add_edge(0,1);
+            a.add_edge(0,2);
+            edge(a,0,1) = 4;
+            edge(a,0,2) = 5;
+
+            a.add_edge(0,0);
+            edge(a,0,0) = 9;
+            copy_graph(a, b);
+
+            DLIB_TEST(b.number_of_nodes() == 3);
+            DLIB_TEST(b.node(0).data == 1);
+            DLIB_TEST(b.node(1).data == 2);
+            DLIB_TEST(b.node(2).data == 3);
+            DLIB_TEST(edge(b,0,1) == 4);
+            DLIB_TEST(edge(b,0,2) == 5);
+            DLIB_TEST(edge(b,0,0) == 9);
+        }
+        {
+            graph<int,int>::kernel_1a_c a,b;
+
+            a.set_number_of_nodes(4);
+            a.node(0).data = 1;
+            a.node(1).data = 2;
+            a.node(2).data = 3;
+            a.node(3).data = 8;
+            a.add_edge(0,1);
+            a.add_edge(0,2);
+            a.add_edge(2,3);
+            edge(a,0,1) = 4;
+            edge(a,0,2) = 5;
+            edge(a,2,3) = 6;
+
+            copy_graph(a, b);
+
+            DLIB_TEST(b.number_of_nodes() == 4);
+            DLIB_TEST(b.node(0).data == 1);
+            DLIB_TEST(b.node(1).data == 2);
+            DLIB_TEST(b.node(2).data == 3);
+            DLIB_TEST(b.node(3).data == 8);
+            DLIB_TEST(edge(b,0,1) == 4);
+            DLIB_TEST(edge(b,0,2) == 5);
+            DLIB_TEST(edge(b,2,3) == 6);
+        }
+    }
 
 
 
@@ -349,6 +402,8 @@ namespace
 
             dlog << LINFO << "testing kernel_1a";
             graph_test<graph<int>::kernel_1a>();
+
+            test_copy();
         }
     } a;