X-Git-Url: https://fleuret.org/cgi-bin/gitweb/gitweb.cgi?a=blobdiff_plain;f=tracker.cc;h=0d1d781ede1febbc57ad39fe50dc48451dcf83f0;hb=f2f1701bfeb50ecb468489d58a59741400d1d791;hp=4b7375f26ffcf99d965f6bd5ac1a1f28af10aac5;hpb=8db91faf223fcb893b589c7b85d4ef5e03ffb6ce;p=mtp.git diff --git a/tracker.cc b/tracker.cc index 4b7375f..0d1d781 100644 --- a/tracker.cc +++ b/tracker.cc @@ -25,61 +25,99 @@ 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(nb_time_steps, nb_locations); - _allowed_motion = allocate_array(nb_locations, nb_locations); + + _detection_score = allocate_array(_nb_time_steps, _nb_locations); + _allowed_motion = allocate_array(_nb_locations, _nb_locations); + + _entrances = new int[_nb_locations]; + _exits = new int[_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; } } + for(int t = 0; t < _nb_time_steps; t++) { + for(int l = 0; l < _nb_locations; l++) { + _detection_score[t][l] = 0.0; + } + } + _edge_lengths = 0; _graph = 0; - _edge_occupation = 0; } Tracker::~Tracker() { delete[] _edge_lengths; delete _graph; - delete[] _edge_occupation; deallocate_array(_detection_score); deallocate_array(_allowed_motion); + delete[] _exits; + delete[] _entrances; } void Tracker::set_allowed_motion(int from_location, int to_location, int v) { + ASSERT(from_location >= 0 && from_location < _nb_locations && + to_location >= 0 && to_location < _nb_locations); _allowed_motion[from_location][to_location] = v; } +void Tracker::set_as_entrance(int location, int v) { + ASSERT(location >= 0 && location < _nb_locations); + _entrances[location] = v; +} + +void Tracker::set_as_exit(int location, int v) { + ASSERT(location >= 0 && location < _nb_locations); + _exits[location] = v; +} + void Tracker::set_detection_score(int time, int location, scalar_t score) { + ASSERT(time >= 0 && time < _nb_time_steps && + location >= 0 && location < _nb_locations); _detection_score[time][location] = score; } void Tracker::build_graph() { - - // Delete existing graph + // Delete existing graph if there was one delete[] _edge_lengths; - delete[] _graph; - delete[] _edge_occupation; + delete _graph; + + int nb_motions = 0, nb_exits = 0, nb_entrances = 0; - int nb_motions = 0; for(int l = 0; l < _nb_locations; l++) { + if(_exits[l]) nb_exits++; + if(_entrances[l]) nb_entrances++; for(int m = 0; m < _nb_locations; m++) { if(_allowed_motion[l][m]) nb_motions++; } } int nb_vertices = 2 + 2 * _nb_time_steps * _nb_locations; - int nb_edges = _nb_locations * 2 - + (_nb_time_steps - 1) * nb_motions - + _nb_locations * _nb_time_steps; - int source = 0, sink = nb_vertices - 1; + 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 exists + // to the sink (in every time frames but the first and last) + (_nb_time_steps - 1) * (nb_exits + nb_entrances) + + // The edges for the motions, between every pair of successive + // frames + (_nb_time_steps - 1) * nb_motions + + // The edges inside the duplicated nodes + _nb_locations * _nb_time_steps; + int *node_from = new int[nb_edges]; int *node_to = new int[nb_edges]; + + int source = 0, sink = nb_vertices - 1; int e = 0; _edge_lengths = new scalar_t[nb_edges]; - _edge_occupation = new int[nb_edges]; // We put the in-node edges first, since these are the ones whose // lengths we will have to change according to the detection score @@ -92,8 +130,6 @@ void Tracker::build_graph() { } } - // We put the other edges after - for(int l = 0; l < _nb_locations; l++) { node_from[e] = source; node_to[e] = 1 + l + 0 * _nb_locations; @@ -121,6 +157,23 @@ void Tracker::build_graph() { } } + for(int t = 0; t < _nb_time_steps; t++) { + 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; + _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_to[e] = sink; + _edge_lengths[e] = 0.0; + e++; + } + } + } + _graph = new MTPGraph(nb_vertices, nb_edges, node_from, node_to, source, sink); @@ -129,18 +182,28 @@ void Tracker::build_graph() { delete[] node_to; } +void Tracker::print_graph_dot(ostream *os) { + int e = 0; + for(int t = 0; t < _nb_time_steps; t++) { + for(int l = 0; l < _nb_locations; l++) { + _edge_lengths[e++] = - _detection_score[t][l]; + } + } + _graph->print_dot(os); +} + void Tracker::track() { int e = 0; for(int t = 0; t < _nb_time_steps; t++) { for(int l = 0; l < _nb_locations; l++) { - _edge_lengths[e] = - _detection_score[t][l]; - e++; + _edge_lengths[e++] = - _detection_score[t][l]; } } - _graph->find_best_paths(_edge_lengths, _edge_occupation); - _graph->retrieve_paths(); + _graph->find_best_paths(_edge_lengths); + _graph->retrieve_disjoint_paths(); +#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]; @@ -149,20 +212,21 @@ void Tracker::track() { } cout << endl; } - // _graph->print_dot(); +#endif } -// void Tracker::track() { -// } - -// int Tracker::nb_trajectories() { -// } +int Tracker::nb_trajectories() { + return _graph->nb_paths; +} -// int Tracker::trajectory_start_time(int k) { -// } +int Tracker::trajectory_entrance_time(int k) { + return (_graph->paths[k]->nodes[1] - 1) / (2 * _nb_locations); +} -// int Tracker::trajectory_end_time(int k) { -// } +int Tracker::trajectory_duration(int k) { + return (_graph->paths[k]->length - 2) / 2; +} -// int Tracker::trajectory_location(int k, int time) { -// } +int Tracker::trajectory_location(int k, int time) { + return (_graph->paths[k]->nodes[2 * time + 1] - 1) % _nb_locations; +}