CPrepHstr::~CPrepHstr() {
if (hStrCCOM)
CCOM_DeleteContainer(hStrCCOM);
delete[] pRc;
delete[] begx;
delete[] movey;
delete[] flmovey;
delete[] hi;
}
void NegMoveMas(Handle* hCCOM,int n,int num)
{
int i;
CCOM_DeleteContainer(hCCOM[num]);
for(i=num;i<n-1;i++)
{
hCCOM[i]=hCCOM[i+1];
}
hCCOM[n-1]=0;
}
void NegRecog(Handle hCPage,NegList** proot,int& nRC,int skew)
{
uint32_t code_recd=512<<19;
uint32_t code_resd=(512<<19)+(512<<16);
CCOM_handle hNegCCOM;
CCOM_comp * pcomp;
Rect16* pN;
Rect16* pRc;
int i,j,r;
int medium_w;
int nN=0;
int len_neg_mas=100;
int add_len_mas=50;
Bool vertical;
char Alf[256];
Bool nomem=FALSE;
NegList* root=(*proot);
NegList* now=root;
NegList* temp;
uchar Prob[3];
double neg_str_control;
int len_result;
double prec;
double prob0[2], prob1[2];
for(i=1;i<nRC;i++)
now=now->next;
NegSetAlf(Alf);
while(now)
{
if((now->neg).rot.pmasp)
{
if((now->neg).nRc>10)
{
delete[] (now->neg).rot.hi;
(now->neg).rot.hi= new int[(now->neg).nRc];
}
RSELSTR_UnRotateRect(-skew,(now->neg).pRc,(now->neg).nRc,(now->neg).rot.Rc,(now->neg).rot.begx,(now->neg).rot.movey,(now->neg).rot.flmovey,(now->neg).rot.hi);
}
pRc=(now->neg).pRc;
vertical=FALSE;
if(!((pRc[(now->neg).nRc-1].bottom-pRc[0].top)*2<(pRc[0].right-pRc[0].left)))
{
vertical=TRUE;
}
for(i=(now->neg).nRc-1;i>=0;i--)
{
nomem=FALSE;
len_neg_mas=100;
nN=0;
hNegCCOM=0;
hNegCCOM=GetNegCCOM(hCPage,pRc,i);
if(!hNegCCOM)
continue;
if(i<MAX_STR)
now->neg.hCCOM[i]=hNegCCOM;
pcomp = CCOM_GetFirst (hNegCCOM, NULL);
if(pcomp==NULL)
{
NegMoveMas((now->neg).pRc,(now->neg).nRc,i);
NegMoveMas(now->neg.hCCOM,now->neg.nRc,i);
if(i==0)
{
(now->neg).p_rec/=(double)((now->neg).nRc);
(now->neg).p_str/=(double)((now->neg).nRc);
(now->neg).p=((now->neg).p_rec+(now->neg).p_str)/2.;
if(dpPrintResConsole)
{
LDPUMA_ConsoleN("");
LDPUMA_Console("Ќегатив с веро¤тностью :");
LDPUMA_ConsoleN("");
LDPUMA_Console("по внутренней структуре ");
NegPrintConsol((now->neg).p_str);
LDPUMA_Console("по результатам распозновани¤ ");
NegPrintConsol((now->neg).p_rec);
LDPUMA_Console("итого ");
NegPrintConsol((now->neg).p);
LDPUMA_ConsoleN("площадь=%d",(int)((now->neg).pRc[0].right-(now->neg).pRc[0].left+1)*(int)((now->neg).pRc[0].bottom-(now->neg).pRc[(now->neg).nRc-1].top+1));
}
if(dpNegResD )
{
Rect16 Rect;
Rect.bottom=(now->neg).pRc[0].bottom;
Rect.left=(now->neg).pRc[0].left;
Rect.right=(now->neg).pRc[0].right+1;
Rect.top=(now->neg).pRc[(now->neg).nRc-1].top-1;
LDPUMA_DrawRect (MainWindowD, &(Rect),0,RGB(0,0,255), 1,code_resd );
LDPUMA_WaitUserInput (NegResD,MainWindowD);
LDPUMA_DeleteRects (MainWindowD,code_resd);
}
}
}
if(pcomp==NULL)
continue;
if(!(InitNegMas(&pN,len_neg_mas)))
continue;
InitRc(pN,nN,pcomp);
nN++;
for(;;)
{
pcomp = CCOM_GetNext (pcomp, NULL);
if (pcomp==NULL)
break;
if (nN>=len_neg_mas)
{
AddLenNegMas(&pN,len_neg_mas,add_len_mas);
}
InitRc(pN,nN,pcomp);
nN++;
}
if(i>=MAX_STR)
CCOM_DeleteContainer(hNegCCOM);
if((now->neg).rot.pmasp)
{
RSELSTR_CleanStr(pN,NULL,nN,pRc[i].top,pRc[i].left,(now->neg).rot.hi[i],pRc[i].right-pRc[i].left+1,skew,FALSE);
}
if(!nN)
DelNegMas(&pN);
if(!nN)
continue;
/*ѕрорисовка компонент в негативе*/
if(nN>0)
{
if(dpNegRecD)
{
for(j=0;j<nN;j++)
NegDrawRect(MainWindowD,code_recd,RGB(0,0,255),pN[j]);
LDPUMA_WaitUserInput (NegRecD,MainWindowD);
if(LDPUMA_Skip (NegRecDC) )
LDPUMA_DeleteRects (MainWindowD,code_recd);
}
}
SortLetter(pN,nN,vertical);
neg_str_control=NegStrControl(pN,nN,vertical,&(now->neg.pRc[i]));
(now->neg).p_str+=neg_str_control;
RecVersions* vs;
UniVersions* uvs;
if(!(InitNegMas(&vs,nN)))
{
nomem=TRUE;
DelNegMas(&pN);
}
if(nomem==TRUE)
continue;
if(!(InitNegMas(&uvs,nN)))
{
nomem=TRUE;
DelNegMas(&pN);
DelNegMas(vs);
}
if(nomem==TRUE)
continue;
RecRaster rec;
int16_t Language;
int turn;
if(neg_str_control/2.>inf_prob-.5)
{
if( !(CCOM_GetLanguage(hNegCCOM, &Language)) )
Language=7;
for(j=0; j<2; j++)
{
prob0[j] = 0;
prob1[j] = 0;
}
Bool32 ShowNegByOne = !LDPUMA_Skip(hShowNegComps);
Handle comp_window = NULL;
for(j=0;j<nN;j++)
{
if( NegGetRaster(hCPage,pN[j],&rec,vertical) )
{
if(!dpRecOneLetter)
{
// if (vertical) TurnOverNeg(&rec);
for(turn=0; turn<2; turn++)
{
//-----------------------------------------------------------
if (ShowNegByOne/* && vertical*/)
{
BITMAPINFOHEADER lpBI; // Pointer to DIB info structure
RGBQUAD Palette1;
RGBQUAD Palette2;
uint32_t bfSize, dwDIBSize;
HANDLE hDIB;
uchar* pDIB;
uchar* pTmpDIB;
uchar* pTmpBuffer;
uint16_t Height, Width, ByteWidth;
CIMAGEBITMAPINFOHEADER image_info = {0};
Height = (uint16_t)rec.lnPixHeight;
Width = (uint16_t)rec.lnPixWidth;
ByteWidth = (Width+7)/8;
dwDIBSize = 64 * Height;
bfSize = dwDIBSize + sizeof(BITMAPINFOHEADER) + 2*sizeof(RGBQUAD);
///////////////// Bitmap information header //////////////////////////////////
lpBI.biSize = sizeof(BITMAPINFOHEADER);
lpBI.biWidth = 64;
lpBI.biHeight = Height;
lpBI.biPlanes = 0x1;
lpBI.biBitCount = 0x1;
lpBI.biCompression = 0;
lpBI.biSizeImage = dwDIBSize;
CIMAGE_GetImageInfo((puchar)PUMA_IMAGE_USER, &image_info);
lpBI.biXPelsPerMeter = image_info.biXPelsPerMeter;
lpBI.biYPelsPerMeter = image_info.biYPelsPerMeter;
lpBI.biClrUsed = 0;
lpBI.biClrImportant = 0;
/////////////// Palette ///////////////////////////////////////////////////////////
Palette1.rgbBlue = 0xFF;
Palette1.rgbGreen = 0xFF;
Palette1.rgbRed = 0xFF;
Palette1.rgbReserved = 0;
Palette2.rgbBlue = 0;
Palette2.rgbGreen = 0;
Palette2.rgbRed = 0;
Palette2.rgbReserved = 0;
hDIB = calloc(1, bfSize);
if (hDIB != 0)
{
pDIB = static_cast<uchar*> (hDIB);
pTmpDIB = pDIB;
///////// filling Dib ///////////////////////////////////////////////////////////
memcpy(pTmpDIB, &lpBI, sizeof(BITMAPINFOHEADER));
pTmpDIB += sizeof(BITMAPINFOHEADER);
memcpy(pTmpDIB, &Palette1, sizeof(RGBQUAD));
pTmpDIB += sizeof(RGBQUAD);
memcpy(pTmpDIB, &Palette2, sizeof(RGBQUAD));
pTmpDIB += sizeof(RGBQUAD);
pTmpBuffer = rec.Raster;
uchar* pTempDib = pTmpDIB;
for(int i=0; i<Height; i++ )
{
memcpy(pTmpDIB, pTmpBuffer, 8);
pTmpDIB += 8;
pTmpBuffer += 8;
}
TurnOverNeg(rec, pTempDib);
const char *pText;
pText = turn ? "Component up-down" : "Component down-up";
comp_window = LDPUMA_CreateWindow(pText, pDIB);
// LDPUMA_WaitUserInput(hShowNegComps, comp_window);
free(hDIB);
}
}
//----------------------------------------------------------------------
if( !(RSTR_RecogOneLetter_all (&rec,Alf, &(vs[j]),(int32_t)(1)) ) )
Prob[1]=0;
else
{
if (!turn) Prob[1]=vs[j].Alt[0].Prob;
prob1[turn] += NegRecControl((int)vs[j].Alt[0].Prob);
if (ShowNegByOne)
LDPUMA_ConsoleN("handprint symbol: %c , probability = %d", (char)vs[j].Alt[0].Code, vs[j].Alt[0].Prob);
}
// if( !(RSTR_RecogOneLetter_all (&rec,Alf, &(vs[j]),(int32_t)(2)) ) )
// Prob[2]=0;
// else
// Prob[2]=vs[j].Alt[0].Prob;
if( !(RSTR_RecogOneLetter_all (&rec,Alf, &(vs[j]),(int32_t)(0)) ) )
Prob[0]=0;
else
{
if (!turn) Prob[0]=vs[j].Alt[0].Prob;
prob0[turn] += NegRecControl((int)vs[j].Alt[0].Prob);
if (ShowNegByOne)
LDPUMA_ConsoleN("print symbol: %c , probability = %d", (char)vs[j].Alt[0].Code, vs[j].Alt[0].Prob);
}
if (ShowNegByOne)
LDPUMA_WaitUserInput(hShowNegComps, comp_window);
if (!vertical) break;
if (!turn) TurnRaster(&rec);
}
vs[j].Alt[0].Prob=(uchar)( ((int)(Prob[0])+(int)(Prob[1])/*+(int)(Prob[2])*/)/2/*3*/);
/*else
{
vs[j].lnAltMax =uvs[j].lnAltMax;
vs[j].lnAltCnt=uvs[j].lnAltCnt;
for(int alt=0;alt<uvs[j].lnAltCnt;alt++)
{
vs[j].Alt[alt].Code=uvs[j].Alt[alt].Code[0];
vs[j].Alt[alt].Prob=uvs[j].Alt[alt].Prob;
}
}*/
}
else
{
if( !(RSTR_RecogOneLetter (&rec, (uchar)(Language), &(vs[j])) ) )
vs[j].Alt[0].Prob=0;
}
}
else
vs[j].Alt[0].Prob=0;
}
}
if(vertical)
ToHoriz(pN,nN);
medium_w=GetMediumW(pN,nN);
int medium_h=GetMediumH(pN,nN);
uchar* result=NULL;
if(!(result=new uchar[nN*2]))
{
nomem=TRUE;
DelNegMas(&pN);
DelNegMas(vs);
DelNegMas(uvs);
}
if(nomem==TRUE)
continue;
len_result=0;
NegPutLetter(result,len_result,vs[0].Alt[0],FALSE);
if(neg_str_control/2.>inf_prob-.5)
{
prec=NegRecControl(vs[0].Alt[0].Prob);
for(j=1;j<nN;j++)
{
prec+=NegRecControl(vs[j].Alt[0].Prob);
/* if( (pN[j].left-pN[j-1].right)>(medium_w/2)*3+2)
{
NegPutLetter(result,len_result,vs[j].Alt[0],TRUE);
if( (pN[j].right-pN[j].left+1>(pN[j].bottom-pN[j].top+1)*2) && (pN[j].bottom-pN[j].top+1<medium_h/2) )
result[len_result-1]='-';
if( (pN[j].top<pN[j-1].top) && (pN[j].bottom-pN[j].top+1<medium_h/2) )
{
len_result--;
if( IfExistI(vs[j-1]) )
result[len_result-1]=256+'…';
}
if((pN[j].bottom-pN[j].top+1<(medium_h/3)*2)&&( (result[len_result-1]=='I')||(result[len_result-1]=='|')||((result[len_result-1]=='?') && (IfExistDef(vs[j]))) ) )
result[len_result-1]=',';
}
else
{
NegPutLetter(result,len_result,vs[j].Alt[0],FALSE);
if( (pN[j].right-pN[j].left+1>(pN[j].bottom-pN[j].top+1)*2) && (pN[j].bottom-pN[j].top+1<medium_h/2) )
result[len_result-1]='-';
if( (pN[j].top<pN[j-1].top) && (pN[j].bottom-pN[j].top+1<medium_h/2) )
{
len_result--;
if( IfExistI(vs[j-1]) )
result[len_result-1]=256+'…';
}
if((pN[j].bottom-pN[j].top+1<(medium_h/3)*2)&&( (result[len_result-1]=='I')||(result[len_result-1]=='|')||((result[len_result-1]=='?') && (IfExistDef(vs[j]))) ) )
result[len_result-1]=',';
}*/
}
r=1;
(now->neg).p_rec+=prec/(double)(nN);
}
/* for(j=1;j<nN;j++)
{
if(result[r]!='?')
{
if(result[r]!=' ')
{
if(result[r]=='|')
result[r]='I';
if(Language==7)
{
if( ((result[r-1]==256+'ь')||(result[r-1]==256+'№'))&&((result[r]=='I' )||(result[r]=='i')||(result[r]=='1')||(result[r]=='l')) )
{
if(result[r-1]==256+'ь')
result[r-1]=256+'ы';
else
result[r-1]=256+'џ';
NegMoveResult(result,len_result,r);
r--;
}
if( (result[r-1]!=' ')&&(result[r-1]!='?')&&(!(IfGl(result[r-1])))&&(result[r]==256+'ƒ') )
{
if(IfExistA(vs[j]))
{
if(j<nN-1)
{
if(!(IfGl(result[r+1])))
result[r]=256+'ј';
}
else
result[r]=256+'ј';
}
}
}
if( (pN[j].right-pN[j].left+1>pN[j].bottom-pN[j].top+1) && (result[r]=='I') )
result[r]='-';
r++;
}
else
{
j--;
r++;
}
}
else
r++;
}
*/
//Andrey
(now->neg).Flags = 0;
if (vertical)
{
if(dpPrintResConsole)
{
LDPUMA_Console("\n down-up print:");
NegPrintConsol((double)prob0[0]/nN);
LDPUMA_Console("down-up handprint:");
NegPrintConsol((double)prob1[0]/nN);
LDPUMA_Console("up-down print:");
NegPrintConsol((double)prob0[1]/nN);
LDPUMA_Console("up-down handprint:");
NegPrintConsol((double)prob1[1]/nN);
}
double down_up = (prob0[0]+prob1[0])/2;
double up_down = (prob0[1]+prob1[1])/2;
(now->neg).Flags |= FlVert;
if (down_up > up_down) (now->neg).Flags |= FlDown2Up;
}
if(i==(now->neg).nRc-1)
{
if(dpPrintResConsole)
NegPrintConsol(pRc[0].left,pRc[(now->neg).nRc-1].top,pRc[0].right,pRc[0].bottom);
}
if(dpPrintResConsole)
NegPrintConsol(result,len_result);
if(i==0)
{
(now->neg).p_rec/=(double)((now->neg).nRc);
(now->neg).p_str/=(double)((now->neg).nRc);
(now->neg).p=((now->neg).p_rec+(now->neg).p_str)/2.;
if(dpPrintResConsole)
{
LDPUMA_ConsoleN("");
LDPUMA_Console("Ќегатив с веро¤тностью :");
LDPUMA_ConsoleN("");
LDPUMA_Console("по внутренней структуре ");
NegPrintConsol((now->neg).p_str);
LDPUMA_Console("по результатам распозновани¤ ");
NegPrintConsol((now->neg).p_rec);
LDPUMA_Console("итого ");
NegPrintConsol((now->neg).p);
LDPUMA_ConsoleN("площадь=%d",(int)((now->neg).pRc[0].right-(now->neg).pRc[0].left+1)*(int)((now->neg).pRc[0].bottom-(now->neg).pRc[(now->neg).nRc-1].top+1));
}
}
if(i==0)
{
if(dpNegResD)
{
Rect16 Rect;
Rect.bottom=(now->neg).pRc[0].bottom;
Rect.left=(now->neg).pRc[0].left;
Rect.right=(now->neg).pRc[0].right+1;
Rect.top=(now->neg).pRc[(now->neg).nRc-1].top-1;
LDPUMA_DrawRect (MainWindowD, &(Rect),0,RGB(0,0,255), 1,code_resd );
LDPUMA_WaitUserInput (NegResD,MainWindowD);
LDPUMA_DeleteRects (MainWindowD,code_resd);
}
}
DelNegMas(vs);
DelNegMas(uvs);
delete[] result;
DelNegMas(&pN);
}
// if((now->neg).rot.pmasp)
// DeleteRotateMas(&((now->neg).rot.pmasp),&((now->neg).rot.begx),&((now->neg).rot.movey),&((now->neg).rot.flmovey),&((now->neg).rot.hi));
if(!(now->neg).nRc)
{
temp=now;
if(!temp->prev)
root=temp->next;
now=now->prev;
delete temp;
nRC--;
}
else
now=now->prev;
}
(*proot)=root;
}
Bool32 RemoveLines(PRSPreProcessImage Image, puchar * lppDIB)
{
Handle hccom = *Image->phCCOM;
Handle hcpage = Image->hCPAGE;
Handle *hLinesCCOM = Image->phLinesCCOM;
puchar hDIB = NULL;
Bool32 rc = TRUE;
*hLinesCCOM = NULL;
CCOM_comp *victim[100];
int32_t nvict,i;
Bool32 yes_victim = FALSE;
//
// Удалим линии
//
if(!LDPUMA_Skip(ObvKillLines)||(LDPUMA_Skip(hNewLine)&&LDPUMA_Skip(Image->hDebugCancelVerifyLines)))
rc=DeleteLines(hcpage,Image->phCLINE,PUMA_IMAGE_DELLINE);
else
{
if(rc && !RLINE_DeleteLines(hcpage,PUMA_IMAGE_DELLINE))
{
SetReturnCode_rstuff(RLINE_GetReturnCode());
rc = FALSE;
}
if (rc && LDPUMA_Skip(NotKillPointed) && LDPUMA_Skip(Image->hDebugCancelSearchDotLines))
rc = DeleteDotLines(Image->phCLINE, PUMA_IMAGE_DELLINE);
}
LDPUMA_Skip(hPrep2);
//
// Получим изображение с удаленными линиями
//
if(rc && !CIMAGE_ReadDIB((puchar)PUMA_IMAGE_DELLINE,(Handle*)&hDIB,TRUE))
{
SetReturnCode_rstuff(CIMAGE_GetReturnCode());
rc = FALSE;
}
if(hDIB)
{
//
// Удалим компоненты и выделим их заново.
//
*lppDIB = (puchar)hDIB;
if(rc)
{
//if( CCOM_GetContainerVolume((CCOM_handle)*Image->phCCOM)>30000 )
// CCOM_CompressContatiner((CCOM_handle)*Image->phCCOM);
if( CCOM_GetContainerVolume((CCOM_handle)*Image->phCCOM)<60000 &&
MyGetZher ((void**)victim, &nvict, 100, hcpage) && nvict )
yes_victim = TRUE;
if( !yes_victim )
{
CCOM_DeleteContainer((CCOM_handle)*Image->phCCOM);
*Image->phCCOM = 0;
}
if(!ExtractComponents(FALSE, hLinesCCOM, (puchar)PUMA_IMAGE_DELLINE, Image))
{
rc = FALSE;
}
else
{
PAGEINFO inf = {0};
GetPageInfo(Image->hCPAGE,&inf);
strcpy((char*)inf.szImageName,PUMA_IMAGE_DELLINE);
inf.Images|=IMAGE_DELLINE;
SetPageInfo(Image->hCPAGE,inf);
}
if(rc)
{
*Image->phCCOM = (Handle)REXCGetContainer();
if(*Image->phCCOM == 0)
{
SetReturnCode_rstuff(REXC_GetReturnCode());
rc = FALSE;
}
hccom = *Image->phCCOM;
if( *hLinesCCOM )
{
//
// Refersh CCOM
//
CCOM_comp *exa=CCOM_GetFirst((CCOM_handle)*hLinesCCOM,NULL);
if( yes_victim )
{
/*
Rect16 rect1;
uint32_t key = 111;
for(i=0;i<nvict;i++)
{
exa = victim[i];
rect1.top = exa->upper;
rect1.left = exa->left;
rect1.bottom = exa->upper+exa->h;
rect1.right = exa->left+exa->w;
LDPUMA_DrawRect(NULL, &rect1, 0, 23635, 1, key);
}
if(!LDPUMA_Skip(hShowCheckLetters))
{
LDPUMA_Console("Puma_Коробки жертв \n");
LDPUMA_WaitUserInput(NULL, NULL);
LDPUMA_DeleteRects(NULL, key);
}
*/
for(i=0;i<nvict;i++)
{
exa = victim[i];
if( remove_overlayed(exa,(CCOM_handle)*Image->phCCOM) )
{
CCOM_comp *dup=CCOM_New((CCOM_handle)*Image->phCCOM,exa->upper,exa->left,exa->w,exa->h);
if( dup )
{
CCOM_Store(dup,0,
exa->size_linerep,
exa->linerep, exa->nl,
exa->begs, exa->ends,
exa->vers, NULL);
dup->scale= exa->scale;
dup->type = exa->type;
dup->cs = exa->cs;
}
}
}
}
CCOM_DeleteContainer((CCOM_handle)*hLinesCCOM);
}
}
else
LDPUMA_Console("Пропущен этап выделения компонент после удаления линий.\n");
}
}
return rc;
}
//////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
// Выделение компонент
Bool32 ExtractComponents( Bool32 bIsRotate, Handle * prev_ccom, puchar name, PRSPreProcessImage Image)
{
Bool32 rc = TRUE;
ExcControl exc = {0};
// RSGETMODULEPATH pGetModulePath;
// RSSETUPDATE pSetUpdate;
//
// if ( ProgressPoints.pGetModulePath && ProgressPoints.pSetUpdate)
// {
// pGetModulePath = (RSGETMODULEPATH)ProgressPoints.pGetModulePath;
// pSetUpdate = (RSSETUPDATE)ProgressPoints.pSetUpdate;
// }
// else
// {
// return false;
// }
if(prev_ccom)
{
*prev_ccom = *Image->phCCOM ? *Image->phCCOM: NULL;
*Image->phCCOM=NULL;
}
else
{
CCOM_DeleteContainer((CCOM_handle)*Image->phCCOM);
*Image->phCCOM=NULL;
}
if(!REXC_SetImportData(REXC_ProgressStep, (void*)rexcProgressStep))
{
SetReturnCode_rstuff(REXC_GetReturnCode());
return FALSE;
}
// будет распознавания эвентами
//Andrey: опознавалка вынесена в отдельный модуль RRecCom
exc.Control = Ex_ExtraComp|/*Ex_EvnRecog|*/Ex_Picture;
//exc.Control |= Ex_NetRecog;
//Andrey: orientation is obtained from new library RNORM
//exc.Control |= ( bIsRotate ? Ex_Orient : 0 );
//Andrey: without flag Ex_PictureLarge big comps aren't extracted which may cause loss of big negatives
// if( Image->gnPictures )
exc.Control |= Ex_PictureLarge;
/*//Andrey: опознавалка вынесена в отдельный модуль RRecCom
if(rc && !REXC_SetEVNProperties(exc, GetModulePath(),(uchar)Image->gnLanguage) )
{ // инициализировать распознавание по эвентам и задать алфавит
SetReturnCode_rstuff(REXC_GetReturnCode());
rc = FALSE;
}
else
*/ {
uchar w8 = (uchar)Image->gbDotMatrix;
REXC_SetImportData(REXC_Word8_Matrix,&w8);
w8 = (uchar)Image->gbFax100;
REXC_SetImportData(REXC_Word8_Fax1x2,&w8);
}
//exc.Control ^= Ex_EvnRecog;
/*
if(rc && !REXCExtraDIB( exc, lpdata,0,0,0,0) ) // поиск компонент в DIB-e
*/
CIMAGEIMAGECALLBACK clbk;
if(rc && !CIMAGE_GetCallbackImage(name, &clbk))
{
SetReturnCode_rstuff(CIMAGE_GetReturnCode());
rc = FALSE;
}
if( rc && !REXCExtracomp3CB(exc, // поиск компонент by 3CallBacks
(TImageOpen)clbk.CIMAGE_ImageOpen,
(TImageClose)clbk.CIMAGE_ImageClose,
(TImageRead)clbk.CIMAGE_ImageRead)
)
{
SetReturnCode_rstuff(REXC_GetReturnCode());
rc = FALSE;
}
if(rc)
{
*Image->phCCOM = (Handle)REXCGetContainer();
if(*Image->phCCOM==0)
{
SetReturnCode_rstuff(REXC_GetReturnCode());
rc = FALSE;
}
RRecComControl rec_control;
memset(&rec_control, 0, sizeof(RRecComControl));
rec_control.flags = RECOG_EVN;
if (!RRECCOM_Recog(*(Image->phCCOM), rec_control, GetModulePath(), (uchar)Image->gnLanguage))
{
SetReturnCode_rstuff(RRECCOM_GetReturnCode());
rc = FALSE;
}
}
if(rc)
SetUpdate(FLG_UPDATE_NO,FLG_UPDATE_CCOM);
return rc ;
}
Bool CutComp(Handle hCPAGE, CCOM_handle hCCOM, CCOM_comp* comp, int bound, Bool fl_cut) {
RecRaster rast;
int ii;
if (!CCOM_GetRaster(comp, &rast))
return FALSE;
RecRaster rast2;
for (ii = REC_MAX_RASTER_SIZE - 1; ii; ii--)
rast2.Raster[ii] = 0;
int rast_bound = (bound - comp->upper + 1) >> (comp->scale);
int nowbyte = 0;
int j = rast.lnPixHeight * 8 * ((rast.lnPixWidth + 63) / 64);
Rect16 rect1;
Rect16 rect2;
CCOM_comp* comp1;
CCOM_comp* comp2;
uchar* lp = NULL;
// uchar* old;
// int16_t lp_size;
// int16_t numcomp;
for (ii = rast_bound * 8 * ((rast.lnPixWidth + 63) / 64); ii < j; ii++) {
rast2.Raster[nowbyte] = rast.Raster[ii];
rast.Raster[ii] = 0;
nowbyte++;
}
rast2.lnPixHeight = rast.lnPixHeight - rast_bound;
rast2.lnPixWidth = rast.lnPixWidth;
rast2.lnRasterBufSize = REC_MAX_RASTER_SIZE;
rast.lnPixHeight = rast_bound;
rect1.top = comp->upper;
rect1.bottom = bound;
rect1.left = comp->left;
rect1.right = rect1.left + comp->w - 1;
rect2.top = bound + 1;
rect2.bottom = comp->upper + comp->h - 1;
rect2.left = comp->left;
rect2.right = comp->left + comp->w - 1;
// CleanRaster(&rast,&rect1,comp->scale);
// CleanRaster(&rast2,&rect2,comp->scale);
comp1 = CCOM_New(hCCOM, rect1.top, rect1.left, rect1.right - rect1.left + 1, rect1.bottom
- rect1.top + 1);
if (!comp1)
return FALSE;
comp2 = CCOM_New(hCCOM, rect2.top, rect2.left, rect2.right - rect2.left + 1, rect2.bottom
- rect2.top + 1);
if (!comp2) {
CCOM_Delete(hCCOM, comp1);
return FALSE;
}
comp1->scale = comp2->scale = comp->scale;
while (comp1->scale) {
if (!Increase2(&rast, comp1))
break;
}
while (comp2->scale) {
if (!Increase2(&rast2, comp2))
break;
}
CCOM_Delete(hCCOM, comp1);
CCOM_Delete(hCCOM, comp2);
CCOM_cont * hCutCCOM1 = 0;
CCOM_handle hCutCCOM2 = 0;
Rect16 Rc;
Rc.left = comp->left;
Rc.right = comp->left + comp->w - 1;
Rc.top = comp->upper;
Rc.bottom = bound;
int min_h_1 = inf_let_h;
int min_h_2 = inf_let_h;
if (type_let == 1)
min_h_1 = inf_dust_h;
if (type_let == 2)
min_h_2 = inf_dust_h;
hCutCCOM1 = GetStrCCOM(hCPAGE, NULL, Rc, FALSE, FALSE, &rast, min_h_1);
if (!hCutCCOM1)
return FALSE;
Rc.left = comp->left;
Rc.right = comp->left + comp->w - 1;
Rc.top = bound + 1;
Rc.bottom = comp->upper + comp->h - 1;
hCutCCOM2 = GetStrCCOM(hCPAGE, NULL, Rc, FALSE, FALSE, &rast2, min_h_2);
if (!hCutCCOM2) {
CCOM_DeleteContainer(hCutCCOM1);
return FALSE;
}
comp1 = CCOM_GetFirst(hCutCCOM1, NULL);
if (comp1 == NULL) {
CCOM_DeleteContainer(hCutCCOM1);
CCOM_DeleteContainer(hCutCCOM2);
return FALSE;
}
CCOM_comp* newcomp;
CCOM_comp* prev_comp = comp1;
while (comp1) {
newcomp = CCOM_New(hCCOM, comp1->upper + comp->upper - 1, comp1->left + comp->left,
comp1->w, comp1->h);
if (newcomp) {
CCOM_Copy(newcomp, comp1);
MyCreateComp(newcomp);
}
prev_comp = comp1;
comp1 = CCOM_GetNext(comp1, NULL);
}
comp1 = prev_comp;
comp2 = CCOM_GetFirst(hCutCCOM2, NULL);
if (comp2)
prev_comp = comp2;
else
prev_comp = comp1;
while (comp2) {
newcomp = CCOM_New(hCCOM, comp2->upper + bound, comp2->left + comp->left, comp2->w,
comp2->h);
if (newcomp) {
CCOM_Copy(newcomp, comp2);
MyCreateComp(newcomp);
}
prev_comp = comp2;
comp2 = CCOM_GetNext(comp2, NULL);
}
comp2 = prev_comp;
comp1->upper += comp->upper - 1;
comp1->left += comp->left;
if (comp2 != comp1) {
comp2->upper += bound;
comp2->left += comp->left;
}
FILE* f = NULL;
if (fl_cut == 0)
f = f_cut_comp;
if (fl_cut == 1)
f = f_cut_str;
if (f) {
int max_count = 6;
int i;
// if(oldRoot.top>comp->upper||oldRoot.bottom<comp->upper+comp->h-1||oldRoot.left>comp->left||oldRoot.right<comp->left+comp->w-1)
// {
fprintf(f, "Top:%d", comp1->upper);
for (i = GetCountNumbers(comp1->upper); i <= max_count; i++)
fprintf(f, " ");
fprintf(f, "Bottom:%d", comp1->upper + comp1->h - 1);
for (i = GetCountNumbers(comp1->upper + comp1->h - 1); i <= max_count; i++)
fprintf(f, " ");
fprintf(f, "Left:%d", comp1->left);
for (i = GetCountNumbers(comp1->left); i <= max_count; i++)
fprintf(f, " ");
fprintf(f, "Right:%d", comp1->left + comp1->w - 1);
for (i = GetCountNumbers(comp1->left + comp1->w - 1); i <= max_count; i++)
fprintf(f, " ");
fprintf(f, "\n");
fprintf(f, "Top:%d", comp2->upper);
for (i = GetCountNumbers(comp2->upper); i <= max_count; i++)
fprintf(f, " ");
fprintf(f, "Bottom:%d", comp2->upper + comp2->h - 1);
for (i = GetCountNumbers(comp2->upper + comp2->h - 1); i <= max_count; i++)
fprintf(f, " ");
fprintf(f, "Left:%d", comp2->left);
for (i = GetCountNumbers(comp2->left); i <= max_count; i++)
fprintf(f, " ");
fprintf(f, "Right:%d", comp2->left + comp2->w - 1);
for (i = GetCountNumbers(comp2->left + comp2->w - 1); i <= max_count; i++)
fprintf(f, " ");
fprintf(f, "\n");
/*
oldRoot.top=comp->upper;
oldRoot.bottom=comp->upper+comp->h-1;
oldRoot.left=comp->left;
oldRoot.right=comp->left+comp->w-1;
}
*/
}
FILE* f_temp = NULL;
if (fl_cut == 0)
f_temp = f_temp_cut_comp;
if (fl_cut == 1)
f_temp = f_temp_cut;
if (f_temp) {
int max_count = 6;
int i;
// if(oldRoot.top>comp->upper||oldRoot.bottom<comp->upper+comp->h-1||oldRoot.left>comp->left||oldRoot.right<comp->left+comp->w-1)
// {
fprintf(f_temp, "Top:%d", comp1->upper);
for (i = GetCountNumbers(comp1->upper); i <= max_count; i++)
fprintf(f_temp, " ");
fprintf(f_temp, "Bottom:%d", comp1->upper + comp1->h - 1);
for (i = GetCountNumbers(comp1->upper + comp1->h - 1); i <= max_count; i++)
fprintf(f_temp, " ");
fprintf(f_temp, "Left:%d", comp1->left);
for (i = GetCountNumbers(comp1->left); i <= max_count; i++)
fprintf(f_temp, " ");
fprintf(f_temp, "Right:%d", comp1->left + comp1->w - 1);
for (i = GetCountNumbers(comp1->left + comp1->w - 1); i <= max_count; i++)
fprintf(f_temp, " ");
fprintf(f_temp, "\n");
fprintf(f_temp, "Top:%d", comp2->upper);
for (i = GetCountNumbers(comp2->upper); i <= max_count; i++)
fprintf(f_temp, " ");
fprintf(f_temp, "Bottom:%d", comp2->upper + comp2->h - 1);
for (i = GetCountNumbers(comp2->upper + comp2->h - 1); i <= max_count; i++)
fprintf(f_temp, " ");
fprintf(f_temp, "Left:%d", comp2->left);
for (i = GetCountNumbers(comp2->left); i <= max_count; i++)
fprintf(f_temp, " ");
fprintf(f_temp, "Right:%d", comp2->left + comp2->w - 1);
for (i = GetCountNumbers(comp2->left + comp2->w - 1); i <= max_count; i++)
fprintf(f_temp, " ");
fprintf(f_temp, "\n");
/*
oldRoot.top=comp->upper;
oldRoot.bottom=comp->upper+comp->h-1;
oldRoot.left=comp->left;
oldRoot.right=comp->left+comp->w-1;
}
*/
}
if ((!LDPUMA_Skip(CutCompD) && fl_cut == 0) || (!LDPUMA_Skip(CutStrD) && fl_cut == 1)) {
if (!WasCutComp && fl_cut == 0)
WasCutComp = TRUE;
if (!WasCut && fl_cut == 1)
WasCut = TRUE;
DrawRect(MainWindowD, code_comp_cut_d, RGB(255,0,0), comp1->upper, comp1->upper + comp1->h
- 1, comp1->left, comp1->left + comp1->w - 1);
DrawRect(MainWindowD, code_comp_cut_d, RGB(255,0,0), comp2->upper, comp2->upper + comp2->h
- 1, comp2->left, comp2->left + comp2->w - 1);
}
CCOM_DeleteContainer(hCutCCOM1);
CCOM_DeleteContainer(hCutCCOM2);
MyKillComp(comp);
return TRUE;
// delete[] lp;
}
