Great question—you don't have to generate that intermediate blacked-out image to get the intersection coordinates. We can calculate the overlapping rectangle directly using basic geometry, whether your images are already aligned in the same coordinate system or need to be matched first. Let's break this down into two common scenarios:

Scenario 1: Images Are Already Aligned (Known Positions) #

If you know the exact position (top-left corner) and size of each image in a shared coordinate system (e.g., they're cropped from the same parent image, or you placed them on a canvas), calculating the intersection is straightforward with arithmetic:

Step-by-Step Logic: #

• For each image, define its bounding box:
  • Image 1: Top-left (x1, y1), width w1, height h1 → bottom-right (x1 + w1, y1 + h1)
  • Image 2: Top-left (x2, y2), width w2, height h2 → bottom-right (x2 + w2, y2 + h2)
• The intersection's top-left corner is the maximum of the two images' top-left coordinates: left = max(x1, x2), top = max(y1, y2)
• The intersection's bottom-right corner is the minimum of the two images' bottom-right coordinates: right = min(x1 + w1, x2 + w2), bottom = min(y1 + h1, y2 + h2)
• If left < right and top < bottom, you have a valid intersection—otherwise, the images don't overlap.

Python Code Example: #

import cv2

def get_intersection_rect(img1_pos, img1_size, img2_pos, img2_size):
    """
    Calculate intersection rectangle coordinates between two aligned images.
    
    Args:
        img1_pos: Tuple (x1, y1) - Top-left corner of image 1 in global coordinates
        img1_size: Tuple (w1, h1) - Width and height of image 1
        img2_pos: Tuple (x2, y2) - Top-left corner of image 2 in global coordinates
        img2_size: Tuple (w2, h2) - Width and height of image 2
    
    Returns:
        Dict with "left", "top", "right", "bottom" if intersection exists; None otherwise
    """
    x1, y1 = img1_pos
    w1, h1 = img1_size
    x2, y2 = img2_pos
    w2, h2 = img2_size
    
    # Compute intersection boundaries
    left = max(x1, x2)
    top = max(y1, y2)
    right = min(x1 + w1, x2 + w2)
    bottom = min(y1 + h1, y2 + h2)
    
    # Validate intersection
    if left < right and top < bottom:
        return {"left": left, "top": top, "right": right, "bottom": bottom}
    return None

# Example usage
if __name__ == "__main__":
    # Load images
    img1 = cv2.imread("image1.jpg")
    img2 = cv2.imread("image2.jpg")
    
    # Define positions (adjust these to match your images' actual positions)
    img1_pos = (50, 30)  # Top-left of img1 in global space
    img2_pos = (100, 50) # Top-left of img2 in global space
    
    # Get image sizes (width, height)
    img1_size = (img1.shape[1], img1.shape[0])
    img2_size = (img2.shape[1], img2.shape[0])
    
    intersection = get_intersection_rect(img1_pos, img1_size, img2_pos, img2_size)
    if intersection:
        print(f"Found intersection: {intersection}")
    else:
        print("No overlap between the two images.")

Scenario 2: Images Are Unaligned (Need Feature Matching) #

If your images are from different angles or perspectives of the same scene, you first need to align them using feature matching to map one image's coordinates to the other's. We'll use ORB (Oriented FAST and Rotated BRIEF) for this, which is fast and works well for most cases:

Python Code Example: #

import cv2
import numpy as np

def find_homography_between_images(img1, img2):
    """Find homography matrix to align img1 to img2's coordinate system."""
    # Initialize ORB detector
    orb = cv2.ORB_create(nfeatures=1000)
    
    # Detect keypoints and compute descriptors
    kp1, des1 = orb.detectAndCompute(img1, None)
    kp2, des2 = orb.detectAndCompute(img2, None)
    
    # Match descriptors using brute-force matcher
    bf = cv2.BFMatcher(cv2.NORM_HAMMING, crossCheck=True)
    matches = bf.match(des1, des2)
    
    # Sort matches by distance (best matches first)
    matches = sorted(matches, key=lambda x: x.distance)
    
    # Extract matched points
    src_pts = np.float32([kp1[m.queryIdx].pt for m in matches]).reshape(-1, 1, 2)
    dst_pts = np.float32([kp2[m.trainIdx].pt for m in matches]).reshape(-1, 1, 2)
    
    # Compute homography with RANSAC to filter outliers
    homography, _ = cv2.findHomography(src_pts, dst_pts, cv2.RANSAC, 5.0)
    return homography

def get_intersection_after_alignment(img1, img2):
    """Calculate intersection rectangle after aligning img1 to img2's coordinates."""
    homography = find_homography_between_images(img1, img2)
    
    # Get transformed corners of img1 in img2's coordinate system
    h1, w1 = img1.shape[:2]
    img1_corners = np.float32([[0,0], [w1,0], [w1,h1], [0,h1]]).reshape(-1,1,2)
    transformed_corners = cv2.perspectiveTransform(img1_corners, homography)
    
    # Get bounding rectangle of transformed img1
    x1, y1, w_transformed, h_transformed = cv2.boundingRect(transformed_corners)
    img1_right = x1 + w_transformed
    img1_bottom = y1 + h_transformed
    
    # Bounds of img2
    h2, w2 = img2.shape[:2]
    img2_right = w2
    img2_bottom = h2
    
    # Calculate intersection
    left = max(x1, 0)
    top = max(y1, 0)
    right = min(img1_right, img2_right)
    bottom = min(img1_bottom, img2_bottom)
    
    if left < right and top < bottom:
        return {"left": left, "top": top, "right": right, "bottom": bottom}
    return None

# Example usage
if __name__ == "__main__":
    img1 = cv2.imread("unaligned_img1.jpg")
    img2 = cv2.imread("unaligned_img2.jpg")
    
    intersection = get_intersection_after_alignment(img1, img2)
    if intersection:
        print(f"Found intersection after alignment: {intersection}")
    else:
        print("No overlap between the images even after alignment.")

Key Notes: #

• For aligned images, double-check that your position coordinates are in the same coordinate system (e.g., both measured from the top-left of a parent canvas).
• For unaligned images, you can swap img1 and img2 in the function if you want the intersection in img1's coordinate system instead.

内容的提问来源于stack exchange，提问作者Alexander Ukhov