particle_track.h

Go to the documentation of this file.

//Copyright 2008-2010 Thomas A Caswell
//tcaswell@uchicago.edu
//http://jfi.uchicago.edu/~tcaswell
//
//This program is free software; you can redistribute it and/or modify
//it under the terms of the GNU General Public License as published by
//the Free Software Foundation; either version 3 of the License, or (at
//your option) any later version.
//
//This program is distributed in the hope that it will be useful, but
//WITHOUT ANY WARRANTY; without even the implied warranty of
//MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
//General Public License for more details.
//
//You should have received a copy of the GNU General Public License
//along with this program; if not, see <http://www.gnu.org/licenses>.
//
//Additional permission under GNU GPL version 3 section 7
//
//If you modify this Program, or any covered work, by linking or
//combining it with MATLAB (or a modified version of that library),
//containing parts covered by the terms of MATLAB User License, the
//licensors of this Program grant you additional permission to convey
//the resulting work.
#include "particle_base.h"

#include <utility>
#include <list>
// namespace utilities{
// class Tuple;
// }

#ifndef PARTICLE_TRACK
#define PARTICLE_TRACK
namespace tracking{
class Track_box;
class Hash_shelf;
class hash_case;

class particle_track :public particle_base{
  
  
public:
  
  friend class Track_box;
  friend class track_list;

  


  
  particle_track(int i_ind,int frame);

  particle_track(int i_ind,utilities::Tuplef pos,unsigned int frame);


  ~particle_track();


  void print_t(int more)const;

  const particle_track* get_next()const{return next_;}

  particle_track* get_next(){return next_;}

  const particle_track* get_prev()const{return prev_;}

  particle_track* get_prev(){return prev_;}
  const utilities::Tuplef get_corrected_disp(const particle_track * part_in)const;
  
  bool step_forwards(int n,const particle_track* & next)const;

  
   bool step_backwards(int n,const particle_track* & next)const;


  


  Track_box* get_track()const;

  int get_track_id()const;

  const Hash_shelf* get_shelf()const{
    return shelf_;
  }
  void set_shelf(Hash_shelf* shelf);
  
  float distancesq_corrected(const particle_track* part_in)const;
  
  bool has_track()const;
  
  bool has_next()const;
  const utilities::Tuplef get_corrected_pos()const;
  
    
  std::list<std::pair<particle_track*, float> >* n_pos_link;
  std::list<std::pair<particle_track*, float> >* p_pos_link;

  

  int get_value(utilities::D_TYPE type,int &val) const;
  float get_value(utilities::D_TYPE type,float &val) const;
  std::complex<float> get_value(utilities::D_TYPE type,std::complex<float>& val) const;
  

private:
  particle_track* next_;
  particle_track* prev_;
  Track_box * track_;

  Hash_shelf* shelf_;

  bool step_backwards(int n, particle_track* & next);
  bool step_forwards(int n,particle_track* & next);  
  

  
  

  void set_track(Track_box* i_track);


  particle_track* reset_track(Track_box * i_track,int & count);
  
  void clear_next()
  {
    next_ = NULL;
  }
  void clear_prev()
  {
    prev_ = NULL;
  }
  
  void set_next(particle_track* n_next);

  void set_prev(particle_track* n_prev);

  
  void clear_track_data();

  void clear_data_forward();
  
  void clear_data_backward();


};
}
#endif