Python+OpenCV： Image pyramid

theory

Usually , We use fixed size images . But in some cases , We need to deal with it ( same ) Different resolution images .

for example , When searching for something in an image , Like the face , We're not sure how big the object will appear in the image .

under these circumstances , We will need to create a set of identical images with different resolutions , And search all these images for objects .

These sets of images with different resolutions are called image pyramids ( Because when they're stored in a stack , The highest resolution image is at the bottom , The lowest resolution image is at the top , It looks like a pyramid ).

There are two kinds of image pyramids ：1)Gaussian  The pyramid ;2)Laplacian  The pyramid

Gaussian The high level in the pyramid ( low resolution ) It's by removing low levels ( high resolution ) Continuous rows and columns in an image . then , Use the next layer 5 Gaussian weight contribution of pixels , Each pixel that forms the upper layer .

such , One M×N The image becomes M/2×N/2 Image . So the area is reduced to the original 1 / 4. It's called octave . When we get to the top of the pyramid , The same pattern continues ( That is, the resolution is reduced ).

similarly , When extended , The area of each layer will become 4 times . We can use cvv.pyrdown() and cvv.pyrup() Function to find the Gaussian pyramid .

Laplacian The pyramids are made up of Gaussian The pyramids are made of . It has no specific function .Laplacian Pyramid images are just like edge images . Most of its elements are 0. They are used for image compression .

Laplacian The hierarchy in the pyramid is made up of Gaussian The hierarchy in the pyramid and Gaussian The pyramid is formed by the difference of the extended forms of the upper and middle levels of the pyramid .

Example

####################################################################################################
# Image pyramid (Image Pyramids)
def lmc_cv_image_pyramids():
"""
The functionality : Image pyramid (Image Pyramids).
"""
# Read images
image = lmc_cv.imread('D:/99-Research/Python/Image/Lena.jpg')
image = lmc_cv.cvtColor(image, lmc_cv.COLOR_RGB2BGR)
# Image pyramid (Image Pyramids)
pyr_down_image1 = lmc_cv.pyrDown(image)
pyr_down_image2 = lmc_cv.pyrDown(pyr_down_image1)
pyr_down_image3 = lmc_cv.pyrDown(pyr_down_image2)
pyr_down_image4 = lmc_cv.pyrDown(pyr_down_image3)
pyr_down_image5 = lmc_cv.pyrDown(pyr_down_image4)
# Display images
pyplot.figure('Image Display')
titles = ['Original Image', 'Down Pyramids 1', 'Down Pyramids 2', 'Down Pyramids 3', 'Down Pyramids 4',
'Down Pyramids 5']
images = [image, pyr_down_image1, pyr_down_image2, pyr_down_image3, pyr_down_image4, pyr_down_image5]
for i in range(6):
pyplot.subplot(2, 3, i + 1)
pyplot.imshow(images[i], 'gray')
pyplot.title(titles[i])
pyplot.xticks([])
pyplot.yticks([])
pyplot.show()
# Save images based on user input
if ord("q") == (lmc_cv.waitKey(0) & 0xFF):
# Destruction of the window
pyplot.close()
return

Image pyramid fusion (Image Pyramids Blending)

####################################################################################################
# Image pyramid fusion (Image Pyramids Blending)
def lmc_cv_image_pyramids_blending():
"""
The functionality : Image pyramid fusion (Image Pyramids Blending).
"""
# Read images
image1 = lmc_cv.imread('D:/99-Research/Python/Image/apple.jpg')
image2 = lmc_cv.imread('D:/99-Research/Python/Image/orange.jpg')
image1 = lmc_cv.cvtColor(image1, lmc_cv.COLOR_RGB2BGR)
image2 = lmc_cv.cvtColor(image2, lmc_cv.COLOR_RGB2BGR)
# Image pyramid fusion (Image Pyramids Blending)
# generate Gaussian pyramid for image1
copy_image = image1.copy()
gp_image1 = [copy_image]
for i in range(6):
copy_image = lmc_cv.pyrDown(copy_image)
gp_image1.append(copy_image)
# generate Gaussian pyramid for image2
copy_image = image2.copy()
gp_image2 = [copy_image]
for i in range(6):
copy_image = lmc_cv.pyrDown(copy_image)
gp_image2.append(copy_image)
# generate Laplacian Pyramid for image1
lp_image1 = [gp_image1[5]]
for i in range(5, 0, -1):
ge_image = lmc_cv.pyrUp(gp_image1[i])
lp_image = lmc_cv.subtract(gp_image1[i - 1], ge_image)
lp_image1.append(lp_image)
# generate Laplacian Pyramid for image2
lp_image2 = [gp_image2[5]]
for i in range(5, 0, -1):
ge_image = lmc_cv.pyrUp(gp_image2[i])
lp_image = lmc_cv.subtract(gp_image2[i - 1], ge_image)
lp_image2.append(lp_image)
# Now add left and right halves of images in each level
ls_image = []
for la, lb in zip(lp_image1, lp_image2):
rows, cols, dpt = la.shape
ls = np.hstack((la[:, 0:cols // 2], lb[:, cols // 2:]))
ls_image.append(ls)
# now reconstruct
reconstruct_image = ls_image[0]
for i in range(1, 6):
reconstruct_image = lmc_cv.pyrUp(reconstruct_image)
reconstruct_image = lmc_cv.add(reconstruct_image, ls_image[i])
# image with direct connecting each half
real_image = np.hstack((image1[:, :cols // 2], image2[:, cols // 2:]))
# Display images
pyplot.figure('Image Display')
titles = ['Original Image 1', 'Original Image 2', 'Image Pyramids Blending', 'Image Direct Blending']
images = [image1, image2, reconstruct_image, real_image]
for i in range(4):
pyplot.subplot(2, 2, i + 1)
pyplot.imshow(images[i], 'gray')
pyplot.title(titles[i])
pyplot.xticks([])
pyplot.yticks([])
pyplot.show()
# Save images based on user input
if ord("q") == (lmc_cv.waitKey(0) & 0xFF):
# Destruction of the window
pyplot.close()
return