juce_Line.h

Go to the documentation of this file.

/*
  ==============================================================================
 
   This file is part of the JUCE library.
   Copyright (c) 2022 - Raw Material Software Limited
 
   JUCE is an open source library subject to commercial or open-source
   licensing.
 
   By using JUCE, you agree to the terms of both the JUCE 7 End-User License
   Agreement and JUCE Privacy Policy.
 
   End User License Agreement: www.juce.com/juce-7-licence
   Privacy Policy: www.juce.com/juce-privacy-policy
 
   Or: You may also use this code under the terms of the GPL v3 (see
   www.gnu.org/licenses).
 
   JUCE IS PROVIDED "AS IS" WITHOUT ANY WARRANTY, AND ALL WARRANTIES, WHETHER
   EXPRESSED OR IMPLIED, INCLUDING MERCHANTABILITY AND FITNESS FOR PURPOSE, ARE
   DISCLAIMED.
 
  ==============================================================================
*/
 
namespace juce
{
 
//==============================================================================
template <typename ValueType>
class Line
{
public:
    //==============================================================================
    Line() = default;

    Line (const Line&) = default;

    Line (ValueType startX, ValueType startY, ValueType endX, ValueType endY) noexcept
        : start (startX, startY), end (endX, endY)
    {
    }

    Line (Point<ValueType> startPoint, Point<ValueType> endPoint) noexcept
        : start (startPoint), end (endPoint)
    {
    }

    Line& operator= (const Line&) = default;

    ~Line() = default;
 
    //==============================================================================
    inline ValueType getStartX() const noexcept                             { return start.x; }

    inline ValueType getStartY() const noexcept                             { return start.y; }

    inline ValueType getEndX() const noexcept                               { return end.x; }

    inline ValueType getEndY() const noexcept                               { return end.y; }

    inline Point<ValueType> getStart() const noexcept                       { return start; }

    inline Point<ValueType> getEnd() const noexcept                         { return end; }

    void setStart (ValueType newStartX, ValueType newStartY) noexcept       { start.setXY (newStartX, newStartY); }

    void setEnd (ValueType newEndX, ValueType newEndY) noexcept             { end.setXY (newEndX, newEndY); }

    void setStart (const Point<ValueType> newStart) noexcept                { start = newStart; }

    void setEnd (const Point<ValueType> newEnd) noexcept                    { end = newEnd; }

    Line reversed() const noexcept                                          { return { end, start }; }

    void applyTransform (const AffineTransform& transform) noexcept
    {
        start.applyTransform (transform);
        end.applyTransform (transform);
    }
 
    //==============================================================================
    ValueType getLength() const noexcept                                    { return start.getDistanceFrom (end); }

    ValueType getLengthSquared() const noexcept                             { return start.getDistanceSquaredFrom (end); }

    bool isVertical() const noexcept                                        { return start.x == end.x; }

    bool isHorizontal() const noexcept                                      { return start.y == end.y; }

    typename Point<ValueType>::FloatType getAngle() const noexcept          { return start.getAngleToPoint (end); }

    static Line fromStartAndAngle (Point<ValueType> startPoint, ValueType length, ValueType angle) noexcept
    {
        return { startPoint, startPoint.getPointOnCircumference (length, angle) };
    }
 
    //==============================================================================
    Line<float> toFloat() const noexcept                                    { return { start.toFloat(), end.toFloat() }; }

    Line<double> toDouble() const noexcept                                  { return { start.toDouble(), end.toDouble() }; }
 
    //==============================================================================
    bool operator== (Line other) const noexcept                             { return start == other.start && end == other.end; }

    bool operator!= (Line other) const noexcept                             { return start != other.start || end != other.end; }
 
    //==============================================================================
    Point<ValueType> getIntersection (Line line) const noexcept
    {
        Point<ValueType> p;
        findIntersection (start, end, line.start, line.end, p);
        return p;
    }

    bool intersects (Line line, Point<ValueType>& intersection) const noexcept
    {
        return findIntersection (start, end, line.start, line.end, intersection);
    }

    bool intersects (Line other) const noexcept
    {
        Point<ValueType> ignored;
        return findIntersection (start, end, other.start, other.end, ignored);
    }
 
    //==============================================================================
    Point<ValueType> getPointAlongLine (ValueType distanceFromStart) const noexcept
    {
        const auto length = getLength();
        return length == 0 ? start : start + (end - start) * (distanceFromStart / length);
    }

    Point<ValueType> getPointAlongLine (ValueType distanceFromStart,
                                        ValueType perpendicularDistance) const noexcept
    {
        auto delta = end - start;
        auto length = juce_hypot ((double) delta.x,
                                  (double) delta.y);
        if (length <= 0)
            return start;
 
        return { start.x + static_cast<ValueType> ((delta.x * distanceFromStart - delta.y * perpendicularDistance) / length),
                 start.y + static_cast<ValueType> ((delta.y * distanceFromStart + delta.x * perpendicularDistance) / length) };
    }

    Point<ValueType> getPointAlongLineProportionally (typename Point<ValueType>::FloatType proportionOfLength) const noexcept
    {
        return start + (end - start) * proportionOfLength;
    }

    ValueType getDistanceFromPoint (Point<ValueType> targetPoint,
                                    Point<ValueType>& pointOnLine) const noexcept
    {
        auto delta = end - start;
        auto length = delta.x * delta.x + delta.y * delta.y;
 
        if (length > 0)
        {
            auto prop = ((targetPoint.x - start.x) * delta.x
                       + (targetPoint.y - start.y) * delta.y) / (double) length;
 
            if (prop >= 0 && prop <= 1.0)
            {
                pointOnLine = start + delta * prop;
                return targetPoint.getDistanceFrom (pointOnLine);
            }
        }
 
        auto fromStart = targetPoint.getDistanceFrom (start);
        auto fromEnd   = targetPoint.getDistanceFrom (end);
 
        if (fromStart < fromEnd)
        {
            pointOnLine = start;
            return fromStart;
        }
 
        pointOnLine = end;
        return fromEnd;
    }

    ValueType findNearestProportionalPositionTo (Point<ValueType> point) const noexcept
    {
        auto delta = end - start;
        auto length = delta.x * delta.x + delta.y * delta.y;
 
        return length <= 0 ? 0
                           : jlimit (ValueType(), static_cast<ValueType> (1),
                                     static_cast<ValueType> ((((point.x - start.x) * delta.x
                                                             + (point.y - start.y) * delta.y) / length)));
    }

    Point<ValueType> findNearestPointTo (Point<ValueType> point) const noexcept
    {
        return getPointAlongLineProportionally (findNearestProportionalPositionTo (point));
    }

    bool isPointAbove (Point<ValueType> point) const noexcept
    {
        return start.x != end.x
                && point.y < ((end.y - start.y) * (point.x - start.x)) / (end.x - start.x) + start.y;
    }

    Line withLengthenedStart (ValueType distanceToLengthenBy) const noexcept
    {
        return withShortenedStart (-distanceToLengthenBy);
    }
 
    //==============================================================================
    Line withShortenedStart (ValueType distanceToShortenBy) const noexcept
    {
        return { getPointAlongLine (jmin (distanceToShortenBy, getLength())), end };
    }

    Line withLengthenedEnd (ValueType distanceToLengthenBy) const noexcept
    {
        return withShortenedEnd (-distanceToLengthenBy);
    }

    Line withShortenedEnd (ValueType distanceToShortenBy) const noexcept
    {
        auto length = getLength();
        return { start, getPointAlongLine (length - jmin (distanceToShortenBy, length)) };
    }
 
private:
    //==============================================================================
    Point<ValueType> start, end;
 
    static bool isZeroToOne (ValueType v) noexcept      { return v >= 0 && v <= static_cast<ValueType> (1); }
 
    static bool findIntersection (const Point<ValueType> p1, const Point<ValueType> p2,
                                  const Point<ValueType> p3, const Point<ValueType> p4,
                                  Point<ValueType>& intersection) noexcept
    {
        if (p2 == p3)
        {
            intersection = p2;
            return true;
        }
 
        auto d1 = p2 - p1;
        auto d2 = p4 - p3;
        auto divisor = d1.x * d2.y - d2.x * d1.y;
 
        if (divisor == 0)
        {
            if (! (d1.isOrigin() || d2.isOrigin()))
            {
                if (d1.y == 0 && d2.y != 0)
                {
                    auto along = (p1.y - p3.y) / d2.y;
                    intersection = p1.withX (p3.x + along * d2.x);
                    return isZeroToOne (along);
                }
 
                if (d2.y == 0 && d1.y != 0)
                {
                    auto along = (p3.y - p1.y) / d1.y;
                    intersection = p3.withX (p1.x + along * d1.x);
                    return isZeroToOne (along);
                }
 
                if (d1.x == 0 && d2.x != 0)
                {
                    auto along = (p1.x - p3.x) / d2.x;
                    intersection = p1.withY (p3.y + along * d2.y);
                    return isZeroToOne (along);
                }
 
                if (d2.x == 0 && d1.x != 0)
                {
                    auto along = (p3.x - p1.x) / d1.x;
                    intersection = p3.withY (p1.y + along * d1.y);
                    return isZeroToOne (along);
                }
            }
 
            intersection = (p2 + p3) / static_cast<ValueType> (2);
            return false;
        }
 
        auto along1 = ((p1.y - p3.y) * d2.x - (p1.x - p3.x) * d2.y) / divisor;
        intersection = p1 + d1 * along1;
 
        if (! isZeroToOne (along1))
            return false;
 
        auto along2 = ((p1.y - p3.y) * d1.x - (p1.x - p3.x) * d1.y) / divisor;
        return isZeroToOne (along2);
    }
};
 
} // namespace juce