The tracker seems to work.

diff --git a/mtp.cc b/mtp.cc
index 118e521..bd6d296 100644 (file)
--- a/mtp.cc
+++ b/mtp.cc
@@ -34,6 +34,7 @@
 using namespace std;
 
 #include "mtp_graph.h"
+#include "tracker.h"
 
 //////////////////////////////////////////////////////////////////////
 
@@ -45,25 +46,30 @@ void find_best_paths(int nb_vertices,
   graph.find_best_paths(el, result_edge_occupation);
 }
 
-void dot_print(int nb_vertices,
-               int nb_edges, int *ea, int *eb, scalar_t *el,
-               int source, int sink,
-               int *edge_occupation) {
-  cout << "digraph {" << endl;
-  cout << "  node[shape=circle];" << endl;
-  for(int e = 0; e < nb_edges; e++) {
-    if(edge_occupation[e]) {
-      cout << "  " << ea[e] << " -> " << eb[e] << " [style=bold,color=black,label=\"" << el[e] << "\"];" << endl;
-    } else {
-      cout << "  " << ea[e] << " -> " << eb[e] << " [color=gray,label=\"" << el[e] << "\"];" << endl;
+//////////////////////////////////////////////////////////////////////
+
+int main(int argc, char **argv) {
+  int nb_locations = 3;
+  int nb_time_steps = 4;
+
+  Tracker tracker(nb_time_steps, nb_locations);
+
+  for(int l = 0; l < nb_locations; l++) {
+    for(int k = 0; k < nb_locations; k++) {
+      if(abs(l - k) <= 1) tracker.set_allowed_motion(l, k);
     }
   }
-  cout << "}" << endl;
-}
 
-//////////////////////////////////////////////////////////////////////
+  for(int t = 0; t < nb_time_steps; t++) {
+    for(int l = 0; l < nb_locations; l++) {
+      tracker.set_detection_score(t, l, -1.0);
+    }
+    tracker.set_detection_score(t, 0, 1.0);
+  }
 
-int main(int argc, char **argv) {
+  tracker.track();
+
+  exit(0);
 
   if(argc < 2) {
     cerr << argv[0] << " <graph file>" << endl;

diff --git a/mtp_graph.cc b/mtp_graph.cc
index fe74dd1..eb4d3cc 100644 (file)
--- a/mtp_graph.cc
+++ b/mtp_graph.cc
@@ -236,3 +236,19 @@ void MTPGraph::find_best_paths(scalar_t *lengths, int *result_edge_occupation) {
     }
   }
 }
+
+void dot_print(int nb_vertices,
+               int nb_edges, int *ea, int *eb, scalar_t *el,
+               int source, int sink,
+               int *edge_occupation) {
+  cout << "digraph {" << endl;
+  cout << "  node[shape=circle];" << endl;
+  for(int e = 0; e < nb_edges; e++) {
+    if(edge_occupation[e]) {
+      cout << "  " << ea[e] << " -> " << eb[e] << " [style=bold,color=black,label=\"" << el[e] << "\"];" << endl;
+    } else {
+      cout << "  " << ea[e] << " -> " << eb[e] << " [color=gray,label=\"" << el[e] << "\"];" << endl;
+    }
+  }
+  cout << "}" << endl;
+}

diff --git a/mtp_graph.h b/mtp_graph.h
index 072eeec..9c14ea2 100644 (file)
--- a/mtp_graph.h
+++ b/mtp_graph.h
@@ -43,4 +43,9 @@ public:
   void print();
 };
 
+void dot_print(int nb_vertices,
+               int nb_edges, int *ea, int *eb, scalar_t *el,
+               int source, int sink,
+               int *edge_occupation);
+
 #endif

diff --git a/tracker.cc b/tracker.cc
index 0a76e08..e0b0903 100644 (file)
--- a/tracker.cc
+++ b/tracker.cc
@@ -18,10 +18,14 @@
 
 #include "tracker.h"
 
-Tracker::Tracker(int nb_locations, int nb_time_steps) {
+#include <iostream>
+
+using namespace std;
+
+Tracker::Tracker(int nb_time_steps, int nb_locations) {
   _nb_locations = nb_locations;
   _nb_time_steps = nb_time_steps;
-  _detection_score = allocate_array<scalar_t>(nb_locations, nb_time_steps);
+  _detection_score = allocate_array<scalar_t>(nb_time_steps, nb_locations);
   _allowed_motion = allocate_array<int>(nb_locations, nb_locations);
   for(int l = 0; l < nb_locations; l++) {
     for(int m = 0; m < nb_locations; m++) {
@@ -37,12 +41,13 @@ void Tracker::set_allowed_motion(int from_location, int to_location) {
   _allowed_motion[from_location][to_location] = 1;
 }
 
-void Tracker::set_detection_score(int location, int time, scalar_t score) {
+void Tracker::set_detection_score(int time, int location, scalar_t score) {
+  _detection_score[time][location] = score;
 }
 
 void Tracker::track() {
 
-  cout << "Building graph." << endl;
+  cerr << "Building graph." << endl;
 
   int nb_motions = 0;
   for(int l = 0; l < _nb_locations; l++) {
@@ -51,55 +56,70 @@ void Tracker::track() {
     }
   }
 
-  int nb_vertices = 2 + 2 * (_nb_time_steps + 1) * _nb_locations;
+  int nb_vertices = 2 + 2 * _nb_time_steps * _nb_locations;
   int nb_edges = _nb_locations * 2    // From source and to sink
-    + _nb_time_steps * nb_motions     // Motions
+    + (_nb_time_steps - 1) * nb_motions     // Motions
     + _nb_locations * _nb_time_steps; // Doubling of nodes to force
                                       // one target per location
 
   int source = 0, sink = nb_vertices - 1;
   int *node_from = new int[nb_edges];
   int *node_to = new int[nb_edges];
-  scalar_t *edge_length = new scalar_t[nb_edges];
+  scalar_t *edge_lengths = new scalar_t[nb_edges];
   int e = 0;
 
   for(int l = 0; l < _nb_locations; l++) {
     node_from[e] = source;
     node_to[e] = 1 + l + 0 * _nb_locations;
-    edge_length[e] = 0.0;
+    edge_lengths[e] = 0.0;
     e++;
   }
 
-  for(int t = 0; t <= _nb_time_steps; t++) {
+  for(int t = 0; t < _nb_time_steps; t++) {
     for(int l = 0; l < _nb_locations; l++) {
       node_from[e] = 1 + (2 * (t + 0) + 0) * _nb_locations + l;
       node_to[e] =   1 + (2 * (t + 0) + 1) * _nb_locations + l;
-      edge_length[e] = _detection_score[t][l];
+      edge_lengths[e] = - _detection_score[t][l];
       e++;
-      if(t == _nb_time_steps) {
-        node_from[e] = 1 + (2 * (t + 0) + 0) * _nb_locations + l;
+      if(t == _nb_time_steps - 1) {
+        node_from[e] = 1 + (2 * (t + 0) + 1) * _nb_locations + l;
         node_to[e] =   sink;
-        edge_length[e] = 0;
+        edge_lengths[e] = 0.0;
         e++;
       } else {
         for(int k = 0; k < _nb_locations; k++) {
           if(_allowed_motion[l][k]) {
             node_from[e] = 1 + (2 * (t + 0) + 1) * _nb_locations + l;
             node_to[e] =   1 + (2 * (t + 1) + 0) * _nb_locations + k;
-            edge_length[e] = 0.0;
+            edge_lengths[e] = 0.0;
             e++;
           }
         }
       }
     }
   }
+
+  cerr << "DEBUG e = " << e << " nb_edges = " << nb_edges << endl;
+
+  _graph = new MTPGraph(nb_vertices, nb_edges, node_from, node_to, source, sink);
+
+  int *edge_occupation = new int[nb_edges];
+
+  _graph->find_best_paths(edge_lengths, edge_occupation);
+
+  dot_print(nb_vertices, nb_edges, node_from, node_to, edge_lengths,
+            source, sink,
+            edge_occupation);
+
+  delete[] edge_occupation;
+  delete _graph;
 }
 
 // void Tracker::track() {
   // int e = _nb_locations;
   // for(int t = 0; t <= _nb_time_steps; t++) {
     // for(int l = 0; l < _nb_locations; l++) {
-      // edge_length[e] = _detection_score[t][l];
+      // edge_lengths[e] = _detection_score[t][l];
       // e++;
       // if(t == _nb_time_steps) {
         // e++;
@@ -110,14 +130,14 @@ void Tracker::track() {
   // }
 // }
 
-int Tracker::nb_trajectories() {
-}
+// int Tracker::nb_trajectories() {
+// }
 
-int Tracker::trajectory_start_time(int k) {
-}
+// int Tracker::trajectory_start_time(int k) {
+// }
 
-int Tracker::trajectory_end_time(int k) {
-}
+// int Tracker::trajectory_end_time(int k) {
+// }
 
-int Tracker::trajectory_location(int k, int time) {
-}
+// int Tracker::trajectory_location(int k, int time) {
+// }

diff --git a/tracker.h b/tracker.h
index d37e46a..4143cf5 100644 (file)
--- a/tracker.h
+++ b/tracker.h
@@ -29,19 +29,18 @@ class Tracker {
   int **_allowed_motion;
 
 public:
-  Tracker(int nb_locations, int nb_time_steps);
+  Tracker(int nb_time_steps, int nb_locations);
   ~Tracker();
 
   void set_allowed_motion(int from_location, int to_location);
-  void set_detection_score(int location, int time, scalar_t score);
-  void make_graph();
+  void set_detection_score(int time, int location, scalar_t score);
 
   void track();
 
-  int nb_trajectories();
-  int trajectory_start_time(int k);
-  int trajectory_end_time(int k);
-  int trajectory_location(int k, int time);
+  // int nb_trajectories();
+  // int trajectory_start_time(int k);
+  // int trajectory_end_time(int k);
+  // int trajectory_location(int k, int time);
 };
 
 #endif