line.h

Go to the documentation of this file.

/*
 * Authors:
 *   Marco Cecchetti <mrcekets at gmail.com>
 *   Krzysztof Kosiński <tweenk.pl@gmail.com>
 * Copyright 2008-2011 Authors
 *
 * This library is free software; you can redistribute it and/or
 * modify it either under the terms of the GNU Lesser General Public
 * License version 2.1 as published by the Free Software Foundation
 * (the "LGPL") or, at your option, under the terms of the Mozilla
 * Public License Version 1.1 (the "MPL"). If you do not alter this
 * notice, a recipient may use your version of this file under either
 * the MPL or the LGPL.
 *
 * You should have received a copy of the LGPL along with this library
 * in the file COPYING-LGPL-2.1; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
 * You should have received a copy of the MPL along with this library
 * in the file COPYING-MPL-1.1
 *
 * The contents of this file are subject to the Mozilla Public License
 * Version 1.1 (the "License"); you may not use this file except in
 * compliance with the License. You may obtain a copy of the License at
 * http://www.mozilla.org/MPL/
 *
 * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY
 * OF ANY KIND, either express or implied. See the LGPL or the MPL for
 * the specific language governing rights and limitations.
 */
 
#ifndef LIB2GEOM_SEEN_LINE_H
#define LIB2GEOM_SEEN_LINE_H
 
#include <cmath>
#include <optional>
#include <2geom/bezier-curve.h> // for LineSegment
#include <2geom/rect.h>
#include <2geom/crossing.h>
#include <2geom/exception.h>
#include <2geom/ray.h>
#include <2geom/angle.h>
#include <2geom/intersection.h>
 
namespace Geom
{
 
// class docs in cpp file
class Line
    : boost::equality_comparable< Line >
{
private:
    Point _initial;
    Point _final;
public:
 
    Line()
        : _initial(0,0), _final(1,0)
    {}
    Line(Point const &origin, Coord angle)
        : _initial(origin)
    {
        Point v;
        sincos(angle, v[Y], v[X]);
        _final = _initial + v;
    }
 
    Line(Point const &a, Point const &b)
        : _initial(a)
        , _final(b)
    {}
 
    Line(double a, double b, double c) {
        setCoefficients(a, b, c);
    }
 
    explicit Line(LineSegment const &seg)
        : _initial(seg.initialPoint())
        , _final(seg.finalPoint())
    {}
 
    explicit Line(Ray const &r)
        : _initial(r.origin())
        , _final(r.origin() + r.vector())
    {}
 
    static Line from_normal_distance(Point const &n, Coord c) {
        Point start = c * n.normalized();
        Line l(start, start + rot90(n));
        return l;
    }
    static Line from_origin_and_vector(Point const &o, Point const &v) {
        Line l(o, o + v);
        return l;
    }
 
    Line* duplicate() const {
        return new Line(*this);
    }
 
 
    Point origin() const { return _initial; }
    Point vector() const { return _final - _initial; }
    Point versor() const { return (_final - _initial).normalized(); }
    Coord angle() const {
        Point d = _final - _initial;
        double a = std::atan2(d[Y], d[X]);
        if (a < 0) a += M_PI;
        if (a == M_PI) a = 0;
        return a;
    }
 
    void setOrigin(Point const &p) {
        Point d = p - _initial;
        _initial = p;
        _final += d;
    }
    void setVector(Point const &v) {
        _final = _initial + v;
    }
 
    void setAngle(Coord angle) {
        Point v;
        sincos(angle, v[Y], v[X]);
        v *= distance(_initial, _final);
        _final = _initial + v;
    }
 
    void setPoints(Point const &a, Point const &b) {
        _initial = a;
        _final = b;
    }
 
    void setCoefficients(double a, double b, double c);
 
    std::vector<double> coefficients() const;
 
    void coefficients(Coord &a, Coord &b, Coord &c) const;
 
    bool isDegenerate() const {
        return _initial == _final;
    }
    bool isHorizontal() const {
        return _initial[Y] == _final[Y];
    }
    bool isVertical() const {
        return _initial[X] == _final[X];
    }
 
    void normalize() {
        // this helps with the nasty case of a line that starts somewhere far
        // and ends very close to the origin
        if (L2sq(_final) < L2sq(_initial)) {
            std::swap(_initial, _final);
        }
        Point v = _final - _initial;
        v.normalize();
        _final = _initial + v;
    }
    Line normalized() const {
        Point v = _final - _initial;
        v.normalize();
        Line ret(_initial, _initial + v);
        return ret;
    }
 
    Point initialPoint() const {
        return _initial;
    }
    Point finalPoint() const {
        return _final;
    }
    Point pointAt(Coord t) const {
        return lerp(t, _initial, _final);;
    }
 
    Coord valueAt(Coord t, Dim2 d) const {
        return lerp(t, _initial[d], _final[d]);
    }
 
    Coord timeAt(Point const &p) const;
 
    Coord timeAtProjection(Point const& p) const {
        if ( isDegenerate() ) return 0;
        Point v = vector();
        return dot(p - _initial, v) / dot(v, v);
    }
 
    Coord nearestTime(Point const &p) const {
        return timeAtProjection(p);
    }
 
    std::vector<Coord> roots(Coord v, Dim2 d) const;
    Coord root(Coord v, Dim2 d) const;
 
    void reverse() {
        std::swap(_final, _initial);
    }
    Line reversed() const {
        Line result(_final, _initial);
        return result;
    }
 
    // TODO remove this?
    Curve* portion(Coord  f, Coord t) const {
        LineSegment* seg = new LineSegment(pointAt(f), pointAt(t));
        return seg;
    }
 
    LineSegment segment(Coord  f, Coord t) const {
        return LineSegment(pointAt(f), pointAt(t));
    }
 
    std::optional<LineSegment> clip(Rect const &r) const;
 
    Ray ray(Coord t) {
        Ray result;
        result.setOrigin(pointAt(t));
        result.setVector(vector());
        return result;
    }
 
    Line derivative() const {
        Point v = vector();
        Line result(v, v);
        return result;
    }
 
    Line transformed(Affine const& m) const {
        Line l(_initial * m, _final * m);
        return l;
    }
 
    Point normal() const {
        return rot90(vector()).normalized();
    }
 
    // what does this do?
    Point normalAndDist(double & dist) const {
        Point n = normal();
        dist = -dot(n, _initial);
        return n;
    }
 
    Affine reflection() const {
        Point v = versor();
        Coord x2 = v[X]*v[X], y2 = v[Y]*v[Y], xy = v[X]*v[Y];
        Affine m(x2-y2, 2.*xy,
                 2.*xy, y2-x2,
                 _initial[X], _initial[Y]);
        m = Translate(-_initial) * m;
        return m;
    }
 
    Affine rotationToZero(Dim2 d) const {
        Point v = vector();
        if (d == X) {
            std::swap(v[X], v[Y]);
        } else {
            v[Y] = -v[Y];
        }
        Affine m = Translate(-_initial) * Rotate(v);
        return m;
    }
    Affine rotationToAxis(Dim2 d) const {
        Affine m = rotationToZero(other_dimension(d));
        return m;
    }
 
    Affine transformTo(Line const &other) const;
 
    std::vector<ShapeIntersection> intersect(Line const &other) const;
    std::vector<ShapeIntersection> intersect(Ray const &r) const;
    std::vector<ShapeIntersection> intersect(LineSegment const &ls) const;
 
    template <typename T>
    Line &operator*=(T const &tr) {
        BOOST_CONCEPT_ASSERT((TransformConcept<T>));
        _initial *= tr;
        _final *= tr;
        return *this;
    }
 
    bool operator==(Line const &other) const {
        if (distance(pointAt(nearestTime(other._initial)), other._initial) != 0) return false;
        if (distance(pointAt(nearestTime(other._final)), other._final) != 0) return false;
        return true;
    }
 
    template <typename T>
    friend Line operator*(Line const &l, T const &tr) {
        BOOST_CONCEPT_ASSERT((TransformConcept<T>));
        Line result(l);
        result *= tr;
        return result;
    }
}; // end class Line
 
void filter_line_segment_intersections(std::vector<ShapeIntersection> &xs, bool a=false, bool b=true);
void filter_ray_intersections(std::vector<ShapeIntersection> &xs, bool a=false, bool b=true);
 
inline
double distance(Point const &p, Line const &line)
{
    if (line.isDegenerate()) {
        return ::Geom::distance(p, line.initialPoint());
    } else {
        Coord t = line.nearestTime(p);
        return ::Geom::distance(line.pointAt(t), p);
    }
}
 
inline
bool are_near(Point const &p, Line const &line, double eps = EPSILON)
{
    return are_near(distance(p, line), 0, eps);
}
 
inline
bool are_parallel(Line const &l1, Line const &l2, double eps = EPSILON)
{
    return are_near(cross(l1.vector(), l2.vector()), 0, eps);
}
 
inline
bool are_same(Line const &l1, Line const &l2, double eps = EPSILON)
{
    return are_parallel(l1, l2, eps) && are_near(l1.origin(), l2, eps);
}
 
inline
bool are_orthogonal(Line const &l1, Line const &l2, double eps = EPSILON)
{
    return are_near(dot(l1.vector(), l2.vector()), 0, eps);
}
 
// evaluate the angle between l1 and l2 rotating l1 in cw direction
// until it overlaps l2
// the returned value is an angle in the interval [0, PI[
inline
double angle_between(Line const& l1, Line const& l2)
{
    double angle = angle_between(l1.vector(), l2.vector());
    if (angle < 0) angle += M_PI;
    if (angle == M_PI) angle = 0;
    return angle;
}
 
inline
double distance(Point const &p, LineSegment const &seg)
{
    double t = seg.nearestTime(p);
    return distance(p, seg.pointAt(t));
}
 
inline
bool are_near(Point const &p, LineSegment const &seg, double eps = EPSILON)
{
    return are_near(distance(p, seg), 0, eps);
}
 
// build a line passing by _point and orthogonal to _line
inline
Line make_orthogonal_line(Point const &p, Line const &line)
{
    Point d = line.vector().cw();
    Line l(p, p + d);
    return l;
}
 
// build a line passing by _point and parallel to _line
inline
Line make_parallel_line(Point const &p, Line const &line)
{
    Line result(line);
    result.setOrigin(p);
    return result;
}
 
// build a line passing by the middle point of _segment and orthogonal to it.
inline
Line make_bisector_line(LineSegment const& _segment)
{
    return make_orthogonal_line( middle_point(_segment), Line(_segment) );
}
 
// build the bisector line of the angle between ray(O,A) and ray(O,B)
inline
Line make_angle_bisector_line(Point const &A, Point const &O, Point const &B)
{
    AngleInterval ival(Angle(A-O), Angle(B-O));
    Angle bisect = ival.angleAt(0.5);
    return Line(O, bisect);
}
 
// prj(P) = rot(v, Point( rot(-v, P-O)[X], 0 )) + O
inline
Point projection(Point const &p, Line const &line)
{
    return line.pointAt(line.nearestTime(p));
}
 
inline
LineSegment projection(LineSegment const &seg, Line const &line)
{
    return line.segment(line.nearestTime(seg.initialPoint()),
                        line.nearestTime(seg.finalPoint()));
}
 
inline
std::optional<LineSegment> clip(Line const &l, Rect const &r) {
    return l.clip(r);
}
 
 
namespace detail
{
 
OptCrossing intersection_impl(Ray const& r1, Line const& l2, unsigned int i);
OptCrossing intersection_impl( LineSegment const& ls1,
                             Line const& l2,
                             unsigned int i );
OptCrossing intersection_impl( LineSegment const& ls1,
                             Ray const& r2,
                             unsigned int i );
}
 
 
inline
OptCrossing intersection(Ray const& r1, Line const& l2)
{
    return detail::intersection_impl(r1,  l2, 0);
 
}
 
inline
OptCrossing intersection(Line const& l1, Ray const& r2)
{
    return detail::intersection_impl(r2,  l1, 1);
}
 
inline
OptCrossing intersection(LineSegment const& ls1, Line const& l2)
{
    return detail::intersection_impl(ls1,  l2, 0);
}
 
inline
OptCrossing intersection(Line const& l1, LineSegment const& ls2)
{
    return detail::intersection_impl(ls2,  l1, 1);
}
 
inline
OptCrossing intersection(LineSegment const& ls1, Ray const& r2)
{
    return detail::intersection_impl(ls1,  r2, 0);
 
}
 
inline
OptCrossing intersection(Ray const& r1, LineSegment const& ls2)
{
    return detail::intersection_impl(ls2,  r1, 1);
}
 
 
OptCrossing intersection(Line const& l1, Line const& l2);
 
OptCrossing intersection(Ray const& r1, Ray const& r2);
 
OptCrossing intersection(LineSegment const& ls1, LineSegment const& ls2);
 
 
} // end namespace Geom
 
 
#endif // LIB2GEOM_SEEN_LINE_H
 
 
/*
  Local Variables:
  mode:c++
  c-file-style:"stroustrup"
  c-file-offsets:((innamespace . 0)(inline-open . 0)(case-label . +))
  indent-tabs-mode:nil
  fill-column:99
  End:
*/
// vim: filetype=cpp:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:fileencoding=utf-8:textwidth=99 :