edge_segment.h

Go to the documentation of this file.

/* $Id: edge_segment.h 18301 2014-11-26 19:17:13Z ksimek $ */

// vim: tabstop=4 shiftwidth=4 foldmethod=marker

#ifndef KJB_EDGE_CPP_EDGE_SEGMENT_H
#define KJB_EDGE_CPP_EDGE_SEGMENT_H

#include "edge/edge_base.h"
#include "gr_cpp/gr_line_segment.h"
#include "edge_cpp/edge.h"
#include <iosfwd>

namespace kjb {

class Edge_segment : public Line_segment
{
public:

    Edge_segment(
        const kjb::Edge & iedge,
        bool use_num_pts_as_length = true
    )
    :   Line_segment(),
        edge_pts(iedge)
    {
        fit_to_edge_points_with_least_squares(iedge, use_num_pts_as_length);
    }

    Edge_segment(
        const kjb::Edge & iedge,
        const kjb::Line_segment & ls
    )
    :   Line_segment(ls),
        edge_pts(iedge)
    {
        least_squares_fitting_error = 0.0;
        strength = 0.0;
    }

    Edge_segment(
        const kjb::Edge & iedge,
        std::istream& in
    );

    Edge_segment(const Edge_segment & src)
    :   Line_segment(src),
        least_squares_fitting_error(src.least_squares_fitting_error),
        strength(src.strength),
        edge_pts(src.edge_pts)
    {}

    Edge_segment & operator=(const Edge_segment & src)
    {
        Line_segment::operator=(src);
        least_squares_fitting_error = src.least_squares_fitting_error;
        strength = src.strength;
        edge_pts = src.edge_pts;
        return (*this);
    }

    ~Edge_segment() {}

    bool operator==(const Edge_segment & edg)
    {
        if(!Line_segment::operator==(edg))
        {
            return false;
        }
        if(fabs(strength - edg.strength) > FLT_EPSILON)
        {
            return false;
        }
        if( fabs(least_squares_fitting_error - edg.least_squares_fitting_error)
                > FLT_EPSILON
          )
        {
            return false;
        }

        return true;
    }

    inline const kjb::Edge & get_edge()
    {
        return edge_pts;
    }

    inline kjb::Edge_point get_edge_point(unsigned int i)
    {
        return edge_pts.get_edge_point(i);
    }

    inline double get_least_squares_fitting_error() const
    {
        return least_squares_fitting_error;
    }

    inline double get_strength() const
    {
        return strength;
    }

    void read(std::istream& in);

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

    friend std::ostream& operator<<(std::ostream& out, const Edge_segment& es);

    bool is_overlapping
    (
        const Edge_segment & es,
        double collinear_threshold = 0.12,
        double overlapping_threshold = 10
    )   const;

    void set_edge(const kjb::Edge & iedge_pts)
    {
        edge_pts = iedge_pts;
    }


private:

     void fit_to_edge_points_with_least_squares(
        const kjb::Edge & edge,
        bool use_num_pts_as_length = true
    );

    double least_squares_fitting_error;

    double strength;

    kjb::Edge edge_pts;
};

std::ostream& operator<<(std::ostream& out, const Edge_segment& es);


} // namespace kjb
#endif /* KJB_EDGE_CPP_EDGE_SEGMENT_H */