OpenCV 将图像形状变换为给定轮廓

Question

有谁知道如果图像 A 的形状是随机的，是否可以使用 OpenCV 或任何其他处理图像的 python 库将图像 A 转换为图像 B 轮廓？

这是我到目前为止所得到的两张图片：

我已经能够找到灯泡的绘制轮廓并使用bitwise_and方法在其中插入狐狸，但它所做的是裁剪第二个图像，而我需要它将其形状转换为灯泡轮廓。

import cv2


src1 = cv2.imread('fox.png')
src2 = cv2.imread('bulb-contour-filled.png')

src2 = cv2.resize(src2, src1.shape[1::-1])

dst = cv2.bitwise_and(src1, src2)

cv2.imwrite('img_fin.jpg', dst)

灯泡原图：

狐狸原图：

灯泡轮廓：

Answer 1

这个概念

为此，我们需要将其切成三角形，并单独扭曲每个三角形。图像的起点应沿着原始图像的轮廓，终点应沿着目标形状的轮廓。

尽管下面我对 2 组点进行了硬编码，但您只需要找出最佳处理来检索 2 个图像的轮廓（每个图像需要具有相同数量的点和相同的顺序）。另外，我还编写了一个交互式 OpenCV 程序，使我们能够轻松检索坐标。

代码

import cv2
import numpy as np

def triangles(points):
    points = np.where(points, points, 1)
    subdiv = cv2.Subdiv2D((*points.min(0), *points.max(0)))
    for pt in points:
        subdiv.insert(tuple(map(int, pt)))
    for pts in subdiv.getTriangleList().reshape(-1, 3, 2):
        yield [np.where(np.all(points == pt, 1))[0][0] for pt in pts]

def crop(img, pts):
    x, y, w, h = cv2.boundingRect(pts)
    img_cropped = img[y: y + h, x: x + w]
    pts[:, 0] -= x
    pts[:, 1] -= y
    return img_cropped, pts

def warp(img1, img2, pts1, pts2):
    img2 = img2.copy()
    for indices in triangles(pts1):
        img1_cropped, triangle1 = crop(img1, pts1[indices])
        img2_cropped, triangle2 = crop(img2, pts2[indices])
        transform = cv2.getAffineTransform(np.float32(triangle1), np.float32(triangle2))
        img2_warped = cv2.warpAffine(img1_cropped, transform, img2_cropped.shape[:2][::-1], None, cv2.INTER_LINEAR, cv2.BORDER_REFLECT_101)
        mask = np.zeros_like(img2_cropped)
        cv2.fillConvexPoly(mask, np.int32(triangle2), (1, 1, 1), 16, 0)
        img2_cropped *= 1 - mask
        img2_cropped += img2_warped * mask
    return img2

def resize(img, size):
    h, w = img.shape[:2]
    return cv2.resize(img, (int(w * size), int(h * size)))

img1 = resize(cv2.imread("dog.png"), 0.8)
img2 = resize(cv2.imread("bulb.png"), 0.8)

pts1 = np.array([[322, 508], [390, 475], [413, 425], [440, 367], [453, 305], [458, 289], [446, 202], [434, 139], [392, 104], [324, 94], [246, 97], [194, 101], [111, 127], [98, 185], [88, 240], [95, 306], [90, 363], [123, 431], [160, 487], [223, 508]])
pts2 = np.array([[459, 793], [513, 715], [541, 580], [552, 470], [583, 398], [633, 323], [643, 233], [616, 144], [557, 71], [470, 28], [354, 27], [264, 72], [206, 138], [179, 225], [178, 302], [236, 401], [266, 480], [278, 564], [297, 707], [357, 792]])

cv2.imshow("result", warp(img1, img2, pts1, pts2))
cv2.waitKey(0)
cv2.destroyAllWindows()

输出

说明

1. 导入必要的库：

import cv2
import numpy as np

2. 定义一个函数 ，triangles它将接受坐标数组 ，points并生成包含 3 个三角形索引的列表，这些三角形将覆盖原始坐标数组的区域：

def triangles(points):
    points = np.where(points, points, 1)
    subdiv = cv2.Subdiv2D((*points.min(0), *points.max(0)))
    for pt in points:
        subdiv.insert(tuple(map(int, pt)))
    for pts in subdiv.getTriangleList().reshape(-1, 3, 2):
        yield [np.where(np.all(points == pt, 1))[0][0] for pt in pts]

3. 定义一个函数 ，crop它将接收图像数组img和三个坐标的数组pts。它将返回图像的一个矩形部分，其大小足以容纳这三个点形成的三角形，并返回传输到图像左上角的三个坐标的数组：

def crop(img, pts):
    x, y, w, h = cv2.boundingRect(pts)
    img_cropped = img[y: y + h, x: x + w]
    pts[:, 0] -= x
    pts[:, 1] -= y
    return img_cropped, pts

4. 定义一个函数 ，warp它将接受 2 个图像数组img1和img2，以及 2 个坐标数组pts1和pts2。它将利用triangles之前定义的函数从第一个坐标数组迭代三角形，该crop函数之前定义的函数在与三角形索引相对应的坐标处裁剪两个图像，并使用该cv2.warpAffine()方法在迭代的当前三角形处扭曲图像：

def warp(img1, img2, pts1, pts2):
    img2 = img2.copy()
    for indices in triangles(pts1):
        img1_cropped, triangle1 = crop(img1, pts1[indices])
        img2_cropped, triangle2 = crop(img2, pts2[indices])
        transform = cv2.getAffineTransform(np.float32(triangle1), np.float32(triangle2))
        img2_warped = cv2.warpAffine(img1_cropped, transform, img2_cropped.shape[:2][::-1], None, cv2.INTER_LINEAR, cv2.BORDER_REFLECT_101)
        mask = np.zeros_like(img2_cropped)
        cv2.fillConvexPoly(mask, np.int32(triangle2), (1, 1, 1), 16, 0)
        img2_cropped *= 1 - mask
        img2_cropped += img2_warped * mask
    return img2

5. 阅读您的图像。请注意，我已经调整了图像的大小以更好地适合我的屏幕。如果删除调整大小部分，则需要使用下面的程序重新调整点并获取校正后的点集：

def resize(img, size):
    h, w = img.shape[:2]
    return cv2.resize(img, (int(w * size), int(h * size)))

img1 = resize(cv2.imread("dog.png"), 0.8)
img2 = resize(cv2.imread("bulb.png"), 0.8)

6. 最后，定义2组点；第一组概述了第一幅图像，第二组概述了第二幅图像。使用warp之前定义的函数进行扭曲，img1使其关键点与 的关键点重叠img2并显示结果图像：

pts1 = np.array([[0, 0], [286, 0], [286, 198], [174, 198], [158, 116], [0, 97]])
pts2 = np.array([[80, 37], [409, 42], [416, 390], [331, 384], [291, 119], [111, 311]])

cv2.imshow("result", warp(img1, img2, pts1, pts2))
cv2.waitKey(0)
cv2.destroyAllWindows()

工具

使用下面的程序手动将点拖动到每个图像上，并实时查看扭曲效果。当然，您可以检测两个图像的轮廓，而不是手动执行此操作（确保它们具有相同的点数且顺序相同）：

import cv2
import numpy as np

def triangles(points):
    points = np.where(points, points, 1)
    subdiv = cv2.Subdiv2D((*points.min(0), *points.max(0)))
    for pt in points:
        subdiv.insert(tuple(map(int, pt)))
    for pts in subdiv.getTriangleList().reshape(-1, 3, 2):
        yield [np.where(np.all(points == pt, 1))[0][0] for pt in pts]

def crop(img, pts):
    x, y, w, h = cv2.boundingRect(pts)
    img_cropped = img[y: y + h, x: x + w]
    pts[:, 0] -= x
    pts[:, 1] -= y
    return img_cropped, pts

def warp(img1, img2, pts1, pts2):
    img2 = img2.copy()
    for indices in triangles(pts1):
        img1_cropped, triangle1 = crop(img1, pts1[indices])
        img2_cropped, triangle2 = crop(img2, pts2[indices])
        transform = cv2.getAffineTransform(np.float32(triangle1), np.float32(triangle2))
        img2_warped = cv2.warpAffine(img1_cropped, transform, img2_cropped.shape[:2][::-1], None, cv2.INTER_LINEAR, cv2.BORDER_REFLECT_101)
        mask = np.zeros_like(img2_cropped)
        cv2.fillConvexPoly(mask, np.int32(triangle2), (1, 1, 1), 16, 0)
        img2_cropped *= 1 - mask
        img2_cropped += img2_warped * mask
    return img2

def draw_circle(event, x, y, flags, param):
    pts = param
    if event == cv2.EVENT_LBUTTONDOWN:
        for pt in pts:
            dist = (pt[0] - x) ** 2 + (pt[1] - y) ** 2
            if dist < 225:
                active_pt[:] = pt
    elif event == cv2.EVENT_LBUTTONUP:
        active_pt[:] = 0
    elif event == cv2.EVENT_MOUSEMOVE:
        if np.any(active_pt):
            for pt in pts:
                if np.all(active_pt == pt):
                    pt[:] = active_pt[:] = x, y

def draw_circles(img, pts):
    img = img.copy()
    for i, (x, y) in enumerate(pts):
        cv2.circle(img, (x, y), 15, (0, 0, 255), -1)
        cv2.putText(img, str(i), (x - 10, y + 10), cv2.FONT_HERSHEY_COMPLEX, 0.8, (0, 0, 0), 2)
    return img

def resize(img, size):
    h, w = img.shape[:2]
    return cv2.resize(img, (int(w * size), int(h * size)))

img1 = resize(cv2.imread("dog.png"), 0.8)
img2 = resize(cv2.imread("bulb.png"), 0.8)

pts_count = 20

pts1 = np.arange(pts_count * 2).reshape((pts_count, 2))
pts2 = np.arange(pts_count * 2).reshape((pts_count, 2))

active_pt = np.array([0, 0])

cv2.namedWindow("image 1")
cv2.setMouseCallback('image 1', draw_circle, pts1)
cv2.namedWindow("image 2")
cv2.setMouseCallback('image 2', draw_circle, pts2)

pause = False
while True:
    cv2.imshow('image 1', draw_circles(img1, pts1))
    cv2.imshow('image 2', draw_circles(img2, pts2))
    if not pause:
        try:
            cv2.imshow("result", warp(img1, img2, pts1, pts2))
        except:
            pass
    key = cv2.waitKey(20)
    if key & 0xFF == ord("q"):
        break
    if key & 0xFF == ord("p"):
        pause = not pause
    
cv2.waitKey(0)
cv2.destroyAllWindows()

以下是其工作原理的粗略演示（加速 x4）：

如果您的计算机上的实时扭曲太慢，只需按 p 键暂停扭曲更新，然后再按一次即可恢复。