DjVuSource::DjVuSource(const CString& strFileName, GP<DjVuDocument> pDoc, DocSettings* pSettings)
: m_strFileName(strFileName), m_pDjVuDoc(pDoc), m_nPageCount(0), m_bHasText(false),
m_pSettings(pSettings)
{
m_nPageCount = m_pDjVuDoc->get_pages_num();
ASSERT(m_nPageCount > 0);
m_pages.clear();
m_pages.resize(m_nPageCount);
if (pApplication != NULL)
{
if (pApplication->GetDictionaryInfo(strFileName) != NULL)
m_dictInfo.bInstalled = true;
}
PageInfo info = GetPageInfo(0, false, true);
if (info.pAnt != NULL)
{
m_dictInfo.ReadPageIndex(info.pAnt->metadata[pszPageIndexKey]);
m_dictInfo.ReadCharMap(info.pAnt->metadata[pszCharMapKey]);
m_dictInfo.ReadTitle(info.pAnt->metadata[pszTitleKey]);
m_dictInfo.ReadLangFrom(info.pAnt->metadata[pszLangFromKey]);
m_dictInfo.ReadLangTo(info.pAnt->metadata[pszLangToKey]);
}
}
void __fastcall TTiffBook::DrawCenter(TCanvas *c, int xc, int yc, int w, int h) {
//-------------------------------------------------------------------------------
// Рисует текущую страницу с центром (xc, yc) |
// Масштабирует пропроционально, в итоге будет заполнено либо w, либо h |
//-------------------------------------------------------------------------------
TTiffImage *img;
if (Page >= GetNPages()) return;
img = GetImagePage(Page);
TTiffPageInfo *pt = GetPageInfo(Page);
img->DrawCenter(c, xc, yc, w, h, pt->PageNumber);
}
void CRtfWord::calcBRect() {
PAGEINFO PageInfo;
Handle hCPAGE = CPAGE_GetHandlePage(CPAGE_GetCurrentPage());
if (!hCPAGE)
throw Exception("[CRtfWord::calcBRect] CPAGE_GetHandlePage failed");
GetPageInfo(hCPAGE, &PageInfo);
Rect tmp = charsBRect();
rotateRect(tmp, PageInfo.Angle, PageInfo.Width, PageInfo.Height);
brect_ = tmp;
}
void PageMarker::searchNegatives(CCOM_cont * cont)
{
if(hasFlag(SKIP_SEARCH_PICTURES))
return;
assert(image_data_);
PAGEINFO info;
GetPageInfo(image_data_->hCPAGE, &info);
RNEG_RecogNeg(cont, image_data_->hCPAGE, (uchar*) info.szImageName, info.Incline2048);
}
bool __fastcall TTiffBook::SaveBook(String TiffFiln, TPanel *SaveFilePanel) {
//-------------------------------------------------------------------------------
// Сохраняет результат манипуляций |
// SaveFilePanel - куда будет рисовать процесс выполнения
// Если что не так - выдает сообщение и вываливается |
//-------------------------------------------------------------------------------
TTiffImage *img;
TTiffPageInfo *pt;
String TempFiln, BakFiln;
int i;
char buf[50];
// if (TiffFiln == Filn) return false; // /* TODO : Временно для отладки ошибки сохранения файла */
DWORD A = GetFileAttributes(TiffFiln.c_str());
if (A != 0xFFFFFFFF) {
if (A & (FILE_ATTRIBUTE_READONLY | FILE_ATTRIBUTE_DIRECTORY | FILE_ATTRIBUTE_HIDDEN | FILE_ATTRIBUTE_SYSTEM))
return false;
}
if (A == 0xFFFFFFFF) {
TempFiln = TiffFiln;
} else {
TempFiln = TrimExt(TiffFiln) + "_temp.tif";
}
// if (!IniSaveBitmap2Tiff(TiffFiln.c_str())) {
if (!IniSaveBitmap2Tiff(TempFiln.c_str())) {
return false;
}
for (i = 0; i < Pages->Nrecs; i++) {
if (SaveFilePanel != NULL) {
wsprintf(buf, "Запись страницы %d из %d", i + 1, Pages->Nrecs);
SaveFilePanel->Caption = (String)buf;
Application->ProcessMessages();
}
img = GetImagePage(i);
pt = GetPageInfo(i);
SaveBitmap2Tiff(img->fbm, pt->PageNumber);
}
StopSaveBitmap2Tiff();
if (A != 0xFFFFFFFF) {
String BakFiln = TrimExt(TiffFiln) + ".bak";
DeleteFile(BakFiln);
if (MoveFile(TiffFiln.c_str(), BakFiln.c_str()) == 0) return false;
if (MoveFile(TempFiln.c_str(), TiffFiln.c_str()) == 0) return false;
}
return true;
}
void plRegistryPageNode::LoadKeys()
{
hsAssert(IsValid(), "Trying to load keys for invalid page");
hsAssert(!fIsNewPage, "Trying to read a new page");
if (IsFullyLoaded())
return;
hsStream* stream = OpenStream();
if (!stream)
{
hsAssert(0, plString::Format("plRegistryPageNode::LoadKeysFromSource - bad stream %s,%s",
GetPageInfo().GetAge(), GetPageInfo().GetPage()).c_str());
return;
}
// If we're loading keys in the middle of a read because FindKey() failed, we'd better
// make note of our stream position and restore it when we're done.
uint32_t oldPos = stream->GetPosition();
stream->SetPosition(GetPageInfo().GetIndexStart());
// Read in the number of key types
uint32_t numTypes = stream->ReadLE32();
for (uint32_t i = 0; i < numTypes; i++)
{
uint16_t classType = stream->ReadLE16();
plRegistryKeyList* keyList = IGetKeyList(classType);
if (!keyList)
{
keyList = new plRegistryKeyList(classType);
fKeyLists[classType] = keyList;
}
keyList->Read(stream);
}
stream->SetPosition(oldPos);
CloseStream();
fStaticLoadedTypes = fKeyLists.size();
}
Bool32 CreateContainerBigComp( PRSPreProcessImage Image )
{
CCOM_handle hCCOM_old=(CCOM_handle)(*(Image->phCCOM));
Handle hCPage=Image->hCPAGE;
CCOM_handle hCCOM_new=0;
BIG_IMAGE big_Image;
PAGEINFO info = {0};
GetPageInfo(hCPage,&info);
int i=0;
for(i=0;i<CPAGE_MAXNAME;i++)
big_Image.ImageName[i]=info.szImageName[i];
hCCOM_new = CCOM_CreateContainer();
if(!hCCOM_new)
{
big_Image.hCCOM=NULL;
return TRUE;
}
CCOM_comp* comp=NULL;
CCOM_comp* new_comp;
comp=CCOM_GetFirst(hCCOM_old,FALSE);
while(comp)
{
if( (comp->h>=MIN_BIG_H)&&(comp->w>=MIN_BIG_W) )
{
new_comp=CCOM_New(hCCOM_new,comp->upper,comp->left,comp->w,comp->h);
if(new_comp)
{
if(comp->size_linerep<0)
;
else
{
if(!CCOM_Copy(new_comp,comp) )
CCOM_Delete(hCCOM_new,comp);
}
}
}
comp=CCOM_GetNext(comp,FALSE);
}
big_Image.hCCOM=hCCOM_new;
CPAGE_CreateBlock(hCPage,TYPE_BIG_COMP,0,0,&big_Image,sizeof(BIG_IMAGE));
return TRUE;
}
int GetMediumHeight(POLY_* pBlock) {
CCOM_comp * comp;
int sum_height = 0;
int count = 0;
cf::Point16 pLeftTop;
cf::Point16 pRightTop;
cf::Point16 pLeftBottom;
cf::Point16 pRightBottom;
PAGEINFO info;
GetPageInfo(HCPAGE, &info);
int nIncline = info.Incline2048;
for (comp = CCOM_GetFirst((CCOM_handle) HCCOM, NULL); comp; comp
= CCOM_GetNext(comp, NULL)) {
if (comp->h < inf_let_h)
continue;
pLeftTop.rx() = comp->left;
pLeftTop.ry() = comp->upper - 1;
pRightTop.rx() = comp->left + comp->w - 1;
pRightTop.ry() = comp->upper - 1;
pLeftBottom.rx() = comp->left;
pLeftBottom.ry() = comp->upper + comp->h - 2;
pRightBottom.rx() = comp->left + comp->w - 1;
pRightBottom.ry() = comp->upper + comp->h - 2;
IDEAL_XY(pLeftTop.rx(), pLeftTop.ry());
IDEAL_XY(pRightTop.rx(), pRightTop.ry());
IDEAL_XY(pLeftBottom.rx(), pLeftBottom.ry());
IDEAL_XY(pRightBottom.rx(), pRightBottom.ry());
if (IsInPoly(pLeftTop, pBlock) || IsInPoly(pRightTop, pBlock)
|| IsInPoly(pLeftBottom, pBlock) || IsInPoly(pRightBottom,
pBlock)) {
sum_height += comp->h;
count++;
}
}
if (!count)
return medium_statistics_h;
return sum_height / count;
}
Bool GetMasP(Handle hCPage, Rect16 Rc, uchar** ppmasp) {
int prewide;
int left = Rc.left;
int h = Rc.bottom - Rc.top + 1;
int w = Rc.right - Rc.left + 1;
int upper = Rc.top - 1;
if ((w % 8) == 0)
prewide = w;
else {
prewide = w / 8 + 1;
prewide *= 8;
}
PAGEINFO info;
CIMAGE_InfoDataInGet DataInto;
CIMAGE_InfoDataOutGet DataOut;
char Name[CPAGE_MAXNAME];
Bool ret;
int i;
// 1. Подготовка к запросу части изображения.
DataInto.dwHeight = (uint32_t)(h);
DataInto.dwWidth = (uint32_t)(prewide);
DataInto.wByteWidth = (uint16_t)(prewide / 8);
DataInto.dwX = left;
DataInto.dwY = upper;
GetPageInfo(hCPage, &info);
for (i = 0; i < CPAGE_MAXNAME; i++)
Name[i] = info.szImageName[i];
DataOut.dwWidth = DataInto.dwWidth;
DataOut.dwHeight = DataInto.dwHeight;
DataOut.wByteWidth = DataInto.wByteWidth;
DataOut.byBit = (uint16_t) info.BitPerPixel;
DataOut.lpData = *ppmasp;
// 5. Чтение части изображения.
ret = CIMAGE_GetRawData(Name, &DataInto, &DataOut);
if (!ret)
return FALSE;
if (DataOut.lpData == NULL)
return FALSE;
*ppmasp = DataOut.lpData;
return TRUE;
}
void __fastcall TTiffBook::EnumPages(int start, int first) {
//-------------------------------------------------------------------------------
// Нумерует страницы |
//-------------------------------------------------------------------------------
TTiffPageInfo *pt;
int i, k;
if (start == 0 || first == 0) return;
for (i = 1, k = first; i <= Pages->Nrecs; i++) {
pt = GetPageInfo(i-1);
if (i < start) {
pt->PageNumber = -1;
} else {
pt->PageNumber = k;
k++;
}
}
}
void ResolutionChecker::check()
{
PAGEINFO page_info;
if(!GetPageInfo(cpage_, &page_info))
return;
if(isValidResolution(page_info)) {
cfDebug(cf::MODULE_RSTUFF) << "no resolution correction needed: "
<< page_info.DPIX << "x" << page_info.DPIY;
return;
}
ComponentHistogram hist;
hist.fill(ccom_);
hist.calculate();
bool changed = false;
if(hist.isYCorrectionNeeded(page_info)) {
page_info.DPIY = hist.yDpi();
changed = true;
}
if(hist.isXCorrectionNeeded(page_info)) {
page_info.DPIX = hist.xDpi();
changed = true;
}
if(changed) {
SetPageInfo(cpage_, page_info);
cfDebug(cf::MODULE_RSTUFF) << "new resolution: "
<< page_info.DPIX << "x" << page_info.DPIY;
}
if(hist_height_callback_)
hist_height_callback_(hist.heightHistogram());
if(hist_width_callback_)
hist_width_callback_(hist.widthHistogram());
}
/////////////////////////////////////////////////////////////////////////////
// CreateInternalFileForFormatter
Bool CreateInternalFileForFormatter(FILE *pIFName)
{
Bool FReturnCode = TRUE;
CSTR_line line;
CFPage Page;
PAGEINFO PageInfo;
Handle hCPAGE = CPAGE_GetHandlePage( CPAGE_GetCurrentPage());
GetPageInfo(hCPAGE,&PageInfo);
if(PageInfo.X && PageInfo.Y){
TemplateOffset.x = PageInfo.X;
TemplateOffset.y = PageInfo.Y;
}
else{
TemplateOffset.x = 0;
TemplateOffset.y = 0;
}
//Создание массива текстовых фрагментов
Page.FragmentsArray.clear();
Page.CreateArray_For_TextFragments( );
//Чтение информации из хранилиша
line = CSTR_FirstLine (1);
while(line)
{
if(CheckComingLine(&line) && Page.CheckComingLine_For_TextFragments(&line))
Page.ProcessingComingLine(&line);
line = CSTR_NextLine ( line, 1 );
}
CountPict = GetPictCount();
// CountTable = GetTablCount();
if(Page.Count.Chars>32000){
ExFlagMode = TRUE;
}
if(!(Page.Count.Frags + (int)CountPict + (int)CountTable)){
if(CreateEmptyRtfFile()<0){
SetReturnCode_rfrmt(IDS_ERR_SIZEFRAGMENT);
return FALSE;
}
return TRUE;
}
//Создания внутреннего файла для форматирования
uint16_t DistanceBetweenLeftMargin = 15;
uint16_t DistanceBetweenTopMargin = 5;
Page.m_wDpi = (uint16_t)PageInfo.DPIX;
PageIncline2048 = PageInfo.Incline2048;
InternalRect VRect;
fwrite(&Page.m_wDpi, sizeof(uint16_t),1,pIFName); // ScanResolution
fwrite(&Page.Count.Frags, sizeof(uint16_t),1,pIFName); // число колонок
fwrite(&Page.Count.Chars, sizeof(uint16_t),1,pIFName); // число знакомест in all page
fwrite(&Page.Count.Words, sizeof(uint16_t),1,pIFName); // число слов
fwrite(&Page.Count.Strings, sizeof(uint16_t),1,pIFName); // число строк
fwrite(&DistanceBetweenLeftMargin,sizeof(uint16_t),1,pIFName); // distance between left margin letters- neighdoors from one word
fwrite(&DistanceBetweenTopMargin, sizeof(uint16_t),1,pIFName); // distance between top margin
CFragment* cFrag;
CFString* cString;
CWord* cWord;
CChar* cChar;
// Processing Fragments
for(int iPage=0; iPage < Page.Count.Frags; iPage++){
cFrag = (CFragment*)Page.m_arFrags[iPage];
VCopyRect( &VRect, &cFrag->m_rectFrag);
if(CheckRect( &VRect ) == FALSE)
FReturnCode = FALSE ;
fwrite(&VRect , sizeof( InternalRect ),1,pIFName);
fwrite(&cFrag->m_wStringsCount, sizeof( uint16_t ),1,pIFName);
fwrite(&cFrag->m_wUserNumber , sizeof( uint32_t ),1,pIFName);
fwrite(&cFrag->m_Flags , sizeof( uint32_t ),1,pIFName);
// Processing Strings
for(int iFrag=0; iFrag < cFrag->m_wStringsCount; iFrag++){
cString = (CFString*)cFrag->m_arStrings[iFrag];
VCopyRect( &VRect, &cString->m_rectBaseLine );
fwrite( &VRect, sizeof( InternalRect ),1,pIFName);
VCopyRect( &VRect, &cString->m_rectString );
fwrite( &VRect, sizeof( InternalRect ),1,pIFName);
fwrite( &cString->m_wWordsCount, sizeof( uint16_t ),1,pIFName);
fwrite( &cString->S_Flags, sizeof( uint32_t ),1,pIFName); //NEGA_STR
// Processing Words
for(int iString=0; iString < cString->m_wWordsCount; iString++){
cWord = (CWord*)cString->m_arWords[iString];
fwrite( &cWord->m_wCharsCount, sizeof( uint16_t ),1,pIFName);
fwrite( &cWord->m_wFontNumber, sizeof( uint16_t ),1,pIFName);
fwrite( &cWord->m_wFontPointSize,sizeof( uint16_t ),1,pIFName);
// Processing Letters
for(int iWord=0; iWord < cWord->m_wCharsCount; iWord++){
cChar = (CChar*)cWord->m_arChars[iWord];
VCopyRect( &VRect, &cChar->m_rectChar );
fwrite( &VRect , sizeof( InternalRect ),1,pIFName);
VCopyRect( &VRect, &cChar->m_RealRectChar );
fwrite( &VRect , sizeof( InternalRect ),1,pIFName);
fwrite( &cChar->m_wCountAlt , sizeof( uint16_t ),1,pIFName);
for (int iAlt=0;iAlt<cChar->m_wCountAlt&&iAlt<REC_MAX_VERS;iAlt++)
{
fwrite( &cChar->m_chrVersions[iAlt].m_bChar ,sizeof( char ),1,pIFName);
fwrite( &cChar->m_chrVersions[iAlt].m_bProbability , sizeof( char ),1,pIFName);
}
fwrite( &cChar->m_blanguage , sizeof( char ),1,pIFName);
fwrite( &cChar->m_bFlg_spell_nocarrying, sizeof( char ),1,pIFName);
fwrite( &cChar->m_bFlg_cup_drop ,sizeof( char ),1,pIFName);
fwrite( &cChar->m_bFlg_spell, sizeof( char ),1,pIFName);
fwrite( &cChar->m_wFontNumber , sizeof( char ),1,pIFName);
}
}
}
}
return FReturnCode;
}
void PrintEdit(HWND hEdit, wchar_t * lpDocName){
FORMATRANGE fr;
CHARRANGE chrg;
HDC hPrintDC;
int tempFlags;
int pageMin = 0, pageMax = 0;
HFONT hFontPageNumber, hFontOld;
LOGFONTW lf;
int xNP, yNP, yDoc;
DOCINFOW docinfo;
wchar_t szPage[32];
int oldAlign;
COLORREF oldColor;
ZeroMemory(&g_pPdlg, sizeof(g_pPdlg));
g_pPdlg.lStructSize = sizeof(g_pPdlg);
g_pPdlg.hwndOwner = g_hMain;
g_pPdlg.hInstance = g_hInstance;
SendMessageW(hEdit, EM_EXGETSEL ,0, (LPARAM)&chrg);
if(chrg.cpMax == 0 || chrg.cpMax == chrg.cpMin){
g_pPdlg.Flags = PD_ALLPAGES | PD_NOSELECTION;
}
else{
if(chrg.cpMax > chrg.cpMin){
g_pPdlg.Flags = PD_SELECTION;
}
else{
g_pPdlg.Flags = PD_ALLPAGES;
}
}
g_pPdlg.Flags |= PD_RETURNDC | PD_HIDEPRINTTOFILE | 0x20000; //PD_NONETWORKBUTTON
GetPageInfo(hEdit, FALSE);
g_pPdlg.nFromPage = 1;
g_pPdlg.nToPage = m_CountPage;
g_pPdlg.nMinPage = 1;
g_pPdlg.nMaxPage = m_CountPage;
g_pPdlg.nCopies = 1;
if(PrintDlgW(&g_pPdlg)){
hPrintDC = g_pPdlg.hDC;
fr.hdc = hPrintDC;
fr.hdcTarget = NULL;
tempFlags = g_pPdlg.Flags;
tempFlags &= PD_ALLPAGES | PD_SELECTION | PD_PAGENUMS;
if(tempFlags == PD_ALLPAGES){
pageMin = 0;
pageMax = m_CountPage;
}
else if(tempFlags == PD_SELECTION){
GetPageInfo(hEdit, TRUE);
pageMin = 0;
pageMax = m_CountPage;
}
else if(tempFlags == PD_PAGENUMS){
pageMin = g_pPdlg.nFromPage;
pageMin--;
pageMax = g_pPdlg.nToPage;
}
fr.rc.left = m_Margin.left;
fr.rc.top = m_Margin.top;
fr.rc.right = m_Paper.x - m_Margin.right;
fr.rc.bottom = m_Paper.y - m_Margin.bottom;
ZeroMemory(&lf, sizeof(lf));
lf.lfHeight = -MulDiv(10, GetDeviceCaps(hPrintDC, LOGPIXELSY), 72);
wcscpy(lf.lfFaceName, FONT_NP);
hFontPageNumber = CreateFontIndirectW(&lf);
yNP = GetDeviceCaps(hPrintDC, VERTRES);
xNP = GetDeviceCaps(hPrintDC, HORZRES) / 2;
yDoc = 16;
fr.rcPage.left = 0;
fr.rcPage.top = 0;
fr.rcPage.right = m_Paper.x;
fr.rcPage.bottom = m_Paper.y ;
ZeroMemory(&docinfo, sizeof(docinfo));
docinfo.cbSize = sizeof(docinfo);
docinfo.lpszDocName = lpDocName;
StartDocW(hPrintDC, &docinfo);
if(pageMax){
do{
pageMin++;
StartPage(hPrintDC);
hFontOld = SelectFont(hPrintDC, hFontPageNumber);
wsprintfW(szPage, L"Page %i", pageMin);
oldAlign = SetTextAlign(hPrintDC, TA_CENTER | TA_BOTTOM);
oldColor = SetTextColor(hPrintDC, 0);
TextOutW(hPrintDC, xNP, yNP, szPage, wcslen(szPage));
SetTextAlign(hPrintDC, TA_CENTER | TA_TOP);
TextOutW(hPrintDC, xNP, yDoc, lpDocName, wcslen(lpDocName));
SetTextColor(hPrintDC, oldColor);
SelectFont(hPrintDC, hFontOld);
SetTextAlign(hPrintDC, oldAlign);
if(m_pChar){
int min = pageMin;
min--;
fr.chrg.cpMin = *(m_pChar + min);
min++;
fr.chrg.cpMax = *(m_pChar + min);
}
else{
fr.chrg.cpMin = 0;
fr.chrg.cpMax = 0;
}
SendMessageW(hEdit, EM_FORMATRANGE, TRUE, (LPARAM)&fr);
EndPage(hPrintDC);
}while(pageMin < pageMax);
}
DeleteFont(hFontPageNumber);
SendMessageW(hEdit, EM_FORMATRANGE, FALSE, (LPARAM)NULL);
EndDoc(hPrintDC);
DeleteDC(hPrintDC);
}
}
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;
}
CCOM_handle GetStrCCOM(Handle hCPage, uchar* ImageName, Rect16 Rc, Bool neg, Bool vertical,
RecRaster* rast, int min_h) {
int min_w, max_h, max_w;
// int j;
PAGEINFO info;
// uchar Name[CPAGE_MAXNAME];
GetPageInfo(hCPage, &info);
// if(ImageName)
// {
// for (j=0; j<CPAGE_MAXNAME; j++)
// Name[j] = ImageName[j];
// }
// else
// {
// for (j=0; j<CPAGE_MAXNAME; j++)
// Name[j] = info.szImageName[j];
// }
// Handle lpDIB;
// if(!CIMAGE_ReadDIB(Name,&lpDIB,1))
// return 0;
ExcControl Control;
if (vertical) {
min_h = 2;
min_w = 2;
max_w = Rc.right - Rc.left + 1;
max_h = max_w * 2;
} else {
min_w = 2;
max_h = Rc.bottom - Rc.top + 1;
max_w = Rc.right - Rc.left + 1;
}
int bytewide = ((rast->lnPixWidth + 63) / 64) * 8;
Bool fotomet = FALSE;
Bool RevOv = FALSE;
Control.MinCompHei = min_h;
Control.MinCompWid = min_w;
Control.MaxCompHei = rast->lnPixHeight + 1;
Control.MaxCompWid = bytewide * 8;
Control.MaxScale = 0;
Control.Control = Ex_ExtraComp/*|Ex_EvnRecog*/;//Andrey: опознавалка вынесена в отдельный модуль RRecCom, и кроме того, не вызвана функция REXC_SetEVNProperties для опознавания методом "Event"
if (REXCExtra(Control, rast->Raster, bytewide, RevOv, bytewide * 8, rast->lnPixHeight,
(info.DPIX * 10000) / 254, (info.DPIY * 10000) / 254, 0, 0, 0, 0, fotomet)) {
/* //Andrey: здесь как раз и идет опознавалка
RRecComControl rcontrol;
rcontrol.MinCompHei=min_h;
rcontrol.MinCompWid=min_w;
rcontrol.MaxCompHei=rast->lnPixHeight+1;
rcontrol.MaxCompWid=bytewide*8;
rcontrol.MaxScale=0;
rcontrol.flags = RECOG_EVN;
Handle hCCOM = (Handle)REXCGetContainer();
if (hCCOM)
//Andrey: вообще-то так делать нельзя (в смысле передавать последними 2мя параметрами то, что передается), но пока я не знаю, как здесь получить язык распознавания, поэтому вот таким образом пропускается инициализация
if (!RRECCOM_Recog(hCCOM, rcontrol, NULL, -1))
LDPUMA_ConsoleN(RRECCOM_GetReturnString(RRECCOM_GetReturnCode()));
return (int32_t)hCCOM;
*/return REXCGetContainer();
}
return 0;
}
int CutStrings(POLY_* pBlock) {
medium_h = GetMediumHeight(pBlock);
int cut_h = (int) ((double) (medium_h) * k_cut);
CCOM_comp * comp;
CCOM_comp* prev_comp = NULL;
PAGEINFO info;
GetPageInfo(HCPAGE, &info);
int nIncline = info.Incline2048;
cf::Point16 pLeftTop;
cf::Point16 pRightTop;
cf::Point16 pLeftBottom;
cf::Point16 pRightBottom;
Bool fl_cont = FALSE;
comp = CCOM_GetFirst((CCOM_handle) HCCOM, NULL);
prev_comp = comp;
//Andrey: устанавливаем переменные для метода определения точек разрезания, перемещенного в RCUTP
if (!RCUTP_RSelStr_SetEnv(/*(char*)info.szImageName, */medium_h, inf_let_w,
inf_dust_h, inf_let_h, HCCOM, sup_dust_w, min_cut_down_let_w,
sup_prob_w, info.BitPerPixel))
return 0;
while (comp) {
fl_cont = FALSE;
if (comp->h < inf_let_h) {
prev_comp = comp;
comp = CCOM_GetNext(comp, NULL);
fl_cont = TRUE;
}
if (fl_cont)
continue;
pLeftTop.rx() = comp->left;
pLeftTop.ry() = comp->upper - 1;
pRightTop.rx() = comp->left + comp->w - 1;
pRightTop.ry() = comp->upper - 1;
pLeftBottom.rx() = comp->left;
pLeftBottom.ry() = comp->upper + comp->h - 2;
pRightBottom.rx() = comp->left + comp->w - 1;
pRightBottom.ry() = comp->upper + comp->h - 2;
IDEAL_XY(pLeftTop.rx(), pLeftTop.ry());
IDEAL_XY(pRightTop.rx(), pRightTop.ry());
IDEAL_XY(pLeftBottom.rx(), pLeftBottom.ry());
IDEAL_XY(pRightBottom.rx(), pRightBottom.ry());
if (IsInPoly(pLeftTop, pBlock) || IsInPoly(pRightTop, pBlock)
|| IsInPoly(pLeftBottom, pBlock) || IsInPoly(pRightBottom,
pBlock)) {
if (comp->h >= cut_h && comp->h <= medium_h * 5 && comp->w
>= inf_let_w - 1) {
uchar Data[1000];
memset(Data, 0, sizeof(Data));
uchar* pmasp = Data;
Rect16 Rc;
Rc.top = comp->upper;
Rc.bottom = comp->upper + comp->h - 1;
Rc.left = comp->left;
Rc.right = comp->left + comp->w - 1;
int bound = GetMasP(HCPAGE, Rc, &pmasp) ? RCUTP_RSelStr_CP(
comp, &type_let, pmasp) : comp->h / medium_h;
if (bound > 0) {
if (CutComp(HCPAGE, (CCOM_handle) HCCOM, comp, bound, 1)) {
comp = prev_comp;
fl_cont = TRUE;
}
}
if (!fl_cont)
comp = CCOM_GetNext(comp, NULL);
} else
comp = CCOM_GetNext(comp, NULL);
} else
comp = CCOM_GetNext(comp, NULL);
}
//Andrey: снятие действия установки переменных в RCUTP
RCUTP_RSelStr_UnsetEnv();
return 1;
}
RNEG_FUNC(void) RNEG_RecogNeg(CCOM_handle hCCOM, Handle hCPage,uchar* pImageName,int skew)
{
MainWindowD=NULL;
MainWindowD=LDPUMA_GetWindowHandle ("Изображение после разворота");
if(!MainWindowD)
MainWindowD=LDPUMA_GetWindowHandle ("Main");
dpTime=!LDPUMA_Skip(hTime);
dpPrintResConsole=!LDPUMA_Skip(PrintResConsole);
dpNegResD=!LDPUMA_Skip(NegResD);
dpNegRecD=!LDPUMA_Skip(NegRecD);
dpRecOneLetter=!LDPUMA_Skip(RecOneLetter);
// LDPUMA_ConsoleN("");
if(dpTime)
LDPUMA_ConsoleN("Активизируется функция поиска и разпознования негативов");
int time=clock();
if(!(LDPUMA_Skip (NegSearch)) )
return;
uint32_t code_sersized=(512<<16);
uint32_t code_normd=(512<<17);
uint32_t code_colord=(512<<17)+(512<<16);
uint32_t code_cutd=(512<<18);
uint32_t code_cutstrd=(512<<18)+(512<<16);
uint32_t code_sized=(512<<18)+(512<<17);
#define NEGA 1<<14
#define VERTICA 1<<13
inf_neg_h=30;
inf_neg_w=100;
neg_cut_black=.95;
neg_cut_white=.3;
neg_cut_str=.8;
min_let_h=2;
min_let_w=2;
inf_betw_str_h=10;
sup_square=500000;
PAGEINFO info = {0};
GetPageInfo(hCPage,&info);
DPIX=info.DPIX;
DPIY=info.DPIY;
inf_neg_h=inf_neg_h*((int)(DPIY)+1)/300;
inf_neg_w=inf_neg_w*((int)(DPIX)+1)/300;
inf_betw_str_h=inf_betw_str_h*((int)(DPIY)+1)/300;
sup_square=(int)(((double)sup_square*(double)(DPIY+1)*(double)(DPIX+1))/90000);
min_let_w=min_let_w*((int)(DPIX)+1)/300;
min_let_h=min_let_h*((int)(DPIY)+1)/300;
if((info.Angle==90)||(info.Angle==270))
{
Height=info.Width;
Width=info.Height;
}
else
{
Height=info.Height;
Width=info.Width;
}
NegList* root=NULL;
NegList* now;
NegList* temp;
int nRC=0;
int i;
Bool fl_del_mas_neg;
Bool flag_rotate;
Bool flag_rimage_rotate;
if(!LDPUMA_Skip(SetSkew))
skew=Skew;
for(i=0;i<CPAGE_MAXNAME&&pImageName[i]!='\0';i++)
ImageName[i]=pImageName[i];
if(i<CPAGE_MAXNAME)
ImageName[i]='\0';
if(!InitMyImage())
return;
if(dpTime)
{
LDPUMA_ConsoleN("Time prep=%d",clock()-time);
time=clock();
}
/* Осуществляется поиск кандидатов в негативы по размеру*/
if(LDPUMA_Skip (NegSearchSize) )
{
fl_del_mas_neg=SearchNegBySize(hCCOM,hCPage,&root,nRC);
/*Прорисовка найденных кандидатов в негативы по размерам*/
if(nRC>0)
{
now=root;
if(!(LDPUMA_Skip (NegSearchSizeD)) )
{
for(i=0;i<nRC;i++)
{
NegDrawRect(MainWindowD,code_sersized,RGB(0,0,255),(now->neg).pRc[0]);
now=now->next;
}
LDPUMA_ConsoleN("По размерам");
LDPUMA_WaitUserInput (NegSearchSizeD,MainWindowD);
if(LDPUMA_Skip (NegSearchSizeDC) )
LDPUMA_DeleteRects (MainWindowD,code_sersized);
}
}
}
flag_rimage_rotate=IfNeedGlobalRotate(root,skew);
now=root;
while(now)
{
while((now->neg).pRc[0].top<=0)
((now->neg).pRc[0].top)++;
while(((now->neg).pRc[0].bottom+1)>Height )
((now->neg).pRc[0].bottom)--;
while((now->neg).pRc[0].left<0)
((now->neg).pRc[0].left)++;
while( ((now->neg).pRc[0].right+1)>Width )
((now->neg).pRc[0].right)--;
int prewide=(((now->neg).pRc[0].right-(now->neg).pRc[0].left+8)/8)*8;
if( ((now->neg).pRc[0].left+prewide)>Width )
(now->neg).pRc[0].right-=8;
now=now->next;
}
/* Осуществляется удаление(если повезёт) грязи, т.е. приведение
негатива к каноническому виду*/
if(LDPUMA_Skip (NegNorm) )
{
/* Поворот (если необходим) негативов*/
flag_rotate=NegRotate(hCPage,root,nRC,skew);
now=root;
for(i=1;i<nRC;i++)
now=now->next;
i=nRC-1;
while(i>=0)
{
temp=now->prev;
NormNeg(hCPage,now,&root,nRC);
i--;
now=temp;
}
/*Обратное преобразование*/
if(flag_rotate)
{
now=root;
while(now)
{
if((now->neg).rot.pmasp)
{
RSELSTR_UnRotateRect(-skew,&((now->neg).pRc[0]),1,(now->neg).rot.Rc,(now->neg).rot.begx,(now->neg).rot.movey,(now->neg).rot.flmovey,(now->neg).rot.hi);
PostRotate(now,skew);
}
DeleteRotateMas(&((now->neg).rot.pmasp),&((now->neg).rot.begx),&((now->neg).rot.movey),&((now->neg).rot.flmovey),&((now->neg).rot.hi));
now=now->next;
}
}
/* Прорисовка нормализованных кандидатов в негативы*/
if(nRC>0)
{
now=root;
if(!(LDPUMA_Skip (NegNormD)) )
{
for(i=0;i<nRC;i++)
{
NegDrawRect(MainWindowD,code_normd,RGB(0,255,0),(now->neg).pRc[0]);
now=now->next;
}
LDPUMA_ConsoleN("Нормализованные");
LDPUMA_WaitUserInput (NegNormD,MainWindowD);
if(LDPUMA_Skip (NegNormDC) )
LDPUMA_DeleteRects (MainWindowD,code_normd);
}
}
}
/* Резка сложных негативов*/
if(LDPUMA_Skip (NegCut) )
{
/* Поворот (если необходим) негативов*/
flag_rotate=NegRotate(hCPage,root,nRC,skew);
CutNeg(hCPage,&root,nRC,skew);
/* Поворот (если необходим) негативов*/
flag_rotate=NegRotate(hCPage,root,nRC,skew);
now=root;
for(i=1;i<nRC;i++)
now=now->next;
i=nRC-1;
while(i>=0)
{
temp=now->prev;
NormNeg(hCPage,now,&root,nRC);
i--;
now=temp;
}
/*Обратное преобразование*/
if(flag_rotate)
{
now=root;
while(now)
{
if((now->neg).rot.pmasp)
{
RSELSTR_UnRotateRect(-skew,&((now->neg).pRc[0]),1,(now->neg).rot.Rc,(now->neg).rot.begx,(now->neg).rot.movey,(now->neg).rot.flmovey,(now->neg).rot.hi);
PostRotate(now,skew);
}
DeleteRotateMas(&((now->neg).rot.pmasp),&((now->neg).rot.begx),&((now->neg).rot.movey),&((now->neg).rot.flmovey),&((now->neg).rot.hi));
now=now->next;
}
}
/* Прорисовка разрезанных негативов*/
if(nRC>0)
{
now=root;
if(!(LDPUMA_Skip (NegCutD)) )
{
for(i=0;i<nRC;i++)
{
NegDrawRect(MainWindowD,code_cutd,RGB(255,0,0),(now->neg).pRc[0]);
now=now->next;
}
LDPUMA_ConsoleN("Разрезанные");
LDPUMA_WaitUserInput (NegCutD,MainWindowD);
if(LDPUMA_Skip (NegCutDC) )
LDPUMA_DeleteRects (MainWindowD,code_cutd);
}
}
}
now=root;
for(i=1;i<nRC;i++)
now=now->next;
int h;
int w;
Rect16 Rc;
/*Отсев по размеру*/
if(LDPUMA_Skip (NegSize) )
{
while(now)
{
h=(now->neg).pRc[0].bottom-(now->neg).pRc[(now->neg).nRc-1].top+1;
w=(now->neg).pRc[0].right-(now->neg).pRc[0].left+1;
if( ((h<2*w)&&(w<2*h)) || ((h*w)>sup_square) )
{
temp=now;
if(!temp->prev)
root=temp->next;
nRC--;
now=now->prev;
delete temp;
}
else
now=now->prev;
}
/* Прорисовка отсеянных по размеру*/
if(nRC>0)
{
now=root;
if(!(LDPUMA_Skip (NegSizeD)) )
{
for(i=0;i<nRC;i++)
{
Rc.left=(now->neg).pRc[0].left;
Rc.right=(now->neg).pRc[0].right;
Rc.bottom=(now->neg).pRc[0].bottom;
Rc.top=(now->neg).pRc[(now->neg).nRc-1].top;
NegDrawRect(MainWindowD,code_sized,RGB(255,255,0),Rc);
now=now->next;
}
LDPUMA_ConsoleN("Окончательная прорисовка");
LDPUMA_WaitUserInput (NegSizeD,MainWindowD);
if(LDPUMA_Skip (NegSizeDC) )
LDPUMA_DeleteRects (MainWindowD,code_sized);
}
}
}
/* Поворот (если необходим) негативов*/
flag_rotate=NegRotate(hCPage,root,nRC,skew);
/* Осуществляется отсев кандидатов в негативы по насыщенности
чёрного цвета*/
if(LDPUMA_Skip (NegColor) )
{
SearchNegByBlack(hCPage,&root,nRC);
/*Прорисовка кандидатов в негативы после отсева по цветовой гамме*/
if(nRC>0)
{
now=root;
if(!(LDPUMA_Skip (NegColorD)) )
{
for(i=0;i<nRC;i++)
{
NegDrawRect(MainWindowD,code_colord,RGB(0,255,255),(now->neg).pRc[0]);
now=now->next;
}
LDPUMA_ConsoleN("Отсеянные по цветовой гамме");
LDPUMA_WaitUserInput (NegColorD,MainWindowD);
if(LDPUMA_Skip (NegColorDC) )
LDPUMA_DeleteRects (MainWindowD,code_colord);
}
}
}
/* Резка многострочных негативов*/
if(LDPUMA_Skip (NegCutStr) )
{
CutNegStr(hCPage,&root,nRC,skew);
/* Прорисовка разрезанных негативов*/
if(nRC>0)
{
now=root;
if(!(LDPUMA_Skip (NegCutStrD)) )
{
while(now)
{
for(i=0;i<(now->neg).nRc;i++)
NegDrawRect(MainWindowD,code_cutstrd,RGB(255,0,255),(now->neg).pRc[i]);
now=now->next;
}
LDPUMA_ConsoleN("Разрезанные на строки");
LDPUMA_WaitUserInput (NegCutStrD,MainWindowD);
if(LDPUMA_Skip (NegCutStrDC) )
LDPUMA_DeleteRects (MainWindowD,code_cutstrd);
}
}
}
/*Отсев пересекающихся*/
DelIn(hCPage,&root,nRC);
int time_stuff=clock();
if(dpTime)
LDPUMA_ConsoleN("Time stuff=%d",time_stuff-time);
/* Осуществляется распознование из массива кандидатов*/
if(flag_rimage_rotate)
{
UnRotateNeg(root,skew);
ResetMyImage();
if(!InitMyImage())
return;
CheckNega(root);
if(!flag_rotate)
flag_rotate=NegRotate(hCPage,root,nRC,skew);
}
if(LDPUMA_Skip (NegRec) )
{
NegRecog(hCPage,&root,nRC,skew);
}
if(dpTime)
LDPUMA_ConsoleN("Time recog=%d",clock()-time_stuff);
if(!(LDPUMA_Skip (NegPrintFILE) ))
{
FILE *f;
f=fopen("recneg.res","a");
if(f==NULL)
f=fopen("recneg.res","w+");
if(f!=NULL)
{
NegPrintInFile(f,root,nRC);
fclose(f);
}
}
/* Отпись в CPage*/
now=root;
if(1/*!(LDPUMA_Skip (PutToCPage) )*/)
{
POLY_ block={0};
uint32_t size_poly=sizeof(POLY_);
while(now)
{
if((now->neg).p>inf_prob)
{
block.com.Flags=0;
Rc.left=(now->neg).pRc[0].left;
Rc.right=(now->neg).pRc[0].right;
Rc.top=(now->neg).pRc[(now->neg).nRc-1].top;
Rc.bottom=(now->neg).pRc[0].bottom;
block.com.type = TYPE_TEXT; //Текст, Картинка, Таблица;
block.com.count = 4;
block.negative=TYPE_NEGATIVE;
block.com.Flags=NEGA;
//Andrey: moved from RBLOCK (keyword:TYPE_NEGATIVE)
//------------------------------
block.alphabet=0;
block.com.number=0;
//------------------------------
//commented by Andrey
/* if(Rc.bottom-Rc.top>Rc.right-Rc.left)
{
block.orient=TYPE_DOWNUP;
block.com.Flags|=VERTICA;
}
else
block.orient=TYPE_LEFTRIGHT;
*/
if ((now->neg).Flags&FlVert)
{
block.com.Flags |= VERTICA;
block.orient = (now->neg).Flags&FlDown2Up ? TYPE_DOWNUP : TYPE_UPDOWN;
}
else block.orient = TYPE_LEFTRIGHT;
block.com.Vertex[0].x = Rc.left;
block.com.Vertex[0].y = Rc.top;
block.com.Vertex[1].x = Rc.right;
block.com.Vertex[1].y = Rc.top;
block.com.Vertex[2].x = Rc.right;
block.com.Vertex[2].y = Rc.bottom;
block.com.Vertex[3].x = Rc.left;
block.com.Vertex[3].y = Rc.bottom;
//Andrey: create TYPE_TEXT block
CPAGE_CreateBlock(hCPage, TYPE_IMAGE,0,0,&block,size_poly);
// CPAGE_CreateBlock(hCPage, TYPE_TEXT,0,0,&block,size_poly);
}
now=now->next;
}
}
if(!(LDPUMA_Skip (PutToCHSTR) ))
{
now=root;
uchar Name[CPAGE_MAXNAME];
for (int j=0; j<CPAGE_MAXNAME; j++)
Name[j] = ImageName[j];
if(!(LDPUMA_Skip (TestCHSTR) ))
{
CHSTR_Objects Hstr;
Hstr.Rc.top=TOP;
Hstr.Rc.bottom=BOTTOM;
Hstr.Rc.left=LEFT;
Hstr.Rc.right=RIGHT;
Hstr.block_number=1000;
Hstr.ImageName[0]='\0';
Hstr.type_neg=NEGATIVE;
Hstr.type_vert=VERTICALE;
RSELSTR_PutObjects(hCPage,(void*)hCCOM,&Hstr,1);
}
}
PutTempToCPAGE(hCPage,root);
if( (LDPUMA_Skip (NegSearchSize))&&(fl_del_mas_neg==TRUE) )
{
while(root)
{
now=root;
root=root->next;
delete now;
}
}
ResetMyImage();
// LDPUMA_ConsoleN("Time work RNEG=%d",clock()-time);
}
/////////////////////////////////////////////////////////////////////////////////////////////////////
//
//Bool32 AboutLines(PRSPreProcessImage Image, Bool32 *BadScan, int32_t *ScanQual)
//{
// return TRUE;
//}
/////////////////////////////////////////////////////////////////////////////////////////////////////
//
Bool32 CalcIncline(PRSPreProcessImage Image)
{
int SizeWork,SizeMain;
char Str[256];
Bool ret, WasLine, ManyComp;
Bool CalcMuchSkew, TalkMuchSkew;
uint16_t Code;
int32_t SkewReg, Skew, SkewLocVerLin;
Rect16 RcReg;
PAGEINFO info = {0};
UN_BUFF MainBuff = {0};
void *vMain;
char *cWork;
Handle hCPage=Image->hCPAGE;
CLINE_handle hCLINE=*((CLINE_handle*)Image->phCLINE);
GetPageInfo(hCPage,&info);
/* 2. Инициализация. */
/*** переменные ***/
WasLine = 0;
/*** организация памяти ***/
GiveMainBuff (&vMain, &SizeMain);
MainBuff.vBuff = vMain;
MainBuff.SizeBuff = SizeMain;
MainBuff.vCurr = MainBuff.vBuff;
MainBuff.SizeCurr = MainBuff.SizeBuff;
GiveWorkBuff (&cWork, &SizeWork);
/*** линии ***/
// if(!LDPUMA_Skip(hUseCLine))
ret=LoadLinesVP_rv(hCLINE,UN_LD_LinesVP2,&MainBuff,Str,&Code);
// else
// ret = LoadLinesVP_rv (hCPage, UN_LD_LinesVP, (void *)(&MainBuff), Str, &Code);
if ((ret!=RV_TRUE)&&(ret!=RV_EMPTY))
{
SetReturnCode_rstuff (Code);
return ret;
}
WasLine = (ret==RV_TRUE);
/*** компоненты ***/
ret = LoadComps_rv (*(Image->phCCOM), (void *)(&MainBuff), Str, 0); //t-e-d
if (ret==RV_DOUBT)
{
SetReturnCode_rstuff (Code);
CleanLastDataPart ((void *)(&MainBuff));
}
ManyComp = (ret==RV_TRUE)&&(MainBuff.nPartUnits[MainBuff.nPart-1]>10000);
if (ManyComp)
{
CleanLastDataPart ((void *)(&MainBuff));
}
if (ret==RV_DOUBT||ManyComp)
{
ret = LoadComps_rv (*(Image->phCCOM), (void *)(&MainBuff), Str, 3); //t-e-d
if (ret==RV_DOUBT)
{
SetReturnCode_rstuff (Code);
CleanLastDataPart ((void *)(&MainBuff));
}
}
if (ret!=RV_TRUE)
{
return ret;
}
RcReg.left=0;
RcReg.right=(int16_t)info.Width;
RcReg.top=0;
RcReg.bottom=(int16_t)info.Height;
SkewReg=0;
Bool ContWarn = 0;
SkewLocVerLin = 0;
CalcMuchSkew = (!LDPUMA_Skip(hCalcMuchSkew));
TalkMuchSkew = (!LDPUMA_Skip(hTalkMuchSkew));
// 5.1 Определяем угол наклона страницы (ее заполнения в целом).
// if(!LDPUMA_Skip(hUseCLine))
ret=ConvertLinesToAM_rv (UN_LD_LinesVP2, UN_LD_LinesAM, (void *)(&MainBuff)
,(int *)cWork, SizeWork / sizeof (int), &RcReg, SkewReg, Str, ContWarn);
// else
// ret = ConvertLinesToAM_rv (UN_LD_LinesVP, UN_LD_LinesAM, (void *)(&MainBuff)
// ,(int *)cWork, SizeWork / sizeof (int), &RcReg, SkewReg, Str, ContWarn); // f-t-e-d
if (ret==RV_DOUBT)
{
SetReturnCode_rstuff (Code);
}
if (ret!=RV_TRUE)
return ret;
SMetric_SetImportData(SMetric_ResolX, (void *)info.DPIX);
SMetric_SetImportData(SMetric_ResolY, (void *)info.DPIY);
ret = SMetric_FindMainSkew ((void *)(&MainBuff), cWork, SizeWork, &Skew
, &SkewLocVerLin, &RcReg, SkewReg, Str, CalcMuchSkew, TalkMuchSkew);
if (ret!=RV_TRUE)
return ret;
info.Incline2048 = Skew*2;
info.SkewLocVerLin2048 = SkewLocVerLin*2;
if(!CPAGE_SetPageData(Image->hCPAGE,PT_PAGEINFO,&info,sizeof(PAGEINFO)))
{
SetReturnCode_rstuff(CPAGE_GetReturnCode());
return FALSE;
}
return TRUE;
}
Bool32 DeleteLines(Handle hCPage,void* phCLINE, const char* ImageDelLines)
{
// LDPUMA_ConsoleN("Активизируется функция тривиального удаления линий");
int time=clock();
CLINE_handle* pCLINE=(CLINE_handle*)phCLINE;
MyLine* pHorLines=NULL;
MyLine* pVerLines=NULL;
int nHorLines=0;
int nVerLines=0;
int len_hor_mas=0;
int len_ver_mas=0;
int add_len_mas=50;
uint32_t size_lineinfo=sizeof(LineInfo);
if(!LDPUMA_Skip(NotKillPointed))
fl_not_kill_pointed=TRUE;
else
fl_not_kill_pointed=FALSE;
dphNotTestAlik=!LDPUMA_Skip(hNotTestAlik);
CIMAGEIMAGECALLBACK cbk;
CIMAGEIMAGECALLBACK cbk1;
// LinesTotalInfo lti;
// LineInfo linfo; // собственно, что и надо
PAGEINFO info = {0}; // Описание страницы
// Handle pBlock;
// uint32_t size32;
int i;
// uint32_t HorType;
// uint32_t VerType;
Bool fl_cont;
uchar ImageName[CPAGE_MAXNAME];
// Получаем PAGEINFO текущей страницы
GetPageInfo(hCPage,&info);
// Копируем в pImage из PInfo указатель на изображение,
// связанное со страницей
for(i=0;i<CPAGE_MAXNAME;i++)
ImageName[i]=info.szImageName[i];
if (!CIMAGE_GetCallbackImage(ImageName,&cbk))
return FALSE;
cbk1.CIMAGE_ImageOpen = cbk.CIMAGE_ImageOpen;
cbk1.CIMAGE_ImageRead = cbk.CIMAGE_ImageRead;
cbk1.CIMAGE_ImageClose = cbk.CIMAGE_ImageClose;
if (!CIMAGE_WriteCallbackImage((uchar*)ImageDelLines,cbk1))
{
return FALSE;
}
Handle lpDIB;
if(!CIMAGE_ReadDIB((uchar*)ImageDelLines,&lpDIB,1))
{
CIMAGE_DeleteImage((uchar*)ImageDelLines);
return FALSE;
}
CTDIB* ctdib = new CTDIB;
if(!ctdib)
{
CIMAGE_DeleteImage((uchar*)ImageDelLines);
return FALSE;
}
ctdib->SetDIBbyPtr (lpDIB);
const int bytewide=ctdib->GetLineWidthInBytes();
int num_str=ctdib->GetLinesNumber ();
// int bytesize=ctdib->GetImageSizeInBytes ();
uchar* pmasp=(uchar*)(ctdib->GetPtrToBitFild());
// uchar* pos=(uchar*)(ctdib->GetPtrToPixel (pHorLines[0].begx,pHorLines[0].begy));
// uchar* pos2=(uchar*)(ctdib->GetPtrToPixel (pHorLines[0].begx,pHorLines[0].begy));
uint32_t size_line_com=sizeof(LINE_COM);
CLINE_handle hline;
if(LDPUMA_Skip(ObvKillLines))
{
for(hline=CLINE_GetFirstLine(*pCLINE);hline;hline=CLINE_GetNextLine(hline))
{
DelLineFromInside(pmasp,bytewide,num_str,hline);
}
}
else//тривиальное снятие линий
{
// if(!LDPUMA_Skip(hUseCLine))
// {
hline = CLINE_GetFirstLine(*pCLINE);
nHorLines=0;
len_hor_mas=50;
nVerLines=0;
len_ver_mas=50;
if(!InitLineMas(&pHorLines,len_hor_mas))
{
ctdib->ResetDIB ();
delete ctdib;
CIMAGE_DeleteImage((uchar*)ImageDelLines);
return FALSE;
}
if(!InitLineMas(&pVerLines,len_ver_mas))
{
DelLineMas(pHorLines);
ctdib->ResetDIB ();
delete ctdib;
CIMAGE_DeleteImage((uchar*)ImageDelLines);
return FALSE;
}
while(hline)
{
CPDLine cpdata;
fl_cont=FALSE;
cpdata=CLINE_GetLineData(hline);
if(!cpdata)
hline=CLINE_GetNextLine(hline);
else
{
if((cpdata->Flags & LI_IsTrue)&&(!fl_not_kill_pointed||(fl_not_kill_pointed&&cpdata->Type!=NR_DT_LinePointed)))
{
if(cpdata->Dir==LD_Horiz)
{
if(nHorLines>=len_hor_mas)
{
if(!AddLenLineMas(&pHorLines,len_hor_mas,add_len_mas))
{
fl_cont=TRUE;
hline=CLINE_GetNextLine(hline);
}
}
if(!fl_cont)
{
pHorLines[nHorLines].begx=cpdata->Line.Beg_X;
pHorLines[nHorLines].begy=cpdata->Line.Beg_Y;
pHorLines[nHorLines].endx=cpdata->Line.End_X;
pHorLines[nHorLines].endy=cpdata->Line.End_Y;
pHorLines[nHorLines].wide10=cpdata->Line.Wid10;
nHorLines++;
hline=CLINE_GetNextLine(hline);
}
}
else
{
if(nVerLines>=len_ver_mas)
{
if(!AddLenLineMas(&pVerLines,len_ver_mas,add_len_mas))
{
fl_cont=TRUE;
hline=CLINE_GetNextLine(hline);
}
}
if(!fl_cont)
{
pVerLines[nVerLines].begx=cpdata->Line.Beg_X;
pVerLines[nVerLines].begy=cpdata->Line.Beg_Y;
pVerLines[nVerLines].endx=cpdata->Line.End_X;
pVerLines[nVerLines].endy=cpdata->Line.End_Y;
pVerLines[nVerLines].wide10=cpdata->Line.Wid10;
nVerLines++;
hline=CLINE_GetNextLine(hline);
}
}
}
else
hline=CLINE_GetNextLine(hline);
}
}
/* }
else
{
pBlock=NULL;
pBlock = CPAGE_GetBlockFirst (hCPage, RLINE_BLOCK_TYPE );
if( pBlock==NULL)
{
info.Images|=IMAGE_DELLINE;
SetPageInfo(hCPage,info);
ctdib->ResetDIB ();
delete ctdib;
return TRUE;
}
size32 = CPAGE_GetBlockData(hCPage, pBlock, RLINE_BLOCK_TYPE, <i, sizeof(LinesTotalInfo));
if (size32 != sizeof(LinesTotalInfo) )
{
ctdib->ResetDIB ();
delete ctdib;
CIMAGE_DeleteImage((uchar*)ImageDelLines);
return FALSE;
}
HorType = (uint32_t)lti.Hor.Lns;
VerType = (uint32_t)lti.Ver.Lns;
/////////////////////////////////////////////////////////////////////////////////////////////
nHorLines=0;
len_hor_mas=50;
if(!InitLineMas(&pHorLines,len_hor_mas))
{
ctdib->ResetDIB ();
delete ctdib;
CIMAGE_DeleteImage((uchar*)ImageDelLines);
return FALSE;
}
pBlock=NULL;
pBlock = CPAGE_GetBlockFirst(hCPage,HorType);
while (pBlock)
{
fl_cont=FALSE;
size32 = CPAGE_GetBlockData(hCPage,pBlock,HorType,&linfo,size_lineinfo);
if(size32!=size_lineinfo)
{
fl_cont=TRUE;
pBlock = CPAGE_GetBlockNext(hCPage,pBlock,HorType);
}
if(fl_cont)
continue;
if(!(linfo.Flags&LI_IsTrue)||(fl_not_kill_pointed&&(linfo.Flags&LI_Pointed)))
{
fl_cont=TRUE;
pBlock = CPAGE_GetBlockNext(hCPage,pBlock,HorType);
}
if(fl_cont)
continue;
if(nHorLines>=len_hor_mas)
{
if(!AddLenLineMas(&pHorLines,len_hor_mas,add_len_mas))
{
fl_cont=TRUE;
pBlock = CPAGE_GetBlockNext(hCPage,pBlock,HorType);
}
}
if(fl_cont)
continue;
pHorLines[nHorLines].begx=linfo.A.x;
pHorLines[nHorLines].begy=linfo.A.y;
pHorLines[nHorLines].endx=linfo.B.x;
pHorLines[nHorLines].endy=linfo.B.y;
pHorLines[nHorLines].wide10=(linfo.Thickness)*10;
nHorLines++;
pBlock = CPAGE_GetBlockNext(hCPage,pBlock,HorType);
}
/////////////////////////////////////////////////////////////////////////////////////////////
nVerLines=0;
len_ver_mas=50;
pBlock=NULL;
pBlock = CPAGE_GetBlockFirst(hCPage,VerType);
if(!InitLineMas(&pVerLines,len_ver_mas))
{
ctdib->ResetDIB ();
delete ctdib;
CIMAGE_DeleteImage((uchar*)ImageDelLines);
DelLineMas(pHorLines);
return FALSE;
}
while (pBlock)
{
fl_cont=FALSE;
size32 = CPAGE_GetBlockData(hCPage,pBlock,VerType,&linfo,size_lineinfo);
if(size32!=size_lineinfo)
{
fl_cont=TRUE;
pBlock = CPAGE_GetBlockNext(hCPage,pBlock,VerType);
}
if(fl_cont)
continue;
if(!(linfo.Flags&LI_IsTrue)||(fl_not_kill_pointed&&(linfo.Flags&LI_Pointed)))
{
fl_cont=TRUE;
pBlock = CPAGE_GetBlockNext(hCPage,pBlock,VerType);
}
if(fl_cont)
continue;
if(nVerLines>=len_ver_mas)
{
if(!AddLenLineMas(&pVerLines,len_ver_mas,add_len_mas))
{
fl_cont=TRUE;
pBlock = CPAGE_GetBlockNext(hCPage,pBlock,VerType);
}
}
if(fl_cont)
continue;
pVerLines[nVerLines].begx=linfo.A.x;
pVerLines[nVerLines].begy=linfo.A.y;
pVerLines[nVerLines].endx=linfo.B.x;
pVerLines[nVerLines].endy=linfo.B.y;
pVerLines[nVerLines].wide10=(linfo.Thickness)*10;
nVerLines++;
pBlock = CPAGE_GetBlockNext(hCPage,pBlock,VerType);
}
}
*/
/////////////////////////////////////////////////////////////////////////////////////////////
int time_hor=clock();
for(i=0;i<nHorLines;i++)
{
if(pHorLines[i].begx>pHorLines[i].endx)
DelOneHorLine(pmasp,bytewide,num_str,pHorLines[i].endx,pHorLines[i].endy,pHorLines[i].begx,pHorLines[i].begy,pHorLines[i].wide10);
else
DelOneHorLine(pmasp,bytewide,num_str,pHorLines[i].begx,pHorLines[i].begy,pHorLines[i].endx,pHorLines[i].endy,pHorLines[i].wide10);
}
time_hor=clock()-time_hor;
// LDPUMA_ConsoleN("Time hor=%d",time_hor);
int time_ver=clock();
for(i=0;i<nVerLines;i++)
{
if(pVerLines[i].begy>pVerLines[i].endy)
DelOneVerLine(pmasp,bytewide,num_str,pVerLines[i].endx,pVerLines[i].endy,pVerLines[i].begx,pVerLines[i].begy,pVerLines[i].wide10);
else
DelOneVerLine(pmasp,bytewide,num_str,pVerLines[i].begx,pVerLines[i].begy,pVerLines[i].endx,pVerLines[i].endy,pVerLines[i].wide10);
}
time_ver=clock()-time_ver;
// LDPUMA_ConsoleN("Time ver=%d",time_ver);
DelLineMas(pHorLines);
DelLineMas(pVerLines);
}//конец тривиального удаления
ctdib->ResetDIB ();
delete ctdib;
info.Images|=IMAGE_DELLINE;
SetPageInfo(hCPage,info);
time=clock()-time;
// LDPUMA_ConsoleN("Time work=%d",time);
return TRUE;
}
void checkResolution(Handle hCCOM, Handle hCPAGE)
{
PAGEINFO page_info = {0};
const int min_res = 99;
CCOM_comp* pcomp=NULL;
unsigned int Masy[100], Masx[100], i, Jy_m = 0, My_m = 0, Jx_m = 0, Mx_m = 0, M_t;
bool flag_set = false;
if (!GetPageInfo(hCPAGE, &page_info)) return;
if (page_info.DPIX > min_res && page_info.DPIY > min_res) return;
for (i=0; i<100; i++) Masx[i] = Masy[i] = 0;
pcomp = CCOM_GetFirst(hCCOM, NULL);
while (pcomp)
{
if (pcomp->h > 9 && pcomp->h < 100) Masy[pcomp->h]++;
if (pcomp->w > 9 && pcomp->w < 100) Masx[pcomp->w]++;
pcomp = CCOM_GetNext(pcomp, NULL);
}
for (i=11; i < 99; i++)
{
M_t = Masy[i-1] + Masy[i] + Masy[i+1];
if (M_t > My_m)
{
Jy_m = i;
My_m = M_t;
}
M_t = Masx[i-1] + Masx[i] + Masx[i+1];
if (M_t > Mx_m)
{
Jx_m = i;
Mx_m = M_t;
}
}
if (Jy_m > 10 && My_m > 100 && !(page_info.DPIY*22 < 2*300*Jy_m && 2*page_info.DPIY*22 > 300*Jy_m))
{
page_info.DPIY = (300*Jy_m+11)/22;
flag_set = true;
}
if (Jx_m > 10 && Mx_m > 100 && !(page_info.DPIX*22 < 2*300*Jx_m && 2*page_info.DPIX*22 > 300*Jx_m))
{
page_info.DPIX = (300*Jx_m+11)/22;
flag_set = true;
}
if (flag_set)
{
SetPageInfo(hCPAGE, page_info);
if (!LDPUMA_Skip(hDebugPrintResolution))
LDPUMA_ConsoleN("новое разрешение: DPIX=%d, DPIY=%d", page_info.DPIX, page_info.DPIY);
}
}
////////////////////////////////////////////////////////////////////////////////
// Предварительная обработка
// (07.07.2000) Изначально взято из puma.dll без изменений
// сильно привязана к пуме
// в начале окучиваем выделение компонент
Bool32 PreProcessImage( PRSPreProcessImage Image )
{
Bool32 gbAutoRotate = Image->gbAutoRotate;
puchar *gpRecogDIB = Image->pgpRecogDIB;
Handle hCPAGE = Image->hCPAGE;
const char * glpRecogName = *Image->pglpRecogName;
PCIMAGEBITMAPINFOHEADER info = (PCIMAGEBITMAPINFOHEADER)Image->pinfo;
/////////////////////////////////
Bool32 rc = TRUE;
//char * lpRecogName = NULL;
uint32_t Angle = 0;
hWndTurn = 0;
if(InitPRGTIME())
ProgressStart();
if(!ProgressStep(1,5))
rc = FALSE;
// Andrey 12.11.01
// Проинициализируем контейнер CPAGE
//
if(rc)
{
PAGEINFO PInfo = {0};
GetPageInfo(hCPAGE,&PInfo);
strcpy((char*)PInfo.szImageName, glpRecogName);
PInfo.BitPerPixel = info->biBitCount;
PInfo.DPIX = info->biXPelsPerMeter*254L/10000;
// PInfo.DPIX = PInfo.DPIX < 200 ? 200 : PInfo.DPIX;
PInfo.DPIY = info->biYPelsPerMeter*254L/10000;
// PInfo.DPIY = PInfo.DPIY < 200 ? 200 : PInfo.DPIY;
PInfo.Height = info->biHeight;
PInfo.Width = info->biWidth;
// PInfo.X = 0; Уже установлено
// PInfo.Y = 0;
PInfo.Incline2048 = 0;
PInfo.Page = 1;
PInfo.Angle = Angle;
SetPageInfo(hCPAGE,PInfo);
}
////////////////////////////////////////////////////////
// Выделим компоненты
//
if(!ProgressStep(2,65))
rc = FALSE;
if(rc)
{
if(LDPUMA_Skip(Image->hDebugCancelComponent)/*DPumaSkipComponent()*/)
{
// uchar ori;
PRGTIME prev = StorePRGTIME(65, 85);
rc = ExtractComponents( gbAutoRotate, NULL, (puchar)glpRecogName, Image);
RestorePRGTIME(prev);
/* if(rc && gbAutoRotate)
{
//if(!REXC_GetOrient(&ori))
//if(!REXC_GetOrient(&ori) && db_spec_prj!=SPEC_PRJ_GIP )
if(!RNORM_GetOrient(&ori, *(Image->phCCOM)) && db_spec_prj!=SPEC_PRJ_GIP )
{
SetReturnCode_rstuff(RNORM_GetReturnCode());
rc = FALSE;
}
else
{
//if(ori)
if(ori && !(db_spec_prj==SPEC_PRJ_GIP&&ori==4))
{
uint32_t dwTurn = 0;
switch(ori)
{
case 1:
Angle = 270;
dwTurn = RIMAGE_TURN_270;
break;
case 2:
Angle = 90;
dwTurn = RIMAGE_TURN_90;
break;
case 3:
Angle = 180;
dwTurn = RIMAGE_TURN_180;
break;
}
if( LDPUMA_Skip(Image->hDebugCancelTurn) /*umaSkipTurn()*/ /*)
{
if(!RIMAGE_Turn((puchar)glpRecogName,(puchar)PUMA_IMAGE_TURN,dwTurn,0))
{
SetReturnCode_rstuff_rstuff(RIMAGE_GetReturnCode());
rc = FALSE;
}
else
{
if(!CIMAGE_ReadDIB((puchar)PUMA_IMAGE_TURN,(Handle*)gpRecogDIB,TRUE))
{
SetReturnCode_rstuff_rstuff(CIMAGE_GetReturnCode());
rc = FALSE;
}
else
{
//
// удалим общий контейнер
//
glpRecogName = PUMA_IMAGE_TURN;
hWndTurn = LDPUMA_CreateWindow(PUMA_IMAGE_TURN,(*gpRecogDIB));
PRGTIME prev = StorePRGTIME(85, 100);
rc = ExtractComponents( FALSE, NULL, (puchar)glpRecogName, Image);
PAGEINFO info = {0};
GetPageInfo(hCPAGE,&info);
info.Images|=IMAGE_TURN;
// strcpy((char*)info.szImageName,PUMA_IMAGE_TURN);
SetPageInfo(hCPAGE,info);
RestorePRGTIME(prev);
}
}
}
}
}
}*/
//проверим наличие разрешения и попытаемся определить по компонентам, если его нет
checkResolution(*(Image->phCCOM), hCPAGE);
if(!ProgressStep(2,100))
rc = FALSE;
}
else
LDPUMA_Console("Пропущен этап выделения компонент.\n");
}
//
// Переинициализируем контейнер CPAGE
//
if(rc)
{
PAGEINFO PInfo = {0};
GetPageInfo(hCPAGE,&PInfo);
strcpy((char*)PInfo.szImageName, glpRecogName);
PInfo.BitPerPixel = info->biBitCount;
// PInfo.DPIX = info->biXPelsPerMeter*254L/10000;
PInfo.DPIX = PInfo.DPIX < 200 ? 200 : PInfo.DPIX;
// PInfo.DPIY = info->biYPelsPerMeter*254L/10000;
PInfo.DPIY = PInfo.DPIY < 200 ? 200 : PInfo.DPIY;
PInfo.Height = info->biHeight;
PInfo.Width = info->biWidth;
// PInfo.X = 0; Уже установлено
// PInfo.Y = 0;
PInfo.Incline2048 = 0;
PInfo.Page = 1;
PInfo.Angle = Angle;
SetPageInfo(hCPAGE,PInfo);
}
if(DonePRGTIME())
ProgressFinish();
return rc;
}
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;
}
void __fastcall TTiffBook::FlipCurPage(int n) {
//-------------------------------------------------------------------------------
// Переворачивает текущую страницу вверх ногами |
// n - номер страницы, который надо нанести. <= 0 - только убрать ном стр |
//-------------------------------------------------------------------------------
stop++;
Gdiplus::Graphics *g32;
TTiffImage *img = GetImagePage(GetPage());
Gdiplus::Bitmap *fbm = img->fbm;
Gdiplus::Rect r;
int w = fbm->GetWidth(), h = fbm->GetHeight();
// g = new Gdiplus::Graphics(fbm);
Gdiplus::Bitmap *b32 = new Gdiplus::Bitmap(w, h, PixelFormat32bppARGB);
g32 = new Gdiplus::Graphics(b32);
Gdiplus::Matrix matr;
matr.Rotate(180.0f); // поворачиваем его на 270 градусов
g32->SetTransform(&matr);
//r.X = 0;
//r.Y = 0;
//r.Width = w;
//r.Height = h;
//r.X = -SaveBitmapH;
//r.Y = -30;
//r.Width = SaveBitmapH - 30;
//r.Height = SaveBitmapW - 30;
r.X = -w;
r.Y = -h;
r.Width = w;
r.Height = h;
sres = g32->DrawImage(fbm, r, 0, 0, w, h, Gdiplus::UnitPixel, 0, 0, 0);
matr.Reset();
g32->SetTransform(&matr);
// Удаляем черные полосы сверху и снизу
Gdiplus::Pen whitePen2(Gdiplus::Color(255, 255, 255, 255), 2);
g32->DrawLine(&whitePen2, 0, 0, w, 0);
g32->DrawLine(&whitePen2, 0, h-1, w, h-1);
// Удаляем старый номер страницы - он теперь внизу
// Gdiplus::Pen whitePen40(Gdiplus::Color(255, 0, 0, 0), 45); // ??? Пока черный - для отладки!
Gdiplus::Pen whitePen40(Gdiplus::Color(255, 255, 255, 255), 45);
g32->DrawLine(&whitePen40, 0, h - 50, 200, h - 50);
if (n > 0) { // Здесь выводим номер страницы
AnsiString snum;
wchar_t wnum[20];
snum.printf("%d", n);
snum.WideChar(wnum, 20);
Gdiplus::Font myFont(L"Arial", 40, Gdiplus::FontStyleBold);
Gdiplus::PointF origin(w - 160, 20.0f);
Gdiplus::SolidBrush blackBrush(Gdiplus::Color(255, 0, 0, 0));
g32->DrawLine(&whitePen40, w - 200, 50, w, 50);
sres = g32->DrawString(wnum, -1, &myFont, origin, &blackBrush);
}
//if (npage > 0) { // Здесь выводим номер страницы
// AnsiString snum;
// wchar_t wnum[20];
// snum.printf("%d", npage);
// snum.WideChar(wnum, 20);
// Gdiplus::Font myFont(L"Arial", 40, Gdiplus::FontStyleBold);
// Gdiplus::PointF origin(SaveBitmapW - 160, 20.0f);
// Gdiplus::SolidBrush blackBrush(Gdiplus::Color(255, 0, 0, 0));
// SaveBitmap2TiffGraphics->DrawString(wnum, -1, &myFont, origin, &blackBrush);
//}
// ------- строим SaveBitmap2TiffBitmap1
UINT *pix;
unsigned char byte, bit, *pix1;
Gdiplus::Bitmap *b1 = new Gdiplus::Bitmap(w, h, PixelFormat1bppIndexed);
Gdiplus::Rect BitsRect(0, 0, w, h);
Gdiplus::BitmapData *bits = new Gdiplus::BitmapData;
Gdiplus::BitmapData *bits1 = new Gdiplus::BitmapData;
sres = b32->LockBits(&BitsRect, Gdiplus::ImageLockModeRead, PixelFormat32bppARGB, bits);
sres = b1->LockBits(&BitsRect, Gdiplus::ImageLockModeWrite, PixelFormat1bppIndexed, bits1);
for (int y = 0; y < h; y++) {
pix = (UINT *)((int)bits->Scan0 + bits->Stride * y);
pix1 = (unsigned char *)((int)bits1->Scan0 + bits1->Stride * y);
byte = 0;
for (int x = 0; x < w; x++, pix++) {
if ((*pix & 0xFF) > 0xD8) {
bit = 1;
}
else bit = 0;
byte <<= 1; byte |= bit;
if ((x & 7) == 7) {
*pix1++ = byte;
byte = 0;
}
}
}
b32->UnlockBits(bits); delete bits;
b1->UnlockBits(bits1); delete bits1;
delete g32;
delete b32;
TTiffPageInfo *pi = GetPageInfo(GetPage());
if (img->Filn.Length() == 0) { // Это уже временный файл!
delete img->fbm;
img->fbm = b1;
} else { // Надо будет заменить страницу на временный файл
img = new TTiffImage(b1);
pi->ImageIndex = AppendImage(img);
pi->PageIndex = 0;
}
changed = true;
}
