圖片旋轉演算法雙線性插值

❶ 數字圖像處理 圖像縮放以及旋轉的演算法代碼

clearall;
I=imread('lena.bmp');
figure;imshow(I);title('原圖像');
[m,n]=size(I);

%%%縮小臨近法
M=0.5;%放大倍數

%新的圖像大小
m1=m*M;n1=n*M;
%****************************************************
fori=1:m1
forj=1:n1;
J(i,j)=I(round(i/M),round(j/M));
end
end
%*****************************************************
figure;imshow(J);title('縮小圖像');

%%%放大雙線性插值法
I2=double(I);
N=1.5;%放大倍數
%新的圖像大小
m2=m*N;n2=n*N;
J2=zeros(m2,n2);
fori=1:m2
forj=1:n2
x=i/N;
y=j/N;
u=floor(x);
v=floor(y);
a=x-u;
b=y-v;
ifu+2<=m&v+2<=n
J2(i,j)=I2(u+1,v+1)*(1-a)*(1-b)+I2(u+2,v+1)*a*(1-b)+I2(u+1,v+2)*(1-a)*b+I2(u+2,v+2)*a*b;
end
end
end
J2=uint8(J2);
figure;imshow(J2);title('放大圖像');

%%%%%旋轉
R=45*pi/180;%旋轉角度
I=double(I);
%新圖像大小
m2=ceil(m*cos(R)+n*sin(R));
n2=ceil(m*sin(R)+n*cos(R));

u0=m*sin(R);%平移量

%變換矩陣
T=[cos(R),sin(R);-sin(R),cos(R)];
L=zeros(m2,n2);
foru=1:n2
forv=1:m2
%新圖像坐標變換到原圖像坐標x和y中
temp=T*([u;v]-[u0;0]);
x=temp(1);
y=temp(2);
ifx>=1&x<=m&y>=1&y<=n%若變換出的x和y在原圖像范圍內
x_low=floor(x);
x_up=ceil(x);
y_low=floor(y);
y_up=ceil(y);

%雙線性插值，p1到p4是（x,y）周圍的四個點
p1=I(x_low,y_low);
p2=I(x_up,y_low);
p3=I(x_low,y_low);
p4=I(x_up,y_up);
s=x-x_low;
t=y-y_low;
L(u,v)=(1-s)*(1-t)*p1+(1-s)*t*p3+(1-t)*s*p2+s*t*p4;
end
end
end
L=uint8(L);
figure;imshow(L);

❷ 圖像處理幾何運算

圖像的幾何運算可以使得圖像的幾何形狀發生變化，與點運算不同，幾何運算可以看作像素在圖像內移動過程，這個過程會改變圖像物體對象之間的空間關系，本節就將針對matlab中圖像處理幾何運算進行介紹：
圖像的插值
圖像插值是指利用已知鄰近像素點的灰度值來產生未知像素點的灰度值，使得原始圖像具蔽塌畝有更高的解析度。
interp2函數用於用於對圖像進行插值，該函數的調用格式如下：
J=interp2（X,Y,I,X1,Y1）;
X,Y表示原始像素值，X1,Y1插入新的像素，I表示原始圖像，J表示插值後的圖像
示例：對圖形進行插值
編寫對應的m文件如下：
clear all;
I=imread('cameraman.tif');
subplot(2,2,1)
imshow(I);
title('原始圖像');
J1=interp2(double(I),2,'nearest');%%最鄰近插值法%%
J2=interp2(double(I),2,'spline'); %%三次樣條插值%%
J3=interp2(double(I),2,'linear'); %%線性插值%%
subplot(2,2,2)
imshow(uint8(J1));
title('最鄰近插值法');
subplot(2,2,3)
imshow(uint8(J2));
title('三次樣條插值法');
subplot(2,2,4)
imshow(uint8(J3));
title('線性插值法衫察');
程序運行結果如下圖：
圖像的旋轉
imrotate函數用於實現圖像的旋轉，其調用格式如下：
J=imrotate（I,angle，method，bbox）;
其中I表示原始圖像，angle表示旋轉角度，method表示插值方法，bbox表示旋轉後的顯示方法
示例：對圖形進行旋轉
編寫對應的m文件如下：
clear all;
I=imread('pout.tif');
J=imrotate(I,60,'bilinear');%%對圖像旋轉60度，利用雙線性插值法%%
subplot(1,2,1)
imshow(I);
title('原始圖像');
subplot(1,2,2)
imshow(J);
title('旋轉後的圖像');
程序運行結果如下圖：
圖像的平移
圖像平移變換應用的是直角坐標系的平移變換公式
示例：對圖像進行平移
編寫對應m文件如下：
clear all;
I=imread('peppers.png');
subplot(1,2,1)
imshow(I);
title('原始圖像');
J=double(I);
J1=zeros(size(J));%%構造函數，像素默認為0%%
J2=size(J1);
X=60;
Y=60;
J3(X+1:J2(1),Y+1:J2(2),1:J2(3))=J(1:J2(1)-X,1:J2(2)-Y,1:J2(3));
subplot(1,2,2)
imshow(uint8(J3));
title('平移後圖像');
程序運行後結果如下圖：
圖像的縮放
圖像的縮放就是將原始圖像進行放大或者縮小，imresize函數用於實現對圖像的縮放，其調用格式如下：
J=imresize(I,K,method);
I,J分別表宏森示原始圖像，縮放後圖像，K表示縮放系數，method插值方法，可以去nearest最鄰近插值法，bilinear雙線性插值法，bicubic雙立方插值法
示例：利用imresize函數對圖像進行插值
編寫對應m文件如下：
clear all;
I=imread('office_5.jpg');
subplot(2,2,1)
imshow(I);
title('原始圖像');
J1=imresize(I,4,'nearest');
subplot(2,2,2)
imshow(uint8(J1))
title('最鄰近插值法放大4倍後圖像');
J2=imresize(I,0.2,'bilinear');
subplot(2,2,3)
imshow(uint8(J1))
title('雙線性插值法縮小0.2倍後圖像');
J3=imresize(I,0.2,'bicubic');
subplot(2,2,4)
imshow(uint8(J3))
title('雙立方插值法縮小0.2倍後圖像');
程序運行結果如下圖：
圖像的裁剪
圖像的裁剪是將我們不需要的部分進行刪除，只保留我們感興趣的部分，imcrop函數用於實現對圖像的剪切，該函數調用格式如下：
J=imcrop(I);表示對灰度圖進行剪切
J=imcrop(X,map);表示對索引圖進行剪切
J=imcrop(RGB);表示對真彩圖進行剪切
示例：對索引圖進行剪切
clear all
[X,map]=imread('peppers.png');
colormap(map);
subplot(1,2,1)
imshow(X,map);
title('原始索引圖');
X2=imcrop(X,map,[50 50 120 130]);%%指定剪切區域大小和位置%%
subplot(1,2,2)
imshow(X2);
title('剪切後索引圖');
程序運行結果如下圖：
圖像的鏡像
鏡像特點使圖像左右顛倒或這上下顛倒，圖像鏡像分為水平鏡像和垂直鏡像，flipud函數用於圖像進行左右翻轉
示例：對圖像進行鏡像變換
編寫對應的m文件如下：
clear all;
I=imread('cameraman.tif');
subplot(2,2,1)
imshow(I);
title('原始圖像');
h=size(double(I));
%%水平鏡像%%
J1(1:h(1),1:h(2))=I(1:h(1),h(2):-1:1);
subplot(2,2,2)
imshow(uint8(J1));
title('水平鏡像後的圖像');
%%豎直鏡像%%
J2(1:h(1),1:h(2))=I(h(1):-1:1,1:h(2));
subplot(2,2,3)
imshow(uint8(J2));
title('垂直鏡像後的圖像');
J3(1:h(1),1:h(2))=I(h(1):-1:1,h(2):-1:1);
subplot(2,2,4)
imshow(uint8(J3));
title('對角鏡像後的圖像');
程序運行結果如下圖：

❸ 圖像處理中的雙線性插值演算法的原理

何東健的《數字圖像處理》光碟第六章有前兩種的程序
完整程序已發你郵箱
核心代碼如下：
for(y = 0; y < nNewHeight; y++)
{
//指向新圖像第y行
//注意此處寬度和高度是新圖像的寬度和高度
pNewTemp = pNewBits;
pNewTemp += (nNewHeight - 1 - y) * nNewWidthBytes;
//針對圖像每列進行操作
for(x = 0; x < nNewWidth; x++)
{
//計算該像素在源圖像中的坐標
int y0 = (long) (y / fYZoomRatio + 0.5);
int x0 = (long) (x / fXZoomRatio + 0.5);

//判斷是否在源圖范圍內
if( (x0 >= 0) && (x0 < nOldWidth) &&
(y0 >= 0) && (y0 < nOldHeight))
{
//用雙線性插值
if(bBilinear)
{
unsigned char *pTemp = Interpolation (nOldWidth, nOldHeight,
(float)x0, (float)y0,
nOldWidthBytes, nMovedBits, pOldBits);
//復制像素
memcpy(pNewTemp, pTemp, nMovedBits);

delete [] pTemp ;
}
else
//最近鄰插值
{
//指向源圖像第y0行，第x0個像素
//注意此處寬度和高度應該互換
pOldTemp = pOldBits;
pOldTemp += (nOldHeight - 1 - y0) * nOldWidthBytes;
pOldTemp += x0 * nMovedBits;

//復制像素
memcpy(pNewTemp, pOldTemp, nMovedBits);
}
}
pNewTemp += nMovedBits;

}

}

❹ 雙線性插值法原理 python實現

碼字不易，如果此文對你有所幫助，請幫忙點贊，感謝！

一. 雙線性插值法原理：

        ① 何為線性插值？

        插值就是在兩個數之間插入一個數，線性插值原理圖如下：

        ② 各種插值法：

        插值法的第一步都是相同的，計算目標圖（dstImage）的坐標點對應原圖（srcImage）中哪個坐標點來填充，計算公式為：

        srcX = dstX * (srcWidth/dstWidth)

        srcY = dstY * (srcHeight/dstHeight)

        (dstX,dstY)表示目標圖像的某個坐標點，(srcX,srcY)表示與之對應的原圖像的坐標點。srcWidth/dstWidth 和 srcHeight/dstHeight 分別表示寬和高的放縮比。

        那麼問題來了，通過這個公式算出來的 srcX, scrY 有可能是小數，但是原圖像坐標點是不存在小數的，都是整數，得想辦法把它轉換成整數才行。

        不同插值法的區別就體現在 srcX, scrY 是小數時，怎麼將其變成整數去取原圖像中的像素值。

        最近鄰插值（Nearest-neighborInterpolation）：看名字就很直白，四捨五入選取最接近的整數。這樣的做法會導致像素變化不連續，在目標圖像中產生鋸齒邊緣。

        雙線性插值（Bilinear Interpolation）：雙線性就是利用與坐標軸平行的兩條直線去把小數坐標分解到相鄰的四個整數坐標點。權重與距離成反比。

        雙三次插值（Bicubic Interpolation）：與雙線性插值類似，只不過用了相鄰的16個點。但是需要注意的是，前面兩種方法能保證兩個方向的坐標權重和為1，但是雙三次插值不能保證這點，所以可能出現像素值越界的情況，需要截斷。

        ③ 雙線性插值演算法原理

        假如我們想得到未知函數 f 在點 P = (x, y) 的值，假設我們已知函數 f 在 Q11 = (x1, y1)、Q12 = (x1, y2), Q21 = (x2, y1) 以及 Q22 = (x2, y2) 四個點的值。最常見的情況，f就是一個像素點的像素值。首先在 x 方向進行線性插值，然後再在 y 方向上進行線性插值，最終得到雙線性插值的結果。

    ④ 舉例說明

二. python實現灰度圖像雙線性插值演算法：

灰度圖像雙線性插值放大縮小

import numpy as np

import math

import cv2

def double_linear(input_signal, zoom_multiples):

    '''

    雙線性插值

    :param input_signal: 輸入圖像

    :param zoom_multiples: 放大倍數

    :return: 雙線性插值後的圖像

    '''

    input_signal_cp = np.(input_signal)  # 輸入圖像的副本

    input_row, input_col = input_signal_cp.shape # 輸入圖像的尺寸（行、列）

    # 輸出圖像的尺寸

    output_row = int(input_row * zoom_multiples)

    output_col = int(input_col * zoom_multiples)

    output_signal = np.zeros((output_row, output_col)) # 輸出圖片

    for i in range(output_row):

        for j in range(output_col):

            # 輸出圖片中坐標 （i，j）對應至輸入圖片中的最近的四個點點（x1，y1）（x2, y2），（x3， y3），(x4，y4)的均值

            temp_x = i / output_row * input_row

            temp_y = j / output_col * input_col

            x1 = int(temp_x)

            y1 = int(temp_y)

            x2 = x1

            y2 = y1 + 1

            x3 = x1 + 1

            y3 = y1

            x4 = x1 + 1

            y4 = y1 + 1

            u = temp_x - x1

            v = temp_y - y1

            # 防止越界

            if x4 >= input_row:

                x4 = input_row - 1

                x2 = x4

                x1 = x4 - 1

                x3 = x4 - 1

            if y4 >= input_col:

                y4 = input_col - 1

                y3 = y4

                y1 = y4 - 1

                y2 = y4 - 1

            # 插值

            output_signal[i, j] = (1-u)*(1-v)*int(input_signal_cp[x1, y1]) + (1-u)*v*int(input_signal_cp[x2, y2]) + u*(1-v)*int(input_signal_cp[x3, y3]) + u*v*int(input_signal_cp[x4, y4])

    return output_signal

# Read image

img = cv2.imread("../paojie_g.jpg",0).astype(np.float)

out = double_linear(img,2).astype(np.uint8)

# Save result

cv2.imshow("result", out)

cv2.imwrite("out.jpg", out)

cv2.waitKey(0)

cv2.destroyAllWindows()

三. 灰度圖像雙線性插值實驗結果：

四. 彩色圖像雙線性插值python實現

def BiLinear_interpolation(img,dstH,dstW):

    scrH,scrW,_=img.shape

    img=np.pad(img,((0,1),(0,1),(0,0)),'constant')

    retimg=np.zeros((dstH,dstW,3),dtype=np.uint8)

    for i in range(dstH-1):

        for j in range(dstW-1):

            scrx=(i+1)*(scrH/dstH)

            scry=(j+1)*(scrW/dstW)

            x=math.floor(scrx)

            y=math.floor(scry)

            u=scrx-x

            v=scry-y

            retimg[i,j]=(1-u)*(1-v)*img[x,y]+u*(1-v)*img[x+1,y]+(1-u)*v*img[x,y+1]+u*v*img[x+1,y+1]

    return retimg

im_path='../paojie.jpg'

image=np.array(Image.open(im_path))

image2=BiLinear_interpolation(image,image.shape[0]*2,image.shape[1]*2)

image2=Image.fromarray(image2.astype('uint8')).convert('RGB')

image2.save('3.png')

五. 彩色圖像雙線性插值實驗結果：

六. 最近鄰插值演算法和雙三次插值演算法可參考：

        ① 最近鄰插值演算法： https://www.cnblogs.com/wojianxin/p/12515061.html

         https://blog.csdn.net/Ibelievesunshine/article/details/104936006

        ② 雙三次插值演算法： https://www.cnblogs.com/wojianxin/p/12516762.html

        https://blog.csdn.net/Ibelievesunshine/article/details/104942406

七. 參考內容：

         https://www.cnblogs.com/wojianxin/p/12515061.html

         https://blog.csdn.net/Ibelievesunshine/article/details/104939936

❺ MATLAB，編寫程序，將一個圖像旋轉45度（急！）

您好，如果按照你的程序的話，根據提示內容，在計算
i1=round(i*cos(a) - j*sin(a)+ n * sin(a))+1;
j1=round(i*sin(a) + j*cos(a));

這兩個時會出現零值，那麼，在MATLAB中索引F矩陣就是錯誤的了，你可以設置斷點，然後單步運行一下看看在哪一步出現的零值，你根據旋轉矩陣的計算應該是沒有問題的，關鍵是灰度映射時可能出現零位置，最好在其中加入沖歲判斷的語句，j1計算會出現0值。

你這樣寫，是沿坐標軸原點旋轉，你說的我原來寫的那個是沿固定點旋轉，實現都是使用旋轉矩陣，沿固定點只是先平移到原點，然後再平移回去，你可以看看，具體的我已經記襪判塵不太清楚了，呵呵，已經不做圖像了。

我寫的那個的程序：

function im_final = imrotate_my(im_path,theta,options)
% IM_ROTATE 兩維圖像旋轉以及雙線性灰度插值演算法的實現
% im_path 圖像存儲路徑
% theta 旋轉角度，正數表示順時針旋轉
% options 可以為circular（超出范圍部分，按照周期形式擴展）
% crop（超出部分置零，即全黑）
% Ref. 章毓晉. 圖像工程（上冊）——圖像處理. 清華大學出版社
% Author: lskyp Date: 2009.08.12
% Version: V1.2 Original Version: V1.0 im_bilinear.m;im_rotate.m
% with the parameter options added

error(nargchk(2,3,nargin,'string'))

if nargin == 2
options = 'circular';
else
if ~ (strcmp(options,'circular') || strcmp(options,'crop'))
error('錯誤的輸出方法')
end
end

im_init = imread(im_path);
im_init = double(im_init);
im_height = size(im_init,1);
im_width = size(im_init,2);
% 分別處理灰度圖像和RGB圖像
if ndims(im_init) == 3
im_final = zeros(im_height,im_width,3);
R = im_init(:,:,1);
G = im_init(:,:,2);
B = im_init(:,:,3);
R_final = im_final(:,:,1);
G_final = im_final(:,:,2);
B_final = im_final(:,:,3);
else
im_final = zeros(im_height,im_width);
end

rot_matrix = [cos(theta) -sin(theta);sin(theta) cos(theta)];
orig_h = (im_height + 1)/2;
orig_w = (im_width + 1)/2;
for h = 1:im_height
for w = 1:im_width
% 平移至原點，旋轉，然告禪後再平移回去
new_position = rot_matrix*[h - orig_h;w - orig_w] + [orig_h;orig_w];

% 超出范圍按周期擴展控制，options參數控制
if strcmp(options,'circular')
new_position(1) = mod(new_position(1),im_height);
new_position(2) = mod(new_position(2),im_width);
if new_position(1) == 0
new_position(1) = im_height;
end
if new_position(2) == 0
new_position(2) = im_width;
end
end

% 如果新位置為整數，那麼直接賦予灰度值或者RGB值，否則，按照雙線性插值計算。
% 使用後向映射
if new_position == round(new_position)
if new_position(1) == 0
new_position(1) = 1;
end
if new_position(2) == 0
new_position(2) = 1;
end
% 超出范圍控制，options為crop選項，超出范圍置零
if strcmp(options,'crop') && (new_position(1) >= im_height || ...
new_position(2) >= im_width || new_position(1) < 0 || ...
new_position(2) < 0)
if ndims(im_init) == 3
R_final(h,w) = 0;
G_final(h,w) = 0;
B_final(h,w) = 0;
else
im_final(h,w) = 0;
end
else
if ndims(im_init) == 3
R_final(h,w) = R(new_position(1),new_position(2));
G_final(h,w) = G(new_position(1),new_position(2));
B_final(h,w) = B(new_position(1),new_position(2));
else
im_final(h,w) = im_init(new_position(1),new_position(2));
end
end
else
h_new = floor(new_position(1));
w_new = floor(new_position(2));
if h_new == 0
h_new = 1;
end
if w_new == 0
w_new = 1;
end

% 超出范圍控制，options為crop選項，超出范圍置零
if strcmp(options,'crop') && (h_new >= im_height || ...
w_new >= im_width || h_new < 0 || ...
w_new < 0)
if ndims(im_init) == 3
R_final(h,w) = 0;
G_final(h,w) = 0;
B_final(h,w) = 0;
else
im_final(h,w) = 0;
end
else
% 邊界控制
h1 = h_new + 1;
w1 = w_new + 1;
if h1 >= im_height + 1
h1 = mod(h1,im_height);
end
if w1 >= im_width + 1
w1 = mod(w1,im_width);
end
if ndims(im_init) == 3
% 雙線性插值的實現過程
% Ref. 章毓晉. 圖像工程（上冊）——圖像處理. 清華大學出版社
R_temp1 = R(h1,w_new)*(new_position(1) - h_new) + ...
R(h_new,w_new)*(h_new + 1 - new_position(1));
R_temp2 = R(h1,w1)*(new_position(1) - h_new) + ...
R(h_new,w1)*(h_new + 1 - new_position(1));
R_final(h,w) = R_temp1*(w_new + 1 - new_position(2)) + ...
R_temp2*(new_position(2) - w_new);
G_temp1 = G(h1,w_new)*(new_position(1) - h_new) + ...
G(h_new,w_new)*(h_new + 1 - new_position(1));
G_temp2 = G(h1,w1)*(new_position(1) - h_new) + ...
G(h_new,w1)*(h_new + 1 - new_position(1));
G_final(h,w) = G_temp1*(w_new + 1 - new_position(2)) + ...
G_temp2*(new_position(2) - w_new);
B_temp1 = B(h1,w_new)*(new_position(1) - h_new) + ...
B(h_new,w_new)*(h_new + 1 - new_position(1));
B_temp2 = B(h1,w1)*(new_position(1) - h_new) + ...
B(h_new,w1)*(h_new + 1 - new_position(1));
B_final(h,w) = B_temp1*(w_new + 1 - new_position(2)) + ...
B_temp2*(new_position(2) - w_new);
else
gray_temp1 = im_init(h1,w_new)*(new_position(1) - h_new) + ...
im_init(h_new,w_new)*(h_new + 1 - new_position(1));
gray_temp2 = im_init(h1,w1)*(new_position(1) - h_new) + ...
im_init(h_new,w1)*(h_new + 1 - new_position(1));
im_final(h,w) = gray_temp1*(w_new + 1 - new_position(2)) + ...
gray_temp2*(new_position(2) - w_new);
end
end
end
end
end
if ndims(im_init) == 3
im_final(:,:,1) = R_final;
im_final(:,:,2) = G_final;
im_final(:,:,3) = B_final;
end
im_final = im2uint8(mat2gray(im_final));

❻ 常用的像素操作演算法：Resize、Flip、Rotate

圖像縮放是把原圖像按照目標尺寸放大或者縮小，是圖像處理的一種。

圖像縮放有多種演算法。最為簡單的是最臨近插值演算法，它是根據原圖像和目標圖像的尺寸，計算縮放的比例，然後根據縮放比例計算目標像素所依據的原像素，過程中自然會產生小數，這時就採用四捨五入，取與這個點最相近的點。

除此之外，還有雙線性插值演算法。

其公式如下：
f(i+u,j+v) =(1-u)(1-v)f(i,j) + (1-u)vf(i,j+1) + u(1-v)f(i+1,j) + uvf(i+1,j+1)

其中U和V表示浮點坐標的小數部分，顯然離目標點距離越近的點的權重越大，這也正符合目標點的值與離他最近的點最接近這一事實。

cv4j 的resize目前支持這兩種演算法。通過Resize類的源碼，可以看到有兩個常量

使用最臨近插值演算法，將原圖縮小到0.75倍。

使用雙線性插值演算法，將原圖放大2倍。

效果如下：

Flip是翻轉的意思，也被稱為鏡像變換。又可以分為水平鏡像和垂直鏡像，水平鏡像即將圖像左半部分和右半部分以圖像豎直中軸線為中心軸進行兌換，而豎直鏡像則是將圖像上半部分和下半部分以圖像水平中軸線為中心軸進行兌換。

flip的演算法很簡單

實現具體的左右翻轉

實現具體的上下翻轉

效果如下:

圖像旋轉是指圖像以某一點為中心旋轉一定的角度，形成一幅新的圖像的過程。當然這個點通常就是圖像的中心。既然是按照中心旋轉，自然會有這樣一個屬性：旋轉前和旋轉後的點離中心的位置不變。

圖像的旋轉是圖像幾何變換的一種，旋轉前後的圖像的像素的RGB都是沒有改變的，改變的只是每一個像素的所在位置。

cv4j 提供兩種旋轉的演算法：NormRotate和FastRotate

下面以NormRotate為例，使用起來很簡單，旋轉120度，背景為紅色。

效果如下:

cv4j 是 gloomyfish 和我一起開發的圖像處理庫，純java實現，我們已經分離了一個Android版本和一個Java版本。

像素操作是 cv4j 的基本功能之一，本文介紹了三種常見的變換。我們可以通過圖像的Resize、Flip、Rotate變換來豐富圖片數據的多樣性。

如果您想看該系列先前的文章可以訪問下面的文集：
http://www.jianshu.com/nb/10401400