pt_scene_posterior.h

Go to the documentation of this file.

/* =========================================================================== *
|
|  Copyright (c) 1994-2008 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.
|
| Authors:
|     Ernesto Brau
|
* =========================================================================== */

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

#ifndef PT_SCENE_POSTERIOR_H
#define PT_SCENE_POSTERIOR_H

#include <people_tracking_cpp/pt_scene.h>
#include <people_tracking_cpp/pt_target.h>
#include <people_tracking_cpp/pt_position_prior.h>
#include <people_tracking_cpp/pt_direction_prior.h>
#include <people_tracking_cpp/pt_box_likelihood.h>
#include <people_tracking_cpp/pt_facemark_likelihood.h>
#include <people_tracking_cpp/pt_optical_flow_likelihood.h>
#include <people_tracking_cpp/pt_face_flow_likelihood.h>
#include <people_tracking_cpp/pt_color_likelihood.h>
#include <people_tracking_cpp/pt_entity.h>
#include <people_tracking_cpp/pt_scene_adapter.h>
#include <camera_cpp/perspective_camera.h>
#include <prob_cpp/prob_distribution.h>
#include <detector_cpp/d_bbox.h>
#include <iostream>

namespace kjb {
namespace pt {

class Scene_posterior
{
public:
    Scene_posterior
    (
        const Box_likelihood& box_likelihood,
        const Facemark_likelihood& fm_likelihood,
        const Optical_flow_likelihood& of_likelihood,
        const Face_flow_likelihood& ff_likelihood,
        const Color_likelihood& color_likelihood,
        const Position_prior& pos_prior,
        const Direction_prior& dir_prior,
        const Face_direction_prior& fdir_prior,
        bool vis_off = false,
        bool infer_head_off = false
    ) :
        box_likelihood_(box_likelihood),
        fm_likelihood_(fm_likelihood),
        of_likelihood_(of_likelihood),
        ff_likelihood_(ff_likelihood),
        color_likelihood_(color_likelihood),
        pos_prior_(pos_prior),
        dir_prior_(dir_prior),
        fdir_prior_(fdir_prior),
        N_h(get_entity_type_average_height(get_entity_type("person")),
            get_entity_type_stddev_height(get_entity_type("person"))),
        N_w(get_entity_type_average_width(get_entity_type("person")),
            get_entity_type_stddev_width(get_entity_type("person"))),
        N_g(get_entity_type_average_girth(get_entity_type("person")),
            get_entity_type_stddev_girth(get_entity_type("person"))),
        use_box_lh_(true),
        use_fm_lh_(true),
        use_of_lh_(true),
        use_ff_lh_(true),
        use_color_lh_(false),
        use_pos_prior_(true),
        use_dir_prior_(true),
        use_fdir_prior_(true),
        use_dim_prior_(true),
        m_vis_off(vis_off),
        m_infer_head(!infer_head_off)
    {}

public:
    double operator()(const Scene& scene) const;

    double local
    (
        const Target& target,
        const Scene& scene,
        size_t frame
    ) const
    {
        return local(target, target, scene, frame, frame);
    }

    double local
    (
        const Target& target1,
        const Target& target2,
        const Scene& scene,
        size_t frame1,
        size_t frame2
    ) const;

public:
    bool& use_box_lh() const { return use_box_lh_; }

    bool& use_fm_lh() const { return use_fm_lh_; }

    bool& use_of_lh() const { return use_of_lh_; }

    bool& use_ff_lh() const { return use_ff_lh_; }

    bool& use_color_lh() const { return use_color_lh_; }

    bool& use_pos_prior() const { return use_pos_prior_; }

    bool& use_dir_prior() const { return use_dir_prior_; }

    bool& use_fdir_prior() const { return use_fdir_prior_; }

    bool& use_dim_prior() const { return use_dim_prior_; }

    bool vis_off() const { return m_vis_off; }

    bool infer_head() const { return m_infer_head; }
         
public:
    const Position_prior& position_prior() const { return pos_prior_; }

    const Direction_prior& direction_prior() const { return dir_prior_; }

    const Face_direction_prior& face_direction_prior() const
    {
        return fdir_prior_;
    }

    const Normal_distribution& height_prior() const { return N_h; }

    const Normal_distribution& width_prior() const { return N_w; }

    const Normal_distribution& girth_prior() const { return N_g; }

    const Box_likelihood& box_likelihood() const { return box_likelihood_; }

    const Facemark_likelihood& fm_likelihood() const { return fm_likelihood_; }

    const Optical_flow_likelihood& of_likelihood() const
    {
        return of_likelihood_;
    }

    const Face_flow_likelihood& ff_likelihood() const { return ff_likelihood_; }

    const Color_likelihood& color_likelihood() const
    {
        return color_likelihood_;
    }

//private:
    double dimension_prior(const Scene& scene) const;

private:
    // distributions
    const Box_likelihood& box_likelihood_;
    const Facemark_likelihood& fm_likelihood_;
    const Optical_flow_likelihood& of_likelihood_;
    const Face_flow_likelihood& ff_likelihood_;
    const Color_likelihood& color_likelihood_;
    const Position_prior& pos_prior_;
    const Direction_prior& dir_prior_;
    const Face_direction_prior& fdir_prior_;
    Normal_distribution N_h;
    Normal_distribution N_w;
    Normal_distribution N_g;

    // use distributions?
    mutable bool use_box_lh_;
    mutable bool use_fm_lh_;
    mutable bool use_of_lh_;
    mutable bool use_ff_lh_;
    mutable bool use_color_lh_;
    mutable bool use_pos_prior_;
    mutable bool use_dir_prior_;
    mutable bool use_fdir_prior_;
    mutable bool use_dim_prior_;
    bool m_vis_off;
    bool m_infer_head;
};

class Scene_posterior_ind
{
public:
    Scene_posterior_ind(const Scene_posterior& post) :
        posterior_(post), adapter_(post.vis_off(), post.infer_head()) {}

    double operator()(const Scene& sc, size_t i) const
    {
        const Target* tg_p;
        size_t frame;
        boost::tie(tg_p, frame) = adapter_.target_frame(&sc, i);

        IFT(tg_p != 0, Runtime_error, "Cannot compute ind. post.: bad index.");

        return posterior_.local(*tg_p, sc, frame);
    }

    double operator()(const Scene& sc, size_t i, size_t j) const
    {
        const Target* tg_p1;
        const Target* tg_p2;
        size_t frame1;
        size_t frame2;
        boost::tie(tg_p1, frame1) = adapter_.target_frame(&sc, i);
        boost::tie(tg_p2, frame2) = adapter_.target_frame(&sc, j);

        IFT(tg_p1 != 0, Runtime_error, "Cannot compute ind. post.: bad index.");
        IFT(tg_p2 != 0, Runtime_error, "Cannot compute ind. post.: bad index.");

        return posterior_.local(*tg_p1, *tg_p2, sc, frame1, frame2);
    }

    const Scene_adapter& adapter() const { return adapter_; }

    void reset() const { adapter_.reset(); }

private:
    const Scene_posterior& posterior_;
    Scene_adapter adapter_;
};

void write_posterior_details
(
    const Scene_posterior& post,
    const Scene& scene,
    double mlh,
    std::ostream& ost
);

}} // namespace kjb::pt

#endif /*PT_SCENE_POSTERIOR_H */