图像处理中的掩蔽_图像掩蔽 - CSDN
  • 和心理系在做的实验,主要是研究基于双眼视差的立体视觉在不同的掩蔽类型以及不同视差条件下的去掩蔽效应。基于双眼视差的立体视觉不改变目标与掩蔽刺激之间的信噪比,但能使不同的刺激被知觉在不同的深度位置上以...

    和心理系在做的实验,主要是研究基于双眼视差的立体视觉在不同的掩蔽类型以及不同视差条件下的去掩蔽效应。基于双眼视差的立体视觉不改变目标与掩蔽刺激之间的信噪比,但能使不同的刺激被知觉在不同的深度位置上以降低目标信号所受到的掩蔽作用。掩蔽作用依据机制不同,可分为能量掩蔽,即不受双眼立体视觉所造成的主观空间分离影响的;以及信息掩蔽,即可以被主观空间分离的。

    实验分为几个阶段,最主要是在阶段II被试在存在掩蔽刺激的情况下判断目标图像中的四个字母是否相同。


    我主要负责生成实验材料,以下是一些关键代码:

    //旋转任意角度随机字母
    Mat letterRandRotateMaskerImage(int tag_location)
    {
    	int target_width=img_width+eye_shift+50;
    	int target_height=img_width+50;
    	Mat masker_img(target_height, target_width,CV_8UC3,Scalar(128,128,128));
    
    	Rect roi;
    	roi.y = 0;
    	roi.height = pics[0].rows;
    	int ini_height = 0;
    
    	int pic_num=pics.size();
    	int ang_num=angles.size();
    
    	while(1)
    	{
    		if((ini_height+pics[0].rows) > target_height) break;
    		//initial roi
    		roi.x = 0;
    		while(1)
    		{
    			roi.y = ini_height;
    			int pic_idx = rand()%pic_num;
    			int rotate_angle = rand()%70;
    			if((pic_idx==8||pic_idx==9)&&rotate_angle>45)
    					rotate_angle=rotate_angle-45;
    			int time_flag=rand()%2;
    			int ver_flag=rand()%2;
    			//rotate picture
    			Mat rota_img = rotateImage(pics[pic_idx], rotate_angle, time_flag,ver_flag);
    			//get roi
    			roi.width = rota_img.cols;
    			roi.height = rota_img.rows;
    			if(roi.x < 0) roi.x = 0;
    			if(roi.y < 0) roi.y = 0;
    			if((roi.x+roi.width) > target_width) break;
    			if((roi.y+roi.height) > target_height) break;
    
    			Mat sub_img(masker_img,roi);
    			for(int i=0;i<sub_img.rows;i++){
    				uchar* ptr_rotate=rota_img.ptr<uchar>(i);
    				uchar* ptr_sub=sub_img.ptr<uchar>(i);
    				for(int j=0;j<sub_img.cols;j++){
    					if( (ptr_rotate[j*3]<180)&&(ptr_rotate[j*3+1]<180) &&((ptr_rotate[j*3+2]<180))){
    						ptr_sub[j*3]=78;
    						ptr_sub[j*3+1]=78;
    						ptr_sub[j*3+2]=78;
    					}
    				}
    			}
    			roi.x = roi.x + pics[pic_idx].cols+2;
    		}
    		//next y position
    		ini_height += pics[0].rows+2;
    	}
    
    	//cout<<"masker ok 2"<<endl;
    	int video_width=img_width*2+border_width*4+img_shift;
    	int video_height=img_width+border_width*2;
    
    	Mat video_img(video_height,video_width,CV_8UC3,Scalar(0,0,0));
    
    	roi.width=img_width;
    	roi.height=img_width;
    	roi.x=border_width;
    	roi.y=border_width;
    	Mat left_video(video_img,roi);
    	
    	roi.x=rand()%10;
    	roi.y=rand()%10;
    	Mat right_target(masker_img,roi);
    
    
    	roi.x+=eye_shift;
    	Mat left_target(masker_img,roi);
    	
    	roi.x=border_width*3+img_shift+img_width;
    	roi.y=border_width;
    	Mat right_video(video_img,roi);
    
    	if(tag_location==0){
    		left_target.copyTo(left_video);
    		right_target.copyTo(right_video);
    	}
    	else if(tag_location==1){
    		left_target.copyTo(right_video);
    		left_target.copyTo(left_video);
    	}
    	else if(tag_location==2){
    		left_target.copyTo(right_video);
    		right_target.copyTo(left_video);
    	}
    	int center_x=video_img.rows/2;
    	int center_y=video_img.cols/2;
    	uchar* p_center=video_img.ptr<uchar>(center_x);
    	p_center[center_y*3]=255;
    	p_center[center_y*3+1]=255;
    	p_center[center_y*3+2]=255;
    
    	return video_img;
    }

    这是最主要的掩蔽刺激,任意旋转角度的字母,主要存在信息掩蔽。还有另外几种掩蔽类型:切割后的字母,随机像素,以及随机相位,都是在此种图像处理的结果。

    生成图片其实为左右两幅,用立体镜放映可以使被试看到“立体”效果,当右眼图像内容相对左眼是向右“偏移”时,会有远离人眼的效果,即掩蔽刺激在目标刺激之后。

    //生成随机目标图像
    Mat targetImage(int tag_same)
    {
    	int id_same,id_dif;
    	if(tag_same){
    		id_same=rand()%26;
    		id_dif=id_same;
    	}else{
    		int dif_tmp=rand()%diff_size;
    		id_same=diffs[dif_tmp];
    		if(dif_tmp%2==0){
    			id_dif=diffs[dif_tmp+1];
    		}else{
    			id_dif=diffs[dif_tmp-1];
    		}
    	}
    	
    	int id_location=rand()%4;
    	int textWidth=pics[id_same].cols;
    	int textHeight=pics[id_same].rows;
    	int x[4],y[4];
    	x[0] = img_width/2-textWidth-text_shift;
    	y[0] = img_width/2-textHeight/2;
    	x[1] = img_width/2-textWidth/2;
    	y[1] = img_width/2-textHeight-text_shift;
    	x[2]=img_width/2+text_shift;
    	y[2]=y[0];
    	x[3]=x[1];
    	y[3]=img_width/2+text_shift;
    	Mat targetImage(img_width,img_width, CV_8UC1, 255);
    	Mat subImage1(targetImage,Rect(x[0],y[0],textWidth,textHeight));
    	Mat subImage2(targetImage,Rect(x[1],y[1],textWidth,textHeight));
    	Mat subImage3(targetImage,Rect(x[2],y[2],textWidth,textHeight));
    	Mat subImage4(targetImage,Rect(x[3],y[3],textWidth,textHeight));
    	Mat aGrayImg;
    	cvtColor(pics[id_same], aGrayImg, CV_BGR2GRAY);
    	if(id_location!=0)
    		aGrayImg.copyTo(subImage1);
    	if(id_location!=1)
    		aGrayImg.copyTo(subImage2);
    	if(id_location!=2)
    		aGrayImg.copyTo(subImage3);
    	if(id_location !=3)
    		aGrayImg.copyTo(subImage4);
    
    	int difTextWidth=pics[id_dif].cols;
    	int difTexttHeight=pics[id_dif].rows;
    	int difX=0;
    	int difY=0;
    	if(id_location==0){
    		difX = img_width/2-difTextWidth-text_shift;
    		difY = img_width/2-difTexttHeight/2;
    	}
    	else if(id_location==1){
    		difX= img_width/2-difTextWidth/2;
    		difY = img_width/2-difTexttHeight-text_shift;
    	}
    	else if(id_location==2){
    		difX=img_width/2+text_shift;
    		difY=img_width/2-difTexttHeight/2;
    	}
    	else{
    		difX=img_width/2-difTextWidth/2;
    		difY=img_width/2+text_shift;
    	}
    	Mat subDifImage(targetImage,Rect(difX,difY,difTextWidth,difTexttHeight));
    	Mat bGrayImg;
    	cvtColor(pics[id_dif], bGrayImg, CV_BGR2GRAY);
    	bGrayImg.copyTo(subDifImage);
    
    	//	imshow("target",targetImage);
    	return targetImage;
    }
    *生成的目标刺激和掩蔽刺激后面要合成一张图,目标刺激的左右眼图是在同一视差



    还有保证各种刺激条件的随机性的代码:

    void randVector(vector<int>&same_ids, vector<int>&type_ids, vector<int>&location_ids, int numbers,int tag)
    {
    	for(int i=0;i<numbers;i++){
    		same_ids[i]=0;
    		type_ids[i]=0;
    		location_ids[i]=0;
    	}
    	int same_number=numbers/2;
    	
    	//type_ids 固定,same_ids 和 location_ids 随机
    	if(tag==0){
    		int same_count=0;
    		while(same_count<same_number){
    			int rand_id=rand()%numbers;
    			if(same_ids[rand_id]==0){
    				same_ids[rand_id]=1;
    				++same_count;
    			}
    		}
    		int same_location_number=same_number/3;
    		for(int s=0;s<2;s++){
    			for(int t=1;t<3;t++){
    				int location_count=0;
    				while(location_count<same_location_number){
    					int rand_id=rand()%numbers;
    					if(same_ids[rand_id]==s&&location_ids[rand_id]==0){
    						location_ids[rand_id]=t;
    						++location_count;
    					}
    				}
    			}
    		}
    
    	} //end of tag==0
    	//location_ids 固定,type_ids 和 same_ids 随机
    	else if(tag==1){
    		int same_count=0;
    		while(same_count<same_number){
    			int rand_id=rand()%numbers;
    			if(same_ids[rand_id]==0){
    				same_ids[rand_id]=1;
    				++same_count;
    			}
    		}
    		int type_numbers=same_number/4;
    		for(int s=0;s<2;s++){
    			for(int t=1;t<4;t++){
    				int type_count=0;
    				while(type_count<type_numbers){
    					int rand_id=rand()%numbers;
    					if(same_ids[rand_id]==s&&type_ids[rand_id]==0){
    						type_ids[rand_id]=t;
    						++type_count;
    					}
    				}
    			}
    		}
    	}// end of tag==1
    	//location_ids ,type_ids 和 same_ids 都随机
    	else if(tag==2){
    		int same_count=0;
    		while(same_count<same_number){
    			int rand_id=rand()%numbers;
    			if(same_ids[rand_id]==0){
    				same_ids[rand_id]=1;
    				++same_count;
    			}
    		}
    		int same_location_number=same_number/3;
    		for(int s=0;s<2;s++){
    			for(int t=1;t<3;t++){
    				int location_count=0;
    				while(location_count<same_location_number){
    					int rand_id=rand()%numbers;
    					if(same_ids[rand_id]==s&&location_ids[rand_id]==0){
    						location_ids[rand_id]=t;
    						++location_count;
    					}
    				}
    			}
    		}
    		int same_type_number=same_location_number/4;
    		for(int s=0;s<2;s++){
    			for(int l=0;l<3;l++){
    				for(int t=1;t<4;t++){
    					int type_count=0;
    					while(type_count<same_type_number){
    						int rand_id=rand()%numbers;
    						if(same_ids[rand_id]==s&&location_ids[rand_id]==l&&type_ids[rand_id]==0){
    							type_ids[rand_id]=t;
    							++type_count;
    						}
    					}
    				}
    			}
    		}
    	}
    	return ;
    
    }

    这段代码写得比较笨拙。。。


    (转载请注明作者和出处:http://blog.csdn.net/xiaowei_cqu未经允许请勿用于商业用途)


    展开全文
  • 冈萨雷斯 数字图像处理(第三版)matlab代码 图3.40 非锐化掩蔽和高提升滤波
  • 数字图像处理——非锐化屏蔽与高提升滤波【像素级别处理】(python) 文章目录数字图像处理——非锐化屏蔽与高提升滤波【像素级别处理】(python)非锐化屏蔽介绍高提升滤波介绍 非锐化屏蔽 介绍 其中非锐化屏蔽...

    数字图像处理——非锐化屏蔽与高提升滤波【像素级别处理】(python)

    非锐化屏蔽

    介绍

    其中非锐化屏蔽是指在原图像中减去一个经过锐化的图层

    其步骤为:

    1. 模糊原图像
    2. 原图像减去模糊图像(差值为模版)
    3. 把模版加到原图像上

    f(x,y)\overline{f}(x,y)为模糊图像
    首先我们可以得到模版
    gmask(x,y)=f(x,y)f(x,y)g_{mask}(x,y)=f(x,y)-\overline{f}(x,y)
    然后在原图像加上模版的一个权重k(k>0):
    g(x,y)=f(x,y)+kf(x,y)g(x,y)=f(x,y)+k*\overline{f}(x,y)
    当k=1时,所得的为非锐化屏蔽

    高提升滤波

    介绍

    其中非锐化屏蔽是指在原图像中加上一个经过锐化的图层

    其步骤为:

    1. 模糊原图像
    2. 原图像减去模糊图像(差值为模版)
    3. 把模版加到原图像上

    f(x,y)\overline{f}(x,y)为模糊图像
    首先我们可以得到模版
    gmask(x,y)=f(x,y)f(x,y)g_{mask}(x,y)=f(x,y)-\overline{f}(x,y)
    然后在原图像加上模版的一个权重k(k>0):
    g(x,y)=f(x,y)+kf(x,y)g(x,y)=f(x,y)+k*\overline{f}(x,y)
    当k>1时,为高提升滤波

    代码实现

    import cv2
    import numpy as np
    import matplotlib.pyplot as plt
    
    img = cv2.imread('Fig0340.tif')  # 测试图片
    H = img.shape[0]
    W = img.shape[1]
    
    #   产生5*5的Gaussian smoothing filter
    # Σ=3,h(x,y)=e^((x^2+y^2)/(2*Σ*Σ))
    h = np.zeros((5, 5))  # 高斯模板
    
    for i in range(5):
        for j in range(5):
            x = i - 2
            y = j - 2
            h[i, j] = np.power(np.e, -(x * x + y * y) / 18)
    
    print(h)
    print(sum(h))
    print(sum(sum(h)))
    
    h /= np.sum(h)  # 归一化处理
    
    print('----')
    print(h)
    print(sum(h))
    print(sum(sum(h)))
    
    spanImg = np.zeros((H + 4, W + 4, 3), np.uint8)  # 5*5扩充后的图像
    
    # print('----------')
    # print(spanImg)
    
    
    for i in range(H):
        for j in range(W):
            spanImg[i + 2, j + 2] = img[i, j]
    
    blurImg = np.zeros((H, W, 3), np.uint8)  # 高斯模糊化之后的图像
    for i in range(H):
        for j in range(W):
            pix = 0
            for x in range(5):
                for y in range(5):
                    pix += h[x, y] * spanImg[i + x, j + y, 0]
            blurImg[i, j, 0] = round(pix)
            blurImg[i, j, 1] = blurImg[i, j, 0]
            blurImg[i, j, 2] = blurImg[i, j, 0]
    
    # Unsharp mask
    UmPix = np.zeros((H, W), np.int32)
    max = 0
    min = 255
    for i in range(H):
        for j in range(W):
            UmPix[i, j] = int(img[i, j, 0]) - blurImg[i, j, 0]
            if UmPix[i, j] > max:
                max = UmPix[i, j]
            if UmPix[i, j] < min:
                min = UmPix[i, j]
    
    t = 0
    if max > min:
        t = 255 / (max - min)
    
    # 归一化的掩蔽图像
    UmImg = np.zeros((H, W, 3), np.uint8)
    for i in range(H):
        for j in range(W):
            UmImg[i, j, 0] = round((UmPix[i, j] - min) * t)
            UmImg[i, j, 1] = UmImg[i, j, 0]
            UmImg[i, j, 2] = UmImg[i, j, 0]
    
    # 压缩至0-255之间的加入钝化掩蔽的图像
    simgk = np.zeros((H, W, 3), np.uint8)
    spixk = np.zeros((H, W), np.int32)
    
    # 加入钝化掩蔽之后的图像
    imgk = np.zeros((H, W, 3), np.uint8)
    pixk = np.zeros((H, W), np.int32)
    
    # 高提升滤波后图像
    imgk2 = np.zeros((H, W, 3), np.uint8)
    pixk2 = np.zeros((H, W), np.int32)
    
    # 这里用到了截断来处理,并没有用scale来处理
    for i in range(H):
        for j in range(W):
            pixk[i, j] = img[i, j, 0] + UmPix[i, j]
            spixk[i, j] = pixk[i, j]
            if pixk[i, j] > 255:
                pixk[i, j] = 255
            if pixk[i, j] < 0:
                pixk[i, j] = 0
            pixk2[i, j] = round(img[i, j, 0] + 4.5 * UmPix[i, j])
            if pixk2[i, j] > 255:
                pixk2[i, j] = 255
            if pixk2[i, j] < 0:
                pixk2[i, j] = 0
            imgk[i, j, 0] = pixk[i, j]
            imgk[i, j, 1] = imgk[i, j, 0]
            imgk[i, j, 2] = imgk[i, j, 0]
            imgk2[i, j, 0] = pixk2[i, j]
            imgk2[i, j, 1] = imgk2[i, j, 0]
            imgk2[i, j, 2] = imgk2[i, j, 0]
    
    # 下面处理压缩0-255之间的图片
    max = 0
    min = 255
    for i in range(H):
        for j in range(W):
            if spixk[i, j] > max:
                max = spixk[i, j]
            if spixk[i, j] < min:
                min = spixk[i, j]
    sk = 0
    if max > min:
        sk = 255 / (max - min)
    for i in range(H):
        for j in range(W):
            simgk[i, j, 0] = round((spixk[i, j] - min) * sk)
            simgk[i, j, 1] = simgk[i, j, 0]
            simgk[i, j, 2] = simgk[i, j, 0]
    
    # 原图
    plt.subplot(3, 2, 1)
    plt.axis('off')
    plt.title('Original Image')
    plt.imshow(img)
    
    # 高斯平滑滤波模糊化的图像
    plt.subplot(3, 2, 2)
    plt.axis('off')
    plt.title('Gaussian Smooth Filter Blurring')
    plt.imshow(blurImg)
    
    # 像素拉伸之后的差值图像
    plt.subplot(3, 2, 3)
    plt.axis('off')
    plt.title('Scaled Unsharped mask(original - blur)')
    plt.imshow(UmImg)
    
    # 锐化并压缩的图像
    plt.subplot(3, 2, 4)
    plt.axis('off')
    plt.title('Sharpened Image(scaled to 0-255)')
    plt.imshow(simgk)
    
    # 加上钝化mask之后的锐化图像
    plt.subplot(3, 2, 5)
    plt.axis('off')
    plt.title('Sharpened Image(clipped to 0-255)')
    plt.imshow(imgk)
    
    # 设置系数为4.5之后的锐化图像
    plt.subplot(3, 2, 6)
    plt.axis('off')
    plt.title('Highboostted Image(k=4.5,clipped)')
    plt.imshow(imgk2)
    
    plt.show()
    
    
    展开全文
  • 冈萨雷斯图像处理—非锐化掩蔽和高提升滤波 MATLAB代码 图像处理小白,昨天老师布置了一个作业,搜半天没答案,直接自己写了呜呜呜 clear,clc; % 读取图像 Img = imread(‘moon.jpg’); M = size(Img); if numel(M)&...

    冈萨雷斯图像处理—非锐化掩蔽和高提升滤波

    MATLAB代码

    图像处理小白,昨天老师布置了一个作业,搜半天没答案,直接自己写了呜呜呜

    clear,clc;
    % 读取图像
    Img = imread(‘moon.jpg’);
    M = size(Img);
    if numel(M)>2
    gray = rgb2gray(Img);
    else
    gray = Img;
    end
    % 创建滤波器
    W = fspecial(‘gaussian’,[5,5],3);
    G = imfilter(gray, W, ‘replicate’);
    subplot(1,5,1);imshow(gray); title(‘原始图像’);
    subplot(1,5,2);imshow(G); title(‘滤波后图像’);
    C = imsubtract(gray,G);
    subplot(1,5,3);imshow©;title(‘非锐化模板’);
    K = imadd(G,C);
    上海大学数学系一名苦逼菜鸟写的,错了别笑我。

    展开全文
  • 转载请标明本文出处:http://blog.csdn.net/tonyshengtan,欢迎大家转载,发现博客被某些论坛转载后,图像无法正常显示,无法正常表达本人观点,对此表示很不满意。有些网站转载了我的博文,很开心的是自己写的东西...

    学习DIP第35天

    转载请标明本文出处:http://blog.csdn.net/tonyshengtan,欢迎大家转载,发现博客被某些论坛转载后,图像无法正常显示,无法正常表达本人观点,对此表示很不满意。有些网站转载了我的博文,很开心的是自己写的东西被更多人看到了,但不开心的是这段话被去掉了,也没标明转载来源,虽然这并没有版权保护,但感觉还是不太好,出于尊重文章作者的劳动,转载请标明出处!!!!

    文章代码已托管,欢迎共同开发:https://github.com/Tony-Tan/DIPpro

     

    开篇废话

     

     

           废话开始,今天写了两篇博客,为了加快学习进度,而且是周末,相当于给自己加个班,而且理论之前已经研究明白了,所以写起来也比较自如。有人在群里问,学习图像处理,要看书还是要写代码还是要作项目,我觉得,看书像是内功心法,写代码相当于招式练习,项目就像实战一样,所以如果只写代码或者一上来就去跟别人做项目而完全不看书研究基础算法就像空中楼阁,美丽但不牢固,更重要的是容易迷失自己,也就是走火入魔,个人观点,本人也在基础练习阶段,所以说这些没什么经验依据,只是自己的理解。

           非锐化掩蔽,一开始感觉这个词好难接受,不知道要干嘛,google之发现线索不多,经过一番研究发现这个词这么理解:非锐化--锐化的相反的操作是平滑,所以非锐化就是平滑操作;掩蔽--字面意思是隐藏,其实我们可以把它理解成为减去除去,所以这个过程就是减去平滑后的图像得到的结果。而实际算法的思路是,原图减去平滑后的图像,得到被削弱的边缘部分,然后按照一定比例和原图相加,如果比例为1,那么就是非锐化掩蔽,如果大于1就是高提升滤波,和前面频率域的高提升,高频强调思路一致,只是那部分用的是频率域方法。

     

     

    数学原理

     

    内容迁移至  

    http://www.face2ai.com/DIP-5-7-灰度图像-图像增强-非锐化掩蔽UnsharpeningMask/

     

     

    http://www.tony4ai.com/DIP-5-7-灰度图像-图像增强-非锐化掩蔽UnsharpeningMask/

    展开全文
  • 学习数字图像处理博客索引 更多细节参考:http://face2ai.com/categories/数字图像处理/ 如对计算机视觉,机器学习,深度学习以及其数学原理有兴趣可以通过下面二维码添加博客管理员,进入讨论群,讨论博客的...
  • 灰度图像--图像增强 非锐化掩蔽 (Unsharpening Mask) ...图像增强图像处理非锐化掩蔽USM 目录(?)[+] 开篇废话数学原理示意图代码结果总结 学习DIP第35天 转载请标明本文出处:http://blog.cs
  • 第1章 绪论 什么是数字图像处理 一副图像可以定义为一个二维函数f(x,y)f(x,y)f...数字图像处理界定为其输入和输出都是图像的处理、从图像提取特征的处理、各个目标的识别 三种典型的计算处理 低级处理:输入输出...
  • 数字图像处理中图像增强算法常用的两种技术:非锐化掩蔽和高提升滤波  非锐化掩蔽:  顾名思义即减去平滑后的图像,其原理流程图如下:  1、平滑原图像:f->s;  2、从原图像减去模糊图像,产生的差值图像...
  • 数字图像处理基础

    2018-09-23 20:27:05
    文章目录数字图像处理数字图像基础图像内插 数字图像处理 数字图像基础 图像内插 用于图像放大、缩小、旋转、几何校正等任务。首先确定变换前后的坐标对应关系,用src表示转换前的图像尺寸,dst表示转换后的图像...
  • 除保留了前两版的大部分内容外,根据读者的反馈,作者在13个方面对本书进行了修订,新增了400多幅图像、200多幅图表及80多道习题,融入了近年来数字图像处理领域的重要进展,因而本书特色鲜明且与时俱进。...
  • 而在数字图像处理中滤波可以分为空间域滤波和频率域滤波。这篇博文主要来学习下空间域滤波。空间域滤波机理 *空间滤波器由一个邻域(典型的是一个较小的矩形)构成,对该邻域所包围的像素按照一定的操作计算出目标...
  • 作者:程昊威 上海电力大学 授课教师:秦伦明 开发环境:VS2012+MFC+Opencv2.4.9 实验目的: 利用VC++实现人脸美化软件,要求: 1、具有人脸美化界面;...美白:使用图像增强—非掩蔽锐化 ...
  • 刚开始看冈萨雷斯的《数字图像处理》时,3.7节 混合空间增强法中图3.4.3的全身骨骼图的印象非常深刻。牛XX啊,这么模糊,都能变得这么清楚。虽然书也给出了大段大段的解释,但是能力实在有限,又是自学的,看得...
  • 前面的章节我们介绍了图像的灰度变换以及空间域滤波,本章我们介绍图像的频域滤波。什么是频率?频率我们可以直观的理解为空间或者时间的变化率。对于图像来说,傅里叶变换的频率与图像中的亮度变化直接联系。...
  • 数学工具: 阵列与矩阵操作 ... 几何空间变换和图像配准 向量与矩阵操作 图像变换 概率方法 一 灰度变换与空间滤波 基本的灰度变换函数 函数类型 作用 ...
  • 本节为opencv数字图像处理(3):灰度变换与空间滤波的第三小节,图像平滑与锐化,主要包括:平滑线性滤波器(均值、盒装etc)、统计排序滤波器(中值etc)、拉普拉斯算子、梯度算子、边缘检测算子的对比及其C++实现...
  • 适用场景:增强嵌入在一幅图像的暗区域的白色或灰色细节,特别是当黑色的面积在尺寸上占主导地位的时候。 1.2.对数变换(反对数变换与其相反) 过程:将输入范围较窄的低灰度值映射为输出较宽范围的灰度值。...
  • 在印刷和出版界使用多年的图像锐化处理过程是从原图像中减去一幅非锐化(平滑过的)版本。这个称为非锐化掩蔽处理过程由下列步骤组成: 1、模糊原图像 2、从原图像中减去模糊图像(产生的差值图像称为模板) 3...
1 2 3 4 5 ... 20
收藏数 1,319
精华内容 527
关键字:

图像处理中的掩蔽