polyora/tracks.h

Go to the documentation of this file.

/*  This file is part of Polyora, a multi-target tracking library.
    Copyright (C) 2010 Julien Pilet

    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 2 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/>.

    To contact the author of this program, please send an e-mail to:
    julien.pilet(at)calodox.org
*/
#ifndef TRACKS_H
#define TRACKS_H

#include "mlist.h"
#include "bucket2d.h"


struct tframe;
struct ttrack;
struct tracks;

struct point2d {
        float u,v;

        point2d(float u, float v) : u(u), v(v) {}
        point2d() {}

        float dist(const point2d &a);
};

struct tkeypoint : point2d {

        mlist_elem<tkeypoint> points_in_frame;

        mlist_elem<tkeypoint> matches;

        tframe *frame;

        ttrack *track;

        tkeypoint() { frame=0; track=0; }
        tkeypoint(const tkeypoint &a) : point2d(a), frame(0), track(0) {}

        void set(tframe *f, float u, float v); 
        const tkeypoint &operator = (const tkeypoint &a);

        int track_length();

        bool track_is_longer(int l);

        virtual void dispose() { delete this; }
        virtual ~tkeypoint();


        void unlink();

        struct factory_t {
                virtual tkeypoint *create() { return new tkeypoint(); }
                virtual void destroy(tkeypoint *a) { delete a; } 
        };
};

class tracks;

struct tframe {
        bucket2d<tkeypoint> points;

        mlist_elem<tframe> frames;

        tframe(int w, int h, int bits) : points(w,h,bits) {}

        virtual void append_to(tracks &track);

        virtual ~tframe() {}

        bool has_point_in(float u, float v, float r);

        struct factory_t {
                virtual void destroy(tframe *a) { delete a; } 
        };
};

struct ttrack {

        mlist_elem<ttrack> track_node;

        tkeypoint *keypoints;

        tracks *db;

        int length;

        ttrack(tracks *db) : db(db) { keypoints=0; length=0; }
        virtual ~ttrack() {}

        virtual void point_added(tkeypoint *) { length++; }

        virtual void point_removed(tkeypoint *) { length--; }

        struct factory_t {
                virtual ttrack *create(tracks *db) { return new ttrack(db); }
                virtual void destroy(ttrack *a) { delete a; } 
        };
};

class tracks {
public:

        tracks(tkeypoint::factory_t *kf=0, tframe::factory_t *ff=0, ttrack::factory_t *tf = 0);
        ~tracks();
        
        void set_match(tkeypoint *prev, tkeypoint *next);

        void unset_match(tkeypoint *k);

        struct frame_iterator {
                tframe *frame;
                tframe *operator ++() { return frame = frame->frames.next; }
                tframe *operator --() { return frame = frame->frames.prev; }
                bool end() { return frame == 0; }
                frame_iterator(tracks *t) { frame = t->frames; }
                frame_iterator(tframe *f) { frame = f; }
                tframe *elem() { return frame; }
        };

        frame_iterator get_nth_frame_it(int n);

        tframe *get_nth_frame(int n);

        typedef bucket2d<tkeypoint>::iterator keypoint_frame_iterator;

        struct keypoint_match_iterator {
                tkeypoint *point;
                tkeypoint *operator ++() { return point = point->matches.next; }
                tkeypoint *operator --() { return point = point->matches.prev; }
                tkeypoint &operator ->() { return *point; }
                tkeypoint *elem() { return point; }
                bool end() { return point==0; }
                keypoint_match_iterator(tkeypoint *p) : point(p) {}
        };

        void remove_point_track(tkeypoint *point);

        void remove_track_tail(tkeypoint *point);

        void remove_unmatched_tracks(frame_iterator frame_it);

        void remove_empty_frames();
                
        void remove_frame(frame_iterator &f);

        void remove_frame(tframe *frame);

        tframe *frames;
        ttrack *all_tracks;

        tkeypoint::factory_t *keypoint_factory;
        tframe::factory_t *tframe_factory;
        ttrack::factory_t *ttrack_factory;
};

inline float point2d::dist(const point2d &a)
{
        float du = u-a.u;
        float dv = v-a.v;
        return sqrtf(du*du + dv*dv);
}

inline bool tkeypoint::track_is_longer(int l) {
    if (!track) return l==0;
    return track->length >=l;
    /*
                tkeypoint *p=this->matches.prev;
                for(int i=l;i;--i) {
                        if (p==0) return false;
                        p=p->matches.prev;
                }
                return true;
                */
}

#endif

---