← Back to branch summary

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

« back to all changes in this revision

Viewing changes to cuneiform_src/Kern/rcorrkegl/src/cpp/cor_kegl.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Jakub Wilk, c-assert.diff, slovenian-slv.diff
  • Date: 2011-01-26 21:53:07 UTC
  • mfrom: (5.1.1 experimental)
  • Revision ID: james.westby@ubuntu.com-20110126215307-62x61mcesr607qb7
Tags: 1.0.0+dfsg-2
http://bugs.debian.org/608345
http://bugs.debian.org/572061
http://bugs.debian.org/602512
* Upload to unstable.
* Explicitly build-depend on pkg-config. Thanks to Stefano Rivera for the
  bug report.
* Add Vcs-* fields.
* Use the standard C assert() macro, rather than custom Cuneiform one.
  [c-assert.diff]
* Pass CFLAGS, CXXFLAGS and LDFLAGS (get from dpkg-buildflags) to cmake
  (closes: #608345). Thanks to Sami Liedes for the bug report.
  + Build depend on dpkg-dev (>= 1.15.7).
* Pass --parallel to dh.
  + Bump debhelper minimum version to 7.4.10.
* Update debian/copyright to the latest DEP-5 version.
* Bump year in debian/copyright.
* Explicitly link to GraphicsMagick (rather than via the ImageMagick
  compatibility layer).
* Don't ship /usr/lib/cuneiform/*.so symlinks. These libraries are
  considered private, at least until #598616 is fixed.
* Rename some private variables in debian/rules to make them lowercase.
* Update patch headers.
* Provide proper ‘build-arch’ and ‘build-indep’ targets in debian/rules.
* Document input format in the manual page (closes: #572061). Thanks to
  Janusz S. Bień for the bug report.
* Use ‘slv’ (rather than ‘slo’) as language code for Slovenian.
  [slovenian-slv.diff]
* Fix package description: Slovenian is supported, Slovak is not.
* Improve documentation of the language (-l) option (closes: #602512).
  Thanks to Jari Aalto for the bug report.
* Install reasons file for vrms.

Show diffs side-by-side

added added

removed removed

Lines of Context:
cuneiform_src/Kern/rcorrkegl/src/cpp/cor_kegl.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:
84
84
#endif
85
85
#define  INCLINE_FACTOR  2048
86
86
#define  RELY_LET  220
87
 
#define  V_SIZE  10000  //����. ������ �������� �� ���������
88
 
#define  USER_FRAG       CPAGE_BLOCK_USER  //��������, ���������� �������������
89
 
#define  UNCERTAIN_FRAG  CPAGE_BLOCK_UNCERTAIN //�������������� (������� ��� ������)
90
 
 
91
 
#define  MAX_KEG   127 //������������ ������ ����� � ��������
92
 
#define  KEG_PAGE  10  //������������ ����� ������ �� ��������
93
 
#define  FRAG_PAGE MaxHorLines*MaxVerLines //������������ ����� ���������� �� ��������, ������� ������ ������
94
 
#define  BIG_FRAG_PAGE FRAG_PAGE //������������ ����� ���������� �� ��������
95
 
//#define  BIG_FRAG_PAGE 50 //������������ ����� ���������� �� ��������
96
 
#define  LINE_PAGE FRAG_PAGE //������������ ����� ����� �� ��������
97
 
 
98
 
typedef Word16 KegStat[MAX_KEG+2];
 
87
#define  V_SIZE  10000  //макс. размер страницы по вертикали
 
88
#define  USER_FRAG       CPAGE_BLOCK_USER  //фрагмент, помеченный пользователем
 
89
#define  UNCERTAIN_FRAG  CPAGE_BLOCK_UNCERTAIN //неопределенный (хороший или плохой)
 
90
 
 
91
#define  MAX_KEG   127 //максимальный размер кегля в пикселах
 
92
#define  KEG_PAGE  10  //максимальное число кеглей на странице
 
93
#define  FRAG_PAGE MaxHorLines*MaxVerLines //максимальное число фрагментов на странице, включая ячейки таблиц
 
94
#define  BIG_FRAG_PAGE FRAG_PAGE //максимальное число фрагментов на странице
 
95
//#define  BIG_FRAG_PAGE 50 //максимальное число фрагментов на странице
 
96
#define  LINE_PAGE FRAG_PAGE //максимальное число строк на странице
 
97
 
 
98
typedef uint16_t KegStat[MAX_KEG+2];
99
99
 
100
100
typedef struct tagKegTabElement
101
101
{
102
 
  Int8  keg0;  //���� keg0>0, �� ��� ������� ������������ ��������,
103
 
  Int8  keg1;  // ����� -keg0 � -keg1 - ��������� �������� ����
 
102
  char  keg0;  //если keg0>0, то это надежно определенное значение,
 
103
  char  keg1;  // иначе -keg0 и -keg1 - возможные значения кегл
104
104
} KegTabElement;
105
105
 
106
106
typedef KegTabElement KegTab[MAX_KEG+1];
107
107
 
108
 
typedef struct tagPageWord  //����� �� ��������
 
108
typedef struct tagPageWord  //слово на странице
109
109
{
110
 
  Int32 fragment;  //����� ���������
111
 
  Int32 line;     //����� ������ � ���������
112
 
  Int32 word;     //����� ����� � ������
113
 
  CSTR_rast beg,end;  //������ ������ � ��������� �� ������
 
110
  int32_t fragment;  //номер фрагмента
 
111
  int32_t line;     //номер строки в фрагменте
 
112
  int32_t word;     //номер слова в строке
 
113
  CSTR_rast beg,end;  //растры начала и следующий за концом
114
114
} PageWord;
115
115
 
116
 
typedef struct tagFontStat   //��� ����������� ���������� �� ���������
 
116
typedef struct tagFontStat   //для определения серифности во фрагменте
117
117
{
118
 
  Int32 straight;            //����� ������ ��������
119
 
  Int32 italic;              //����� ���������
120
 
  Int32 it_ser;              //��������� ��������
121
 
  Int32 it_gelv;             //��������� ����������
122
 
  Int32 st_ser;              //�� �� ��� ������
123
 
  Int32 st_gelv;
 
118
  int32_t straight;            //всего прямых символов
 
119
  int32_t italic;              //всего курсивных
 
120
  int32_t it_ser;              //курсивных серифных
 
121
  int32_t it_gelv;             //курсивных несерифных
 
122
  int32_t st_ser;              //то же для прямых
 
123
  int32_t st_gelv;
124
124
} FontStat;
125
125
 
126
 
typedef struct tagFragStat   //��� ��������� ������
 
126
typedef struct tagFragStat   //для выявления мусора
127
127
{
128
128
  Handle hBlock;
129
 
  Rect32 rect;     //������������ �������������
130
 
  Int16 nsym;      //����� �������� �� ���������
131
 
  Int16 nbig;      //������� (�����, �����, "?" � �.�.)
132
 
  Int16 nstick;    //��������
133
 
  Int16 nlet;      //����� ������������
134
 
  Int16 ndig;      // -"- ����
135
 
  Int16 nconf;     //�� ������� ��� ��������������
136
 
  Int16 ngood;     //������� ������������
137
 
  Int16 nhigh;     //������� ������
138
 
  Int16 npunct;    //������ ���������
139
 
  Word8 min_keg;
140
 
  Word8 max_keg;
141
 
  Word8 flag;
 
129
  Rect32 rect;     //охватывающий прямоугольник
 
130
  int16_t nsym;      //всего символов во фрагменте
 
131
  int16_t nbig;      //больших (буквы, цифры, "?" и т.д.)
 
132
  int16_t nstick;    //палочных
 
133
  int16_t nlet;      //всего распознанных
 
134
  int16_t ndig;      // -"- цифр
 
135
  int16_t nconf;     //по эвентам или подтвержденных
 
136
  int16_t ngood;     //надежно распознанных
 
137
  int16_t nhigh;     //высокая оценка
 
138
  int16_t npunct;    //знаков препинани
 
139
  uchar min_keg;
 
140
  uchar max_keg;
 
141
  uchar flag;
142
142
#define RS_GOOD 1
143
143
#define RS_BAD  2
144
144
#define RS_STRANGE 4
145
145
#define RS_ADD  128
146
146
} RecStat;
147
147
 
148
 
typedef struct tagLineNumber  //������ �� ���������
 
148
typedef struct tagLineNumber  //строка во фрагменте
149
149
{
150
 
  Int32  n;                   //����� ������ �� ��������
151
 
  struct tagLineNumber *next; //��������� ������ ���������
 
150
  int32_t  n;                   //номер строки на странице
 
151
  struct tagLineNumber *next; //следующая строка фрагмента
152
152
} LineNumber;
153
153
 
154
 
typedef struct tagLineList       //������ �����
 
154
typedef struct tagLineList       //список строк
155
155
{
156
 
  LineNumber pool[LINE_PAGE];    //����
157
 
  LineNumber *node[FRAG_PAGE+1]; //������ ������ ��� ������� ���������
 
156
  LineNumber pool[LINE_PAGE];    //куча
 
157
  LineNumber *node[FRAG_PAGE+1]; //начало списка для каждого фрагмента
158
158
} LineList;
159
159
 
160
160
 
161
161
extern Bool32      gbFax100;
162
162
extern Bool32 snap_enable;
163
163
extern Bool32 exit_enable;
164
 
extern Word8 language;
 
164
extern uchar language;
165
165
 
166
166
Bool32 gbGarbage = TRUE;
167
167
Handle hSnapMain = 0;
171
171
Handle hSnapTable = 0;
172
172
 
173
173
static Handle hCPAGE;
174
 
static Int32 nIncline;
 
174
static int32_t nIncline;
175
175
static KegTab  keg_tab;
176
 
static Int32 num_keg,num_keg_opt;     //���������� ������ �� �������� �������� � �����������
177
 
static KegStat  keg_stats;            //���������� ������ �� �������� ��������
178
 
static Word8 max_keg=0,min_keg=255;   //����������� � ������������ ����� �� ��������
179
 
static Int32 version;                 //������ ������
180
 
static Word32 key=1;                  //��� snap'�
181
 
static Int32 skew=0;                  //������� �������� (��� ������?)
182
 
static Int32 num_frag=0;              //����� ���������� �� ��������
183
 
static Bool fr_ovf;                   //�� �������� ������ FRAG_PAGE ����������
184
 
static Int16 fragments[LINE_PAGE+FRAG_PAGE],*fragments_end=NULL,*cur_fragment;
185
 
/*     ��������� ���������� �� ��������:
186
 
  n1    -  ����� ����� � 1-�� ���������
187
 
  i[1]  -  ����� ������ ������
 
176
static int32_t num_keg,num_keg_opt;     //количество кеглей на странице исходное и оптимальное
 
177
static KegStat  keg_stats;            //статистика кеглей на исходной странице
 
178
static uchar max_keg=0,min_keg=255;   //минимальный и максимальный кегли на страницы
 
179
static int32_t version;                 //версия строки
 
180
static uint32_t key=1;                  //для snap'а
 
181
static int32_t skew=0;                  //поворот страницы (или строки?)
 
182
static int32_t num_frag=0;              //число фрагментов на странице
 
183
static Bool fr_ovf;                   //на странице больше FRAG_PAGE фрагментов
 
184
static int16_t fragments[LINE_PAGE+FRAG_PAGE],*fragments_end=NULL,*cur_fragment;
 
185
/*     структура фрагментов на странице:
 
186
  n1    -  число строк в 1-ом фрагменте
 
187
  i[1]  -  номер первой строки
188
188
           . . .
189
 
  i[n1] -  ����� ��������� ������
190
 
  n2    -  ����� ����� � 2-�� ���������
 
189
  i[n1] -  номер последней строки
 
190
  n2    -  число строк в 2-ом фрагменте
191
191
           . . .
192
192
*/
193
 
static Word8 fragfont[FRAG_PAGE],*cur_font;
 
193
static uchar fragfont[FRAG_PAGE],*cur_font;
194
194
static RecStat recstat[FRAG_PAGE];
195
195
 
196
196
static PageWord cur_word;
209
209
static Bool rtf_correct();
210
210
 
211
211
static void  garbage_fragments();
212
 
static void draw_fragments(Word32 color);
213
 
static void draw_fragment(Handle hBlock, Word32 color, Word32 key);
214
 
static void display_fragment(RecStat *rsti, Word32 color, Word32 key);
215
 
static Bool in_gap(Int32 top, Int32 bottom, Word8 *proj);
 
212
static void draw_fragments(uint32_t color);
 
213
static void draw_fragment(Handle hBlock, uint32_t color, uint32_t key);
 
214
static void display_fragment(RecStat *rsti, uint32_t color, uint32_t key);
 
215
static Bool in_gap(int32_t top, int32_t bottom, uchar *proj);
216
216
static Bool condition1(RecStat *rsti);
217
217
static Bool condition2(RecStat *rsti);
218
218
static Bool condition3(RecStat *rsti);
219
219
static Bool condition4(RecStat *rsti);
220
 
static Bool condition34(RecStat *rsti, Int32 ngood);
 
220
static Bool condition34(RecStat *rsti, int32_t ngood);
221
221
 
222
 
static void mark_word(Word32 color);
 
222
static void mark_word(uint32_t color);
223
223
static Bool set_cur_word(PageWord *pw);
224
224
static Bool next_word_inline(CSTR_rast *beg, CSTR_rast *end);
225
225
static Bool prev_word_inline(CSTR_rast *beg, CSTR_rast *end);
227
227
static Bool next_word();
228
228
static Bool prev_word();
229
229
static Bool cur_word_eq(PageWord *cmp);
230
 
static void set_word_keg(Word8 keg);
231
 
static Word8 get_word_keg();
 
230
static void set_word_keg(uchar keg);
 
231
static uchar get_word_keg();
232
232
static Bool contain(Rect32 *b, Rect32 *s);
233
233
static void to_real(Rect32 *rect);
234
234
static void to_real16(Rect16 *rect);
235
235
 
236
 
static Handle find_hBlock(Int32 fragment);
 
236
static Handle find_hBlock(int32_t fragment);
237
237
static void pull_rect(Rect32 *rect, Point32 *point);
238
238
static void cover_rect(Rect32 *main_area, Rect32 *rect);
239
 
static Int32 rect_dist(Rect32 *main, Rect32 *test);
240
 
static Int32 dist_border(Rect32 *rect);
241
 
static Bool add2list(LineNumber **frag_lines, Int32 fn, Int32 ln);
 
239
static int32_t rect_dist(Rect32 *main, Rect32 *test);
 
240
static int32_t dist_border(Rect32 *rect);
 
241
static Bool add2list(LineNumber **frag_lines, int32_t fn, int32_t ln);
242
242
 
243
243
static void draw_keg(const char *str);
244
 
static void draw_rect(Rect32 *rect, Word32 color, Word32 key);
 
244
static void draw_rect(Rect32 *rect, uint32_t color, uint32_t key);
245
245
 
246
246
static void kegl_by_frag();
247
247
static void keg_frag_stats();
248
248
 
249
 
//Word32 myMonitorProc(Handle wnd,Handle hwnd,Word32 message,Word32 wParam,Word32 lParam);
 
249
//uint32_t myMonitorProc(Handle wnd,Handle hwnd,uint32_t message,uint32_t wParam,uint32_t lParam);
250
250
 
251
 
Bool32 CorrectKegl(Int32 ver)
 
251
Bool32 CorrectKegl(int32_t ver)
252
252
{
253
 
  Word32 key=1;
 
253
  uint32_t key=1;
254
254
 
255
255
  hCPAGE = CPAGE_GetHandlePage( CPAGE_GetCurrentPage());
256
256
 
263
263
 
264
264
  rtf_correct();
265
265
 
266
 
//������������ �� ���������� (kegf)
 
266
//выравнивание по фрагментам (kegf)
267
267
  kegl_by_frag();
268
268
  draw_keg("by fragments");
269
269
  rtf_correct();
275
275
    if (!fr_ovf)
276
276
      garbage_fragments();
277
277
    else
278
 
      if (snap_enable)  LDPUMA_Console("����� �� �����: ����� ���������\n");
 
278
      if (snap_enable)  LDPUMA_Console("Мусор не чищен: много фраментов\n");
279
279
  }
280
280
 
281
281
  LDPUMA_DeleteRects(NULL, key);
285
285
 
286
286
static Bool32 get_stats()
287
287
{
288
 
  Int32           n,  i,  j;
 
288
  int32_t           n,  i,  j;
289
289
  CSTR_line       line;
290
290
  CSTR_rast       rst;
291
291
  CSTR_rast_attr  attr;
292
292
  UniVersions     uni;
293
 
  Int32   frag_num[FRAG_PAGE+1];
294
 
  Int32  frag_size[FRAG_PAGE+1]={0};
 
293
  int32_t   frag_num[FRAG_PAGE+1];
 
294
  int32_t  frag_size[FRAG_PAGE+1]={0};
295
295
  LineList  frag_lines_pool;
296
296
#define  frag_lines  frag_lines_pool.node
297
 
  Int32 total_size=0;
298
 
  Int16 *fragj=fragments;
 
297
  int32_t total_size=0;
 
298
  int16_t *fragj=fragments;
299
299
  FontStat font_stat[FRAG_PAGE]={0},*fsti;
300
 
  Word8 *ffi=fragfont;
301
 
  Int32 ser_fr=0,gelv_fr=0;
 
300
  uchar *ffi=fragfont;
 
301
  int32_t ser_fr=0,gelv_fr=0;
302
302
  RecStat *rsti;
303
303
 
304
304
  memset(&frag_lines_pool.node[1],0,FRAG_PAGE*sizeof(LineNumber *));
324
324
    if( line )
325
325
    {
326
326
      CSTR_attr  l_attr;
327
 
      Int32 nf;
 
327
      int32_t nf;
328
328
 
329
329
      CSTR_GetLineAttr(line,&l_attr);
330
330
      if (l_attr.Flags & CSTR_STR_CapDrop)  continue;
353
353
      for(;rst;rst=CSTR_GetNext(rst))
354
354
      {
355
355
        UniAlt *alt;
356
 
        Word8 let,keg;
 
356
        uchar let,keg;
357
357
 
358
358
        CSTR_GetAttr(rst,&attr);
359
359
        CSTR_GetCollectionUni(rst,&uni);
360
360
        alt=&uni.Alt[0];   let=alt->Code[0];
361
361
 
362
 
      //��� ����
 
362
      //для кегл
363
363
        attr.keg=MIN(attr.keg,MAX_KEG-1);
364
364
        if(!(attr.flg & CSTR_f_space) && attr.keg && uni.lnAltCnt)
365
365
        {
370
370
        }
371
371
        CSTR_SetAttr(rst,&attr);
372
372
 
373
 
      //��� ����������
 
373
      //для серифности
374
374
        if (attr.flg & (CSTR_f_let | CSTR_f_bad) &&
375
375
            (attr.font & (CSTR_fp_ser | CSTR_fp_gelv)) != (CSTR_fp_ser | CSTR_fp_gelv))
376
376
          if (attr.font & CSTR_fp_str)
389
389
            if (attr.font & CSTR_fp_gelv)  fsti->it_gelv++;
390
390
          }
391
391
 
392
 
      //��� ������
 
392
      //для мусора
393
393
        if (attr.flg & (CSTR_f_let | CSTR_f_bad | CSTR_f_punct))  rsti->nsym++;
394
394
        if (attr.flg & (CSTR_f_let | CSTR_f_bad))
395
395
        {
423
423
  memset(fragfont,0,num_frag);
424
424
  for (i=1,fsti=font_stat; i<=num_frag; i++,ffi++,fsti++)
425
425
  {
426
 
    Int32 size=frag_size[i];
 
426
    int32_t size=frag_size[i];
427
427
    total_size += size+1;
428
428
    if (total_size>LINE_PAGE+FRAG_PAGE)
429
429
    {
433
433
    if (size>=0)
434
434
    {
435
435
      LineNumber *cur_num=frag_lines[i];
436
 
      *fragj=(Int16)size;
 
436
      *fragj=(int16_t)size;
437
437
      fragj += size;
438
438
      while (cur_num)
439
439
      {
440
 
        *fragj-- = (Int16)cur_num->n;
 
440
        *fragj-- = (int16_t)cur_num->n;
441
441
        cur_num=cur_num->next;
442
442
      }
443
443
      fragj += size+1;
444
444
    }
445
445
 
446
 
    //���������� ����������, ��� ���� �����������
 
446
    //определяем серифность, где есть уверенность
447
447
    if (fsti->straight>3 && fsti->straight > fsti->italic/3)
448
448
      if (fsti->st_ser > 2*fsti->st_gelv)
449
449
      {
459
459
  }
460
460
  fragments_end=fragj;
461
461
 
462
 
  //���������� ��� ���������� ����������
 
462
  //серифность для оставшихся фрагментов
463
463
  for (i=0,ffi=fragfont,fsti=font_stat; i<num_frag; i++,ffi++,fsti++)
464
464
    if (*ffi==0)
465
465
    {
466
 
      if ( (ser_fr==0)^(gelv_fr==0) )   //�� �������� ���� �����
 
466
      if ( (ser_fr==0)^(gelv_fr==0) )   //на странице один шрифт
467
467
        *ffi = (ser_fr==0) ? CSTR_fp_gelv : CSTR_fp_ser;
468
 
      else                              //��� ������� ������
 
468
      else                              //нет единого шрифта
469
469
        *ffi = (fsti->it_ser+fsti->st_ser > fsti->it_gelv+fsti->st_gelv) ? CSTR_fp_ser : CSTR_fp_gelv;
470
470
    }
471
471
 
477
477
 
478
478
static void get_keg_tab()
479
479
{
480
 
  Word16 *prev_max=NULL,*cur_min=NULL,*keg_statsi=NULL;
481
 
  Int32 prev_max_n=0,min_n=INT_MAX,prev_n=0;
482
 
//  Int32 prev_size=0,i_prev=0;
483
 
  Int32 i,j;
484
 
  Word8 rely1,rely2,extend2;
 
480
  uint16_t *prev_max=NULL,*cur_min=NULL,*keg_statsi=NULL;
 
481
  int32_t prev_max_n=0,min_n=INT_MAX,prev_n=0;
 
482
//  int32_t prev_size=0,i_prev=0;
 
483
  int32_t i,j;
 
484
  uchar rely1,rely2,extend2;
485
485
  KegTabElement *keg_tabi;
486
486
  Bool rise=TRUE;
487
 
  Word8 temp_tab[3*KEG_PAGE]; //������� �� num_keg_opt ������
488
 
  //��������� temp_tab:
489
 
  //  0 - ������ ����
490
 
  //  1 - ������� ������� ����������������
491
 
  //  2 - ������� ������� ����������������
492
 
  //  3 - ������ ����
 
487
  uchar temp_tab[3*KEG_PAGE]; //таблица из num_keg_opt кеглей
 
488
  //структура temp_tab:
 
489
  //  0 - размер кегл
 
490
  //  1 - граница области неопределенности
 
491
  //  2 - граница области неопределенности
 
492
  //  3 - размер кегл
493
493
  //      . . .
494
 
  //  n - ������ ����
 
494
  //  n - размер кегл
495
495
 
496
 
  Word8 *tab=temp_tab;
 
496
  uchar *tab=temp_tab;
497
497
 
498
498
  num_keg_opt=0;
499
499
  if (num_keg==0)
500
500
    return;
501
501
 
502
502
  for (i=0,keg_statsi=keg_stats; i<=num_keg+1 && num_keg_opt<KEG_PAGE; i++,keg_statsi++)
503
 
  {                       //���� �������� ���� �� �����
504
 
    Int32 n=*keg_statsi;
 
503
  {                       //цикл включает нули по краям
 
504
    int32_t n=*keg_statsi;
505
505
 
506
506
    if (n>prev_n)
507
507
      rise=TRUE;
509
509
    if (n<prev_n)
510
510
    {
511
511
      if (rise)
512
 
      {                  //������ ��������� ��������
513
 
        Int32 tol=MIN(prev_max_n,prev_n)/3;
514
 
        Word16 *cur_max=keg_statsi-1;
515
 
        if (num_keg_opt>0)       //�� ������ �����
 
512
      {                  //найден локальный максимум
 
513
        int32_t tol=MIN(prev_max_n,prev_n)/3;
 
514
        uint16_t *cur_max=keg_statsi-1;
 
515
        if (num_keg_opt>0)       //не первый кегль
516
516
        {
517
517
          Bool rely_bound=FALSE;
518
 
          Int32 dk=cur_max-prev_max;
519
 
          if (min_n<tol && (!gbFax100 || dk>4) && 10*dk >= cur_max-keg_stats)         //�������� �������
 
518
          int32_t dk=cur_max-prev_max;
 
519
          if (min_n<tol && (!gbFax100 || dk>4) && 10*dk >= cur_max-keg_stats)         //надежная граница
520
520
          {
521
 
            Word16 *j;
 
521
            uint16_t *j;
522
522
            for (j=prev_max; j<cur_min && *j>=tol; j++);
523
523
            *tab++=j-keg_stats;
524
524
            for (j=cur_max; j>cur_min && *j>=tol; j--);
535
535
          }
536
536
          if (!rely_bound)
537
537
          {
538
 
            if (cur_max-prev_max>3 && 8*(cur_max-prev_max)>cur_max-keg_stats)  //������� ������� - ���� ���������
 
538
            if (cur_max-prev_max>3 && 8*(cur_max-prev_max)>cur_max-keg_stats)  //большой разброс - надо разделить
539
539
            {
540
540
              *tab++=cur_min-keg_stats;
541
541
              *tab++=cur_min-keg_stats;
544
544
              num_keg_opt++;
545
545
            }
546
546
            else
547
 
            if (prev_n>prev_max_n)   //��� �� �����, �������� ������
 
547
            if (prev_n>prev_max_n)   //тот же кегль, заменяем размер
548
548
            {
549
549
              *(tab-1)=cur_max-keg_stats;
550
550
              prev_max=cur_max;  prev_max_n=prev_n;
568
568
  rely1=0;
569
569
  for (i=1; i<=num_keg_opt; i++,tab += 3)
570
570
  {
571
 
    Int32 tol=(Int8)(keg_stats[*tab])/3;
572
 
    Int32 keg=0,n=0,k;
 
571
    int32_t tol=(char)(keg_stats[*tab])/3;
 
572
    int32_t keg=0,n=0,k;
573
573
    rely2=*(tab+1)-1;  extend2=*(tab+2);  keg_tabi=keg_tab+j;
574
574
    for (k=rely1,keg_statsi=keg_stats+k; k<=rely2; k++,keg_statsi++)
575
575
      if (*keg_statsi>=tol)  { n += *keg_statsi;  keg += *keg_statsi*k; }
576
 
//    if (n>0)  keg=keg*2/n;  //������ ������ �� ����� ��������� �� ���� ���������
 
576
//    if (n>0)  keg=keg*2/n;  //размер шрифта от верха заглавной до низа опущенной
577
577
    if (n>0)  keg=(keg+n/2)/n;
578
 
    for ( ; j<rely1;    j++,keg_tabi++)  keg_tabi->keg1=-(Int8)keg;
579
 
    for ( ; j<=rely2;   j++,keg_tabi++)  keg_tabi->keg0= (Int8)keg;
580
 
    for ( ; j<=extend2; j++,keg_tabi++)  keg_tabi->keg0=-(Int8)keg;
 
578
    for ( ; j<rely1;    j++,keg_tabi++)  keg_tabi->keg1=-(char)keg;
 
579
    for ( ; j<=rely2;   j++,keg_tabi++)  keg_tabi->keg0= (char)keg;
 
580
    for ( ; j<=extend2; j++,keg_tabi++)  keg_tabi->keg0=-(char)keg;
581
581
    rely1=extend2+1;  j=rely2+1;
582
582
  }
583
583
}
584
584
 
585
585
static Bool make_correct()
586
 
//����������� ����� ��� ��������� ����� (�������) � ����� ����� � ������,
587
 
// ���� � ��������� ���� �������
 
586
//проставляет кегль для надежного слова (опорный) и далее влево и вправо,
 
587
// пока в вариантах есть опорный
588
588
{
589
589
  LDPUMA_DeleteRects(NULL, key);
590
590
 
603
603
}
604
604
 
605
605
static void  cor_fax_fragment()
606
 
{  //��� ������ �� ����� ��������� ��������������� ������ �����
 
606
{  //для факсов по всему фрагменту устанавливается единый кегль
607
607
  PageWord beg;
608
 
  Word8 stat[2*MAX_KEG+2]={0},max_keg=0,opt_keg=0;
609
 
  Word8 keg0;
610
 
  Int8  keg;
611
 
  Int32 i,max_n=0;
 
608
  uchar stat[2*MAX_KEG+2]={0},max_keg=0,opt_keg=0;
 
609
  uchar keg0;
 
610
  char  keg;
 
611
  int32_t i,max_n=0;
612
612
 
613
613
  beg.word=1;
614
614
  for (beg.line=1; beg.line<=*cur_fragment; beg.line++)
650
650
  for (i=1; i<=max_keg; i++)
651
651
    if (max_n<stat[i])
652
652
    {
653
 
      max_n=stat[i];  opt_keg=(Word8)i;
 
653
      max_n=stat[i];  opt_keg=(uchar)i;
654
654
    }
655
655
 
656
656
  set_cur_word(&beg);
663
663
      CSTR_line line = CSTR_GetLineHandle (cur_fragment[cur_word.line], version);
664
664
      if (line)
665
665
      {
666
 
        Word8 msg[20];
 
666
        uchar msg[20];
667
667
        CSTR_attr  l_attr;
668
668
        CSTR_GetLineAttr(line,&l_attr);
669
669
        sprintf((char*)msg,"fragment=%d",l_attr.fragment);
679
679
static void  cor_gen_fragment()
680
680
{
681
681
  PageWord fin,rely;
682
 
  Word8 keg0;        //�����, ������� ����� �������� �����
683
 
  Int8  keg;         //������� �����
 
682
  uchar keg0;        //кегль, который будет присвоен слову
 
683
  char  keg;         //текущий кегль
684
684
  Bool next=TRUE;
685
685
 
686
686
  fin.word=1;
688
688
  for (fin.line=1; fin.line<=*cur_fragment; fin.line++)
689
689
    if (set_cur_word(&fin))  break;
690
690
 
691
 
  if (fin.line > *cur_fragment)  //������ ��������
 
691
  if (fin.line > *cur_fragment)  //пустой фрагмент
692
692
    return;
693
693
 
694
694
  keg0=get_word_keg();
699
699
    Bool back=keg<0;
700
700
    fin=get_cur_word();
701
701
 
702
 
    while (keg<0 && next_word())    //�� ���������� ���������
 
702
    while (keg<0 && next_word())    //до следующего надежного
703
703
      keg=keg_tab[get_word_keg()].keg0;
704
704
 
705
 
    if (keg<0)    //�������� ��� - ���������, ��� ����
 
705
    if (keg<0)    //надежных нет - оставляем, как есть
706
706
      break;
707
707
/*
708
 
    if (keg<0)    //���������, ��� ����, ������ ���������������
 
708
    if (keg<0)    //оставляем, как есть, только масштабирование
709
709
    {
710
710
      set_cur_word(&fin);
711
711
      do
725
725
 
726
726
    if (back)
727
727
    {
728
 
      do                      //�� ��������� �����
 
728
      do                      //от надежного влево
729
729
      {
730
 
        Word8  kegw;
 
730
        uchar  kegw;
731
731
        prev_word();
732
732
        kegw=get_word_keg();
733
733
        if (keg0==abs(keg_tab[kegw].keg0) || keg0==abs(keg_tab[kegw].keg1))
742
742
      set_cur_word(&rely);
743
743
    }
744
744
 
745
 
    while (next=next_word())         //�� ��������� ������
 
745
    while (next=next_word())         //от надежного вправо
746
746
    {
747
 
      Word8 kegw=get_word_keg();
 
747
      uchar kegw=get_word_keg();
748
748
      keg=keg_tab[kegw].keg0;
749
749
      if (keg>0)  break;
750
750
 
762
762
      CSTR_line line = CSTR_GetLineHandle (cur_fragment[rely.line], version);
763
763
      if (line)
764
764
      {
765
 
        Word8 msg[20];
 
765
        uchar msg[20];
766
766
        CSTR_attr  l_attr;
767
767
        CSTR_GetLineAttr(line,&l_attr);
768
768
        sprintf((char*)msg,"fragment=%d",l_attr.fragment);
774
774
  }
775
775
}
776
776
 
777
 
static void mark_word(Word32 color)
 
777
static void mark_word(uint32_t color)
778
778
{
779
779
  CSTR_rast_attr  attr;
780
780
  if( snap_enable && !LDPUMA_SkipEx(hSnapMain,FALSE,TRUE,1))
800
800
  CSTR_line       line;
801
801
  CSTR_attr  l_attr;
802
802
  CSTR_rast    beg,end;
803
 
  Int32 i;
 
803
  int32_t i;
804
804
 
805
805
  cur_word.line=pw->line;  cur_word.word=pw->word;
806
806
  cur_word.beg=cur_word.end=NULL;
960
960
  return cur_word.line==cmp->line && cur_word.word==cmp->word;
961
961
}
962
962
 
963
 
static void set_word_keg(Word8 keg)
 
963
static void set_word_keg(uchar keg)
964
964
{
965
965
  CSTR_rast cur=cur_word.beg;
966
966
  CSTR_rast_attr  attr;
967
 
  Word8 font;
 
967
  uchar font;
968
968
 
969
969
  if (!cur)
970
970
    return;
979
979
    CSTR_SetAttr(cur,&attr);
980
980
  }
981
981
 
982
 
//��� �� ����� - �������� ������
 
982
//тот же кегль - пробелам справа
983
983
  CSTR_GetAttr(cur,&attr);
984
984
  while (space(attr))
985
985
  {
992
992
 
993
993
}
994
994
 
995
 
static Word8 get_word_keg()
 
995
static uchar get_word_keg()
996
996
{
997
997
  CSTR_rast cur=cur_word.beg;
998
998
  CSTR_rast_attr  attr;
1005
1005
}
1006
1006
 
1007
1007
static Bool rtf_correct()
1008
 
//���������������
 
1008
//масштабирование
1009
1009
{
1010
1010
  CSTR_line       line;
1011
 
  Int32           n,i,dpi,dpi2;
 
1011
  int32_t           n,i,dpi,dpi2;
1012
1012
  CSTR_rast       rst;
1013
1013
  CSTR_rast_attr  attr;
1014
1014
  PAGEINFO     PageInfo;
1015
1015
 
1016
1016
//  Handle hCPAGE = CPAGE_GetHandlePage( CPAGE_GetCurrentPage());
1017
1017
  GetPageInfo(hCPAGE,&PageInfo);
1018
 
  dpi  = (WORD)PageInfo.DPIY;    //���������� ������� �� ���������
 
1018
  dpi  = (uint16_t)PageInfo.DPIY;    //разрешение сканера по вертикали
1019
1019
  dpi2=2*dpi;
1020
1020
 
1021
1021
  n=CSTR_GetMaxNumber ();
1030
1030
      rst = CSTR_GetFirstRaster(line);
1031
1031
      for(;rst;rst=CSTR_GetNext(rst))
1032
1032
      {
1033
 
        Word8 keg;
 
1033
        uchar keg;
1034
1034
        CSTR_GetAttr(rst,&attr);
1035
 
        keg = (Word8)((attr.keg*2*72+dpi/2)/dpi);  //������ ������ �� ����� ��������� �� ���� ��������� � ������� (1/72 �����)
1036
 
//        keg = (Word8)((attr.keg*72+dpi/2)/dpi);
 
1035
        keg = (uchar)((attr.keg*2*72+dpi/2)/dpi);  //размер шрифта от верха заглавной до низа опущенной в пунктах (1/72 дюйма)
 
1036
//        keg = (uchar)((attr.keg*72+dpi/2)/dpi);
1037
1037
/*
1038
1038
        if (keg>=12)
1039
1039
        {
1040
 
          keg= (attr.keg*2*72+dpi)/dpi2*2;  //���������� �� ���������� �������
1041
 
//          keg= (attr.keg*72+dpi)/dpi2*2;  //���������� �� ���������� �������
 
1040
          keg= (attr.keg*2*72+dpi)/dpi2*2;  //округление до ближайшего четного
 
1041
//          keg= (attr.keg*72+dpi)/dpi2*2;  //округление до ближайшего четного
1042
1042
        }
1043
1043
*/
1044
1044
        attr.keg=attr.kegf;
1048
1048
    }
1049
1049
    if (snap_enable && !LDPUMA_SkipEx(hSnapMain,FALSE,TRUE,1))
1050
1050
    {
1051
 
      Word8 msg[80];
 
1051
      uchar msg[80];
1052
1052
      sprintf((char*)msg,"Line %d corrected\n",i);
1053
1053
      LDPUMA_Console((const char*)msg);
1054
1054
      LDPUMA_RasterText((char*)msg);
1060
1060
 
1061
1061
static Bool32 SomnitelnaLinia(int Nb)
1062
1062
{
1063
 
                        // Nbi <= 0 - ���������� �����
1064
 
                        // Nbi == 127, 128 - ������������ ����� (�������� ������ �� �����������)
 
1063
                        // Nbi <= 0 - ненадежная линия
 
1064
                        // Nbi == 127, 128 - сомнительная линия (получена только по гистограмме)
1065
1065
                        // Nbi 127 - eng, 128 - rus
1066
1066
 
1067
1067
        if( Nb <= 0 )
1088
1088
#define  HOLE32 {0x7FFFFFF, 0x7FFFFFF,0,0}
1089
1089
  Rect32 main_area=HOLE32,hole=HOLE32,*page_num=NULL;
1090
1090
  Bool main_found=FALSE;
1091
 
  Int32 mainsize;
 
1091
  int32_t mainsize;
1092
1092
  Bool add=FALSE,ingap;
1093
1093
  Handle  hBlock;
1094
 
  Word32 k_cur=key+1;
1095
 
  Word8 vproj[V_SIZE]={0};
 
1094
  uint32_t k_cur=key+1;
 
1095
  uchar vproj[V_SIZE]={0};
1096
1096
 
1097
1097
  min_keg=255,max_keg=0;
1098
1098
 
1103
1103
    LDPUMA_DeleteLines(NULL, key);
1104
1104
  }
1105
1105
 
1106
 
//���������� ������� ���������� � ������������ �������������
 
1106
//маркировка хороших фрагментов и охватывающий прямоугольник
1107
1107
  for (cur_fragment=fragments,rsti=recstat;
1108
1108
       cur_fragment<fragments_end;
1109
1109
       cur_fragment += (*cur_fragment)+1,rsti++)
1110
1110
  {
1111
 
    Int32 j,hmax;
 
1111
    int32_t j,hmax;
1112
1112
    Rect32 *rect=&rsti->rect;
1113
 
    Word32 bl_flg;
 
1113
    uint32_t bl_flg;
1114
1114
 
1115
1115
    if (!rsti->hBlock)  continue;
1116
1116
 
1117
1117
    bl_flg=CPAGE_GetBlockFlags(hCPAGE,rsti->hBlock);
1118
 
    if (bl_flg & USER_FRAG)           //������� �������
 
1118
    if (bl_flg & USER_FRAG)           //выделен вручную
1119
1119
      rsti->flag = RS_GOOD;
1120
1120
    else
1121
1121
    if (rsti->ngood>=G_GOOD0 ||
1129
1129
    else
1130
1130
      CPAGE_SetBlockFlags(hCPAGE,rsti->hBlock,bl_flg | UNCERTAIN_FRAG);
1131
1131
 
1132
 
  //min � max ����� � ������������ ������������� ��������
 
1132
  //min и max кегли и охватывающий прямоугольник сегмента
1133
1133
    *rect=hole;
1134
1134
    rsti->min_keg=255;   rsti->max_keg=0;
1135
1135
    for (cur_line=1; cur_line<=*cur_fragment; cur_line++)
1148
1148
        for(;rst;rst=CSTR_GetNext(rst))
1149
1149
        {
1150
1150
          UniVersions uni;
1151
 
          Word8 let;
 
1151
          uchar let;
1152
1152
          CSTR_rast_attr  attr;
1153
1153
 
1154
1154
          CSTR_GetAttr(rst,&attr);
1178
1178
      if (rect->top<0 || rect->top >= rect->bottom || rect->left<0 || rect->left >= rect->right)
1179
1179
        rsti->flag = RS_STRANGE;
1180
1180
 
1181
 
    //������������ ������������� � �������
 
1181
    //охватывающий прямоугольник и проекци
1182
1182
    if (rsti->flag & RS_GOOD)
1183
1183
    {
1184
 
      //����� ��������?
 
1184
      //номер страницы?
1185
1185
      if (rsti->ndig>0 && rsti->ndig<=4 && rsti->ndig==rsti->nbig)
1186
1186
        if ( (rect->bottom<main_area.top || rect->top>main_area.bottom) &&
1187
1187
             rect->left>=main_area.left && rect->right<=main_area.right)
1198
1198
 
1199
1199
    if (snap_enable && !LDPUMA_SkipEx(hSnapGarbage,FALSE,TRUE,1) )
1200
1200
    {
1201
 
      Word32 color=wRGB(255,0,255);
 
1201
      uint32_t color=wRGB(255,0,255);
1202
1202
      if (rsti->flag & RS_GOOD)  color=wRGB(0,255,0);
1203
1203
      else
1204
1204
      if (rsti->flag & RS_BAD)   color=wRGB(255,255,0);
1206
1206
      if (rsti->flag & RS_STRANGE)
1207
1207
      {
1208
1208
        color=wRGB(255,196,0);
1209
 
                                Snap_Console("������ � ��������� ������\n");
 
1209
                                Snap_Console("Ошибки в атрибутах растра\n");
1210
1210
      }
1211
1211
      display_fragment(rsti,color,key);
1212
1212
    }
1219
1219
/*  if( snap_enable && !LDPUMA_SkipEx(hSnapGarbage,FALSE,TRUE,1) )
1220
1220
    if (line)  LDPUMA_CSTR_Monitor(hSnapGarbage,line,0,myMonitorProc);*/
1221
1221
 
1222
 
//���������� ����������
 
1222
//добавление фрагментов
1223
1223
  while(1)
1224
1224
  {
1225
 
    Int32 maxsize=0;
1226
 
    Int16 *maxfrag;
 
1225
    int32_t maxsize=0;
 
1226
    int16_t *maxfrag;
1227
1227
    RecStat *maxrst;
1228
 
    Int32 d;
 
1228
    int32_t d;
1229
1229
    Rect32 *rect;
1230
1230
 
1231
1231
    add=FALSE;
1232
1232
 
1233
 
  //�������� ������������ ��������
 
1233
  //выбираем максимальный фрагмент
1234
1234
    for (cur_fragment=fragments,rsti=recstat;
1235
1235
         cur_fragment<fragments_end;
1236
1236
         cur_fragment += (*cur_fragment)+1,rsti++)
1237
1237
      if (rsti->flag==0)
1238
1238
      {
1239
1239
        Rect32 *rect=&rsti->rect;
1240
 
        Int32 size=rect->right-rect->left+rect->bottom-rect->top;
 
1240
        int32_t size=rect->right-rect->left+rect->bottom-rect->top;
1241
1241
        if (size>maxsize)
1242
1242
        {
1243
1243
          maxsize=size; maxfrag=cur_fragment;   maxrst=rsti;
1248
1248
 
1249
1249
    cur_fragment=maxfrag;  rsti=maxrst;
1250
1250
 
1251
 
    if (main_found)    //���� ������ �� �������� ����������
 
1251
    if (main_found)    //есть костяк из надежный фрагментов
1252
1252
    {
1253
1253
      rsti->flag=RS_BAD;
1254
1254
      if( snap_enable && !LDPUMA_SkipEx(hSnapGarbage,FALSE,TRUE,1) )
1261
1261
      mainsize=MIN(main_area.right-main_area.left,main_area.bottom-main_area.top);
1262
1262
      ingap=in_gap(rect->top,rect->bottom,vproj);
1263
1263
 
1264
 
      if (main_area.top-rect->bottom>d || rect->top-main_area.bottom>d)   //������ ������ ��� �����
 
1264
      if (main_area.top-rect->bottom>d || rect->top-main_area.bottom>d)   //далеко вверху или внизу
1265
1265
      {
1266
 
        Int32 d0=dist_border(rect);
 
1266
        int32_t d0=dist_border(rect);
1267
1267
        d=rect_dist(&main_area,rect);
1268
 
        if (d>d0)   //����� ������
 
1268
        if (d>d0)   //очень далеко
1269
1269
        {
1270
1270
          if (condition4(rsti))  rsti->flag=RS_ADD;
1271
1271
        }
1273
1273
          if (condition2(rsti))  rsti->flag=RS_ADD;
1274
1274
      }
1275
1275
      else
1276
 
      if (main_area.left-rect->right>d || rect->left-main_area.right>d) //������ ����� ��� ������
 
1276
      if (main_area.left-rect->right>d || rect->left-main_area.right>d) //далеко слева или справа
1277
1277
      {
1278
 
        Int32 d0=dist_border(rect);
 
1278
        int32_t d0=dist_border(rect);
1279
1279
        d=rect_dist(&main_area,rect);
1280
 
        if (d>d0) //����� ������
 
1280
        if (d>d0) //очень далеко
1281
1281
        {
1282
1282
          if (condition4(rsti))  rsti->flag=RS_ADD;
1283
1283
        }
1287
1287
          else
1288
1288
            if (condition3(rsti))  rsti->flag=RS_ADD;
1289
1289
      }
1290
 
      else  //������ ��� ������
 
1290
      else  //близко или внутри
1291
1291
      {
1292
 
        Int32 size=MAX(rect->right-rect->left,rect->bottom-rect->top);
 
1292
        int32_t size=MAX(rect->right-rect->left,rect->bottom-rect->top);
1293
1293
        if (SMALL_FRAG*size>mainsize)
1294
1294
        {
1295
1295
          if (rsti->min_keg>=min_keg && rsti->max_keg<=max_keg)  rsti->flag=RS_ADD;
1296
1296
          else
1297
1297
          if (condition1(rsti))  rsti->flag=RS_ADD;
1298
1298
        }
1299
 
        else   //���������
 
1299
        else   //маленькие
1300
1300
        if (ingap)                    rsti->flag=RS_ADD;
1301
1301
        else   if (condition3(rsti))  rsti->flag=RS_ADD;
1302
1302
      }
1303
1303
 
1304
 
    //����� ��������?
 
1304
    //номер страницы?
1305
1305
      if (rsti->ndig>0 && rsti->ndig<=4 && rsti->ndig==rsti->nbig && !page_num)
1306
1306
      {
1307
1307
        if ( (rect->bottom<main_area.top || rect->top>main_area.bottom) &&
1313
1313
        }
1314
1314
      }
1315
1315
    }
1316
 
    else     //�������� ���������� ��� - ��������� ��� ������������
 
1316
    else     //надежных фрагментов нет - добавляем все сомнительные
1317
1317
      rsti->flag=RS_ADD;
1318
1318
 
1319
1319
    if (rsti->flag & RS_ADD)
1320
1320
    {
1321
 
      Int32 j, hmax=0;
 
1321
      int32_t j, hmax=0;
1322
1322
 
1323
1323
      rsti->flag = RS_GOOD;
1324
1324
 
1325
 
  // ���������� �������������� � ��������� ��������
 
1325
  // расширение прямоугольника и коррекция проекции
1326
1326
      cover_rect(&main_area,&rsti->rect);
1327
1327
      hmax=MIN(main_area.bottom,V_SIZE-1);
1328
1328
      for (j=main_area.top; j<=hmax; j++)  vproj[j]=1;
1339
1339
/*  if( snap_enable && !LDPUMA_SkipEx(hSnapGarbage,FALSE,TRUE,1) )
1340
1340
    if (line)  LDPUMA_CSTR_Monitor(hSnapMain,line,0,myMonitorProc);*/
1341
1341
 
1342
 
//�������� ����������
 
1342
//удаление фрагментов
1343
1343
 
1344
1344
        hBlock = CPAGE_GetBlockFirst(hCPAGE,TYPE_TEXT);
1345
1345
        while(hBlock)
1346
1346
        {
1347
1347
                Handle hNext = CPAGE_GetBlockNext(hCPAGE,hBlock,TYPE_TEXT);
1348
 
    Int32 i;
1349
 
    Word32 bl_flg=CPAGE_GetBlockFlags(hCPAGE,hBlock);
 
1348
    int32_t i;
 
1349
    uint32_t bl_flg=CPAGE_GetBlockFlags(hCPAGE,hBlock);
1350
1350
    if (!(bl_flg & USER_FRAG) || rsti->flag==RS_STRANGE)
1351
1351
    {
1352
1352
      for (i=0,rsti=recstat; i<num_frag; i++,rsti++)
1353
1353
        if (hBlock==rsti->hBlock)  break;
1354
1354
 
1355
 
      if (i==num_frag || rsti->flag==0 || rsti->flag==RS_BAD || rsti->flag==RS_STRANGE)  //��������� (��� �����), ����� ��� � ��������
 
1355
      if (i==num_frag || rsti->flag==0 || rsti->flag==RS_BAD || rsti->flag==RS_STRANGE)  //фиктивный (без строк), грязь или с ошибками
1356
1356
         CPAGE_DeleteBlock(hCPAGE,hBlock);
1357
1357
    }
1358
1358
                hBlock = hNext;
1369
1369
 
1370
1370
}
1371
1371
 
1372
 
static Bool in_gap(Int32 top, Int32 bottom, Word8 *proj)
 
1372
static Bool in_gap(int32_t top, int32_t bottom, uchar *proj)
1373
1373
{
1374
 
  Int32 i=(top+bottom)/2;
 
1374
  int32_t i=(top+bottom)/2;
1375
1375
 
1376
1376
//  return proj[i]==0;
1377
1377
 
1412
1412
  return condition34(rsti,CON4_GOOD);
1413
1413
}
1414
1414
 
1415
 
static Bool condition34(RecStat *rsti, Int32 ngood)
 
1415
static Bool condition34(RecStat *rsti, int32_t ngood)
1416
1416
{
1417
1417
  if ((rsti->ngood>=ngood ||
1418
1418
       rsti->nhigh>=CON3_HIGH && CON3_HIGH_DEHOM*rsti->nhigh > CON3_HIGH_NOM*rsti->nbig) &&
1423
1423
  return FALSE;
1424
1424
}
1425
1425
 
1426
 
static void draw_fragments(Word32 color)
 
1426
static void draw_fragments(uint32_t color)
1427
1427
{
1428
1428
        if(hCPAGE)
1429
1429
  {
1438
1438
  }
1439
1439
}
1440
1440
 
1441
 
static void display_fragment(RecStat *rsti, Word32 color, Word32 key)
 
1441
static void display_fragment(RecStat *rsti, uint32_t color, uint32_t key)
1442
1442
{
1443
 
  Word8 msg[90];
 
1443
  uchar msg[90];
1444
1444
 
1445
1445
  draw_fragment(rsti->hBlock,color,key);
1446
1446
 
1457
1457
  }
1458
1458
}
1459
1459
 
1460
 
static void draw_fragment(Handle hBlock, Word32 color, Word32 key)
 
1460
static void draw_fragment(Handle hBlock, uint32_t color, uint32_t key)
1461
1461
{
1462
1462
        POLY_ poly;
1463
 
  Word32  v;
 
1463
  uint32_t  v;
1464
1464
 
1465
1465
  if (!hBlock)
1466
1466
    return;
1472
1472
          COMMON *com=&poly.com;
1473
1473
    Point32 p32=com->Vertex[0];
1474
1474
    Point16 cv,pv,v0;
1475
 
    Int32   i;
1476
 
    v0.x=(Int16)p32.x;  v0.y=(Int16)p32.y;
 
1475
    int32_t   i;
 
1476
    v0.x=(int16_t)p32.x;  v0.y=(int16_t)p32.y;
1477
1477
    cv=v0;
1478
1478
    for (i=1; i<com->count; i++)
1479
1479
    {
1480
1480
      Point32 p32=com->Vertex[i];
1481
1481
      pv=cv;
1482
 
      cv.x=(Int16)p32.x;  cv.y=(Int16)p32.y;
 
1482
      cv.x=(int16_t)p32.x;  cv.y=(int16_t)p32.y;
1483
1483
      LDPUMA_DrawLine(NULL,&pv,&cv,0,color,1,key);
1484
1484
    }
1485
1485
    LDPUMA_DrawLine(NULL,&v0,&cv,0,color,1,key);
1486
1486
    if( snap_enable && !LDPUMA_SkipEx(hSnapGarbage,FALSE,TRUE,1) )
1487
1487
    {
1488
 
      Word8 msg[80];
1489
 
      sprintf((char*)msg,"draw=%d handle=%x\n",com->number,CPAGE_GetHandleBlock(hCPAGE, com->number));
 
1488
      uchar msg[80];
 
1489
      sprintf((char*)msg,"draw=%d handle=%x\n",com->number,(unsigned int)((unsigned long)CPAGE_GetHandleBlock(hCPAGE, com->number)));
1490
1490
      LDPUMA_Console((const char*)msg);
1491
1491
      LDPUMA_RasterText((char*)msg);
1492
1492
    }
1497
1497
        }
1498
1498
}
1499
1499
 
1500
 
static Handle find_hBlock(Int32 fragment)
 
1500
static Handle find_hBlock(int32_t fragment)
1501
1501
{
1502
 
  static Int32  number[BIG_FRAG_PAGE+1]; Int32  *n=number;
 
1502
  static int32_t  number[BIG_FRAG_PAGE+1]; int32_t  *n=number;
1503
1503
  static Handle handle[BIG_FRAG_PAGE+1]; Handle *h=handle;
1504
1504
 
1505
 
  if (fragment<0)    //�������������
 
1505
  if (fragment<0)    //инициализация
1506
1506
  {
1507
 
    Int32 i;
 
1507
    int32_t i;
1508
1508
          Handle hBlock = CPAGE_GetBlockFirst(hCPAGE,TYPE_TEXT);
1509
1509
    for (i=0; hBlock && i<BIG_FRAG_PAGE; i++)
1510
1510
          {
1520
1520
  return  *h;
1521
1521
}
1522
1522
 
1523
 
static Bool set_frag_ptrs(Int32 *num_frag, Handle frag_hdl[], Int32 frag_num[])
 
1523
static Bool set_frag_ptrs(int32_t *num_frag, Handle frag_hdl[], int32_t frag_num[])
1524
1524
{
1525
1525
        Handle hBlock = CPAGE_GetBlockFirst(hCPAGE,TYPE_TEXT);
1526
1526
  *num_frag=0;
1554
1554
  main_area->bottom=MAX(main_area->bottom,rect->bottom);
1555
1555
}
1556
1556
 
1557
 
static Int32 rect_dist(Rect32 *main, Rect32 *test)
 
1557
static int32_t rect_dist(Rect32 *main, Rect32 *test)
1558
1558
{
1559
 
  Int32 x,y;
1560
 
  Int32 x1=main->left-test->right;
1561
 
  Int32 x2=test->left-main->right;
1562
 
  Int32 y1=main->top-test->bottom;
1563
 
  Int32 y2=test->top-main->bottom;
1564
 
  if (x1>0 || x2>0 || y1>0 || y2>0)   //�� �����������
 
1559
  int32_t x,y;
 
1560
  int32_t x1=main->left-test->right;
 
1561
  int32_t x2=test->left-main->right;
 
1562
  int32_t y1=main->top-test->bottom;
 
1563
  int32_t y2=test->top-main->bottom;
 
1564
  if (x1>0 || x2>0 || y1>0 || y2>0)   //не пересекаютс
1565
1565
  {
1566
1566
    x=MAX(x1,x2);  y=max(y1,y2);
1567
1567
    if (x<0)  return y;
1569
1569
    return MIN(x,y);
1570
1570
  }
1571
1571
 
1572
 
//�����������
 
1572
//пересекаютс
1573
1573
  x1=main->left-test->left;
1574
1574
  x2=test->right-main->right;
1575
1575
  y1=main->top-test->top;
1585
1585
         big->right>=little->right && big->bottom>=little->bottom;
1586
1586
}
1587
1587
 
1588
 
static Int32 dist_border(Rect32 *rect)
 
1588
static int32_t dist_border(Rect32 *rect)
1589
1589
{
1590
 
  Int32 rv=MAXINT32;
 
1590
  int32_t rv=MAXINT32;
1591
1591
  PAGEINFO     PageInfo;
1592
1592
  GetPageInfo(hCPAGE,&PageInfo);
1593
1593
  rv=MIN(rect->left,rect->top);
1594
 
  rv=MIN(rv,(Int32)PageInfo.Width-rect->right);
1595
 
  rv=MIN(rv,(Int32)PageInfo.Height-rect->bottom);
 
1594
  rv=MIN(rv,(int32_t)PageInfo.Width-rect->right);
 
1595
  rv=MIN(rv,(int32_t)PageInfo.Height-rect->bottom);
1596
1596
  return rv;
1597
1597
}
1598
1598
 
1608
1608
  IDEAL_XY(rect->bottom, rect->right);
1609
1609
}
1610
1610
 
1611
 
static void draw_rect(Rect32 *rect, Word32 color, Word32 key)
 
1611
static void draw_rect(Rect32 *rect, uint32_t color, uint32_t key)
1612
1612
{
1613
1613
  Point16 v1,v2,v3,v4;
1614
 
  v1.x=(Int16)rect->left;   v1.y=(Int16)rect->top;
1615
 
  v2.x=(Int16)rect->right;  v2.y=(Int16)rect->top;
1616
 
  v3.x=(Int16)rect->right;  v3.y=(Int16)rect->bottom;
1617
 
  v4.x=(Int16)rect->left;   v4.y=(Int16)rect->bottom;
 
1614
  v1.x=(int16_t)rect->left;   v1.y=(int16_t)rect->top;
 
1615
  v2.x=(int16_t)rect->right;  v2.y=(int16_t)rect->top;
 
1616
  v3.x=(int16_t)rect->right;  v3.y=(int16_t)rect->bottom;
 
1617
  v4.x=(int16_t)rect->left;   v4.y=(int16_t)rect->bottom;
1618
1618
  LDPUMA_DrawLine(NULL,&v1,&v2,0,color,1,key);
1619
1619
  LDPUMA_DrawLine(NULL,&v2,&v3,0,color,1,key);
1620
1620
  LDPUMA_DrawLine(NULL,&v3,&v4,0,color,1,key);
1621
1621
  LDPUMA_DrawLine(NULL,&v4,&v1,0,color,1,key);
1622
1622
}
1623
1623
 
1624
 
static Bool add2list(LineNumber **frag_lines_list, Int32 fn, Int32 ln)
 
1624
static Bool add2list(LineNumber **frag_lines_list, int32_t fn, int32_t ln)
1625
1625
{
1626
1626
  LineNumber *cur_num=*frag_lines_list;
1627
 
  if (cur_num != (LineNumber *)frag_lines_list)  //���� �����
 
1627
  if (cur_num != (LineNumber *)frag_lines_list)  //есть место
1628
1628
  {
1629
 
    cur_num->n=ln;                  //������
 
1629
    cur_num->n=ln;                  //данные
1630
1630
    cur_num->next=frag_lines_list[fn];
1631
 
    frag_lines_list[fn]=cur_num;         //��������� � ������ ���������
1632
 
    (*frag_lines_list)++;                //��������� �����
 
1631
    frag_lines_list[fn]=cur_num;         //добавляем к списку фрагмента
 
1632
    (*frag_lines_list)++;                //свободное место
1633
1633
    return TRUE;
1634
1634
  }
1635
1635
  return FALSE;
1644
1644
    CSTR_line line = CSTR_GetLineHandle (1, version);
1645
1645
    CSTR_rast       rst;
1646
1646
    CSTR_rast_attr  attr;
1647
 
    Word8 msg[1024],*s=msg,*se=msg+950;
1648
 
    Word8 keg_range=max_keg-min_keg+1;
1649
 
    Int32 i;
1650
 
    Int32 n=CSTR_GetMaxNumber();
 
1647
    uchar msg[1024],*s=msg,*se=msg+950;
 
1648
    uchar keg_range=max_keg-min_keg+1;
 
1649
    int32_t i;
 
1650
    int32_t n=CSTR_GetMaxNumber();
1651
1651
 
1652
1652
    s += sprintf((char*)s,"%s\n",str);
1653
 
//      s += sprintf(s,"���������:\n");
 
1653
//      s += sprintf(s,"Фрагменты:\n");
1654
1654
 
1655
1655
    LDPUMA_DeleteRects(NULL, key);
1656
1656
    for(i=1;i<=n;i++)
1669
1669
          if (attr.keg)
1670
1670
          {
1671
1671
            Rect16 box;
1672
 
            Int32 keg = attr.keg;
1673
 
            Word8 green;
 
1672
            int32_t keg = attr.keg;
 
1673
            uchar green;
1674
1674
//             if (j==1)  keg /= 2;
1675
1675
            keg=MIN(keg,max_keg);
1676
 
            green=(Word8)(255*(max_keg-keg)/keg_range);
 
1676
            green=(uchar)(255*(max_keg-keg)/keg_range);
1677
1677
 
1678
1678
            box.left=attr.r_col;  box.right=box.left+attr.w-1;
1679
1679
            box.top=attr.r_row;   box.bottom=box.top+attr.h-1;
1704
1704
 
1705
1705
void kegl_snap_init()
1706
1706
{
1707
 
  LDPUMA_Registry(&hSnapMain,"��������� �����...",NULL);
1708
 
  LDPUMA_RegistryHelp(hSnapMain,"��������� �����...",FALSE);
1709
 
  LDPUMA_Registry(&hSnapEndPage,"����� ��������",hSnapMain);
1710
 
  LDPUMA_RegistryHelp(hSnapEndPage,"����� ��������",FALSE);
1711
 
//  LDPUMA_Registry(&hSnapTable,"������ ����� � �������",hSnapMain);
1712
 
  LDPUMA_Registry(&hSnapGarbage,"�������� ������",NULL);
1713
 
  LDPUMA_Registry(&hSnapGarbageLine,"�������� �����",hSnapGarbage);
1714
 
  LDPUMA_RegistryHelp(hSnapGarbage,"�������� ������",FALSE);
1715
 
  LDPUMA_RegistryHelp(hSnapGarbageLine,"��������� �� ������ ������ ���������",FALSE);
1716
 
  LDPUMA_RegVariable(hSnapGarbage,"������� �����",&gbGarbage,"long");
1717
 
  LDPUMA_RegVariable(hSnapMain,"����",&gbFax100,"long");
 
1707
  LDPUMA_Registry(&hSnapMain,"Коррекция кегля...",NULL);
 
1708
  LDPUMA_RegistryHelp(hSnapMain,"Коррекция кегля...",FALSE);
 
1709
  LDPUMA_Registry(&hSnapEndPage,"Конец страницы",hSnapMain);
 
1710
  LDPUMA_RegistryHelp(hSnapEndPage,"Конец страницы",FALSE);
 
1711
//  LDPUMA_Registry(&hSnapTable,"Единый кегль в таблице",hSnapMain);
 
1712
  LDPUMA_Registry(&hSnapGarbage,"Удаление мусора",NULL);
 
1713
  LDPUMA_Registry(&hSnapGarbageLine,"Просмотр строк",hSnapGarbage);
 
1714
  LDPUMA_RegistryHelp(hSnapGarbage,"Удаление мусора",FALSE);
 
1715
  LDPUMA_RegistryHelp(hSnapGarbageLine,"Остановка на каждой строке фрагмента",FALSE);
 
1716
  LDPUMA_RegVariable(hSnapGarbage,"Чистить мусор",&gbGarbage,"long");
 
1717
  LDPUMA_RegVariable(hSnapMain,"Факс",&gbFax100,"long");
1718
1718
}
1719
1719
 
1720
1720
static void kegl_by_frag()
1730
1730
 
1731
1731
static void keg_frag_stats()
1732
1732
{
1733
 
  Int32 nl,sv_num_keg=num_keg;
1734
 
  Word8 max_keg=0;
 
1733
  int32_t nl,sv_num_keg=num_keg;
 
1734
  uchar max_keg=0;
1735
1735
  memset(keg_stats,0,sizeof(keg_stats));
1736
1736
  for (nl=1; nl<=*cur_fragment; nl++)
1737
1737
  {
1753
1753
        CSTR_GetCollectionUni(rst,&uni);
1754
1754
        if(!(attr.flg & CSTR_f_space) && attr.keg && uni.lnAltCnt)
1755
1755
        {
1756
 
          Word8 keg=attr.keg;
 
1756
          uchar keg=attr.keg;
1757
1757
          max_keg=MAX(keg,max_keg);
1758
1758
          keg_stats[keg]++;
1759
1759
        }