delete[] _edge_lengths;
delete _graph;
deallocate_array<scalar_t>(detection_scores);
- deallocate_array<int>(allowed_motion);
- delete[] exits;
- delete[] entrances;
+ deallocate_array<int>(allowed_motions);
+ deallocate_array<int>(exits);
+ deallocate_array<int>(entrances);
}
void MTPTracker::allocate(int t, int l) {
nb_time_steps = t;
detection_scores = allocate_array<scalar_t>(nb_time_steps, nb_locations);
- allowed_motion = allocate_array<int>(nb_locations, nb_locations);
+ allowed_motions = 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;
+ allowed_motions[l][m] = 0;
}
}
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;
}
}
}
void MTPTracker::write(ostream *os) {
- (*os) << nb_locations << " " << nb_time_steps <<endl;
+ (*os) << nb_locations << " " << nb_time_steps << endl;
(*os) << endl;
for(int l = 0; l < nb_locations; l++) {
for(int m = 0; m < nb_locations; m++) {
- (*os) << allowed_motion[l][m];
+ (*os) << allowed_motions[l][m];
if(m < nb_locations - 1) (*os) << " "; else (*os) << 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;
for(int l = 0; l < nb_locations; l++) {
for(int m = 0; m < nb_locations; m++) {
- (*is) >> allowed_motion[l][m];
+ (*is) >> allowed_motions[l][m];
}
}
- 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++) {
nb_time_steps = 0;
detection_scores = 0;
- allowed_motion = 0;
+ allowed_motions = 0;
entrances = 0;
exits = 0;
delete[] _edge_lengths;
delete _graph;
deallocate_array<scalar_t>(detection_scores);
- deallocate_array<int>(allowed_motion);
- delete[] exits;
- delete[] entrances;
+ deallocate_array<int>(allowed_motions);
+ deallocate_array<int>(entrances);
+ deallocate_array<int>(exits);
}
int MTPTracker::early_pair_node(int t, int l) {
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++;
+ if(allowed_motions[l][m]) nb_motions++;
}
}
int nb_vertices = 2 + 2 * nb_time_steps * nb_locations;
int nb_edges =
- // The edges from the source to the first frame, and from the last
- // frame to the sink
- nb_locations * 2 +
// 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
}
}
- // The edges from the source to the first time frame
-
- for(int l = 0; l < nb_locations; 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++) {
- 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++) {
for(int l = 0; l < nb_locations; l++) {
for(int k = 0; k < nb_locations; k++) {
- if(allowed_motion[l][k]) {
+ if(allowed_motions[l][k]) {
node_from[e] = late_pair_node(t, l);
node_to[e] = early_pair_node(t+1, k);
_edge_lengths[e] = 0.0;
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;