Removed the force_empty_*_frame and made the exits and entrances fields space/time.

diff --git a/README.txt b/README.txt
index 2ce7e31..13cf224 100644 (file)
--- a/README.txt
+++ b/README.txt
@@ -64,9 +64,9 @@ The MTPTracker class allows
      - the allowed motions between them (a Boolean flag for each pair
        of locations from/to)
 
-     - the entrances (a Boolean flag for each location)
+     - the entrances (a Boolean flag for each location and time step)
 
-     - the exits (a Boolean flag for each location)
+     - the exits (a Boolean flag for each location and time step)
 
  (2) to define a number of time steps
 
@@ -106,11 +106,13 @@ bool:allowed_motion_from_1_to_1 ... bool:allowed_motion_from_1_to_L
 ...
 bool:allowed_motion_from_L_to_1 ... bool:allowed_motion_from_L_to_L
 
-bool:force_empty_first_frame bool:force_empty_last_frame
-
-bool:is_an_entrance_1 ... bool:is_an_entrance_L
+bool:entrance_1_1 ... bool:entrance_1_L
+...
+bool:entrance_T_1 ... bool:entrance_T_L
 
-bool:is_an_exit_1 ... bool:is_an_exit_L
+bool:exit_1_1 ... bool:exit_1_L
+...
+bool:exit_T_1 ... bool:exit_T_L
 
 float:detection_score_1_1 ... float:detection_score_1_L
 ...

diff --git a/mtp_example.cc b/mtp_example.cc
index 92d4062..2d6489e 100644 (file)
--- a/mtp_example.cc
+++ b/mtp_example.cc
@@ -54,18 +54,27 @@ int main(int argc, char **argv) {
 
   // Here our example is a 1D space with motions from any location to
   // any location less than motion_amplitude away, entrance at
-  // location 0 and exit at location nb_locations-1.
+  // location 0 (or in the first time frame, i.e. targets can already
+  // be in the scene when the sequence starts) and exit at location
+  // nb_locations-1 (or from the last time frame, i.e. target can
+  // still be present when the sequence finishes)
 
   for(int l = 0; l < nb_locations; l++) {
-    for(int k = 0; k < nb_locations; k++) {
-      tracker->allowed_motion[l][k] = abs(l - k) <= motion_amplitude;
+    for(int m = 0; m < nb_locations; m++) {
+      tracker->allowed_motion[l][m] = abs(l - m) <= motion_amplitude;
     }
-    tracker->entrances[0] = 1;
-    tracker->exits[nb_locations - 1] = 1;
   }
 
-  tracker->force_empty_first_frame = 0;
-  tracker->force_empty_last_frame = 0;
+  for(int t = 0; t < nb_time_steps; t++) {
+    for(int l = 0; l < nb_locations; l++) {
+      // We allow targets to enter in the first time frame, or in
+      // location 0
+      tracker->entrances[t][l] = (t == 0 || l == 0);
+      // We allow targets to leave from the last time frame, or from
+      // location nb_locations-1
+      tracker->exits[t][l] = (t == nb_time_steps - 1 || l == nb_locations-1);
+    }
+  }
 
   // We construct the graph corresponding to this structure
 

diff --git a/mtp_tracker.cc b/mtp_tracker.cc
index b4e70ab..b91a000 100644 (file)
--- a/mtp_tracker.cc
+++ b/mtp_tracker.cc
@@ -33,8 +33,8 @@ void MTPTracker::free() {
   delete _graph;
   deallocate_array<scalar_t>(detection_scores);
   deallocate_array<int>(allowed_motion);
-  delete[] exits;
-  delete[] entrances;
+  deallocate_array<int>(exits);
+  deallocate_array<int>(entrances);
 }
 
 void MTPTracker::allocate(int t, int l) {
@@ -46,12 +46,10 @@ void MTPTracker::allocate(int t, int l) {
   detection_scores = allocate_array<scalar_t>(nb_time_steps, nb_locations);
   allowed_motion = allocate_array<int>(nb_locations, nb_locations);
 
-  entrances = new int[nb_locations];
-  exits = new int[nb_locations];
+  entrances = allocate_array<int>(nb_time_steps, nb_locations);
+  exits = allocate_array<int>(nb_time_steps, nb_locations);
 
   for(int l = 0; l < nb_locations; l++) {
-    entrances[l] = 0;
-    exits[l] = 0;
     for(int m = 0; m < nb_locations; m++) {
       allowed_motion[l][m] = 0;
     }
@@ -60,12 +58,11 @@ void MTPTracker::allocate(int t, int l) {
   for(int t = 0; t < nb_time_steps; t++) {
     for(int l = 0; l < nb_locations; l++) {
       detection_scores[t][l] = 0.0;
+      entrances[t][l] = 0;
+      exits[t][l] = 0;
     }
   }
 
-  force_empty_first_frame = 0;
-  force_empty_last_frame = 0;
-
   _edge_lengths = 0;
   _graph = 0;
 }
@@ -84,20 +81,20 @@ void MTPTracker::write(ostream *os) {
 
   (*os) << endl;
 
-  (*os) << force_empty_first_frame << " " << force_empty_last_frame << endl;
-
-  (*os) << endl;
-
-  for(int l = 0; l < nb_locations; l++) {
-    (*os) << entrances[l];
-    if(l < nb_locations - 1) (*os) << " "; else (*os) << endl;
+  for(int t = 0; t < nb_time_steps; t++) {
+    for(int l = 0; l < nb_locations; l++) {
+      (*os) << entrances[t][l];
+      if(l < nb_locations - 1) (*os) << " "; else (*os) << endl;
+    }
   }
 
   (*os) << endl;
 
-  for(int l = 0; l < nb_locations; l++) {
-    (*os) << exits[l];
-    if(l < nb_locations - 1) (*os) << " "; else (*os) << endl;
+  for(int t = 0; t < nb_time_steps; t++) {
+    for(int l = 0; l < nb_locations; l++) {
+      (*os) << exits[t][l];
+      if(l < nb_locations - 1) (*os) << " "; else (*os) << endl;
+    }
   }
 
   (*os) << endl;
@@ -123,14 +120,16 @@ void MTPTracker::read(istream *is) {
     }
   }
 
-  (*is) >> force_empty_first_frame >> force_empty_last_frame;
-
-  for(int l = 0; l < nb_locations; l++) {
-    (*is) >> entrances[l];
+  for(int t = 0; t < nb_time_steps; t++) {
+    for(int l = 0; l < nb_locations; l++) {
+      (*is) >> entrances[t][l];
+    }
   }
 
-  for(int l = 0; l < nb_locations; l++) {
-    (*is) >> exits[l];
+  for(int t = 0; t < nb_time_steps; t++) {
+    for(int l = 0; l < nb_locations; l++) {
+      (*is) >> exits[t][l];
+    }
   }
 
   for(int t = 0; t < nb_time_steps; t++) {
@@ -173,8 +172,8 @@ MTPTracker::~MTPTracker() {
   delete _graph;
   deallocate_array<scalar_t>(detection_scores);
   deallocate_array<int>(allowed_motion);
-  delete[] exits;
-  delete[] entrances;
+  deallocate_array<int>(entrances);
+  deallocate_array<int>(exits);
 }
 
 int MTPTracker::early_pair_node(int t, int l) {
@@ -193,8 +192,10 @@ void MTPTracker::build_graph() {
   int nb_motions = 0, nb_exits = 0, nb_entrances = 0;
 
   for(int l = 0; l < nb_locations; l++) {
-    if(exits[l]) nb_exits++;
-    if(entrances[l]) nb_entrances++;
+    for(int t = 0; t < nb_time_steps; t++) {
+      if(exits[t][l]) nb_exits++;
+      if(entrances[t][l]) nb_entrances++;
+    }
     for(int m = 0; m < nb_locations; m++) {
       if(allowed_motion[l][m]) nb_motions++;
     }
@@ -204,28 +205,13 @@ void MTPTracker::build_graph() {
 
   int nb_edges =
     // The edges from the source to the entrances and from 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) +
+    // to the sink
+    nb_exits + nb_entrances +
     // 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;
 
-  // Edges from the source to the first frame
-  if(force_empty_first_frame) {
-    nb_edges += nb_entrances;
-  } else {
-    nb_edges += nb_locations;
-  }
-
-  // Edges from the last frame to the sink
-  if(force_empty_last_frame) {
-    nb_edges += nb_exits;
-  } else {
-    nb_edges += nb_locations;
-  }
-
   int *node_from = new int[nb_edges];
   int *node_to = new int[nb_edges];
 
@@ -246,28 +232,6 @@ void MTPTracker::build_graph() {
     }
   }
 
-  // The edges from the source to the first time frame
-
-  for(int l = 0; l < nb_locations; l++) {
-    if(!force_empty_first_frame || entrances[l]) {
-      node_from[e] = source;
-      node_to[e] = 1 + l + 0 * nb_locations;
-      _edge_lengths[e] = 0.0;
-      e++;
-    }
-  }
-
-  // The edges from the last frame to the sink
-
-  for(int l = 0; l < nb_locations; l++) {
-    if(!force_empty_last_frame || exits[l]) {
-      node_from[e] = late_pair_node(nb_time_steps - 1, l);
-      node_to[e] = sink;
-      _edge_lengths[e] = 0.0;
-      e++;
-    }
-  }
-
   // The edges between frames, corresponding to allowed motions
 
   for(int t = 0; t < nb_time_steps - 1; t++) {
@@ -288,13 +252,13 @@ void MTPTracker::build_graph() {
 
   for(int t = 0; t < nb_time_steps; t++) {
     for(int l = 0; l < nb_locations; l++) {
-      if(t > 0 && entrances[l]) {
+      if(entrances[t][l]) {
         node_from[e] = source;
         node_to[e] = early_pair_node(t, l);
         _edge_lengths[e] = 0.0;
         e++;
       }
-      if(t < nb_time_steps - 1 && exits[l]) {
+      if(exits[t][l]) {
         node_from[e] = late_pair_node(t, l);
         node_to[e] = sink;
         _edge_lengths[e] = 0.0;

diff --git a/mtp_tracker.h b/mtp_tracker.h
index 1dcb94c..01c831b 100644 (file)
--- a/mtp_tracker.h
+++ b/mtp_tracker.h
@@ -48,8 +48,7 @@ public:
   // The spatial structure
   int nb_locations, nb_time_steps;
   int **allowed_motion;
-  int *entrances, *exits;
-  int force_empty_first_frame, force_empty_last_frame;
+  int **entrances, **exits;
 
   // The detection scores at each location and time
   scalar_t **detection_scores;