数字图像处理代码（数字图像处理代码注释）

今天给各位分享数字图像处理代码的知识，其中也会对数字图像处理代码注释进行解释，如果能碰巧解决你现在面临的问题，别忘了关注本站，现在开始吧！

本文目录一览：

• 1、数字图像处理期末作业。 A类作业，使用MATLAB，求一份代码
• 2、数字图像处理直方图均衡化的程序源代码是什么？
• 3、数字图像处理 图像缩放以及旋转的算法代码
• 4、数字图像处理Python实现图像灰度变换、直方图均衡、均值滤波
• 5、Matlab数字图像处理二值化

数字图像处理期末作业。 A类作业，使用MATLAB，求一份代码

展开全部

Image=imread('原图像');

subplot(2,2,1)

imshow(Image);

title('原图');

Spectrum=fft2(Image);

subplot(2,2,2)

imshow(Spectrum);

title('FFT 变换结果');

subplot(2,2,3)

Spectrum=fftshift(Spectrum);

imshow(Spectrum);

title('零点平移');

subplot(2,2,4)

imshow(log(abs(Spectrum)),[]);

title('系数分布图');

%低通滤波

figure; %建立一张空白图纸

subplot(2,2,1)

imshow(log(abs(Spectrum)),[]);

title('系数分布图');

Filter=zeros(180,240); %滤波数组赋初值,全零；自己根据图像的分辨率来确定，如180*240

r=50; %滤波窗口半径,从中心到半径窗口内滤波数组赋值1

for i=(180/2-r+1):(180/2+r);

for j=(240/2-r+1):(240/2+r);

Filter(i,j)=1;

end;

end;

subplot(2,2,2)

imshow(Filter,[]);

title('滤波窗口');

SpectrumN=Filter.*Spectrum; %频谱与滤波模板卷积

subplot(2,2,3)

imshow(log(abs(SpectrumN)),[]);

title('滤波后频谱');

SpectrumN=ifftshift(SpectrumN);

I2=ifft2(SpectrumN);

subplot(2,2,4)

imshow(abs(I2),[]);

title('反变换图像');

这是我们以前做实验时用的程序，用的傅里叶变换，你稍微改动下应该就行了~

数字图像处理直方图均衡化的程序源代码是什么？

clear all

%一，图像的预处理，读入彩色图像将其灰度化

PS=imread('1.jpg'); %读入JPG彩色图像文件

imshow(PS) %显示出来

title('输入的彩色JPG图像')

imwrite(rgb2gray(PS),'PicSampleGray.bmp'); %将彩色图片灰度化并保存

PS=rgb2gray(PS); %灰度化后的数据存入数组

%二，绘制直方图

[m,n]=size(PS); %测量图像尺寸参数

GP=zeros(1,256); %预创建存放灰度出现概率的向量

for k=0:255

GP(k+1)=length(find(PS==k))/(m*n); %计算每级灰度出现的概率，将其存入GP中相应位置

end

figure,bar(0:255,GP,'g') %绘制直方图

title('原图像直方图')

xlabel('灰度值')

ylabel('出现概率')

%三，直方图均衡化

S1=zeros(1,256);

for i=1:256

for j=1:i

S1(i)=GP(j)+S1(i); %计算Sk

end

end

S2=round((S1*256)+0.5); %将Sk归到相近级的灰度

for i=1:256

GPeq(i)=sum(GP(find(S2==i))); %计算现有每个灰度级出现的概率

end

figure,bar(0:255,GPeq,'b') %显示均衡化后的直方图

title('均衡化后的直方图')

xlabel('灰度值')

ylabel('出现概率')

%四，图像均衡化

PA=PS;

for i=0:255

PA(find(PS==i))=S2(i+1); %将各个像素归一化后的灰度值赋给这个像素

end

figure,imshow(PA) %显示均衡化后的图像

title('均衡化后图像')

imwrite(PA,'PicEqual.bmp');

数字图像处理 图像缩放以及旋转的算法代码

clear all;

I = imread('lena.bmp');

figure; imshow(I);title('原图像');

[m,n]=size(I);

%%% 缩小 临近法

M = 0.5;    %放大倍数

%新的图像大小

m1=m*M;n1=n*M;

%****************************************************

for i=1:m1

    for j=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);

for i=1:m2

  for j=1:n2

    x=i/N;

    y=j/N;

    u=floor(x);

    v=floor(y);

    a=x-u;

    b=y-v;

    if u+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);

for u=1:n2

  for v=1:m2

    %新图像坐标变换到原图像坐标x和y中

    temp = T*([u;v]-[u0;0]);

    x= temp(1);

    y= temp(2);

    if x=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);

数字图像处理Python实现图像灰度变换、直方图均衡、均值滤波

import CV2

import copy

import numpy as np

import random

使用的是pycharm

因为最近看了《银翼杀手2049》，里面Joi实在是太好看了所以原图像就用Joi了

要求是灰度图像，所以第一步先把图像转化成灰度图像

# 读入原始图像

img = CV2.imread('joi.jpg')

# 灰度化处理

gray = CV2.cvtColor(img, CV2.COLOR_BGR2GRAY)

CV2.imwrite('img.png', gray)

第一个任务是利用分段函数增强灰度对比，我自己随便写了个函数大致是这样的

def chng(a):

if a 255/3:

b = a/2

elif a 255/3*2:

b = (a-255/3)*2 + 255/6

else:

b = (a-255/3*2)/2 + 255/6 +255/3*2

return b

rows = img.shape[0]

cols = img.shape[1]

cover = copy.deepcopy(gray)

for i in range(rows):

for j in range(cols):

cover[i][j] = chng(cover[i][j])

CV2.imwrite('cover.png', cover)

下一步是直方图均衡化

# histogram equalization

def hist_equal(img, z_max=255):

H, W = img.shape

# S is the total of pixels

S = H * W * 1.

out = img.copy()

sum_h = 0.

for i in range(1, 255):

ind = np.where(img == i)

sum_h += len(img[ind])

z_prime = z_max / S * sum_h

out[ind] = z_prime

out = out.astype(np.uint8)

return out

covereq = hist_equal(cover)

CV2.imwrite('covereq.png', covereq)

在实现滤波之前先添加高斯噪声和椒盐噪声（代码来源于网络）

不知道这个椒盐噪声的名字是谁起的感觉隔壁小孩都馋哭了

用到了random.gauss()

percentage是噪声占比

def GaussianNoise(src,means,sigma,percetage):

NoiseImg=src

NoiseNum=int(percetage*src.shape[0]*src.shape[1])

for i in range(NoiseNum):

randX=random.randint(0,src.shape[0]-1)

randY=random.randint(0,src.shape[1]-1)

NoiseImg[randX, randY]=NoiseImg[randX,randY]+random.gauss(means,sigma)

if NoiseImg[randX, randY] 0:

NoiseImg[randX, randY]=0

elif NoiseImg[randX, randY]255:

NoiseImg[randX, randY]=255

return NoiseImg

def PepperandSalt(src,percetage):

NoiseImg=src

NoiseNum=int(percetage*src.shape[0]*src.shape[1])

for i in range(NoiseNum):

randX=random.randint(0,src.shape[0]-1)

randY=random.randint(0,src.shape[1]-1)

if random.randint(0,1)=0.5:

NoiseImg[randX,randY]=0

else:

NoiseImg[randX,randY]=255

return NoiseImg

covereqg = GaussianNoise(covereq, 2, 4, 0.8)

CV2.imwrite('covereqg.png', covereqg)

covereqps = PepperandSalt(covereq, 0.05)

CV2.imwrite('covereqps.png', covereqps)

下面开始均值滤波和中值滤波了

就以n x n为例，均值滤波就是用这n x n个像素点灰度值的平均值代替中心点，而中值就是中位数代替中心点，边界点周围补0；前两个函数的作用是算出这个点的灰度值，后两个是对整张图片进行

#均值滤波模板

def mean_filter(x, y, step, img):

sum_s = 0

for k in range(x-int(step/2), x+int(step/2)+1):

for m in range(y-int(step/2), y+int(step/2)+1):

if k-int(step/2) 0 or k+int(step/2)+1 img.shape[0]

or m-int(step/2) 0 or m+int(step/2)+1 img.shape[1]:

sum_s += 0

else:

sum_s += img[k][m] / (step*step)

return sum_s

#中值滤波模板

def median_filter(x, y, step, img):

sum_s=[]

for k in range(x-int(step/2), x+int(step/2)+1):

for m in range(y-int(step/2), y+int(step/2)+1):

if k-int(step/2) 0 or k+int(step/2)+1 img.shape[0]

or m-int(step/2) 0 or m+int(step/2)+1 img.shape[1]:

sum_s.append(0)

else:

sum_s.append(img[k][m])

sum_s.sort()

return sum_s[(int(step*step/2)+1)]

def median_filter_go(img, n):

img1 = copy.deepcopy(img)

for i in range(img.shape[0]):

for j in range(img.shape[1]):

img1[i][j] = median_filter(i, j, n, img)

return img1

def mean_filter_go(img, n):

img1 = copy.deepcopy(img)

for i in range(img.shape[0]):

for j in range(img.shape[1]):

img1[i][j] = mean_filter(i, j, n, img)

return img1

完整main代码如下：

if __name__ == "__main__":

# 读入原始图像

img = CV2.imread('joi.jpg')

# 灰度化处理

gray = CV2.cvtColor(img, CV2.COLOR_BGR2GRAY)

CV2.imwrite('img.png', gray)

rows = img.shape[0]

cols = img.shape[1]

cover = copy.deepcopy(gray)

for i in range(rows):

for j in range(cols):

cover[i][j] = chng(cover[i][j])

CV2.imwrite('cover.png', cover)

covereq = hist_equal(cover)

CV2.imwrite('covereq.png', covereq)

covereqg = GaussianNoise(covereq, 2, 4, 0.8)

CV2.imwrite('covereqg.png', covereqg)

covereqps = PepperandSalt(covereq, 0.05)

CV2.imwrite('covereqps.png', covereqps)

meanimg3 = mean_filter_go(covereqps, 3)

CV2.imwrite('medimg3.png', meanimg3)

meanimg5 = mean_filter_go(covereqps, 5)

CV2.imwrite('meanimg5.png', meanimg5)

meanimg7 = mean_filter_go(covereqps, 7)

CV2.imwrite('meanimg7.png', meanimg7)

medimg3 = median_filter_go(covereqg, 3)

CV2.imwrite('medimg3.png', medimg3)

medimg5 = median_filter_go(covereqg, 5)

CV2.imwrite('medimg5.png', medimg5)

medimg7 = median_filter_go(covereqg, 7)

CV2.imwrite('medimg7.png', medimg7)

medimg4 = median_filter_go(covereqps, 7)

CV2.imwrite('medimg4.png', medimg4)

Matlab数字图像处理二值化

你可以先把原图像a滤波

保存到一个数组中

b

再把原图像a锐化保存到c数组中

b+c构成处理后的图像

用imwrite把这个写到你新的bmp中

或者是在photoshop中直接滤波

然后在图像上锐化即可

关于数字图像处理代码和数字图像处理代码注释的介绍到此就结束了，不知道你从中找到你需要的信息了吗 ？如果你还想了解更多这方面的信息，记得收藏关注本站。