Python，如何拼接重叠区域的图像？

Question

我正在尝试将具有重叠区域的图像拼接在一起。 图像被排序，每个图像与前一个图像有重叠区域。例如：

https://imgur.com/a/t9zzeHD

我已经尝试了https://www.pyimagesearch.com/2016/01/11/opencv-panorama-stitching/ 的代码，我对其稍作更改并使用了倾斜图像，但最终结果 (https://imgur.com/a/B2d2VBL) 与预期不符。

问题是否来自右侧为黑色的第 5 张图像？不知道为什么添加黑色以及如何避免它。

任何人都知道我如何修复代码以在我添加越来越多的图像时不扭曲图像？欢迎更好的代码示例供我使用。

~~~~~~~~ 编辑~~~~~~~ 正如丹在 cmets 中指出的那样，我使用了错误的工具（warpPerspective）来完成这项工作。我真正在寻找的是一种方法来找到两个图像中匹配的关键点，将其转换为每个图像中正确的 Y，这样我就可以剪切图像然后相应地缝合它们。

所以现在关于如何获取匹配的关键点并将其转换为 Y 坐标的问题可能有点简单。

请忽略代码，因为它只是我从哪里开始的一个例子，它只是在这一点上具有误导性。

下面的代码示例输入包含图像的目录路径 ["0.png", "1.png", "2.png", "3.png"]

from PIL import Image
import numpy as np
import imutils
import cv2
# from panorama import Stitcher
import argparse
import imutils
import cv2

class Stitcher:
    def __init__(self):
        # determine if we are using OpenCV v3.X
        self.isv3 = imutils.is_cv3()

    def stitch(self, images, ratio=0.75, reprojThresh=4.0,
               showMatches=False):
        # unpack the images, then detect keypoints and extract
        # local invariant descriptors from them
        (imageB, imageA) = images
        (kpsA, featuresA) = self.detectAndDescribe(imageA)
        (kpsB, featuresB) = self.detectAndDescribe(imageB)

        # match features between the two images
        M = self.matchKeypoints(kpsA, kpsB,
                                featuresA, featuresB, ratio, reprojThresh)

        # if the match is None, then there aren't enough matched
        # keypoints to create a panorama
        if M is None:
            return None

        # otherwise, apply a perspective warp to stitch the images
        # together
        (matches, H, status) = M
        result = cv2.warpPerspective(imageA, H,
                                     (imageA.shape[1] + imageB.shape[1], imageA.shape[0]))
        result[0:imageB.shape[0], 0:imageB.shape[1]] = imageB

        # check to see if the keypoint matches should be visualized
        if showMatches:
            vis = self.drawMatches(imageA, imageB, kpsA, kpsB, matches,
                                   status)

            # return a tuple of the stitched image and the
            # visualization
            return (result, vis)

        # return the stitched image
        return result

    def detectAndDescribe(self, image):
        # convert the image to grayscale
        gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)

        # check to see if we are using OpenCV 3.X
        if self.isv3:
            # detect and extract features from the image
            descriptor = cv2.xfeatures2d.SIFT_create()
            (kps, features) = descriptor.detectAndCompute(image, None)

        # otherwise, we are using OpenCV 2.4.X
        else:
            # detect keypoints in the image
            detector = cv2.FeatureDetector_create("SIFT")
            kps = detector.detect(gray)

            # extract features from the image
            extractor = cv2.DescriptorExtractor_create("SIFT")
            (kps, features) = extractor.compute(gray, kps)

        # convert the keypoints from KeyPoint objects to NumPy
        # arrays
        kps = np.float32([kp.pt for kp in kps])

        # return a tuple of keypoints and features
        return (kps, features)

    def matchKeypoints(self, kpsA, kpsB, featuresA, featuresB,
                       ratio, reprojThresh):
        # compute the raw matches and initialize the list of actual
        # matches
        matcher = cv2.DescriptorMatcher_create("BruteForce")
        rawMatches = matcher.knnMatch(featuresA, featuresB, 2)
        matches = []

        # loop over the raw matches
        for m in rawMatches:
            # ensure the distance is within a certain ratio of each
            # other (i.e. Lowe's ratio test)
            if len(m) == 2 and m[0].distance < m[1].distance * ratio:
                matches.append((m[0].trainIdx, m[0].queryIdx))

        # computing a homography requires at least 4 matches
        if len(matches) > 4:
            # construct the two sets of points
            ptsA = np.float32([kpsA[i] for (_, i) in matches])
            ptsB = np.float32([kpsB[i] for (i, _) in matches])

            # compute the homography between the two sets of points
            (H, status) = cv2.findHomography(ptsA, ptsB, cv2.RANSAC,
                                             reprojThresh)

            # return the matches along with the homograpy matrix
            # and status of each matched point
            return (matches, H, status)

        # otherwise, no homograpy could be computed
        return None

    def drawMatches(self, imageA, imageB, kpsA, kpsB, matches, status):
        # initialize the output visualization image
        (hA, wA) = imageA.shape[:2]
        (hB, wB) = imageB.shape[:2]
        vis = np.zeros((max(hA, hB), wA + wB, 3), dtype="uint8")
        vis[0:hA, 0:wA] = imageA
        vis[0:hB, wA:] = imageB

        # loop over the matches
        for ((trainIdx, queryIdx), s) in zip(matches, status):
            # only process the match if the keypoint was successfully
            # matched
            if s == 1:
                # draw the match
                ptA = (int(kpsA[queryIdx][0]), int(kpsA[queryIdx][1]))
                ptB = (int(kpsB[trainIdx][0]) + wA, int(kpsB[trainIdx][1]))
                cv2.line(vis, ptA, ptB, (0, 255, 0), 1)

        # return the visualization
        return vis


if __name__ == '__main__':
    images_folder = sys.argv[1]
    images = ["0.png", "1.png", "2.png", "3.png"]

    imageA = cv2.imread(images_folder+images[0])
    imageB = cv2.imread(images_folder+images[1])

    # stitch the images together to create a panorama
    stitcher = Stitcher()
    (result, vis) = stitcher.stitch([imageA, imageB], showMatches=True)

    count = 0
    imgRGB=cv2.cvtColor(result, cv2.COLOR_BGR2RGB)
    img = Image.fromarray(imgRGB)
    current_stiched_image = images_folder + "lol10{}.png".format(count)
    img.save(current_stiched_image)

    for image in images[2:]:
        count+=1
        print("image: {}".format(image))
        print("count: {}".format(count))
        print("current_stiched_image: {}".format(current_stiched_image))
        imageA1 = cv2.imread(current_stiched_image)
        imageB1 = cv2.imread(images_folder + image)
        (result, vis) = stitcher.stitch([imageA1, imageB1], showMatches=True)
        imgRGB=cv2.cvtColor(result, cv2.COLOR_BGR2RGB)
        img = Image.fromarray(imgRGB)
        current_stiched_image = images_folder + "lol10{}.png".format(count)
        print("new current_stiched_image: {}".format(current_stiched_image))
        img.save(current_stiched_image)

Answer 1

黑条的问题是你把两个重叠的图像放在一个大小相同的图像中......黑条是重叠区域的宽度。要删除它，您始终可以计算所需的宽度。例如，您可以使用文档中给出的公式找到右上点和右下点的映射位置。像这样的：

def determineMaXSize(self, w, h ,M):
  x0 = (M[0,0]*(w-1) + M[0,2]) / (M[2,0]*(w-1)  + M[2,2]) # for top right point
  x1 = (M[0,0]*(w-1) + M[0,1]*(h-1) + M[0,2]) /  (M[2,0]*(w-1) + M[2,1]*(h-1) + M[2,2])# for bottom right point
  print ("x0",x0)
  print("x1",x1)
  return int(min(x0, x1))

然后：

    result[0:imageB.shape[0], 0:imageB.shape[1]] = imageB
    maxWidth = self.determineMaXSize(imageA.shape[1], imageA.shape[0] ,H)
    result = result[:, 0:maxWidth]

即使图像失真，我也会使用 2 点之间的最小宽度从右侧移除所有黑色部分。 （在这种情况下它会削减一点图像）

你的第二个问题是，不知何故，这两个男人胸部的图像之间的匹配不太好，无法进行匹配，它们最终有点移动，然后以相当多的失真结束。您应该尝试获取更多重叠的图像或尝试使用其他匹配方法或其他参数进行 SIFT 特征检测。也许尝试寻找一种仅根据特征/点估计翻译的方法。