dearsky/HandWritten-Analisys
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

笔迹鉴别程序

Browse Source 
考试的笔迹鉴别程序，分辨出不同人写的笔迹
This commit is contained in:
yanshui177
2017-05-17 16:50:37 +08:00
parent abe00d2e02
commit 962de04ffb
205 changed files with 17672 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

133
测试/本机测试/HWCV_vc6/HWCV_vc6.dsp Normal file
View File

@@ -0,0 +1,133 @@
# Microsoft Developer Studio Project File - Name="HWCV_vc6" - Package Owner=<4>
# Microsoft Developer Studio Generated Build File, Format Version 6.00
# ** DO NOT EDIT **
# TARGTYPE "Win32 (x86) Console Application" 0x0103
CFG=HWCV_vc6 - Win32 Debug
!MESSAGE This is not a valid makefile. To build this project using NMAKE,
!MESSAGE use the Export Makefile command and run
!MESSAGE
!MESSAGE NMAKE /f "HWCV_vc6.mak".
!MESSAGE
!MESSAGE You can specify a configuration when running NMAKE
!MESSAGE by defining the macro CFG on the command line. For example:
!MESSAGE
!MESSAGE NMAKE /f "HWCV_vc6.mak" CFG="HWCV_vc6 - Win32 Debug"
!MESSAGE
!MESSAGE Possible choices for configuration are:
!MESSAGE
!MESSAGE "HWCV_vc6 - Win32 Release" (based on "Win32 (x86) Console Application")
!MESSAGE "HWCV_vc6 - Win32 Debug" (based on "Win32 (x86) Console Application")
!MESSAGE
# Begin Project
# PROP AllowPerConfigDependencies 0
# PROP Scc_ProjName ""
# PROP Scc_LocalPath ""
CPP=cl.exe
RSC=rc.exe
!IF "$(CFG)" == "HWCV_vc6 - Win32 Release"
# PROP BASE Use_MFC 0
# PROP BASE Use_Debug_Libraries 0
# PROP BASE Output_Dir "Release"
# PROP BASE Intermediate_Dir "Release"
# PROP BASE Target_Dir ""
# PROP Use_MFC 0
# PROP Use_Debug_Libraries 0
# PROP Output_Dir "Release"
# PROP Intermediate_Dir "Release"
# PROP Target_Dir ""
# ADD BASE CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /c
# ADD CPP /nologo /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /c
# ADD BASE RSC /l 0x804 /d "NDEBUG"
# ADD RSC /l 0x804 /d "NDEBUG"
BSC32=bscmake.exe
# ADD BASE BSC32 /nologo
# ADD BSC32 /nologo
LINK32=link.exe
# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /machine:I386
# ADD LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /machine:I386
!ELSEIF "$(CFG)" == "HWCV_vc6 - Win32 Debug"
# PROP BASE Use_MFC 0
# PROP BASE Use_Debug_Libraries 1
# PROP BASE Output_Dir "Debug"
# PROP BASE Intermediate_Dir "Debug"
# PROP BASE Target_Dir ""
# PROP Use_MFC 0
# PROP Use_Debug_Libraries 1
# PROP Output_Dir "Debug"
# PROP Intermediate_Dir "Debug"
# PROP Ignore_Export_Lib 0
# PROP Target_Dir ""
# ADD BASE CPP /nologo /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /GZ /c
# ADD CPP /nologo /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /GZ /c
# ADD BASE RSC /l 0x804 /d "_DEBUG"
# ADD RSC /l 0x804 /d "_DEBUG"
BSC32=bscmake.exe
# ADD BASE BSC32 /nologo
# ADD BSC32 /nologo
LINK32=link.exe
# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /debug /machine:I386 /pdbtype:sept
# ADD LINK32 cv.lib cvaux.lib cxcore.lib highgui.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /debug /machine:I386 /pdbtype:sept
!ENDIF
# Begin Target
# Name "HWCV_vc6 - Win32 Release"
# Name "HWCV_vc6 - Win32 Debug"
# Begin Group "Source Files"
# PROP Default_Filter "cpp;c;cxx;rc;def;r;odl;idl;hpj;bat"
# Begin Source File
SOURCE=.\path.cpp
# End Source File
# Begin Source File
SOURCE=.\process.cpp
# End Source File
# Begin Source File
SOURCE=.\segmentation.cpp
# End Source File
# Begin Source File
SOURCE=.\StdAfx.cpp
# End Source File
# End Group
# Begin Group "Header Files"
# PROP Default_Filter "h;hpp;hxx;hm;inl"
# Begin Source File
SOURCE=.\path.h
# End Source File
# Begin Source File
SOURCE=.\Point.h
# End Source File
# Begin Source File
SOURCE=.\process.h
# End Source File
# Begin Source File
SOURCE=.\segmentation.h
# End Source File
# Begin Source File
SOURCE=.\StdAfx.h
# End Source File
# End Group
# Begin Group "Resource Files"
# PROP Default_Filter "ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe"
# End Group
# End Target
# End Project

29
测试/本机测试/HWCV_vc6/HWCV_vc6.dsw Normal file
View File

@@ -0,0 +1,29 @@
Microsoft Developer Studio Workspace File, Format Version 6.00
# 警告: 不能编辑或删除该工作区文件！
###############################################################################
Project: "HWCV_vc6"=".\HWCV_vc6.dsp" - Package Owner=<4>
Package=<5>
{{{
}}}
Package=<4>
{{{
}}}
###############################################################################
Global:
Package=<5>
{{{
}}}
Package=<3>
{{{
}}}
###############################################################################

BIN
测试/本机测试/HWCV_vc6/HWCV_vc6.opt Normal file
View File

Binary file not shown.

16
测试/本机测试/HWCV_vc6/HWCV_vc6.plg Normal file
View File

@@ -0,0 +1,16 @@
<html>
<body>
<pre>
<h1>Build Log</h1>
<h3>
--------------------Configuration: HWCV_vc6 - Win32 Debug--------------------
</h3>
<h3>Command Lines</h3>
<h3>Results</h3>
HWCV_vc6.exe - 0 error(s), 0 warning(s)
</pre>
</body>
</html>

14
测试/本机测试/HWCV_vc6/Point.h Normal file
View File

@@ -0,0 +1,14 @@
/*
头文件：Point.h 图像中的像素点定义
*/
#pragma once
#include "StdAfx.h"
class Point{
private:
public:
int x;
int y;
void setpoint(int a,int b){x=a;y=b;}
};

8
测试/本机测试/HWCV_vc6/StdAfx.cpp Normal file
View File

@@ -0,0 +1,8 @@
// stdafx.cpp : source file that includes just the standard includes
// HWCV.pch will be the pre-compiled header
// stdafx.obj will contain the pre-compiled type information
#include "stdafx.h"
// TODO: reference any additional headers you need in STDAFX.H
// and not in this file

24
测试/本机测试/HWCV_vc6/StdAfx.h Normal file
View File

@@ -0,0 +1,24 @@
// stdafx.h : include file for standard system include files,
// or project specific include files that are used frequently, but
// are changed infrequently
//
#if !defined(AFX_STDAFX_H__0B833134_257D_4F21_9707_24C780138809__INCLUDED_)
#define AFX_STDAFX_H__0B833134_257D_4F21_9707_24C780138809__INCLUDED_
#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000
// Insert your headers here
#define WIN32_LEAN_AND_MEAN // Exclude rarely-used stuff from Windows headers
#include <windows.h>
// TODO: reference additional headers your program requires here
//{{AFX_INSERT_LOCATION}}
// Microsoft Visual C++ will insert additional declarations immediately before the previous line.
#endif // !defined(AFX_STDAFX_H__0B833134_257D_4F21_9707_24C780138809__INCLUDED_)

263
测试/本机测试/HWCV_vc6/path.cpp Normal file
View File

@@ -0,0 +1,263 @@
/*
实现文件：path.cpp 路径操作实现文件
*/
#include "path.h"
/**
获取并返回当前时间
*/
char* GetTime()
{
time( &ltime );
srcTime = ctime( &ltime );
strncpy(timeNow, srcTime, strlen(srcTime)-1); //不拷贝换行
timeNow[strlen(srcTime)-1] = '\0'; //加结束符'\0'
return timeNow;
}
/**
根据学生信息创建文件路径，用于文件读取
@变量 date 考试日期
@变量 subject 考试科目
@变量 stuNum 考号
@返回值 返回生成的文件路径
*/
string CrPath(string date, string subject, string stuNum)
{
string temp = g_dir; temp += date; temp += "/";
temp += subject.substr(0, 4); temp += "/";
temp += stuNum; temp += ".jpg";
return temp;
}
/*
功能：读取标准差文件
@变量 filesname 文件名
@变量 col 行数
@变量 _vector 读取到的标准差存到vector中
@返回值 成功1失败0
*/
int ReadScanf(const string &filename, const int &cols, vector<double *> &_vector)
{
// 功能：将filename 中的数据（共cols列）读取到_vector中，_vector可视为二维数组
FILE *fp = fopen(filename.c_str(), "r");//打开并读取文件
bool flag = true;
int i = 0;
// printf("--read_scanf--");
if (!fp){ return 0; }
while (flag){
double *point = new double[cols];
for (i = 0; i<cols; i++){ //读取数据，存在_vector[cols]中
if (EOF == fscanf(fp, "%lf", &point[i])) {
flag = false; break;
}
if (EOF == fgetc(fp)) {
flag = false; i++; break;
}
}
if (cols == i)
_vector.push_back(point);
}
fclose(fp);
return 1;
}
/**
读取配置文件，并配置各项参数
@变量 filename 配置文件的路径
@返回值 成功1 失败0
*/
int ReadConfig(char *filename)
{
ifstream file(filename);
if (!file)/*"配置文件不存在！"*/
{
/*写入时间*/
memset(g_log_rec, 0, sizeof(g_log_rec));
cout<<"read"<<endl;
strcat(g_log_rec, "--ERR:配置文件不存在!");
SaveLog(g_log_rec, g_err_adr, "a");
return 0;
}
/*步骤：开始读取信息*/
string temp;/*仅用作过滤字符*/
file >> temp >> temp;
/*---此行6个，参考配置信息：图片对比参数*/
file >> temp >> temp >> temp >> temp >> temp >>temp;
file >> g_dir >> temp >> temp >> temp;
string g_log_adr_t;
file >> g_log_adr_t >> temp;
memset(g_log_adr, 0, sizeof(g_log_adr));
strcpy(g_log_adr, (char*)g_log_adr_t.c_str());
/*---此行6个，参考配置信息：网络配置参数*/
file >> temp >> temp >> temp >> temp >> temp >> temp >> temp >> temp >> temp >> temp >> temp >> temp;
/*---此行5个，参考配置信息：控制参数*/
file >> temp >> temp >> temp >> temp >> temp >> temp >> temp >> temp >> temp >> temp >> temp >> temp;
/*---此行5个，参考配置信息：数据库查询参数*/
file >> temp >> temp >> temp >> temp >> temp >> temp >> temp >> temp >> temp >> temp >> temp >> temp;
file.close();/*关闭文件句柄*/
return 1;
}
/**
函数功能：存储过程数据到txt文件
@变量： record 存储的语句
@变量 g_txt_file_path 存储的位置
@返回值 1成功 0失败
*/
int SaveLog(char *txt, string txt_file_path, char *type)
{
FILE* fpzz = fopen(txt_file_path.c_str(), type); //创建文件
if (NULL == fpzz)
{
return 0;
}//要返回错误代码
fprintf(fpzz, txt); //从控制台中读入并在文本输出
fclose(fpzz);
fpzz = NULL;//需要指向空，否则会指向原打开文件地址
return 1;
}
/*
功能：保存中间鉴定图像(不实现，没有必要)
@变量
@变量
@返回值
*/
int SaveImg(IplImage *img, char *g_process_img_adr){
return 1;
}
/*
功能：获取指定目录下的文件
@变量 path 路径
@变量 files 输出vector格式的文件
*/
void getFiles(string path, vector<string>& files)
{
using namespace std;//引入整个名空间
//文件句柄
long hFile = 0;
//文件信息
struct _finddata_t fileinfo;
string p;
if ((hFile = _findfirst(p.assign(path).append("/*").c_str(), &fileinfo)) != -1)
{
do
{
//如果是目录,迭代之
if ((fileinfo.attrib & _A_SUBDIR))
{
if (strcmp(fileinfo.name, ".") != 0 && strcmp(fileinfo.name, "..") != 0)
getFiles(p.assign(path).append("/").append(fileinfo.name), files);
} //如果不是,加入列表
else
{
files.push_back(p.assign(path).append("/").append(fileinfo.name));
}
} while (_findnext(hFile, &fileinfo) == 0);
_findclose(hFile);
}
}
/*
功能：获取指定目录下的目录
@变量 path 目录
@变量 files 返回的目录vector
@返回值 成功1失败0
*/
int getFolders(string path, vector<string>& files)
{
using namespace std;//引入整个名空间
//文件句柄
long hFile = 0;
//文件信息
struct _finddata_t fileinfo;
string p;
int i = 0;
if ((hFile = _findfirst(p.assign(path).append("/*").c_str(), &fileinfo)) != -1)
{
do
{
if (strcmp(fileinfo.name, ".") != 0 && strcmp(fileinfo.name, "..") != 0)
{
files.push_back(p.assign(path).append("/").append(fileinfo.name));
printf("文件夹：%s\n", files[i].c_str());
i++;
}
} while (_findnext(hFile, &fileinfo) == 0);
_findclose(hFile);
}
return 0;
}
/*
功能：搜索目录
*/
int searchDir(char *path, vector<string> &dir)
{
using namespace std;
struct _finddata_t fa;//创建找到的结构体
long handle;
int flag = 0;
char temp[100] = { 0 };
string path_temp = path;
// path_temp=path_temp.substr(0,path_temp.length()-1);
if ((handle = _findfirst(strcat(path, "*"), &fa)) == -1L)//如果不是目录的话
return 0;
do//是目录，先执行循环
{
if (fa.attrib == _A_SUBDIR && ~strcmp(fa.name, ".") && ~strcmp(fa.name, ".."))
{
strcat(temp, path_temp.c_str());
strcat(temp, fa.name);
if (flag++)
dir.push_back(temp);
else;
memset(temp, 0, 100);
}
} while (_findnext(handle, &fa) == 0); /* 成功找到时返回0*/
_findclose(handle);
return 0;
}

123
测试/本机测试/HWCV_vc6/path.h Normal file
View File

@@ -0,0 +1,123 @@
/*
头文件：path.h 与路径相关操作的函数头文件以及函数原型
*/
#pragma once
#include "StdAfx.h"
#include <iostream>
#include <fstream>
#include <string>
#include <vector>
#include <ctime>
#include <cv.h>
#include <io.h>
using namespace std;
extern int g_bi_threshold; /*全局变量 二值化阈值*/
extern double g_std_kesa[50][50]; /*全局变量 标准差数组*/
extern float g_doubt_threshold; /*全局变量 作弊嫌疑阈值*/
extern string g_dir; /*全局变量 总路径的目录*/
extern int g_conti; /*全局变量 比较标准*/
extern string g_db_hostName; /*全局变量 服务器ip或名称*/
extern string g_db_dBName; /*全局变量 服务器ODBC数据源*/
extern string g_db_userName; /*全局变量 服务器用户名*/
extern string g_db_password; /*全局变量 服务器密码*/
extern char g_log_adr[50]; /*全局变量 程序日志存储地址*/
extern char g_err_adr[50]; /*全局变量 错误日志存储地址*/
extern char g_log_rec[500]; /*全局变量 程序日志专用变量*/
/*全局变量 待定*/
/*全局变量 待定*/
extern string g_db_qurry_start; /*全局变量 数据库查询_开始日期*/
extern string g_db_qurry_end; /*全局变量 数据库查询_结束日期*/
extern string g_db_qurry_zone; /*全局变量 数据库查询_特定区域*/
extern string g_db_qurry_stu_num; /*全局变量 数据库查询_特定考号*/
extern bool g_db_qurry_all; /*全局变量 数据库查询_查询全部标记*/
extern string g_db_hoster_zk;
extern time_t ltime;
extern char *srcTime;
extern char timeNow[32];
extern char msg[100];
/**
获取并返回当前时间
*/
char* GetTime();
/**
根据学生信息创建文件路径，用于文件读取
@变量 date 考试日期
@变量 subject 考试科目
@变量 stuNum 考号
@返回值 返回生成的文件路径
*/
string CrPath(string date, string subject, string stuNum);
/*
功能：读取标准差文件
@变量 filesname 文件名
@变量 col 行数
@变量 _vector 读取到的标准差存到vector中
@返回值 成功1失败0
*/
int ReadScanf(const string &filename, const int &cols, vector<double *> &_vector);
/**
读取配置文件，并配置各项参数
@变量 filename 配置文件的路径
@返回值 成功1 失败0
*/
int ReadConfig(char *filename);
/**
函数功能：存储过程数据到txt文件
@变量： record 存储的语句
@变量 g_txt_file_path 存储的位置
@返回值 1成功 0失败
*/
int SaveLog(char *record, string txt_file_path, char *type);
/*
功能：保存中间鉴定图像
@变量
@变量
@返回值
*/
int SaveImg(IplImage *img, char *g_process_img_adr);
/*
功能：获取指定目录下的文件
@变量 path 路径
@变量 files 输出vector格式的文件
*/
void getFiles(string path, vector<string>& files);
/*
功能：获取指定目录下的目录
@变量 path 目录
@变量 files 返回的目录vector
@返回值 成功1失败0
*/
int getFolders(string path, vector<string>& files);
/*
功能：搜索目录
*/
int searchDir(char *path, vector<string> &dir);

713
测试/本机测试/HWCV_vc6/process.cpp Normal file
View File

@@ -0,0 +1,713 @@
/*
实现文件：process.cpp 图像处理过程的实现文件
*/
#include "process.h"
int ComputeImage(vector<string> files, double bzckesa[50][50], double *wcd, int conti)
{
cout<<"1231s"<<endl;
int i, ii, jj, size;
double bzcu[50][50] = { 0 }; //标准差中的u
double featurep[50][50][30] = { 0 }; //所有图像的轮廓方向特征初始化//干什么 //30
int feature[50][50][30] = { 0 }; //所有图像的特征值初始化 //所有图像指的什么意思 //30找出30的位置或者50的位置限制。。。。带入num_dir==49的情况进行类比
int featx[50][50] = { 0 }; //循环赋值的feature
int featureall; //图像特征值和 //做什么用
IplImage* imglk[30]; //轮廓图变量 //30
size = files.size();
for (i = 0; i < size; i++)
{
memset(featx, 0, sizeof(featx));
// strcpy(str,files[i].c_str());
imglk[i] = singlefeature((char*)files[i].c_str(), featx); //featx[][50]
featureall = 0; //图像特征值和的初始化
for (ii = 0; ii<48; ii++) //将featx存起来,回头看能不能用函数换掉
for (jj = ii + 1; jj<47; jj++)
{
feature[ii][jj][i] = featx[ii][jj];
featureall = featureall + featx[ii][jj];
}
//求轮廓方向特征featurep，式(5) 与标准差中的u的和
for (ii = 0; ii<48; ii++)
for (jj = ii + 1; jj<47; jj++)
{
featurep[ii][jj][i] = (double)featx[ii][jj] / featureall;
bzcu[ii][jj] += (double)featx[ii][jj] / featureall * 1000; //标准差的值过小,进行放大（1）
}
}
//处理完一个人的每一张图片后
for (ii = 0; ii<48; ii++)//求标准差中的u
for (jj = ii + 1; jj<47; jj++)
bzcu[ii][jj] = bzcu[ii][jj] / size;
//求相似性就是带权卡方wcd
for (i = 0; i < size; i++)
for (ii = 0; ii<48; ii++)
for (jj = ii + 1; jj<47; jj++)
if (featurep[ii][jj][i] * featurep[ii][jj][conti] != 0 && bzckesa[ii][jj] != -1)
wcd[i] += pow((featurep[ii][jj][i] - featurep[ii][jj][conti]), 2) / ((featurep[ii][jj][i] + featurep[ii][jj][conti])*bzckesa[ii][jj]);
memset(imglk, 0, sizeof(imglk));
memset(feature, 0, sizeof(feature));
memset(featurep, 0, sizeof(featurep));
return 1;
}
/*
功能：读入图像文件，进行二值化
@变量 img iplimage图像文件
@变量 bithro 二值化阈值
@返回值 黑像素的数目（待用）
*/
int* binary(IplImage* img, int g_bi_threshold)
{
int height, width, step, channels;
uchar *data;
int i, j;
static int black[1000]; //C语言不提倡返回一个局部变量的地址以外的功能，所以你必须定义的局部变量，如静态变量。
/* 获取图像信息*/
height = img->height;
width = img->width;
step = img->widthStep;
channels = img->nChannels;
data = (uchar *)img->imageData;
/*二值化，并统计黑像素的个数*/
for (i = 0; i<height; i++)
{
for (j = 0; j<width; j++)//对图像每个点进行二值化,原值为128
data[i*step + j*channels] = (data[i*step + j*channels]>g_bi_threshold) ? 255 : 0;
}
/*计算每一行的黑像素个数*/
int tempBlackPixel = 0;
memset(black, 0, 1000); //##初始化内存，这里用做清零black数组
for (i = height - 1; i>0; i--)
{
for (int j = 0; j<width; j++)
{
if (data[i*step + j*channels] == 0) //计算黑色的像素数
tempBlackPixel += 1;
}
black[height - i] = tempBlackPixel; //black记录黑色像素数
tempBlackPixel = 0;
}
//二值化，并统计黑像素的个数**********
return black;
}
/*
功能：读入图像文件，对图像进行裁剪
@变量 img iplimage图像文件
@变量 img 裁剪后的iplimage图像文件
@jbwhite
@jbblack
@返回值 返回裁剪后的图像
*/
IplImage* Cjbsb(IplImage* img, IplImage* imgjbsb, int jbwhite, int jbblack)
{
/*定义变量*/
int i, j, jbi = 0, jbj = 0;
int height, width, step, channels;
uchar *data;
int brklab = 0;
/* 获取图像信息*/
height = img->height;
width = img->width;
step = img->widthStep;
channels = img->nChannels;
data = (uchar *)img->imageData;
// IplImage* imgjbsb = cvCreateImage(cvGetSize(img),img->depth,img->nChannels);
cvCopy(img, imgjbsb, NULL);
uchar *imgjbsbdata = (uchar *)imgjbsb->imageData;
//以角标为起点进行裁剪与画框
CvSize jbcjsize = cvSize(835, 165); //角标裁剪框的大小，宽为835象素，高为165象素
IplImage* imgjbcj = cvCreateImage(jbcjsize, img->depth, img->nChannels);
uchar *imgjbcjdata = (uchar *)imgjbcj->imageData;
int jbcjstep = imgjbcj->widthStep;
int jbcjchannels = imgjbcj->nChannels;
for (i = 0; i<165; i++)
for (j = 0; j<835; j++)
imgjbcjdata[i*jbcjstep + j*jbcjchannels] = data[(i + jbi)*step + (j + jbj)*channels];
for (i = 0; i<165; i = i + 2)
{
imgjbsbdata[(i + jbi)*step + jbj*channels] = 0;
imgjbsbdata[(i + jbi)*step + (jbj + 835)*channels] = 0;
}
for (j = 0; j<835; j = j + 2)
{
imgjbsbdata[jbi*step + (j + jbj)*channels] = 0;
imgjbsbdata[(jbi + 165)*step + (j + jbj)*channels] = 0;
}
return imgjbcj;
}
/*
功能：计算图像的特征
@变量 imgbj 笔迹部分的图像
@返回值 计算得到的特征图像
*/
IplImage* outline(IplImage* imgbj)
{
/*定义变量*/
int i, j;
int height, width, step, channels;
uchar *data;
/*定义新的图像*/
IplImage* imglk = cvCreateImage(cvGetSize(imgbj), imgbj->depth, imgbj->nChannels);
/* 获取图像信息*/
height = imgbj->height;
width = imgbj->width;
step = imgbj->widthStep;
channels = imgbj->nChannels;
data = (uchar *)imgbj->imageData;
// printf("--outline--");
for (j = 0; j<height; j++){
for (i = 0; i<width; i++){
imglk->imageData[j*step + i*channels] = 255;
}
for (i = 0; i<width - 1; i++){
if (data[j*step + (i + 1)*channels] - data[j*step + i*channels] == 255) //竖线右侧框
imglk->imageData[j*step + i*channels] = 0;
else if (data[j*step + i*channels] - data[j*step + (i + 1)*channels] == 255) //竖线左侧框
imglk->imageData[j*step + (i + 1)*channels] = 0;
}
}
for (i = 0; i<width; i++){
for (j = 0; j<height - 1; j++){
if (data[j*step + i*channels] - data[(j + 1)*step + i*channels] == 255) //横线下侧框
imglk->imageData[(j + 1)*step + i*channels] = 0;
else if (data[(j + 1)*step + i*channels] - data[j*step + i*channels] == 255) //横线上侧框
imglk->imageData[j*step + i*channels] = 0;
}
}
return imglk;
}
/*
功能：输入图像的特征轮廓图，返回图像的特征值
@变量 imglk 输入的图像轮廓图
@变量 feature 得到的图像特征
@返回值 成功1失败0
*/
int outlinefeature(IplImage* imglk, int feature[][50])
{
//定义变量
int i, j;
int height, width, step, channels;
uchar *data;
int feat[50][50] = { 0 }; //特征值初始化
Point featblk[32]; //标记相同H的黑点坐标
int featk; //标记相同H的黑点数目
int m; //for 里面的变量
// printf("--outlinefeature--");
// 获取图像信息
height = imglk->height;
width = imglk->width;
step = imglk->widthStep;
channels = imglk->nChannels;
data = (uchar *)imglk->imageData;
//初始化特征矩阵 最大值为47 ，非空的特征字有1081个
int outllab[9][9] = { \
{3, 37, 10, 36, 2, 35, 9, 34, 1}, { 38, 3, 21, 20, 2, 19, 18, 1, 33 }, \
{11, 22, 3, 10, 2, 9, 1, 17, 8}, { 39, 23, 11, 3, 2, 1, 8, 16, 32 }, \
{4, 4, 4, 4, 0, 0, 0, 0, 0}, { 40, 24, 12, 5, 6, 7, 15, 31, 47 }, \
{12, 25, 5, 13, 6, 14, 7, 30, 15}, { 41, 5, 26, 27, 6, 28, 29, 7, 46 }, \
{5, 42, 13, 43, 6, 44, 14, 45, 7} };
for (i = 4; i <= width - 5; i++){
for (j = 4; j <= height - 5; j++){
if (data[j*step + i*channels] == 0){
//**************H=1
memset(featblk, 0, sizeof(Point) * 32); //归零
featk = 0;
if (data[j*step + (i + 1)*channels] == 0){ //右侧点
featblk[featk].x = i + 1;
featblk[featk].y = j;
featk++;
}
for (m = i + 1; m >= i - 1; m--){ //上排点
if (data[(j - 1)*step + m*channels] == 0) {
featblk[featk].x = m;
featblk[featk].y = j - 1;
featk++;
}
}
if (data[j*step + (i - 1)*channels] == 0){ //左侧点
featblk[featk].x = i - 1;
featblk[featk].y = j;
featk++;
}
for (m = i - 1; m <= i + 1; m++) { //下排点
if (data[(j + 1)*step + m*channels] == 0){
featblk[featk].x = m;
featblk[featk].y = j + 1;
featk++;
}
}
//统计特征点
if (featk >= 2){
for (m = 1; m <= featk - 1; m++){
feat[outllab[featblk[m - 1].x - i + 4][featblk[m - 1].y - j + 4]][outllab[featblk[m].x - i + 4][featblk[m].y - j + 4]]++;
}
}
//H=1*******************
//*********************H=2
memset(featblk, 0, sizeof(Point) * 32); //归零
featk = 0;
for (m = j + 1; m >= j - 2; m--){
if (data[m*step + (i + 2)*channels] == 0){ //右排点
featblk[featk].x = i + 2;
featblk[featk].y = m;
featk++;
}
}
for (m = i + 1; m >= i - 2; m--){ //上排点
if (data[(j - 2)*step + m*channels] == 0){
featblk[featk].x = m;
featblk[featk].y = j - 2;
featk++;
}
}
for (m = j - 1; m <= j + 2; m++){ //左侧点
if (data[m*step + (i - 2)*channels] == 0){
featblk[featk].x = i - 2;
featblk[featk].y = m;
featk++;
}
}
for (m = i - 1; m <= i + 2; m++){ //下排点
if (data[(j + 2)*step + m*channels] == 0){
featblk[featk].x = m;
featblk[featk].y = j + 2;
featk++;
}
}
//统计特征点
if (featk >= 2){
for (m = 1; m <= featk - 1; m++){
feat[outllab[featblk[m - 1].x - i + 4][featblk[m - 1].y - j + 4]][outllab[featblk[m].x - i + 4][featblk[m].y - j + 4]]++;
}
}
//H=2********************
//*********************H=3
memset(featblk, 0, sizeof(Point) * 32); //归零
featk = 0;
for (m = j + 2; m >= j - 3; m--){
if (data[m*step + (i + 3)*channels] == 0){ //右排点
featblk[featk].x = i + 3;
featblk[featk].y = m;
featk++;
}
}
for (m = i + 2; m >= i - 3; m--){ //上排点
if (data[(j - 3)*step + m*channels] == 0){
featblk[featk].x = m;
featblk[featk].y = j - 3;
featk++;
}
}
for (m = j - 2; m <= j + 3; m++){ //左侧点
if (data[m*step + (i - 3)*channels] == 0){
featblk[featk].x = i - 3;
featblk[featk].y = m;
featk++;
}
}
for (m = i - 2; m <= i + 3; m++){ //下排点
if (data[(j + 3)*step + m*channels] == 0){
featblk[featk].x = m;
featblk[featk].y = j + 3;
featk++;
}
}
//统计特征点
if (featk >= 2){
for (m = 1; m <= featk - 1; m++){
feat[outllab[featblk[m - 1].x - i + 4][featblk[m - 1].y - j + 4]][outllab[featblk[m].x - i + 4][featblk[m].y - j + 4]]++;
}
}
//H=3********************
//*********************H=4
memset(featblk, 0, sizeof(Point) * 32); //归零
featk = 0;
for (m = j + 3; m >= j - 4; m--){
if (data[m*step + (i + 4)*channels] == 0){ //右排点
featblk[featk].x = i + 4;
featblk[featk].y = m;
featk++;
}
}
for (m = i + 3; m >= i - 4; m--) { //上排点
if (data[(j - 4)*step + m*channels] == 0){
featblk[featk].x = m;
featblk[featk].y = j - 4;
featk++;
}
}
for (m = j - 3; m <= j + 4; m++){ //左侧点
if (data[m*step + (i - 4)*channels] == 0){
featblk[featk].x = i - 4;
featblk[featk].y = m;
featk++;
}
}
for (m = i - 3; m <= i + 4; m++){ //下排点
if (data[(j + 4)*step + m*channels] == 0){
featblk[featk].x = m;
featblk[featk].y = j + 4;
featk++;
}
}
//统计特征点
if (featk >= 2){
for (m = 1; m <= featk - 1; m++){
feat[outllab[featblk[m - 1].x - i + 4][featblk[m - 1].y - j + 4]][outllab[featblk[m].x - i + 4][featblk[m].y - j + 4]]++;
}
}
//H=4***********************
}// if
} //for j
} //for i
//****注：最终特征值为feat(x,y)+feat(y,x)，放入feat(x,y)中，x<y
for (i = 1; i<50; i++)
for (j = 0; j<i; j++){
feat[j][i] = feat[i][j] + feat[j][i];
feat[i][j] = 0;
}
memcpy(feature, feat, 2500 * 4); //int有四个字节
// printf("轮廓特征值计算完成\n");
return 0;
}
/*
功能：对单张图像的处理，最终得到一个特征值，用来计算各个图像之间的卡方距离
@变量 path 图像的物理地址
@变量 feature 图像的特征值
@返回值 处理后的图像
*/
IplImage* singlefeature(char* path, int feature[][50])
{
//定义变量
//原图
IplImage* imglk = 0; //轮廓图
IplImage* imggj = 0; //骨架图
IplImage* imgjbsb = 0; //角标识别图
IplImage* imgbj = 0; //只提取笔记部分的图像
IplImage* imgbjhf = 0; //为文字区域画上方格
IplImage* imgwzbj = 0; //为文字区域标出是否为文字（文字标记）
int height, width, step, channels;
uchar *data;
int i, j; //用于返回图像每行黑像素的个数
//int feature[50][50]={0}; //特征值初始化
IplImage* img = cvLoadImage(path, 0);
/* 获取图像信息*/
height = img->height;
width = img->width;
step = img->widthStep;
channels = img->nChannels;
data = (uchar *)img->imageData;
/*开始处理*/
/*图像放大*/
IplImage* imgbig = 0; //原图的放大图
CvSize dst_cvsize; //目标图像的大小
float scale = 1;
if (width<840){
scale = (float)840 / width;
dst_cvsize.width = 840;
dst_cvsize.height = (int)(height*scale);
}
else
{
dst_cvsize.width = width;
dst_cvsize.height = height;
}
imgbig = cvCreateImage(dst_cvsize, img->depth, img->nChannels);
cvResize(img, imgbig, CV_INTER_LINEAR); // CV_INTER_NN - 最近邻插值,
//CV_INTER_LINEAR - 双线性插值 (缺省使用),
//CV_INTER_AREA - 使用象素关系重采样。当图像缩小时候，该方法可以避免波纹出现。
//CV_INTER_CUBIC - 立方插值.
/*二值化*/
binary(imgbig, g_bi_threshold);
//SaveLog("singlefeature_binary\n", "D:\\HWCV\\numtxt.txt", "a");
/*裁剪识别*/
int jbwhite = 5, jbblack = 4;
imgjbsb = cvCreateImage(cvGetSize(imgbig), imgbig->depth, imgbig->nChannels);
imgbj = Cjbsb(imgbig, imgjbsb, jbwhite, jbblack); //返回文字的笔迹部分
/*计算骨架图*/
imggj = cvCreateImage(cvGetSize(imgbj), imgbj->depth, imgbj->nChannels); //复制
cvCopy(imgbj, imggj, NULL);
uchar *gjdata = (uchar *)imggj->imageData;
beforethin(gjdata, gjdata, imggj->width, imggj->height);
/*笔迹图像颜色范围转换，以进行细化*/
for (j = 0; j<imggj->height; j++)//取值范围转到0--1
{
for (i = 0; i<imggj->width; i++)
{
if (gjdata[j*imggj->widthStep + i] == 255)
gjdata[j*imggj->widthStep + i] = 1;
}
}
/*细化*/
ThinnerRosenfeld(imggj->imageData, imggj->height, imggj->width);
/*笔记图像颜色范围转化回正常水平*/
for (j = 0; j<imggj->height; j++)//取值范围转到0--255,反转过来
{
for (i = 0; i<imggj->width; i++)
{
if (gjdata[j*imggj->widthStep + i] == 1)
gjdata[j*imggj->widthStep + i] = 0;
else
gjdata[j*imggj->widthStep + i] = 255;
}
}
/*计算骨架特征徝*/
outlinefeature(imggj, feature); //特征值占48*48的右上三角形，feature调用返回
/*释放内存*/
cvReleaseImage(&imgbig);
cvReleaseImage(&img);
cvReleaseImage(&imgbj);
cvReleaseImage(&imglk);
cvReleaseImage(&imgjbsb);
cvReleaseImage(&imgbjhf);
cvReleaseImage(&imgwzbj);
cvDestroyAllWindows();
return imggj;
}
/*
功能：细化之前的图像颜色处理，将颜色范围转换到0-1
@变量 ip 图像的句柄
@变量 jp
@变量 lx 图象宽度
@变量 ly 图象高度
@返回值 空
*/
void beforethin(unsigned char *ip, unsigned char *jp, unsigned long lx, unsigned long ly)
{
unsigned long i, j;
for (i = 0; i<ly; i++){
for (j = 0; j<lx; j++){
//这里要视前景是白点还是黑点而定，可以改动
//如果前景是白点，就是这样；反之反过来
//jp[i*lx+j]=ip[i*lx+j];
/* jp[i*lx+j]=255;*/
if (ip[i*lx + j]>0)
jp[i*lx + j] = 0;
else
jp[i*lx + j] = 255;
}
}
}
/*功能：细化算法 ，Rosenfeld细化算法，用于完成对笔迹图像的股价提取
@变量 image 代表图象的一维数组
@变量 lx 图象宽度
@变量 ly 图象高度
@返回值 无返回值
*/
void ThinnerRosenfeld(void *image, unsigned long lx, unsigned long ly)
{
char *f, *g;
char n[10];
char a[5] = { 0, -1, 1, 0, 0 };
char b[5] = { 0, 0, 0, 1, -1 };
char nrnd, cond, n48, n26, n24, n46, n68, n82, n123, n345, n567, n781;
short k, shori;
unsigned long i, j;
long ii, jj, kk, kk1, kk2, kk3, size;
// printf("--Thinner_Rosenfeld--");
size = (long)lx * (long)ly;
g = (char *)malloc(size);
if (g == NULL){
printf("error in alocating mmeory!\n");
return;
}
f = (char *)image;
for (kk = 0l; kk<size; kk++){
g[kk] = f[kk];
}
do{
shori = 0;
for (k = 1; k <= 4; k++){
for (i = 1; i<lx - 1; i++){
ii = i + a[k];
for (j = 1; j<ly - 1; j++){
kk = i*ly + j;
if (!f[kk])
continue;
jj = j + b[k];
kk1 = ii*ly + jj;
if (f[kk1])
continue;
kk1 = kk - ly - 1;
kk2 = kk1 + 1;
kk3 = kk2 + 1;
n[3] = f[kk1];
n[2] = f[kk2];
n[1] = f[kk3];
kk1 = kk - 1;
kk3 = kk + 1;
n[4] = f[kk1];
n[8] = f[kk3];
kk1 = kk + ly - 1;
kk2 = kk1 + 1;
kk3 = kk2 + 1;
n[5] = f[kk1];
n[6] = f[kk2];
n[7] = f[kk3];
nrnd = n[1] + n[2] + n[3] + n[4]
+ n[5] + n[6] + n[7] + n[8];
if (nrnd <= 1)
continue;
cond = 0;
n48 = n[4] + n[8];
n26 = n[2] + n[6];
n24 = n[2] + n[4];
n46 = n[4] + n[6];
n68 = n[6] + n[8];
n82 = n[8] + n[2];
n123 = n[1] + n[2] + n[3];
n345 = n[3] + n[4] + n[5];
n567 = n[5] + n[6] + n[7];
n781 = n[7] + n[8] + n[1];
if (n[2] == 1 && n48 == 0 && n567>0){
if (!cond)
continue;
g[kk] = 0;
shori = 1;
continue;
}
if (n[6] == 1 && n48 == 0 && n123>0) {
if (!cond)
continue;
g[kk] = 0;
shori = 1;
continue;
}
if (n[8] == 1 && n26 == 0 && n345>0){
if (!cond)
continue;
g[kk] = 0;
shori = 1;
continue;
}
if (n[4] == 1 && n26 == 0 && n781>0) {
if (!cond)
continue;
g[kk] = 0;
shori = 1;
continue;
}
if (n[5] == 1 && n46 == 0){
if (!cond)
continue;
g[kk] = 0;
shori = 1;
continue;
}
if (n[7] == 1 && n68 == 0){
if (!cond)
continue;
g[kk] = 0;
shori = 1;
continue;
}
if (n[1] == 1 && n82 == 0){
if (!cond)
continue;
g[kk] = 0;
shori = 1;
continue;
}
if (n[3] == 1 && n24 == 0){
if (!cond)
continue;
g[kk] = 0;
shori = 1;
continue;
}
cond = 1;
if (!cond)
continue;
g[kk] = 0;
shori = 1;
}
}
for (i = 0; i<lx; i++){
for (j = 0; j<ly; j++){
kk = i*ly + j;
f[kk] = g[kk];
}
}
}
} while (shori);
free(g);
}

99
测试/本机测试/HWCV_vc6/process.h Normal file
View File

@@ -0,0 +1,99 @@
/*
头文件：process.h 图像处理函数头文件
*/
#pragma once
#include "StdAfx.h"
#include "Point.h"
#include "path.h"
#include "process.h"
#include <cv.h>
#include <direct.h>
#include <io.h>
#include <iostream>
#include <math.h>
#include <malloc.h>
#include <highgui.h>
#include <stdlib.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <vector>
using namespace std;
/*全局变量*/
extern IplImage* src;
/***************************************函数原型****************************************/
int ComputeImage(vector<string> files, double bzckesa[50][50], double *wcd, int conti);
/*
功能：读入图像文件，进行二值化
@变量 img iplimage图像文件
@变量 bithro 二值化阈值
@返回值 黑像素的数目（待用）
*/
int* binary(IplImage* img, int bithro);
/*
功能：读入图像文件，对图像进行裁剪
@变量 img iplimage图像文件
@变量 img 裁剪后的iplimage图像文件
@jbwhite
@jbblack
@返回值 返回裁剪后的图像
*/
IplImage* Cjbsb(IplImage* img, IplImage* imgjbsb, int jbwhite, int jbblack);
/*
功能：计算图像的特征
@变量 imgbj 笔迹部分的图像
@返回值 计算得到的特征图像
*/
IplImage* outline(IplImage* imgbj);
/*
功能：输入图像的特征轮廓图，返回图像的特征值
@变量 imglk 输入的图像轮廓图
@变量 feature 得到的图像特征
@返回值 成功1失败0
*/
int outlinefeature(IplImage* imglk, int feature[][50]);
/*
功能：对单张图像的处理，最终得到一个特征值，用来计算各个图像之间的卡方距离
@变量 path 图像的物理地址
@变量 feature 图像的特征值
@返回值 处理后的图像
*/
IplImage* singlefeature(char* path, int feature[][50]);
/*
功能：细化之前的图像颜色处理，将颜色范围转换到0-1
@变量 ip 图像的句柄
@变量 jp
@变量 lx 图象宽度
@变量 ly 图象高度
@返回值 空
*/
void beforethin(unsigned char *ip, unsigned char *jp, unsigned long lx, unsigned long ly);
/*功能：细化算法 ，Rosenfeld细化算法，用于完成对笔迹图像的股价提取
@变量 image 代表图象的一维数组
@变量 lx 图象宽度
@变量 ly 图象高度
@返回值 无返回值
*/
void ThinnerRosenfeld(void *image, unsigned long lx, unsigned long ly);

219
测试/本机测试/HWCV_vc6/seg_bck.cpp Normal file
View File

@@ -0,0 +1,219 @@
///*
//主函数文件：segmentation.cpp 主函数的实现文件
//*/
//#include "segmentation.h"
////#pragma comment( linker, "/subsystem:windows /entry:mainCRTStartup" )//无界面运行
///*主函数*/
//int ComputeImage(vector<string> files, double bzckesa[50][50], double *wcd, int conti);
//int main(int argc, char* argv[])
//{
// /*变量定义*/
// string dir = "E:\\xiangmu\\Img\\imgjiaobiao\\010211100518"; //存储目录
// //string dir;
// //if (argc < 2)
// // return -1;
// //else
// // dir = argv[1];
// cout << (char*)dir.c_str() << endl;
// char record[2400] = { 0 };
// FILE* fpzz = NULL;//需要注意
// int i, ii, jj, feature[50][50][30] = { 0 }, featureall = 0;
// double featurep[50][50][30] = { 0 };
// double bzcu[50][50] = { 0 };
// double bzckesa[50][50] = { 0 };
// double wcd[30] = { 0 };
//
// int featx[50][50] = { 0 };
// int featdif[30] = { 0 };
// float maxx = 0; //最大特征值的标号与值
// int xyimgnum = 0; //嫌疑图片的数目
// char str[80]; //存储地址
//
// vector<string> suspict; //记录嫌疑图片地址
// vector<float> suspict_wcd; //嫌疑图片的wcd值
// vector<string> files; //存储该生所有考试文件路径
//
// /*读取配置文件，并配置各项参数*/
// if (!ReadConfig("D:/HWCV/config/configure.cfg"))
// {
// // SaveLog("\t配置文件读取失败\n", g_log_adr, "a");
// SaveLog("\n0\n", g_log_adr, "a");
// return 0;
// }
// char path[100] = "E:/xiangmu/Img/imgjiaobiao/";
//
//
//
// /*步骤：读取标准差文件*/
// int bzccolumns = 47;//txt文件中有47列
// vector<double *> output_bzc;
// if (!ReadScanf("D:\\HWCV\\config\\stdfile.db", bzccolumns, output_bzc))
// {
// memset(g_log_rec, 0, sizeof(g_log_rec));
//
// // SaveLog("\n读取路径：D:\\HWCV\\config\\stdfile.db 的标准差文件失败！\n", g_log_adr, "a");
// SaveLog("\n0\n", g_log_adr, "a");
// return 0;
// }
//
// //开始检测
// //-------------------------------------------------------------//
// getFiles(dir.c_str(), files); //遍历当前文件夹下的所有文件
// int size = files.size();
//
// for (i = 0; i < size; i++)
// {
// // cout << ".";
// memset(str, 0, sizeof(str));
// memset(featx, 0, sizeof(featx));
// memset(bzcu, 0, sizeof(bzcu));
//
// strcpy(str, files[i].c_str());
// singlefeature(str, featx);//featx[][50]
//
// featureall = 0; //图像特征值和的初始化
// for (ii = 0; ii < 48; ii++) //将featx存起来,回头看能不能用函数换掉
// for (jj = ii + 1; jj < 47; jj++)
// {
// feature[ii][jj][i] = featx[ii][jj];
// featureall = featureall + featx[ii][jj];
// }
// /*求轮廓方向特征featurep，式(5) 与标准差中的u的和*/
// for (ii = 0; ii < 48; ii++)
// for (jj = ii + 1; jj < 47; jj++)
// {
// featurep[ii][jj][i] = (double)featx[ii][jj] / featureall;
// bzcu[ii][jj] += (double)featx[ii][jj] / featureall * 1000; //标准差的值过小,进行放大（1）
// }
// }/*处理完全部图片*/
//
// /*求标准差中u*/
// for (ii = 0; ii < 48; ii++)
// for (jj = ii + 1; jj < 47; jj++)
// bzcu[ii][jj] = bzcu[ii][jj] / size;
//
//
// for (ii = 0; ii < 48; ii++)//output_vector可视为二维数组;输出数组元素：
// for (jj = ii + 1; jj < 47; jj++)
// bzckesa[ii][jj] = output_bzc[ii][jj];
//
// /*求相似性，即带权卡方wcd*/
// for (i = 0; i < size; i++)
// for (ii = 0; ii < 48; ii++)
// for (jj = ii + 1; jj < 47; jj++)
// if (featurep[ii][jj][i] * featurep[ii][jj][g_conti] != 0 && bzckesa[ii][jj] != -1)
// wcd[i] += pow((featurep[ii][jj][i] - featurep[ii][jj][g_conti]), 2) / ((featurep[ii][jj][i] + featurep[ii][jj][g_conti])*bzckesa[ii][jj]);
//
// //标出所有有嫌疑的图像1，无嫌疑的图像0
// for (i = 0; i < size; i++)
// {
// if (wcd[i] > 0.12)
// {
// xyimgnum++;
// suspict.push_back(files[i].c_str());
// suspict_wcd.push_back(wcd[i]);
// }
// }
//
// /*将结果存入log文件*/
// strcat(g_log_rec, "\n");
// memset(g_log_rec, 0, sizeof(g_log_rec));
// // strcat(g_log_rec, GetTime());
// // strcat(g_log_rec, "\t考生考号：");
// strcat(g_log_rec, dir.substr(27, 22).c_str());
// strcat(g_log_rec, "\t");//图片总数为：
// char pic_num[20];
// _itoa(size, pic_num, 10);
// strcat(g_log_rec, pic_num);
// if (xyimgnum > 0)
// {
// char b[20];
// sprintf(b, "\t%d", xyimgnum);
// strcat(g_log_rec, b);
// strcat(g_log_rec, "\n");
// for (i = 0; i < xyimgnum; i++)
// {
// // cout << "嫌疑图像：" << files[i].c_str() << endl;
// strcat(g_log_rec, "\t\t\t");//\t嫌疑图像：
// strcat(g_log_rec, suspict[i].c_str());
// strcat(g_log_rec, "\t");//相似度：
// float sim = (1.0 - suspict_wcd[i]) * 100;
// char a[20];
// sprintf(a, "%g", sim);
// strcat(g_log_rec, a);
// strcat(g_log_rec, "%%\n");
// }
// }
// else
// {
// // strcat(g_log_rec, "\t该考生没有嫌疑图像！\n");
// strcat(g_log_rec, "\t0\n");
// // cout << "该考生无嫌疑图像！" << endl;
// }
// SaveLog(g_log_rec, g_log_adr, "a");
//
//
// /*善后*/
// suspict.clear();
// suspict_wcd.clear();
// memset(g_log_rec, 0, sizeof(g_log_rec));
// memset(feature, 0, sizeof(feature));
// memset(featurep, 0, sizeof(featurep));
// memset(bzckesa, 0, sizeof(bzckesa));
// memset(wcd, 0, sizeof(wcd));
// memset(featdif, 0, sizeof(featdif));
// files.clear();
// memset(g_log_rec, 0, sizeof(g_log_rec));
//
// /*返回值*/
// return 0;
//}
//
//
//int ComputeImage(vector<string> files, double bzckesa[50][50], double *wcd, int conti)
//{
// int i, ii, jj, k, size;
// double bzcu[50][50] = { 0 }; //标准差中的u
// double featurep[50][50][30] = { 0 }; //所有图像的轮廓方向特征初始化//干什么 //30
// int feature[50][50][30] = { 0 }; //所有图像的特征值初始化 //所有图像指的什么意思 //30找出30的位置或者50的位置限制。。。。带入num_dir==49的情况进行类比
// int featx[50][50] = { 0 }; //循环赋值的feature
// int featureall; //图像特征值和 //做什么用
// IplImage* imglk[30]; //轮廓图变量 //30
//
// size = files.size();
// for (i = 0; i < size; i++)
// {
// memset(featx, 0, sizeof(featx));
// // strcpy(str,files[i].c_str());
// imglk[i] = singlefeature((char*)files[i].c_str(), featx); //featx[][50]
// featureall = 0; //图像特征值和的初始化
// for (ii = 0; ii<48; ii++) //将featx存起来,回头看能不能用函数换掉
// for (jj = ii + 1; jj<47; jj++)
// {
// feature[ii][jj][i] = featx[ii][jj];
// featureall = featureall + featx[ii][jj];
// }
// //求轮廓方向特征featurep，式(5) 与标准差中的u的和
// for (ii = 0; ii<48; ii++)
// for (jj = ii + 1; jj<47; jj++)
// {
// featurep[ii][jj][i] = (double)featx[ii][jj] / featureall;
// bzcu[ii][jj] += (double)featx[ii][jj] / featureall * 1000; //标准差的值过小,进行放大（1）
// }
// }
// //处理完一个人的每一张图片后
// for (ii = 0; ii<48; ii++)//求标准差中的u
// for (jj = ii + 1; jj<47; jj++)
// bzcu[ii][jj] = bzcu[ii][jj] / size;
// //求相似性就是带权卡方wcd
// for (i = 0; i < size; i++)
// for (ii = 0; ii<48; ii++)
// for (jj = ii + 1; jj<47; jj++)
// if (featurep[ii][jj][i] * featurep[ii][jj][conti] != 0 && bzckesa[ii][jj] != -1)
// wcd[i] += pow((featurep[ii][jj][i] - featurep[ii][jj][conti]), 2) / ((featurep[ii][jj][i] + featurep[ii][jj][conti])*bzckesa[ii][jj]);
// memset(imglk, 0, sizeof(imglk));
// memset(feature, 0, sizeof(feature));
// memset(featurep, 0, sizeof(featurep));
//
// return 1;
//}

146
测试/本机测试/HWCV_vc6/segmentation.cpp Normal file
View File

@@ -0,0 +1,146 @@
/*
主函数文件：segmentation.cpp 主函数的实现文件
*/
#include "segmentation.h"
//#pragma comment( linker, "/subsystem:windows /entry:mainCRTStartup" )//无界面运行
/*主函数*/
int main(int argc, char* argv[])
{
/*变量定义*/
string dir = "E:/xiangmu/Img/imgjiaobiao/010211100518"; //存储目录
//string dir;
//if (argc < 2)
// return -1;
//else
// dir = argv[1];
cout << (char*)dir.c_str() << endl;
char record[2400] = { 0 };
FILE* fpzz = NULL;//需要注意
int i, ii, jj, feature[50][50][30] = { 0 }, featureall = 0;
double featurep[50][50][30] = { 0 };
double bzcu[50][50] = { 0 };
double bzckesa[50][50] = { 0 };
double wcd[30] = { 0 };
int featx[50][50] = { 0 };
int featdif[30] = { 0 };
float maxx = 0; //最大特征值的标号与值
int xyimgnum = 0; //嫌疑图片的数目
vector<string> suspict; //记录嫌疑图片地址
vector<float> suspict_wcd; //嫌疑图片的wcd值
vector<string> files; //存储该生所有考试文件路径
/*读取配置文件，并配置各项参数*/
if (!ReadConfig("D:/HWCV/config/configure.cfg"))
{
// SaveLog("\t配置文件读取失败\n", g_log_adr, "a");
SaveLog("\n0\n", g_log_adr, "a");
return 0;
}
char path[100] = "E:/xiangmu/Img/imgjiaobiao/";
/*步骤：读取标准差文件*/
int bzccolumns = 47;//txt文件中有47列
vector<double *> output_bzc;
if (!ReadScanf("D:\\HWCV\\config\\stdfile.db", bzccolumns, output_bzc))
{
memset(g_log_rec, 0, sizeof(g_log_rec));
// SaveLog("\n读取路径：D:\\HWCV\\config\\stdfile.db 的标准差文件失败！\n", g_log_adr, "a");
SaveLog("\n0\n", g_log_adr, "a");
return 0;
}
// cout<<"标准差："<<endl;
for (ii = 0; ii < 48; ii++)//output_vector可视为二维数组;输出数组元素：
for (jj = ii + 1; jj < 47; jj++)
{
bzckesa[ii][jj] = output_bzc[ii][jj];
// cout<< bzckesa[ii][jj];
}
// cout<<endl;
//开始检测
//-------------------------------------------------------------//
getFiles(dir.c_str(), files); //遍历当前文件夹下的所有文件
int size = files.size();
cout << "考生文件数量" <<size<< endl;
//开始对每一张图片进行处理
for (int r = 0; r<size; r++)
{
memset(wcd, 0, sizeof(wcd));
cout<<"-对每一张图片进行处理-："<<files[r].c_str()<<endl;
ComputeImage(files, bzckesa, wcd, r);
xyimgnum = 0;
//求卡方距离的最大值
for (i = 0; i < size; i++)
{
cout << files[i].c_str()<< " " << wcd[i] << endl;
if (wcd[i]>0.12)
{
xyimgnum++;
suspict.push_back(files[i].c_str());
suspict_wcd.push_back(wcd[i]);
}
}
if (xyimgnum<3) break;
}
/*将结果存入log文件*/
strcat(g_log_rec, "\n");
memset(g_log_rec, 0, sizeof(g_log_rec));
// strcat(g_log_rec, GetTime());
// strcat(g_log_rec, "\t考生考号：");
strcat(g_log_rec, dir.substr(27, 22).c_str());
strcat(g_log_rec, "\t");//图片总数为：
char pic_num[20];
_itoa(size, pic_num, 10);
strcat(g_log_rec, pic_num);
if (xyimgnum > 0)
{
char b[20];
sprintf(b, "\t%d", xyimgnum);
strcat(g_log_rec, b);
strcat(g_log_rec, "\n");
for (i = 0; i < xyimgnum; i++)
{
cout << "嫌疑图像：" << files[i].c_str() << endl;
strcat(g_log_rec, "\t\t\t");//\t嫌疑图像：
strcat(g_log_rec, suspict[i].c_str());
strcat(g_log_rec, "\t");//相似度：
float sim = (1.0 - suspict_wcd[i]) * 100;
char a[20];
sprintf(a, "%g", sim);
strcat(g_log_rec, a);
strcat(g_log_rec, "%%\n");
}
}
else
{
// strcat(g_log_rec, "\t该考生没有嫌疑图像！\n");
strcat(g_log_rec, "\t0\n");
cout << "该考生无嫌疑图像！" << endl;
}
SaveLog(g_log_rec, g_log_adr, "a");
/*善后*/
suspict.clear();
suspict_wcd.clear();
memset(g_log_rec, 0, sizeof(g_log_rec));
memset(feature, 0, sizeof(feature));
memset(featurep, 0, sizeof(featurep));
memset(bzckesa, 0, sizeof(bzckesa));
memset(wcd, 0, sizeof(wcd));
memset(featdif, 0, sizeof(featdif));
files.clear();
memset(g_log_rec, 0, sizeof(g_log_rec));
/*返回值*/
system("pause");
return 0;
}

43
测试/本机测试/HWCV_vc6/segmentation.h Normal file
View File

@@ -0,0 +1,43 @@
/*
头文件：segmentation.h 主函数头文件
*/
#pragma once
#ifdef WIN32 //屏蔽VC6对STL的一些不完全支持造成
#pragma warning (disable: 4514 4786)
#endif
#include "StdAfx.h"
#include "path.h"
#include "Point.h"
#include "process.h"
using namespace std;
/*定义全局变量*/
int g_bi_threshold = 230; /* 全局变量 二值化阈值*/
double g_std_kesa[50][50]; /* 全局变量 标准差数组*/
float g_doubt_threshold = 0.12; /* 全局变量 作弊嫌疑阈值*/
string g_dir = "Y:/"; /* 全局变量 总路径的目录*/
int g_cheat_num_threshold = 0; /* 全局变量 默认作弊阈值*/
int g_conti = 1; /* 全局变量 默认作弊比较的图片*/
int g_all_img_num = 0; /* 全局变量 已鉴定的全部图片数量*/
int g_doubt_img_num = 0; /* 全局变量 已鉴定怀疑的图片数量*/
int g_all_stu_num = 0; /* 全局变量 已鉴定的全部学生数量*/
int g_doubt_stu_num = 0; /* 全局变量 已鉴定怀疑的学生数量*/
bool g_output_cmd_config = false; /*全局变量 输出参数控制*/
bool g_output_txt_config = false; /*全局变量 输出中间文件选项*/
char g_log_adr[50] = "D:/HWCV/log_ori.txt"; /*全局变量 程序日志存储地址*/
char g_log_rec[500] = { 0 }; /*全局变量 程序日志专用变量*/
char g_err_adr[50]= "D:/HWCV/err_ori.txt"; /*错误日志路径*/
/*全局变量 输出txt结果文件*/
/*全局变量 输出txt结果文件地址*/
time_t ltime;
char *srcTime=NULL;
char timeNow[32]={0};
char msg[100]={0};