bool WritePict(uint32_t IndexPict, SectorInfo * SectorInfo, Bool OutPutTypeFrame) {
uint32_t PictNumber = 0;
Point RtfLt;
CPAGE_PICTURE pict;
uint32_t NumberPage = CPAGE_GetCurrentPage();
Handle h_Page = CPAGE_GetHandlePage(NumberPage);
Handle h_Pict = CPAGE_PictureGetFirst(h_Page);
while (h_Pict) {
if (++PictNumber > IndexPict)
break;
h_Pict = CPAGE_PictureGetNext(h_Page, h_Pict);
}
if (!h_Pict)
return false;
PAGEINFO pinfo;
if (!GetPageInfo(h_Page, &pinfo))
return false;
CIMAGE_InfoDataInGet in;
BitmapInfoHeader image_info;
Point Lr;
Point Wh;
Point LrN;
Point WhN;
if (CIMAGE_GetImageInfo(pinfo.szImageName, &image_info) == FALSE)
return false;
CPAGE_PictureGetPlace(h_Page, h_Pict, 0, &Lr, &Wh);
CPAGE_PictureGetPlace(h_Page, h_Pict, -pinfo.Incline2048, &LrN, &WhN);
Lr.rx() -= TemplateOffset.x();
Lr.ry() -= TemplateOffset.y();
int FrameOffset = abs(WhN.x() - Wh.x());
if (Lr.x() < 0)
FrameOffset += abs(Lr.x());
// Получим картинку из исходного изображения задав ее контур
//определяем размер маски
if (!CPAGE_PictureGetPlace(h_Page, h_Pict, -pinfo.Incline2048, &Lr, &Wh))
return false;
Bool rc = TRUE;
//piter : Корректируем координаты из-за повернута страницы.
switch (pinfo.Angle) {
case 0:
in.dwX = Lr.x();
in.dwY = Lr.y();
in.dwWidth = Wh.x();
in.dwHeight = Wh.y();
break;
case 270:
in.dwX = pinfo.Width - (Wh.y() + Lr.y());
in.dwY = Lr.x();
in.dwWidth = Wh.y();
in.dwHeight = Wh.x();
break;
case 180:
in.dwX = pinfo.Width - (Wh.x() + Lr.x());
in.dwY = pinfo.Height - (Wh.y() + Lr.y());
in.dwWidth = Wh.x();
in.dwHeight = Wh.y();
break;
case 90:
in.dwX = Lr.y();
in.dwY = pinfo.Height - (Wh.x() + Lr.x());
in.dwWidth = Wh.y();
in.dwHeight = Wh.x();
break;
}
// end piter
BitmapPtr pOutDIB = NULL;
if (!CIMAGE_GetDIBData(PUMA_IMAGE_USER, Rect(in.dwX, in.dwY, in.dwWidth, in.dwHeight), NULL, &pOutDIB)) {
Debug() << "[WritePict] CIMAGE_GetDIBData failed: " << PUMA_IMAGE_USER << "\n";
return false;
}
// Соберем изображение
const char * szTurnName = "RFRMT:TurnPicture";
const char * szPictName = "RFRMT:Picture";
const char * szRotateName = "RFRMT:RotatePicture";
const char * lpName = szPictName;
if (CIMAGE_AddImage(szPictName, (BitmapPtr) pOutDIB)) {
switch (pinfo.Angle) {
case 90:
rc = RIMAGE_Turn(szPictName, szTurnName, RIMAGE_TURN_90);
CIMAGE_RemoveImage(lpName);
lpName = szTurnName;
break;
case 180:
rc = RIMAGE_Turn(szPictName, szTurnName, RIMAGE_TURN_180);
CIMAGE_RemoveImage(lpName);
lpName = szTurnName;
break;
case 270:
rc = RIMAGE_Turn(szPictName, szTurnName, RIMAGE_TURN_270);
CIMAGE_RemoveImage(lpName);
lpName = szTurnName;
break;
}
if (!rc) {
Debug() << "[WritePict] RIMAGE_Turn failed";
rc = FALSE;
}
} else {
Debug() << "[WritePict] CIMAGE_WriteDIB failed: " << szPictName << "\n";
}
// Довернем изображение на малый угол.
if (!RIMAGE_Rotate(lpName, szRotateName, pinfo.Incline2048, 2048)) {
Debug() << "[WritePict] RIMAGE_Rotate failed\n";
rc = FALSE;
} else {
CIMAGE_RemoveImage(lpName);
lpName = szRotateName;
}
// Маскируем полученное изображение
Point ptLt, ptWh;
if (rc && CPAGE_PictureGetPlace(h_Page, h_Pict, 0, &ptLt, &ptWh)) {
if (pinfo.Incline2048 >= 0) {
in.dwX = ptWh.y() * pinfo.Incline2048 / 2048;
in.dwY = 0;
} else {
in.dwX = 0;
// Beg of Almi Corr
// in.dwY = ptWh.x*pinfo.Incline2048/2048;
in.dwY = (-ptWh.x() * pinfo.Incline2048 / 2048);
// End of Almi Corr
}
if (!RIMAGE_RotatePoint(lpName, in.dwX, in.dwY, (int32_t *) &in.dwX,
(int32_t *) &in.dwY)) {
in.dwX = 0;
in.dwY = 0;
}
in.dwWidth = ptWh.x();
in.dwHeight = ptWh.y();
in.wByteWidth = (unsigned short) ((in.dwWidth + 7) / 8); //?
// Получим размер маски
uint32_t nSize = 0;
if (CPAGE_PictureGetMask(h_Page, h_Pict, 0, NULL, &nSize)) {
char * lpMask = (char*) malloc(sizeof(in) + nSize);
if (lpMask) {// Получаем маску
*(CIMAGE_InfoDataInGet*) lpMask = in;
if (CPAGE_PictureGetMask(h_Page, h_Pict, 0, lpMask + sizeof(in), &nSize)) {
cf::BitMask bit_mask(0, 0, (uchar*) lpMask + sizeof(in));
if (!CIMAGE_GetDIBData(lpName, Rect(in.dwX, in.dwY, in.dwWidth, in.dwHeight), &bit_mask, &pOutDIB)) {
Debug() << "CIMAGE_GetDIBData failed\n";
rc = FALSE;
}
} else {
Debug() << "PAGE_PictureGetMask failed\n";
rc = FALSE;
}
free(lpMask);
}
} else {
Debug() << "PAGE_PictureGetMask() failed\n";
rc = FALSE;
}
}
BlockElement * hPrevObject = NULL;
if (rc) {
CTDIB * pTmpDIB = new CTDIB;
pTmpDIB->setBitmap(pOutDIB);
cf::Size pictGoal;
pictGoal.rwidth() = pTmpDIB->lineWidth();
pictGoal.rheight() = pTmpDIB->linesNumber();
int32_t iDIBSize = pTmpDIB->dibSize();
delete pTmpDIB;
Rect indent;
Rect playout;
Lr.rx() = MAX(0, Lr.x());
Lr.ry() = MAX(0, Lr.y());
Rect slayout;
slayout.rleft() = Lr.x();
slayout.rright() = Lr.x() + Wh.x();
slayout.rtop() = Lr.y();
slayout.rbottom() = Lr.y() + Wh.y();
hPrevObject = SectorInfo->hObject;
if (SectorInfo->FlagInColumn || (OutPutTypeFrame && SectorInfo->FlagFictiveParagraph)) {
CEDParagraph * par = SectorInfo->hEDSector->createParagraph(SectorInfo->hColumn,
ALIGN_NONE, indent, SectorInfo->userNum, -1, playout);
par->addLine(new CEDLine(NULL, false, 6));
SectorInfo->FlagFictiveParagraph = FALSE;
}
if (RfrmtOptions::useNone() || SectorInfo->CountFragments == 1)
SectorInfo->hObject = SectorInfo->hColumn;
else {
if (SectorInfo->FlagInColumn == TRUE) {
Rect EdFragmRect;
EdFragmRect.setLeft(MAX(0, SectorInfo->OffsetFromColumn.x()));
EdFragmRect.setTop(MAX(0, SectorInfo->OffsetFromColumn.y()));
EdFragmRect.setWidth(MAX(0, Wh.x() - FrameOffset));
EdFragmRect.setHeight(Wh.y());
CEDFrame * frame = new CEDFrame(NULL, CEDFrame::HPOS_COLUMN,
CEDFrame::VPOS_PARAGRAPH);
frame->setBoundingRect(EdFragmRect);
SectorInfo->hColumn->addElement(frame);
SectorInfo->hObject = frame;
} else {
Rect EdFragmRect;
EdFragmRect.setLeft(Lr.x() - SectorInfo->Offset.x());
EdFragmRect.setTop(Lr.y() - SectorInfo->Offset.y());
EdFragmRect.setWidth(MAX(0, Wh.x() - FrameOffset));
EdFragmRect.setHeight(Wh.y());
CEDFrame * frame = new CEDFrame(NULL, CEDFrame::HPOS_COLUMN,
CEDFrame::VPOS_PARAGRAPH);
frame->setBoundingRect(EdFragmRect);
frame->dxfrtextx = 0;
frame->dxfrtexty = 0;
SectorInfo->hColumn->addElement(frame);
SectorInfo->hObject = frame;
}
}
CEDParagraph * ced_par = SectorInfo->hEDSector->createParagraph(SectorInfo->hObject,
ALIGN_NONE, indent, SectorInfo->userNum, -1, playout);
CEDLine * ced_line = new CEDLine;
// TODO hard coded font value
ced_line->setDefaultFontHeight(6);
CEDPicture * ced_pict = new CEDPicture();
ced_pict->setBoundingRect(slayout);
ced_pict->setPictureNumber(IndexPict);
ced_pict->setAlign(ED_ALIGN_MIDDLE);
uchar * img_data = new uchar[iDIBSize];
memcpy(img_data, pOutDIB, iDIBSize);
ced_pict->setImage(new Image(img_data, iDIBSize, Image::AllocatorNew));
ced_pict->image()->setSize(slayout.size());
ced_line->addElement(ced_pict);
ced_par->addLine(ced_line);
}
// piter
// освобождает память переданную по pOutDIB
CIMAGE_RemoveImage(lpName);
CIMAGE_FreeCopiedDIB(pOutDIB);
// end piter
SectorInfo->hObject = hPrevObject;
return TRUE;
}
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;
}
