Finding rotated rectangle from contour

Question

I'm attempting to use OpenCV to identify and extract a fairly obvious region from an image. So far, by using a threshold and a series of dilations and erosions, I can successfully find the contour for the area I require.

However, my attempts to use minAreaRect as a precursor to rotation and cropping are failing to generate a rectangle that contains the input contour.

contours, hierarchy = cv2.findContours(morph.copy() ,cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)
contour = contours[0]

draw = cv2.cvtColor(morph, cv2.COLOR_GRAY2BGR)
cv2.drawContours(draw, [contour], 0, (0,255,0), 2)

rotrect = cv2.minAreaRect(contour)
box = cv2.cv.BoxPoints(rotrect)
box = numpy.int0(box)
cv2.drawContours(draw, [box], 0, (0,0,255), 2)

cv2.imshow('image', draw); cv2.waitKey(0)

Here's and example of the output:

Where the red stroke is the rect and the green is the contour. I would have expected the red stroke to encompass the green stroke.

Unfortunately I'm unable to provide the input image.

Answer 1

I ended up solving this by implementing my own rotating callipers procedure to find the minimum rectangle. It uses the convex hull to determine candidate rotations.

def p2abs(point):
    return math.sqrt(point[0] ** 2 + point[1] ** 2)

def rotatePoint(point, angle):
    s, c = math.sin(angle), math.cos(angle)
    return (p[0] * c - p[1] * s, p[0] * s + p[1] * c)

def rotatePoints(points, angle):
    return [rotatePoint(point, angle) for point in points]

points = map(lambda x: tuple(x[0]), contour)
convexHull = map(lambda x: points[x], scipy.spatial.ConvexHull(numpy.array(points)).vertices)

minArea = float("inf")
minRect = None

for i in range(len(hull)):
    a, b = convexHull[i], convexHull[i - 1]
    ang = math.atan2(b[0] - a[0], b[1] - a[1])

    rotatedHull = rotatePoints(convexHull, ang)

    minX = min(map(lambda p: p[0], rotatedHull))
    maxX = max(map(lambda p: p[0], rotatedHull))
    minY = min(map(lambda p: p[1], rotatedHull))
    maxY = max(map(lambda p: p[1], rotatedHull))

    area = (maxX - minX) * (maxY - minY)

    if area < minArea:
        minArea = area

        rotatedRect = [(minX, minY), (minX, maxY), (maxX, maxY), (maxX, minY)]
        minRect = rotatePoints(rotatedRect, -ang)

_, topLeft = min([(p2abs(p), i) for p, i in zip(range(4), minRect)])
rect = minrect[topLeft:] + minrect[:topLeft]