Обнаружение столкновения круг-прямоугольник (пересечение)

вот как я бы сделал это:

bool intersects(CircleType circle, RectType rect)
{
    circleDistance.x = abs(circle.x - rect.x);
    circleDistance.y = abs(circle.y - rect.y);

    if (circleDistance.x > (rect.width/2 + circle.r)) { return false; }
    if (circleDistance.y > (rect.height/2 + circle.r)) { return false; }

    if (circleDistance.x <= (rect.width/2)) { return true; } 
    if (circleDistance.y <= (rect.height/2)) { return true; }

    cornerDistance_sq = (circleDistance.x - rect.width/2)^2 +
                         (circleDistance.y - rect.height/2)^2;

    return (cornerDistance_sq <= (circle.r^2));
}

вот как это работает:

1. первая пара линий вычисляет абсолютные значения разности x и y между центром круга и центром прямоугольника. Это приводит к тому, что четыре квадранта распадаются на один, так что вычисления не нужно делать четыре раза. На рисунке показана область, в которой теперь должен находиться центр круга. Обратите внимание, что только показан одиночный квадрант. Прямоугольник-это серая область, а красная граница очерчивает критическую область, которая находится ровно в одном радиусе от краев прямоугольника. Центр круга должен находиться в пределах этой красной границы, чтобы произошло пересечение.

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

3. третья пара линий обрабатывает простые случаи, когда круг достаточно близок к прямоугольнику (в любом направлении), что гарантируется пересечение. Это соответствует оранжевым и серым участкам изображения. Обратите внимание, что этот шаг должен быть сделан после шага 2, чтобы логика имела смысл.

4. остальные линии вычисляют сложный случай, когда окружность может пересекать угол прямоугольника. Чтобы решить, вычислите расстояние от центра круга и угла, а затем убедитесь, что расстояние не превышает радиуса окружности. Это вычисление возвращает false для всех кругов, центр которых находится в области красного оттенка, и true для всех кругов, центр которых находится в области белого оттенка.

вот еще одно решение, которое довольно просто реализовать (и довольно быстро). Он будет ловить все пересечения, в том числе, когда сфера полностью вошла в прямоугольник.

// clamp(value, min, max) - limits value to the range min..max

// Find the closest point to the circle within the rectangle
float closestX = clamp(circle.X, rectangle.Left, rectangle.Right);
float closestY = clamp(circle.Y, rectangle.Top, rectangle.Bottom);

// Calculate the distance between the circle's center and this closest point
float distanceX = circle.X - closestX;
float distanceY = circle.Y - closestY;

// If the distance is less than the circle's radius, an intersection occurs
float distanceSquared = (distanceX * distanceX) + (distanceY * distanceY);
return distanceSquared < (circle.Radius * circle.Radius);

С любой приличной математической библиотекой, которая может быть сокращена до 3 или 4 строк.

ваша сфера и прямая пересекаются IIF
расстояние между центром круга и одной вершиной прямой кишки меньше радиуса вашей сферы
Или
расстояние между центром круга и одним краем прямой кишки меньше радиуса сферы ([расстояние между точками ])
Или
центр круга находится внутри прямой кишки

точка-точка расстояние:

P1 = [x1,y1]
P2 = [x2,y2]
Distance = sqrt(abs(x1 - x2)+abs(y1-y2))

точка-линия расстояние:

L1 = [x1,y1],L2 = [x2,y2] (two points of your line, ie the vertex points)
P1 = [px,py] some point

Distance d =  abs( (x2-x1)(y1-py)-(x1-px)(y2-y1) ) / Distance(L1,L2)

центр круга внутри прямой кишки:
возьмите разделяющую ось: если существует проекция на линию, которая отделяет прямоугольник от точки, они не пересекаются

вы проецируете точку на линии, параллельные сторонам прямой кишки, и затем можете легко определить, пересекаются ли они. если они пересекаются не на всех 4 проекциях, они (точка и прямоугольник) не могут пересекаться.

нужно просто внутренний продукт (x= [x1,x2] , y = [y1,y2] , x*y = x1*y1 + x2*y2 )

ваш тест будет выглядеть так:

//rectangle edges: TL (top left), TR (top right), BL (bottom left), BR (bottom right)
//point to test: POI

seperated = false
for egde in { {TL,TR}, {BL,BR}, {TL,BL},{TR-BR} }:  // the edges
    D = edge[0] - edge[1]
    innerProd =  D * POI
    Interval_min = min(D*edge[0],D*edge[1])
    Interval_max = max(D*edge[0],D*edge[1])
    if not (  Interval_min ≤ innerProd ≤  Interval_max ) 
           seperated = true
           break  // end for loop 
    end if
end for
if (seperated is true)    
      return "no intersection"
else 
      return "intersection"
end if

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

Это самое быстрое решение:

public static boolean intersect(Rectangle r, Circle c)
{
    float cx = Math.abs(c.x - r.x - r.halfWidth);
    float xDist = r.halfWidth + c.radius;
    if (cx > xDist)
        return false;
    float cy = Math.abs(c.y - r.y - r.halfHeight);
    float yDist = r.halfHeight + c.radius;
    if (cy > yDist)
        return false;
    if (cx <= r.halfWidth || cy <= r.halfHeight)
        return true;
    float xCornerDist = cx - r.halfWidth;
    float yCornerDist = cy - r.halfHeight;
    float xCornerDistSq = xCornerDist * xCornerDist;
    float yCornerDistSq = yCornerDist * yCornerDist;
    float maxCornerDistSq = c.radius * c.radius;
    return xCornerDistSq + yCornerDistSq <= maxCornerDistSq;
}

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

на самом деле, это гораздо проще. Вам нужно только две вещи.

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

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

удачи!

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

float physicsProcessCollisionBetweenSelfAndActorRect(SPhysics *self, SPhysics *actor)
{
    float diff = 99999;

    SVector relative_position_of_circle = getDifference2DBetweenVectors(&self->worldPosition, &actor->worldPosition);
    rotateVector2DBy(&relative_position_of_circle, -actor->axis.angleZ); // This aligns the coord system so the rect becomes an AABB

    float x_clamped_within_rectangle = relative_position_of_circle.x;
    float y_clamped_within_rectangle = relative_position_of_circle.y;
    LIMIT(x_clamped_within_rectangle, actor->physicsRect.l, actor->physicsRect.r);
    LIMIT(y_clamped_within_rectangle, actor->physicsRect.b, actor->physicsRect.t);

    // Calculate the distance between the circle's center and this closest point
    float distance_to_nearest_edge_x = relative_position_of_circle.x - x_clamped_within_rectangle;
    float distance_to_nearest_edge_y = relative_position_of_circle.y - y_clamped_within_rectangle;

    // If the distance is less than the circle's radius, an intersection occurs
    float distance_sq_x = SQUARE(distance_to_nearest_edge_x);
    float distance_sq_y = SQUARE(distance_to_nearest_edge_y);
    float radius_sq = SQUARE(self->physicsRadius);
    if(distance_sq_x + distance_sq_y < radius_sq)   
    {
        float half_rect_w = (actor->physicsRect.r - actor->physicsRect.l) * 0.5f;
        float half_rect_h = (actor->physicsRect.t - actor->physicsRect.b) * 0.5f;

        CREATE_VECTOR(push_vector);         

        // If we're at one of the corners of this object, treat this as a circular/circular collision
        if(fabs(relative_position_of_circle.x) > half_rect_w && fabs(relative_position_of_circle.y) > half_rect_h)
        {
            SVector edges;
            if(relative_position_of_circle.x > 0) edges.x = half_rect_w; else edges.x = -half_rect_w;
            if(relative_position_of_circle.y > 0) edges.y = half_rect_h; else edges.y = -half_rect_h;   

            push_vector = relative_position_of_circle;
            moveVectorByInverseVector2D(&push_vector, &edges);

            // We now have the vector from the corner of the rect to the point.
            float delta_length = getVector2DMagnitude(&push_vector);
            float diff = self->physicsRadius - delta_length; // Find out how far away we are from our ideal distance

            // Normalise the vector
            push_vector.x /= delta_length;
            push_vector.y /= delta_length;
            scaleVector2DBy(&push_vector, diff); // Now multiply it by the difference
            push_vector.z = 0;
        }
        else // Nope - just bouncing against one of the edges
        {
            if(relative_position_of_circle.x > 0) // Ball is to the right
                push_vector.x = (half_rect_w + self->physicsRadius) - relative_position_of_circle.x;
            else
                push_vector.x = -((half_rect_w + self->physicsRadius) + relative_position_of_circle.x);

            if(relative_position_of_circle.y > 0) // Ball is above
                push_vector.y = (half_rect_h + self->physicsRadius) - relative_position_of_circle.y;
            else
                push_vector.y = -((half_rect_h + self->physicsRadius) + relative_position_of_circle.y);

            if(fabs(push_vector.x) < fabs(push_vector.y))
                push_vector.y = 0;
            else
                push_vector.x = 0;
        }

        diff = 0; // Cheat, since we don't do anything with the value anyway
        rotateVector2DBy(&push_vector, actor->axis.angleZ);
        SVector *from = &self->worldPosition;       
        moveVectorBy2D(from, push_vector.x, push_vector.y);
    }   
    return diff;
}

чтобы визуализировать, возьмите цифровую клавиатуру. Если ключ " 5 " представляет ваш прямоугольник, то все ключи 1-9 представляют 9 квадрантов пространства, разделенных линиями, которые составляют ваш прямоугольник (с 5 внутри.)

1) Если центр круга находится в квадранте 5 (т. е. внутри прямоугольника), то две фигуры пересекаются.

с этим из Пути, есть два возможных случая: a) окружность пересекается с двумя или более соседними краями прямоугольник. b) окружность пересекается с одним краем прямоугольника.

первый случай прост. Если круг пересекается с двумя соседними краями прямоугольника, он должен содержать угол, соединяющий эти два края. (Это, или его центр, находится в квадранте 5, который мы уже рассмотрели. Также обратите внимание, что случай, когда круг пересекается только с двумя противоположные края прямоугольника, а также.)

2) Если любой из углов A, B, C, D прямоугольник лежит внутри круга, затем две фигуры пересекаются.

второй случай сложнее. Следует отметить, что это может произойти только тогда, когда центр круга находится в одном из квадрантов 2, 4, 6 или 8. (Фактически, если центр находится в любом из квадрантов 1, 3, 7, 8, соответствующий угол будет ближайшей к нему точкой.)

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

3) для каждой линии AB, BC, CD, DA постройте перпендикулярные линии p(AB, P), p(BC, P), p(CD, P), p(DA, P) через центр окружности P. Для каждой перпендикулярной линии,если пересечение с исходным краем лежит внутри окружности, то две фигуры пересекаются.

существует ярлык для этого последнего шага. Если центр круга находится в квадранте 8, а край AB-верхний ребро, точка пересечения будет иметь y-координату A и B, а X-координату центра P.

вы можете построить четыре пересечения линий и проверить, лежат ли они на соответствующих ребрах, или узнать, в каком квадранте P, и проверить соответствующее пересечение. Оба должны быть упрощены до одного и того же логического уравнения. Будьте осторожны с тем, что Шаг 2 выше не исключал, что P находится в одном из "угловых" квадрантов; он просто искал пересечение.

изменить: Как оказалось, я упустил из виду тот простой факт, что #2 это ней из #3 выше. В конце концов, углы тоже являются точками по краям. См. ответ @ShreevatsaR ниже для отличного объяснения. И в то же время забудьте #2 выше, если вы не хотите быстрой, но избыточной проверки.

эта функция обнаруживает столкновения (пересечения) между кругом и прямоугольником. Он работает как Э. Метод Джеймса в своем ответе, но этот обнаруживает столкновения для всех углов прямоугольника (а не только для правого угла).

Примечание:

aRect.происхождение.x и aRect.происхождение.y - координаты нижнего левого угла прямоугольника!

круге составляет.x и круге составляет.y - координаты круга Центр!

static inline BOOL RectIntersectsCircle(CGRect aRect, Circle aCircle) {

    float testX = aCircle.x;
    float testY = aCircle.y;

    if (testX < aRect.origin.x)
        testX = aRect.origin.x;
    if (testX > (aRect.origin.x + aRect.size.width))
        testX = (aRect.origin.x + aRect.size.width);
    if (testY < aRect.origin.y)
        testY = aRect.origin.y;
    if (testY > (aRect.origin.y + aRect.size.height))
        testY = (aRect.origin.y + aRect.size.height);

    return ((aCircle.x - testX) * (aCircle.x - testX) + (aCircle.y - testY) * (aCircle.y - testY)) < aCircle.radius * aCircle.radius;
}

самое простое решение, которое я придумал, довольно просто.

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

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

public boolean intersects(float cx, float cy, float radius, float left, float top, float right, float bottom)
{
   float closestX = (cx < left ? left : (cx > right ? right : cx));
   float closestY = (cy < top ? top : (cy > bottom ? bottom : cy));
   float dx = closestX - cx;
   float dy = closestY - cy;

   return ( dx * dx + dy * dy ) <= radius * radius;
}

и это все! Вышеприведенное решение предполагает происхождение в верхнем левом углу мира с осью x, направленной вниз.

Если вы хотите решение для обработки столкновений между движущимся кругом и прямоугольником это намного сложнее и покрыто в другом моем ответе.

Я создал класс для работы с формами надеюсь, вам понравится

public class Geomethry {
  public static boolean intersectionCircleAndRectangle(int circleX, int circleY, int circleR, int rectangleX, int rectangleY, int rectangleWidth, int rectangleHeight){
    boolean result = false;

    float rectHalfWidth = rectangleWidth/2.0f;
    float rectHalfHeight = rectangleHeight/2.0f;

    float rectCenterX = rectangleX + rectHalfWidth;
    float rectCenterY = rectangleY + rectHalfHeight;

    float deltax = Math.abs(rectCenterX - circleX);
    float deltay = Math.abs(rectCenterY - circleY);

    float lengthHypotenuseSqure = deltax*deltax + deltay*deltay;

    do{
        // check that distance between the centerse is more than the distance between the circumcircle of rectangle and circle
        if(lengthHypotenuseSqure > ((rectHalfWidth+circleR)*(rectHalfWidth+circleR) + (rectHalfHeight+circleR)*(rectHalfHeight+circleR))){
            //System.out.println("distance between the centerse is more than the distance between the circumcircle of rectangle and circle");
            break;
        }

        // check that distance between the centerse is less than the distance between the inscribed circle
        float rectMinHalfSide = Math.min(rectHalfWidth, rectHalfHeight);
        if(lengthHypotenuseSqure < ((rectMinHalfSide+circleR)*(rectMinHalfSide+circleR))){
            //System.out.println("distance between the centerse is less than the distance between the inscribed circle");
            result=true;
            break;
        }

        // check that the squares relate to angles
        if((deltax > (rectHalfWidth+circleR)*0.9) && (deltay > (rectHalfHeight+circleR)*0.9)){
            //System.out.println("squares relate to angles");
            result=true;
        }
    }while(false);

    return result;
}

public static boolean intersectionRectangleAndRectangle(int rectangleX, int rectangleY, int rectangleWidth, int rectangleHeight, int rectangleX2, int rectangleY2, int rectangleWidth2, int rectangleHeight2){
    boolean result = false;

    float rectHalfWidth = rectangleWidth/2.0f;
    float rectHalfHeight = rectangleHeight/2.0f;
    float rectHalfWidth2 = rectangleWidth2/2.0f;
    float rectHalfHeight2 = rectangleHeight2/2.0f;

    float deltax = Math.abs((rectangleX + rectHalfWidth) - (rectangleX2 + rectHalfWidth2));
    float deltay = Math.abs((rectangleY + rectHalfHeight) - (rectangleY2 + rectHalfHeight2));

    float lengthHypotenuseSqure = deltax*deltax + deltay*deltay;

    do{
        // check that distance between the centerse is more than the distance between the circumcircle
        if(lengthHypotenuseSqure > ((rectHalfWidth+rectHalfWidth2)*(rectHalfWidth+rectHalfWidth2) + (rectHalfHeight+rectHalfHeight2)*(rectHalfHeight+rectHalfHeight2))){
            //System.out.println("distance between the centerse is more than the distance between the circumcircle");
            break;
        }

        // check that distance between the centerse is less than the distance between the inscribed circle
        float rectMinHalfSide = Math.min(rectHalfWidth, rectHalfHeight);
        float rectMinHalfSide2 = Math.min(rectHalfWidth2, rectHalfHeight2);
        if(lengthHypotenuseSqure < ((rectMinHalfSide+rectMinHalfSide2)*(rectMinHalfSide+rectMinHalfSide2))){
            //System.out.println("distance between the centerse is less than the distance between the inscribed circle");
            result=true;
            break;
        }

        // check that the squares relate to angles
        if((deltax > (rectHalfWidth+rectHalfWidth2)*0.9) && (deltay > (rectHalfHeight+rectHalfHeight2)*0.9)){
            //System.out.println("squares relate to angles");
            result=true;
        }
    }while(false);

    return result;
  } 
}

вот модифицированный код 100% работает:

public static bool IsIntersected(PointF circle, float radius, RectangleF rectangle)
{
    var rectangleCenter = new PointF((rectangle.X +  rectangle.Width / 2),
                                     (rectangle.Y + rectangle.Height / 2));

    var w = rectangle.Width  / 2;
    var h = rectangle.Height / 2;

    var dx = Math.Abs(circle.X - rectangleCenter.X);
    var dy = Math.Abs(circle.Y - rectangleCenter.Y);

    if (dx > (radius + w) || dy > (radius + h)) return false;

    var circleDistance = new PointF
                             {
                                 X = Math.Abs(circle.X - rectangle.X - w),
                                 Y = Math.Abs(circle.Y - rectangle.Y - h)
                             };

    if (circleDistance.X <= (w))
    {
        return true;
    }

    if (circleDistance.Y <= (h))
    {
        return true;
    }

    var cornerDistanceSq = Math.Pow(circleDistance.X - w, 2) + 
                                    Math.Pow(circleDistance.Y - h, 2);

    return (cornerDistanceSq <= (Math.Pow(radius, 2)));
}

Alugili Бассам

вот быстрый однострочный тест для этого:

if (length(max(abs(center - rect_mid) - rect_halves, 0)) <= radius ) {
  // They intersect.
}

это выровненный по оси случай, когда rect_halves - положительный вектор, указывающий от середины прямоугольника до угла. Выражение внутри length() является дельта-вектором от center до ближайшей точки в прямоугольник. Это работает в любом измерении.

• сначала проверьте, перекрываются ли прямоугольник и квадратная касательная к окружности (легко). Если они не перекрываются, они не сталкиваются.
• проверьте, находится ли центр круга внутри прямоугольника (легко). Если он внутри, они сталкиваются.
• вычислить минимальное квадратное расстояние от сторон прямоугольника до центра круга (немного трудно). Если радиус меньше квадратного, то они сталкиваются, иначе-нет.--2-->

это эффективно, потому что:

• сначала он проверяет наиболее распространенный сценарий с дешевым алгоритмом, и когда он уверен, что они не сталкиваются, он заканчивается.
• затем он проверяет следующий наиболее распространенный сценарий с дешевым алгоритмом (не вычисляйте квадратный корень, используйте квадратные значения), и когда он уверен, что они сталкиваются, он заканчивается.
• затем он выполняет более дорогой алгоритм для проверки столкновения с границами прямоугольника.

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

и это будет работать для неевклидова тоже:

class Circle {
 // create the bounding box of the circle only once
 BBox bbox;

 public boolean intersect(BBox b) {
    // test top intersect
    if (lat > b.maxLat) {
        if (lon < b.minLon)
            return normDist(b.maxLat, b.minLon) <= normedDist;
        if (lon > b.maxLon)
            return normDist(b.maxLat, b.maxLon) <= normedDist;
        return b.maxLat - bbox.minLat > 0;
    }

    // test bottom intersect
    if (lat < b.minLat) {
        if (lon < b.minLon)
            return normDist(b.minLat, b.minLon) <= normedDist;
        if (lon > b.maxLon)
            return normDist(b.minLat, b.maxLon) <= normedDist;
        return bbox.maxLat - b.minLat > 0;
    }

    // test middle intersect
    if (lon < b.minLon)
        return bbox.maxLon - b.minLon > 0;
    if (lon > b.maxLon)
        return b.maxLon - bbox.minLon > 0;
    return true;
  }
}

• minLat, maxLat можно заменить на minY, maxY и то же самое для minLon, maxLon: замените его на minX, maxX
• normDist ist просто немного быстрее, чем метод расчета полного расстояния. Е. Г. без квадратного корня в евклидовом пространстве (или без много других вещей для haversine):dLat=(lat-circleY); dLon=(lon-circleX); normed=dLat*dLat+dLon*dLon. Конечно, если вы используете этот метод normDist, вам нужно будет создать normedDist = dist*dist; круг

посмотреть полный BBox и круг код GraphHopper.

для тех, кто должен вычислить столкновение круга / прямоугольника в географических координатах с SQL,
это моя реализация в Oracle 11 из e.Джеймс предложил алгоритм.

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

CREATE OR REPLACE FUNCTION "DETECT_CIRC_RECT_COLLISION"
(
    circleCenterLat     IN NUMBER,      -- circle Center Latitude
    circleCenterLon     IN NUMBER,      -- circle Center Longitude
    circleRadius        IN NUMBER,      -- circle Radius in KM
    rectSWLat           IN NUMBER,      -- rectangle South West Latitude
    rectSWLon           IN NUMBER,      -- rectangle South West Longitude
    rectNELat           IN NUMBER,      -- rectangle North Est Latitude
    rectNELon           IN NUMBER       -- rectangle North Est Longitude
)
RETURN NUMBER
AS
    -- converts km to degrees (use 69 if miles)
    kmToDegreeConst     NUMBER := 111.045;

    -- Remaining rectangle vertices 
    rectNWLat   NUMBER;
    rectNWLon   NUMBER;
    rectSELat   NUMBER;
    rectSELon   NUMBER;

    rectHeight  NUMBER;
    rectWIdth   NUMBER;

    circleDistanceLat   NUMBER;
    circleDistanceLon   NUMBER;
    cornerDistanceSQ    NUMBER;

BEGIN
    -- Initialization of remaining rectangle vertices  
    rectNWLat := rectNELat;
    rectNWLon := rectSWLon;
    rectSELat := rectSWLat;
    rectSELon := rectNELon;

    -- Rectangle sides length calculation
    rectHeight := calc_distance(rectSWLat, rectSWLon, rectNWLat, rectNWLon);
    rectWidth := calc_distance(rectSWLat, rectSWLon, rectSELat, rectSELon);

    circleDistanceLat := abs( (circleCenterLat * kmToDegreeConst) - ((rectSWLat * kmToDegreeConst) + (rectHeight/2)) );
    circleDistanceLon := abs( (circleCenterLon * kmToDegreeConst) - ((rectSWLon * kmToDegreeConst) + (rectWidth/2)) );

    IF circleDistanceLon > ((rectWidth/2) + circleRadius) THEN
        RETURN -1;   --  -1 => NO Collision ; 0 => Collision Detected
    END IF;

    IF circleDistanceLat > ((rectHeight/2) + circleRadius) THEN
        RETURN -1;   --  -1 => NO Collision ; 0 => Collision Detected
    END IF;

    IF circleDistanceLon <= (rectWidth/2) THEN
        RETURN 0;   --  -1 => NO Collision ; 0 => Collision Detected
    END IF;

    IF circleDistanceLat <= (rectHeight/2) THEN
        RETURN 0;   --  -1 => NO Collision ; 0 => Collision Detected
    END IF;


    cornerDistanceSQ := POWER(circleDistanceLon - (rectWidth/2), 2) + POWER(circleDistanceLat - (rectHeight/2), 2);

    IF cornerDistanceSQ <=  POWER(circleRadius, 2) THEN
        RETURN 0;  --  -1 => NO Collision ; 0 => Collision Detected
    ELSE
        RETURN -1;  --  -1 => NO Collision ; 0 => Collision Detected
    END IF;

    RETURN -1;  --  -1 => NO Collision ; 0 => Collision Detected
END;    

работает, только что понял это неделю назад, и только сейчас приступил к тестированию.

double theta = Math.atan2(cir.getX()-sqr.getX()*1.0,
                          cir.getY()-sqr.getY()*1.0); //radians of the angle
double dBox; //distance from box to edge of box in direction of the circle

if((theta >  Math.PI/4 && theta <  3*Math.PI / 4) ||
   (theta < -Math.PI/4 && theta > -3*Math.PI / 4)) {
    dBox = sqr.getS() / (2*Math.sin(theta));
} else {
    dBox = sqr.getS() / (2*Math.cos(theta));
}
boolean touching = (Math.abs(dBox) >=
                    Math.sqrt(Math.pow(sqr.getX()-cir.getX(), 2) +
                              Math.pow(sqr.getY()-cir.getY(), 2)));

предполагая, что у вас есть четыре края прямоугольника, проверьте расстояние от краев до центра круга, если его меньше радиуса, то фигуры пересекаются.

if sqrt((rectangleRight.x - circleCenter.x)^2 +
        (rectangleBottom.y - circleCenter.y)^2) < radius
// then they intersect

if sqrt((rectangleRight.x - circleCenter.x)^2 +
        (rectangleTop.y - circleCenter.y)^2) < radius
// then they intersect

if sqrt((rectangleLeft.x - circleCenter.x)^2 +
        (rectangleTop.y - circleCenter.y)^2) < radius
// then they intersect

if sqrt((rectangleLeft.x - circleCenter.x)^2 +
        (rectangleBottom.y - circleCenter.y)^2) < radius
// then they intersect

Если прямоугольник пересекается с кругом, один или несколько угловых точек прямоугольника должны быть внутри круга. Предположим, что четыре точки прямоугольника-A,B,C,D. По крайней мере одна из них должна пересекать круг. поэтому, если расстояние от одной точки до центра круга меньше радиуса круга, он должен пересекать круг. Чтобы получить расстояние, вы можете использовать теорему Пифагора,

H^2 = A^2 + B^2

эта техника имеет некоторые ограничения. Но это будет работать лучше для разработчиков игр. особенно обнаружение столкновений

Это хорошее обновление алгоритма Арво