Как узнать, пересекает ли линия прямоугольник

к сожалению, неправильный ответ был проголосован. Это очень дорого, чтобы вычислить фактические точки пересечения, вам нужны только сравнения. Ключевое слово для поиска - "обрезка строк" (http://en.wikipedia.org/wiki/Line_clipping). Википедия рекомендует алгоритм Коэна-Сазерленда (http://en.wikipedia.org/wiki/Cohen%E2%80%93Sutherland) Когда вы хотите быстрые отклонения, что, вероятно, является наиболее распространенным сценарием. Есть C++-реализация на страница Википедии. Если вы не заинтересованы в том, чтобы обрезать линию, вы можете пропустить большую ее часть. Ответ @Johann очень похож на этот алгоритм, но я не рассматривал его подробно.

алгоритм грубой силы...

сначала проверьте, находится ли прямая кишка слева или справа от конечных точек линии:

• установите самые левые и самые правые значения X конечных точек линии: XMIN и XMAX
• Если Rect.Слева > XMAX, затем нет пересечения.
• Если Rect.Справа

затем, если выше было недостаточно, чтобы исключить пересечение, проверьте, находится ли прямая линия выше или ниже линии конечные точки:

• установите самые верхние и самые нижние значения Y конечных точек линии: YMAX и YMIN
• Если Rect.Внизу > YMAX, затем нет пересечения.
• Если Rect.Top

тогда, если вышеизложенного было недостаточно, чтобы исключить пересечение, вам нужно проверить уравнение линии,y = m * x + b, чтобы увидеть, находится ли прямая кишка над линией:

• установите y-значение линии в Rect.Влево и Прямоугольник.Справа: LINEYRECTLEFT и LINEYRECTRIGHT
• Если Rect.Дно > LINEYRECTRIGHT & & Rect.Внизу > LINEYRECTLEFT, затем нет пересечения.

затем, если выше было недостаточно, чтобы исключить пересечение, вам нужно проверить, находится ли прямая кишка ниже линии:

• Если Rect.Top

потом, если вы получите здесь:

• перекресток.

некоторый непроверенный и некомпилированный код, чтобы пойти с этим:

public struct Line
{
    public int XMin { get { ... } }
    public int XMax { get { ... } }

    public int YMin { get { ... } }
    public int YMax { get { ... } }

    public Line(Point a, Point b) { ... }

    public float CalculateYForX(int x) { ... }
}

public bool Intersects(Point a, Point b, Rectangle r)
{
    var line = new Line(a, b);

    if (r.Left > line.XMax || r.Right < line.XMin)
    {
        return false;
    }

    if (r.Top < line.YMin || r.Bottom > line.YMax)
    {
        return false;
    }

    var yAtRectLeft = line.CalculateYForX(r.Left);
    var yAtRectRight = line.CalculateYForX(r.Right);

    if (r.Bottom > yAtRectLeft && r.Bottom > yAtRectRight)
    {
        return false;
    }

    if (r.Top < yAtRectLeft && r.Top < yAtRectRight)
    {
        return false;
    }

    return true;
}

Я взял решение ХАБДЖАНА, которое хорошо работало, и преобразовал его в Objective-C. Код Objective-C выглядит следующим образом:

bool LineIntersectsLine(CGPoint l1p1, CGPoint l1p2, CGPoint l2p1, CGPoint l2p2)
{
    CGFloat q = (l1p1.y - l2p1.y) * (l2p2.x - l2p1.x) - (l1p1.x - l2p1.x) * (l2p2.y - l2p1.y);
    CGFloat d = (l1p2.x - l1p1.x) * (l2p2.y - l2p1.y) - (l1p2.y - l1p1.y) * (l2p2.x - l2p1.x);

    if( d == 0 )
    {
        return false;
    }

    float r = q / d;

    q = (l1p1.y - l2p1.y) * (l1p2.x - l1p1.x) - (l1p1.x - l2p1.x) * (l1p2.y - l1p1.y);
    float s = q / d;

    if( r < 0 || r > 1 || s < 0 || s > 1 )
    {
        return false;
    }

    return true;
}

bool LineIntersectsRect(CGPoint p1, CGPoint p2, CGRect r)
{
    return LineIntersectsLine(p1, p2, CGPointMake(r.origin.x, r.origin.y), CGPointMake(r.origin.x + r.size.width, r.origin.y)) ||
    LineIntersectsLine(p1, p2, CGPointMake(r.origin.x + r.size.width, r.origin.y), CGPointMake(r.origin.x + r.size.width, r.origin.y + r.size.height)) ||
    LineIntersectsLine(p1, p2, CGPointMake(r.origin.x + r.size.width, r.origin.y + r.size.height), CGPointMake(r.origin.x, r.origin.y + r.size.height)) ||
    LineIntersectsLine(p1, p2, CGPointMake(r.origin.x, r.origin.y + r.size.height), CGPointMake(r.origin.x, r.origin.y)) ||
    (CGRectContainsPoint(r, p1) && CGRectContainsPoint(r, p2));
}

большое спасибо HABJAN. Я отмечу, что сначала я написал свою собственную программу, которая проверяла каждую точку вдоль градиента, и я сделал все, что мог, чтобы максимизировать производительность, но это было сразу намного быстрее.

этот код имеет лучшую производительность:

    public static bool SegmentIntersectRectangle(
        double rectangleMinX,
        double rectangleMinY,
        double rectangleMaxX,
        double rectangleMaxY,
        double p1X,
        double p1Y,
        double p2X,
        double p2Y)
    {
        // Find min and max X for the segment
        double minX = p1X;
        double maxX = p2X;

        if (p1X > p2X)
        {
            minX = p2X;
            maxX = p1X;
        }

        // Find the intersection of the segment's and rectangle's x-projections
        if (maxX > rectangleMaxX)
        {
            maxX = rectangleMaxX;
        }

        if (minX < rectangleMinX)
        {
            minX = rectangleMinX;
        }

        if (minX > maxX) // If their projections do not intersect return false
        {
            return false;
        }

        // Find corresponding min and max Y for min and max X we found before
        double minY = p1Y;
        double maxY = p2Y;

        double dx = p2X - p1X;

        if (Math.Abs(dx) > 0.0000001)
        {
            double a = (p2Y - p1Y)/dx;
            double b = p1Y - a*p1X;
            minY = a*minX + b;
            maxY = a*maxX + b;
        }

        if (minY > maxY)
        {
            double tmp = maxY;
            maxY = minY;
            minY = tmp;
        }

        // Find the intersection of the segment's and rectangle's y-projections
        if (maxY > rectangleMaxY)
        {
            maxY = rectangleMaxY;
        }

        if (minY < rectangleMinY)
        {
            minY = rectangleMinY;
        }

        if (minY > maxY) // If Y-projections do not intersect return false
        {
            return false;
        }

        return true;
    }

вы также можете проверить, как это работает в JS demo:http://jsfiddle.net/77eej/2/

Если у вас есть две точки и Rect, вы можете вызвать эту функцию следующим образом:

    public static bool LineIntersectsRect(Point p1, Point p2, Rect r)
    {
        return SegmentIntersectRectangle(r.X, r.Y, r.X + r.Width, r.Y + r.Height, p1.X, p1.Y, p2.X, p2.Y);
    }

нет простого предопределенного метода .NET, который вы можете вызвать для этого. Однако, используя Win32 API, есть довольно простой способ сделать это (легко в смысле реализации, производительность не является сильной стороной):LineDDA

BOOL LineDDA(int nXStart,int nYStart,int nXEnd,int nYEnd,LINEDDAPROC lpLineFunc,LPARAM lpData)

эта функция вызывает функцию обратного вызова для каждого пикселя на линию. В этой функции вы можете проверить, находится ли пиксель внутри вашего прямоугольника - если вы его найдете, то он пересекается.

Как Я ВОФК, это не самое быстрое решение, но довольно легко реализовать. Чтобы использовать его в C#, вам, конечно, нужно будет ddlimport его из gdi32.файл DLL.

[DllImport("gdi32.dll")] public static extern int LineDDA(int n1,int n2,int n3,int n4,int lpLineDDAProc,int lParam);

самый простой метод вычислительной геометрии - просто пройти через сегменты многоугольника и посмотреть, пересекается ли он с любым из них, так как он также должен пересекать многоугольник.

единственное предостережение этого метода (и большинства CG) заключается в том, что мы должны быть осторожны с крайними случаями. Что делать, если линия пересекает прямоугольник в точке - мы считаем это пересечением или нет? Будьте осторожны в своей реализации.

редактировать: типичный инструмент для линия-пересечение-сегмент расчета -LeftOf(Ray, Point) test, который возвращается, если точка находится слева от луча. Дана строка l (который мы используем как луч) и сегмент, содержащий точки a и b, линия пересекает сегмент, если одна точка находится слева, а одна точка-нет:

(LeftOf(l,a) && !LeftOf(l,b)) || (LeftOf(l,b) && !LeftOf(l,a))

опять же, вам нужно следить за краевыми случаями, когда точка находится на линии, но зависит от того, как вы хотите фактически определить пересечение.

для Unity (инвертирует y!). Это заботится о делении на ноль, что другие подходы здесь имеют:

using System;
using UnityEngine;

namespace Util {
    public static class Math2D {

        public static bool Intersects(Vector2 a, Vector2 b, Rect r) {
            var minX = Math.Min(a.x, b.x);
            var maxX = Math.Max(a.x, b.x);
            var minY = Math.Min(a.y, b.y);
            var maxY = Math.Max(a.y, b.y);

            if (r.xMin > maxX || r.xMax < minX) {
                return false;
            }

            if (r.yMin > maxY || r.yMax < minY) {
                return false;
            }

            if (r.xMin < minX && maxX < r.xMax) {
                return true;
            }

            if (r.yMin < minY && maxY < r.yMax) {
                return true;
            }

            Func<float, float> yForX = x => a.y - (x - a.x) * ((a.y - b.y) / (b.x - a.x));

            var yAtRectLeft = yForX(r.xMin);
            var yAtRectRight = yForX(r.xMax);

            if (r.yMax < yAtRectLeft && r.yMax < yAtRectRight) {
                return false;
            }

            if (r.yMin > yAtRectLeft && r.yMin > yAtRectRight) {
                return false;
            }

            return true;
        }
    }
}