edge_lines_likelihood.h

Go to the documentation of this file.

/* $Id: edge_lines_likelihood.h 18283 2014-11-25 05:05:59Z ksimek $ */
/* =========================================================================== *
   |
   |  Copyright (c) 1994-2010 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: Jinyan Guan 
 * =========================================================================== */
#ifndef EDGE_LINES_LIKELIHOOD_H_INCLUDED
#define EDGE_LINES_LIKELIHOOD_H_INCLUDED

#include <edge_cpp/edge.h>

#include <camera_cpp/perspective_camera.h>

#include <likelihood_cpp/model_edge.h>
#include <likelihood_cpp/edge_likelihood_util.h>
#include <list>

namespace kjb {

class Line_correspondence
{
    public:

        Line_correspondence
        (
            const Edge_segment_set&             image_edge_segments,
            double                              angle_sigma,
            double                              dist_sigma,
            double                              max_distance,
            double                              max_angle
        );

        ~Line_correspondence(){};

        class Line_bin 
        {
             public:
                
                Line_bin 
                (
                    const Edge_segment&         iimage_edge_segment, 
                    const Model_edge&           model_edge_segment, 
                    unsigned int                imodel_edge_segment_index,
                    double                      angle_sigma,
                    double                      dist_sigma
                );
                
                class Compare_edge_segment_starting_points
                {     
                    public:
                        bool operator() (const Line_bin* line_bin1, const Line_bin* line_bin2) const;
                };

                bool operator< (const Line_bin& l_bin) const;

                const Edge_segment& image_edge_segment;

                unsigned int model_edge_segment_index;

                float distance; 

                double gauss_distance;
                                     
                float angle;

                double gauss_angle;
        }; 

        inline const std::vector<std::vector<Line_bin*> >& get_model_corresponding_image_edges ( ) const
        {
            return m_model_corresponding_image_edges;
        }

        inline double get_max_distance() const
        {
            return m_max_distance;
        }

        inline std::vector<const Edge_segment*> get_noisy_edge_segments()
        {
            return noisy_image_edge_segments;
        }

        void find_model_corresponding_image_edges
        (
            const std::vector<Model_edge>&  model_edge_segments
        ); 

    private: 

        double m_max_distance;
   
        double m_max_angle;
        
        double m_angle_sigma;

        double m_dist_sigma;

        const Edge_segment_set& image_edge_segments;

        std::vector<std::list<Line_bin> > m_image_corresponding_model_edges;

        std::vector<std::vector<Line_bin*> > m_model_corresponding_image_edges; 

        std::vector<const Edge_segment*> noisy_image_edge_segments; 

};

class Edge_lines_likelihood
{
    public:
        
        Edge_lines_likelihood
        (
             const Edge_segment_set&  iimage_edge_segments,
             double                   angle_sigma,
             double                   dist_sigma,
             double                   prob_of_missing,
             double                   prob_of_noise,
             double                   max_distance,
             double                   max_angle,
             double                   collinear_distance_threshold
        );
        
        template <class T> double compute_likelihood(T & model);
    
        template <class T, class U>
        double compute_likelihood(T & model, U & camera);
        
        double operator()(std::vector<Model_edge>& model_edges);

        //For debug purposes, draw the correspondence 
        void draw_correspondence
        (
            Image&          model_edge_image, 
            Image&          data_edge_image,
            const           std::vector<Model_edge>& model_edges, 
            double          width
        );

    private:

        kjb::Int_matrix model_map;

        const Edge_segment_set& image_edge_segments;
        

        double m_prob_of_missing;

        double m_prob_of_noise;

        Line_correspondence m_line_correspondence;

        double m_collinear_distance_threshold;
};

    template <class T>
    double Edge_lines_likelihood::compute_likelihood(T & model)
    {
        std::vector<Model_edge> model_edges;
        model.prepare_model_map(model_map);
        model.prepare_rendered_model_edges(model_edges, model_map);
        return this->operator()(model_edges);
    }
    
    template <class T, class U>
    double Edge_lines_likelihood::compute_likelihood(T & model, U & camera)
    {
        std::vector<Model_edge> model_edges;
        model.prepare_model_map(model_map);
        model.prepare_rendered_model_edges(model_edges, model_map);
        return this->operator()(model_edges);
    }
}

#endif