model_edge.h

Go to the documentation of this file.

/* $Id: model_edge.h 18278 2014-11-25 01:42:10Z 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: Luca Del Pero
 * =========================================================================== */

#ifndef KJB_MODEL_EDGE_H_
#define KJB_MODEL_EDGE_H_

#include <edge_cpp/line_segment.h>

namespace kjb
{
    class Model_edge : public Line_segment{

    public:

        Model_edge(double x1, double y1, double x2, double y2, bool isilhouette = false, bool isvisible = false, bool iflagged = false);

        Model_edge(const kjb::Vector & istart, const kjb::Vector & iend, bool isilhouette = false, bool isvisible = false, bool iflagged = false)
        {
            if(istart.size() < 2 || iend.size() < 2)
            {
                KJB_THROW_2(Illegal_argument, "Bad start and end points, expectin x and y coordinates");
            }

            _degenerate = false;
            if( (istart(0) == iend(0)) && (istart(1) == iend(1)) )
            {
                init_from_end_points(istart(0), istart(1), iend(0), iend(1) + FLT_EPSILON);
                _degenerate = true;
            }
            else
            {
                init_from_end_points(istart(0), istart(1), iend(0), iend(1));
            }
            _silhouette = isilhouette;
            _visible = isvisible;
            _flagged = iflagged;
        }

        Model_edge(const Model_edge & src) :
            Line_segment(src), _silhouette(src._silhouette), _degenerate(src._degenerate), _visible(src._visible), _flagged(src._flagged)
        {

        }

        Model_edge & operator=(const Model_edge & src)
        {
            Line_segment::operator=(src);
            _silhouette = src._silhouette;
            _visible = src._visible;
            _degenerate = src._degenerate;
            _flagged = src._flagged;
            return (*this);
        }

        inline bool operator==(const Model_edge& model_edge) const
        {
            return (get_start() == model_edge.get_start() &&
                        get_end() == model_edge.get_end()) ||
                    (get_end() == model_edge.get_start() &&
                        get_start() == model_edge.get_end());
        }

        void read(std::istream& in);

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

        inline bool is_silhouette() const { return _silhouette; }

        inline bool is_visible() const { return _visible; }

        inline void set_silhouette(bool isilhouette) { _silhouette = isilhouette; }

        inline void set_flagged(bool iflagged) { _flagged = iflagged; }

        inline void set_visible(bool isvisible) { _visible = isvisible; }

        void update_detected_segments
        (
            const Edge_segment& image_edge_segment, 
            double              collinear_distance_threshold,
            Vector&             previous_center,
            bool&               mapped,
            double              noisy_length
        );

        double get_detected_length(); 

        bool is_flagged() const
        {
            return _flagged;
        }
    
    private:

        bool _silhouette;

        bool _degenerate;
        
        bool _visible;

        bool _flagged;
       
        std::vector<Line_segment> detected_segments;
    };
}

#endif /* KJB_MODEL_EDGE_H_ */