https://blog.csdn.net/cai13160674275/article/details/72991049?locationNum=7&fps=1
 
上文讲了几种简单的方法，显著性检测就是把一幅图像中最吸引人注意的部分提取出来。
 
我用opencv重写了LC，AC,FT三种算法，代码和效果如下：
 
1.，后面的方法其实大概都是基于这个实现的，代码样子差不多
 
LC思路就是利用对某个像素点累加其与全幅像素的距离(欧式距离)，然后归一化到0-255，由于是rgb信息，于是用直方图优化，提前计算好每个颜色与其他的距离和
 
void SalientRegionDetectionBasedonLC(Mat &src){
 
int HistGram[256]={0};
 
int row=src.rows,col=src.cols;
 
int gray[row][col];
 
//int Sal_org[row][col];
 
int val;
 
Mat Sal=Mat::zeros(src.size(),CV_8UC1 );
 
Point3_* p;
 
for (int i=0;i
 
for (int j=0;j
 
p=src.ptr > (i,j);
 
val=(p->x + (p->y) *2 + p->z)/4;
 
HistGram[val]++;
 
gray[i][j]=val;
 
}
 
}
 
int Dist[256];
 
int Y,X;
 
int max_gray=0;
 
int min_gray=1<<28;
 
for (Y = 0; Y 
 
{
 
val = 0;
 
for (X = 0; X 
 
val += abs(Y - X) * HistGram[X];                //    论文公式(9)，灰度的距离只有绝对值，这里其实可以优化速度，但计算量不大，没必要了
 
Dist[Y] = val;
 
max_gray=max(max_gray,val);
 
min_gray=min(min_gray,val);
 
}
 
for (Y = 0; Y 
 
{
 
for (X = 0; X 
 
{
 
Sal.at(Y,X) = (Dist[gray[Y][X]] - min_gray)*255/(max_gray - min_gray);        //    计算全图每个像素的显著性
 
//Sal.at(Y,X) = (Dist[gray[Y][X]])*255/(max_gray);        //    计算全图每个像素的显著性
 
}
 
}
 
imshow("sal",Sal);
 
waitKey(0);
 
}
 
效果图
 

 
2.AC算法也挺有意思，利用了类似图像金字塔算法，在不同纬度(具体实现是用大小不同的均值滤波器过滤图像)与标准图像做差并累加，然后归一化，实现如下:
 
void SalientRegionDetectionBasedonAC(Mat &src,int MinR2, int MaxR2,int Scale){
 
Mat Lab;
 
cvtColor(src, Lab, CV_BGR2Lab);
 
int row=src.rows,col=src.cols;
 
int Sal_org[row][col];
 
memset(Sal_org,0,sizeof(Sal_org));
 
Mat Sal=Mat::zeros(src.size(),CV_8UC1 );
 
Point3_* p;
 
Point3_* p1;
 
int val;
 
Mat filter;
 
int max_v=0;
 
int min_v=1<<28;
 
for (int k=0;k
 
int len=(MaxR2 - MinR2) * k / (Scale - 1) + MinR2;
 
blur(Lab, filter, Size(len,len ));
 
for (int i=0;i
 
for (int j=0;j
 
p=Lab.ptr > (i,j);
 
p1=filter.ptr > (i,j);
 
//cout<x - p1->x)*(p->x - p1->x)+ (p->y - p1->y)*(p->y-p1->y) + (p->z - p1->z)*(p->z - p1->z) <
 
val=sqrt( (p->x - p1->x)*(p->x - p1->x)+ (p->y - p1->y)*(p->y-p1->y) + (p->z - p1->z)*(p->z - p1->z) );
 
Sal_org[i][j]+=val;
 
if(k==Scale-1){
 
max_v=max(max_v,Sal_org[i][j]);
 
min_v=min(min_v,Sal_org[i][j]);
 
}
 
}
 
}
 
}
 
cout<
 
int X,Y;
 
for (Y = 0; Y 
 
{
 
for (X = 0; X 
 
{
 
Sal.at(Y,X) = (Sal_org[Y][X] - min_v)*255/(max_v - min_v);        //    计算全图每个像素的显著性
 
//Sal.at(Y,X) = (Dist[gray[Y][X]])*255/(max_gray);        //    计算全图每个像素的显著性
 
}
 
}
 
imshow("sal",Sal);
 
waitKey(0);
 
}
 
SalientRegionDetectionBasedonAC(test,test.rows/8,test.rows/2,3);
 

 
3.FT算法
 
lab空间的均值减去当前像素值
 
void SalientRegionDetectionBasedonFT(Mat &src){
 
Mat Lab;
 
cvtColor(src, Lab, CV_BGR2Lab);
 
int row=src.rows,col=src.cols;
 
int Sal_org[row][col];
 
memset(Sal_org,0,sizeof(Sal_org));
 
Point3_* p;
 
int MeanL=0,Meana=0,Meanb=0;
 
for (int i=0;i
 
for (int j=0;j
 
p=Lab.ptr > (i,j);
 
MeanL+=p->x;
 
Meana+=p->y;
 
Meanb+=p->z;
 
}
 
}
 
MeanL/=(row*col);
 
Meana/=(row*col);
 
Meanb/=(row*col);
 
GaussianBlur(Lab,Lab,Size(3,3),0,0);
 
Mat Sal=Mat::zeros(src.size(),CV_8UC1 );
 
int val;
 
int max_v=0;
 
int min_v=1<<28;
 
for (int i=0;i
 
for (int j=0;j
 
p=Lab.ptr > (i,j);
 
val=sqrt( (MeanL - p->x)*(MeanL - p->x)+ (p->y - Meana)*(p->y-Meana) + (p->z - Meanb)*(p->z - Meanb) );
 
Sal_org[i][j]=val;
 
max_v=max(max_v,val);
 
min_v=min(min_v,val);
 
}
 
}
 
cout<
 
int X,Y;
 
for (Y = 0; Y 
 
{
 
for (X = 0; X 
 
{
 
Sal.at(Y,X) = (Sal_org[Y][X] - min_v)*255/(max_v - min_v);        //    计算全图每个像素的显著性
 
//Sal.at(Y,X) = (Dist[gray[Y][X]])*255/(max_gray);        //    计算全图每个像素的显著性
 
}
 
}
 
imshow("sal",Sal);
 
waitKey(0);
 
}
 

 
四种比较简单的图像显著性区域特征提取方法原理及实现-----&gt&semi; AC&sol;HC&sol;LC&sol;FT。
 
laviewpbt  2014.8.4 编辑 Email:laviewpbt@sina.com   QQ:33184777 最近闲来蛋痛,看了一些显著性检测的文章,只是简单的看看,并没有深入的研究,以 ...
 
四种简单的图像显著性区域特征提取方法-----AC&sol;HC&sol;LC&sol;FT。
 
四种简单的图像显著性区域特征提取方法-----> AC/HC/LC/FT. 分类: 图像处理 2014-08-03 12:40 4088人阅读 评论(4) 收藏 举报 salient regio ...
 
图像局部显著性—点特征(SURF)
 
1999年的SIFT(ICCV 1999,并改进发表于IJCV 2004,本文描述):参考描述:图像特征点描述. 参考原文:SURF特征提取分析 本文有大量删除,如有疑义,请参考原文. SURF对SI ...
 
基于qml创建最简单的图像处理程序(3)-使用opencv&amp&semi;qml进行图像处理
 
系列课程及配套代码基于qml创建最简单的图像处理程序(1)-基于qml创建界面http://www.cnblogs.com/jsxyhelu/p/83 ...
 
Python下opencv使用笔记(二)(简单几何图像绘制)
 
简单几何图像一般包含点.直线.矩阵.圆.椭圆.多边形等等.首先认识一下opencv对像素点的定义. 图像的一个像素点有1或者3个值.对灰度图像有一个灰度值,对彩色图像有3个值组成一个像素值.他们表现出 ...
 
图像局部显著性—点特征(GLOH)
 
基于古老的Marr视觉理论,视觉识别和场景重建的基础即第一阶段为局部显著性探测.探测到的主要特征为直觉上可刺激底层视觉的局部显著性--特征点.特征线.特征块. 相关介绍:局部特征显著性-点特征(SIF ...
 
图像显著性论文(一)—A Model of saliency Based Visual Attention for Rapid Scene Analysis
 
这篇文章是图像显著性领域最具代表性的文章,是在1998年Itti等人提出来的,到目前为止引用的次数超过了5000,是多么可怕的数字,在它的基础上发展起来的有关图像显著性论文更是数不胜数,论文的提出主要 ...
 
Python用Pillow&lpar;PIL&rpar;进行简单的图像操作
 
Python用Pillow(PIL)进行简单的图像操作 颜色与RGBA值 计算机通常将图像表示为RGB值,或者再加上alpha值(通透度,透明度),称为RGBA值.在Pillow中,RGBA的值表示为 ...
 
图像的全局特征--HOG特征、DPM特征
 
HOG特征:方向梯度直方图(Histogram of Oriented Gradient,)特征是一种全局图像特征描述子. 它通过计算和统计图像局部区域的梯度方向直方图来构成特征.Hog特征结合SVM ...
 
随机推荐
 
Java jstatd详解
 
jstatd 命令全称: Virtual Machine jstat Daemon DESCRIPTION The  jstatd tool is an RMI server application ...
 
视觉中的深度学习方法CVPR 2012 Tutorial Deep Learning Methods for Vision
 
Deep Learning Methods for Vision CVPR 2012 Tutorial  9:00am-5:30pm, Sunday June 17th, Ballroom D (Fu ...
 
RPi 2B Documentation
 
/********************************************************************** * RPi 2B Documentation * 声明: ...
 
帝国cms7&period;0 内容页控制简介字数！
 
帝国cms7.0 内容页有简介部分,使用以下代码可以有效控制字数限制! 下载类简介:=esub($navinfor[softsay],160)?> 文章类简介:=esub($ ...
 
python TCP编程
 
1.socket 服务端和客户端通过socket套接字进行通信 2.服务端 import socket import threading def tcp_handler(connect_sock, a ...
 
PCL中分割方法的介绍(3)
 
(3)上两篇介绍了关于欧几里德分割,条件分割,最小分割法等等还有之前就有用RANSAC法的分割方法,这一篇是关于区域生成的分割法, 区 域生长的基本 思想是: 将具有相似性的像素集合起来构成区域.首先 ...
 
CI框架 -- 核心文件 之 Loader&period;php(加载器)
 
顾名思义,装载器就是加载元素的,使用CI时,经常加载的有: 加载类库文件:$this->load->library()   加载视图文件:$this->load->view() ...
 
Windows 2003扩充磁盘空间
 
diskpartlist volumeselect volume 1 (选择需要扩充空间的分区)extend size=409600 (单位为MB)
 
python笔记2 生成器 文件读写
 
生成器 一边循环一边计算的机制,称为生成器(Generator). 把一个列表生成式的[]改成(),就创建了一个generator: 创建了一个generator后,通过for循环来迭代它. 著名的斐 ...
 
Balanced Numbers(数位dp)
 
Description Balanced numbers have been used by mathematicians for centuries. A positive integer is c ...

 
本代码内容是关于Saliency Detection via Graph-Based Manifold Ranking的算法详解，想要运行此代码还需要一系列的文件，单纯此代码无法演示结果的。
 
可以在网上搜索完整文件，简单来说就是基本的SLIC小程序，其余的不是必要项。
 

 
将数据集直接放入test文件夹中，运行sample或者demo都可以吧，我的是师兄传给我的，跟各位下载的结果应该差别不大。
 
(为了避免大家浪费时间，这里贴出百度云下载链接，链接：
 
关注并且私信我发链接
 
clear all;close all;clc;
 
addpath('./function/');
 
%%------------------------设置参数---------------------%%
 
theta = 0.1; % 控制边缘的权重
 
alpha = 0.99; % 控制流行排序成本函数两个项的平衡
 
spnumber = 200; % 超像素的数量
 
imgRoot = './test/'; % 测试图像的路径
 
saldir = './saliencymap/'; % 显著性图像的输出路径
 
supdir = './superpixels/'; % 超像素标签的文件路径
 
mkdir(supdir);
 
mkdir(saldir);
 
imnames = dir([imgRoot '*' 'jpg']);
 
disp(imnames);
 
imname = [imgRoot imnames.name];
 
[input_im,w] = removeframe(imname); %预处理去掉边框
 
[m,n,k] = size(input_im);
 
%%----------------------生成超像素--------------------%%
 
imname = [imname(1:end-4) '.bmp']; %SLIC软件仅支持bmp格式的图片
 
comm = ['SLICSuperpixelSegmentation' ' ' imname ' ' int2str(20) ' ' int2str(spnumber) ' ' supdir]; %设置启用SLIC.exe前参数
 
%
 
system(comm); %启用SLIC.exe，将每一个像素按照超像素的区域分类，同一区域的超像素赋相同的值，值与此区域的颜色亮度无关
 
spname = [supdir imnames.name(1:end-4) '.dat'];
 
%超像素标签矩阵
 
fid = fopen(spname,'r');%fid是文件代号(句柄)
 
A = fread(fid, m * n, 'uint32'); %fread(fid, N, 'str') N代表读入元素个数， 'str'是格式类型，将此文件顺序读出来，m*n个像素点逐行扫描
 
A = A+1; %把A变成正整数或逻辑值
 
B = reshape(A,[n, m]);%将顺序读出的值改为原图像的二维格式
 
superpixels = B';%B的转置矩阵，转成m*n,从列开始，在同一超像素区域内的像素赋同一值，值仅作为计数用，值为n，表示第n个超像素
 
fclose(fid);
 
spnum = max(superpixels(:)); %实际的超像素数目
 
%%----------------------设计图形模型--------------------------%%
 
%计算特征值 (mean color in lab color space)
 
%对于每个超像素
 
input_vals = reshape(input_im, m*n, k);%将原图像按行扫描转换为(m*n)*3的矩阵，即m*n行,3列的矩阵，分别为rgb
 
%input_im的值为0-1之间，是正常的rgb取值范围，全0表示黑，全1表示白
 
rgb_vals = zeros(spnum,1,3);
 
inds = cell(spnum,1);
 
for i = 1:spnum%从1到spnum，找到superpixels值相同的像素，放到一个cell中
 
inds{i} = find(superpixels==i);
 
rgb_vals(i,1,:) = mean(input_vals(inds{i},:),1);%input_vals每一行代表一个像素，将inds{i}中的所有对应的input_vals中的第几行，也就是
 
%第几个像素，取平均值，rgb_vals(i,1,1)也就是第i个超像素的r值
 
end
 
lab_vals = colorspace('Lab
 
seg_vals = reshape(lab_vals,spnum,3); % 每个超像素点的特征，将三维向量lab_vals变为二维向量，
 
%也就是以每一个超像素(一行Lab为特征)为单位，seg_vals(1,1)表示第1个超像素的L值
 
% 求得边界
 
%求邻接矩阵
 
adjloop = zeros(spnum,spnum);%邻接矩阵，不相连为0，相连为1，默认自身不相连
 
[m1,n1] = size(superpixels);
 
for i = 1:m1-1
 
for j = 1:n1-1
 
if(superpixels(i,j)~=superpixels(i,j+1))%从列开始搜索，临近一个像素的超像素标记值不相等，说明这个像素是两个超像素的边界线上点，即这两个超像素相连
 
adjloop(superpixels(i,j),superpixels(i,j+1)) = 1;%superpixels(i,j)的值代表第几个超像素
 
adjloop(superpixels(i,j+1),superpixels(i,j)) = 1;
 
end;%横方向
 
if(superpixels(i,j)~=superpixels(i+1,j))
 
adjloop(superpixels(i,j),superpixels(i+1,j)) = 1;
 
adjloop(superpixels(i+1,j),superpixels(i,j)) = 1;
 
end;%竖方向
 
if(superpixels(i,j)~=superpixels(i+1,j+1))
 
adjloop(superpixels(i,j),superpixels(i+1,j+1)) = 1;
 
adjloop(superpixels(i+1,j+1),superpixels(i,j)) = 1;
 
end;%捺方向
 
if(superpixels(i+1,j)~=superpixels(i,j+1))
 
adjloop(superpixels(i+1,j),superpixels(i,j+1)) = 1;
 
adjloop(superpixels(i,j+1),superpixels(i+1,j)) = 1;
 
end;%撇方向
 
end;
 
end;
 
bd = unique([superpixels(1,:),superpixels(m,:),superpixels(:,1)',superpixels(:,n)']);%边界的超像素的标记值
 
for i = 1:length(bd)
 
for j = i+1:length(bd)
 
adjloop(bd(i),bd(j)) = 1;
 
adjloop(bd(j),bd(i)) = 1;
 
end
 
end %将边界超像素赋值1，是将边界超像素相连
 
edges = [];
 
for i = 1:spnum; %真实超像素总数
 
indext = [];
 
ind = find(adjloop(i,:)==1);%邻接矩阵行i为1的项，也就是找到所有与第i个超像素相连接的超像素
 
for j = 1:length(ind)
 
indj = find(adjloop(ind(j),:)==1);%indj仅仅起到过渡作用，将与第i个超像素相连接的所有像素的连接情况一行一行的传递到indext中
 
indext = [indext,indj];
 
end
 
indext = [indext,ind];%indext是第i个超像素连接的超像素的连接情况，ind是第i个超像素的连接情况
 
indext = indext((indext>i));%只保留indext中值大于i的项
 
indext = unique(indext);%合并重复项，只保留不重复的项，即获取矩阵indext的不同元素构成的向量
 
%其目的是将第i个超像素的两圈节点与i连接，例如1超像素周围一圈再加边界一共52个与1相连，再加上这52个节点的周围节点也与1相连接，一共92个节点与1相连
 
if(~isempty(indext))
 
ed = ones(length(indext),2);%
 
ed(:,2) = i*ed(:,2);
 
ed(:,1) = indext;%第一列是列举了与i节点相连接的节点，第二列的值就全为i，因为1*i=i
 
edges = [edges;ed];%edges是加上第二圈后的连接边矩阵，一共两列，第一列是加上第二圈后与第i个节点相连接的所有节点(为避免重复运算增加运算速度，列举出第i个节点的所有连接点后，列举第i+1个节点的所有连接点时，去掉第i个节点)，第二列是i
 
end
 
end
 
% 计算关联矩阵
 
valDistances = sqrt(sum((seg_vals(edges(:,1),:)-seg_vals(edges(:,2),:)).^2,2));
 
%b=sum(a,dim); a表示矩阵；dim等于1或者2，1表示每一列进行求和，2表示每一行进行求和
 
%对于valDistances来说,valDistances(1)=sqrt(([1连接的超像素列的第一个的L]-[1的L])^2+[1连接的超像素列的第一个的a]-[1的a])^2+[1连接的超像素列的第一个的b]-[1的b])^2)
 
valDistances = normalize(valDistances); %Normalize to [0,1]
 
weights = exp(-valDistances/theta);%theta=0.1
 
W=sparse([edges(:,1);edges(:,2)],[edges(:,2);edges(:,1)], ...%将weight和edges合并，更加直观
 
[weights;weights],spnum,spnum);
 
% sparse函数用法：
 
% 例如：
 
% 0, 0, 0, 0;
 
% 0, 0, 1, 0;
 
% 0, 0, 0, 0;
 
% 0, 1, 0, 2;
 
% 计算机存储稀疏矩阵可以有两种思路：
 
% 1.按照存储一个普通矩阵一样存储一个稀疏矩阵，比如上面这个稀疏矩阵中总共十六个元素(三个非零元素)，把这些元素全部放入存储空间中。这种存储方式，在matlab就叫做full storage organization。
 
% 2.只存储非零元素，那么怎么存储呢？
 
% (4,2) 1
 
% (2,3) 1
 
% (4,4) 2
 
% 最优化关联矩阵 (公式3) f∗ = y/(D − αW) .
 
dd = sum(W); %sum函数不写第二个参数默认为列求和
 
D = sparse(1:spnum,1:spnum,dd);
 
clear dd; %S = sparse(i,j,s,m,n,nzmax)由向量i,j,s生成一个m*n的含有nzmax个非零元素的稀疏矩阵S;即矩阵A中任何0元素被去除，非零元素及其下标组成矩阵S
 
optAff = eye(spnum)/(D-alpha*W);% eye函数返回单位矩阵,Y = eye(n)：返回n*n单位矩阵
 
mz = diag(ones(spnum,1));%将mz设置为方阵，方阵大小为spnum*spnum，内容全为1
 
mz = ~mz; %将A的对角元素设置为0
 
optAff = optAff.*mz;%将optAff的对角元素归零，因为超像素自身和自身之间的关联性并不考虑，要考虑的话也应该是无限大，没有数值，此矩阵用来表示各个超像素之间的关联性
 
%%-----------------------------显著性检测第一阶段--------------------------%%
 
% 为每个超像素计算显著性值
 
% 作为种子点的上边界
 
% top
 
Yt = zeros(spnum,1);%指示向量
 
bst = unique(superpixels(1,1:n));
 
Yt(bst) = 1;%将上边界的超像素赋值为1
 
bsalt = optAff*Yt;%(spnum*spnum)*(spnum*1)，表示从1到spnum的所有超像素对于上边界超像素的关联性和
 
bsalt = (bsalt-min(bsalt(:)))/(max(bsalt(:))-min(bsalt(:))); %括号内只有一个冒号表示历遍所有元素，将所有元素放进【0,1】中，即正规化数据
 
bsalt = 1-bsalt; %补码为显著性度量
 
% down
 
Yd = zeros(spnum,1);
 
bsd = unique(superpixels(m,1:n));
 
Yd(bsd) = 1;
 
bsald = optAff*Yd; %f*(i) 此向量中的每个元素表示节点与背景种子点的相关性
 
bsald = (bsald-min(bsald(:)))/(max(bsald(:))-min(bsald(:)));
 
bsald = 1-bsald;
 
% right
 
Yr = zeros(spnum,1);
 
bsr = unique(superpixels(1:m,1));
 
Yr(bsr) = 1;
 
bsalr = optAff*Yr;
 
bsalr = (bsalr-min(bsalr(:)))/(max(bsalr(:))-min(bsalr(:)));
 
bsalr = 1-bsalr;
 
% left
 
Yl = zeros(spnum,1);
 
bsl = unique(superpixels(1:m,n));
 
Yl(bsl) = 1;
 
bsall = optAff*Yl;
 
bsall = (bsall-min(bsall(:)))/(max(bsall(:))-min(bsall(:)));
 
bsall = 1-bsall;
 
% combine
 
bsalc = (bsalt.*bsald.*bsall.*bsalr);
 
bsalc = (bsalc-min(bsalc(:)))/(max(bsalc(:))-min(bsalc(:)));
 
% 为每个像素分配显著性值
 
tmapstage1 = zeros(m,n);
 
for i = 1:spnum
 
tmapstage1(inds{i}) = bsalc(i);
 
end
 
tmapstage1 = (tmapstage1-min(tmapstage1(:)))/(max(tmapstage1(:))-min(tmapstage1(:)));%正规化
 
mapstage1 = zeros(w(1),w(2));
 
mapstage1(w(3):w(4),w(5):w(6)) = tmapstage1;
 
mapstage1 = uint8(mapstage1*255); %显著性值的高低俩分配灰度值，越显著值越大
 
outname = [saldir imnames.name(1:end-4) '_stage1' '.png'];
 
imwrite(mapstage1,outname);
 
%%----------------------显著性检测第二阶段-------------------------%%
 
% 自适应阈值二值化
 
th = mean(bsalc); %阈值被设置为整个显著图上的平均显著性
 
bsalc(bsalc
 
bsalc(bsalc>=th)=1;%前景
 
% 为每个超像素计算显著性值
 
fsal = optAff*bsalc;%optAff是所有超像素对所有超像素的关联性，只选取其中的前景部分，即所有前景的显著性值
 
% 为每个像素分配显著性值
 
tmapstage2 = zeros(m,n);
 
for i = 1:spnum
 
tmapstage2(inds{i}) = fsal(i);
 
end
 
tmapstage2 = (tmapstage2-min(tmapstage2(:)))/(max(tmapstage2(:))-min(tmapstage2(:)));
 
mapstage2 = zeros(w(1),w(2));
 
mapstage2(w(3):w(4),w(5):w(6)) = tmapstage2;
 
mapstage2 = uint8(mapstage2*255);
 
outname = [saldir imnames.name(1:end-4) '_stage2' '.png'];
 
imwrite(mapstage2,outname);
 
根据代码内容我有感而发，f∗ =  y/(D − αW)此函数算出所有超像素的关联性后，稍微整理一下就可以当做显著值赋予灰度值，至于论文中提到的两次流形排序，
 
其实在代码中只有一次用到了此函数计算了所有超像素之间的关联性(127-135)。第一次和第二次都只是分别用了类似于指示向量的向量提取出来而已，本质上没有进行两次流形排序，
 
而是算了一次总的，而后再分别提取，算是简化了过程吧，至于模型的化简，仍然还是比较复杂的，需要摸索的，本文仅仅对代码详解注释，希望对大家的理解过程有帮助。

 
目录
 
理论知识
代码步骤
读取图像
得到金字塔图像
提取底层特征
计算显著图
显著图综合
  
运行结果展示

 
理论知识
 
显著性检测 是指按照人类的视觉注意机制，判断出图像中的显著区域，并为该区域分配较高的显著值，通常认为显著区域更有可能包含目标，利用显著性检测的方法能够快速在图像中找到可能的目标区域，可以减少计算量。显著性检测主要是提取底层视觉特征来计算局部区域的差异性。
 
 Itti模型是一种经典的自底向上基于底层显著特征计算的显著性检测模型，其实现过程大致分为高斯滤波、计算底层空间特征图和计算显著性图，结构如下图所示
 
 篇幅原因，详细原理可以参考Itti算法
 
代码步骤
 
全部代码：github链接
 
读取图像
 
读取图像后，将其转化为double类型。
 
img1=im2double(img1);
 
得到金字塔图像
 
一共是九层金字塔，除去原图外，还需要八层。
 
%得到金字塔图像
w=fspecial('gaussian',[3 3]);
img2=imresize(imfilter(img1,w),[m/2 n/2]);
img3=imresize(imfilter(img2,w),[m/4 n/4]);
img4=imresize(imfilter(img3,w),[m/8 n/8]);
img5=imresize(imfilter(img4,w),[m/16 n/16]);
img6=imresize(imfilter(img5,w),[m/32 n/32]);
img7=imresize(imfilter(img6,w),[m/64 n/64]);
img8=imresize(imfilter(img7,w),[m/128 n/128]);
img9=imresize(imfilter(img8,w),[m/256 n/256]);
 
提取底层特征
 
分别提取亮度金字塔、色度金字塔、方向特征金字塔。
 定义亮度金字塔提取函数
 
function I=extract_Ifeature(img)
% 输入：待提取图像
% 输出：亮度特征图
I=(img(:,:,1)+img(:,:,2)+img(:,:,3))./3;
 
定义色度金字塔提取函数，红绿蓝三个特征，以红色为例
 
function R=extract_Rfeature(img)
% 输入：待提取图像
% 输出：红色R特征
R=img(:,:,1)-((img(:,:,2)+img(:,:,3))./2);
 
%亮度金字塔
I1=extract_Ifeature(img1);
I2=extract_Ifeature(img2);
I3=extract_Ifeature(img3);
I4=extract_Ifeature(img4);
I5=extract_Ifeature(img5);
I6=extract_Ifeature(img6);
I7=extract_Ifeature(img7);
I8=extract_Ifeature(img8);
I9=extract_Ifeature(img9);
% figure,
% imshow(I2);


%色度金字塔
%红色特征
R1=extract_Rfeature(img1);
R2=extract_Rfeature(img2);
R3=extract_Rfeature(img3);
R4=extract_Rfeature(img4);
R5=extract_Rfeature(img5);
R6=extract_Rfeature(img6);
R7=extract_Rfeature(img7);
R8=extract_Rfeature(img8);
R9=extract_Rfeature(img9);
% figure,
% imshow(R1);

%绿色特征
G1=extract_Gfeature(img1);
G2=extract_Gfeature(img2);
G3=extract_Gfeature(img3);
G4=extract_Gfeature(img4);
G5=extract_Gfeature(img5);
G6=extract_Gfeature(img6);
G7=extract_Gfeature(img7);
G8=extract_Gfeature(img8);
G9=extract_Gfeature(img9);
% figure,
% imshow(G1);

%蓝色特征
B1=extract_Bfeature(img1);
B2=extract_Bfeature(img2);
B3=extract_Bfeature(img3);
B4=extract_Bfeature(img4);
B5=extract_Bfeature(img5);
B6=extract_Bfeature(img6);
B7=extract_Bfeature(img7);
B8=extract_Bfeature(img8);
B9=extract_Bfeature(img9);
% figure,
% imshow(B1);

%黄色特征
Y1=extract_Yfeature(img1);
Y2=extract_Yfeature(img2);
Y3=extract_Yfeature(img3);
Y4=extract_Yfeature(img4);
Y5=extract_Yfeature(img5);
Y6=extract_Yfeature(img6);
Y7=extract_Yfeature(img7);
Y8=extract_Yfeature(img8);
Y9=extract_Yfeature(img9);
% figure,
%imshow(Y1);
 
提取方向特征，使用Matlab自带的gabor滤波器
 
%方向特征
%使用内置gabor滤波器
gaborArray = gabor(3,[0 45 90 135]);%滤波器数组，波长为10，四个方向
img1_gaborMag=imgaborfilt(rgb2gray(img1),gaborArray);%结果包含四个方向的特征图，在第三维度
img2_gaborMag=imgaborfilt(rgb2gray(img2),gaborArray);
img3_gaborMag=imgaborfilt(rgb2gray(img3),gaborArray);
img4_gaborMag=imgaborfilt(rgb2gray(img4),gaborArray);
img5_gaborMag=imgaborfilt(rgb2gray(img5),gaborArray);
img6_gaborMag=imgaborfilt(rgb2gray(img6),gaborArray);
img7_gaborMag=imgaborfilt(rgb2gray(img7),gaborArray);
img8_gaborMag=imgaborfilt(rgb2gray(img8),gaborArray);
img9_gaborMag=imgaborfilt(rgb2gray(img9),gaborArray);
figure('Name',"原图的 Gabor 特征图（四个方向）")
for i=1:4
    subplot(2,2,i),imshow(img1_gaborMag(:,:,i),[]);
    theta = gaborArray(i).Orientation;
    lambda = gaborArray(i).Wavelength;
    title(sprintf('方向=%d, 波长=%d',theta,lambda));
end
 
计算显著图
 
根据公式计算显著图，这里分辨率不同的特征图合并时以函数中最大的分辨率为标准。
 定义亮度特征取差函数
 
function I_cs=Ifeature_diff(I1,I2)
% 输入：I1为高分辨率图像，I2为低分辨率图像
% 输出：亮度特征取差结果
[m,n]=size(I1);
I2=imresize(I2,[m,n],'nearest');
I_cs=abs(double(I1)-double(I2));
 
定义色度特征取差函数
 
function RGBY=RGBfeature_diff(Rc,Gc,Rs,Gs)
%输入：高分辨率图像红色、绿色特征图，低分辨率图像红色、绿色特征图
%输出：红绿特征取差结果
[m,n]=size(Rc);
Rs=imresize(Rs,[m,n],'nearest');
Gs=imresize(Gs,[m,n],'nearest');
RGBY=abs((double(Rc)-double(Gc))-(double(Gs)-double(Rs)));
 
定义方向特征取差函数
 
function ocs=directionfeature_diff(oc,os)
[m,n]=size(oc);
os=imresize(os,[m,n],'nearest');
ocs=abs(oc-os);
 
%%
%%计算显著图,分辨率以函数中最大的分辨率为标准
%亮度特征取差
I_2_5=double(Ifeature_diff(I2,I5));
I_2_6=double(Ifeature_diff(I2,I6));
I_3_6=double(Ifeature_diff(I3,I6));
I_3_7=double(Ifeature_diff(I3,I7));
I_4_7=double(Ifeature_diff(I4,I7));
I_4_8=double(Ifeature_diff(I4,I8));

%色度特征取差
%RG
RG_2_5=double(RGBfeature_diff(R2,G2,R5,G5));
RG_2_6=double(RGBfeature_diff(R2,G2,R6,G6));
RG_3_6=double(RGBfeature_diff(R3,G3,R6,G6));
RG_3_7=double(RGBfeature_diff(R3,G3,R7,G7));
RG_4_7=double(RGBfeature_diff(R4,G4,R7,G7));
RG_4_8=double(RGBfeature_diff(R4,G4,R8,G8));

%BY
BY_2_5=double(RGBfeature_diff(B2,B2,Y5,Y5));
BY_2_6=double(RGBfeature_diff(B2,B2,Y6,Y6));
BY_3_6=double(RGBfeature_diff(B3,B3,Y6,Y6));
BY_3_7=double(RGBfeature_diff(B3,B3,Y7,Y7));
BY_4_7=double(RGBfeature_diff(B4,B4,Y7,Y7));
BY_4_8=double(RGBfeature_diff(B4,B4,Y8,Y8));

%方向特征取差
%0度
O_2_5_0=double(directionfeature_diff(img2_gaborMag(:,:,1),img5_gaborMag(:,:,1)));
O_2_6_0=double(directionfeature_diff(img2_gaborMag(:,:,1),img6_gaborMag(:,:,1)));
O_3_6_0=double(directionfeature_diff(img3_gaborMag(:,:,1),img6_gaborMag(:,:,1)));
O_3_7_0=double(directionfeature_diff(img3_gaborMag(:,:,1),img7_gaborMag(:,:,1)));
O_4_7_0=double(directionfeature_diff(img4_gaborMag(:,:,1),img7_gaborMag(:,:,1)));
O_4_8_0=double(directionfeature_diff(img4_gaborMag(:,:,1),img8_gaborMag(:,:,1)));

%45度
O_2_5_45=double(directionfeature_diff(img2_gaborMag(:,:,2),img5_gaborMag(:,:,2)));
O_2_6_45=double(directionfeature_diff(img2_gaborMag(:,:,2),img6_gaborMag(:,:,2)));
O_3_6_45=double(directionfeature_diff(img3_gaborMag(:,:,2),img6_gaborMag(:,:,2)));
O_3_7_45=double(directionfeature_diff(img3_gaborMag(:,:,2),img7_gaborMag(:,:,2)));
O_4_7_45=double(directionfeature_diff(img4_gaborMag(:,:,2),img7_gaborMag(:,:,2)));
O_4_8_45=double(directionfeature_diff(img4_gaborMag(:,:,2),img8_gaborMag(:,:,2)));

%90度
O_2_5_90=double(directionfeature_diff(img2_gaborMag(:,:,3),img5_gaborMag(:,:,3)));
O_2_6_90=double(directionfeature_diff(img2_gaborMag(:,:,3),img6_gaborMag(:,:,3)));
O_3_6_90=double(directionfeature_diff(img3_gaborMag(:,:,3),img6_gaborMag(:,:,3)));
O_3_7_90=double(directionfeature_diff(img3_gaborMag(:,:,3),img7_gaborMag(:,:,3)));
O_4_7_90=double(directionfeature_diff(img4_gaborMag(:,:,3),img7_gaborMag(:,:,3)));
O_4_8_90=double(directionfeature_diff(img4_gaborMag(:,:,3),img8_gaborMag(:,:,3)));

%135度
O_2_5_135=double(directionfeature_diff(img2_gaborMag(:,:,4),img5_gaborMag(:,:,4)));
O_2_6_135=double(directionfeature_diff(img2_gaborMag(:,:,4),img6_gaborMag(:,:,4)));
O_3_6_135=double(directionfeature_diff(img3_gaborMag(:,:,4),img6_gaborMag(:,:,4)));
O_3_7_135=double(directionfeature_diff(img3_gaborMag(:,:,4),img7_gaborMag(:,:,4)));
O_4_7_135=double(directionfeature_diff(img4_gaborMag(:,:,4),img7_gaborMag(:,:,4)));
O_4_8_135=double(directionfeature_diff(img4_gaborMag(:,:,4),img8_gaborMag(:,:,4)));
 
显著图综合
 
定义归一化函数，归一化函数很关键
 
function img1 = normalizeImg(img)
%输入：待归一化特征图
%输出：归一化特征图
[r,c]=size(img);
m = 0;%动态存储局部最小值
M=1;%全局最大值

img = mat2gray(img);%全局最大值M归一化,并且数值类型转化为double

%寻找局部最大值
step=16;%搜索步长
for i=1:step:r-step
    for j=1:step:c-step
        tempImg=img(i:i+step-1,j:j+step-1);%取块
        m=[m,max(max(tempImg))];
    end
end

%取平均值
[~,cc]=size(m);
sum=0;
for i=1:cc
    sum=sum+m(i);
end
m_=sum/cc;
img1=img+((M-m_)^2);
 
%%综合显著图
%归一化图像
I_2_5=normalizeImg(I_2_5);
I_2_6=normalizeImg(I_2_6);
I_3_6=normalizeImg(I_3_6);
I_3_7=normalizeImg(I_3_7);
I_4_7=normalizeImg(I_4_7);
I_4_8=normalizeImg(I_4_8);

RG_2_5=normalizeImg(RG_2_5);
RG_2_6=normalizeImg(RG_2_6);
RG_3_6=normalizeImg(RG_3_6);
RG_3_7=normalizeImg(RG_3_7);
RG_4_7=normalizeImg(RG_4_7);
RG_4_8=normalizeImg(RG_4_8);

BY_2_5=normalizeImg(BY_2_5);
BY_2_6=normalizeImg(BY_2_6);
BY_3_6=normalizeImg(BY_3_6);
BY_3_7=normalizeImg(BY_3_7);
BY_4_7=normalizeImg(BY_4_7);
BY_4_8=normalizeImg(BY_4_8);

O_2_5_0=normalizeImg(O_2_5_0);
O_2_6_0=normalizeImg(O_2_6_0);
O_3_6_0=normalizeImg(O_3_6_0);
O_3_7_0=normalizeImg(O_3_7_0);
O_4_7_0=normalizeImg(O_4_7_0);
O_4_8_0=normalizeImg(O_4_8_0);

O_2_5_45=normalizeImg(O_2_5_45);
O_2_6_45=normalizeImg(O_2_6_45);
O_3_6_45=normalizeImg(O_3_6_45);
O_3_7_45=normalizeImg(O_3_7_45);
O_4_7_45=normalizeImg(O_4_7_45);
O_4_8_45=normalizeImg(O_4_8_45);

O_2_5_90=normalizeImg(O_2_5_90);
O_2_6_90=normalizeImg(O_2_6_90);
O_3_6_90=normalizeImg(O_3_6_90);
O_3_7_90=normalizeImg(O_3_7_90);
O_4_7_90=normalizeImg(O_4_7_90);
O_4_8_90=normalizeImg(O_4_8_90);

O_2_5_135=normalizeImg(O_2_5_135);
O_2_6_135=normalizeImg(O_2_6_135);
O_3_6_135=normalizeImg(O_3_6_135);
O_3_7_135=normalizeImg(O_3_7_135);
O_4_7_135=normalizeImg(O_4_7_135);
O_4_8_135=normalizeImg(O_4_8_135);

%综合计算
%亮度
I_c2=I_2_5+I_2_6;
I_c3=I_3_7+I_3_6;
I_c4=I_4_7+I_4_8;

I_c3=imresize(I_c3,size(I_c2),'nearest');
I_c4=imresize(I_c4,size(I_c2),'nearest');

I=(I_c2+I_c3+I_c4);

%色度
c2=RG_2_5+BY_2_5+RG_2_6+BY_2_6;
c3=RG_3_6+BY_3_6+RG_3_7+BY_3_7;
c4=RG_4_7+BY_4_7+RG_4_8+BY_4_8;

c3=imresize(c3,size(c2),'nearest');
c4=imresize(c4,size(c2),'nearest');

C=(c2+c3+c4);

%方向
O2=O_2_5_0+O_2_5_45+O_2_5_90+O_2_5_135+O_2_6_0+O_2_6_45+O_2_6_90+O_2_6_135;
O3=O_3_6_0+O_3_6_45+O_3_6_90+O_3_6_135+O_3_7_0+O_3_7_45+O_3_7_90+O_3_7_135;
O4=O_4_7_0+O_4_7_45+O_4_7_90+O_4_7_135+O_4_8_0+O_4_8_45+O_4_8_90+O_4_8_135;

O3=imresize(O3,size(O2),'nearest');
O4=imresize(O4,size(O2),'nearest');


O=normalizeImg(O2+O3+O4);

S=(double(I)+double(O)+double(C))./3;

figure,
imshow(S,[]);
 
运行结果展示
 
原图
 
 金字塔图像
 
 方向特征
 
 显著图
 

 
摘要:计算机视觉技术目前在很多领域得以广泛应用，而人们要从图像或是视频中提取的信息也日益丰富。而在这些有关应用当中，大部分图像处理的步骤均与提高图像内部细节和特征的可见度有关。这些由人们对从图像中所注意到或是忽略了的内容的一些理解所决定。本文的目的是设计一种基于图像的视觉显著算法(GBVS算法)来实现从图像中提取显著区域。与此同时，在本文中还相应研究了几种其它用于图像处理或是场景中目标检测的算法，它们大部分都从我们对人类视觉处理如何工作的理解中而来，但结果却不尽相同。
 
本文中对于各种图像视觉显著算法的应用主要是由静态图像和动态视频图像中的显著目标提取和处理两个方面组成。在仿真分析时，采用了Matlab软件，通过仿真结果发现在单一背景下，无论是静态或是运动目标，GBVS算法均可以较好的完成显著区域的提取工作。这种图像视觉显著算法既可以应用于简单环境下静态目标的提取，也可以应用于复杂背景下运动目标的提取，具有很广泛的应用范围和良好的开发前景。
 
关键词：人眼视觉;注意机制；显著；GBVS算法；光流法
 
目录
 
摘要
 
Abstract
 
1 概述-1
 
1.1 研究背景和意义-1
 
1.2 国内外研究现状-2
 
1.3 主要工作内容-4
 
1.4 论文结构安排-5
 
2 运动目标检测算法基础-6
 
2.1 光流法原理-6
 
2.2 LK光流算法原理-7
 
2.3 HS光流算法原理-7
 
2.4 光流算法仿真及分析-8
 
3 显著目标检测算法基础-11
 
3.1 人类视觉注意机制-11
 
3.2 生物视觉注意机制模型-11
 
3.2.1 Itti算法模型-11
 
3.2.2 SR算法模型-13
 
3.2.3 GBVS算法模型-14
 
4 Matlab仿真实验结果与分析-16
 
4.1 显著静态目标检测算法仿真与分析-16
 
4.1.1 SR算法仿真结果-16
 
4.2.2 GBVS&Itti算法仿真结果-17
 
4.2 显著运动目标检测算法构建-20
 
4.3 显著运动目标检测算法仿真与分析-21
 
结    论-24
 
参 考 文 献-25
 
致    谢-27