📄 minutiaextract.h
字号:
/////////////////////////////////////////////////////////////////////////
// angleBegin: [in] 起始角度 （0 - 360）
// angleEnd: [in] 终结角度 （0 - 360）
/////////////////////////////////////////////////////////////////////////
int a;
a = angleEnd-angleBegin;
if(a < 0)
{
a += 360;
}
return a;
}
//
// GetAngle： 两个点连线与x轴方向的角度
//
int GetAngle(int x0, int y0, int x1, int y1)
{
/////////////////////////////////////////////////////////////////////////
// x0: [in] 第一个点横坐标
// y0: [in] 第一个点纵坐标
// x1: [in] 第二个点横坐标
// y1: [in] 第二个点纵坐标
/////////////////////////////////////////////////////////////////////////
double angle;
angle = atan2((double)(y1-y0), (double)(x1-x0));
// 弧度转化到0 - 2*PI
if(angle < 0)
{
angle += 2*PI;
}
// 弧度转化为角度
return (int)(angle*EPI + 0.5);
}
//
// DIndex: 对角度进行量化，得到量化的索引号(0-12)
//
int DIndex(int angle)
{
/////////////////////////////////////////////////////////////////////////
// angle: [in] 角度 （0 - 180）
/////////////////////////////////////////////////////////////////////////
if(angle >= 173 || angle < 8)
{
return 0;
}
else
{
return ((angle-8)/15 + 1);
}
}
int getMinutia(BYTE *g_lpOrgFinger, BYTE *g_lpOrient, LPVOID feature, int IMGW, int IMGH)
{
setup(IMGW, IMGH, g_lpOrgFinger);
FEATURE *g_Feature = (FEATURE*)(feature);
int x, y, i, j, k, n;
int temp;
int sum;
BYTE *lpNow;
BYTE *lpDis;
int r = 16; // 允许特征点靠近前景边缘的最近距离
double d, d1, d2, d0, a;
int dGate = 16;
bool flag;
int x11, y11;
int x21, y21;
int angle1, angle2, angle3, angle4;
BYTE *tempPtr[8];
BYTE *disPtr[3];
BYTE *lpOri;
int tempForkNum;
int tempEndNum;
int ForkNum;
int EndNum;
// 临时特征点数组
MINUTIA tempFork[MAXRAWMINUTIANUM];
MINUTIA tempEnd[MAXRAWMINUTIANUM];
MINUTIA ForkArr[MAXRAWMINUTIANUM];
MINUTIA EndArr[MAXRAWMINUTIANUM];
// 某点为圆心，半径为5的圆上所有点的地址偏移
int SiteR5[28] = {
-5, IMGW-5, 2*IMGW-5, 3*IMGW-4, 4*IMGW-3, 5*IMGW-2, 5*IMGW-1, 5*IMGW,
5*IMGW+1, 5*IMGW+2, 4*IMGW+3, 3*IMGW+4, 2*IMGW+5, IMGW+5, 5, -IMGW+5,
-2*IMGW+5, -3*IMGW+4, -4*IMGW+3, -5*IMGW+2, -5*IMGW+1, -5*IMGW,
-5*IMGW-1, -5*IMGW-2, -4*IMGW-3, -3*IMGW-4, -2*IMGW-5, -IMGW-5
};
// 某点周围8个点的地址偏移
int SiteU8[8] = {IMGW-1, IMGW, IMGW+1, 1, -IMGW+1, -IMGW, -IMGW-1, -1};
// 初始化临时特征点数组
memset((void *)&tempFork[0], 0, MAXRAWMINUTIANUM*sizeof(MINUTIA));
memset((void *)&tempEnd[0], 0, MAXRAWMINUTIANUM*sizeof(MINUTIA));
memset((void *)&ForkArr[0], 0, MAXRAWMINUTIANUM*sizeof(MINUTIA));
memset((void *)&EndArr[0], 0, MAXRAWMINUTIANUM*sizeof(MINUTIA));
bool bGood = false; // 标记阈值是否调整好，使特征点数目在允许范围内
int densD = 7; // 允许两个特征点间最近的距离
int loopnum; // 循环次数
int trilen = 16;
// 第一遍寻找所有端点和叉点
ForkNum = 0;
EndNum = 0;
temp = 17*IMGW;
for(y = 17; y < IMGH-17; y++)
{
for(x = 17; x < IMGW-17; x++)
{
lpNow = g_lpOrgFinger + temp + x;
lpOri = g_lpOrient + y*IMGW + x;
// 不是黑点则不考虑
if(*lpNow != 0)
{
continue;
}
// 是叉点
if(IsFork(lpNow))
{
// 检查是否靠近边缘, 靠近边缘则不考虑
flag = true;
for(i = -r; i <= r && flag; i++)
{
for(j = -r; j <= r && flag; j++)
{
if(y+i<0 || y+i>=IMGH || x+j<0 || x+j>=IMGW)
{
continue;
}
if(*(g_lpOrient + temp + i*IMGW + x + j) == 255)
{
flag = false;
break;
}
}
}
// 检查该点周围方向场是否变化剧烈，变化剧烈则不考虑，因为很可能是虚假点
sum = 0;
for(i = 0; i < 28; i++)
{
sum += GetJiajiao(*(lpOri+SiteR5[(i+1)%28]), *(lpOri+SiteR5[i]));
}
if(sum > 96)
flag = false;
// 达到所有要求则记录下来该点
if(flag)
{
ForkArr[ForkNum].x = x;
ForkArr[ForkNum].y = y;
ForkNum++;
// 如果总数已经超过允许最大数目，则返回错误
if(ForkNum >= MAXRAWMINUTIANUM)
{
ForkNum = 0;
return 1;
}
}
}
else if(IsEnd(lpNow)) // 如果是端点
{
// 检查是否靠近边缘, 靠近边缘则不考虑
flag = true;
for(i = -r; i <= r && flag; i++)
{
for(j = -r; j <= r && flag; j++)
{
if(y+i<0 || y+i>=IMGH || x+j<0 || x+j>=IMGW)
{
continue;
}
if(*(g_lpOrient + temp + i*IMGW + x + j) == 255)
{
flag = false;
break;
}
}
}
// 检查该点周围方向场是否变化剧烈，变化剧烈则不考虑，因为很可能是虚假点
sum = 0;
for(i = 0; i < 28; i++)
{
sum += GetJiajiao(*(lpOri+SiteR5[(i+1)%28]), *(lpOri+SiteR5[i]));
}
if(sum > 96)
flag = false;
// 达到所有要求则记录下来该点
if(flag)
{
EndArr[EndNum].x = x;
EndArr[EndNum].y = y;
EndNum++;
// 如果总数已经超过允许最大数目，则返回错误
if(EndNum >= MAXRAWMINUTIANUM)
{
EndNum = 0;
return 1;
}
}
}
}
temp += IMGW;
}
// 初始化临时缓冲区，准备循环调整两个特征点间允许的最小距离，使之增大到一个合适的值
// 因为如果特征点非常密集的地方很有可能是质量很差的地方
for(i = 0; i < MAXRAWMINUTIANUM; i++)
{
tempEnd[i] = EndArr[i];
}
for(i = 0; i < MAXRAWMINUTIANUM; i++)
{
tempFork[i] = ForkArr[i];
}
tempForkNum = ForkNum;
tempEndNum = EndNum;
// 循环调整
bGood = false;
loopnum = 0; // 调整的次数
while(!bGood && loopnum < 32) // 最多调整32次
{
loopnum++; // 调整次数加一
// 得到新的特征点数组
for(i = 0; i < MAXRAWMINUTIANUM; i++)
{
EndArr[i] = tempEnd[i];
}
for(i = 0; i < MAXRAWMINUTIANUM; i++)
{
ForkArr[i] = tempFork[i];
}
// 新的特征点数
ForkNum = tempForkNum; // 叉点
EndNum = tempEndNum; // 端点
// 去掉虚假的端点
bGood = true;
for(i = 0; i < EndNum-1; i++)
{
flag = false;
for(j = i+1; j < EndNum; j++)
{
// 求两个端点的距离
d = sqrt((double)((EndArr[i].x-EndArr[j].x)*(EndArr[i].x-EndArr[j].x) +
(EndArr[i].y-EndArr[j].y)*(EndArr[i].y-EndArr[j].y)));
// 距离足够大则检查下一个端点
if(d > dGate && d > densD)
{
continue;
}
// 距离太小，则将其坐标置为（0，0）
if(d <= densD)
{
EndArr[j].x = 0;
EndArr[j].y = 0;
flag = true;
continue;
}
// 求第一个端点所在纹线的角度
lpNow = g_lpOrgFinger + EndArr[i].y*IMGW + EndArr[i].x;
if(GetByDis(lpNow, &lpDis, 8) != 0)
{
break;
}
angle1 = GetAngle(EndArr[i].x, EndArr[i].y, PX(lpDis), PY(lpDis));
// 求第二个端点所在纹线的角度
lpNow = g_lpOrgFinger + EndArr[j].y*IMGW + EndArr[j].x;
if(GetByDis(lpNow, &lpDis, 8) != 0)
{
continue;
}
angle2 = GetAngle(EndArr[j].x, EndArr[j].y, PX(lpDis), PY(lpDis));
// 求两个角度间的距离
angle3 = GetAngleDis(angle1, angle2);
// 如果两个角度间成锐角，则不是虚假特征点
if(angle3 > 270 || angle3 < 90)
{
continue;
}
// 求两个端点连线的角度
angle3 = GetAngle(EndArr[i].x, EndArr[i].y, EndArr[j].x, EndArr[j].y);
// 求第一个端点纹线与连线的夹角
angle3 = GetAngleDis(angle1, angle3);
// 如果夹角较大则不是虚假点
if(angle3 < 150 || angle3 > 210)
{
continue;
}
// 求第二个端点纹线与连线的夹角
angle4 = GetAngle(EndArr[j].x, EndArr[j].y, EndArr[i].x, EndArr[i].y);
angle4 = GetAngleDis(angle2, angle4);
// 如果夹角较大则不是虚假点
if(angle4 < 150 || angle4 > 210)
{
continue;
}
// 否则表示这两个点是同一条纹线上的断裂处的两个端点,坐标置原点
EndArr[j].x = 0;
EndArr[j].y = 0;
flag = true;
}
if(flag)// 表示这两个点是同一条纹线上的断裂处的两个端点,坐标置原点
{
EndArr[i].x = 0;
EndArr[i].y = 0;
}
}
// 统计新的端点数目
j = 0;
for(i = 0; i < EndNum; i++)
{
if(EndArr[i].x == 0 || EndArr[i].y == 0)
{
continue;
}
lpNow = g_lpOrgFinger + EndArr[i].y*IMGW + EndArr[i].x;
if(GetByDis(lpNow, &lpDis, 8) != 0)
{
continue;
}
j++;
// 如果端点数目还是过多，则需要调整densD
if(j >= MAXMINUTIANUM)
{
bGood = false;
break;
}
}
// 调整densD
if(!bGood)
{
densD++; // 加一
continue;
}
// 将端点装配到g_Feature
j = 0;
for(i = 0; i < EndNum; i++)
{
if(EndArr[i].x == 0 || EndArr[i].y == 0)
{
continue;
}
// 沿纹线找到第8个点
lpNow = g_lpOrgFinger + EndArr[i].y*IMGW + EndArr[i].x;
if(GetByDis(lpNow, &lpDis, 8) != 0)
{
continue;
}
// 求该点与端点连线的角度
angle1 = GetAngle(EndArr[i].x, EndArr[i].y, PX(lpDis), PY(lpDis));
angle2 = *(g_lpOrient + EndArr[i].y*IMGW + EndArr[i].x);
angle3 = GetAngleDis(angle1, angle2);
// 如果成钝角，则表示该特征点方向与该点方向场方向相反
if(angle3 > 90 && angle3 < 270)
{
g_Feature->MinutiaArr[j].Direction = angle2 + 180;
}
else // 如果成锐角，则表示该特征点方向与该点方向场方向相同
{
g_Feature->MinutiaArr[j].Direction = angle2;
}
a = g_Feature->MinutiaArr[j].Direction / EPI + PI/4.0;
x11 = EndArr[i].x + (int)(trilen*cos(a)+ 0.5);
y11 = EndArr[i].y + (int)(trilen*sin(a)+ 0.5);
g_Feature->MinutiaArr[j].Triangle[0] = *(g_lpOrient + y11*IMGW + x11);
a += PI*2/3.0;
x11 = EndArr[i].x + (int)(trilen*cos(a)+ 0.5);
y11 = EndArr[i].y + (int)(trilen*sin(a)+ 0.5);
g_Feature->MinutiaArr[j].Triangle[1] = *(g_lpOrient + y11*IMGW + x11);
a += PI*2/3.0;
x11 = EndArr[i].x + (int)(trilen*cos(a)+ 0.5);
y11 = EndArr[i].y + (int)(trilen*sin(a)+ 0.5);
g_Feature->MinutiaArr[j].Triangle[2] = *(g_lpOrient + y11*IMGW + x11);
g_Feature->MinutiaArr[j].x = EndArr[i].x; //横坐标
g_Feature->MinutiaArr[j].y = EndArr[i].y; //纵坐标
g_Feature->MinutiaArr[j].Type = VF_MINUTIA_END; //类型
j++;
}
EndNum = j; // 端点数目
// 去掉距离太近的叉点
for(i = 0; i < ForkNum-1; i++)
{
flag = false;
for(j = i+1; j < ForkNum; j++)
{
d = sqrt((double)((ForkArr[i].x-ForkArr[j].x)*(ForkArr[i].x-ForkArr[j].x) +
(ForkArr[i].y-ForkArr[j].y)*(ForkArr[i].y-ForkArr[j].y)));
if(d <= densD-2)
{
ForkArr[j].x = 0;
ForkArr[j].y = 0;
flag = true;
}
}
if(flag)
{
ForkArr[i].x = 0;
ForkArr[i].y = 0;
}
}
// 统计新的真正的叉点
j = 0;
for(i = 0; i < ForkNum; i++)
{
if(ForkArr[i].x == 0 || ForkArr[i].y == 0)
{
continue;
}
lpNow = g_lpOrgFinger + ForkArr[i].y*IMGW + ForkArr[i].x;
tempPtr[0] = lpNow;
*tempPtr[0] = 255;
// 检查是否真正叉点
n = 0;
for(k = 0; k < 8; k++)
{
if(*(lpNow + SiteU8[k]) == 0)
{
tempPtr[n+1] = lpNow + SiteU8[k];
*tempPtr[n+1] = 255;
n++;
}
}
for(k = 0; k < 4; k++)
{
*tempPtr[k] = 0;
}
if(n != 3)
{
continue;
}
j++;
// 特征点总数大于允许最大数目则要调整densD
if(EndNum + j >= MAXMINUTIANUM)
{
densD++;
bGood = false;
break;
}
}
if(!bGood)
{
continue;
}
// 装配叉点到g_Feature
j = 0;
for(i = 0; i < ForkNum; i++)
{
if(ForkArr[i].x == 0 || ForkArr[i].y == 0)
{
continue;
}
lpNow = g_lpOrgFinger + ForkArr[i].y*IMGW + ForkArr[i].x;
tempPtr[0] = lpNow;
*tempPtr[0] = 255;
n = 0;
for(k = 0; k < 8; k++)
{
if(*(lpNow + SiteU8[k]) == 0)
{
tempPtr[n+1] = lpNow + SiteU8[k];
*tempPtr[n+1] = 255;
n++;
}
}
if(n != 3)
{
continue;
}
// 找到叉点三个方向纹线上距离为8的点
for(k = 0; k < 3; k++)
{
GetByDis(tempPtr[k+1], &disPtr[k], 8);
}
for(k = 0; k < 4; k++)
{
*tempPtr[k] = 0;
}
// 求该三个点两两间的距离
d0 = sqrt((double)((PX(disPtr[1]) - PX(disPtr[2]))*(PX(disPtr[1]) - PX(disPtr[2])) +
(PY(disPtr[1]) - PY(disPtr[2]))*(PY(disPtr[1]) - PY(disPtr[2]))));
d1 = sqrt((double)((PX(disPtr[0]) - PX(disPtr[2]))*(PX(disPtr[0]) - PX(disPtr[2])) +
(PY(disPtr[0]) - PY(disPtr[2]))*(PY(disPtr[0]) - PY(disPtr[2]))));
d2 = sqrt((double)((PX(disPtr[1]) - PX(disPtr[0]))*(PX(disPtr[1]) - PX(disPtr[0])) +
(PY(disPtr[1]) - PY(disPtr[0]))*(PY(disPtr[1]) - PY(disPtr[0]))));
// 距离最短的边对应的是叉线方向
if(d0 < d1 && d0 < d2)
{
x11 = PX(disPtr[1]);
y11 = PY(disPtr[1]);
x21 = PX(disPtr[2]);
y21 = PY(disPtr[2]);
lpDis = disPtr[0];
}
else if(d1 < d0 && d1 < d2)
{
x11 = PX(disPtr[0]);
y11 = PY(disPtr[0]);
x21 = PX(disPtr[2]);
y21 = PY(disPtr[2]);
lpDis = disPtr[1];
}
else
{
x11 = PX(disPtr[0]);
y11 = PY(disPtr[0]);
x21 = PX(disPtr[1]);
y21 = PY(disPtr[1]);
lpDis = disPtr[2];
}
// 求最短边中点与叉点连线的方向与该点方向场方向的夹角
angle1 = GetAngle(ForkArr[i].x, ForkArr[i].y, (x11+x21)/2, (y11+y21)/2);
angle2 = *(g_lpOrient + ForkArr[i].y*IMGW + ForkArr[i].x);
angle3 = GetAngleDis(angle1, angle2);
// 如果成钝角，则表示该特征点方向与该点方向场方向相反
if(angle3 > 90 && angle3 < 270)
{
g_Feature->MinutiaArr[EndNum + j].Direction = angle2 + 180;
}
else // 如果成锐角，则表示该特征点方向与该点方向场方向相同
{
g_Feature->MinutiaArr[EndNum + j].Direction = angle2;
}
// 纪录以特征点为中心外接圆半径为trilen的正三角形三个顶点的方向
a = g_Feature->MinutiaArr[EndNum + j].Direction / EPI + PI/4.0;
x11 = EndArr[i].x + (int)(trilen*cos(a)+ 0.5);
y11 = EndArr[i].y + (int)(trilen*sin(a)+ 0.5);
g_Feature->MinutiaArr[EndNum + j].Triangle[0] = *(g_lpOrient + y11*IMGW + x11);
a += PI*2/3.0;
x11 = EndArr[i].x + (int)(trilen*cos(a)+ 0.5);
y11 = EndArr[i].y + (int)(trilen*sin(a)+ 0.5);
g_Feature->MinutiaArr[EndNum + j].Triangle[1] = *(g_lpOrient + y11*IMGW + x11);
a += PI*2/3.0;
x11 = EndArr[i].x + (int)(trilen*cos(a)+ 0.5);
y11 = EndArr[i].y + (int)(trilen*sin(a)+ 0.5);
g_Feature->MinutiaArr[EndNum + j].Triangle[2] = *(g_lpOrient + y11*IMGW + x11);
g_Feature->MinutiaArr[EndNum + j].x = ForkArr[i].x; //横坐标
g_Feature->MinutiaArr[EndNum + j].y = ForkArr[i].y; //纵坐标
g_Feature->MinutiaArr[EndNum + j].Type = VF_MINUTIA_FORK; // 类型
j++;
}
ForkNum = j; // 叉点数目
}
// 如果循环32次都不能得到理想结果，则表示图像质量差，返回错误
if(loopnum >= 32)
{
EndNum = 0;
ForkNum = 0;
return 1;
}
// 特征点数目等于端点数加叉点数
g_Feature->MinutiaNum = (BYTE)(EndNum+ForkNum);
// 特征点数目太少则返回错误
if(ForkNum + EndNum < 8)
{
EndNum = 0;
ForkNum = 0;
return 1;
}
feature = (LPVOID)new BYTE[sizeof(FEATURE)];
memcpy(feature, &g_Feature, sizeof(FEATURE));
return 0;
}
#endif // !defined(AFX_MINUTIAEXTRACT_H__F76D271A_5FD4_4DBA_B826_7B57F2574483__INCLUDED_)
⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -