精华内容
下载资源
问答
  • 最新版全套个体营业执照PSD模板 作品简介:个体营业执照模板 位图, CMYK格式高清大图,使用软件为 Photoshop(.psd)营业执照模版 超清原版设计、更清晰、容易修改、采用防伪底纹,分层设计PSD模板。 执照规格为:...

    最新版全套个体营业执照PSD模板

    作品简介:个体营业执照模板 位图, CMYK格式高清大图,使用软件为 Photoshop(.psd)营业执照模版

    超清原版设计、更清晰、容易修改、采用防伪底纹,分层设计PSD模板。

    执照规格为:宽:3389mm 高:5340mm 分辨率为:300 

    下载地址:  http://www.ufaxian.com/thread-pshlaamor-1-1.html

    模板任意修改:文字 底纹 水印 边框 印章 烫金文字等。

    文件以压缩方式打包 包含:PSD模板 电子印章PSD模板 字体包等

    作品简介:个体营业执照模板 位图, CMYK格式高清大图,使用软件为 Photoshop(.psd)营业执照模版

    超清原版设计、更清晰、容易修改、采用防伪底纹,分层设计PSD模板。

    执照规格为:宽:3389mm 高:5340mm 分辨率为:300 

    素材来源:http://www.ufaxian.com/post/pshlaamor.html

    转载于:https://www.cnblogs.com/zaaakkmnb12/p/9532148.html

    展开全文
  • 企业工商营业执照副本PSD模板下载地址: http://www.qijieworld.com/thread-1911181-1-1.html 模板为psd格式内容可编辑修改,需使用 Photoshop CS5等软件打开 仅供参考学习使用!切勿当作驾驶证使用!造成的一切...

    企业工商营业执照副本PSD模板下载地址:
    http://www.qijieworld.com/thread-1911181-1-1.html

    模板为psd格式内容可编辑修改,需使用 Photoshop CS5等软件打开

    仅供参考学习使用!切勿当作驾驶证使用!造成的一切后果概不负责!!
    这里写图片描述
    详细参数:格式:PSD 模式:RGB 体积:压缩前:84M,压缩后:37M

    打包方式:压缩包,内含附件:所有用到字体+PSD文件+说明文档

    机动车行驶证PSD模板下载地址: http://www.qijieworld.com/thread-1911181-1-1.html

    展开全文
  • 最新网吧营业执照代办网吧工商执照申请书DOC新版文档.docx
  • #include "opencv2/imgproc/imgproc.hpp" #include "opencv2/highgui/highgui.hpp" #include <opencv2/opencv.hpp> #include <iostream&...#include ...
    #include "opencv2/imgproc/imgproc.hpp"
    #include "opencv2/highgui/highgui.hpp"
    #include <opencv2/opencv.hpp>
    #include <iostream>
    #include <fstream>
    #include <stdio.h>
    #include <algorithm>
    #include <iterator>
    #include <vector>
    #include <math.h>
    #include <vector>
    #include <assert.h>
    #include <string.h>
    #include <dirent.h>
    #include <string>
    #include <sys/stat.h>
    #include <sys/types.h>
    #include "classification.cpp"
    using namespace std;
    using namespace cv;
    
    //hanshu shengming
    class Cuter
    {
    public:
    Cuter();
    Mat newThreshold(Mat img);
    
    vector<RotatedRect> findTextRegion(Mat img);
    
    int  detect(Mat tmp,int type,int &title_right);
    //将部分图片切成行
    bool vcut(Mat srcImage,char *name);
    
    Mat append(Mat src);
    
    Mat hcut_spare(Mat srcImage);
    
    bool hcut_big(Mat srcImage,char *name);
    
    bool hcut_small();
    
    bool hcut_title();
    
    Mat preprocess(Mat gray,int type);
    
    bool findtitle_cut(Mat src,char *name);
    
    //void linecut(Mat img,char *name,int lineRank,int ranks);
    
    bool hcut_search(Mat srcImage,char *name,int lineRank);
    
    bool hcut_digit_single(Mat roiImg);
    
    Mat merge(Mat leftImg,Mat rightImg);
    
    void digit_classify();
    
    void word_classify(int avg_width);
    
    void linecut(int avg_width);
    
    bool isDigit(string result)
    {
    	if(result=="1"||result=="2"||result=="3"||result=="0"||result=="4"||result=="5"||result=="6"||result=="7"||result=="8"||result=="9"||result=="0")
    	return true;
    	else return false;
    }
    
    void show()
    {
    	cout<<"数字的行数 "<<digit_line<<endl;
    	for(int i=0;i<singleList.size();i++)
    	{
    		char savePath[64];
    		sprintf(savePath,"singleList/%d.png",tmpRank++);
    		imwrite(savePath,singleList[i]);
    	}
    }
    
    void writeClassifyList()
    {
    	for(int i=0;i<classifyList.size();i++)
    	{
    		char savePath[64];
    		sprintf(savePath,"classifyList/%d.png",tmpRank2++);
    		imwrite(savePath,classifyList[i]);
    	}
    }
    
    bool printResult(char *picName,bool isSuccess)
    {
    	int cutPos=0;
    	for(int i=strlen(picName);i>=0;i--)
    	{
    		if(picName[i]=='/')
    		{	
    			cutPos=i;
    			break;
    		}
    	}
    	string name;
    	for(int i=cutPos+1;i<strlen(picName);i++)
    	{
    		name+=picName[i];
    	}
    
    
    	FILE *fpRead=fopen("result_two","a");
    	if(digitResult.size()<=12||wordResult.size()<=0||!isSuccess)
    	{
    		string tmpResult;
    		tmpResult=tmpResult+name+" 识别错误  识别错误";
    		//out<<name<<" 识别错误 "<<"识别错误"<<endl;
    		char saveResult[256];
    		strcpy(saveResult,tmpResult.c_str());
    		fprintf(fpRead,"%s\n",saveResult);
    		fclose(fpRead);
    		return false;
    	}
    	string tmpResult;
    	char saveResult[256];
    	string digitAll;
    	for(int i=0;i<digitResult.size();i++)
    	{
    		string result=digitResult[i];
    		digitAll+=result;
    		/*
    		if(result=="A"||result=="B"||result=="C"||result=="D"||result=="E"||result=="F"||result=="G"||result=="H"||result=="I"||result=="J"||result=="K"||result=="L"||result=="M"||result=="N"||result=="O"||result=="P"||result=="Q"||result=="R"||result=="S"||result=="T"||result=="V"||result=="U"||result=="W"||result=="X"||result=="Y"||result=="Z")break;
    		*/
    		
    	}
    	cout<<digitAll<<endl;
    	string wordAll;
    	int endPos=0;
    	string add;
    	
    	for(int i=0;i<wordResult.size();i++)
    	{
    		string result=wordResult[i];
    		if(result=="有")
    		{
    			add="有限公司";
    			endPos=i-1;
    			break;
    		}
    		if(result=="限")
    		{
    			add="限公司";
    			endPos=i-2;
    			break;
    		}
    		if(result=="公")
    		{
    			add="公司";
    			endPos=i-3;
    			break;
    		}
    		if(result=="司")
    		{
    			add="司";
    			endPos=i-4;
    			break;
    		}
    		if(result=="厂")
    		{
    			add="厂";
    			endPos=i-1;
    			break;
    		}
    	}
    	if(endPos<0)
    	{
    		//cout<<"识别矫正错误"<<endl;
    		return false;
    	}
    	for(int i=0;i<=endPos;i++)
    	{
    		string result=wordResult[i];
    		wordAll+=result;
    	}
    	wordAll+=add;
    	cout<<wordAll<<endl;
    	tmpResult=tmpResult+name+" "+digitAll+" "+wordAll;
    	strcpy(saveResult,tmpResult.c_str());
    	fprintf(fpRead,"%s\n",saveResult);
    	fclose(fpRead);
    	return true;
    }
    
    Mat myRotate(Mat src,int rotateType)
    {
    	if(rotateType==1)
    	{
    		// 矩阵转置
    		transpose(src, src);
    		//0: 沿X轴翻转; >0: 沿Y轴翻转; <0: 沿X轴和Y轴翻转
    		flip(src, src, 1);// 翻转模式,flipCode == 0垂直翻转(沿X轴翻转),flipCode>0水平翻转(沿Y轴翻转),flipCode<0水平垂直翻转(先沿X轴翻转,再沿Y轴翻转,等价于旋转180°)
    		return src;
    	}
    	else if(rotateType==2)
    	{
    		//0: 沿X轴翻转; >0: 沿Y轴翻转; <0: 沿X轴和Y轴翻转
        		flip(src, src, 0);// 翻转模式,flipCode == 0垂直翻转(沿X轴翻转),flipCode>0水平翻转(沿Y轴翻转),flipCode<0水平垂直翻转(先沿X轴翻转,再沿Y轴翻转,等价于旋转180°)
        		flip(src, src, 1);
        		return src;
    	}
    	else if(rotateType==3)
    	{
    		transpose(src, src);// 翻转模式,flipCode == 0垂直翻转(沿X轴翻转),flipCode>0水平翻转(沿Y轴翻转),flipCode<0水平垂直翻转(先沿X轴翻转,再沿Y轴翻转,等价于旋转180°)
        		flip(src, src, 0);
        		return src;
    	}
    	return src;
    }
    
    Mat quzao(Mat src);
    
    void tmplinecut(int avg_width);
    
    Mat getVcutImg()
    {
    	return vcutImg;
    }
    private:
    	vector<double> rateList;
    	Mat vcutImg;
    	int classifyRank;
    	int imageType; //图片类型
    	int digit_line;
    	bool isFirstDigitLine;
    	bool isFirstWordLine;
    	bool hasFindWordLine;
    	int word_line;
    	int currentLine;
    	int currentSingle;
    	int lineDigitNum;
    	int maxLineDigitNum;
    	vector<Mat> lineList;
    	vector<Mat> preLineList;
    	vector<Mat> singleList;
    	vector<Mat> classifyList;
    	vector<string> digitResult;
    	vector<string> wordResult;
    	Classifier *allClassifier;
    	Classifier *digitClassifier;
    	int tmpRank;
    	int tmpRank2;
    	int avg_word_width;
    	/*
    type 0 height>width
         1 width>height && title on the left
         2 width>height && title on the center
      */
    
    };
    
    
    Cuter::Cuter()
    {
    	 hasFindWordLine=false;
    	tmpRank=0;
    	tmpRank2=0;
    	isFirstDigitLine=true;
    	isFirstWordLine=true;
    	maxLineDigitNum=0;
    	classifyRank=0;
    	imageType=-1;
    	digit_line=-1;
    	word_line=-1;
    	currentLine=0;
    	currentSingle=0;
    	string model_file="45-word-new/lenet.prototxt";
    	string trained_file="45-word-new/lenet_solver_iter_405000.caffemodel";
    	string label_file="45-word-new/label";
    	//初始化分类器
    	allClassifier=new Classifier(model_file, trained_file, label_file);
    	
    	model_file="45-digit-model/lenet.prototxt";
    	trained_file="45-digit-model/lenet_solver_iter_45000.caffemodel";
    	label_file="45-digit-model/label";
    	digitClassifier=new Classifier(model_file,trained_file,label_file);
    }
    
    Mat Cuter::newThreshold(Mat img)
    {
    int pixcount=0;
    int height=img.rows;
    int width=img.cols;
    for(int i=0;i<height;i++)
    {
    	for(int j=0;j<width;j++)
    	{
    		pixcount+=img.at<uchar>(i,j);
    	}
    }
    int avg_pix=(pixcount)/(height*width);
    //cout<<avg_pix<<endl;
    threshold(img,img,avg_pix-10,255,CV_THRESH_BINARY);
    return img;
    }
    
    Mat Cuter::preprocess(Mat gray,int type)
    {
        //1.Sobel算子,x方向求梯度
        Mat sobel;
        Sobel(gray, sobel, CV_8U, 2, 1, 5);
    
        //2.二值化
        Mat binary;
       // threshold(sobel, binary, 0, 255, THRESH_OTSU + THRESH_BINARY);
        //imwrite("binary.png",sobel);
        
         //3.膨胀和腐蚀操作核设定
        Mat element1,element2;
        if(type==0)
        {
        	  element1 = getStructuringElement(MORPH_RECT, Size(40, 5));
       	 //控制高度设置可以控制上下行的膨胀程度,例如3比4的区分能力更强,但也会造成漏检
        	  element2 = getStructuringElement(MORPH_RECT, Size(45,3));
        }
        else
        {
        	
       	element1 = getStructuringElement(MORPH_RECT, Size(65, 10));
        	//控制高度设置可以控制上下行的膨胀程度,例如3比4的区分能力更强,但也会造成漏检
        	element2 = getStructuringElement(MORPH_RECT, Size(40,4));
        }
        //4.膨胀一次,让轮廓突出
        Mat dilate1;
        dilate(sobel, dilate1, element2);
    
        //5.腐蚀一次,去掉细节,表格线等。这里去掉的是竖直的线
        Mat erode1;
        erode(dilate1, erode1, element1);
    
        //6.再次膨胀,让轮廓明显一些
        Mat dilate2;
        dilate(erode1, dilate2, element2);
    
        //7.存储中间图片
     return dilate2;
    }
    
    
    vector<RotatedRect> Cuter::findTextRegion(Mat img)
    {
        vector<RotatedRect> rects;
        //1.查找轮廓
        vector<vector<Point> > contours;
        vector<Vec4i> hierarchy;
        findContours(img, contours, hierarchy, RETR_CCOMP, CHAIN_APPROX_SIMPLE, Point(0, 0));
    
        //2.筛选那些面积小的
        for (int i = 0; i < contours.size(); i++)
        {
        	//cout<<"contours.size "<<contours.size()<<endl;
            //计算当前轮廓的面积
            double area = contourArea(contours[i]);
    
            //面积小于1000的全部筛选掉
            
            if (area < 2000)
                continue;
    	
            //轮廓近似,作用较小,approxPolyDP函数有待研究
            double epsilon = 0.001*arcLength(contours[i], true);
            Mat approx;
            approxPolyDP(contours[i], approx, epsilon, true);
    
            //找到最小矩形,该矩形可能有方向
            RotatedRect rect = minAreaRect(contours[i]);
    
            //计算高和宽
            int m_width = rect.boundingRect().width;
            int m_height = rect.boundingRect().height;
    
            //筛选那些太细的矩形,留下扁的
            if (m_height > m_width * 1.2)
                continue;
    
            //符合条件的rect添加到rects集合中
            rects.push_back(rect);
    
        }
        return rects;
    }
    
    int Cuter:: detect(Mat tmp,int type,int &title_right)
    {
       Mat img=tmp.clone();
       int flag=0; //正数 正的,-1反的,0找不到
        //1.转化成灰度图
       Mat gray=img.clone();
    //    cvtColor(img, gray, CV_BGR2GRAY);
    
        //2.形态学变换的预处理,得到可以查找矩形的轮廓
        Mat dilation = preprocess(gray,type);
        //imwrite("dilation.png",dilation);
    
        //3.查找和筛选文字区域
        vector<RotatedRect> rects = findTextRegion(dilation);
    
        //4.用绿线画出这些找到的轮廓
    	RotatedRect rect;
    	RotatedRect aimrect;
    	int aimrect_pos=-1;
    	//cout<<"rect.size()"<<rects.size()<<endl;
    	int topest=10000;
    	int lowest=-1;
    	int leftest=10000;
        for (int i=0;i<rects.size();i++)
       {
    	rect=rects[i];
            Point2f P[4];
            rect.points(P);
            for (int j = 0; j <= 3; j++)
            {
                line(img, P[j], P[(j + 1) % 4], Scalar(0,255,0), 2);
            }
    
    //求矩形的长和高
    	double width= sqrt((P[0].x-P[1].x)*(P[0].x-P[1].x)+(P[0].y-P[1].y)*(P[0].y-P[1].y));
    	double height= sqrt((P[0].x-P[3].x)*(P[0].x-P[3].x)+(P[0].y-P[3].y)*(P[0].y-P[3].y));
    	if(height>width)swap(width,height);
    //找到标题
    
    	int top=P[0].y; //最上面的点
    	int low=P[0].y;
    	int left=P[0].x;
    	int right=P[0].x;
    	for(int j=1;j<4;j++)
    	{
    		if(P[j].y<top)top=P[j].y;
    		if(P[j].y>low)low=P[j].y;
    		if(P[j].x>left)right=P[j].x;
    	}
    	
    	if(!((type==1&&width>=350&&width<=620&&height>=40&&height<=80)||(type==0&&width>=300&&width<=450&&height>=40&&height<=90)||(type==1&&width>=500&&width<=700&&height>=80&&height<=100)))
    	{
    		continue;
    	}
    	if(top<topest)
    	{
    		topest=top;
    		lowest=low;
    		title_right=right;
    	}
            
        }
        //5.显示带轮廓的图像
        imwrite("imgDrawRect.jpg", img);
       // cout<<img.rows<<endl;
        //cout<<topest<<endl;
       // cout<<lowest<<endl;
    
       // waitKey(0);
       //找不到titile
        if((type==0&&lowest>=img.rows/2)||(type==1&&lowest>=img.rows/2))return -1;
        return lowest;
    }
    
    bool Cuter::findtitle_cut(Mat src,char *name)
    {
    	if(src.rows>src.cols)imageType=0;
    	else imageType=1;
    	//too bad image
    	if(src.rows<=800&&src.cols<=800)
    	{
    		//cout<<"can't classify, too small"<<endl;
    		return false;
    	}
    	//I try to find title after images are resized to 1000
    	Mat resizes;
    	int std_length=1000;
    	int cutpos=-1;
    	int title_right;
    	if(imageType==0)
    	
    	{
    		double rate=src.rows*1.0/std_length;
    		resize(src,resizes,Size(int(src.cols/rate),std_length),0,0,INTER_LINEAR);
    		Mat dst=newThreshold(resizes);
    		cutpos=detect(dst,0,title_right);
    	}
    	else
    	{
    		double rate=src.cols*1.0/std_length;
    		resize(src,resizes,Size(std_length,int(src.rows/rate)),0,0,INTER_LINEAR);
    		Mat dst=newThreshold(resizes);
    		cutpos=detect(dst,1,title_right);
    	}
    	//can't find title
    	if(cutpos==-1)return false;
    	
    	//try to cut image after images are resized to 2400
    	int final_length=2400;
    	Mat cutImg;
    	Mat tmp;
    	if(imageType==0)
    	{
    		imageType=0;
    		double rate=src.rows*1.0/final_length;
    		Mat tmp;
    		resize(src,tmp,Size(int(src.cols/rate),final_length),0,0,INTER_LINEAR);
    		tmp=newThreshold(tmp);
    		tmp=quzao(tmp);
    		//imwrite("quzao.png",tmp);
    		cutImg=tmp(Rect(0,int(cutpos*2.4),tmp.cols,int(1.0*(tmp.rows/2-cutpos*2.4))));
    	}
    	else
    	{
    		double rate=src.cols*1.0/final_length;
    		Mat tmp;
    		resize(src,tmp,Size(final_length,int(src.rows/rate)),0,0,INTER_LINEAR);
    		tmp=newThreshold(tmp);
    		tmp=quzao(tmp);
    		//imwrite("quzao.png",tmp);
    		if(title_right*2.4>=0.6*tmp.cols)
    		{
    		imageType=2;
    		cutImg=tmp(Rect(0,int(cutpos*2.4),tmp.cols,int(1.0*(tmp.rows/2-cutpos*2.4))));
    		}
    		else
    		{
    		imageType=1;
    		cutImg=tmp(Rect(0,int(cutpos*2.4),tmp.cols/2,int(0.5*(tmp.rows/2-cutpos*2.4))));
    		}
    	}
    	vcutImg=cutImg;
    	//imwrite("cut.png",cutImg);
    	return true;
    	
    }
    	
    	
    //将部分图片切成行
    bool Cuter::vcut(Mat srcImage,char *name)
    {
    	int type2_flag=-1;
    	int height=srcImage.rows;
    	int width=srcImage.cols;
    	int perPixeValue;
    	int *projectValArry=new int[height];
    	int *pixeArry=new int[height];
    	memset(projectValArry,0,height*4);
    	memset(pixeArry,0,height*4);
    
    
    	for(int i=0;i<height;i++)
    	{
    		for(int j=0;j<width;j++)
    		{
    			perPixeValue=srcImage.at<uchar>(i,j);
    			if(perPixeValue==0)
    			{
    				projectValArry[i]++;
    				pixeArry[i]++;
    			}
    	
    		}	
    	}
    
    	sort(pixeArry,pixeArry+height);
    	int limit=pixeArry[height/3];
    
    	for(int i=0;i<height;i++)
    	{
    		projectValArry[i]-=limit;
    		if(projectValArry[i]<=0)projectValArry[i]=0;
    		//cout<<i<<" "<<projectValArry[i]<<endl;
    	}
    
    	//以下为绘制投影直方图
    	Mat verticalProjectionMat(height,width,CV_8UC1);
    	for(int i=0;i<height;i++)
    	{
    		for(int j=0;j<width;j++)
    		{
    			perPixeValue=255;
    			verticalProjectionMat.at<uchar>(i,j)=perPixeValue;
    		}
    	}
    
    	for (int i = 0; i < height; i++)
    	{
            	for (int j = 0; j < projectValArry[i]; j++)
            	{
               	 	perPixeValue = 0;  //直方图设置为黑色  
               		 verticalProjectionMat.at<uchar>(i, j) = perPixeValue;
           		 }
        	}
    	//imwrite("touying.png",verticalProjectionMat);
    
    
    
        //delete[] projectValArry;//不要忘了删除数组空间
    	vector<Mat> roiList; //用于储存分割出来的每个字符
    	int startIndex=0; //记录进入字符区的索引
    	int endIndex=0; //进入进入空白区域的索引
    	bool inBlock=false;
    	for(int i=0;i<height;i++)
    	{
    		int highest=0;
    		if(!inBlock && projectValArry[i]>0) //进入字符区
    		{
    			inBlock=true;
    			startIndex=i;
    		}
    		else if(projectValArry[i]==0&&inBlock&&i-startIndex>=20) //进入空白区
    		{
    			endIndex=i;
    			inBlock=false;
    			int highest=0;
    			Mat roiImg=srcImage(Rect(0,startIndex,srcImage.cols,endIndex-startIndex));	
    				
    			for(int j=startIndex;j<endIndex;j++)
    			{
    				if(projectValArry[j]>highest)highest=projectValArry[j];
    			}
    			//cout<<"highest "<<highest<<endl;
    			if(highest>=50) //作用在于去掉“副本”行
    			{
    				roiList.push_back(roiImg);
    			}
    		}
    	}
    	if(roiList.size()<1)
    	{
    		cout<<"vcut wrong"<<endl;
    		return false;
    	}
    	int vcut_rank=0;
    	int min=roiList.size()<4?roiList.size():4;
    	for(int i=0;i<min;i++)
    	{
    		Mat image;
    		image=roiList[i];
    		//char tmp[64];
     		//sprintf(tmp,"vcut/%s/%d.png",name,vcut_rank);
    		//imwrite(tmp,image);
    		//if(i==0)
    		hcut_big(image,name);
    		vcut_rank++;
    	}
    	if(digit_line<0)
    	{	return false;
    	}
    	hcut_title();
    	hcut_small();
    	delete[]projectValArry;
    	delete[]pixeArry;
    	return true;
    }
    
    
    
    //
    Mat Cuter::append(Mat src)
    {
    	int src_h=src.rows;
    	int src_w=src.cols;
    	int max_l,type;
    	if(src_h>src_w)
    	{
    		max_l=src_h;
    		type=0;
    	}
    	else
    	{
    		max_l=src_w;
    		type=1;
    	}
    	if(type==0)
    	{
    		int tmp_l=src_h*1.25;
    		int gap_h=(tmp_l-src_h)/2;
    		int gap_w=(tmp_l-src_w)/2;
    		Mat result(tmp_l,tmp_l,CV_8UC1);
    		for(int i=0;i<result.rows;i++)
    		{
    			for(int j=0;j<result.cols;j++)
    			{
    				result.at<uchar>(i,j)=255;
    			}
    		}
    		for(int i=gap_h;i<src_h+gap_h;i++)
    		{
    			for(int j=gap_w;j<src_w+gap_w;j++)
    			{
    				result.at<uchar>(i,j)=src.at<uchar>(i-gap_h,j-gap_w);
    			}
    		}
    		return result;
    	}
    	else
    	{
    		int tmp_l=src_w*1.25;
    		int gap_h=(tmp_l-src_h)/2;
    		int gap_w=(tmp_l-src_w)/2;
    		Mat result(tmp_l,tmp_l,CV_8UC1);
    		for(int i=0;i<result.rows;i++)
    		{
    			for(int j=0;j<result.cols;j++)
    			{
    				result.at<uchar>(i,j)=255;
    			}
    		}
    		for(int i=gap_h;i<src_h+gap_h;i++)
    		{
    			for(int j=gap_w;j<src_w+gap_w;j++)
    			{
    				result.at<uchar>(i,j)=src.at<uchar>(i-gap_h,j-gap_w);
    			}
    		}
    		return result;
    	}
    }
    
    //合并的两张图片的高需要相同
    Mat Cuter::merge(Mat leftImg,Mat rightImg)
    {
    	//assert(leftImg.rows==rightImg.rows);
    	int merge_width=leftImg.cols+rightImg.cols;
    	int merge_height=leftImg.rows<rightImg.rows?leftImg.rows:rightImg.rows;
    	Mat result(merge_height,merge_width,CV_8UC1);
    	for(int i=0;i<result.cols;i++)
    	{
    		for(int j=0;j<result.rows;j++)
    		{
    			if(i<leftImg.cols)
    			{
    				result.at<uchar>(j,i)=leftImg.at<uchar>(j,i);
    			}
    			else
    			{
    			 	result.at<uchar>(j,i)=rightImg.at<uchar>(j,i-leftImg.cols);
    			 }
    		}
    	}
    	//cout<<result.cols<<" "<<leftImg.cols<<" "<<rightImg.cols<<endl;
    	return result;
    }
    	
    
    Mat Cuter::hcut_spare(Mat srcImage)
    {
    	int height=srcImage.rows;
    	int width=srcImage.cols;
    	int perPixeValue;
    	int *projectValArry=new int[height];
    memset(projectValArry,0,height*4);
    
    
    for(int i=0;i<height;i++)
    {
    	for(int j=0;j<width;j++)
    	{
    		perPixeValue=srcImage.at<uchar>(i,j);
    		if(perPixeValue==0)
    		{
    			projectValArry[i]++;
    		}
    	
    	}	
    }
    
    vector<Mat> roiList; //用于储存分割出来的每个字符
    int top=0; //上界
    int down=height-1;//下界
    int fit=0;
    for(int i=0;i<height;i++)
    {
    	if(projectValArry[i]>0)
    	{
    		top=i;
    		break;
    	}
    }
    
    for(int i=height-1;i>=0;i--)
    {
    	if(projectValArry[i]>0)
    	{
    		down=i;
    		break;
    	}
    }
    
    //cout<<top<<" : "<<down<<endl;
    Mat roiImg;
    roiImg=srcImage(Rect(0,top,srcImage.cols,down-top+1));
    
    delete[] projectValArry;
    return roiImg;
    }
    
    
    bool Cuter::hcut_search(Mat srcImage,char *name,int lineRank)
    {
    	if(!isFirstDigitLine)return true;
    	int height=srcImage.rows;
    	int width=srcImage.cols;
    	int perPixeValue;
    	int *projectValArry=new int[width];
    	int *pixeArry=new int[width];
    	memset(projectValArry,0,width*4);
    	memset(pixeArry,0,width*4);
    	
    
    for(int i=0;i<width;i++)
    {
    	for(int j=0;j<height;j++)
    	{
    		perPixeValue=srcImage.at<uchar>(j,i);
    		if(perPixeValue==0)
    		{
    			projectValArry[i]++;
    		}
    	
    	}	
    }
    
    
    vector<Mat> roiList; //用于储存分割出来的每个字符
    
    //字的间距由文字的类型决定
    int i;
    bool inBlock=false;
    int startIndex=0; //记录进入字符区的索引
    int endIndex=0;
    for( i=0;i<width;i++)
    {
    	int flag_empty=1;
    	int tmp_num=0;
    	for(int j=i;j<(i+int(height));j++)
    	{
    		tmp_num+=projectValArry[j];
    		if(tmp_num>0)
    		{
    			flag_empty=0;
    			break;
    		}
    	}	
    	if(!inBlock && projectValArry[i]>0) //进入字符区
    	{
    		inBlock=true;
    		startIndex=i;
    	}
    	else if(projectValArry[i]<=0&&inBlock) //进入空白区
    	{
    		endIndex=i;
    		inBlock=false;
    		Mat roiImg=srcImage(Rect(startIndex,0,endIndex-startIndex,srcImage.rows));
    		roiList.push_back(roiImg);
    	}
    }
    
    if(projectValArry[width-1]>0&&inBlock)
    {
    	endIndex=i;
    	inBlock=false;
    	Mat roiImg=srcImage(Rect(startIndex,0,endIndex-startIndex,srcImage.rows));
    	roiList.push_back(roiImg);
    }
    
    
     	if(roiList.size()<=0)
     	{
     		//cout<<"hcut wrong"<<endl;
     		return false;
     	}
    	for(int i=0;i<roiList.size();i++)
    	{
    		//if(imageType==0)
    		Mat image=roiList[i];
    		
    		Mat cImage=append(hcut_spare(image));
    		AimPrediction result=allClassifier->Classify(cImage);
    		//cout<<result.word<<endl;
    		if(isDigit(result.word)&&image.cols>=10&&image.cols<=30&&isFirstDigitLine)
    		{
    			digit_line=lineRank;
    			isFirstDigitLine=false;
    			//cout<<"数字的行数是 "<<lineRank<<endl;
    		}
    	}
    	delete[]projectValArry;
    	delete[]pixeArry;
    	return true;
    }
    
    
    
    //去除图片的噪点
    Mat Cuter::quzao(Mat src)
    {
       CvSeq* contour = NULL;   
       double minarea = 10;   
       double tmparea = 0.0;      
        CvMemStorage* storage = cvCreateMemStorage(0);   
           
        IplImage img_src= src;   
        IplImage* img_Clone=cvCloneImage(&img_src);   
        //访问二值图像每个点的值   
        uchar *pp;      
           
        IplImage* img_dst = cvCreateImage(cvGetSize(&img_src),IPL_DEPTH_8U,1);   
           
        //------------搜索二值图中的轮廓,并从轮廓树中删除面积小于某个阈值minarea的轮廓-------------//   
        CvScalar color = cvScalar(255,0,0);//CV_RGB(128,0,0);   
        CvContourScanner scanner = NULL;   
    scanner = cvStartFindContours(&img_src,storage,sizeof(CvContour),CV_RETR_CCOMP,CV_CHAIN_APPROX_NONE,cvPoint(0,0));   
        //开始遍历轮廓树   
        CvRect rect;   
        while (contour=cvFindNextContour(scanner))   
        {   
            tmparea = fabs(cvContourArea(contour));   
                rect = cvBoundingRect(contour,0);      
            if (tmparea < minarea/*||tmparea>4900*/)   
            {   
               
            //当连通域的中心点为黑色时,而且面积较小则用白色进行填充   
                pp=(uchar*)(img_Clone->imageData + img_Clone->widthStep*(rect.y+rect.height/2)+rect.x+rect.width/2);   
                if (pp[0]==0)   
                {   
                    for(int y = rect.y;y<rect.y+rect.height;y++)   
                    {   
                        for(int x =rect.x;x<rect.x+rect.width;x++)   
                        {   
                            pp=(uchar*)(img_Clone->imageData + img_Clone->widthStep*y+x);   
                               
                            if (pp[0]==0)   
                            {   
                                pp[0]=255;   
                            }   
                        }   
                    }   
                }   
               
            } 
         }    
         Mat result(img_Clone,true);
         return result;  
    }
    
    //将一行字切成数块
    bool Cuter::hcut_big(Mat srcImage,char *name)
    {
    	lineDigitNum=0;
    	int height=srcImage.rows;
    	int width=srcImage.cols;
    	int perPixeValue;
    	int *projectValArry=new int[width];
    	int *pixeArry=new int[width];
    	memset(projectValArry,0,width*4);
    	memset(pixeArry,0,width*4);
    	
    
    for(int i=0;i<width;i++)
    {
    	for(int j=0;j<height;j++)
    	{
    		perPixeValue=srcImage.at<uchar>(j,i);
    		if(perPixeValue==0)
    		{
    			projectValArry[i]++;
    		}
    	
    	}	
    }
    
    
    vector<Mat> roiList; //用于储存分割出来的每个字符
    vector<int> startArry; //记录分割出来的图片的长度
    
    //字的间距由文字的类型决定
    int i;
    int first_start=0;
    int second_start=0;
    bool is_first_start=true;
    bool is_second_start=false;
    
    int startIndex=first_start; //记录进入字符区的索引
    int endIndex=first_start; //进入进入空白区域的索引
    int lastendIndex=0;
    bool inBlock=false;
    double avg_width=0;
    for( i=first_start;i<width;i++)
    {
    	int flag_empty=1;
    	int tmp_num=0;
    	for(int j=i;j<(i+int(height/2));j++)
    	{
    		tmp_num+=projectValArry[j];
    		if(tmp_num>0)
    		{
    			flag_empty=0;
    			break;
    		}
    	}	
    	if(!inBlock && projectValArry[i]>0) //进入字符区
    	{
    		inBlock=true;
    		startIndex=i;
    	}
    	else if(projectValArry[i]<=0&&inBlock&&flag_empty) //进入空白区
    	{
    		endIndex=i;
    		inBlock=false;
    		
    		int flag_notfull=1;
    		int len=endIndex-startIndex;
    		Mat roiImg=srcImage(Rect(startIndex,0,endIndex-startIndex,srcImage.rows));
    		if(flag_notfull&&roiImg.cols>=200)
    		roiList.push_back(roiImg);
    	}
    }
    
    if(projectValArry[width-1]>0&&inBlock)
    {
    	endIndex=i;
    	inBlock=false;
    	int flag_notfull=1;
    	int len=endIndex-startIndex;
    	Mat roiImg=srcImage(Rect(startIndex,0,endIndex-startIndex,srcImage.rows));
    	if(flag_notfull&&roiImg.cols>=200)
    		roiList.push_back(roiImg);
    }
    //cout<<"roiList.size()"<<roiList.size()<<endl;
    if(roiList.size()==0)
    {
    	//cout<<"cant't hcut"<<endl;
    	return false;
    }
    for(int i=0;i<roiList.size();i++)
    {
    	
    	Mat image=roiList[i];
    	image=hcut_spare(image);
    	//Mat save=append(hcut_spare(image);
    	char tmp[64];
    	sprintf(tmp,"hcut-big/%s/%d.png",name,currentLine);
    	cout<<tmp<<endl;
    	imwrite(tmp,image);
    	preLineList.push_back(image);
    
    	hcut_search(image,name,currentLine);
    		
    	
    	currentLine++;
    }
    }
    
    //用于去除标题
    bool Cuter::hcut_title()
    {
    
    	for(int t=0;t<preLineList.size();t++)
    	{
    		Mat srcImage=preLineList[t];
    		bool readyCut=false;
    		bool mayCut=false;
    		int mayCutPos=0;
    		int height=srcImage.rows;
    		int width=srcImage.cols;
    		int perPixeValue;
    		int *projectValArry=new int[width];
    		memset(projectValArry,0,width*4);
    	
    
    	for(int i=0;i<width;i++)
    	{
    		for(int j=0;j<height;j++)
    		{
    			perPixeValue=srcImage.at<uchar>(j,i);
    			if(perPixeValue==0)
    			{
    			projectValArry[i]++;
    			}
    	
    		}	
    	}
    
    
    vector<Mat> roiList; //用于储存分割出来的每个字符
    
    //字的间距由文字的类型决定
    int i;
    bool inBlock=false;
    int startIndex=0; //记录进入字符区的索引
    int endIndex=0;
    for( i=0;i<width;i++)
    {	
    	if(!inBlock && projectValArry[i]>0) //进入字符区
    	{
    		inBlock=true;
    		startIndex=i;
    		if(readyCut)
    		{
    			//cout<<"去掉了第"<<t<<"行的行头"<<endl;
    			Mat newImg=srcImage(Rect(startIndex,0,width-startIndex,height));
    			lineList.push_back(newImg);
    			break;
    		}
    		if(mayCut)
    		{
    			mayCutPos=startIndex;
    			mayCut=false;
    		}
    	}
    	else if(projectValArry[i]<=0&&inBlock) //进入空白区
    	{
    		endIndex=i;
    		inBlock=false;
    		Mat roiImg=hcut_spare(srcImage(Rect(startIndex,0,endIndex-startIndex,srcImage.rows)));
    		Mat toClassify=append(hcut_spare(roiImg));
    		//char saveName[64];
    		//sprintf(saveName,"hcut_tmp/%d-%d.png",t,i);
    		//imwrite(saveName,roiImg);	
    		//cout<<result.word<<endl;
    		
    			
    		vector<AimPrediction> resultList=allClassifier->ClassifyMore(toClassify);
    		if(roiImg.rows<=0.5*height&&resultList[0].word!="一"&&resultList[0].word!="-"&&roiImg.cols>=30)
    		{
    			mayCut=true;
    			continue;
    		}
    		
    		for(int m=0;m<resultList.size();m++)
    		{
    			AimPrediction result=resultList[m];
    			if(t==digit_line&&(result.word=="号"||result.word=="码"))readyCut=true;
    			if(t!=digit_line&&result.word=="称")readyCut=true;
    			//if(t==digit_line&&(roiImg.rows>=0.5*height&&!(result.word=="注"||result.word=="册"||result.word=="号"||result.word=="统"||result.word=="一"||result.word=="-"||result.word=="社"||result.word=="会"||result.word=="信"||result.word=="用"||result.word=="代"||result.word=="码"||result.word=="倍")))readyCut=true;
    			//if(t!=digit_line&&(roiImg.rows>=0.5*height&&!(result.word=="字"||result.word=="号"||result.word=="名"||result.word=="称")))readyCut=true;
    		}
    			
    		//if(t==digit_line&&(result.word=="号"||result.word=="码"))readyCut=true;
    		
    	}
    }
    if(!readyCut)
    {
    //cout<<"mayCutPos"<<mayCutPos<<endl;
    Mat resultImg=srcImage(Rect(mayCutPos,0,width-mayCutPos,height));
    lineList.push_back(resultImg);
    }
    
    }
    	return true;
    }
    
    
    
    bool Cuter::hcut_digit_single(Mat roiImg)
    {
    	int height=roiImg.rows;
    	int width=roiImg.cols;
    	int tops[width]={height-1};
    	int downs[width]={0};
    	for(int i=0;i<width;i++)
    	{
    		for(int j=0;j<height;j++)
    		{
    			int pixe=roiImg.at<uchar>(j,i);
    			if(pixe==0){tops[i]=j;break;}
    		}
    		for(int j=height-1;j>=0;j--)
    		{
    			int pixe=roiImg.at<uchar>(j,i);
    			if(pixe==0)
    			{downs[i]=j;break;}
    		}
    	}
    	int len=9;
    	int flag[width]={0};
    	int flag_top[width]={0};
    	int flag_down[width]={0};
    	
    	for(int i=0;i<width;i++)
    	{
    		flag_top[i]=1;
    		flag_down[i]=1;	
    		//int flag=0;
    		for(int j=i-len;j<=i+len;j++)
    		{
    			if(j<0||j>=width)continue;
    			if(tops[j]>tops[i]){flag_top[i]=0;break;}
    		}
    		for(int j=i-len;j<=i+len;j++)
    		{
    			if(j<0||j>=width)continue;
    			if(downs[j]<downs[i]){flag_down[i]=0;break;}
    		}		
    	}
    	
    	int len2=3;
    	int flag_top2[width]={0};
    	int flag_down2[width]={0};
    	
    	for(int i=0;i<width;i++)
    	{
    		flag_top2[i]=1;
    		flag_down2[i]=1;	
    		//int flag=0;
    		for(int j=i-len2;j<=i+len2;j++)
    		{
    			if(j<0||j>=width)continue;
    			if(tops[j]>tops[i]){flag_top2[i]=0;break;}
    		}
    		for(int j=i-len2;j<=i+len2;j++)
    		{
    			if(j<0||j>=width)continue;
    			if(downs[j]<downs[i]){flag_down2[i]=0;break;}
    		}		
    	}
    	int startIndex=0;
    	int endIndex=0;
    	for(int i=0;i<width;i++)
    	{
    		if((flag_top[i]==1||(flag_top2[i]==1&&flag_down2[i]==1))&&(i-startIndex>=5))
    		{	
    			endIndex=i;
    			cout<<"startIndex  "<<startIndex<<endl;
    			cout<<"endIndex  "<<endIndex<<endl;
    			Mat singleImg=roiImg(Rect(startIndex,0,endIndex-startIndex+1,height));	
    			singleList.push_back(singleImg);
    			startIndex=endIndex+1;
    			
    			
    		}
    	}
    	
    	
    	
    	if(endIndex<width-1)
    	{
    		cout<<"last"<<endl;
    		endIndex=width-1;
    		cout<<"startIndex  "<<startIndex<<endl;
    		cout<<"endIndex  "<<endIndex<<endl;
    		Mat singleImg=roiImg(Rect(startIndex,0,width-startIndex,height));
    		if(singleImg.cols>=5)	
    			singleList.push_back(singleImg);
    		else
    		{
    			Mat lastImg=singleList[singleList.size()-1];
    			singleList.pop_back();
    			Mat newImg=merge(lastImg,singleImg);
    			singleList.push_back(newImg);
    		}
    		startIndex=endIndex+1;
    		
    	}
    	
    	cout<<endl;
    			
    }
    
    
    bool Cuter::hcut_small()
    {
    	for(int k=0;k<lineList.size();k++)
    	{
    	//cout<<"正在处理的行数是: "<<k<<endl;
    	double avg_width;
    	int total_width=0;
    	int suit_num=0;
    	char saveName[64];
    	sprintf(saveName,"hcut-title/%d.png",k);
    	imwrite(saveName,lineList[k]);
    	singleList.clear();
    	classifyList.clear();
    	Mat tmpImg=lineList[k];
    	Mat srcImage=hcut_spare(tmpImg);
    	int height=srcImage.rows;
    	int width=srcImage.cols;
    	int perPixeValue;
    	int *projectValArry=new int[width];
    	memset(projectValArry,0,width*4);
    	
    
    	for(int i=0;i<width;i++)
    	{
    		
    		for(int j=0;j<height;j++)
    		{
    			perPixeValue=srcImage.at<uchar>(j,i);
    			if(perPixeValue==0)
    			{
    				projectValArry[i]++;
    			}
    	
    		}	
    	}
    
    //字的间距由文字的类型决定
    	bool inBlock=false;
    	int startIndex=0; //记录进入字符区的索引
    	int endIndex=0;
    	
    	for(int i=0;i<width;i++)
    	{	
    		if(!inBlock && projectValArry[i]>0) //进入字符区
    		{
    			inBlock=true;
    			startIndex=i;
    		}
    		else if((projectValArry[i]<=0&&inBlock)||(projectValArry[i]>0&&i==width-1)) //进入空白区
    		{
    				//cout<<"before"<<endl;
    			endIndex=i;
    			inBlock=false;
    			Mat roiImg=srcImage(Rect(startIndex,0,endIndex-startIndex,height));
    			//char saveName[64];
    		//sprintf(saveName,"hcut_tmp/%d-%d.png",k,i);
    		//imwrite(saveName,roiImg);
    			/*
    			if(k!=digit_line&&roiImg.cols<=45&&roiImg.cols>=30)
    			{
    				total_width+=roiImg.cols;
    				suit_num++;
    			}
    			*/
    			if(k==digit_line)
    			{
    			//hcut_digit_single(roiImg);
    			singleList.push_back(roiImg);
    			}
    			else 
    			{
    			
    			singleList.push_back(roiImg);
    			
    			}//cout<<"before"<<endl;
    			//char imgName[64];
    			//sprintf(imgName,"special/%d.png",endIndex);
    			//imwrite(imgName,roiImg);
    		}
    		
    	}
    	
    	
    
    	if(k==digit_line)digit_classify();
    	else word_classify(0);
    	show();
    	if(!hasFindWordLine)wordResult.clear();
    	delete[] projectValArry;
    	}
    	
    	
    	return true;
    }
    
    
    void Cuter::digit_classify()
    {
    	string lastword;
    	vector<Mat> readyMatList;
    	
    	bool okLast=false;
    	int size=singleList.size();
    	//cout<<"size: "<<size<<endl;
    	
    	
    	for(int i=0;i<singleList.size()-1;i++)
    	{
    		Mat currentImg=singleList[i];
    		Mat toClassify=append(hcut_spare(currentImg));
    		Mat nextImg=singleList[i+1];
    			if(currentImg.cols+nextImg.cols<=23)
    			{
    				AimPrediction result=digitClassifier->Classify(toClassify);
    				AimPrediction next_result=digitClassifier->Classify(append(hcut_spare(nextImg)));
    				int new_width=currentImg.cols+nextImg.cols;
    				int new_height=currentImg.cols;
    				Mat mergeImg=merge(currentImg,nextImg);
    				AimPrediction merge_result=digitClassifier->Classify(append(hcut_spare(mergeImg)));
    				if((merge_result.rate>result.rate&&merge_result.rate>next_result.rate)||(result.word=="("&&next_result.word==")")||((hcut_spare(currentImg)).rows<=15&&(hcut_spare(nextImg)).rows<=15))
    				{
    					//cout<<merge_result.word<<endl;
    					digitResult.push_back(merge_result.word);
    					
    					classifyList.push_back(mergeImg);
    					//cout<<"发生了合并"<<endl;
    					char saveName[64];
    					sprintf(saveName,"merge/digit-%d.png",i);
    					imwrite(saveName,mergeImg);
    					if(i==size-2)okLast=true;
    					i++;
    				}
    				else
    				{
    					classifyList.push_back(currentImg);
    					//cout<<result.word<<endl;
    					digitResult.push_back(result.word);
    				}
    			}
    			else
    			{
    				AimPrediction result=digitClassifier->Classify(append(toClassify));
    				classifyList.push_back(currentImg);
    				digitResult.push_back(result.word);
    				//cout<<result.word<<endl;
    			}
    	}
    	if(!okLast)
    	{
    		AimPrediction result=digitClassifier->Classify(append(hcut_spare(singleList[size-1])));
    		classifyList.push_back(singleList[size-1]);
    		digitResult.push_back(result.word);
    		//cout<<result.word<<endl;
    	}
    	tmplinecut(1);
    	
    	
    	
    	
    	
    	
    	
    	
    	
    	
    	
    	
    	
    	
    	
    	
    	
    	
    	
    	/*
    	
    	for(int i=0;i<singleList.size()-1;i++)
    	{
    		Mat currentImg=singleList[i];
    		Mat toClassify=append(hcut_spare(currentImg));
    		Mat nextImg=singleList[i+1];
    			if(currentImg.cols+nextImg.cols<=23)
    			{
    				AimPrediction result=allClassifier->Classify(toClassify);
    				AimPrediction next_result=allClassifier->Classify(append(hcut_spare(nextImg)));
    				int new_width=currentImg.cols+nextImg.cols;
    				int new_height=currentImg.cols;
    				Mat mergeImg=merge(currentImg,nextImg);
    				AimPrediction merge_result=allClassifier->Classify(append(hcut_spare(mergeImg)));
    				if((merge_result.rate>result.rate&&merge_result.rate>next_result.rate)||(result.word=="("&&next_result.word==")")||((hcut_spare(currentImg)).rows<=15&&(hcut_spare(nextImg)).rows<=15))
    				{
    					//cout<<merge_result.word<<endl;
    					digitResult.push_back(merge_result.word);
    					
    					classifyList.push_back(mergeImg);
    					//cout<<"发生了合并"<<endl;
    					char saveName[64];
    					sprintf(saveName,"merge/digit-%d.png",i);
    					imwrite(saveName,mergeImg);
    					if(i==size-2)okLast=true;
    					i++;
    				}
    				else
    				{
    					classifyList.push_back(currentImg);
    					//cout<<result.word<<endl;
    					digitResult.push_back(result.word);
    				}
    			}
    			else
    			{
    				AimPrediction result=allClassifier->Classify(append(toClassify));
    				classifyList.push_back(currentImg);
    				digitResult.push_back(result.word);
    				//cout<<result.word<<endl;
    			}
    	}
    	if(!okLast)
    	{
    		AimPrediction result=allClassifier->Classify(append(hcut_spare(singleList[size-1])));
    		classifyList.push_back(singleList[size-1]);
    		digitResult.push_back(result.word);
    		//cout<<result.word<<endl;
    	}
    	*/
    	writeClassifyList();
    }
    
    
    void Cuter::tmplinecut(int avg_width)
    {
    	for(int k=0;k<classifyList.size();k++)
    	{
    	Mat img=hcut_spare(classifyList[k]);
    	int height=img.rows;
    	int width=img.cols;
    	
    	if(height<=5&&width<=5)
    	{
    		continue;
    		
    	}
    	
    	//只考虑粘连的汉字  b
    	int suitHeight=height<32?height:32;
    	int charNum=width*1.0/suitHeight/1+0.5;//cout<<"charNum "<<charNum<<endl;
    	//imwrite("error.png",img);
    	if(charNum<=1)
    	{
    		AimPrediction result=digitClassifier->Classify(append(img));
    		wordResult.push_back(result.word);
    		cout<<result.word<<endl;
    		continue;
    	}
    	int avgLen=width/charNum;
    	int startIndex=0;
    	int endIndex=0;
    	for(int i=1;i<charNum;i++)
    	{
    		int avgPos=i*avgLen;
    		double max_rate=0;
    		string word;
    		Mat save;
    		for(int j=-5;j<=5;j++)
    		{
    			int actPos=avgPos+j;
    			Mat roiImg=img(Rect(startIndex,0,actPos-startIndex+1,height));
    			Mat tmp=append(hcut_spare(roiImg));
    			AimPrediction result=digitClassifier->Classify(tmp);
    			if(result.rate>max_rate)
    			{			
    				word=result.word;	
    				max_rate=result.rate;
    				endIndex=actPos;
    				save=tmp;
    				
    			}
    		}
    		//cout<<"endIndex: "<<endIndex;
    		cout<<word<<endl;
    		//if(!hasFindWordLine)wordResult.push_back(word);
    		char saveName[64];
    				sprintf(saveName,"linecut/%d-%d.png",k,i);
    				imwrite(saveName,save);
    		//classifyList.push_back(word);
    		//classifyRank++;
    		startIndex=endIndex+1;
    	}
    	Mat roiImg=img(Rect(startIndex,0,width-startIndex,height));
    	Mat tmp=append(hcut_spare(roiImg));
    	AimPrediction result=digitClassifier->Classify(tmp);
    	char saveName[64];
    	sprintf(saveName,"linecut/%d-%d.png",k,charNum);
    	imwrite(saveName,tmp);
    	//classifyList.push_back(result.word);
    	//classifyRank++;
    	cout<<result.word<<endl;
    	/*
    	if(!hasFindWordLine)wordResult.push_back(result.word);
    	}
    	for(int k=0;k<wordResult.size();k++)
    	{
    		if(wordResult[k]=="有"||wordResult[k]=="司"||wordResult[k]=="公"||wordResult[k]=="司"||wordResult[k]=="厂")
    		{
    			hasFindWordLine=true;
    		}
    	}
    	*/
    	}
    }
    
    
    void Cuter::word_classify(int avg_width)
    {
    	string lastword;
    	vector<Mat> readyMatList;
    	bool okLast=false;
    	int size=singleList.size();
    	//cout<<"size: "<<size<<endl;
    	if(size<=1)return;
    	for(int i=0;i<singleList.size()-1;i++)
    	{
    		/*
    		Mat currentImg=singleList[i];
    		Mat toClassify=append(hcut_spare(currentImg));
    		Mat nextImg=singleList[i+1];
    		if(currentImg.cols+nextImg.cols<=50)
    		{
    			AimPrediction result=allClassifier->Classify(toClassify);
    			AimPrediction next_result=allClassifier->Classify(append(hcut_spare(nextImg)));
    			int new_width=currentImg.cols+nextImg.cols;
    			int new_height=currentImg.cols;
    			Mat mergeImg=merge(currentImg,nextImg);
    			AimPrediction merge_result=allClassifier->Classify(append(hcut_spare(mergeImg)));
    			if(merge_result.rate>result.rate&&merge_result.rate>next_result.rate&&!(result.word=="("&&next_result.word!=")"))
    			{
    				//cout<<merge_result.word<<endl;
    				i++;
    				classifyList.push_back(mergeImg);
    				cout<<"发生了合并"<<endl;
    				//cout<<result.word<<" "<<next_result.word<<endl;
    				//imwrite("tmp.png",
    				char saveName[64];
    				sprintf(saveName,"merge/word-%d.png",i);
    				imwrite(saveName,mergeImg);
    				if(i==size-2)okLast=true;
    			}
    			else
    			{
    				classifyList.push_back(currentImg);
    				//cout<<result.word<<endl;
    			}
    		}
    		else
    		{
    			//AimPrediction result=allClassifier->Classify(toClassify);
    			classifyList.push_back(currentImg);
    			//cout<<result.word<<endl;
    		}
    		*/
    		Mat currentImg=singleList[i];
    		Mat toClassify=append(hcut_spare(currentImg));
    		AimPrediction result=allClassifier->Classify(toClassify);
    		Mat nextImg=singleList[i+1];
    		if(currentImg.cols<=30)
    		{	
    			if((result.word=="("||result.word==")"||result.word=="1")||currentImg.cols+nextImg.cols>=50)
    			{
    				//cout<<result.word<<endl;
    				//cout<<currentImg.cols<<" "<<nextImg.cols<<endl;
    				classifyList.push_back(currentImg);
    			}
    			else 
    			{
    				Mat mergeImg=merge(currentImg,nextImg);
    				AimPrediction merge_result=allClassifier->Classify(append(hcut_spare(mergeImg)));
    				//cout<<merge_result.word<<endl;			
    				classifyList.push_back(mergeImg);
    				//cout<<"发生了合并"<<endl;
    				//char saveName[64];
    				//sprintf(saveName,"merge/word-%d.png",i);
    				//imwrite(saveName,mergeImg);
    				if(i==size-2)okLast=true;
    				i++;
    			}
    		}
    		else
    		{
    			//cout<<result.word<<endl;
    			classifyList.push_back(currentImg);
    		}
    			
    			
    	}
    	
    	if(!okLast)
    	{
    		//AimPrediction result=allClassifier->Classify(append(hcut_spare(singleList[size-1])));
    		classifyList.push_back(singleList[size-1]);
    		//cout<<result.word<<endl;
    	}
    	writeClassifyList();
    	linecut(avg_width);
    }
    				
    
    
    void Cuter::linecut(int avg_width)
    {
    	for(int k=0;k<classifyList.size();k++)
    	{
    	Mat img=hcut_spare(classifyList[k]);
    	int height=img.rows;
    	int width=img.cols;
    	
    	if(height<=20&&width<=20)
    	{
    		continue;
    		
    	}
    	
    	//只考虑粘连的汉字  b
    	int suitHeight=height<42?height:42;
    	int charNum=width*1.0/suitHeight/1+0.5;//cout<<"charNum "<<charNum<<endl;
    	//imwrite("error.png",img);
    	if(charNum<=1)
    	{
    		AimPrediction result=allClassifier->Classify(append(img));
    		if(!hasFindWordLine)wordResult.push_back(result.word);
    		//cout<<result.word<<endl;
    		continue;
    	}
    	int avgLen=width/charNum;
    	int startIndex=0;
    	int endIndex=0;
    	for(int i=1;i<charNum;i++)
    	{
    		int avgPos=i*avgLen;
    		double max_rate=0;
    		string word;
    		Mat save;
    		for(int j=-5;j<=5;j++)
    		{
    			int actPos=avgPos+j;
    			Mat roiImg=img(Rect(startIndex,0,actPos-startIndex+1,height));
    			Mat tmp=append(hcut_spare(roiImg));
    			AimPrediction result=allClassifier->Classify(tmp);
    			if(result.rate>max_rate)
    			{			
    				word=result.word;	
    				max_rate=result.rate;
    				endIndex=actPos;
    				save=tmp;
    				
    			}
    		}
    		//cout<<"endIndex: "<<endIndex;
    		//cout<<word<<endl;
    		if(!hasFindWordLine)wordResult.push_back(word);
    		//char saveName[64];
    				//sprintf(saveName,"linecut/%d-%d.png",k,i);
    				//imwrite(saveName,save);
    		//classifyList.push_back(word);
    		//classifyRank++;
    		startIndex=endIndex+1;
    	}
    	Mat roiImg=img(Rect(startIndex,0,width-startIndex,height));
    	Mat tmp=append(hcut_spare(roiImg));
    	AimPrediction result=allClassifier->Classify(tmp);
    	//char saveName[64];
    	//sprintf(saveName,"linecut/%d-%d.png",k,charNum);
    	//imwrite(saveName,tmp);
    	//classifyList.push_back(result.word);
    	//classifyRank++;
    	//cout<<result.word<<endl;
    	if(!hasFindWordLine)wordResult.push_back(result.word);
    	}
    	for(int k=0;k<wordResult.size();k++)
    	{
    		if(wordResult[k]=="有"||wordResult[k]=="司"||wordResult[k]=="公"||wordResult[k]=="司"||wordResult[k]=="厂")
    		{
    			hasFindWordLine=true;
    		}
    	}
    }
    
    //int cutAndClassify(char *picName) 
    int main(int argc,char *argv[])
    {
    	
    	char *picName=argv[1];
    	
    	Mat src=imread(picName,0);
    	if(src.empty()) return 0;
    	
    	/*
        	vector<Mat> channels;
       	 split(src, channels);
       	 Mat red = channels[2];
       	 Mat green = channels[1];
        	imwrite("gray.png",red);
        	*/
        	Cuter cuter;
    	bool success=false;
    	char greeting[]="hello";
    	int rank=4;
    	bool isFindTitle;
    	while(!success&&rank--)
    	{
    			
    			isFindTitle=cuter.findtitle_cut(src,greeting);
    			//cout<<"hello "<<endl;
    			if(isFindTitle)
    			{
    				success=cuter.vcut(cuter.getVcutImg(),greeting);
    				success=cuter.printResult(picName,success);
    				//cout<<"find title"<<endl;
    				break;
    			}
    			src=cuter.myRotate(src,1);
    		
    	}
    	//cout<<picName<<endl;
    	if(!isFindTitle)
    	{
    		cuter.printResult(picName,success);
    		//cout<<"can't classify"<<endl;
    		return 0;
    	}
    	else return 1;
    }
    

     

    展开全文
  • 营业执照信息录入可谓是个难题,要输入包括企业名称、18位统一社会信用代码、住所、法人代表、经营范围等各种信息,怎么能不愁呢?并且在很多企事业单位营业执照的录入可不是一本两本。为解决这个难题,营业执照ocr...

    营业执照信息录入可谓是个难题,要输入包括企业名称、18位统一社会信用代码、住所、法人代表、经营范围等各种信息,怎么能不愁呢?并且在很多企事业单位营业执照的录入可不是一本两本。为解决这个难题,营业执照ocr识别技术应运而生。营业执照ocr识别可以仅通过摄像头采集营业执照信息就可以完成信息录入,节省了大量的人力。

    营业执照OCR识别

    营业执照ocr识别技术包含移动端和云端两种,移动端营业执照ocr识别即集成在app中就可调用相应的识别程序;那云端营业执照ocr识别是怎么回事呢?云端识别的优势有哪些?

    营业执照OCR识别,企业只需将该识别服务部署在自有服务器上(云服务器或本地服务器),1个小时即可完成安装部署,非常简单,还可以多种方式调用支持APP端、PC端、H5端、微信端等多种平台调用识别,可供互联网平台用户多种方式调取。

    云端营业执照ocr识别可将需要录入的营业执照上的信息识别出来,识别的数据可修改、可编辑、可保存,完全省去了手工录入的繁琐,能减少工作人员95%工作量,采用ocr文字识别技术,可以根据各行的具体需求划分识别区域,识别率高达97%,识别速度小于一秒,行业内领先。改善在工作人员手动录入的情况下造成的体验差,流程繁琐,效率低下,错误率高的问题。

    发票识别,票据识别,文档识别,车牌识别,名片识别,人脸识别,人证合一,证件识别,身份证识别,银行卡识别,营业执照识别,Vin码识别,火车票识别,增值税发票识别,机动车销售发票识别,OCR文字检测,身份证核验验真,手机号核验验真,银行卡四要素核验


    展开全文
  • 市场监管总局印发《电子营业执照管理办法(试行)》,明确市场主体设立登记后,即时生成电子营业执照并存储于电子营业执照库。电子营业执照通过手机等装载有电子营业执照应用程序的智能移动终端进行领取、下载和使用。...
  • 1、个体营业执照是指有经营能力的公民经工商行政管理部门登记,领取个体工商营业执照,依法开展经营活动。 2、开公司营业执照是公司从事生产经营活动的证件。公司必须依法取得营业执照后方可进行生产经营活动。...
  • 企业登记成功后,工商管理部门颁发全国唯一的营业执照,一式两份,职能没有本质区别。在企业从事生产经营时,营业执照起着至关重要的作用。但部分企业由于各种原因,造成营业执照损坏或遗失,这一次需要到工商行政...
  • 合肥各个区域的注册公司工商局办理地点 注册公司想名称字号虽然是第一步,但是核名得找对所在区域工商局;因为合肥不同的区县跑的地方也不一样。这次统一整理下,方便各位创业...事先,很有必要和工商局电话沟通确认。
  • 网上年检的具体步骤: 1、登录全国企业信用信息公示系统。进入后选择您所属地区,企业所属哪个城市就进入哪个城市,或者直接进入省份。进入企业公示信息填报。...提交后你的个体工商营业执照年检就完了。
  • 每个公司都有自己的营业执照和章,这些在公司经营的过程中作用不言而喻,如果不小心把营业执照正本、营业执照副本、公章等证件因为某些原因丢失了,这种情况应该尽快补办。营业执照丢失了不管会不会有影响?营业执照...
  • 二、去工商局申请办理执照:大家要注意的是,个体户在申请办理营业执照的时候,需要将相关注册资料备齐,备齐资料之后,再前往工商局窗口提交办理。通常情况下,2-7个工作日后领取“三证合一”加载社会统一信用码的...
  • 众所周知,在很多业务场合,都会涉及到营业执照信息的录入,营业执照作为企业经营的必备证件,可应用于企业信息登记环节,如支付业务申请、自媒体平台企业账号申请、办理银行业务等。 由于营业执照上的信息比较...
  • 深圳营业执照网上办理的流程,想在深圳创业、开公司的朋友,深圳的工商环境是很适合创业的,但是注册公司是一个流程比较复杂的事,而其中办理深圳营业执照又是很重要的一环。所以大家务必要知道如何办理深圳营业执照...
  • 1、统一社会信用代码(新版营业执照号): 新版营业执照右上方标记统一社会信用代码,由18位数字组成。  18位数字与字母组合2、营业执照注册号: 15位数字 3、组织机构代码: 8位数字+“-”+1位字母或数字 4、...
  • 营业执照过期怎么办

    2021-03-10 11:13:47
    营业执照是企业或个体工商户合法经营的凭证,对于企业来说,营业执照也是有着有效期的,到期后便需要重新更换新证,那么在生活中,营业执照过期多久作废呢,下面就一起来看看吧。 营业执照过期多久作废 一般是个体...
  • 最近有不少老铁找我,问抖音小店营业执照的问题。 比如抖音小店营业执照怎么办理? 个体营业执照和企业营业执照开店有什么区别? 新手做无货源抖音小店,营业执照范围应该怎么选? 今天这篇文章一次性搞清楚。 ...
  • 据知情人士向 Odaily星球日报透露,5 月 8 日上午,北京市工商局通知詹克团前去领取北京比特大陆科技有限公司的营业执照,在其正欲签字之时,被北京比特大陆前法人、比特大陆 CFO 刘...
  • 近日平罗县市场监管局注册登记窗口推出个体工商户“秒批”系统。今后,75%个体户常见经营项目可实现5分钟内乃至数秒无人工干预智能审批。01 一是实现智能化审批。平罗县市场监管局登记注册窗口依托自治区系统升级...
  • 我国现行的营业执照上的注册号都是15位的,不存在13位的,从07年开始国家进行了全面的注册号升级就全部都是15位的了,如果你看见的是13位的注册号那肯定是假的。  下面我来说一下注册号15位数字的含义,代码结构...
  • 营业执照识别api接口调用OCR识别

    千次阅读 2017-08-28 13:20:14
    营业执照识别 营业执照云识别 营业执照识别api产品描述 营业执照识别api开发的一款基于服务器平台的营业执照OCR识别服务程序,支持主流Windows、Linux 服务器平台。上传营业执照图像在服务器端完成识别后,...
  • 实现营业执照注册号校验

    万次阅读 2016-06-08 23:22:34
    简单的了解营业执照注册号,注册号是有15位数字组成。简单的认识一下15数字的含义:代码结构工商注册号由14位数字本体码和1位数字校验码组成,... * 15位营业执照注册号检验工具 */ public class BusinessUtils { ...
  • 9月18日,宿迁市工商局与京东集团益世商服、大数据与智能供应链事业部在京东集团总部发布国内首个电商电子营业执照区块链应用平台,宿迁市工商局、京东商城、益世商服三方成功部署区块链节点,并实际应用于京东平台...
  • 常见的营业执照有《企业法人营业执照》、《营业执照》两种。前者是取得企业法人资格的合法凭证,有限公司即属此类;后者是合法经营权的凭证,不具备法人资格的个人独资企业和合伙企业核发该种执照。  企业法人营业...
  • 7月8日上午,潍坊市首张“微信秒批”营业执照颁发仪式在潍坊综合保税区举行,标志着潍坊综合保税区保税“e秒批”智能登记系统正式上线运行。作为潍坊市试点单位,潍坊综合保税区积极推广“智能审批”企业开办模式,...
  • 营业执照工商行政管理机关发给工商企业、个体经营者的准许从事某项生产经营活动的凭证。其格式由国家市场监督管理总局统一规定。 其登记事项为:名称、地址、负责人、资金数额、经济成分、经营范围、经营方式、...
  • 由于公司业务需要,小编最近频繁奔跑于工商、税务和社保之间,没到一个地方,都要出具营业执照,登记营业执照信息,等啊等,等得花儿都谢了~ 其实,有一种技术叫营业执照自动识别/营业执照扫描识别/营业执照OCR...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 2,745
精华内容 1,098
关键字:

工商营业执照查询