图像特征提取源码
① 网上找到的SIFT特征提取代码，怎么使用
这是源码里针对找到图像特征点进行聚类的函数，运行到这里sift算法已经结束了。可以试着吧调用kmeans算法的部分注释掉，搭陵只执行sift算法然后打出来特征点看一下效果。我也不明白弊枝丛在一张图像上对特征点聚类的意义何在。对多张图像聚类租樱还有意义。
② 对图像进行边缘特征提取程序代码
基于小波变换的多尺度燃睁大图像边缘检测matlab源代皮竖码(在Matlab7.0下早漏运行)
clear all;
load wbarb;
I = ind2gray(X,map);imshow(I);
I1 = imadjust(I,stretchlim(I),[0,1]);figure;imshow(I1);
[N,M] = size(I);
h = [0.125,0.375,0.375,0.125];
g = [0.5,-0.5];
delta = [1,0,0];
J = 3;
a(1:N,1:M,1,1:J+1) = 0;
dx(1:N,1:M,1,1:J+1) = 0;
dy(1:N,1:M,1,1:J+1) = 0;
d(1:N,1:M,1,1:J+1) = 0;
a(:,:,1,1) = conv2(h,h,I,'same');
dx(:,:,1,1) = conv2(delta,g,I,'same');
dy(:,:,1,1) = conv2(g,delta,I,'same');
x = dx(:,:,1,1);
y = dy(:,:,1,1);
d(:,:,1,1) = sqrt(x.^2+y.^2);
I1 = imadjust(d(:,:,1,1),stretchlim(d(:,:,1,1)),[0 1]);figure;imshow(I1);
lh = length(h);
lg = length(g);
for j = 1:J+1
lhj = 2^j*(lh-1)+1;
lgj = 2^j*(lg-1)+1;
hj(1:lhj)=0;
gj(1:lgj)=0;
for n = 1:lh
hj(2^j*(n-1)+1)=h(n);
end
for n = 1:lg
gj(2^j*(n-1)+1)=g(n);
end
a(:,:,1,j+1) = conv2(hj,hj,a(:,:,1,j),'same');
dx(:,:,1,j+1) = conv2(delta,gj,a(:,:,1,j),'same');
dy(:,:,1,j+1) = conv2(gj,delta,a(:,:,1,j),'same');
x = dx(:,:,1,j+1);
y = dy(:,:,1,j+1);
dj(:,:,1,j+1) = sqrt(x.^2+y.^2);
I1 = imadjust(dj(:,:,1,j+1),stretchlim(dj(:,:,1,j+1)),[0 1]);figure;imshow(I1);
End
③ 求人脸识别源代码
基于Gabor特征提取和人工智能的人脸检测系统源代码Face Detection System
这是一个使用了Gabor特征提取和人工智能的人脸检测系统源代码关键内容
使用步骤：
1. 拷贝所有文件到MATLAB工作目录下(确认已经安装了图像处理工具箱和人工智能工具箱)
2. 找到"main.m"文件
3. 命令行中运行它
4. 点击"Train Network"，等待程序训练好样本
5. 点击"Test on Photos"，选择一个.jpg图片，识别。
6. 等待程序检测出人脸区域
createffnn.m, drawrec.m, gabor.m, im2vec.m, imscan.m, loadimages.m, main.m, template1.png, template2.png, trainnet.m
④ 求matlab彩色图片的颜色特征提取算法的代码，和纹理特征提取的代码。传统方法即可。
其实学数字图像处理，关键的不是源代码（和一般编程还是有区别的，这个是经验之谈，其实一般博导未必会编程，但是你和他说说你的方法，他一般都能切中要害），而是你能理解基于概念及适用场所。
基于颜色、纹理、形状都属于低层特征，这些你理解就够了，关键是对你的课题适合哪种方法来映射到高层语义上面，例如：识别物体轮廓，那可能形状就比较适合等。
我之所以写上面那段话，主要是我感觉你索取代码也不说明具体要求，也就是方向不明确。
如今颜色特征提取算法有很多，诸如颜色直方图、颜色矩、颜色集、颜色聚合向量、颜色相关图等，既然你没说，我就给个IEEE CSVT 2001的一篇关于颜色直方图法的论文（源码版权归作者所有）：
function colorhist = colorhist(rgb)
% CBIR_colorhist() --- color histogram calculation
% input: MxNx3 image data, in RGB
% output: 1x256 colorhistogram == (HxSxV = 16x4x4)
% as the MPEG-7 generic color histogram descriptor
% [Ref] Manjunath, B.S.; Ohm, J.-R.; Vasudevan, V.V.; Yamada, A., "Color and texture descriptors"
% IEEE Trans. CSVT, Volume: 11 Issue: 6 , Page(s): 703 -715, June 2001 (section III.B)
% check input
if size(rgb,3)~=3
error('3 components is needed for histogram');
end
% globals
H_BITS = 4; S_BITS = 2; V_BITS = 2;
%rgb2hsv可用rgb2hsi代替，见你以前的提问。
hsv = uint8(255*rgb2hsv(rgb));
imgsize = size(hsv);
% get rid of irrelevant boundaries
i0=round(0.05*imgsize(1)); i1=round(0.95*imgsize(1));
j0=round(0.05*imgsize(2)); j1=round(0.95*imgsize(2));
hsv = hsv(i0:i1, j0:j1, :);
% histogram
for i = 1 : 2^H_BITS
for j = 1 : 2^S_BITS
for k = 1 : 2^V_BITS
colorhist(i,j,k) = sum(sum( ...
bitshift(hsv(:,:,1),-(8-H_BITS))==i-1 &...
bitshift(hsv(:,:,2),-(8-S_BITS))==j-1 &...
bitshift(hsv(:,:,3),-(8-V_BITS))==k-1 ));
end
end
end
colorhist = reshape(colorhist, 1, 2^(H_BITS+S_BITS+V_BITS));
% normalize
colorhist = colorhist/sum(colorhist);
%基于纹理特征提取灰度共生矩阵用于纹理判断
% Calculates cooccurrence matrix
% for a given direction and distance
%
% out = cooccurrence (input, dir, dist, symmetric);
%
% INPUT:
% input: input matrix of any size
%
% dir: direction of evaluation
% "dir" value Angle
% 0 0
% 1 -45
% 2 -90
% 3 -135
% 4 -180
% 5 +135
% 6 +90
% 7 +45
%
% dist: distance between pixels
%
% symmetric: 1 for symmetric version
% 0 for non-symmetric version
%
% eg: out = cooccurrence (input, 0, 1, 1);
% Author: Baran Aydogan (15.07.2006)
% RGI, Tampere University of Technology
% [email protected]
function out = cooccurrence (input, dir, dist, symmetric);
input = round(input);
[r c] = size(input);
min_intensity = min(min(input));
max_intensity = max(max(input));
out = zeros(max_intensity-min_intensity+1);
if (dir == 0)
dir_x = 0; dir_y = 1;
end
if (dir == 1)
dir_x = 1; dir_y = 1;
end
if (dir == 2)
dir_x = 1; dir_y = 0;
end
if (dir == 3)
dir_x = 1; dir_y = -1;
end
if (dir == 4)
dir_x = 0; dir_y = -1;
end
if (dir == 5)
dir_x = -1; dir_y = -1;
end
if (dir == 6)
dir_x = -1; dir_y = 0;
end
if (dir == 7)
dir_x = -1; dir_y = 1;
end
dir_x = dir_x*dist;
dir_y = dir_y*dist;
out_ind_x = 0;
out_ind_y = 0;
for intensity1 = min_intensity:max_intensity
out_ind_x = out_ind_x + 1;
out_ind_y = 0;
[ind_x1 ind_y1] = find (input == intensity1);
ind_x1 = ind_x1 + dir_x;
ind_y1 = ind_y1 + dir_y;
for intensity2 = min_intensity:max_intensity
out_ind_y = out_ind_y + 1;
[ind_x2 ind_y2] = find (input == intensity2);
count = 0;
for i = 1:size(ind_x1,1)
for j = 1:size(ind_x2,1)
if ( (ind_x1(i) == ind_x2(j)) && (ind_y1(i) == ind_y2(j)) )
count = count + 1;
end
end
end
out(out_ind_x, out_ind_y) = count;
end
end
if (symmetric)
if (dir < 4)
dir = dir + 4;
else
dir = mod(dir,4);
end
out = out + cooccurrence (input, dir, dist, 0);
end
⑤ 我也求一份opencv下提取图片sift特征的项目源码，急用，谢谢您了
#include "stdafx.h"
#include <opencv2/opencv.hpp>
double
compareSURFDescriptors( const float* d1, const float* d2, double best, int length )
{
double total_cost = 0;
assert( length % 4 == 0 );
for( int i = 0; i < length; i += 4 )
{
double t0 = d1[i ] - d2[i ];
double t1 = d1[i+1] - d2[i+1];
double t2 = d1[i+2] - d2[i+2];
double t3 = d1[i+3] - d2[i+3];
total_cost += t0*t0 + t1*t1 + t2*t2 + t3*t3;
if( total_cost > best )
break;
}
return total_cost;
}
int
naiveNearestNeighbor( const float* vec, int laplacian,
const CvSeq* model_keypoints,
const CvSeq* model_descriptors )
{
int length = (int)(model_descriptors->elem_size/sizeof(float));
int i, neighbor = -1;
double d, dist1 = 1e6, dist2 = 1e6;
CvSeqReader reader, kreader;
cvStartReadSeq( model_keypoints, &kreader, 0 );
cvStartReadSeq( model_descriptors, &reader, 0 );
for( i = 0; i < model_descriptors->total; i++ )
{
const CvSURFPoint* kp = (const CvSURFPoint*)kreader.ptr;
const float* mvec = (const float*)reader.ptr;
CV_NEXT_SEQ_ELEM( kreader.seq->elem_size, kreader );
CV_NEXT_SEQ_ELEM( reader.seq->elem_size, reader );
if( laplacian != kp->laplacian )
continue;
d = compareSURFDescriptors( vec, mvec, dist2, length );
if( d < dist1 )
{
dist2 = dist1;
dist1 = d;
neighbor = i;
}
else if ( d < dist2 )
dist2 = d;
}
if ( dist1 < 0.6*dist2 )
return neighbor;
return -1;
}
void
findPairs( const CvSeq* objectKeypoints, const CvSeq* objectDescriptors,
const CvSeq* imageKeypoints, const CvSeq* imageDescriptors, vector<int>& ptpairs )
{
int i;
CvSeqReader reader, kreader;
cvStartReadSeq( objectKeypoints, &kreader );
cvStartReadSeq( objectDescriptors, &reader );
ptpairs.clear();
for( i = 0; i < objectDescriptors->total; i++ )
{
const CvSURFPoint* kp = (const CvSURFPoint*)kreader.ptr;
const float* descriptor = (const float*)reader.ptr;
CV_NEXT_SEQ_ELEM( kreader.seq->elem_size, kreader );
CV_NEXT_SEQ_ELEM( reader.seq->elem_size, reader );
int nearest_neighbor = naiveNearestNeighbor( descriptor, kp->laplacian, imageKeypoints, imageDescriptors );
if( nearest_neighbor >= 0 )
{
ptpairs.push_back(i);
ptpairs.push_back(nearest_neighbor);
}
}
}
void
flannFindPairs( const CvSeq*, const CvSeq* objectDescriptors,
const CvSeq*, const CvSeq* imageDescriptors, vector<int>& ptpairs )
{
int length = (int)(objectDescriptors->elem_size/sizeof(float));
cv::Mat m_object(objectDescriptors->total, length, CV_32F);
cv::Mat m_image(imageDescriptors->total, length, CV_32F);
// descriptors
CvSeqReader obj_reader;
float* obj_ptr = m_object.ptr<float>(0);
cvStartReadSeq( objectDescriptors, &obj_reader );
for(int i = 0; i < objectDescriptors->total; i++ )
{
const float* descriptor = (const float*)obj_reader.ptr;
CV_NEXT_SEQ_ELEM( obj_reader.seq->elem_size, obj_reader );
memcpy(obj_ptr, descriptor, length*sizeof(float));
obj_ptr += length;
}
CvSeqReader img_reader;
float* img_ptr = m_image.ptr<float>(0);
cvStartReadSeq( imageDescriptors, &img_reader );
for(int i = 0; i < imageDescriptors->total; i++ )
{
const float* descriptor = (const float*)img_reader.ptr;
CV_NEXT_SEQ_ELEM( img_reader.seq->elem_size, img_reader );
memcpy(img_ptr, descriptor, length*sizeof(float));
img_ptr += length;
}
// find nearest neighbors using FLANN
cv::Mat m_indices(objectDescriptors->total, 2, CV_32S);
cv::Mat m_dists(objectDescriptors->total, 2, CV_32F);
cv::flann::Index flann_index(m_image, cv::flann::KDTreeIndexParams(4)); // using 4 randomized kdtrees
flann_index.knnSearch(m_object, m_indices, m_dists, 2, cv::flann::SearchParams(64) ); // maximum number of leafs checked
int* indices_ptr = m_indices.ptr<int>(0);
float* dists_ptr = m_dists.ptr<float>(0);
for (int i=0;i<m_indices.rows;++i) {
if (dists_ptr[2*i]<0.6*dists_ptr[2*i+1]) {
ptpairs.push_back(i);
ptpairs.push_back(indices_ptr[2*i]);
}
}
}
/* a rough implementation for object location */
int
locatePlanarObject( const CvSeq* objectKeypoints, const CvSeq* objectDescriptors,
const CvSeq* imageKeypoints, const CvSeq* imageDescriptors,
const CvPoint src_corners[4], CvPoint dst_corners[4] )
{
double h[9];
CvMat _h = cvMat(3, 3, CV_64F, h);
vector<int> ptpairs;
vector<CvPoint2D32f> pt1, pt2;
CvMat _pt1, _pt2;
int i, n;
#ifdef USE_FLANN
flannFindPairs( objectKeypoints, objectDescriptors, imageKeypoints, imageDescriptors, ptpairs );
#else
findPairs( objectKeypoints, objectDescriptors, imageKeypoints, imageDescriptors, ptpairs );
#endif
n = (int)(ptpairs.size()/2);
if( n < 4 )
return 0;
pt1.resize(n);
pt2.resize(n);
for( i = 0; i < n; i++ )
{
pt1[i] = ((CvSURFPoint*)cvGetSeqElem(objectKeypoints,ptpairs[i*2]))->pt;
pt2[i] = ((CvSURFPoint*)cvGetSeqElem(imageKeypoints,ptpairs[i*2+1]))->pt;
}
_pt1 = cvMat(1, n, CV_32FC2, &pt1[0] );
_pt2 = cvMat(1, n, CV_32FC2, &pt2[0] );
if( !cvFindHomography( &_pt1, &_pt2, &_h, CV_RANSAC, 5 ))
return 0;
for( i = 0; i < 4; i++ )
{
double x = src_corners[i].x, y = src_corners[i].y;
double Z = 1./(h[6]*x + h[7]*y + h[8]);
double X = (h[0]*x + h[1]*y + h[2])*Z;
double Y = (h[3]*x + h[4]*y + h[5])*Z;
dst_corners[i] = cvPoint(cvRound(X), cvRound(Y));
}
return 1;
}
int main(int argc, char** argv)
{
const char* object_filename = argc == 3 ? argv[1] : "box.png";
const char* scene_filename = argc == 3 ? argv[2] : "box_in_scene.png";
IplImage* object = cvLoadImage( object_filename, CV_LOAD_IMAGE_GRAYSCALE );
IplImage* image = cvLoadImage( scene_filename, CV_LOAD_IMAGE_GRAYSCALE );
if( !object || !image )
{
fprintf( stderr, "Can not load %s and/or %s\n",
object_filename, scene_filename );
exit(-1);
}
CvMemStorage* storage = cvCreateMemStorage(0);
cvNamedWindow("Object", 1);
cvNamedWindow("Object Correspond", 1);
static CvScalar colors[] =
{
{{0,0,255}},
{{0,128,255}},
{{0,255,255}},
{{0,255,0}},
{{255,128,0}},
{{255,255,0}},
{{255,0,0}},
{{255,0,255}},
{{255,255,255}}
};
IplImage* object_color = cvCreateImage(cvGetSize(object), 8, 3);
cvCvtColor( object, object_color, CV_GRAY2BGR );
CvSeq* objectKeypoints = 0, *objectDescriptors = 0;
CvSeq* imageKeypoints = 0, *imageDescriptors = 0;
int i;
CvSURFParams params = cvSURFParams(500, 1);
double tt = (double)cvGetTickCount();
cvExtractSURF( object, 0, &objectKeypoints, &objectDescriptors, storage, params );
printf("Object Descriptors: %d\n", objectDescriptors->total);
cvExtractSURF( image, 0, &imageKeypoints, &imageDescriptors, storage, params );
printf("Image Descriptors: %d\n", imageDescriptors->total);
tt = (double)cvGetTickCount() - tt;
printf( "Extraction time = %gms\n", tt/(cvGetTickFrequency()*1000.));
CvPoint src_corners[4] = {{0,0}, {object->width,0}, {object->width, object->height}, {0, object->height}};
CvPoint dst_corners[4];
IplImage* correspond = cvCreateImage( cvSize(image->width, object->height+image->height), 8, 1 );
cvSetImageROI( correspond, cvRect( 0, 0, object->width, object->height ) );
cvCopy( object, correspond );
cvSetImageROI( correspond, cvRect( 0, object->height, correspond->width, correspond->height ) );
cvCopy( image, correspond );
cvResetImageROI( correspond );
#ifdef USE_FLANN
printf("Using approximate nearest neighbor search\n");
#endif
if( locatePlanarObject( objectKeypoints, objectDescriptors, imageKeypoints,
imageDescriptors, src_corners, dst_corners ))
{
for( i = 0; i < 4; i++ )
{
CvPoint r1 = dst_corners[i%4];
CvPoint r2 = dst_corners[(i+1)%4];
cvLine( correspond, cvPoint(r1.x, r1.y+object->height ),
cvPoint(r2.x, r2.y+object->height ), colors[8] );
}
}
vector<int> ptpairs;
#ifdef USE_FLANN
flannFindPairs( objectKeypoints, objectDescriptors, imageKeypoints, imageDescriptors, ptpairs );
#else
findPairs( objectKeypoints, objectDescriptors, imageKeypoints, imageDescriptors, ptpairs );
#endif
for( i = 0; i < (int)ptpairs.size(); i += 2 )
{
CvSURFPoint* r1 = (CvSURFPoint*)cvGetSeqElem( objectKeypoints, ptpairs[i] );
CvSURFPoint* r2 = (CvSURFPoint*)cvGetSeqElem( imageKeypoints, ptpairs[i+1] );
cvLine( correspond, cvPointFrom32f(r1->pt),
cvPoint(cvRound(r2->pt.x), cvRound(r2->pt.y+object->height)), colors[8] );
}
cvShowImage( "Object Correspond", correspond );
for( i = 0; i < objectKeypoints->total; i++ )
{
CvSURFPoint* r = (CvSURFPoint*)cvGetSeqElem( objectKeypoints, i );
CvPoint center;
int radius;
center.x = cvRound(r->pt.x);
center.y = cvRound(r->pt.y);
radius = cvRound(r->size*1.2/9.*2);
cvCircle( object_color, center, radius, colors[0], 1, 8, 0 );
}
cvShowImage( "Object", object_color );
cvWaitKey(0);
cvDestroyWindow("Object");
cvDestroyWindow("Object Correspond");
return 0;
}
⑥ matlab特征提取相关代码求解答
提取网站的部分源代码 是不需要软件的 Internet Explorer
本身就支持JSP,ASP等网页编辑的代码.
操作方法: 在页面宏扮空白处单击右键 选择 查看源文件(V)
(其中有一些独立的加密文基绝肢件是无权查搏世看的,
即便是你使用第三方软件,被加密的文件也无法复制或篡改)
⑦ 求基于matlab指纹扫描图像处理的源代码
clear all,close all,clc % 清理工作空间，关闭运行窗口，清理命令窗口
I=imread('Empreinte.bmp'); % 读入图像
imshow(I) % 显示图像
set(gcf,'position',[1 1 600 600]); % 得到图形窗口句柄，设置图形窗口位置
J=I(:,:,1)>160; % 设定阈值为160，进行黑白化处理
imshow(J) % 显示处理后的图像
set(gcf,'position',[1 1 600 600]); % 得到图形窗口句柄，设置图形窗口位置
K=bwmorph(~J,'thin','inf'); % 数学形态学运算，图像细化，~符号代表黑白反色
imshow(~K) % 显示处理后的图像，~符号代表黑白反色
set(gcf,'position',[1 1 600 600]); % 得到图形窗口句柄，设置图形窗口位置
function y=minutie(x)
i=ceil(size(x)/2);
if x(i,i)==0;
y=0;
else
y=sum(x(:)) - 1;
end
fun=@minutie; % 得到函数句柄
L = nlfilter(K,[3 3],fun); % 滤波处理
LTerm=(L==1); % 选择端点
imshow(LTerm) % 显示白色点
LTermLab=bwlabel(LTerm); % 端点标识
propTerm=regionprops(LTermLab,'Centroid'); % 端点区域分析，寻找端点区域中心
CentroidTerm=round(cat(1,propTerm(:).Centroid)); % 端点圆整为整数
imshow(~K) % 显示隆线细化图像
set(gcf,'position',[1 1 600 600]); % 得到当前图形窗口句柄，设置位置
hold on % 在前面的图形窗口继续绘制图像
plot(CentroidTerm(:,1),CentroidTerm(:,2),'ro') % 绘制隆线端点标识，红色圆圈
LBif=(L==3); % 选择分叉点
LBifLab=bwlabel(LBif); % 分叉点标识
propBif=regionprops(LBifLab,'Centroid','Image'); % 区域分析，寻找区域中心
CentroidBif=round(cat(1,propBif(:).Centroid)); % 分叉点圆整为整数
plot(CentroidBif(:,1),CentroidBif(:,2),'go') % 绘制隆线分叉点标识，绿色圆圈
D=6;
Distance=DistEuclidian(CentroidBif,CentroidTerm); % 求端点和分叉点的距离
SpuriousMinutae=Distance<D; % 满足距离小于D的点
[i,j]=find(SpuriousMinutae); % 查找对应像素点
CentroidBif(i,:)=[]; % 去除该分叉点
CentroidTerm(j,:)=[]; % 去除该端点
Distance=DistEuclidian(CentroidBif); % 求两个分叉点的距离
SpuriousMinutae=Distance<D; % 满足距离小于D的点
[i,j]=find(SpuriousMinutae); % 查找对应像素点
CentroidBif(i,:)=[]; % 去除该分叉点
Distance=DistEuclidian(CentroidTerm); % 求两个端点的距离
SpuriousMinutae=Distance<D; % 满足距离小于D的点
[i,j]=find(SpuriousMinutae); % 查找对应像素点
CentroidTerm(i,:)=[]; % 去除该端点
hold off % 结束在前面的图形窗口绘图
imshow(~K) % 显示细化图
hold on % 继续在前面的图形窗口绘图
plot(CentroidTerm(:,1),CentroidTerm(:,2),'ro') % 绘制隆线端点标识，红色圆圈
plot(CentroidBif(:,1),CentroidBif(:,2),'go') % 绘制隆线分叉点标识，绿色圆圈
hold off % 结束在前面的图形窗口绘图
Kopen=imclose(K,strel('square',7)); % 闭合运算
KopenClean= imfill(Kopen,'holes'); % 填充图像中的孔洞
KopenClean=bwareaopen(KopenClean,5); % 开运算
imshow(KopenClean) % 显示处理结果
KopenClean([1 end],:)=0; % 赋值语句
KopenClean(:,[1 end])=0; % 赋值语句
ROI=imerode(KopenClean,strel('disk',10)); % 腐蚀运算
imshow(ROI) % 显示处理结果
imshow(I) % 显示原始图像
hold on % 继续在前面的图形窗口绘图
imshow(ROI) % 显示感兴趣区域
alpha(0.5) % 设置透明度
hold on % 继续在前面的图形窗口绘图
plot(CentroidTerm(:,1),CentroidTerm(:,2),'ro') % 绘制端点标识，红色圆圈
plot(CentroidBif(:,1),CentroidBif(:,2),'go') % 绘制分叉点标识，绿色圆圈
hold off % 结束在前面的图形窗口绘图
[m,n]=size(I(:,:,1)); % 求图像尺寸
indTerm=sub2ind([m,n]; % 从下标得到单精度索引
CentroidTerm(:,1),CentroidTerm(:,2)); % 端点
Z=zeros(m,n); % 全零矩阵
Z(indTerm)=1;
ZTerm=Z.*ROI';
[CentroidTermX,CentroidTermY]=find(ZTerm);
indBif=sub2ind([m,n],CentroidBif(:,1),CentroidBif(:,2)); % 从下标得到单精度索引
Z=zeros(m,n);
Z(indBif)=1;
ZBif=Z.*ROI';
[CentroidBifX,CentroidBifY]=find(ZBif);
imshow(I) % 显示原始图像
hold on % 继续绘图
plot(CentroidTermX,CentroidTermY,'ro','linewidth',2) % 红色圆圈
plot(CentroidBifX,CentroidBifY,'go','linewidth',2) % 绿色圆圈
Table=[3*pi/4 2*pi/3 pi/2 pi/3 pi/4 % 角度查找表
5*pi/6 0 0 0 pi/6
pi 0 0 0 0
-5*pi/6 0 0 0 -pi/6
-3*pi/4 -2*pi/3 -pi/2 -pi/3 -pi/4];
for ind=1:length(CentroidTermX)
Klocal=K(CentroidTermY(ind)-2:CentroidTermY(ind)+2, ...
CentroidTermX(ind)-2:CentroidTermX(ind)+2);
Klocal(2:end-1,2:end-1)=0;
[i,j]=find(Klocal);
OrientationTerm(ind,1)=Table(i,j);
end
dxTerm=sin(OrientationTerm)*5;
dyTerm=cos(OrientationTerm)*5;
figure % 新建窗口
imshow(K) % 显示黑白图
set(gcf,'position',[1 1 600 600]); % 设置图像窗口属性
hold on % 继续绘图
plot(CentroidTermX,CentroidTermY,'ro','linewidth',2) % 红色圆圈
plot([CentroidTermX CentroidTermX+dyTerm]',... % 红色短线
[CentroidTermY CentroidTermY-dxTerm]','r','linewidth',2)
for ind=1:length(CentroidBifX)
Klocal=K(CentroidBifY(ind)-2:CentroidBifY(ind)+2, ...
CentroidBifX(ind)-2:CentroidBifX(ind)+2);
Klocal(2:end-1,2:end-1)=0;
[i,j]=find(Klocal);
if length(i)~=3
CentroidBifY(ind)=NaN;
CentroidBifX(ind)=NaN;
OrientationBif(ind)=NaN;
else
for k=1:3
OrientationBif(ind,k)=Table(i(k),j(k));
dxBif(ind,k)=sin(OrientationBif(ind,k))*5;
dyBif(ind,k)=cos(OrientationBif(ind,k))*5;
end
end
end
plot(CentroidBifX,CentroidBifY,'go','linewidth',2) % 绿色圆圈
OrientationLinesX=[CentroidBifX ...
CentroidBifX+dyBif(:,1);CentroidBifX ...
CentroidBifX+dyBif(:,2);CentroidBifX CentroidBifX+dyBif(:,3)]';
OrientationLinesY=[CentroidBifY
CentroidBifY-dxBif(:,1);CentroidBifY ...
CentroidBifY-dxBif(:,2);CentroidBifY CentroidBifY-dxBif(:,3)]';
plot(OrientationLinesX,OrientationLinesY,'g','linewidth',2) % 绿色短线
MinutiaTerm=[CentroidTermX,CentroidTermY,OrientationTerm];
MinutiaBif=[CentroidBifX,CentroidBifY,OrientationBif];
saveMinutia('John Doe',MinutiaTerm,MinutiaBif); % saveMinutia函数见附件程序
⑧ OpenCV3.0.0中关于ORB算法提取特征点的程序怎么写还有ORB算法的源码位置在哪里
先新建工程，控制台程序，然后把代码复制进去
接着添加库函数，然后调试运行，看看出现什么错误再接着更改。
对了，还要将你要匹配的图像文件放到工程文件的目录下。
⑨ 纹理特征提取方法：LBP, 灰度共生矩阵
搬运自本人 CSDN 博客： 《纹理特征提取方法：LBP, 灰度共生矩阵》
注：本文中大量行内 Latex 公式在中不支持，如果想要仔细参阅，请移步上面的 CSDN 博客链接。
在前面的博文 《图像纹理特征总体简述》 中，笔者总结了图像纹理特征及其分类。在这里笔者对其中两种算法介绍并总结。
参考网址：
《纹理特征提取》
《【纹理特征】LBP 》
《灰度共生矩阵（GLCM）理解》
《灰度共生矩阵的理解》
《图像的纹理特征之灰度共生矩阵 》
参考论文：
《基于灰度共生矩阵提取纹理特征图像的研究》——冯建辉
《灰度共生矩阵纹理特征提取的Matlab实现》——焦蓬蓬
LBP方法（Local binary patterns, 局部二值模式）是一种用来描述图像局部纹理特征的算子；它的作用是进行特征提取，提取图像的局部纹理特征。
LBP是一个计算机视觉中用于图像特征分类的一个方法，用于纹理特征提取。后来LBP方法与HOG特征分类器与其他机器学习算法联合使用。
LBP算法的核心思想，是以某个像素点为中心，与其邻域像素点共同计算。关于邻域像素点的选择方法，其实并不唯一：
这里选择环形邻域的方法进行说明：
窗口中心的像素点作为中心，该像素点的像素值作为阈值。然后将周围8个像素点的灰度值与该阈值进行比较，若周围某像素值大于中心像素值，则该像素点位置被标记为1；反之，该像素点标记为0。
如此这样，该窗口的8个点可以产生8位的无符号数，这样就得到了该窗口的LBP值，该值反应了该窗口的纹理信息。如下图所示：
图中，中心像素点的像素值作为阈值，其值v = 3；周围邻域8个像素值中，橘塌如有3个比阈值小的像素点置0，5个比阈值大的像素点置1。
LBP算法的计算公式如下：
$$ LBP_{P, R}(x_{c},y_{c}) = sum_{p=0}^{P-1}s(g_{p} - g_{c})2^p, s(x)=left{egin{matrix}1 : x geq 0 0 : x leq 0 end{matrix} ight. $$
LBP纹理特征向量，一般以图像分块LBP直方图表示。具体步骤如下：
得到了整幅图像的LBP纹理特征后，便可以利用SVM或者其他机器学习算法进行分类了。
这两天笔者将会对源码进行测试封装，以后会上传到我的GitHub网站上。
灰度共生矩阵法(GLCM, Gray-level co-occurrence matrix)，就是通过计算灰度图像得到它的共生矩阵，然后透过计算该共生矩阵得到矩阵的部分特征值，来分别代表图像的某些纹理特征（纹理的定义仍是难点）。灰度共生圆启矩阵能反映图像灰度关于<font color = red> 方向、相邻间隔、变化幅度等 </font>综合信息，它是分析图像的局部模式和它们排列规则的基础。
对于灰度共生矩阵的理解，需要明确几个概念：方向，偏移量和灰度共生矩阵的阶数。
计算纹理特征第一步，就是将多通道的图像（一般指RGB图像）转换为灰度图像，分别提取出多个通道的灰度图像。
纹理特征是一种结构特征，使用不同通道图像得到的纹理特征都是一样的，所以可以任意选择其一。
一般在一幅图像中的灰度级有256级，从0--255。但在计算灰度共生矩阵时我们并不需要256个灰度级，且计算量实在太大，所以一般分为8个灰度级或16个灰度级。
而且当分成8个灰度级时，如果直接将像素点的灰度值除以32取整，会引起影像清晰度降低，所以进行灰度级压缩时，首先我们会将图片进行直方图均衡化处理，增加灰度值的动态范围，这样就增加了影像的整体对比效果。
注：笔者后文中的例子中，为了简要说明，所以灰衫肢度等级简单设置为4。
计算特征值前，先选择计算过程中的一些参数：
下面分部且适当的使用一些例子说明计算过程：
为了达到简单说明计算纹理特征值的目的，笔者此处做简要的假设：灰度被分为4阶，灰度阶从0--3；窗口大小为6 × 6；
窗口A的灰度矩阵A如下：
窗口B的灰度矩阵B如下：
此处以左上角元素为坐标原点，原点记为(1, 1)；以此为基础举例，第四行第二列的点记为(4, 2)；
情景1：d = 1，求0°方向矩阵A的共生矩阵：
则按照0°方向（即水平方向 从左向右，从右向左两个方向 ），统计矩阵值(1, 2)，则如下图所示：
$$
P_{A}(d=1, heta =0^o)=egin{vmatrix}
0 & 8 & 0 & 7
8 & 0 & 8 & 0
0 & 8 & 0 & 7
7 & 0 & 7 & 0
end{vmatrix}
$$
情景2：d = 1，求45°方向矩阵A的共生矩阵：
按照情景1，同理可得此时的统计矩阵结果如下：
$$
P_{A}(d=1, heta =45^o)=egin{vmatrix}
12 & 0 & 0 & 0
0 & 14 & 0 & 0
0 & 0 & 12 & 0
0 & 0 & 0 & 12
end{vmatrix}
$$
情景3：d = 1，求0°与45°方向矩阵B的共生矩阵：
与前面同理，可以得到矩阵B的统计及矩阵结果如下：
$$
P_{B}(d=1, heta =0^o)=egin{vmatrix}
24 & 4 & 0 & 0
4 & 8 & 0 & 0
0 & 0 & 12 & 2
0 & 0 & 2 & 4
end{vmatrix}
$$
$$
P_{B}(d=1, heta =45^o)=egin{vmatrix}
18 & 3 & 3 & 0
3 & 6 & 1 & 1
3 & 1 & 6 & 1
0 & 1 & 1 & 2
end{vmatrix}
$$
矩阵A, B的其余90°、135°矩阵与上面同理，所以笔者偷懒略去。
这样，我们就已经计算得到了单个窗口的灰度共生矩阵的各个方向的矩阵，下面就要用刚才算出的矩阵计算灰度共生矩阵特征值。
用P表示灰度共生矩阵的归一化频率矩阵，其中i, j表示按照某方向同时出现于两个像素的某两个级别的灰度值，所以P(i, j)表示满足这种情况的两个像素出现的概率。
以上述情景2中的矩阵为例：
原矩阵为：
$$
P(d=1, heta =45^o)=egin{vmatrix}
12 & 0 & 0 & 0
0 & 14 & 0 & 0
0 & 0 & 12 & 0
0 & 0 & 0 & 12
end{vmatrix}
$$
归一化后，矩阵形式变为：
$$
P(d=1, heta =45^o)=egin{vmatrix}
12/50 & 0 & 0 & 0
0 & 14/50 & 0 & 0
0 & 0 & 12/50 & 0
0 & 0 & 0 & 12/50
end{vmatrix}
$$
灰度共生矩阵理论的前辈Haralick等人用灰度共生矩阵提出了14中特征值，但由于灰度共生矩阵的计算量很大，所以为了简便，我们一般采用四个最常用的特征来提取图像的纹理特征：<font color=red> 能量、对比度、相关度、熵 </font>。
$ ASM = sum_{i} sum_{j}P(i, j)^2 $
能量是灰度共生矩阵各元素的平方和，又被称角二阶距。它是图像纹理灰度变化均一的度量，反映了图像灰度分布均匀程度和纹理粗细程度。
$ CON = sum_{i} sum_{j} (i-j)^2 P(i,j) $
对比度是灰度共生矩阵主对角线附近的惯性矩，它体现矩阵的值如何分布，反映了图像的清晰度和纹理沟纹的深浅。
$ CORRLN = [sum_{i} sum_{j}((ij)P(i,j)) - mu_{x} mu_{y}]/ sigma_{x} sigma_{y} $
相关度体现了空间灰度共生矩阵元素在行或列方向上的相似程度，反映了图像局部灰度相关性。
$ ENT = - sum_{i} sum_{j} P(i,j) log P(i,j) $
熵体现了图像纹理的随机性。若共生矩阵中所有值都相等，取得最大值；若共生矩阵中的值不均匀，则其值会变得很小。
求出该灰度共生矩阵各个方向的特征值后，再对这些特征值进行均值和方差的计算，这样处理就消除了方向分量对纹理特征的影响。
一个滑动窗口计算结束后，该窗口就可以移动一个像素点，形成另一个小窗口图像，重复进行上一步的计算，生成新窗口图像的共生矩阵和纹理特征值；
以此类推，滑动窗口遍历完所有的图像像素点后，整个图像就形成了一个由纹理特征值构成的一个纹理特征值矩阵。
之后，就可以将这个纹理特征值矩阵转换成纹理特征图像。
笔者已经对源码进行测试了封装，并上传到了笔者的GitHub网站上。
GitHub： https://github.com/upcAutoLang/GLCM-OpenCV
⑩ 常用的十大python图像处理工具
原文标题：10 Python image manipulation tools.
作者 | Parul Pandey
翻译 | 安其罗乔尔、JimmyHua
今天，在我们的世界里充满了数据，图像成为构成这些数据的重要组成部分。但无论是用于何种用途，这些图像都需要进行处理。图像处理就是分析和处理数字图像的过程，主要旨在提高其质量或从中提取一些信息，然后可以将其用于某种用途。
图像处理中的常见任务包括显示图像，基本操作如裁剪、翻转、旋转等，图像分割，分类和特征提取，图像恢复和图像识别。Python成为这种图像处理任务是一个恰当选择，这是因为它作为一种科学编程语言正在日益普及，并且在其生态系统中免费提供许多最先进的图像处理工具供大家使用。
让我们看一下可以用于图像处理任务中的常用 Python 库有哪些吧。
1.scikit-image
scikit-image是一个开源的Python包，适用于numpy数组。它实现了用于研究，教育和工业应用的算法和实用工具。即使是那些刚接触Python生态系统的人，它也是一个相当简单直接的库。此代码是由活跃的志愿者社区编写的，具有高质量和同行评审的性质。
资源
文档里记录了丰富的例子和实际用例，阅读下面的文档：
http://scikit-image.org/docs/stable/user_guide.html
用法
该包作为skimage导入，大多数功能都在子模块中找的到。下面列举一些skimage的例子：
图像过滤
使用match_template函数进行模板匹配
你可以通过此处查看图库找到更多示例。
2. Numpy
Numpy是Python编程的核心库之一，并为数组提供支持。图像本质上是包含数据点像素的标准Numpy数组。因此，我们可以通过使用基本的NumPy操作，例如切片、掩膜和花式索引，来修改图像的像素值。可以使用skimage加载图像并使用matplotlib显示图像。
资源
Numpy的官方文档页面提供了完整的资源和文档列表：
http://www.numpy.org/
用法
使用Numpy来掩膜图像.
3.Scipy
scipy是Python的另一个类似Numpy的核心科学模块，可用于基本的图像操作和处理任务。特别是子模块scipy.ndimage，提供了在n维NumPy数组上操作的函数。该包目前包括线性和非线性滤波，二值形态学，B样条插值和对象测量等功能函数。
资源
有关scipy.ndimage包提供的完整功能列表，请参阅下面的链接：
https://docs.scipy.org/doc/scipy/reference/tutorial/ndimage.html#correlation-and-convolution
用法
使用SciPy通过高斯滤波器进行模糊：
4. PIL/ Pillow
PIL( Python图像库 )是Python编程语言的一个免费库，它支持打开、操作和保存许多不同的文件格式的图像。然而， 随着2009年的最后一次发布，它的开发停滞不前。但幸运的是还有有Pillow，一个PIL积极开发的且更容易安装的分支，它能运行在所有主要的操作系统，并支持Python3。这个库包含了基本的图像处理功能，包括点运算、使用一组内置卷积核的滤波和色彩空间的转换。
资源
文档中有安装说明，以及涵盖库的每个模块的示例：
https://pillow.readthedocs.io/en/3.1.x/index.html
用法
在 Pillow 中使用 ImageFilter 增强图像：
5. OpenCV-Python
OpenCV( 开源计算机视觉库 )是计算机视觉应用中应用最广泛的库之一 。OpenCV-Python 是OpenCV的python版API。OpenCV-Python的优点不只有高效，这源于它的内部组成是用C/C++编写的，而且它还容易编写和部署（因为前端是用Python包装的）。这使得它成为执行计算密集型计算机视觉程序的一个很好的选择。
资源
OpenCV-Python-Guide指南可以让你使用OpenCV-Python更容易：
https://github.com/abidrahmank/OpenCV2-Python-Tutorials
用法
下面是一个例子，展示了OpenCV-Python使用金字塔方法创建一个名为“Orapple”的新水果图像融合的功能。
6. SimpleCV
SimpleCV 也是一个用于构建计算机视觉应用程序的开源框架。有了它，你就可以访问几个高性能的计算机视觉库，如OpenCV，而且不需要先学习了解位深度、文件格式、颜色空间等。
它的学习曲线大大小于OpenCV，正如它们的口号所说“计算机视觉变得简单”。一些支持SimpleCV的观点有：
即使是初学者也可以编写简单的机器视觉测试摄像机、视频文件、图像和视频流都是可互操作的资源
官方文档非常容易理解，而且有大量的例子和使用案例去学习：
https://simplecv.readthedocs.io/en/latest/
用法
7. Mahotas
Mahotas 是另一个计算机视觉和图像处理的Python库。它包括了传统的图像处理功能例如滤波和形态学操作以及更现代的计算机视觉功能用于特征计算，包括兴趣点检测和局部描述符。该接口是Python语言，适合于快速开发，但是算法是用C语言实现的，并根据速度进行了调优。Mahotas库速度快，代码简洁，甚至具有最小的依赖性。通过原文阅读它们的官方论文以获得更多的了解。
资源
文档包括安装指导，例子，以及一些教程，可以更好的帮助你开始使用mahotas。
https://mahotas.readthedocs.io/en/latest/install.html
用法
Mahotas库依赖于使用简单的代码来完成任务。关于‘Finding Wally’的问题，Mahotas做的很好并且代码量很少。下面是源码：
https://mahotas.readthedocs.io/en/latest/wally.html
8. SimpleITK
ITK 或者 Insight Segmentation and Registration Toolkit是一个开源的跨平台系统，为开发人员提供了一套广泛的图像分析软件工具 。其中, SimpleITK是建立在ITK之上的简化层，旨在促进其在快速原型设计、教育、解释语言中的应用。SimpleITK 是一个图像分析工具包，包含大量支持一般过滤操作、图像分割和匹配的组件。SimpleITK本身是用C++写的，但是对于包括Python以内的大部分编程语言都是可用的。
资源
大量的Jupyter Notebooks 表明了SimpleITK在教育和研究领域已经被使用。Notebook展示了用Python和R编程语言使用SimpleITK来进行交互式图像分析。
http://insightsoftwareconsortium.github.io/SimpleITK-Notebooks/
用法
下面的动画是用SimpleITK和Python创建的刚性CT/MR匹配过程的可视化 。点击此处可查看源码！
9. pgmagick
pgmagick是GraphicsMagick库的一个基于python的包装。 GraphicsMagick图像处理系统有时被称为图像处理的瑞士军刀。它提供了一个具有强大且高效的工具和库集合，支持以88种主要格式(包括重要格式，如DPX、GIF、JPEG、JPEG-2000、PNG、PDF、PNM和TIFF)读取、写入和操作图像。
资源
有一个专门用于PgMagick的Github库 ，其中包含安装和需求说明。还有关于这个的一个详细的用户指导：
https://github.com/hhatto/pgmagick
用法
使用pgmagick可以进行的图像处理活动很少，比如：
图像缩放
边缘提取
10. Pycairo
Pycairo是图像处理库cairo的一组Python捆绑。Cairo是一个用于绘制矢量图形的2D图形库。矢量图形很有趣，因为它们在调整大小或转换时不会失去清晰度 。Pycairo是cairo的一组绑定，可用于从Python调用cairo命令。
资源
Pycairo的GitHub库是一个很好的资源，有关于安装和使用的详细说明。还有一个入门指南，其中有一个关于Pycairo的简短教程。
库：https://github.com/pygobject/pycairo指南：https://pycairo.readthedocs.io/en/latest/tutorial.html用法
使用Pycairo绘制线条、基本形状和径向梯度：
总结
有一些有用且免费的Python图像处理库可以使用，有的是众所周知的，有的可能对你来说是新的，试着多去了解它们。