Cleaned up the ambiguous synthetic example.

[mtp.git] / tracker.cc

diff --git a/tracker.cc b/tracker.cc
index f5dffd8..d3397cf 100644 (file)
--- a/tracker.cc
+++ b/tracker.cc
@@ -59,8 +59,16 @@ Tracker::~Tracker() {
   delete[] entrances;
 }
 
+int Tracker::early_pair_node(int t, int l) {
+  return 1 + (2 * (t + 0) + 0) * _nb_locations + l;
+}
+
+int Tracker::late_pair_node(int t, int l) {
+  return 1 + (2 * (t + 0) + 1) * _nb_locations + l;
+}
+
 void Tracker::build_graph() {
-  // Delete existing graph if there was one
+  // Delete the existing graph if there was one
   delete[] _edge_lengths;
   delete _graph;
 
@@ -81,11 +89,10 @@ void Tracker::build_graph() {
     // frame to the sink
     _nb_locations * 2 +
     // The edges from the source to the entrances and from the exists
-    // to the sink (in every time frames but the first for the source,
-    // and last for the exits)
+    // to the sink (in every time frames but the first for the
+    // entrances, and last for the exits)
     (_nb_time_steps - 1) * (nb_exits + nb_entrances) +
-    // The edges for the motions, between every pair of successive
-    // frames
+    // The edges for the motions, between every successive frames
     (_nb_time_steps - 1) * nb_motions +
     // The edges inside the duplicated nodes
     _nb_locations * _nb_time_steps;
@@ -99,13 +106,13 @@ void Tracker::build_graph() {
   _edge_lengths = new scalar_t[nb_edges];
 
   // We put the in-node edges first, since these are the ones whose
-  // lengths we will have to set later, according to the detection
-  // scores
+  // lengths we will have to change before tracking, according to the
+  // detection scores
 
   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;
+      node_from[e] = early_pair_node(t, l);
+      node_to[e] = late_pair_node(t, l);
       e++;
     }
   }
@@ -120,15 +127,15 @@ void Tracker::build_graph() {
   for(int t = 0; t < _nb_time_steps; t++) {
     for(int l = 0; l < _nb_locations; l++) {
       if(t == _nb_time_steps - 1) {
-        node_from[e] = 1 + (2 * (t + 0) + 1) * _nb_locations + l;
+        node_from[e] = late_pair_node(t, l);
         node_to[e] = sink;
         _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;
+            node_from[e] = late_pair_node(t, l);
+            node_to[e] = early_pair_node(t+1, k);
             _edge_lengths[e] = 0.0;
             e++;
           }
@@ -141,12 +148,12 @@ void Tracker::build_graph() {
     for(int l = 0; l < _nb_locations; l++) {
       if(t > 0 && entrances[l]) {
         node_from[e] = source;
-        node_to[e] =   1 + (2 * (t + 0) + 0) * _nb_locations + l;
+        node_to[e] = early_pair_node(t, l);
         _edge_lengths[e] = 0.0;
         e++;
       }
       if(t < _nb_time_steps - 1 && exits[l]) {
-        node_from[e] =   1 + (2 * (t + 0) + 1) * _nb_locations + l;
+        node_from[e] = late_pair_node(t, l);
         node_to[e] = sink;
         _edge_lengths[e] = 0.0;
         e++;
@@ -186,8 +193,8 @@ void Tracker::track() {
 #ifdef VERBOSE
   for(int p = 0; p < _graph->nb_paths; p++) {
     Path *path = _graph->paths[p];
-    cout << "PATH " << p << " [length " << path->length << "] " << path->nodes[0];
-    for(int n = 1; n < path->length; n++) {
+    cout << "PATH " << p << " [length " << path->nb_nodes << "] " << path->nodes[0];
+    for(int n = 1; n < path->nb_nodes; n++) {
       cout << " -> " << path->nodes[n];
     }
     cout << endl;
@@ -199,14 +206,18 @@ int Tracker::nb_trajectories() {
   return _graph->nb_paths;
 }
 
+scalar_t Tracker::trajectory_score(int k) {
+  return -_graph->paths[k]->length;
+}
+
 int Tracker::trajectory_entrance_time(int k) {
   return (_graph->paths[k]->nodes[1] - 1) / (2 * _nb_locations);
 }
 
 int Tracker::trajectory_duration(int k) {
-  return (_graph->paths[k]->length - 2) / 2;
+  return (_graph->paths[k]->nb_nodes - 2) / 2;
 }
 
-int Tracker::trajectory_location(int k, int time) {
-  return (_graph->paths[k]->nodes[2 * time + 1] - 1) % _nb_locations;
+int Tracker::trajectory_location(int k, int time_from_entry) {
+  return (_graph->paths[k]->nodes[2 * time_from_entry + 1] - 1) % _nb_locations;
 }