Algorithm to detect intersection between an axis-aligned rectangle and an oriented superellipse

Question

I am in the process of writing a function to test for the intersection of a rectangle with a superellipse. The rectangle will always be axis-aligned whereas the superellipse may be oriented with an angle of rotation alpha.

In the case of an axis-aligned rectangle intersecting an axis-aligned superellipse I have written these two short functions that work beautifully. The code is concise, clear and efficient. If possible, I would like to keep a similar structure for the new more general function.

Here is what I have for detecting if an axis-aligned rectangle intersects an axis-aligned superellipse:

double fclamp(double x, double min, double max)
{
    if (x <= min) return min;
    if (x >= max) return max;
    return x;
}

bool rect_intersects_superellipse(const t_rect *rect, double cx, double cy, double rx, double ry, double exponent)
{
    t_pt closest;
    closest.x = fclamp(cx, rect->x, rect->x + rect->width);
    closest.y = fclamp(cy, rect->y, rect->y + rect->height);
    return point_inside_superellipse(&closest, cx, cy, rx, ry, exponent);
}

bool point_inside_superellipse(const t_pt *pt, double cx, double cy, double rx, double ry, double exponent)
{
    double dx = fabs(pt->x - cx);
    double dy = fabs(pt->y - cy);

    double dxp = pow(dx, exponent);
    double dyp = pow(dy, exponent);

    double rxp = pow(rx, exponent);
    double ryp = pow(ry, exponent);

    return (dxp * ryp + dyp * rxp) <= (rxp * ryp);
}

This works correctly but - as I said - only for an axis-aligned superellipse.

Now I would like to generalize it to an oriented superellipse, keeping the algorithm structure as close to the above as possible. The obvious expansion of the previous two functions would then become something like:

bool rect_intersects_oriented_superellipse(const t_rect *rect, double cx, double cy, double rx, double ry, double exponent, double radians)
{
    t_pt closest;
    closest.x = fclamp(cx, rect->x, rect->x + rect->width);
    closest.y = fclamp(cy, rect->y, rect->y + rect->height);
    return point_inside_oriented_superellipse(&closest, cx, cy, rx, ry, exponent, radians);
}

bool point_inside_oriented_superellipse(const t_pt *pt, double cx, double cy, double rx, double ry, double exponent, double radians)
{
    double dx = pt->x - cx;
    double dy = pt->y - cy;

    if (radians) {

        double c = cos(radians);
        double s = sin(radians);

        double new_x = dx * c - dy * s;
        double new_y = dx * s + dy * c;

        dx = new_x;
        dy = new_y;
    }
    double dxp = pow(fabs(dx), exponent);
    double dyp = pow(fabs(dy), exponent);

    double rxp = pow(rx, exponent);
    double ryp = pow(ry, exponent);

    return (dxp * ryp + dyp * rxp) < (rxp * ryp);
}

For an oriented superellipse, the above doesn’t work correctly, even though point_inside_oriented_superellipse() by itself works as expected. I cannot use the above functions to test for an intersection with an axis-aligned rectangle. I have been researching online for about a week now and I have found some solutions requiring an inverse matrix transform to equalize the superellipse axes and bring its origin at (0, 0). The tradeoff is that now my rectangle won’t be a rectangle anymore and certainly not axis-aligned. I would like to avoid going down that route. My question is to show how to make the above algorithm work keeping its structure more or less unaltered. If it is not possible to keep the same algorithmic structure, please show the simplest, most efficient algorithm to test for the intersection between an axis-aligned rectangle and an oriented superellipse. I only need to know if the intersection occurred or not (boolean result). The range of the exponent parameter can vary from 0.25 to 100.0.

Thanks for any assistance.

Answer 1

First you should rule out the obvious non-intersecting cases using the separating axis theorem -- The super-ellipse has possibly two bounding boxes (cases where exponent n>1) and case where n<=1.

In the SAT, all vertices in Bounding Box ABCD are compared against all (directed) edges in the BB(abcd) of super-ellipse; then vice versa. If the signed distances to the separating axis are all positive (i.e. outside), the objects don't collide.

          b
       a  
   A------B
   |      |     d
   |      |  c
   C------D

The exponent n==1 divides the cases further -- n<=1 makes the super-ellipsoid concave, in which case ABCD intersects abcd only, if one or more points are inside the super-ellipsoid. When n>1, one must solve the intersection point of the line segment in AABB and the super-ellipsoid, which may have to be approximated by splines or another proxy must be found. After all, the actual intersection point is not of interest, but putting the equations to wolfram alpha failed to produce any results in standard execution time.

Answer 2

Take a look at point 2 in this source. In simple terms, you will need to do the following tests:

1. Are there any rectangle vertexes in the ellipse?

2. Is a rectangle edge intersecting the ellipse?

3. Is the center of the ellipse inside the rectangle?

The ellipse and the rectangle intersect each-other if any of the questions above can be answered with a yes, so, your function should return something like this:

return areVertexesInsideEllipse(/*params*/) || areRectangleEdgesIntersectingEllipse(/*params*/) || isEllipseCenterInsideRectangle(/*params*/);

The doc even has an example of implementation, which is reasonably close to yours.

To check whether any of the vertex is inside the ellipse, you can compute their coordinates against the inequality of the ellipse. To check whether an edge overlaps the ellipse, you will need to check whether its line goes through the ellipse or touches it. If so, you will need to check whether the segment where the line goes through the ellipse or touches it intersects the segment defined by the edge. To check whether the center of the ellipse is inside the rectangle you will need to check the center against the inequalities of the rectangle.

Note, that these are very general terms, they do not even assume that your rectangle is axis oriented, yet alone your ellipse.