pt_scene.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:  Ernesto Brau
 * =========================================================================== */

/* $Id: pt_scene.h 18971 2015-04-29 23:31:48Z jguan1 $ */

#ifndef PT_SCENE_H
#define PT_SCENE_H

#include <people_tracking_cpp/pt_association.h>
#include <people_tracking_cpp/pt_target.h>
#include <people_tracking_cpp/pt_data.h>
#include <camera_cpp/perspective_camera.h>
#include <string>
#include <iterator>
#include <boost/format.hpp>

namespace kjb {
namespace pt {

class Scene
{
public:
    Scene
    (
        const Ascn& assoc,
        const Perspective_camera& cam,
        double k,
        double t,
        double l
    ) :
        association(assoc),
        camera(cam),
        kappa(k),
        theta(t),
        lambda(l)
        //ns_faces(0)
    {}

    Ascn association;
    Perspective_camera camera;
    double kappa;
    double theta;
    double lambda;
    //mutable size_t ns_faces;
};

inline
void swap(Scene& s1, Scene& s2)
{
    using std::swap;

    swap(s1.association, s2.association);
    swap(s1.camera, s2.camera);
    swap(s1.kappa, s2.kappa);
    swap(s1.theta, s2.theta);
    swap(s1.lambda, s2.lambda);
    //swap(s1.ns_faces, s2.ns_faces);
}

size_t dims
(
    const Scene& scene, 
    bool respect_changed = true, 
    bool infer_head = true
);

void update_scene_state
(
    const Scene& scene,
    const Facemark_data& fmdata,
    bool infer_head = true,
    bool refine = true
);

void read_scene
(
    Scene& s,
    const std::string& tracks_dp,
    const std::string& ass_fp,
    const std::string& cam_fp,
    const std::string& params_fp,
    bool infer_head = true
);

inline
void read_scene
(
    Scene& scene,
    const std::string& tracks_dp,
    bool infer_head = true
)
{
    read_scene(
            scene,
            tracks_dp,
            tracks_dp + "/association.txt",
            tracks_dp + "/camera.txt",
            tracks_dp + "/params.txt",
            infer_head);
}

void write_scene
(
    const Scene& s,
    const std::string& tracks_dp,
    const std::string& ass_fp,
    const std::string& cam_fp,
    const std::string& params_fp
);

inline
void write_scene(const Scene& scene, const std::string& tracks_dp)
{
    write_scene(
            scene,
            tracks_dp,
            tracks_dp + "/association.txt",
            tracks_dp + "/camera.txt",
            tracks_dp + "/params.txt");
}


class Scene_recorder
{
public:
    Scene_recorder(const std::string& dir) : parent_dir(dir), i(1){}

    void operator()(const Scene& scene) const
    {
        std::string cur_dir = boost::str(boost::format("/%04d") % i++);
        write_scene(scene, parent_dir + cur_dir);
    }

    void reset() const
    {
        i = 1;
    }

private:
    std::string parent_dir;
    mutable size_t i;
};

class Write_scene_iterator :
    public std::iterator<std::output_iterator_tag, void, void, void, void>
{
public:
    struct container_type
    {
        typedef Scene value_type;
    };

    Write_scene_iterator(const std::string& dir) : parent_dir(dir), i(1), n(i){}

    Write_scene_iterator(const std::string& dir, size_t& sn) :
        parent_dir(dir), n(sn){}

    void operator=(const Scene& scene)
    {
        std::string cur_dir = boost::str(boost::format("/%04d") % n);
        write_scene(scene, parent_dir + cur_dir);
    }

    Write_scene_iterator& operator*()
    {
        return *this;
    }

    Write_scene_iterator& operator++(int)
    {
        n++;
        return *this;
    }

    Write_scene_iterator& operator++()
    {
        return (*this)++;
    }

    void reset()
    {
        n = 1;
    }

private:
    std::string parent_dir;
    size_t i;
    size_t& n;
};

void set_trajectory_at_frame
(
    const Scene& scene,
    const Target& target,
    size_t frame,
    const Vector3& v,
    bool vis_off,
    bool infer_head = true
);

void set_trajectories_at_frames
(
    const Scene& scene,
    const Target& target1,
    const Target& target2,
    size_t frame1,
    size_t frame2,
    const Vector3& v1,
    const Vector3& v2,
    bool vis_off,
    bool infer_head = true
);

inline
void move_trajectory_at_frame
(
    const Scene& scene,
    const Target& target,
    size_t frame,
    const Vector3& dv,
    bool vis_off,
    bool infer_head = true
)
{
    const Vector3& v = target.trajectory()[frame - 1]->value.position;
    set_trajectory_at_frame(scene, target, frame, v + dv, vis_off, infer_head);
}

inline
void move_trajectories_at_frames
(
    const Scene& scene,
    const Target& target1,
    const Target& target2,
    size_t frame1,
    size_t frame2,
    const Vector3& dv1,
    const Vector3& dv2,
    bool vis_off,
    bool infer_head = true
)
{
    const Vector3& v1 = target1.trajectory()[frame1 - 1]->value.position;
    const Vector3& v2 = target2.trajectory()[frame2 - 1]->value.position;

    set_trajectories_at_frames(scene,
                               target1, target2,
                               frame1, frame2,
                               v1 + dv1, v2 + dv2,
                               vis_off, 
                               infer_head);
}

void set_trajectory_dir_at_frame
(
    const Scene& scene,
    const Target& target,
    size_t frame,
    double dir,
    bool vis_off
);

void set_trajectory_dirs_at_frames
(
    const Scene& scene,
    const Target& target1,
    const Target& target2,
    size_t frame1,
    size_t frame2,
    double dir1,
    double dir2,
    bool vis_off
);

inline
void move_trajectory_dir_at_frame
(
    const Scene& scene,
    const Target& target,
    size_t frame,
    double dd,
    bool vis_off
)
{
    double d = target.trajectory()[frame - 1]->value.body_dir;
    set_trajectory_dir_at_frame(scene, target, frame, d + dd, vis_off);
}

inline
void move_trajectory_dirs_at_frames
(
    const Scene& scene,
    const Target& target1,
    const Target& target2,
    size_t frame1,
    size_t frame2,
    double dd1,
    double dd2,
    bool vis_off
)
{
    double d1 = target1.trajectory()[frame1 - 1]->value.body_dir;
    double d2 = target2.trajectory()[frame2 - 1]->value.body_dir;

    set_trajectory_dirs_at_frames(scene,
                                  target1, target2,
                                  frame1, frame2,
                                  d1 + dd1, d2 + dd2,
                                  vis_off);
}

void set_trajectory_face_dir_at_frame
(
    const Scene& scene,
    const Target& target,
    size_t frame,
    const Vector2& dir,
    bool vis_off
);

void set_trajectory_face_dirs_at_frames
(
    const Scene& scene,
    const Target& target1,
    const Target& target2,
    size_t frame1,
    size_t frame2,
    const Vector2& dir1,
    const Vector2& dir2,
    bool vis_off
);

inline
void move_trajectory_face_dir_at_frame
(
    const Scene& scene,
    const Target& target,
    size_t frame,
    const Vector2& dd,
    bool vis_off
)
{
    const Vector2& d = target.trajectory()[frame - 1]->value.face_dir;
    set_trajectory_face_dir_at_frame(scene, target, frame, d + dd, vis_off);
}

inline
void move_trajectory_face_dirs_at_frames
(
    const Scene& scene,
    const Target& target1,
    const Target& target2,
    size_t frame1,
    size_t frame2,
    const Vector2& dd1,
    const Vector2& dd2,
    bool vis_off
)
{
    const Vector2& d1 = target1.trajectory()[frame1 - 1]->value.face_dir;
    const Vector2& d2 = target2.trajectory()[frame2 - 1]->value.face_dir;

    set_trajectory_face_dirs_at_frames(scene,
                                       target1, target2,
                                       frame1, frame2,
                                       d1 + dd1, d2 + dd2,
                                       vis_off);
}

void update_body_model_directions
(
    const Target& target,
    size_t frame,
    const Perspective_camera& cam
);

void update_face_model_directions
(
    const Target& target,
    size_t frame,
    const Perspective_camera& cam
);

inline void update_model_directions
(
    const Target& target,
    size_t frame,
    const Perspective_camera& cam
)
{
    update_body_model_directions(target, frame, cam);
    update_face_model_directions(target, frame, cam);
}

}} //namespace kjb::pt

#endif /*PT_SCENE_H */