溫馨提示×
您好，登錄后才能下訂單哦！
點擊 登錄注冊 即表示同意《億速云用戶服務條款》
您好，登錄后才能下訂單哦！
這篇文章主要介紹“Python怎么實現RGB等圖片的圖像插值算法”，在日常操作中，相信很多人在Python怎么實現RGB等圖片的圖像插值算法問題上存在疑惑，小編查閱了各式資料，整理出簡單好用的操作方法，希望對大家解答”Python怎么實現RGB等圖片的圖像插值算法”的疑惑有所幫助！接下來，請跟著小編一起來學習吧！
對于這個圖片讀取到數組中形成的三維數組，我剛理解了很久，在網上找大佬的資料自己看等等，然后慢慢的才形成了自己的理解，大佬們都是縱說紛紜，自己走了很多彎路，這里吧我的理解寫下來，第一，方便自以后學習查看；第二，方便和我一樣的初學者理解。
先話不多說，直接上一個圖：
這里我直接把彩色圖片的三個通道數畫成了三位圖片顯示出來方面自己理解。彩色圖片是三通道的，分別為R、G、B，這三個通道的重疊，通過調節每個通道數灰度值的亮度，從而構成了五顏六色的彩色世界！！
紅色區域為第0通道（R），以此類推，第1通道（G）、第2通道（B）。讀取回來的數組是一個三維數組，這個三維數組又分為了很多二維矩陣，每個二維矩陣有三個列（三個通道）。上圖中有多少個i（高h），就表示三維數組中有多少個二維數組，有多少個j（寬h），就表示二維數組有多少個行，通道數k表示通道數，彩色圖像有三個通道，所以 k 是個固定值 3。
數組中的值怎么理解欸？
下面插入我這個靈魂畫師的一張圖示來說明吧哈哈哈哈哈哈（不禁默默的流下了眼淚）
上圖中左邊給出了一個圖片讀入到數組（假設)中的樣子，不同顏色的線條表示組成的不同通道圖片，然后再把這三個通道里面的圖片按照上上圖片一樣堆疊起來，就構成了這個三維空間圖了。
RGB圖像的理解就說到這里吧，希望能幫助到和我一樣的初學者少走彎路。
要問這公式怎么來的，第一個可以根據放大后像素點的位置成比例算出來，第二個公式暫時還沒想出來咋個算出來的，要是有大佬給我指出來就好了。
在代碼中有傳入參數指定使用哪一種對齊方式align = left，該參數默認是居中對其center。
src_X = dst_X*(src_Width/dst_Width) src_Y = dst_Y*(src_Height/dst_Height)
這里的src_X 就是目標圖像上的點映射到原圖像上的x坐標點，同理src_Y 就是映射到原圖像上的y坐標點。
dst_X表示目標圖像的x坐標，dst_Y表示目標圖像的y坐標。
src_X = （dst_X+0.5）*(src_Width/dst_Width) - 0.5 src_Y = （dst_Y+0.5）*(src_Height/dst_Height) - 0.5
這里的src_X 就是目標圖像上的點映射到原圖像上的x坐標點，同理src_Y 就是映射到原圖像上的y坐 標點。
dst_X表示目標圖像的x坐標，dst_Y表示目標圖像的y坐標。
最鄰近插值算法是最簡單的，我們算出來的坐標點：i ，j，使用round函數對其進行四舍五入，就可以得到img[i,j]這個像素點的臨近值了（是一個像素值）。
這個圖片中就能看出，A點是目標圖像映射到原圖像上面的位置，整個背景是原圖像，圖中的Q1、Q2、Q3、Q4四個點就是A點的最鄰近的四個像素點。
最鄰近插值算法的代碼是最簡單的，但是放大后的圖片效果是最差的，下面看代碼實現：
def nearest_inter(self): """最鄰近插值法""" new_img = np.zeros((self.goal_h, self.goal_w, self.goal_channel), dtype=np.uint8) for i in range(0, new_img.shape[0]): for j in range(0, new_img.shape[1]): src_i, src_j = self.convert2src_axes(i, j) new_img[i, j] = self.img[round(src_i), round(src_j)] return new_img
線性插值公式說白了就是，咱們數學中的直線的參數方程形式。我們知道兩點可以確定一條直線，但是在確定好的這條直線中我們怎么確定直線中的某個點呢，這樣我們就可以根據兩條平行線之間的關系來建立該兩點確定的直線方程。看下面的圖
所以這樣就能得該直線方程了。
這里給出線性插值算法的代碼：
def linear_inter(self): """線性插值算法""" new_img = np.zeros((self.goal_h, self.goal_w, self.goal_channel), dtype=np.uint8) for i in range(0, new_img.shape[0]): for j in range(0, new_img.shape[1]): src_i, src_j = self.convert2src_axes(i, j) if ((src_j - int(src_j)) == 0 and (src_i - int(src_i)) == 0) \ or ((src_i - int(src_i)) == 0) \ or ( (src_j - int(src_j)) == 0): # 表明border_src_j是一個整數 如果是整數，直接將原圖的灰度值付給目標圖像即可 new_img[i, j] = self.img[round(src_i), round(src_j)] # 直接將原圖的灰度值賦值給目標圖像即可 else: """否則進行向上和向下取整,然后進行（一維）線性插值算法""" src_i, src_j = self.convert2src_axes(i, j) j1 = int(src_j) # 向下取整 j2 = math.ceil(src_j) # 向上取整 new_img[i, j] = (j2 - src_j)*self.img[round(src_i), j1] + (src_j-j1)*self.img[round(src_i), j2] return new_img
雙線性插值算法實現起來就比線性插值算法要難一些，本質上還是和線性插值算法一樣，都是為了去找更目標圖像映射到原圖像上的點，把這個點周圍盡像素盡可能多的信息傳遞到這個點中。線性插值使用到了周圍的兩個點，這里的雙線性就是使用到了周圍的四個點的像素值信息，所以理論上來說，采用雙線線性插值算法的效果會明顯優于線性插值算法（單線性插值算法）。更具體的圖示我這里就不畫出來了，就使用我自己手繪的簡化版（因為懶），網上其他帖子講得更加明白，這里只貼出我自己的理解，這樣以后來看的時候也能一目了然。
圖中的x就是圖片的高h，y就是圖片的寬度w，因為我們讀出來的圖片是彩色圖片，所以這樣操作的同時，圖片的三個通道也會同步更新這樣的操作。
下面給出雙線性插值算法的python代碼：
def double_linear_inter(self): new_img = np.zeros((self.goal_h-2, self.goal_w-2, self.goal_channel), dtype=np.uint8) # 這里減的目的就是為了可以進行向上向下取整 for i in range(0, new_img.shape[0]): # 減1的目的就是為了可以進行向上向下取整數 for j in range(0, new_img.shape[1]): inner_src_i, inner_src_j = self.convert2src_axes(i, j) # 將取得到的變量參數坐標映射到原圖中，并且返回映射到原圖中的坐標 inner_i1 = int(inner_src_i) # 對行進行向上向下取整數 inner_i2 = math.ceil(inner_src_i) inner_j1 = int(inner_src_j) # 對列進行向上向下取整數 inner_j2 = math.ceil(inner_src_j) Q1 = (inner_j2 - inner_src_j) * self.img[inner_i1, inner_j1] + \ (inner_src_j - inner_j1) * self.img[inner_i1, inner_j2] Q2 = (inner_j2 - inner_src_j) * self.img[inner_i2, inner_j1] + \ (inner_src_j - inner_j1) * self.img[inner_i2, inner_j2] new_img[i, j] = (inner_i2 - inner_src_i) * Q1 + (inner_src_i - inner_i1) * Q2 return new_img
在進行圖片處理的時候，對于圖片的四個角，沒有四個或者兩個鄰域，所以四個角就采用最鄰近插值算法實現，二上下，左右這幾行，沒有四個鄰域，所以采用線性插值算法，其余中心部分每個點都有四個鄰域，所以采用雙線性插值算法來實現，這樣的圖片效果會更好，以下是這三種算法的具體實現：
def all_transform(self): # source_h, source_w, source_channel = self.img.shape # 獲得原圖像的高度，寬度和通道量 # goal_h, goal_w = round(source_h*self.h_rate), round(source_w*self.w_rate) # 將原圖像的size進行按照傳入進來的rate參數等比的放大 # goal_channel = source_channel """進行圖像轉換了""" new_img = np.zeros((self.goal_h-1, self.goal_w-1, self.goal_channel), dtype=np.uint8) # 得到一個空的數組用來存放轉換后的值，即為新的圖片 """邊界使用線性插值算法""" temp_row = [0, new_img.shape[0]-1] # 上下兩行進行線性插值 for i in temp_row: # i -> h -> x # j -> w -> y for j in range(0, new_img.shape[1]): """邊界線（除了四個角落）采用線性插值法""" t_border_src_i, t_border_src_j = self.convert2src_axes(i, j) if ((t_border_src_j - int(t_border_src_j)) == 0 and (t_border_src_i - int(t_border_src_i)) == 0) \ or (t_border_src_i - int(t_border_src_i)) == 0 \ or (t_border_src_j - int(t_border_src_j)) == 0: # 表明t_border_src_j是一個整數 如果是整數，直接將原圖的灰度值付給目標圖像即可 new_img[i, j] = self.img[round(t_border_src_i), round(t_border_src_j)] # 直接將原圖的灰度值賦值給目標圖像即可 else: """否則進行向上和向下取整,然后進行（一維）線性插值算法""" t_border_src_i, t_border_src_j = self.convert2src_axes(i, j) j1 = int(t_border_src_j) # 向下取整 j2 = math.ceil(t_border_src_j) # 向上取整 new_img[i, j] = self.img[round(t_border_src_i), j1] + (t_border_src_j - j1) * \ (self.img[round(t_border_src_i), j2] - self.img[round(t_border_src_i), j1]) # 左右兩列進行線性插值 temp_col = [0, new_img.shape[1]-1] for i in temp_col: # i -> w -> y # j -> h -> x for j in range(0, new_img.shape[0]): """邊界線（除了四個角落）采用線性插值法""" t_border_src_i, t_border_src_j = self.convert2src_axes(i, j) if ((t_border_src_j - int(t_border_src_j)) == 0 and (t_border_src_i - int(t_border_src_i)) == 0) \ or (t_border_src_i - int(t_border_src_i)) == 0 \ or (t_border_src_j - int(t_border_src_j)) == 0: # 表明border_src_j是一個整數 如果是整數，直接將原圖的灰度值付給目標圖像即可 new_img[j, i] = self.img[round(t_border_src_i), round(t_border_src_j)] # 直接將原圖的灰度值賦值給目標圖像即可 else: """否則進行向上和向下取整,然后進行（一維）線性插值算法""" t_border_src_i, t_border_src_j = self.convert2src_axes(j, i) j1 = int(t_border_src_i) # 向下取整 j2 = math.ceil(t_border_src_i) # 向上取整 new_img[j, i] = self.img[j1, round(t_border_src_j)] + (t_border_src_i - j1) * \ (self.img[j2, round(t_border_src_j)] - self.img[j1, round(t_border_src_j)]) """四個角落(頂點)使用最臨近插值算法""" corner_low = [0, new_img.shape[0]-1] corner_height = [0, new_img.shape[1]-1] for i in corner_low: for j in corner_height: src_i, src_j = self.convert2src_axes(i, j) new_img[i, j] = self.img[round(src_i), round(src_j)] """中間的使用雙線性插值法""" for i in range(1, new_img.shape[0] - 1): # 減1的目的就是為了可以進行向上向下取整數 for j in range(1, new_img.shape[1] - 1): inner_src_i, inner_src_j = self.convert2src_axes(i, j) # 將取得到的變量參數坐標映射到原圖中，并且返回映射到原圖中的坐標 inner_i1 = int(inner_src_i) # 對行進行向上向下取整數 inner_i2 = math.ceil(inner_src_i) inner_j1 = int(inner_src_j) # 對列進行向上向下取整數 inner_j2 = math.ceil(inner_src_j) Q1 = (inner_j2 - inner_src_j) * self.img[inner_i1, inner_j1] + \ (inner_src_j - inner_j1) * self.img[inner_i1, inner_j2] Q2 = (inner_j2 - inner_src_j) * self.img[inner_i2, inner_j1] + \ (inner_src_j - inner_j1) * self.img[inner_i2, inner_j2] new_img[i, j] = (inner_i2 - inner_src_i) * Q1 + (inner_src_i - inner_i1) * Q2 return new_img
下面附上我這個插值算法所有的代碼
import numpy as np
import cv2
import math
import logging
class Image_inter_lines(object):
"""設置傳入參數"""
def __init__(self, img, modify_size=(3, 3), *, align='center'):
self.img = img
self.h_rate = modify_size[0] # 高度的縮放率
self.w_rate = modify_size[1] # 寬度的縮放率
self.align = align # 設置居中模式，進而進行判斷其對齊方式
self.source_h = img.shape[0] # 對應 i 列 -> x
self.source_w = img.shape[1] # 對飲 j 列 -> y
self.goal_channel = img.shape[2] # 通道數
self.goal_h = round(self.source_h * self.h_rate) # 將原圖像的size進行按照傳入進來的rate參數等比的放大
self.goal_w = round(self.source_w * self.w_rate)
if self.align not in ['center', 'left']:
logging.exception(f'{self.align} is not a valid align parameter')
self.align = 'center' # 如果傳入的參數不是居中或者居左，則強制將其置為居中
pass
def set_rate(self, new_modify_size=(None, None)):
self.h_rate = new_modify_size[0]
self.w_rate = new_modify_size[1]
def convert2src_axes(self, des_x, des_y):
if self.align == 'left': # 左對齊
src_x = float(des_x * (self.source_w / self.goal_w))
src_y = float(des_y * (self.source_h / self.goal_h))
src_x = min((self.source_h - 1), src_x)
src_y = min((self.source_w - 1), src_y)
else: # 幾何中心對齊
src_x = float(des_x * (self.source_w / self.goal_w) + 0.5 * (self.source_w / self.goal_w))
src_y = float(des_y * (self.source_h / self.goal_h) + 0.5 * (self.source_h / self.goal_h))
src_x = min((self.source_h - 1), src_x)
src_y = min((self.source_w - 1), src_y)
return src_x, src_y # 這里返回的數值可以是小數，也可能是整數例如：23.00，但是這個數仍然是小數
def nearest_inter(self):
"""最鄰近插值法"""
new_img = np.zeros((self.goal_h, self.goal_w, self.goal_channel), dtype=np.uint8)
for i in range(0, new_img.shape[0]):
for j in range(0, new_img.shape[1]):
src_i, src_j = self.convert2src_axes(i, j)
new_img[i, j] = self.img[round(src_i), round(src_j)]
return new_img
def linear_inter(self):
"""線性插值算法"""
new_img = np.zeros((self.goal_h, self.goal_w, self.goal_channel), dtype=np.uint8)
for i in range(0, new_img.shape[0]):
for j in range(0, new_img.shape[1]):
src_i, src_j = self.convert2src_axes(i, j)
if ((src_j - int(src_j)) == 0 and (src_i - int(src_i)) == 0) \
or ((src_i - int(src_i)) == 0) \
or (
(src_j - int(src_j)) == 0): # 表明t_border_src_j是一個整數 如果是整數，直接將原圖的灰度值付給目標圖像即可
new_img[i, j] = self.img[round(src_i), round(src_j)] # 直接將原圖的灰度值賦值給目標圖像即可
else:
"""否則進行向上和向下取整,然后進行（一維）線性插值算法"""
src_i, src_j = self.convert2src_axes(i, j)
j1 = int(src_j) # 向下取整
j2 = math.ceil(src_j) # 向上取整
new_img[i, j] = (j2 - src_j)*self.img[round(src_i), j1] + (src_j-j1)*self.img[round(src_i), j2]
return new_img
def double_linear_inter(self):
new_img = np.zeros((self.goal_h-2, self.goal_w-2, self.goal_channel), dtype=np.uint8) # 這里減的目的就是為了可以進行向上向下取整
for i in range(0, new_img.shape[0]): # 減1的目的就是為了可以進行向上向下取整數
for j in range(0, new_img.shape[1]):
inner_src_i, inner_src_j = self.convert2src_axes(i, j) # 將取得到的變量參數坐標映射到原圖中，并且返回映射到原圖中的坐標
inner_i1 = int(inner_src_i) # 對行進行向上向下取整數
inner_i2 = math.ceil(inner_src_i)
inner_j1 = int(inner_src_j) # 對列進行向上向下取整數
inner_j2 = math.ceil(inner_src_j)
Q1 = (inner_j2 - inner_src_j) * self.img[inner_i1, inner_j1] + \
(inner_src_j - inner_j1) * self.img[inner_i1, inner_j2]
Q2 = (inner_j2 - inner_src_j) * self.img[inner_i2, inner_j1] + \
(inner_src_j - inner_j1) * self.img[inner_i2, inner_j2]
new_img[i, j] = (inner_i2 - inner_src_i) * Q1 + (inner_src_i - inner_i1) * Q2
return new_img
def all_transform(self):
# source_h, source_w, source_channel = self.img.shape # 獲得原圖像的高度，寬度和通道量
# goal_h, goal_w = round(source_h*self.h_rate), round(source_w*self.w_rate) # 將原圖像的size進行按照傳入進來的rate參數等比的放大
# goal_channel = source_channel
"""進行圖像轉換了"""
new_img = np.zeros((self.goal_h-1, self.goal_w-1, self.goal_channel), dtype=np.uint8) # 得到一個空的數組用來存放轉換后的值，即為新的圖片
"""邊界使用線性插值算法"""
temp_row = [0, new_img.shape[0]-1]
# 上下兩行進行線性插值
for i in temp_row:
# i -> h -> x
# j -> w -> y
for j in range(0, new_img.shape[1]):
"""邊界線（除了四個角落）采用線性插值法"""
t_border_src_i, t_border_src_j = self.convert2src_axes(i, j)
if ((t_border_src_j - int(t_border_src_j)) == 0 and (t_border_src_i - int(t_border_src_i)) == 0) \
or (t_border_src_i - int(t_border_src_i)) == 0 \
or (t_border_src_j - int(t_border_src_j)) == 0: # 表明t_border_src_j是一個整數 如果是整數，直接將原圖的灰度值付給目標圖像即可
new_img[i, j] = self.img[round(t_border_src_i), round(t_border_src_j)] # 直接將原圖的灰度值賦值給目標圖像即可
else:
"""否則進行向上和向下取整,然后進行（一維）線性插值算法"""
t_border_src_i, t_border_src_j = self.convert2src_axes(i, j)
j1 = int(t_border_src_j) # 向下取整
j2 = math.ceil(t_border_src_j) # 向上取整
new_img[i, j] = self.img[round(t_border_src_i), j1] + (t_border_src_j - j1) * \
(self.img[round(t_border_src_i), j2] - self.img[round(t_border_src_i), j1])
# 左右兩列進行線性插值
temp_col = [0, new_img.shape[1]-1]
for i in temp_col:
# i -> w -> y
# j -> h -> x
for j in range(0, new_img.shape[0]):
"""邊界線（除了四個角落）采用線性插值法"""
t_border_src_i, t_border_src_j = self.convert2src_axes(i, j)
if ((t_border_src_j - int(t_border_src_j)) == 0 and (t_border_src_i - int(t_border_src_i)) == 0) \
or (t_border_src_i - int(t_border_src_i)) == 0 \
or (t_border_src_j - int(t_border_src_j)) == 0: # 表明border_src_j是一個整數 如果是整數，直接將原圖的灰度值付給目標圖像即可
new_img[j, i] = self.img[round(t_border_src_i), round(t_border_src_j)] # 直接將原圖的灰度值賦值給目標圖像即可
else:
"""否則進行向上和向下取整,然后進行（一維）線性插值算法"""
t_border_src_i, t_border_src_j = self.convert2src_axes(j, i)
j1 = int(t_border_src_i) # 向下取整
j2 = math.ceil(t_border_src_i) # 向上取整
new_img[j, i] = self.img[j1, round(t_border_src_j)] + (t_border_src_i - j1) * \
(self.img[j2, round(t_border_src_j)] - self.img[j1, round(t_border_src_j)])
"""四個角落(頂點)使用最臨近插值算法"""
corner_low = [0, new_img.shape[0]-1]
corner_height = [0, new_img.shape[1]-1]
for i in corner_low:
for j in corner_height:
src_i, src_j = self.convert2src_axes(i, j)
new_img[i, j] = self.img[round(src_i), round(src_j)]
"""中間的使用雙線性插值法"""
for i in range(1, new_img.shape[0] - 1): # 減1的目的就是為了可以進行向上向下取整數
for j in range(1, new_img.shape[1] - 1):
inner_src_i, inner_src_j = self.convert2src_axes(i, j) # 將取得到的變量參數坐標映射到原圖中，并且返回映射到原圖中的坐標
inner_i1 = int(inner_src_i) # 對行進行向上向下取整數
inner_i2 = math.ceil(inner_src_i)
inner_j1 = int(inner_src_j) # 對列進行向上向下取整數
inner_j2 = math.ceil(inner_src_j)
Q1 = (inner_j2 - inner_src_j) * self.img[inner_i1, inner_j1] + \
(inner_src_j - inner_j1) * self.img[inner_i1, inner_j2]
Q2 = (inner_j2 - inner_src_j) * self.img[inner_i2, inner_j1] + \
(inner_src_j - inner_j1) * self.img[inner_i2, inner_j2]
new_img[i, j] = (inner_i2 - inner_src_i) * Q1 + (inner_src_i - inner_i1) * Q2
return new_img
if __name__ == '__main__':
pic1 = cv2.imread(r'C:\Users\heshijie\Desktop\Py_study\image processing\Carmen.jpg')
pic2 = cv2.imread(r'C:\Users\heshijie\Desktop\Py_study\image processing\girl.jpg')
pic3 = cv2.imread(r'C:\Users\heshijie\Desktop\Py_study\image processing\architecture.jpg')
Obj_pic1 = Image_inter_lines(pic1, modify_size=(2, 2), align='center')
new_pic1 = Obj_pic1.nearest_inter()
cv2.imshow('origin', pic1)
cv2.imshow('nearest_inter', new_pic1)
new_pic2 = Obj_pic1.linear_inter()
cv2.imshow('liner_inter', new_pic2)
new_pic3 = Obj_pic1.all_transform()
cv2.imshow('double_liner_inter', new_pic3)
cv2.waitKey()到此，關于“Python怎么實現RGB等圖片的圖像插值算法”的學習就結束了，希望能夠解決大家的疑惑。理論與實踐的搭配能更好的幫助大家學習，快去試試吧！若想繼續學習更多相關知識，請繼續關注億速云網站，小編會繼續努力為大家帶來更多實用的文章！
免責聲明：本站發布的內容（圖片、視頻和文字）以原創、轉載和分享為主，文章觀點不代表本網站立場，如果涉及侵權請聯系站長郵箱：is@yisu.com進行舉報，并提供相關證據，一經查實，將立刻刪除涉嫌侵權內容。
