如何识别高级的验证码（pstzine_09_01.txt）


//SuperImage.h

#ifndef _SUPER_IMAGE_

#define _SUPER_IMAGE_

typedef short Pixel;

//

template <class T>

class SuperImage

{

public:

SuperImage(const int w, const int h);

~SuperImage();

public:

T* data;

int width;

int height;

};

//

class EnhancedImage

{

public:

SuperImage<Pixel>* superImage;

public:

EnhancedImage();

~EnhancedImage();

int load(const char* name);

int save(const char* name);

int copy(EnhancedImage* copy);

int film(EnhancedImage* film);

int binv();

int otsu();

int line();

int roii();

int trac();

int edge();

int thin();

int tidy();

int kerf();

int join();

};

#endif

//SuperImage.cpp

#include "superImage.h"

#include "ximage.h"

template <class T>

SuperImage<T>::SuperImage(const int w, const int h)

{

width = w;

height = h;

data = new T[w * h];

};

template <class T>

SuperImage<T>::~SuperImage()

{

if(data)

{

delete[] data;

}

};

EnhancedImage::EnhancedImage()

{

superImage=NULL;

};

EnhancedImage::~EnhancedImage()

{

if(superImage)

{

delete superImage;

}

};

int EnhancedImage::load(const char* name)

{

CxImage input;

input.Load(name, CXIMAGE_SUPPORT_J2K);

if(!input.IsValid())

{

return 1;

}

else

{

int h=input.GetHeight();

int w=input.GetWidth();

superImage = new SuperImage<Pixel>(w,h);

for(int y=0;y<h;y++)

{

for(int x=0;x<w;x++)

{

RGBQUAD rgbQUAD = CxImage::RGBtoXYZ(input.GetPixelColor(x,y));

Pixel pixel = 255;

if(true)

{

pixel = (rgbQUAD.rgbRed + rgbQUAD.rgbGreen + rgbQUAD.rgbBlue) / 3.0;

}

else

{

double yy = (0.299 * rgbQUAD.rgbRed + 0.587 * rgbQUAD.rgbGreen + 0.114 * rgbQUAD.rgbBlue) / 256.0;

pixel = (int) (219.0 * yy + 16.5);

}

superImage->data[y*w+x]=pixel;

}

}

}

return 0;

};

int EnhancedImage::save(const char* name)

{

CxImage output;

output.Create(superImage->width,superImage->height,24,CXIMAGE_SUPPORT_BMP); //1 4 8 24

for(int y=0;y<superImage->height;y++)

{

for(int x=0;x<superImage->width;x++)

{

Pixel pixel = superImage->data[y*superImage->width + x];

RGBQUAD rgbQUAD;

if(pixel == -1)

{

rgbQUAD.rgbRed = 255;

rgbQUAD.rgbGreen = 0;

rgbQUAD.rgbBlue = 0;

}

else if(pixel == -2)

{

rgbQUAD.rgbRed = 0;

rgbQUAD.rgbGreen = 255;

rgbQUAD.rgbBlue = 0;

}

else if(pixel == -3)

{

rgbQUAD.rgbRed = 0;

rgbQUAD.rgbGreen = 0;

rgbQUAD.rgbBlue = 255;

}

else

{

rgbQUAD.rgbRed = pixel;

rgbQUAD.rgbGreen = pixel;

rgbQUAD.rgbBlue =pixel;

}

output.SetPixelColor(x,y,rgbQUAD);

}

}

output.Save(name,CXIMAGE_SUPPORT_BMP);

return 0;

};

int EnhancedImage::copy(EnhancedImage* copy)

{

int w = copy->superImage->width;

int h = copy->superImage->height;

short* cpy = copy->superImage->data;

//

this->superImage = new SuperImage<Pixel>(w,h);

short* tgt = this->superImage->data;

//

for (int y=0; y<h; y++)

{

for (int x=0; x<w; x++)

{

tgt[w*(y)+(x)] = cpy[w*(y)+(x)];

}

}

return 0;

}

int EnhancedImage::film(EnhancedImage* film)

{

int h = film->superImage->height;

int w = film->superImage->width;

short* flm = film->superImage->data;

short* tgt = this->superImage->data;

//

for (int y=0; y<h; y++)

{

for (int x=0; x<w; x++)

{

unsigned char source = flm[w*(y)+(x)];

unsigned char target = tgt[w*(y)+(x)];

if(source < 0 || target < 0)

{

printf("x=%d y=%d src=%d tgt=%d\n",x,y,source,target);

}

if(source==0 && target == 255)

{

tgt[w*(y)+(x)] = source;

}

}

}

return 0;

}

int EnhancedImage::binv()

{

int threshold = 256 / 8 * 7;

for(int y2=0;y2<superImage->height;y2++)

{

for(int x2=0;x2<superImage->width;x2++)

{

Pixel pixel = superImage->data[y2*superImage->width+x2];

if(pixel>=threshold)

{

superImage->data[y2*superImage->width+x2] = 255;

}

else

{

superImage->data[y2*superImage->width+x2] = 0;

}

}

}

return 0;

};

int EnhancedImage::otsu()

{

int ihist[256];

memset(ihist, 0, sizeof(ihist));

int gmin=255;

int gmax=0;

for (int y=0; y<superImage->height; y++)

{

for (int x=0; x<superImage->width; x++)

{

unsigned char point = superImage->data[y*superImage->width+x];

ihist[point]++;

if(point > gmax)

{

gmax=point;

}

if(point < gmin)

{

gmin=point;

}

}

}

double sum = 0.0;

int n = 0;

for (int k = 0; k <= 255; k++)

{

sum += (double) k * (double) ihist[k]; // x*f(x) 质量矩

n += ihist[k]; // f(x) 质量

}

// do the otsu global thresholding method

int threshold = 127;

double fmax = -1.0;

int n1 = 0;

double csum = 0.0;

for (k = 0; k < 255; k++)

{

n1 += ihist[k];

if (!n1)

{

continue;

}

int n2 = n - n1;

if (n2 == 0)

{

break;

}

csum += (double) k *ihist[k];

int m1 = csum / n1;

int m2 = (sum - csum) / n2;

int sb = (double) n1 *(double) n2 *(m1 - m2) * (m1 - m2);

//note: can be optimized.

if (sb > fmax)

{

fmax = sb;

threshold = k;

}

}

//

for(int y2=0;y2<superImage->height;y2++)

{

for(int x2=0;x2<superImage->width;x2++)

{

Pixel pixel = superImage->data[y2*superImage->width+x2];

if(pixel>threshold)

{

superImage->data[y2*superImage->width+x2] = 255;

}

else

{

superImage->data[y2*superImage->width+x2] = 0;

}

}

}

return 0;

};

/*************************************************************************

*

* 函数名称：

* Hough()

*

* 参数:

* LPSTR lpDIBBits - 指向源DIB图像指针

* LONG lWidth - 源图像宽度（象素数，必须是4的倍数）

* LONG lHeight - 源图像高度（象素数）

* 返回值:

* BOOL - 运算成功返回TRUE，否则返回FALSE。

*

* 说明:

* 该函数用于对检测图像中的平行直线。如果图像中有两条平行的直线，则将这两条平行直线

* 提取出来。

*

* 要求目标图像为只有0和255两个灰度值的灰度图像。

************************************************************************/

// 在计算图像大小时，采用公式：biSizeImage = biWidth' × biHeight。

// 是biWidth'，而不是biWidth，这里的biWidth'必须是4的整倍数，表示

// 大于或等于biWidth的，离4最近的整倍数。WIDTHBYTES就是用来计算

// biWidth'

#define WIDTHBYTES(bits) (((bits) + 31) / 32 * 4)

#define pi 3.1415927

typedef struct{

int Value;

int Dist;

int AngleNumber;

}MaxValue;

int EnhancedImage::line()

{

//

LONG lWidth = superImage->width;

LONG lHeight = superImage->height;

//

LPSTR lpDIBBits = (char *)LocalAlloc(LHND, lWidth * lHeight);

if (lpDIBBits == NULL)

{

return false ;

}

lpDIBBits = (char *)LocalLock(lpDIBBits);

//

for (int y=0; y<superImage->height; y++)

{

for (int x=0; x<superImage->width; x++)

{

unsigned char point = superImage->data[y*superImage->width+x];

lpDIBBits[lWidth * y + x] = point;

}

}

//

//

// 指向源图像的指针

LPSTR lpSrc;

// 指向缓存图像的指针

LPSTR lpDst;

// 指向变换域的指针

LPSTR lpTrans;

// 图像每行的字节数

LONG lLineBytes;

// 指向缓存DIB图像的指针

LPSTR lpNewDIBBits;

HLOCAL hNewDIBBits;

//指向变换域的指针

LPSTR lpTransArea;

HLOCAL hTransArea;

//变换域的尺寸

int iMaxDist;

int iMaxAngleNumber;

//变换域的坐标

int iDist;

int iAngleNumber;

//循环变量

long i;

long j;

//像素值

unsigned char pixel;

//存储变换域中的两个最大值

MaxValue MaxValue1;

MaxValue MaxValue2;

// 暂时分配内存，以保存新图像

hNewDIBBits = LocalAlloc(LHND, lWidth * lHeight);

if (hNewDIBBits == NULL)

{

// 分配内存失败

return FALSE;

}

// 锁定内存

lpNewDIBBits = (char * )LocalLock(hNewDIBBits);

// 初始化新分配的内存，设定初始值为255

lpDst = (char *)lpNewDIBBits;

memset(lpDst, (BYTE)255, lWidth * lHeight);

//计算变换域的尺寸

//最大距离

iMaxDist = (int) sqrt(lWidth*lWidth + lHeight*lHeight);

//角度从0－180，每格2度

iMaxAngleNumber = 90;

//为变换域分配内存

hTransArea = LocalAlloc(LHND, lWidth * lHeight * sizeof(int));

if (hNewDIBBits == NULL)

{

// 分配内存失败

return FALSE;

}

// 锁定内存

lpTransArea = (char * )LocalLock(hTransArea);

// 初始化新分配的内存，设定初始值为0

lpTrans = (char *)lpTransArea;

memset(lpTrans, 0, lWidth * lHeight * sizeof(int));

// 计算图像每行的字节数

for(j = 0; j <lHeight; j++)

{

for(i = 0;i <lWidth; i++)

{

// 指向源图像倒数第j行，第i个象素的指针

lpSrc = (char *)lpDIBBits + lWidth * j + i;

//取得当前指针处的像素值，注意要转换为unsigned char型

pixel = (unsigned char)*lpSrc;

//目标图像中含有0和255外的其它灰度值

if(pixel != 255 && *lpSrc != 0)

return FALSE;

//如果是黑点，则在变换域的对应各点上加1

if(pixel == 0)

{

//注意步长是2度

for(iAngleNumber=0; iAngleNumber<iMaxAngleNumber; iAngleNumber++)

{

iDist = (int) fabs(i*cos(iAngleNumber*2*pi/180.0) + j*sin(iAngleNumber*2*pi/180.0));

//变换域的对应点上加1

*(lpTransArea+iDist*iMaxAngleNumber+iAngleNumber) = *(lpTransArea+iDist*iMaxAngleNumber+iAngleNumber) +1;

}

}

}

}

//找到变换域中的两个最大值点

MaxValue1.Value=0;

MaxValue2.Value=0;

//找到第一个最大值点

for (iDist=0; iDist<iMaxDist;iDist++)

{

for(iAngleNumber=0; iAngleNumber<iMaxAngleNumber; iAngleNumber++)

{

if((int)*(lpTransArea+iDist*iMaxAngleNumber+iAngleNumber)>MaxValue1.Value)

{

MaxValue1.Value = (int)*(lpTransArea+iDist*iMaxAngleNumber+iAngleNumber);

MaxValue1.Dist = iDist;

MaxValue1.AngleNumber = iAngleNumber;

}

}

}

//将第一个最大值点附近清零

for (iDist = -9;iDist < 10;iDist++)

{

for(iAngleNumber=-1; iAngleNumber<2; iAngleNumber++)

{

if(iDist+MaxValue1.Dist>=0 && iDist+MaxValue1.Dist<iMaxDist && iAngleNumber+MaxValue1.AngleNumber>=0 && iAngleNumber+MaxValue1.AngleNumber<=iMaxAngleNumber)

{

*(lpTransArea+(iDist+MaxValue1.Dist)*iMaxAngleNumber+(iAngleNumber+MaxValue1.AngleNumber))=0;

}

}

}

//找到第二个最大值点

for (iDist=0; iDist<iMaxDist;iDist++)

{

for(iAngleNumber=0; iAngleNumber<iMaxAngleNumber; iAngleNumber++)

{

if((int)*(lpTransArea+iDist*iMaxAngleNumber+iAngleNumber)>MaxValue2.Value)

{

MaxValue2.Value = (int)*(lpTransArea+iDist*iMaxAngleNumber+iAngleNumber);

MaxValue2.Dist = iDist;

MaxValue2.AngleNumber = iAngleNumber;

}

}

}

//判断两直线是否平行

if(abs(MaxValue1.AngleNumber-MaxValue2.AngleNumber)<=2)

{

//两直线平行，在缓存图像中重绘这两条直线

for(j = 0; j <lHeight; j++)

{

for(i = 0;i <lWidth; i++)

{

// 指向缓存图像倒数第j行，第i个象素的指针

lpDst = (char *)lpNewDIBBits + lLineBytes * j + i;

//如果该点在某一条平行直线上，则在缓存图像上将该点赋为黑

//在第一条直线上

iDist = (int) fabs(i*cos(MaxValue1.AngleNumber*2*pi/180.0) + j*sin(MaxValue1.AngleNumber*2*pi/180.0));

if (iDist == MaxValue1.Dist)

*lpDst = (unsigned char)0;

//在第二条直线上

iDist = (int) fabs(i*cos(MaxValue2.AngleNumber*2*pi/180.0) + j*sin(MaxValue2.AngleNumber*2*pi/180.0));

if (iDist == MaxValue2.Dist)

*lpDst = (unsigned char)0;

}

}

}

// 复制腐蚀后的图像

memcpy(lpDIBBits, lpNewDIBBits, lWidth * lHeight);

// 释放内存

LocalUnlock(hNewDIBBits);

LocalFree(hNewDIBBits);

// 释放内存

LocalUnlock(hTransArea);

LocalFree(hTransArea);

//

//

for (int yy=0; yy<superImage->height; yy++)

{

for (int xx=0; xx<superImage->width; xx++)

{

unsigned char point = lpDIBBits[lWidth * yy + xx];

superImage->data[yy*superImage->width+xx] = point;

}

}

//

LocalUnlock(lpDIBBits);

LocalFree(lpDIBBits);

// 返回

return TRUE;

}

int EnhancedImage::roii()

{

int minX = superImage->width;

int minY = superImage->height;

int maxX = 0;

int maxY = 0;

//

for (int y=0; y<superImage->height; y++)

{

for (int x=0; x<superImage->width; x++)

{

unsigned char point = superImage->data[y*superImage->width+x];

if(point==0)

{

if(x<minX)

{

minX = x;

}

if(y<minY)

{

minY = y;

}

//

if(x>maxX)

{

maxX = x;

}

if(y>maxY)

{

maxY = y;

}

}

}

}

//

if(minX>maxX)

{

minX=maxX=0;

}

if(minY>maxY)

{

minY=maxY=0;

}

//

if(minX>0)

minX = minX -1;

if(minY>0)

minY = minY -1;

if(maxX<superImage->width-1)

maxX= maxX+1;

if(maxY<superImage->height-1)

maxY = maxY+1;

//

int tmpW = maxX - minX+1;

int tmpH = maxY - minY+1;

SuperImage<Pixel>* tmpD = new SuperImage<Pixel>(tmpW,tmpH);

//

for(int y2=minY,y3=0;y3<tmpH;y2++,y3++)

{

for(int x2=minX,x3=0;x3<tmpW;x2++,x3++)

{

Pixel pixel = superImage->data[y2*superImage->width+x2];

tmpD->data[y3*tmpW+x3] = pixel;

}

}

//

if(superImage)

{

delete superImage;

superImage = NULL;

}

//

superImage = tmpD;

//

return 0;

};

/*************************************************************************

*

* 函数名称：

* TraceDIB()

*

* 参数:

* LPSTR lpDIBBits - 指向源DIB图像指针

* LONG lWidth - 源图像宽度（象素数，必须是4的倍数）

* LONG lHeight - 源图像高度（象素数）

* 返回值:

* BOOL - 运算成功返回TRUE，否则返回FALSE。

*

* 说明:

* 该函数用于对图像进行轮廓跟踪运算。

*

* 要求目标图像为只有0和255两个灰度值的灰度图像。

************************************************************************/

int EnhancedImage::trac()

{

typedef struct

{

int Height;

int Width;

}Point;

//

LONG lWidth = superImage->width;

LONG lHeight = superImage->height;

//

LPSTR lpDIBBits = (char *)LocalAlloc(LHND, lWidth * lHeight);

if (lpDIBBits == NULL)

{

return false ;

}

lpDIBBits = (char *)LocalLock(lpDIBBits);

//

for (int y=0; y<superImage->height; y++)

{

for (int x=0; x<superImage->width; x++)

{

unsigned char point = superImage->data[y*superImage->width+x];

lpDIBBits[lWidth * y + x] = point;

}

}

//

//

// 指向源图像的指针

LPSTR lpSrc;

// 指向缓存图像的指针

LPSTR lpDst;

// 指向缓存DIB图像的指针

LPSTR lpNewDIBBits;

HLOCAL hNewDIBBits;

//循环变量

long i;

long j;

//像素值

unsigned char pixel;

//是否找到起始点及回到起始点

bool bFindStartPoint;

//是否扫描到一个边界点

bool bFindPoint;

//起始边界点与当前边界点

Point StartPoint,CurrentPoint;

//八个方向和起始扫描方向

int Direction[8][2]={{-1,1},{0,1},{1,1},{1,0},{1,-1},{0,-1},{-1,-1},{-1,0}};

int BeginDirect;

// 图像每行的字节数

//LONG lLineBytes;

// 计算图像每行的字节数

//lLineBytes = WIDTHBYTES(lWidth * 8);

// 暂时分配内存，以保存新图像

hNewDIBBits = LocalAlloc(LHND, lWidth * lHeight);

if (hNewDIBBits == NULL)

{

// 分配内存失败

return FALSE;

}

// 锁定内存

lpNewDIBBits = (char * )LocalLock(hNewDIBBits);

// 初始化新分配的内存，设定初始值为255

lpDst = (char *)lpNewDIBBits;

memset(lpDst, (BYTE)255, lWidth * lHeight);

//先找到最左上方的边界点

bFindStartPoint = false;

for (j = 0;j < lHeight && !bFindStartPoint;j++)

{

for(i = 0;i < lWidth && !bFindStartPoint;i++)

{

// 指向源图像倒数第j行，第i个象素的指针

lpSrc = (char *)lpDIBBits + lWidth * j + i;

//取得当前指针处的像素值，注意要转换为unsigned char型

pixel = (unsigned char)*lpSrc;

if(pixel == 0)

{

bFindStartPoint = true;

StartPoint.Height = j;

StartPoint.Width = i;

// 指向目标图像倒数第j行，第i个象素的指针

lpDst = (char *)lpNewDIBBits + lWidth * j + i;

*lpDst = (unsigned char)0;

}

}

}

//由于起始点是在左下方，故起始扫描沿左上方向

BeginDirect = 0;

//跟踪边界

bFindStartPoint = false;

//从初始点开始扫描

CurrentPoint.Height = StartPoint.Height;

CurrentPoint.Width = StartPoint.Width;

while(!bFindStartPoint)

{

bFindPoint = false;

while(!bFindPoint)

{

//沿扫描方向查看一个像素

lpSrc = (char *)lpDIBBits + lWidth * ( CurrentPoint.Height + Direction[BeginDirect][1]) + (CurrentPoint.Width + Direction[BeginDirect][0]);

pixel = (unsigned char)*lpSrc;

if(pixel == 0)

{

bFindPoint = true;

CurrentPoint.Height = CurrentPoint.Height + Direction[BeginDirect][1];

CurrentPoint.Width = CurrentPoint.Width + Direction[BeginDirect][0];

if(CurrentPoint.Height == StartPoint.Height && CurrentPoint.Width == StartPoint.Width)

{

bFindStartPoint = true;

}

lpDst = (char *)lpNewDIBBits + lWidth * CurrentPoint.Height + CurrentPoint.Width;

*lpDst = (unsigned char)0;

//扫描的方向逆时针旋转两格

BeginDirect--;

if(BeginDirect == -1)

BeginDirect = 7;

BeginDirect--;

if(BeginDirect == -1)

BeginDirect = 7;

}

else

{

//扫描方向顺时针旋转一格

BeginDirect++;

if(BeginDirect == 8)

BeginDirect = 0;

}

}

}

// 复制腐蚀后的图像

memcpy(lpDIBBits, lpNewDIBBits, lWidth * lHeight);

// 释放内存

LocalUnlock(hNewDIBBits);

LocalFree(hNewDIBBits);

//

//

for (int yy=0; yy<superImage->height; yy++)

{

for (int xx=0; xx<superImage->width; xx++)

{

unsigned char point = lpDIBBits[lWidth * yy + xx];

superImage->data[yy*superImage->width+xx] = point;

}

}

//

LocalUnlock(lpDIBBits);

LocalFree(lpDIBBits);

// 返回

return TRUE;

}

int EnhancedImage::edge()

{

//

LONG lWidth = superImage->width;

LONG lHeight = superImage->height;

//

LPSTR lpDIBBits = (char *)LocalAlloc(LHND, lWidth * lHeight);

if (lpDIBBits == NULL)

{

return false ;

}

lpDIBBits = (char *)LocalLock(lpDIBBits);

//

for (int y=0; y<superImage->height; y++)

{

for (int x=0; x<superImage->width; x++)

{

unsigned char point = superImage->data[y*superImage->width+x];

lpDIBBits[lWidth * y + x] = point;

}

}

//

//

// 指向源图像的指针

LPSTR lpSrc;

// 指向缓存图像的指针

LPSTR lpDst;

// 指向缓存DIB图像的指针

LPSTR lpNewDIBBits;

HLOCAL hNewDIBBits;

//循环变量

long i;

long j;

unsigned char n,e,s,w,ne,se,nw,sw;

//像素值

unsigned char pixel;

// 暂时分配内存，以保存新图像

hNewDIBBits = LocalAlloc(LHND, lWidth * lHeight);

if (hNewDIBBits == NULL)

{

// 分配内存失败

return FALSE;

}

// 锁定内存

lpNewDIBBits = (char * )LocalLock(hNewDIBBits);

// 初始化新分配的内存，设定初始值为255

lpDst = (char *)lpNewDIBBits;

memset(lpDst, (BYTE)255, lWidth * lHeight);

for(j = 1; j <lHeight-1; j++)

{

for(i = 1;i <lWidth-1; i++)

{

// 指向源图像倒数第j行，第i个象素的指针

lpSrc = (char *)lpDIBBits + lWidth * j + i;

// 指向目标图像倒数第j行，第i个象素的指针

lpDst = (char *)lpNewDIBBits + lWidth * j + i;

//取得当前指针处的像素值，注意要转换为unsigned char型

pixel = (unsigned char)*lpSrc;

if(pixel == 0)

{

*lpDst = (unsigned char)0;

nw = (unsigned char)*(lpSrc + lWidth -1);

n = (unsigned char)*(lpSrc + lWidth );

ne = (unsigned char)*(lpSrc + lWidth +1);

w = (unsigned char)*(lpSrc -1);

e = (unsigned char)*(lpSrc +1);

sw = (unsigned char)*(lpSrc - lWidth -1);

s = (unsigned char)*(lpSrc - lWidth );

se = (unsigned char)*(lpSrc - lWidth +1);

//如果相邻的八个点都是黑点

if(nw+n+ne+w+e+sw+s+se==0)

{

*lpDst = (unsigned char)255;

}

}

}

}

// 复制腐蚀后的图像

memcpy(lpDIBBits, lpNewDIBBits, lWidth * lHeight);

// 释放内存

LocalUnlock(hNewDIBBits);

LocalFree(hNewDIBBits);

//

//

for (int yy=0; yy<superImage->height; yy++)

{

for (int xx=0; xx<superImage->width; xx++)

{

unsigned char point = lpDIBBits[lWidth * yy + xx];

superImage->data[yy*superImage->width+xx] = point;

}

}

//

LocalUnlock(lpDIBBits);

LocalFree(lpDIBBits);

// 返回

return TRUE;

}

int EnhancedImage::thin()

{

//

LONG lWidth = superImage->width;

LONG lHeight = superImage->height;

//

LPSTR lpDIBBits = (char *)LocalAlloc(LHND, lWidth * lHeight);

if (lpDIBBits == NULL)

{

return false ;

}

lpDIBBits = (char *)LocalLock(lpDIBBits);

//

for (int y=0; y<superImage->height; y++)

{

for (int x=0; x<superImage->width; x++)

{

unsigned char point = superImage->data[y*superImage->width+x];

lpDIBBits[lWidth * y + x] = point;

}

}

//

//

LPSTR lpSrc;

LPSTR lpDst;

LPSTR lpNewDIBBits;

HLOCAL hNewDIBBits;

BOOL bModified;

long i,j,m,n;

BOOL con1;

BOOL con2;

BOOL con3;

BOOL con4;

unsigned char nCount;

unsigned char pixel;

unsigned char ne[5][5];

hNewDIBBits = LocalAlloc(LHND, lWidth * lHeight);

if (hNewDIBBits == NULL)

{

return false ;

}

lpNewDIBBits = (char * )LocalLock(hNewDIBBits);

// 初始化新分配的内存，设定初始值为255

lpDst = (char *)lpNewDIBBits;

memset(lpDst, (BYTE)255, lWidth * lHeight);

bModified = TRUE;

while(bModified)

{

bModified = FALSE;

lpDst = (char *)lpNewDIBBits;

memset(lpDst, (BYTE)255, lWidth * lHeight);

for(j = 2; j <lHeight-2; j++)

{

for(i = 2;i <lWidth-2; i++)

{

con1 = FALSE;

con2 = FALSE;

con3 = FALSE;

con4 = FALSE;

lpSrc = (char *)lpDIBBits + lWidth * j + i;

lpDst = (char *)lpNewDIBBits + lWidth * j + i;

pixel = (unsigned char)*lpSrc;

if(pixel != 255 && *lpSrc != 0)

{

continue;

}

else if(pixel == 255)

{

continue;

}

//白色用0代表，黑色用1代表

for (m = 0;m < 5;m++ )

{

for (n = 0;n < 5;n++)

{

ne[m]
=(255 - (unsigned char)*(lpSrc + ((4 - m) - 2)*lWidth + n - 2 )) / 255;

}

}

//判断2<=NZ(P1)<=6

nCount = ne[1][1] + ne[1][2] + ne[1][3]

+ ne[2][1] + ne[2][3]

+ ne[3][1] + ne[3][2] + ne[3][3];

if ( nCount >= 2 && nCount <=6)

{

con1 = TRUE;

}

//判断Z0(P1)=1

nCount = 0;

if (ne[1][2] == 0 && ne[1][1] == 1)

nCount++;

if (ne[1][1] == 0 && ne[2][1] == 1)

nCount++;

if (ne[2][1] == 0 && ne[3][1] == 1)

nCount++;

if (ne[3][1] == 0 && ne[3][2] == 1)

nCount++;

if (ne[3][2] == 0 && ne[3][3] == 1)

nCount++;

if (ne[3][3] == 0 && ne[2][3] == 1)

nCount++;

if (ne[2][3] == 0 && ne[1][3] == 1)

nCount++;

if (ne[1][3] == 0 && ne[1][2] == 1)

nCount++;

if (nCount == 1)

con2 = TRUE;

//判断P2*P4*P6=0 or Z0(p4)!=1

if (ne[1][2]*ne[2][1]*ne[3][2] == 0)

{

con3 = TRUE;

}

else

{

nCount = 0;

if (ne[1][1] == 0 && ne[1][0] == 1)

nCount++;

if (ne[1][0] == 0 && ne[2][0] == 1)

nCount++;

if (ne[2][0] == 0 && ne[3][0] == 1)

nCount++;

if (ne[3][0] == 0 && ne[3][1] == 1)

nCount++;

if (ne[3][1] == 0 && ne[3][2] == 1)

nCount++;

if (ne[3][2] == 0 && ne[2][2] == 1)

nCount++;

if (ne[2][2] == 0 && ne[1][2] == 1)

nCount++;

if (ne[1][2] == 0 && ne[1][1] == 1)

nCount++;

if (nCount != 1)

con3 = TRUE;

}

//判断P2*P4*P8=0 or Z0(p2)!=1

if (ne[1][2]*ne[2][1]*ne[2][3] == 0)

{

con4 = TRUE;

}

else

{

nCount = 0;

if (ne[0][2] == 0 && ne[0][1] == 1)

nCount++;

if (ne[0][1] == 0 && ne[1][1] == 1)

nCount++;

if (ne[1][1] == 0 && ne[2][1] == 1)

nCount++;

if (ne[2][1] == 0 && ne[2][2] == 1)

nCount++;

if (ne[2][2] == 0 && ne[2][3] == 1)

nCount++;

if (ne[2][3] == 0 && ne[1][3] == 1)

nCount++;

if (ne[1][3] == 0 && ne[0][3] == 1)

nCount++;

if (ne[0][3] == 0 && ne[0][2] == 1)

nCount++;

if (nCount != 1)

con4 = TRUE;

}

if(con1 && con2 && con3 && con4)

{

*lpDst = (unsigned char)255;

bModified = TRUE;

}

else

{

*lpDst = (unsigned char)0;

}

}

}

memcpy(lpDIBBits, lpNewDIBBits, lWidth * lHeight);

}

memcpy(lpDIBBits, lpNewDIBBits, lWidth * lHeight);

LocalUnlock(hNewDIBBits);

LocalFree(hNewDIBBits);

//

//

for (int yy=0; yy<superImage->height; yy++)

{

for (int xx=0; xx<superImage->width; xx++)

{

unsigned char point = lpDIBBits[lWidth * yy + xx];

superImage->data[yy*superImage->width+xx] = point;

}

}

//

LocalUnlock(lpDIBBits);

LocalFree(lpDIBBits);

}

int EnhancedImage::tidy()

{

//一个更好的算法，是要求整理之后，还保证原来的联通性，现在还不够好

int h = this->superImage->height;

int w = this->superImage->width;

short* src = this->superImage->data;

//

for (int y=0; y<h; y++)

{

for (int x=0; x<w; x++)

{

unsigned char o = src[w*(y)+(x)];

//

unsigned char u = -1;

unsigned char ur = -1;

unsigned char r = -1;

unsigned char br = -1;

unsigned char b = -1;

unsigned char bl = -1;

unsigned char l = -1;

unsigned char ul = -1;

//

if(y<h)

{

u = src[w*(y+1)+(x)];

}

if(y<h && x< w)

{

ur =src[w*(y+1)+(x+1)];

}

if(x<w)

{

r=src[w*(y)+(x+1)];

}

if(y>0 && x<w)

{

br = src[w*(y-1)+(x+1)];

}

if(y>0)

{

b = src[w*(y-1)+(x)];

}

if(y>0 && x>0)

{

bl = src[w*(y-1)+(x-1)];

}

if(x>0)

{

l = src[w*(y)+(x-1)];

}

if(y<h && x>0)

{

ul = src[w*(y+1)+(x-1)];

}

//

if(o==0)

{

if(r==0 && u==0 && br==0)

{

src[w*(y)+(x+1)] = 255;

}

if(r==0 && ur==0 && r==0)

{

src[w*(y)+(x+1)] = 255;

}

if(r==0 && ul==0 && br==0)

{

src[w*(y)+(x+1)] = 255;

}

//

if(l==0 && u==0 && bl==0)

{

src[w*(y)+(x-1)] = 255;

}

if(l==0 && u==0 && ur==0)

{

src[w*(y)+(x-1)] = 255;

}

if(l==0 && bl==0 && ur==0)

{

src[w*(y)+(x-1)] = 255;

}

if(l==0 && bl==0 && r==0)

{

src[w*(y)+(x-1)] = 255;

}

if(l==0 && ul==0 && r==0)

{

src[w*(y)+(x-1)] = 255;

}

if(l==0 && ul==0 && br==0)

{

src[w*(y)+(x-1)] = 255;

}

}

}

}

return 0;

}

int EnhancedImage::kerf()

{

int w = this->superImage->width;

int h = this->superImage->height;

short* src = this->superImage->data;

//

SuperImage<Pixel>* tmpD = new SuperImage<Pixel>(w,h);

short* tgt = tmpD->data;

//

for (int y=0; y<h; y++)

{

for (int x=0; x<w; x++)

{

int count = 0;

unsigned char p = src[y*w+x];

tgt[y*w+x] = p;

//

if(y<h && src[w*(y+1)+(x)] == 0)

{

count = count + 1;

}

if(y<h && x< w && src[w*(y+1)+(x+1)] == 0)

{

count = count + 1;

}

if(x<w && src[w*(y)+(x+1)] == 0)

{

count = count + 1;

}

if(y>0 && x<w && src[w*(y-1)+(x+1)] == 0)

{

count = count + 1;

}

if(y>0 && src[w*(y-1)+(x)] == 0)

{

count = count + 1;

}

if(y>0 && x>0 && src[w*(y-1)+(x-1)] == 0)

{

count = count + 1;

}

if(x>0 && src[w*(y)+(x-1)] == 0)

{

count = count + 1;

}

if(y<h && x>0 && src[w*(y+1)+(x-1)] == 0)

{

count = count + 1;

}

//

if(p == 0 && count > 2)

{

tgt[y*w+x] = -1;

}

}

}

//

if(superImage)

{

delete superImage;

superImage = NULL;

}

//

superImage = tmpD;

//

return 0;

}

int EnhancedImage::join()

{

return 0;

}

//AntiCaptchaPart1.cpp

#include <stdio.h>

#include <string>

#include <windows.h>

#include "common.h"

//

void process(char* loadPathName,char* tempPathName)

{

EnhancedImage otsuImage;

otsuImage.load(loadPathName);

if(1)

{

char convPathName[MAX_PATH];

sprintf(convPathName,"%s%s",tempPathName,".001.conv.bmp");

otsuImage.save(convPathName);

}

if(1)

{

char binvPathName[MAX_PATH];

sprintf(binvPathName,"%s%s",tempPathName,".002.binv.bmp");

otsuImage.binv();

otsuImage.save(binvPathName);

}

if(1)

{

char otsuPathName[MAX_PATH];

sprintf(otsuPathName,"%s%s",tempPathName,".003.otsu.bmp");

otsuImage.otsu();

otsuImage.save(otsuPathName);

}

if(0)

{

char linePathName[MAX_PATH];

sprintf(linePathName,"%s%s",tempPathName,".004.line.bmp");

otsuImage.line();

otsuImage.save(linePathName);

}

if(1)

{

char roiiPathName[MAX_PATH];

sprintf(roiiPathName,"%s%s",tempPathName,".005.roii.bmp");

otsuImage.roii();

otsuImage.save(roiiPathName);

}

EnhancedImage tracImage;

tracImage.copy(&otsuImage);

if(1)

{

char tracPathName[MAX_PATH];

sprintf(tracPathName,"%s%s",tempPathName,".006.trac.bmp");

tracImage.trac();

tracImage.save(tracPathName);

}

//

EnhancedImage edgeImage;

edgeImage.copy(&otsuImage);

if(1)

{

char edgePathName[MAX_PATH];

sprintf(edgePathName,"%s%s",tempPathName,".007.edge.bmp");

edgeImage.edge();

edgeImage.save(edgePathName);

}

//

EnhancedImage thinImage;

thinImage.copy(&otsuImage);

if(1)

{

char thinPathName[MAX_PATH];

sprintf(thinPathName,"%s%s",tempPathName,".008.thin.bmp");

thinImage.thin();

thinImage.save(thinPathName);

}

if(1)

{

char tidyPathName[MAX_PATH];

sprintf(tidyPathName,"%s%s",tempPathName,".009.tidy.bmp");

thinImage.tidy();

thinImage.save(tidyPathName);

}

EnhancedImage kerfImage;

kerfImage.copy(&thinImage);

if(1)

{

char kerfPathName[MAX_PATH];

sprintf(kerfPathName,"%s%s",tempPathName,".010.kerf.bmp");

kerfImage.kerf();

kerfImage.save(kerfPathName);

}

EnhancedImage filmImage;

filmImage.copy(&kerfImage);

if(1)

{

char filmPathName[MAX_PATH];

sprintf(filmPathName,"%s%s",tempPathName,".011.film.bmp");

filmImage.film(&edgeImage);

filmImage.save(filmPathName);

}

}

//

void travel()

{

char homePathName[MAX_PATH];

GetCurrentDirectory(MAX_PATH,homePathName);

//

SetCurrentDirectory(homePathName);

SetCurrentDirectory(".\\output");

WIN32_FIND_DATA findDataDelete;

HANDLE hHandleDelete = FindFirstFile("*.*", &findDataDelete);

int hasNextFileDelete = (hHandleDelete != INVALID_HANDLE_VALUE);

while (hasNextFileDelete != 0)

{

char deletePathName[MAX_PATH];

GetFullPathName(findDataDelete.cFileName, MAX_PATH, deletePathName, NULL);

printf("Delete %s\n",deletePathName);

DeleteFile(deletePathName);

hasNextFileDelete = FindNextFile(hHandleDelete, &findDataDelete);

}

if(hHandleDelete != INVALID_HANDLE_VALUE)

{

FindClose(hHandleDelete);

}

//

//

SetCurrentDirectory(homePathName);

SetCurrentDirectory(".\\sample");

WIN32_FIND_DATA findData;

HANDLE hFindHandle = FindFirstFile("*.jpg", &findData);

int hasNextFile = (hFindHandle != INVALID_HANDLE_VALUE);

while (hasNextFile != 0)

{

char loadPathName[MAX_PATH];

GetFullPathName(findData.cFileName, MAX_PATH, loadPathName, NULL);

//

char tempPathName[MAX_PATH];

sprintf(tempPathName,"%s",loadPathName);

for(int i=strlen(tempPathName);i>=0;i--)

{

if(tempPathName[i]=='\\')

{

break;

}

else

{

tempPathName[i]='\0';

}

}

strcat(tempPathName,"..\\output\\");

strcat(tempPathName,findData.cFileName);

//

printf("Process %s to %s\n",loadPathName,tempPathName);

process(loadPathName,tempPathName);

//

//

hasNextFile = FindNextFile(hFindHandle, &findData);

}

if(hFindHandle != INVALID_HANDLE_VALUE)

{

FindClose(hFindHandle);

}

}

//

void main(int argc, char* argv[])

{

printf("Anti Captcha ...\n");

travel();

printf("Anti Captcha !!!\n");

}