tracking_trajectory.h

Go to the documentation of this file.

/* =========================================================================== *
   |
   |  Copyright (c) 1994-2011 by Kobus Barnard (author)
   |
   |  Personal and educational use of this code is granted, provided that this
   |  header is kept intact, and that the authorship is not misrepresented, that
   |  its use is acknowledged in publications, and relevant papers are cited.
   |
   |  For other use contact the author (kobus AT cs DOT arizona DOT edu).
   |
   |  Please note that the code in this file has not necessarily been adequately
   |  tested. Naturally, there is no guarantee of performance, support, or fitness
   |  for any particular task. Nonetheless, I am interested in hearing about
   |  problems that you encounter.
   |
   |  Author:  Kyle Simek, Ernesto Brau, Jinyan Guan
 * =========================================================================== */

/* $Id: tracking_trajectory.h 18658 2015-03-18 14:44:28Z ernesto $ */

#ifndef TRACKING_TRAJECTORY_H
#define TRACKING_TRAJECTORY_H

#include <tracking_cpp/tracking_entity.h>
#include <l_cpp/l_exception.h>
#include <l_cpp/l_word_list.h>
#include <l/l_sys_io.h>
#include <m_cpp/m_vector.h>
#include <string>
#include <map>
#include <algorithm>
#include <vector>
#include <fstream>
#include <iterator>
#include <boost/optional.hpp>
#include <boost/foreach.hpp>
#include <boost/lambda/lambda.hpp>
#include <boost/algorithm/string.hpp>
#include <boost/format.hpp>
#include <boost/lexical_cast.hpp>

namespace kjb {
namespace tracking {

// forward declarations
template <class T>
class Generic_trajectory;
typedef Generic_trajectory<kjb::Vector> Canonical_trajectory;

template <class T>
class Generic_trajectory_map;
typedef Generic_trajectory_map<kjb::Vector> Canonical_trajectory_map;


template <class T>
struct Generic_trajectory_element
{
    Generic_trajectory_element() {}

    Generic_trajectory_element(const T& value_) : value(value_) {}

    bool parse(const std::string& line)
    {
        // NOT_IMPLEMENTED IN GENERAL
        KJB_THROW(Not_implemented);
    }

    void write(std::ofstream& ofs) const
    {
        // Implementer must specialize this function
        KJB_THROW(Not_implemented);
    }

    static void write_invalid(std::ofstream& ofs)
    {
        // Implementer must specialize this function
        KJB_THROW(Not_implemented);
    }

    friend
    void swap
    (
        Generic_trajectory_element<T>& t1,
        Generic_trajectory_element<T>& t2
    )
    {
        using std::swap;
        swap(t1.value, t2.value);
    }

    T value;
};


template <class T>
class Generic_trajectory :
    public std::vector<boost::optional<Generic_trajectory_element<T> > >
{
public:
    typedef Generic_trajectory_element<T> Trajectory_element;
    typedef std::vector<boost::optional<Trajectory_element> > Base;

public:

    Generic_trajectory(){}

    Generic_trajectory(size_t size) : Base(size) {}

    Generic_trajectory(double h, double w, double g) :
        height(h), width(w), girth(g) {}

    Generic_trajectory(size_t sz, double h, double w, double g) :
        Base(sz), height(h), width(w), girth(g) {}

    template <class F>
    Canonical_trajectory to_canonical(F to_vector) const;

    size_t parse(std::ifstream& ifs);

    void write(const std::string& filename) const;

    bool parse_header(const std::string& /*line*/)
    {
        return false;
    }

    void write_header(std::ofstream& /*ofs*/) const {}

    int start_time() const;

    int end_time() const;

    std::vector<T> get_values() const
    {
        std::vector<T> vals;
        transform(std::back_inserter(vals), boost::lambda::_1);
        return vals;
    }

    template <class OutIt, class Trans>
    void transform(OutIt outp, Trans f) const;

    friend void swap(Generic_trajectory<T>& t1, Generic_trajectory<T>& t2)
    {
        using std::swap;
        swap(t1.id, t2.id);
        swap(t1.height, t2.height);
        swap(t1.width, t2.width);
        swap(t1.girth, t2.girth);
        swap(static_cast<Base&>(t1), static_cast<Base&>(t2));
    }

public:
    Entity_id id;
    double height;
    double width;
    double girth;
};

typedef Generic_trajectory<kjb::Vector> Canonical_trajectory;

/* \/ \/ \/ \/ \/ \/ \/ \/ \/ \/ \/ \/ \/ \/ \/ \/ \/ \/ \/ \/ \/ \/ \/ \/ \/ */

template <class T>
template <class F>
Canonical_trajectory
Generic_trajectory<T>::to_canonical(F to_vector) const
{
    //typedef typename Base::value_type Map_element;
    //typedef typename Canonical_trajectory::Base::value_type Out_element;

    Canonical_trajectory out(
            this->size(),
            this->height,
            this->width,
            this->girth);
    out.id = this->id;

    for(size_t i = 0; i < this->size(); ++i)
    {
        if((*this)[i])
            out[i] = to_vector((*this)[i]->value);
    }

    return out;
}

/* \/ \/ \/ \/ \/ \/ \/ \/ \/ \/ \/ \/ \/ \/ \/ \/ \/ \/ \/ \/ \/ \/ \/ \/ \/ */

template <class T>
size_t Generic_trajectory<T>::parse(std::ifstream& ifs)
{
    std::string line;
    while(std::getline(ifs, line))
    {
        if(line == "")
        {
            continue;
        }

        if(!parse_header(line))
        {
            Trajectory_element elem;
            if(elem.parse(line))
            {
                this->push_back(elem);
            }
            else
            {
                this->push_back(false);
            }
        }
    }

    return this->size();
}

/* \/ \/ \/ \/ \/ \/ \/ \/ \/ \/ \/ \/ \/ \/ \/ \/ \/ \/ \/ \/ \/ \/ \/ \/ \/ */

template <class T>
void Generic_trajectory<T>::write(const std::string& filename) const
{
    std::ofstream ofs(filename.c_str()); 
    if(!ofs)
    {
        KJB_THROW_3(IO_error, "Couldn't write to file: %s", (filename.c_str()));
    }

    write_header(ofs);

    for(size_t f = 0; f < this->size(); f++)
    {
        if((*this)[f])
        {
            (*this)[f]->write(ofs);
        }
        else
        {
            Generic_trajectory_element<T>::write_invalid(ofs);
        }
    }

    ofs.close();
}

/* \/ \/ \/ \/ \/ \/ \/ \/ \/ \/ \/ \/ \/ \/ \/ \/ \/ \/ \/ \/ \/ \/ \/ \/ \/ */

template <class T>
int Generic_trajectory<T>::start_time() const
{   
    size_t sz = this->size();
    for(size_t i = 0; i < sz; i++)
    {
        if((*this)[i])
        {
            return i + 1;
        }
    }

    return -1;
}

/* \/ \/ \/ \/ \/ \/ \/ \/ \/ \/ \/ \/ \/ \/ \/ \/ \/ \/ \/ \/ \/ \/ \/ \/ \/ */

template <class T>
int Generic_trajectory<T>::end_time() const
{   
    size_t sz = this->size();
    for(int i = static_cast<int>(sz) - 1; i >= 0; i--)
    {
        if((*this)[i])
        {
            return i + 1;
        }
    }

    return -1;
}

/* \/ \/ \/ \/ \/ \/ \/ \/ \/ \/ \/ \/ \/ \/ \/ \/ \/ \/ \/ \/ \/ \/ \/ \/ \/ */

template <class T>
template <class OutIt, class Trans>
void Generic_trajectory<T>::transform(OutIt outp, Trans f) const
{
    int stime = start_time();
    int etime = end_time();

    if(stime == -1 || etime == -1)
    {
        return;
    }

    size_t stm = stime;
    size_t etm = etime;
    for(size_t i = stm - 1; i <= etm - 1; i++)
    {
        assert((*this)[i]);
        *outp++ = f((*this)[i]->value);
    }
}


template <class T>
class Generic_trajectory_map :
    public std::map<Entity_id, Generic_trajectory<T> > 
{
public:
    typedef Generic_trajectory<T> Trajectory;
    typedef Generic_trajectory_element<T> Trajectory_element;
    typedef std::map<Entity_id, Trajectory> Base;

public:
    Generic_trajectory_map(size_t duration = 0) : duration_(duration) {}

    template <class F>
    Canonical_trajectory_map to_canonical(F to_vector) const;

    void parse(const std::string& path, const std::string& entity);

    void write(const std::string& dirname) const;

    size_t duration() const
    {
        return duration_;
    }

    size_t& duration()
    {
        return duration_;
    }

    friend
    void swap(Generic_trajectory_map<T>& t1, Generic_trajectory_map<T>& t2)
    {
        using std::swap;
        swap(t1.duration_, t2.duration_);
        swap(static_cast<Base&>(t1), static_cast<Base&>(t2));
    }

private:
    size_t duration_;
};
typedef Generic_trajectory_map<kjb::Vector> Canonical_trajectory_map;

/* \/ \/ \/ \/ \/ \/ \/ \/ \/ \/ \/ \/ \/ \/ \/ \/ \/ \/ \/ \/ \/ \/ \/ \/ \/ */

template <class T>
template <class F>
Canonical_trajectory_map
Generic_trajectory_map<T>::to_canonical(F to_vector) const
{
    typedef typename Base::value_type Map_element;
    //typedef typename Canonical_trajectory_map::Base::value_type Out_map_element;

    Canonical_trajectory_map out_map(this->duration_);

    BOOST_FOREACH(const Map_element& element, *this)
    {
        out_map[element.first] = element.second.to_canonical(to_vector);
    }

    return out_map;
}

/* \/ \/ \/ \/ \/ \/ \/ \/ \/ \/ \/ \/ \/ \/ \/ \/ \/ \/ \/ \/ \/ \/ \/ \/ \/ */

template <class T>
void Generic_trajectory_map<T>::parse
(
    const std::string& path,
    const std::string& entity
)
{
    using namespace boost;

    if(entity.empty()) return;

    std::string pattern = path + "/" + entity + "_*.txt";
    Word_list word_list(pattern.c_str(), NULL);

    for(size_t i = 0; i < word_list.size(); i++)
    {
        std::string path = word_list[i];

        // file name format is <type>_<index>.txt
        // use this format to extract the entity_id
        std::string::size_type fname_st = path.rfind('/') + 1;
        std::string fname = path.substr(fname_st);

        std::vector<std::string> parts;
        split(parts, fname, is_any_of("_."), token_compress_on);

        IFTD(parts.size() == 3, Illegal_argument,
            "Invalid filename format for track file:", (fname.c_str()));

        Entity_type type = boost::lexical_cast<Entity_type>(parts[0]);
        size_t index = boost::lexical_cast<size_t>(parts[1]);

        Entity_id id(type, index);
        IFT(this->count(id) == 0, Illegal_argument, "Duplicate entity");

        std::ifstream ifs(path.c_str());
        IFTD(ifs, IO_error, "File not found: %s", (path.c_str()));

        Trajectory traj;
        traj.id = id;
        traj.height = get_entity_type_average_height(type);
        traj.width = get_entity_type_average_width(type);
        traj.girth = get_entity_type_average_girth(type);

        if(this->size() == 0)
        {
            //set_duration(traj.parse(ifs));
            duration() = traj.parse(ifs);
        }
        else
        {
            size_t num_frames = traj.parse(ifs);
            IFT(duration() == num_frames, Runtime_error,
                "Trajectories have differing duration.");
        }

        (*this)[id] = traj;
    }
}

/* \/ \/ \/ \/ \/ \/ \/ \/ \/ \/ \/ \/ \/ \/ \/ \/ \/ \/ \/ \/ \/ \/ \/ \/ \/ */

template <class T>
void Generic_trajectory_map<T>::write(const std::string& dirname) const
{
    kjb_c::kjb_mkdir(dirname.c_str());
    for(typename Generic_trajectory_map<T>::const_iterator it = Base::begin();
                                                           it != Base::end();
                                                           it++)
    {
        boost::format fmt("%s/%s_%d.txt");
        std::string filename = (
            fmt % dirname
                % boost::lexical_cast<std::string>(it->first.type)
                % it->first.index).str();

        assert(duration() == it->second.size());
        it->second.write(filename);
    }
}

}} //namespace kjb::tracking

#endif /*TRACKING_TRAJECTORY_H */