我试着把有重叠区域的图像缝合在一起。

对图像进行排序，每个图像都有与前一个图像重叠的区域。例如：

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

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

~~~~~~~编辑~~~~~~~

正如丹在评论中指出的那样，我在工作中使用了错误的工具(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)