gr_line_segment.h

Go to the documentation of this file.

/* $Id: gr_line_segment.h 18301 2014-11-26 19:17:13Z ksimek $ */
/* {{{=========================================================================== *
   |
   |  Copyright (c) 1994-2014 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:  Kyle Simek
 * =========================================================================== }}}*/

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

#ifndef GR_CPP_LINE_SEGMENT_H
#define GR_CPP_LINE_SEGMENT_H

#include <utility>
#include <iosfwd>
#include <l_cpp/l_readable.h>
#include <l_cpp/l_writeable.h>
#include <m_cpp/m_vector.h>
#include <g_cpp/g_line.h>

namespace kjb {

class Image;

class Line_segment : public Readable, public Writeable
{
public:

    Line_segment()
    :   Readable(),
        Writeable(),
        centre(3,1.0),
        start_point(3,1.0),
        end_point(3,1.0),
        line()
    {}

    Line_segment(
        double icentre_x,
        double icentre_y,
        double iorientation,
        double ilength
    );

    Line_segment(const Vector& start, const Vector& end);

    Line_segment(std::istream & in);

    Line_segment(const Line_segment & ls);

    Line_segment & operator=(const Line_segment & ls);

    bool operator ==(const Line_segment& ls) const;

    inline bool operator <(const Line_segment& ls) const
    {
        return      (this->get_start_x() < ls.get_start_x())
                ||  (       this->get_start_x() == ls.get_start_x()
                        &&  this->get_start_y() < ls.get_start_y()
                    );
    }

    void init_from_slope_and_intercept(
        double x_start,
        double x_end,
        double islope,
        double iintercept
    );

    void init_vertical_segment(double y_start, double y_end, double x);

    void init_from_end_points(double x_1, double y_1, double x_2, double y_2);

    void init_from_centre_and_orientation(
        double icentre_x,
        double icentre_y,
        double iorientation,
        double ilength
    );

    inline double get_centre_x() const
    {
        return centre(0);
    }

    inline double get_centre_y() const
    {
        return centre(1);
    }

    bool point_outside_segment(const Vector& point) const;

    const kjb::Vector & get_centre() const { return centre; }

    inline double get_start_x() const
    {
        return start_point(0);
    }

    inline double get_start_y() const
    {
        return start_point(1);
    }

    const kjb::Vector & get_start() const { return start_point; }

    inline double get_end_x() const
    {
        return end_point(0);
    }

    inline double get_end_y() const
    {
        return end_point(1);
    }

    const kjb::Vector & get_end() const { return end_point; }

    inline double get_slope() const
    {
        if(is_vertical())
        {
            return std::numeric_limits<double>::max() - DBL_EPSILON;
        }
        return -line.get_a();
    }

    inline double get_y_intercept() const
    {
        if(is_vertical())
        {
            throw KJB_error("Vertical segment, there is no y intercept");
        }
        return -line.get_c();
    }

    inline double get_x_intercept() const
    {
        if(is_horizontal())
        {
            throw KJB_error("Horizontal segment, there is no x intercept");
        }
        return -line.get_c()/line.get_a();
    }

    inline const Vector & get_line_params() const
    {
        return line.get_params();
    }

    inline const Line & get_line() const
    {
        return line;
    }

    inline double get_orientation() const
    {
        return orientation;
    }

    inline double get_length() const
    {
        return length;
    }

    void read(std::istream& in);

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

    void draw(
        kjb::Image & img,
        double ir,
        double ig,
        double ib,
        double width = 1.0
    )  const;

    void randomly_color(kjb::Image & img, double width = 1.0)  const;

    bool get_intersection
    (
        const Line_segment&      line,
        kjb::Vector&             point
    ) const;

    double get_distance_from_point (const kjb::Vector& point) const;

    double get_angle_between_line (const Line_segment& line) const;

    double find_t(const kjb::Vector & point) const;

    double get_distance_from_point (
        const kjb::Vector& point,
        double * perp_dist
    ) const;

    inline double get_dx() const
    {
        return  fabs(end_point(0) - start_point(0) );
    }

    inline double get_dy() const {return  (end_point(1) - start_point(1) ); }

    friend std::ostream& operator<<(std::ostream&, const Line_segment&);

    inline bool is_horizontal() const
    {
        return (fabs(orientation) <= FLT_EPSILON );
    }

    inline bool is_vertical() const
    {
        //This is a little hacky but I could not find a more elegant solution
        //if(fabs(line.get_b()) <= FLT_EPSILON)
        if(fabs(get_orientation()-M_PI_2) <= FLT_EPSILON)
        {
            return true;
        }
        return false;
    }

    void get_direction(kjb::Vector & idirection) const;

    bool is_line_segment_consistent();

    static std::pair<Vector, Vector> project_line_segment_onto_line
    (
        const Line_segment&     segment,
        const Line&             iline
    );

    static bool project_line_segment_onto_line_segment
    (
        const Line_segment&         segment_project,
        const Line_segment&         segment_target,
        std::pair<Vector, Vector>&  projected_points,
        double&                     length_inside,
        double&                     length_outside
    );

    static bool less_than (const Vector& point1, const Vector& point2);


    static bool collision_detection
    (
        double start_1,
        double end_1,
        double start_2,
        double end_2,
        int & direction,
        double & delta
    );

    static bool collision_detection_with_direction
    (
        double start_1,
        double end_1,
        double start_2,
        double end_2,
        int & direction,
        double & delta,
        int idirection
    );

    static double get_overlap
    (
        double start_1,
        double end_1,
        double start_2,
        double end_2
    );

    bool is_collinear
    (
        const Line_segment & ls,
        double collinear_threshold
    ) const;

protected:

    void compute_extrema();

    void compute_line_parameters();


    kjb::Vector centre;

    double orientation;

    double length;

    kjb::Vector start_point;
    kjb::Vector end_point;

    Line line;

    static Matrix _line_segment_rotation;

};

std::ostream& operator<<(std::ostream& out, const Line_segment& ls);

} // namespace kjb
#endif /* GR_CPP_LINE_SEGMENT_H */