features_manager.h

Go to the documentation of this file.

/* $Id $ */

#ifndef EDGE_FEATURES_MANAGER_H
#define EDGE_FEATURES_MANAGER_H

#include "l_cpp/l_exception.h"
#include "l_cpp/l_readable.h"
#include "l_cpp/l_writeable.h"
#include "edge_cpp/line_segment_set.h"
#include "edge_cpp/edge.h"
#include "edge_cpp/manhattan_world.h"

#define FM_DEFAULT_EDGE_SIGMA 1.0
#define FM_DEFAULT_EDGE_BEGIN 2.55
#define FM_DEFAULT_EDGE_END 2.04
#define FM_DEFAULT_EDGE_PADDING 30
#define FM_DEFAULT_VP_SUCCESS_PROBABILITY 0.999
#define FM_DEFAULT_VP_ASSIGNMENT_THRESHOLD 0.16

namespace kjb {
class Features_manager : public Readable, public Writeable
{
    public:

        Features_manager
        (
            const kjb::Image & img,
            bool idetect_edges = true,
            bool ifit_edge_segments = true,
            bool icreate_manhattan_world = true
        );

        Features_manager
        (
            bool read_image,
            const std::string & img_path,
            bool idetect_edges = true,
            bool ifit_edge_segments = true,
            bool icreate_manhattan_world = true
        );

        Features_manager
        (
            kjb::Edge_set * edges,
            Edge_segment_set * edge_segments,
            Manhattan_world * manhattan_world
        );

        Features_manager
        (
            const kjb::Image & img,
            float iblurring_sigma,
            float ibegin_threshold,
            float iend_threshold,
            unsigned int ipadding,
            bool iuse_fourier,
            double ivanishing_point_detection_success_probability = FM_DEFAULT_VP_SUCCESS_PROBABILITY,
            double ioutlier_threshold_for_vanishing_points_assignment = FM_DEFAULT_VP_ASSIGNMENT_THRESHOLD,
            bool idetect_edges = true,
            bool ifit_edge_segments = true,
            bool icreate_manhattan_world = true
        );

        Features_manager(std::istream & in) : Readable(), Writeable(),
                 edges(0), edge_segments(0), manhattan_world(0),
                _edges_available(false),_edge_segments_available(false),
                _manhattan_world_available(false)
        {
            read(in);
        }

        Features_manager(const char * filename) : Readable(), Writeable(),
                 edges(0), edge_segments(0), manhattan_world(0),
                _edges_available(false),_edge_segments_available(false),
                _manhattan_world_available(false)
        {
            Readable::read(filename);
        }

        ~Features_manager()
        {
            delete manhattan_world;
            delete edge_segments;
            delete edges;
        }

        void set_edge_detection_parameters
        (
            float iblurring_sigma,
            float ibegin_threshold,
            float iend_threshold,
            unsigned int ipadding,
            bool iuse_fourier
        );

        void set_manhattan_world_parameters
        (
            double ivanishing_point_detection_success_probability,
            double ioutlier_threshold_for_vanishing_points_assignment
        );

        void read(std::istream& in);

        void read(const char* fname)
        {
            Readable::read(fname);
        }

        void write(std::ostream& out) const;

        void write(const char* fname) const
        {
            Writeable::write(fname);
        }

        inline const kjb::Edge_set & get_edges()
        {
            if(!_edges_available)
            {
                KJB_THROW_2(KJB_error,"Edges are not available!");
            }
            return *edges;
        }

        inline const Edge_segment_set & get_edge_segments()
        {
            if(!_edge_segments_available)
            {
                KJB_THROW_2(KJB_error,"Edge segments are not available!");
            }
            return *edge_segments;
        }

        inline Manhattan_world & get_manhattan_world() const
        {
            if(!_manhattan_world_available)
            {
                KJB_THROW_2(KJB_error,"Manhattan world is not available!");
            }
            return *manhattan_world;
        }

        inline bool edges_available()
        {
            return _edges_available;
        }

        inline bool edge_segments_available()
        {
            return _edge_segments_available;
        }

        inline bool manhattan_world_available()
        {
            return _manhattan_world_available;
        }

        void set_manhattan_focal_length(double ifocal);

        void set_manhattan_world(Manhattan_world * mw);

        double get_outlier_threshold_for_vanishing_points_assignment()
        {
            return outlier_threshold_for_vanishing_points_assignment;
        }

        void remove_frame_segments();

        void reset_manhattan_world_vpts(const std::vector<Vanishing_point> & vpts, double focal)
        {
            manhattan_world->reset_vanishing_points(vpts);
            manhattan_world->set_focal_length(focal);
            manhattan_world->assign_segments_to_vpts(*edge_segments);
            manhattan_world->create_corners();
        }

    private:

        Features_manager(const Features_manager & src) :
                    Readable(), Writeable() { (*this) = src; }

        Features_manager & operator=(const Features_manager & /* src */)
        {
            return (*this);
        }

        bool detect_features
        (
            bool idetect_edges,
            bool ifit_edge_segments,
            bool icreate_manhattan_world,
            const kjb::Image & img
        );

        bool detect_features
        (
            bool idetect_edges,
            bool ifit_edge_segments,
            bool icreate_manhattan_world,
            const std::string & img_path
        );

        void detect_edges(const kjb::Image & img);

        void fit_edge_segments_to_edges();

        bool create_manhattan_world(const kjb::Image & img);

        bool create_manhattan_world(const std::string & img_path);

        kjb::Edge_set         * edges;

        Edge_segment_set * edge_segments;

        Manhattan_world * manhattan_world;

        bool _edges_available;

        bool _edge_segments_available;

        bool _manhattan_world_available;



        float blurring_sigma;

        float begin_threshold;

        float end_threshold;

        unsigned int padding;

        bool use_fourier;

        double vanishing_point_detection_success_probability;

        double outlier_threshold_for_vanishing_points_assignment;

};

Features_manager * detect_hoiem_features_manager
(
    const std::string & img_path
);

}

#endif