← Back to branch summary

~ubuntu-branches/ubuntu/precise/cuneiform/precise

« back to all changes in this revision

Viewing changes to cuneiform_src/Kern/rshelllines/src/rshelllines.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Jakub Wilk
  • Date: 2010-09-14 15:53:54 UTC
  • mto: (5.1.1 experimental)
  • mto: This revision was merged to the branch mainline in revision 6.
  • Revision ID: james.westby@ubuntu.com-20100914155354-i3uu2woc5aucphax
Tags: upstream-1.0.0+dfsg
Import upstream version 1.0.0+dfsg

Show diffs side-by-side

added added

removed removed

Lines of Context:
cuneiform_src/Kern/rshelllines/src/rshelllines.cpp
2
2
Copyright (c) 1993-2008, Cognitive Technologies
3
3
All rights reserved.
4
4
 
5
 
����������� ��������� ��������������� � ������������� ��� � ���� ��������� ����,
6
 
��� � � �������� �����, � ����������� ��� ���, ��� ���������� ��������� �������:
7
 
 
8
 
      * ��� ��������� ��������������� ��������� ���� ������ ���������� ���������
9
 
        ���� ����������� �� ��������� �����, ���� ������ ������� � �����������
10
 
        ����� �� ��������.
11
 
      * ��� ��������� ��������������� ��������� ���� � ������������ �/��� �
12
 
        ������ ����������, ������������ ��� ���������������, ������ �����������
13
 
        ��������� ���� ���������� �� ��������� �����, ���� ������ ������� �
14
 
        ����������� ����� �� ��������.
15
 
      * �� �������� Cognitive Technologies, �� ����� �� ����������� �� �����
16
 
        ���� ������������ � �������� �������� ��������� �/��� �����������
17
 
        ���������, ���������� �� ���� ��, ��� ���������������� �����������
18
 
        ����������.
19
 
 
20
 
��� ��������� ������������� ����������� ��������� ���� �/��� ������� ������ "���
21
 
��� ����" ��� ������-���� ���� ��������, ���������� ���� ��� ���������������,
22
 
������� �������� ������������ �������� � ����������� ��� ���������� ����, �� ��
23
 
������������� ���. �� �������� ��������� ���� � �� ���� ������ ����, �������
24
 
����� �������� �/��� �������� �������������� ���������, �� � ���� ������ ��
25
 
��Ѩ� ���������������, ������� ����� �����, ���������, ����������� ���
26
 
������������� ������, ��������� � �������������� ��� ���������� ����������
27
 
������������� ������������� ��������� (������� ������ ������, ��� ������,
28
 
������� ���������, ��� ������ �/��� ������ �������, ���������� ��-�� ��������
29
 
������� ��� �/��� ������ ��������� �������� ��������� � ������� �����������,
30
 
�� �� ������������� ����� ��������), �� �� ������������� ���, ���� ���� �����
31
 
�������� ��� ������ ���� ���� �������� � ����������� ����� ������� � ������.
 
5
Разрешается повторное распространение и использование как в виде исходного кода,
 
6
так и в двоичной форме, с изменениями или без, при соблюдении следующих условий:
 
7
 
 
8
      * При повторном распространении исходного кода должны оставаться указанное
 
9
        выше уведомление об авторском праве, этот список условий и последующий
 
10
        отказ от гарантий.
 
11
      * При повторном распространении двоичного кода в документации и/или в
 
12
        других материалах, поставляемых при распространении, должны сохраняться
 
13
        указанная выше информация об авторском праве, этот список условий и
 
14
        последующий отказ от гарантий.
 
15
      * Ни название Cognitive Technologies, ни имена ее сотрудников не могут
 
16
        быть использованы в качестве средства поддержки и/или продвижения
 
17
        продуктов, основанных на этом ПО, без предварительного письменного
 
18
        разрешения.
 
19
 
 
20
ЭТА ПРОГРАММА ПРЕДОСТАВЛЕНА ВЛАДЕЛЬЦАМИ АВТОРСКИХ ПРАВ И/ИЛИ ДРУГИМИ ЛИЦАМИ "КАК
 
21
ОНА ЕСТЬ" БЕЗ КАКОГО-ЛИБО ВИДА ГАРАНТИЙ, ВЫРАЖЕННЫХ ЯВНО ИЛИ ПОДРАЗУМЕВАЕМЫХ,
 
22
ВКЛЮЧАЯ ГАРАНТИИ КОММЕРЧЕСКОЙ ЦЕННОСТИ И ПРИГОДНОСТИ ДЛЯ КОНКРЕТНОЙ ЦЕЛИ, НО НЕ
 
23
ОГРАНИЧИВАЯСЬ ИМИ. НИ ВЛАДЕЛЕЦ АВТОРСКИХ ПРАВ И НИ ОДНО ДРУГОЕ ЛИЦО, КОТОРОЕ
 
24
МОЖЕТ ИЗМЕНЯТЬ И/ИЛИ ПОВТОРНО РАСПРОСТРАНЯТЬ ПРОГРАММУ, НИ В КОЕМ СЛУЧАЕ НЕ
 
25
НЕСЁТ ОТВЕТСТВЕННОСТИ, ВКЛЮЧАЯ ЛЮБЫЕ ОБЩИЕ, СЛУЧАЙНЫЕ, СПЕЦИАЛЬНЫЕ ИЛИ
 
26
ПОСЛЕДОВАВШИЕ УБЫТКИ, СВЯЗАННЫЕ С ИСПОЛЬЗОВАНИЕМ ИЛИ ПОНЕСЕННЫЕ ВСЛЕДСТВИЕ
 
27
НЕВОЗМОЖНОСТИ ИСПОЛЬЗОВАНИЯ ПРОГРАММЫ (ВКЛЮЧАЯ ПОТЕРИ ДАННЫХ, ИЛИ ДАННЫЕ,
 
28
СТАВШИЕ НЕГОДНЫМИ, ИЛИ УБЫТКИ И/ИЛИ ПОТЕРИ ДОХОДОВ, ПОНЕСЕННЫЕ ИЗ-ЗА ДЕЙСТВИЙ
 
29
ТРЕТЬИХ ЛИЦ И/ИЛИ ОТКАЗА ПРОГРАММЫ РАБОТАТЬ СОВМЕСТНО С ДРУГИМИ ПРОГРАММАМИ,
 
30
НО НЕ ОГРАНИЧИВАЯСЬ ЭТИМИ СЛУЧАЯМИ), НО НЕ ОГРАНИЧИВАЯСЬ ИМИ, ДАЖЕ ЕСЛИ ТАКОЙ
 
31
ВЛАДЕЛЕЦ ИЛИ ДРУГОЕ ЛИЦО БЫЛИ ИЗВЕЩЕНЫ О ВОЗМОЖНОСТИ ТАКИХ УБЫТКОВ И ПОТЕРЬ.
32
32
 
33
33
Redistribution and use in source and binary forms, with or without modification,
34
34
are permitted provided that the following conditions are met:
91
91
#define     RSL_AboutLines_SizeMyBuff    492000
92
92
#define     RSL_AboutLines_SizeWorkMem   180000
93
93
 
94
 
//#define     RSL_ERR_NO_MEMORY "������ ��������� ������ ��������"
 
94
//#define     RSL_ERR_NO_MEMORY "Ошибка выделения памяти системой"
95
95
#define RSL_ERR_NO_MEMORY 1
96
96
#define     MAF_GALL_GPTR              0x0010
97
 
Char8       cCommentBuffer[CFIO_MAX_COMMENT];
 
97
char       cCommentBuffer[CFIO_MAX_COMMENT];
98
98
 
99
99
static char *Buffer = NULL;
100
100
static char *WorkMem = NULL;
101
101
 
102
 
static Word16            gwHeightRC = 0;
103
 
static Word16            gwLowRC = 0;
 
102
static uint16_t            gwHeightRC = 0;
 
103
static uint16_t            gwLowRC = 0;
104
104
static HANDLE            ghStorage = NULL;
105
105
static HINSTANCE         ghInst =  NULL;
106
106
//DVP DLine*             tempLine;
124
124
typedef Bool32 (*FNPUMA_XGetTemplate)(Rect32 *pRect);
125
125
typedef struct tagRSPreProcessImage
126
126
{
127
 
    PWord8      *pgpRecogDIB;
 
127
    puchar      *pgpRecogDIB;
128
128
    Bool32      gbAutoRotate;
129
129
    Bool32  gbDotMatrix;
130
130
    Bool32  gbFax100;
131
 
    Word32  gnLanguage;
132
 
    Word32  gnTables;
 
131
    uint32_t  gnLanguage;
 
132
    uint32_t  gnTables;
133
133
    Handle      hCPAGE;
134
134
    Handle  hDebugCancelSearchPictures;
135
135
    Handle  hDebugCancelComponent;
147
147
    Handle* phLinesCCOM;
148
148
    void *  phCLINE;
149
149
    PBool32 pgneed_clean_line;
150
 
    PInt32  pgnNumberTables;
151
 
    Word32  gnPictures;
 
150
    int32_t *  pgnNumberTables;
 
151
    uint32_t  gnPictures;
152
152
    Bool32* pgrc_line;
153
153
    Rect32  gRectTemplate;
154
154
    FNPUMA_XSetTemplate fnXSetTemplate;
156
156
    char *szLayoutFileName;
157
157
} RSPreProcessImage, *PRSPreProcessImage;
158
158
 
159
 
Bool32 AboutLines (PRSPreProcessImage Image, Bool32 *BadScan, Int32 *ScanQual);
 
159
Bool32 AboutLines (PRSPreProcessImage Image, Bool32 *BadScan, int32_t *ScanQual);
160
160
 
161
 
//  BOOL APIENTRY DllMain( HANDLE hModule,
162
 
//                         DWORD  ul_reason_for_call,
163
 
//                         LPVOID lpReserved
 
161
//  Bool APIENTRY DllMain( HANDLE hModule,
 
162
//                         uint32_t  ul_reason_for_call,
 
163
//                         pvoid lpReserved
164
164
//                                )
165
165
//  {
166
166
//      switch (ul_reason_for_call)
192
192
}
193
193
 
194
194
///////////////////////////////////////////////////////////////
195
 
RSL_FUNC(Bool32) RSL_Init(Word16 wHeightCode,HANDLE hStorage)
 
195
RSL_FUNC(Bool32) RSL_Init(uint16_t wHeightCode,HANDLE hStorage)
196
196
{
197
197
        LDPUMA_Init(0,NULL);
198
198
        LDPUMA_Registry(&hDebugRSL,SNAP_STUFF_RSL,NULL);
199
 
        LDPUMA_Registry(&hPreRSL_Root, "��������������� ��������� �����", hDebugRSL);
200
 
        LDPUMA_Registry(&hPreRSL_Debug, "������� ������ (pre)", hPreRSL_Root);
201
 
        LDPUMA_Registry(&hPreRSL_Control, "�������� ������ (pre)", hPreRSL_Root);
202
 
 
203
 
        LDPUMA_Registry(&hSkipCheckUnderlining, "��������� �������� ���������", hPreRSL_Debug);
204
 
        LDPUMA_Registry(&hPrintUnderlineTest, "����� ����������� �������� �������������", hPreRSL_Control);
205
 
        LDPUMA_RegistryHelp(hPrintUnderlineTest, "� Console ���������� ���������� ������ ����� (�� 1000) � ������� ����� ������ �����", FALSE);
206
 
        LDPUMA_Registry(&hPrintUnderlines, "����� ��������� ���������", hPreRSL_Control);
207
 
        LDPUMA_RegistryHelp(hPrintUnderlines, "� Console ���������� ���������� �����, ������������ ��� ��������", FALSE);
208
 
 
209
 
        LDPUMA_Registry(&hSkipCheckRaster, "�� ��������� ����� �� ������", hPreRSL_Debug);
210
 
        LDPUMA_RegistryHelp(hSkipCheckRaster, "���� ��������� �������� ����� �� ������, ����� ������������� �����, ���������� �� ������� ������", FALSE);
211
 
        LDPUMA_Registry(&hPrintRasterCheck, "����� ����������� �������� ������", hPreRSL_Control);
212
 
        LDPUMA_RegistryHelp(hPrintRasterCheck, "� Console ���������� ���������� ������ ����� (�� 1000) � ������ �����", FALSE);
213
 
 
214
 
        LDPUMA_Registry(&hDebugFrag,"����� ���������� �����",hDebugRSL);
215
 
    LDPUMA_Registry(&hDebugFragOwner,"������� ������ ���������� �����",hDebugFrag);
216
 
    LDPUMA_Registry(&hDebugFragOwnerControl,"�������� ������ ���������� �����",hDebugFrag);
217
 
 
218
 
        LDPUMA_Registry(&hDebugDrowRectForRaster,"�������� ������������� �����",hDebugFragOwnerControl);
219
 
        LDPUMA_Registry(&hSkipCorrectPolynomia,"�� �������������� 4-��������� �����",hDebugFragOwner);
220
 
        LDPUMA_Registry(&hPrintCorrectPolynomia,"��������� �������� 4-���������� �����",hDebugFragOwnerControl);
221
 
        LDPUMA_RegistryHelp(hPrintCorrectPolynomia,"����� �� ������� ����������� �������� 4-���������� �����",FALSE);
222
 
        LDPUMA_Registry(&hDebugDrowPolynomia,"�������� ������ �����",hDebugFragOwnerControl);
223
 
        LDPUMA_Registry(&hDebugDrowCleanedRaster,"�������� ������������� ����� ����� ���������",hDebugFragOwnerControl);
224
 
        LDPUMA_Registry(&hDebugDrowGetCorrectedLineStripesIntervals,"�������� ������������ ������������� �����",hDebugFragOwnerControl);
225
 
 
226
 
        LDPUMA_Registry(&hDebugDrowVerticalLineRaster,"�������� ����� ������������ �����",hDebugFragOwnerControl);
227
 
        LDPUMA_Registry(&hDebugDrowVerticalLineStripesIntervals,"�������� ������������ ������������� ������������ �����",hDebugFragOwnerControl);
228
 
        LDPUMA_Registry(&hDebugDrowVerticalLineCutPoints,"�������� ����� ����������� ������������ �����",hDebugFragOwnerControl);
229
 
        LDPUMA_Registry(&hDebugTypeIntervals,"����� �� Consol ��������� ���������� �����",hDebugFragOwnerControl);
230
 
        LDPUMA_Registry(&hDebugTypeStripe,"����� �� Consol ������������ ������������� �����",hDebugFragOwnerControl);
231
 
        LDPUMA_Registry(&hSkipDeleteNoiseEvents, "�� ��������� �������� ������� ����������", hDebugFragOwner);
232
 
        LDPUMA_RegistryHelp(hSkipDeleteNoiseEvents, "�� ������� ������� ���������", FALSE);
233
 
        LDPUMA_Registry(&hSkipDelFragLines, "�� ������� ������ ����������������� �����", hDebugFragOwner);
234
 
        LDPUMA_RegistryHelp(hSkipDelFragLines, "�� ������� ����� � ������ ���������� ������ 5", FALSE);
235
 
        LDPUMA_Registry(&hPrintFragLines, "������ ����������� �������� ������������", hDebugFragOwnerControl);
236
 
        LDPUMA_RegistryHelp(hPrintFragLines, "����� �� Consol ����������� �������� ���������� �� ��������", FALSE);
237
 
        LDPUMA_Registry(&hDebugDrawLineFragmentsOwnWindow,"�������� ��������� ����� � ��������� ����",hDebugFragOwnerControl);
238
 
        LDPUMA_Registry(&hDebugDroweparationPoints,"�������� ����� ������� ����� � ��������� ����",hDebugFragOwnerControl);
239
 
    LDPUMA_Registry(&hDebugDrawLineFragments,"�������� ��������� ����� � �������� ����",hDebugFragOwnerControl);
240
 
    LDPUMA_RegistryHelp(hDebugDrawLineFragments, "��������� �������� ��� ������ ����� � �����������", FALSE);
241
 
 
242
 
        LDPUMA_Registry(&hDebugAttr,"����� ��������� �����",hDebugRSL);
243
 
    LDPUMA_Registry(&hDebugAttrOwner,"�������� ������ ��������� �����",hDebugAttr);
244
 
        LDPUMA_Registry(&hDebugTypeWidth,"����� �� Consol ������ �����",hDebugAttrOwner);
245
 
        LDPUMA_Registry(&hDebugTypeDegree,"����� �� Consol ���� ������� �����",hDebugAttrOwner);
 
199
        LDPUMA_Registry(&hPreRSL_Root, "Предварительная обработка линий", hDebugRSL);
 
200
        LDPUMA_Registry(&hPreRSL_Debug, "Отладка работы (pre)", hPreRSL_Root);
 
201
        LDPUMA_Registry(&hPreRSL_Control, "Контроль работы (pre)", hPreRSL_Root);
 
202
 
 
203
        LDPUMA_Registry(&hSkipCheckUnderlining, "Выключить проверку подчерков", hPreRSL_Debug);
 
204
        LDPUMA_Registry(&hPrintUnderlineTest, "Вывод результатов проверки подчеркивания", hPreRSL_Control);
 
205
        LDPUMA_RegistryHelp(hPrintUnderlineTest, "В Console печатается количество черных точек (на 1000) в верхней части растра линии", FALSE);
 
206
        LDPUMA_Registry(&hPrintUnderlines, "Вывод координат подчерков", hPreRSL_Control);
 
207
        LDPUMA_RegistryHelp(hPrintUnderlines, "В Console печатаются координаты линий, определенных как подчерки", FALSE);
 
208
 
 
209
        LDPUMA_Registry(&hSkipCheckRaster, "Не проверять линии по растру", hPreRSL_Debug);
 
210
        LDPUMA_RegistryHelp(hSkipCheckRaster, "Если выключить проверку линий по растру, могут подтвердиться линии, выделенные по жирному тексту", FALSE);
 
211
        LDPUMA_Registry(&hPrintRasterCheck, "Вывод результатов проверки растра", hPreRSL_Control);
 
212
        LDPUMA_RegistryHelp(hPrintRasterCheck, "В Console печатается количество черных точек (на 1000) в растре линии", FALSE);
 
213
 
 
214
        LDPUMA_Registry(&hDebugFrag,"Поиск фрагментов линии",hDebugRSL);
 
215
    LDPUMA_Registry(&hDebugFragOwner,"Отладка поиска фрагментов линии",hDebugFrag);
 
216
    LDPUMA_Registry(&hDebugFragOwnerControl,"Контроль поиска фрагментов линии",hDebugFrag);
 
217
 
 
218
        LDPUMA_Registry(&hDebugDrowRectForRaster,"Рисуется прямоугольник линии",hDebugFragOwnerControl);
 
219
        LDPUMA_Registry(&hSkipCorrectPolynomia,"Не корректировать 4-хугольник линии",hDebugFragOwner);
 
220
        LDPUMA_Registry(&hPrintCorrectPolynomia,"Результат проверки 4-хугольника линии",hDebugFragOwnerControl);
 
221
        LDPUMA_RegistryHelp(hPrintCorrectPolynomia,"Вывод на консоль результатов проверки 4-хугольника линии",FALSE);
 
222
        LDPUMA_Registry(&hDebugDrowPolynomia,"Рисуется контур линии",hDebugFragOwnerControl);
 
223
        LDPUMA_Registry(&hDebugDrowCleanedRaster,"Рисуется прямоугольник линии после подчистки",hDebugFragOwnerControl);
 
224
        LDPUMA_Registry(&hDebugDrowGetCorrectedLineStripesIntervals,"Рисуется интервальное представление линии",hDebugFragOwnerControl);
 
225
 
 
226
        LDPUMA_Registry(&hDebugDrowVerticalLineRaster,"Рисуется растр вертикальной линии",hDebugFragOwnerControl);
 
227
        LDPUMA_Registry(&hDebugDrowVerticalLineStripesIntervals,"Рисуется интервальное представление вертикальной линии",hDebugFragOwnerControl);
 
228
        LDPUMA_Registry(&hDebugDrowVerticalLineCutPoints,"Рисуется точки пересечения вертикальной линии",hDebugFragOwnerControl);
 
229
        LDPUMA_Registry(&hDebugTypeIntervals,"Вывод на Consol координат интервалов линии",hDebugFragOwnerControl);
 
230
        LDPUMA_Registry(&hDebugTypeStripe,"Вывод на Consol интервальное представление линии",hDebugFragOwnerControl);
 
231
        LDPUMA_Registry(&hSkipDeleteNoiseEvents, "Не выполнять удаление шумовых фрагментов", hDebugFragOwner);
 
232
        LDPUMA_RegistryHelp(hSkipDeleteNoiseEvents, "Не удалять шумовые фрагменты", FALSE);
 
233
        LDPUMA_Registry(&hSkipDelFragLines, "Не удалять сильно фрагментированную линии", hDebugFragOwner);
 
234
        LDPUMA_RegistryHelp(hSkipDelFragLines, "Не удалять линии с числом фрагментов больше 5", FALSE);
 
235
        LDPUMA_Registry(&hPrintFragLines, "Печать результатов проверки фрагментации", hDebugFragOwnerControl);
 
236
        LDPUMA_RegistryHelp(hPrintFragLines, "Вывод на Consol результатов проверки кандидатов на удаление", FALSE);
 
237
        LDPUMA_Registry(&hDebugDrawLineFragmentsOwnWindow,"Рисуются фрагменты линии в отдельном окне",hDebugFragOwnerControl);
 
238
        LDPUMA_Registry(&hDebugDroweparationPoints,"Рисуются точки деления линии в отдельном окне",hDebugFragOwnerControl);
 
239
    LDPUMA_Registry(&hDebugDrawLineFragments,"Рисуются фрагменты линии в основном окне",hDebugFragOwnerControl);
 
240
    LDPUMA_RegistryHelp(hDebugDrawLineFragments, "Фрагменты рисуются для каждой линии в отдельности", FALSE);
 
241
 
 
242
        LDPUMA_Registry(&hDebugAttr,"Поиск атрибутов линий",hDebugRSL);
 
243
    LDPUMA_Registry(&hDebugAttrOwner,"Контроль поиска атрибутов линии",hDebugAttr);
 
244
        LDPUMA_Registry(&hDebugTypeWidth,"Вывод на Consol ширины линии",hDebugAttrOwner);
 
245
        LDPUMA_Registry(&hDebugTypeDegree,"Вывод на Consol угла наклона линии",hDebugAttrOwner);
246
246
 
247
247
    gwHeightRC = wHeightCode;
248
248
 
249
249
    return RESULT;
250
250
}
251
251
 
252
 
void SetReturnCode_rshelllines(Word16 rc)
 
252
void SetReturnCode_rshelllines(uint16_t rc)
253
253
{
254
254
    gwLowRC = rc;
255
255
}
264
264
 
265
265
//////////////////////////////////////////////////////////////////////////////////
266
266
//
267
 
RSL_FUNC(Word32) RSL_GetReturnCode()
 
267
RSL_FUNC(uint32_t) RSL_GetReturnCode()
268
268
{
269
 
    Word32 rc = 0;
 
269
    uint32_t rc = 0;
270
270
    if((gwLowRC - IDS_ERR_NO)>0)
271
 
        rc = (Word32)(gwHeightRC<<16)|(gwLowRC - IDS_ERR_NO);
 
271
        rc = (uint32_t)(gwHeightRC<<16)|(gwLowRC - IDS_ERR_NO);
272
272
 
273
273
    return rc;
274
274
}
275
275
 
276
276
//////////////////////////////////////////////////////////////////////////////////
277
277
//
278
 
RSL_FUNC(Int8 *) RSL_GetReturnString(Word32 dwError)
 
278
RSL_FUNC(char *) RSL_GetReturnString(uint32_t dwError)
279
279
{
280
 
        Word16 rc = (Word16)(dwError & 0xFFFF) + IDS_ERR_NO;
281
 
        static Int8 szBuffer[512];
 
280
        uint16_t rc = (uint16_t)(dwError & 0xFFFF) + IDS_ERR_NO;
 
281
        static char szBuffer[512];
282
282
 
283
283
        if( dwError >> 16 != gwHeightRC)
284
284
                gwLowRC = IDS_ERR_NOTIMPLEMENT;
294
294
 
295
295
//////////////////////////////////////////////////////////////////////////////////
296
296
//
297
 
RSL_FUNC(Bool32) RSL_GetExportData(Word32 dwType, void * pData)
 
297
RSL_FUNC(Bool32) RSL_GetExportData(uint32_t dwType, void * pData)
298
298
{
299
299
        Bool32 rc = TRUE;
300
300
 
303
303
 
304
304
//////////////////////////////////////////////////////////////////////////////////
305
305
//
306
 
RSL_FUNC(Bool32) RSL_SetImportData(Word32 dwType, void * pData)
 
306
RSL_FUNC(Bool32) RSL_SetImportData(uint32_t dwType, void * pData)
307
307
{
308
308
        Bool32 rc = RESULT;
309
309
 
315
315
    RSPreProcessImage IImage;
316
316
    PRSPreProcessImage Image = &IImage;
317
317
 
318
 
    Word32 nTeor = sizeof (RSPreProcessImage);
 
318
    uint32_t nTeor = sizeof (RSPreProcessImage);
319
319
    Handle hPage = CPAGE_GetHandlePage(CPAGE_GetCurrentPage());
320
320
    Handle VerifyN = CPAGE_GetBlockFirst (*phCPage, RSL_VERLINE);//hPage, RSL_VERLINE);
321
 
    Word32 nReal = CPAGE_GetBlockData (*phCPage, VerifyN, RSL_VERLINE, Image, nTeor);
322
 
//     Word32 err32 = CPAGE_GetReturnCode ();
 
321
    uint32_t nReal = CPAGE_GetBlockData (*phCPage, VerifyN, RSL_VERLINE, Image, nTeor);
 
322
//     uint32_t err32 = CPAGE_GetReturnCode ();
323
323
//     if (err32)
324
324
//         return FALSE;
325
325
 
332
332
            if( !RVERLINE_SetImportData(RVERLINE_DTRVERLINE_RegimeOfVerifyLines,&val)||
333
333
                !RVERLINE_MarkLines(*Image->phCCOM, Image->hCPAGE))
334
334
            {
335
 
                SetReturnCode_rshelllines((Word16)RVERLINE_GetReturnCode());
 
335
                SetReturnCode_rshelllines((uint16_t)RVERLINE_GetReturnCode());
336
336
                rc = FALSE;
337
337
            }
338
338
            else
339
339
            {
340
340
                Bool32 BadScan = FALSE;
341
 
                Int32  ScanQual= 0;
 
341
                int32_t  ScanQual= 0;
342
342
                AboutLines(Image, &BadScan, &ScanQual);
343
343
            }
344
344
 
356
356
 
357
357
//////////////////////////////////////////////////////////////////////////////////
358
358
//
359
 
void *  RSLAlloc(Word32 stAllocateBlock)
 
359
void *  RSLAlloc(uint32_t stAllocateBlock)
360
360
{
361
361
    char * mem = NULL;
362
362
 
374
374
#endif
375
375
 
376
376
    if(!mem)
377
 
        SetReturnCode_rshelllines((Word16)RSL_ERR_NO_MEMORY);
 
377
        SetReturnCode_rshelllines((uint16_t)RSL_ERR_NO_MEMORY);
378
378
#else
379
379
 
380
 
    mem = (char *)CFIO_DAllocMemory(stAllocateBlock,MAF_GALL_GPTR,(Int8*)"RSL", (Int8*)cCommentBuffer);
 
380
    mem = (char *)CFIO_DAllocMemory(stAllocateBlock,MAF_GALL_GPTR,(char*)"RSL", (char*)cCommentBuffer);
381
381
 
382
382
    if(!mem)
383
 
        SetReturnCode_rshelllines((Word16)RSL_ERR_NO_MEMORY);
 
383
        SetReturnCode_rshelllines((uint16_t)RSL_ERR_NO_MEMORY);
384
384
 
385
385
#endif
386
386
 
407
407
#endif
408
408
}
409
409
 
410
 
Bool32 AboutLines (PRSPreProcessImage Image, Bool32 *BadScan, Int32 *ScanQual)
 
410
Bool32 AboutLines (PRSPreProcessImage Image, Bool32 *BadScan, int32_t *ScanQual)
411
411
{
412
412
        int SizeMain, SizeWork;
413
413
 
423
423
 
424
424
        if (Buffer == NULL || WorkMem == NULL )
425
425
        {
426
 
                SetReturnCode_rshelllines((Word16)RSL_ERR_NO_MEMORY);
 
426
                SetReturnCode_rshelllines((uint16_t)RSL_ERR_NO_MEMORY);
427
427
                bRc =  FALSE;
428
428
        }
429
429
 
431
431
                do
432
432
                {
433
433
                        //////////////////////////////////////////////////////////////////////////////////////
434
 
                        /*  1. ��������.  */
 
434
                        /*  1. Контроль.  */
435
435
                        if ((Image->pgneed_clean_line==NULL)&&(BadScan!=NULL))
436
436
                                break;
437
437
                                //return TRUE;
438
438
 
439
 
                        /*  2. �������������.  */
 
439
                        /*  2. Инициализация.  */
440
440
                        vMain = Buffer;
441
441
                        SizeMain = RSL_AboutLines_SizeMyBuff;
442
442
                        MainBuff.vBuff    = vMain;
451
451
                        {
452
452
                                *Image->pgneed_clean_line = FALSE;
453
453
                                CLINE_handle hCLINE=*((CLINE_handle*)(Image->phCLINE));
454
 
                                BOOL fl_break=FALSE;
 
454
                                Bool fl_break=FALSE;
455
455
                                for(CLINE_handle hline=CLINE_GetFirstLine(hCLINE);hline;hline=CLINE_GetNextLine(hline))
456
456
                                {
457
457
                                        CPDLine cpdata=CLINE_GetLineData(hline);
468
468
                                if (1)
469
469
                                {
470
470
                                        if (*Image->pgneed_clean_line)
471
 
                                                LDPUMA_ConsoleN ("RSource: ����� ����� �����.");
 
471
                                                LDPUMA_ConsoleN ("RSource: Нужно снять линии.");
472
472
                                        else
473
 
                                                LDPUMA_ConsoleN ("RSource: �� ���� ������� �����!");
 
473
                                                LDPUMA_ConsoleN ("RSource: Не надо снимать линии!");
474
474
                                }
475
475
                        }
476
476
//                 }
478
478
                        if (BadScan!=NULL)
479
479
                        {
480
480
                                if (1)
481
 
                                        LDPUMA_ConsoleN ("RSource: �������� ������������ : �� ���� ���� ����������.");
 
481
                                        LDPUMA_ConsoleN ("RSource: Качество сканирования : не умею пока определять.");
482
482
                                *BadScan = TRUE;
483
483
                                *ScanQual = 100;
484
484
                        }
492
492
 
493
493
//////////////////////////////////////////////////////////////////////////////////
494
494
//
495
 
Word16 GetReturnCode_rshelllines()
 
495
uint16_t GetReturnCode_rshelllines()
496
496
{
497
497
        return gwLowRC;
498
498
}
532
532
 
533
533
struct FictInterval
534
534
{
535
 
        Int32 Level;
536
 
        Int32 Pos;
537
 
        Int32 End;
538
 
        Int32 RelIndex;
 
535
        int32_t Level;
 
536
        int32_t Pos;
 
537
        int32_t End;
 
538
        int32_t RelIndex;
539
539
};
540
540
 
541
541
static int mycompare( const void *elem1, const void *elem2 )
553
553
 
554
554
// struct TieComp
555
555
// {
556
 
//      Int32 LeftBorder;
557
 
//      Int32 RightBorder;
558
 
//      Int32 Weight;
 
556
//      int32_t LeftBorder;
 
557
//      int32_t RightBorder;
 
558
//      int32_t Weight;
559
559
//      Bool32 IsNoiseComp;
560
 
//      Int32 VoteResult;
 
560
//      int32_t VoteResult;
561
561
// };
562
562
 
563
563
void   DeleteNoiseEvents(CLINE_handle hLine, DLine* pLine)
565
565
        return;
566
566
}
567
567
 
568
 
void CheckUnderlining(CLINE_handle hLine, DLine* pLine, LPSTR pSourceRaster)
 
568
void CheckUnderlining(CLINE_handle hLine, DLine* pLine, char* pSourceRaster)
569
569
{
570
570
        return;
571
571
}
572
572
 
573
 
Bool32 CompareRasterParts(CPDLine pLine, LPSTR pSourceRaster, Bool32 CheckSerif)
 
573
Bool32 CompareRasterParts(CPDLine pLine, char* pSourceRaster, Bool32 CheckSerif)
574
574
{
575
575
    return TRUE;
576
576
}
590
590
    return 0;
591
591
}
592
592
 
593
 
BOOL SL_IsPointInAB(Point32 *P,Point32 *A,Point32 *B)
 
593
Bool SL_IsPointInAB(Point32 *P,Point32 *A,Point32 *B)
594
594
{
595
595
    return FALSE;
596
596
}
615
615
{
616
616
}
617
617
 
618
 
void   CleaningRaster(DLine* pCLine, LPSTR Buffer)
619
 
{
620
 
}
621
 
 
622
 
void   DrowCleanedRaster(DLine* pCLine, LPSTR Buffer, CIMAGEBITMAPINFOHEADER* image_info, Handle* HndMyWindow)
623
 
{
624
 
}
625
 
 
626
 
void   DrowVerticalLineRaster(DLine* pCLine, LPSTR Buffer, CIMAGEBITMAPINFOHEADER* image_info, Handle* HndMyWindow)
627
 
{
628
 
}
629
 
 
630
 
void   Transpose_bit_matrixes(PCHAR buf_in,PCHAR buf_out, Rect32* rect)
631
 
{
632
 
}
633
 
 
634
 
BOOL GetLineStripesIntervals(CLINE_handle line, DLine* pCLine, PCHAR  pRaster, BOOL FlagVerticalLine)
 
618
void   CleaningRaster(DLine* pCLine, char* Buffer)
 
619
{
 
620
}
 
621
 
 
622
void   DrowCleanedRaster(DLine* pCLine, char* Buffer, CIMAGEBITMAPINFOHEADER* image_info, Handle* HndMyWindow)
 
623
{
 
624
}
 
625
 
 
626
void   DrowVerticalLineRaster(DLine* pCLine, char* Buffer, CIMAGEBITMAPINFOHEADER* image_info, Handle* HndMyWindow)
 
627
{
 
628
}
 
629
 
 
630
void   Transpose_bit_matrixes(pchar buf_in,pchar buf_out, Rect32* rect)
 
631
{
 
632
}
 
633
 
 
634
Bool GetLineStripesIntervals(CLINE_handle line, DLine* pCLine, pchar  pRaster, Bool FlagVerticalLine)
635
635
{
636
636
    return TRUE;
637
637
}
638
638
 
639
 
void   FillingStripes(CLINE_handle line, int y, INT Count, WORD* pIntervals, BOOL FlagVerticalLine, DLine* pCLine)
640
 
{
641
 
}
642
 
 
643
 
void   CheckDotLines(DLine* pCLine, BOOL FlagVerticalLine)
644
 
{
645
 
}
646
 
 
647
 
void   TypeIntervals(int y, INT Count, WORD* pIntervals)
 
639
void   FillingStripes(CLINE_handle line, int y, int16_t Count, uint16_t* pIntervals, Bool FlagVerticalLine, DLine* pCLine)
 
640
{
 
641
}
 
642
 
 
643
void   CheckDotLines(DLine* pCLine, Bool FlagVerticalLine)
 
644
{
 
645
}
 
646
 
 
647
void   TypeIntervals(int y, int16_t Count, uint16_t* pIntervals)
648
648
{
649
649
}
650
650
 
652
652
{
653
653
}
654
654
 
655
 
BOOL   GetLineFragments(CLINE_handle line, DLine* pCLine)
 
655
Bool   GetLineFragments(CLINE_handle line, DLine* pCLine)
656
656
{
657
657
    return TRUE;
658
658
}
699
699
    return FALSE;
700
700
}
701
701
 
702
 
RSHELLLINES_FUNC( Bool) SL_GetRaster(Rect32* rect, Word8** ppData, PAGEINFO* page_info)
 
702
RSHELLLINES_FUNC( Bool) SL_GetRaster(Rect32* rect, uchar** ppData, PAGEINFO* page_info)
703
703
{
704
704
    return TRUE;
705
705
}
716
716
{
717
717
}
718
718
 
719
 
RSHELLLINES_FUNC(Int32) RSL_VerifyShortLine(CPDLine pLine, Handle hCCOM, PAGEINFO* page_info, Word8 lang, Word8 debug_flags, Int32 *cross_point)
 
719
RSHELLLINES_FUNC(int32_t) RSL_VerifyShortLine(CPDLine pLine, Handle hCCOM, PAGEINFO* page_info, uchar lang, uchar debug_flags, int32_t *cross_point)
720
720
{
721
721
    return 0;
722
722
}
727
727
}
728
728
 
729
729
Bool32 SetExtLines(CLINE_handle hExtContainer, CLINE_handle hContainer, CLINE_handle* hLinesMass,
730
 
                   Int32 CountLines)
 
730
                   int32_t CountLines)
731
731
{
732
732
    return FALSE;
733
733
}
734
734
 
735
 
Int32 CountBlackRaster(CPDLine pLine, CPDLine pLineExt, Bool32 IsHor, Int32 delta, Handle hDrawRaster)
 
735
int32_t CountBlackRaster(CPDLine pLine, CPDLine pLineExt, Bool32 IsHor, int32_t delta, Handle hDrawRaster)
736
736
{
737
737
    return 0;
738
738
}