How to find minimum translation vector of rotated squares?

Question

I've made a collision detection algorithm that can detect if rotated squares are colliding. I am struggling to understand what I should do to resolve these collisions. I think the first step is to calculate a minimum translation vector (MTV) that can separate the two squares.

I think the way to do this is by calculating the overlap of the projections of the squares on the axes that are being tested, and then use the length of the smallest overlap and the angle of that axis to form the MTV.

The problem is my code doesn't work by comparing projections but instead uses this code to detect collisions:

double DotProduct(Vector vector0, Vector vector1)
{
    return (vector0.X * vector1.X) + (vector0.Y * vector1.Y);
}

bool TestIfPointIsInFrontOfEdge(int edgeNormalIndex, int vertexToTestIndex, Box observerBox, Box observedBox)
{
    // if (v - a) · n > 0 then vertex is in front of edge
    // v is the vertex to test
    // a is a vertex on the edge that relates to the edge normal
    // n is the edge normal

    Vector v = new Vector(observedBox.vertices[vertexToTestIndex].X, observedBox.vertices[vertexToTestIndex].Y);
    Vector a = new Vector(observerBox.vertices[edgeNormalIndex].X, observerBox.vertices[edgeNormalIndex].Y);
    Vector n = observerBox.edgeNormals[edgeNormalIndex];

    Vector vMinusA = Vector.Subtract(v, a);
    double dotProduct = DotProduct(vMinusA, n);

    //Console.WriteLine(dotProduct);

    return dotProduct > 0;
}

bool TestIfAllPointsAreInFrontOfEdge(int edgeIndex, Box observerBox, Box observedBox)
{
    for (int i = 0; i < observedBox.vertices.Length; i++)
    {
        if (!TestIfPointIsInFrontOfEdge(edgeIndex, i, observerBox, observedBox))
        {
            return false;
        }
    }

    return true;
}

bool TestIfAllPointsAreInFrontOfAnyEdge(Box observerBox, Box observedBox)
{
    for (int i = 0; i < observerBox.edgeNormals.Length; i++)
    {
        if (TestIfAllPointsAreInFrontOfEdge(i, observerBox, observedBox))
            return true;
    }

    return false;
}

bool TestBoxOverlap(Box observerBox, Box observedBox)
{
    if (TestIfAllPointsAreInFrontOfAnyEdge(observerBox, observedBox) || TestIfAllPointsAreInFrontOfAnyEdge(observedBox, observerBox))
        return false;

    return true;
}

Each Box contains an array of four PointF objects which represent the vertices (Box.vertices). They also contain an array of four Vector objects which are normalised (unit) vectors that represent the normals to each of the edges (Box.edgeNormals).

I then call this function for each box to check if there is a collision:

if (TestBoxOverlap(observerBox, observedBox))
{
    narrowPhaseCollisionList.Add(collision);
}

collision is a two element array containing observerBox and observedBox.

---

So how do I calculate the MTV?

Also how do I apply it to the boxes?

• Only translate one box with the MTV?
• Translate each box away from each other with half the MTV?
• Somehow weight how much of the MTV is applied to each box depending on some property (mass / velocity) of the boxes?