← Back to branch summary

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

« back to all changes in this revision

Viewing changes to cuneiform_src/Kern/rfrmt/sources/main/pagetree.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/rfrmt/sources/main/pagetree.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:
118
118
           det15=0,     //frame_coor
119
119
           det16=0,     //ordering and recalc colons
120
120
           det17=0,     //indent
121
 
           det18=0,     //����������� ���������
122
 
                                det19=0,     //������� ������
123
 
                                det20=0,     //������� realese version
124
 
                                det21=0,     //������� realese version
125
 
                                det22=0,     //������� realese version--memory
126
 
                                det23=1,     //������� realese version only name file
 
121
           det18=0,     //межстрочное растояние
 
122
                                det19=0,     //отладка ошибок
 
123
                                det20=0,     //отладка realese version
 
124
                                det21=0,     //отладка realese version
 
125
                                det22=0,     //отладка realese version--memory
 
126
                                det23=1,     //отладка realese version only name file
127
127
    dets =0;     //tmp break points
128
128
 
129
129
 
135
135
extern  std::vector <tagRECT> *pTheGeomTemp ;
136
136
extern  vectorWord           *pFragRectColor;
137
137
extern  void MyDrawForDebug(void);
138
 
extern  WORD                 *CountRect;
 
138
extern  uint16_t                 *CountRect;
139
139
 
140
140
#else
141
141
        #define CONS_MESS1 1 ? 0 : ConsMess
156
156
typedef void(*FMyDraw)(void);
157
157
typedef struct tagSETUP_GENERATE_TREE
158
158
{
159
 
        Int16 size_x,size_y; //standard sizes of symbols in page
 
159
        int16_t size_x,size_y; //standard sizes of symbols in page
160
160
} SETUP_GENERATE_TREE;
161
161
 
162
 
Int16   FlagOdinSectorOdnaColonka = FALSE;
163
 
Int16   MaxLev,NumColTrue,RegimExt;
 
162
int16_t   FlagOdinSectorOdnaColonka = FALSE;
 
163
int16_t   MaxLev,NumColTrue,RegimExt;
164
164
const char    *errRtf="ED_RTF";
165
165
Rect16  *RectFragm;
166
166
FRAME   *ArrFrm;
167
167
 
168
 
extern  Int16 SizeYGlobUpp;
 
168
extern  int16_t SizeYGlobUpp;
169
169
extern  SUB_ALLOC SubZn;
170
 
extern  Int16 MonoSpaceAllPage;
171
 
extern  Int16 HeiStrAllPage;
172
 
extern  Word32   RtfWriteMode;
 
170
extern  int16_t MonoSpaceAllPage;
 
171
extern  int16_t HeiStrAllPage;
 
172
extern  uint32_t   RtfWriteMode;
173
173
 
174
174
/*
175
175
util     - memory alloc
177
177
sort_int - fast sorting
178
178
util_spl:
179
179
        OpenFullOutTiger  - RTF
180
 
        CalcStatTiger     - ���������� �� ���������� (������- � ���- ������� � �.�.)
 
180
        CalcStatTiger     - статистика об интервалах (внутри- и меж- словные и т.п.)
181
181
*/
182
 
extern "C" BOOL PageTree(FILE *InFileName, CRtfPage* RtfPage, const char* OutFileName);
 
182
extern "C" Bool PageTree(FILE *InFileName, CRtfPage* RtfPage, const char* OutFileName);
183
183
extern short __cdecl OpenFullOutTiger(FILE *FileName);
184
 
void   show_frm(Int16 NumFragm,FRAME **frm);
 
184
void   show_frm(int16_t NumFragm,FRAME **frm);
185
185
Bool   Alik_sort_function( const void *a, const void *b);
186
186
int    CalcStatTiger(void);
187
 
Int16  GenerateTreeByFragm(Rect16 *RectFragm,Int16 NumFragm,
 
187
int16_t  GenerateTreeByFragm(Rect16 *RectFragm,int16_t NumFragm,
188
188
                                 SETUP_GENERATE_TREE *setup, FRAME ***Frm1, INF_TREE *Inf);
189
 
void   GetFirstIndexFragm(Rect16 *RectFragm,Int16 NumCol,Int16 *nc,FRAME **frm);
190
 
Int16  CreateTreePlainTxt1(BOUND BndTxt,STRET *LineV,Int16 NumLV,STRET *LineH,
191
 
                          Int16 NumLH,FRAME **frm,Int16 NumFrm,INF_TREE *Inf,Int16 size_x,Int16 size_y);
192
 
Int16  AddLine1(LINE_KNOT **Line1,Int16 *nCurr,Int16 *nMax,Int16 Coor,Int16 Thres);
193
 
Int16  SearchColHist1(FRAME **frm,Int16 k_frm,BOUND *bnd,Int16 ave_x,Int16 ave_y,
194
 
                     Int16 reg,Int16 *k_int,Int16 **intr1,Int16 **begI,Int16 **endI,Int16 *NumMax);
195
 
Int16  SearchInterval1(FRAME **frm,Int16 k_frm,Int16 **beg1,Int16 **end1,
196
 
                      Int16 *k_int1,BOUND *bnd,Int16 ave_dir,Int16 ave_ort,Int16 reg,Int16 *NumMax);
 
189
void   GetFirstIndexFragm(Rect16 *RectFragm,int16_t NumCol,int16_t *nc,FRAME **frm);
 
190
int16_t  CreateTreePlainTxt1(BOUND BndTxt,STRET *LineV,int16_t NumLV,STRET *LineH,
 
191
                          int16_t NumLH,FRAME **frm,int16_t NumFrm,INF_TREE *Inf,int16_t size_x,int16_t size_y);
 
192
int16_t  AddLine1(LINE_KNOT **Line1,int16_t *nCurr,int16_t *nMax,int16_t Coor,int16_t Thres);
 
193
int16_t  SearchColHist1(FRAME **frm,int16_t k_frm,BOUND *bnd,int16_t ave_x,int16_t ave_y,
 
194
                     int16_t reg,int16_t *k_int,int16_t **intr1,int16_t **begI,int16_t **endI,int16_t *NumMax);
 
195
int16_t  SearchInterval1(FRAME **frm,int16_t k_frm,int16_t **beg1,int16_t **end1,
 
196
                      int16_t *k_int1,BOUND *bnd,int16_t ave_dir,int16_t ave_ort,int16_t reg,int16_t *NumMax);
197
197
KNOTT* IncKnot(KNOTT *up,KNOTT *after,KNOTT **free);
198
 
void   FillFieldKNOTT1(KNOTT *ptr,Int16 Left,Int16 Right,Int16 Top,Int16 Bottom,
199
 
                                                                                                                                                                        Int16 InBegFrm,Int16 NumFrm,Int16 InColA,
 
198
void   FillFieldKNOTT1(KNOTT *ptr,int16_t Left,int16_t Right,int16_t Top,int16_t Bottom,
 
199
                                                                                                                                                                        int16_t InBegFrm,int16_t NumFrm,int16_t InColA,
200
200
                                                                                                                                                                        uint OrderChild,uint Type,uint AllowOCR,uint JustH,uint JustV,char *Name);
201
 
Int16  SortHorLine1(LINE_KNOT *LineHK,Int16 NumH,LINE_KNOT *LineVK,Int16 NumV,
202
 
                   KNOTT *Root,KNOTT ***colt1,Int16 *k_colt1,FRAME **frm);
203
 
char   *get2_param(char *str,char *param,Int16 max_len);
204
 
Int16  Check_IsItFalseHorLine(Int16 recalc,Int16 reg,FRAME **frm,Int16 *his,Int16 pos,Int16 len,
205
 
                                                                                                                                                                                                                                        Int16 maxh,Int16 sum,Int16 len_group,Int16 *his_first_group,
206
 
                                                                                                                                                                                                                                        Int16 *his_second_group,BOUND *bnd,Int16 k_frm);
207
 
Int16  check_white_int(Int16 beg_white_int,Int16 end_white_int,Int16 maxh,
208
 
                                                                                                Int16 *his_second_group);
209
 
Int16  GetRealSize( char* str,Int16 len,Int16 FontSize ,Int16 FontNumber,Int16* strHeight);
210
 
void   Get_all_term_fragms( KNOTT *ptr,Int16 *Colt,Int16 *iv ,Int16 NumCol,FRAME **frm);
211
 
void   Get_all_term_fragms1( KNOTT* ptr,Int16* Colt,Int16* iv,Int16 NumCol,FRAME **frm);
212
 
Int16  term_col_seriated(Int16* term_ind,Int16 Count_Term_Col,Int16* K_Ver_Flag_Term);
213
 
Int16  OrderingAndRecalcCol(Int16 Nsector,Int16 Ncol,Int16 H0,Int16 L0,Int16 *W_P,Int16 *H_P,
214
 
                                                                                                                                                                                                                        Int16 dist_col,KNOTT *pRoot,FRAME **frm,
215
 
                                                                                                                                                                                                                        Float32 Max_koof_for_width,Float32 Max_koof_for_height);
216
 
Int16  RecalcRect(Int16 L,Int16 H,Int16 *w,Int16 *h,KNOTT *ptrc,FRAME **frm,
217
 
                                                                         Float32 Max_koof_for_width,Float32 Max_koof_for_height);
218
 
Int16 GetOffsetVerticalCell(Int16 L,Int16 H,Int16 *w,Int16 *h,KNOTT *ptrc,FRAME **frm);
 
201
int16_t  SortHorLine1(LINE_KNOT *LineHK,int16_t NumH,LINE_KNOT *LineVK,int16_t NumV,
 
202
                   KNOTT *Root,KNOTT ***colt1,int16_t *k_colt1,FRAME **frm);
 
203
char   *get2_param(char *str,char *param,int16_t max_len);
 
204
int16_t  Check_IsItFalseHorLine(int16_t recalc,int16_t reg,FRAME **frm,int16_t *his,int16_t pos,int16_t len,
 
205
                                                                                                                                                                                                                                        int16_t maxh,int16_t sum,int16_t len_group,int16_t *his_first_group,
 
206
                                                                                                                                                                                                                                        int16_t *his_second_group,BOUND *bnd,int16_t k_frm);
 
207
int16_t  check_white_int(int16_t beg_white_int,int16_t end_white_int,int16_t maxh,
 
208
                                                                                                int16_t *his_second_group);
 
209
int16_t  GetRealSize( char* str,int16_t len,int16_t FontSize ,int16_t FontNumber,int16_t* strHeight);
 
210
void   Get_all_term_fragms( KNOTT *ptr,int16_t *Colt,int16_t *iv ,int16_t NumCol,FRAME **frm);
 
211
void   Get_all_term_fragms1( KNOTT* ptr,int16_t* Colt,int16_t* iv,int16_t NumCol,FRAME **frm);
 
212
int16_t  term_col_seriated(int16_t* term_ind,int16_t Count_Term_Col,int16_t* K_Ver_Flag_Term);
 
213
int16_t  OrderingAndRecalcCol(int16_t Nsector,int16_t Ncol,int16_t H0,int16_t L0,int16_t *W_P,int16_t *H_P,
 
214
                                                                                                                                                                                                                        int16_t dist_col,KNOTT *pRoot,FRAME **frm,
 
215
                                                                                                                                                                                                                        float Max_koof_for_width,float Max_koof_for_height);
 
216
int16_t  RecalcRect(int16_t L,int16_t H,int16_t *w,int16_t *h,KNOTT *ptrc,FRAME **frm,
 
217
                                                                         float Max_koof_for_width,float Max_koof_for_height);
 
218
int16_t GetOffsetVerticalCell(int16_t L,int16_t H,int16_t *w,int16_t *h,KNOTT *ptrc,FRAME **frm);
219
219
void RtfUnionRect_CRect_SRect(tagRECT *s1,SRECT *s2);
220
220
void RtfUnionRect_CRect_CRect(tagRECT *s1,tagRECT *s2);
221
221
void RtfAssignRect_CRect_SRect(tagRECT *s1,SRECT *s2);
223
223
void    RtfCalcRectSizeInTwips(tagRECT *s1, float Twips);
224
224
void RtfAssignRect_CRect_CRect(tagRECT *s1,tagRECT *s2);
225
225
 
226
 
//Int16 CreateEmptyRtfFile(void);
 
226
//int16_t CreateEmptyRtfFile(void);
227
227
 
228
228
////////////// functions, which are moved from other modules //////////////
229
229
static HWND h_found=NULL;
230
 
extern "C" BOOL __stdcall FindByPartOfTitle( HWND hwnd,       // handle to parent window
 
230
extern "C" Bool __stdcall FindByPartOfTitle( HWND hwnd,       // handle to parent window
231
231
                                             LPARAM lParam      ) // application-defined value
232
232
{
233
233
   char title[256];
297
297
}
298
298
 
299
299
//==
300
 
/* // !!! Art - ��������
 
300
/* // !!! Art - устарело
301
301
int statis(TYPE *arr,int n,TYPE *ave1,TYPE *sig1,TYPE *med,TYPE *mod,int regim)
302
 
//���� regim > 0, ������� ���� ������� ������ [0,n] - [n/regim,n-n/regim]
 
302
//если regim > 0, усекаем края выборки вместо [0,n] - [n/regim,n-n/regim]
303
303
{ int i; long ave=0,sig=0,work;
304
304
 
305
 
  u4sort(arr,n+1,sizeof(TYPE),(COMP_FUN)comp1); //�������
306
 
  if(regim) //�������� ���� �������
 
305
  u4sort(arr,n+1,sizeof(TYPE),(COMP_FUN)comp1); //медиана
 
306
  if(regim) //обрезаем края выборки
307
307
  { int beg=n/regim; if((n-=2*beg)<0){n+=2*beg;goto m1;}
308
308
    if(beg) do0(i,0,n) arr[i]=arr[i+beg];
309
309
  }
317
317
  *ave1=(TYPE)ave; *sig1=(TYPE)sig;
318
318
  return 0;
319
319
}
320
 
*/ // !!! Art - ��������
 
320
*/ // !!! Art - устарело
321
321
//==
322
322
void bound_frm(FRAME **frm,int k_frm,BOUND *bnd)
323
323
{
333
333
}
334
334
 
335
335
//==
336
 
void TestKNOTT1(KNOTT *ptr,LINE_KNOT *LineVK,LINE_KNOT *LineHK,Int16 NumFrm,Int16 NumVK,Int16 NumHK)
 
336
void TestKNOTT1(KNOTT *ptr,LINE_KNOT *LineVK,LINE_KNOT *LineHK,int16_t NumFrm,int16_t NumVK,int16_t NumHK)
337
337
{
338
338
        RECT r1=ptr->Rect; KNOTT *up=ptr->up;
339
339
        if(r1.left >= r1.right || r1.top == r1.bottom ||
346
346
       ERR(1,"TestKNOTT1");
347
347
}
348
348
 
349
 
//===��� �����������.���������� Return=0
 
349
//===Для нераспознан.знакоместа Return=0
350
350
uchar Get1Alt(ZN *z,int na)
351
351
{ int ka=z->Title.Z_Num_Alt;
352
352
  if(ka <= 0 /*|| na >= ka*/)
360
360
  { return n > 0 ? statis1(arr,n-1,ave,sig,med,mod,regim) : -1; }
361
361
//==
362
362
int statis1(TYPE *arr,int n,TYPE *ave1,TYPE *sig1,TYPE *med,TYPE *mod,int regim)
363
 
/*���� regim > 0, ������� ���� ������� ������ [0,n] - [n/regim,n-n/regim]*/
 
363
/*если regim > 0, усекаем края выборки вместо [0,n] - [n/regim,n-n/regim]*/
364
364
{
365
365
        int i;
366
366
        long ave=0,sig=0,work;
367
367
 
368
368
        if(*med)
369
369
  { u4sort(arr,n+1,sizeof(TYPE),(COMP_FUN)comp1);
370
 
    if(regim) /*�������� ���� �������*/
 
370
    if(regim) /*обрезаем края выборки*/
371
371
    {
372
372
                        int beg=n/regim;
373
373
                        if((n-=2*beg)<0)
388
388
  return 0;
389
389
}
390
390
 
391
 
//== SizeWin - ������ ���� ��� ��������� �����������(if =1 => ��������.�����������)
 
391
//== SizeWin - ширина окна при наложении гистограммы(if =1 => стандарт.гистограмма)
392
392
int statis2(TYPE *arr,int n,TYPE *med,TYPE *mod,int SizeWin,int *NumMod)
393
393
{
394
394
        int i,PosExtr,num; long ave=0,sig=0;
395
395
        int *his,mi=32000,ma=-32000,nmax,modd=-32000,ki,sum=0,k=(n+1)>>1;
396
 
        //---������ ����,������� �� �����������---
 
396
        //---Расчет моды,медианы по гистограмме---
397
397
        int medd=-32000; const char *err="statis2";
398
398
 
399
399
        mi=MinArr(arr,n,&PosExtr);
402
402
        if((his=(int*)malloc(num*sizeof(int)))==NULL)
403
403
                return NOT_ALLOC;
404
404
        memset(his,0,num*sizeof(int));
405
 
        if(SizeWin == 1) //��������.�����������
 
405
        if(SizeWin == 1) //стандарт.гистограмма
406
406
        {
407
407
                do0(i,0,n)
408
408
                        ++his[arr[i]-mi];
409
409
        }
410
 
        else if(SizeWin > 1) //���������� �����������
 
410
        else if(SizeWin > 1) //огрубление гистограммы
411
411
        {
412
412
                if(SizeWin > 2)
413
 
                        return -1; //!����!
 
413
                        return -1; //!пока!
414
414
                do0(i,0,n)
415
415
                {
416
416
                        ++his[arr[i]-mi];
444
444
        return 0;
445
445
}
446
446
 
447
 
//������ ��� beg_as[][] ������-��� ������, ������ ��� �����.��-�� KNOT3 �������
448
 
//==��������� ������� �� �� ���������� �������
 
447
//Память под beg_as[][] захват-тся внутри, память под списк.пр-во KNOT3 снаружи
 
448
//==Генерация плоской АС на двусвязных списках
449
449
int GenAS(FRAME **frm,int k_frm,int dx,int dy,BOUND *bnd,KNOT3 *beg_free,
450
450
    int value,AS *As,RECT Rect)
451
451
{
453
453
  KNOT3 ***beg,*ptr; FRAME *f;
454
454
  const char *err="GenAS";
455
455
 
456
 
        /*������������� ������� ������ �������*/
 
456
        /*оконтуривание решетки пустой полосой*/
457
457
  xmin=bnd->left;xmax=bnd->right;ymin=bnd->up;ymax=bnd->down;
458
458
  xmin-=(dx+1);kx=((xmax-xmin+1)/dx)+1;xmax=xmin+(kx+1)*dx;
459
459
  ymin-=(dy+1);ky=((ymax-ymin+1)/dy)+1;ymax=ymin+(ky+1)*dy;
464
464
                        return NOT_ALLOC;
465
465
    memset(beg[i],0,(kx+1)*sizeof(PTR));
466
466
  }
467
 
  if(value != INDEF)//���������� ��������. ���-��
 
467
  if(value != INDEF)//заполнение ассоциат. стр-ры
468
468
  {
469
469
                do0(i,0,k_frm)
470
470
    { f=frm[i];
503
503
        //================================================================================
504
504
        //=================================   ImageKnot1  ================================
505
505
  //================================================================================
506
 
        void ImageKnot1(KNOTT *ptr,LINE_KNOT *LineVK,LINE_KNOT *LineHK,Int16 col,
507
 
                        Int16 line_style,Int16 fill,Int16 ColFrm,FRAME **f,Int16 NumFrm,
508
 
                                                                        Int16 NumVK,Int16 NumHK)
 
506
        void ImageKnot1(KNOTT *ptr,LINE_KNOT *LineVK,LINE_KNOT *LineHK,int16_t col,
 
507
                        int16_t line_style,int16_t fill,int16_t ColFrm,FRAME **f,int16_t NumFrm,
 
508
                                                                        int16_t NumVK,int16_t NumHK)
509
509
        {
510
510
                RECT r,r1=ptr->Rect;
511
 
                Int16 fl= (ColFrm != INDEF) ? 0 : 1;
 
511
                int16_t fl= (ColFrm != INDEF) ? 0 : 1;
512
512
 
513
513
                if(ColFrm == INDEF)
514
514
                          ColFrm=col;
524
524
          }
525
525
        }
526
526
 
527
 
        //������ �� ������ � ������������
 
527
        //проход по дереву с отображением
528
528
        //================================================================================
529
529
        //=================================   ImageTree1  ================================
530
530
  //================================================================================
531
 
        Int16 ImageTree1(KNOTT *Root,LINE_KNOT *LineVK,LINE_KNOT *LineHK,
532
 
          FRAME **frm,Int16 NumFrm,Int16 NumVK,Int16 NumHK)
 
531
        int16_t ImageTree1(KNOTT *Root,LINE_KNOT *LineVK,LINE_KNOT *LineHK,
 
532
          FRAME **frm,int16_t NumFrm,int16_t NumVK,int16_t NumHK)
533
533
        {
534
534
                STACK St;
535
 
          Int16 DepthTree=20,col,ColFrm,i=1;
 
535
          int16_t DepthTree=20,col,ColFrm,i=1;
536
536
          KNOTT *Curr;
537
537
          char *err="ImageTree1";
538
538
 
546
546
                        col=1;
547
547
                ColFrm=col;
548
548
            //ImageKnot1(Curr,LineVK,LineHK,col,0xFFFF,_GBORDER,ColFrm,frm,NumFrm,NumVK,NumHK);
549
 
            //--������ �� ������������ ������� ��������. H-�����,������ �� V-������ � �� ��������
550
 
            //if(Curr->InBegFrm == IN_NO && Curr->down == NULL) //����. H-����
 
549
            //--Рисуем по перекрестным ссылкам терминал. H-графы,списки их V-ссылок и им обратные
 
550
            //if(Curr->InBegFrm == IN_NO && Curr->down == NULL) //Терм. H-узел
551
551
                        if(det10)       {ConsMess("i=%2d   InBegFrm=%2d  NumFrm=%2d  InColA=%6d  OrderChild=%2d",
552
552
                                                         i,Curr->InBegFrm,Curr->NumFrm,Curr->InColA,Curr->OrderChild);
553
553
                              ++i;}
554
554
 
555
 
                        ImageKnot1(Curr,LineVK,LineHK,col,(Int16)0xFFFF,_GBORDER,(Int16)-1,frm,NumFrm,NumVK,
 
555
                        ImageKnot1(Curr,LineVK,LineHK,col,(int16_t)0xFFFF,_GBORDER,(int16_t)-1,frm,NumFrm,NumVK,
556
556
                                         NumHK);
557
557
            Curr=NextKnot(Curr,&St);
558
558
            if(OverflowStack(&St))
567
567
#endif /*DRAW*/
568
568
 
569
569
//==
570
 
static Int16 Realloc2(KNOTT*** colt,KNOTT*** colnt,KNOTT*** colnt1,
571
 
        Int16 **begI,Int16 **endI,Int16 **intr,Int16 nOld,Int16 nNew)
572
 
{ Int16 oldS =nOld*sizeof(PTR),newS =nNew*sizeof(PTR),
573
 
        oldS1=nOld*sizeof(Int16),newS1=nNew*sizeof(Int16);
 
570
static int16_t Realloc2(KNOTT*** colt,KNOTT*** colnt,KNOTT*** colnt1,
 
571
        int16_t **begI,int16_t **endI,int16_t **intr,int16_t nOld,int16_t nNew)
 
572
{ int16_t oldS =nOld*sizeof(PTR),newS =nNew*sizeof(PTR),
 
573
        oldS1=nOld*sizeof(int16_t),newS1=nNew*sizeof(int16_t);
574
574
  if((colt   && ((*colt=(KNOTT**)realloc_m(*colt,  oldS,newS))==NULL))||
575
575
     (colnt  && ((*colnt=(KNOTT**)realloc_m(*colnt, oldS,newS))==NULL))||
576
576
     (colnt1 && ((*colnt1=(KNOTT**)realloc_m(*colnt1,oldS,newS))==NULL))||
577
 
     (begI   && ((*begI=(Int16*)realloc_m(*begI,oldS1,newS1))==NULL))||
578
 
     (endI   && ((*endI=(Int16*)realloc_m(*endI,oldS1,newS1))==NULL))||
579
 
     (intr   && ((*intr=(Int16*)realloc_m(*intr,oldS1,newS1))==NULL)))
 
577
     (begI   && ((*begI=(int16_t*)realloc_m(*begI,oldS1,newS1))==NULL))||
 
578
     (endI   && ((*endI=(int16_t*)realloc_m(*endI,oldS1,newS1))==NULL))||
 
579
     (intr   && ((*intr=(int16_t*)realloc_m(*intr,oldS1,newS1))==NULL)))
580
580
       return NOT_ALLOC;
581
581
  return 0;
582
582
}
588
588
}
589
589
 
590
590
#ifdef alDebug
591
 
void show_frm(Int16 NumFragm,FRAME **frm)
 
591
void show_frm(int16_t NumFragm,FRAME **frm)
592
592
{
593
 
        Int16 i;
 
593
        int16_t i;
594
594
 
595
595
        for(i=0; i < NumFragm; ++i)
596
596
        {
607
607
//              RectFragm[NumFragm],
608
608
//              setup - input parameters
609
609
//      output - Inf
610
 
Int16 GenerateTreeByFragm(Rect16 *RectFragm,Int16 NumFragm,
 
610
int16_t GenerateTreeByFragm(Rect16 *RectFragm,int16_t NumFragm,
611
611
        SETUP_GENERATE_TREE *setup, FRAME ***Frm1, INF_TREE *Inf)
612
612
{
613
613
        FRAME  **frm;
614
 
        Int16  i,fl=0;
 
614
        int16_t  i,fl=0;
615
615
        BOUND  BndAll;
616
616
 
617
617
        ArrFrm=(FRAME*) malloc(NumFragm*sizeof(FRAME));
645
645
        //--calling internal function for tree generation--
646
646
        if(CreateTreePlainTxt1(BndAll,NULL,0,NULL,0,
647
647
     frm,NumFragm,Inf, setup->size_x, setup->size_y))
648
 
                        return (Int16)fl-200;
 
648
                        return (int16_t)fl-200;
649
649
 
650
650
        return 0;
651
651
}
652
652
 
653
 
//������� ������ ���-�� Text Plain
 
653
//Создать дерево стр-ры Text Plain
654
654
//Input:
655
655
//   BndTxt - page boundaries
656
 
//   LineV[NumLV],LineH[NumLH] - ������������ � �������������� �����, ��������� �� �����
657
 
//   frm[NumFrm] - ����� ���� (���������� � CunieForm) �����
658
 
//   size_x,size_y - ��������. ������ ���� �����
 
656
//   LineV[NumLV],LineH[NumLH] - вертикальные и горизонтальные линии, найденные на листе
 
657
//   frm[NumFrm] - рамки букв (фрагментов в CunieForm) листа
 
658
//   size_x,size_y - стандарт. размер букв листа
659
659
//Output:
660
 
//   Inf - �������������� ��������� �������� ������ ������� �����
 
660
//   Inf - результирующая структура хранения дерева колонок листа
661
661
//Return: 0 - OK
662
662
//====
663
 
Int16 CreateTreePlainTxt1(BOUND BndTxt,STRET *LineV,Int16 NumLV,STRET *LineH,
664
 
    Int16 NumLH,FRAME **frm,Int16 NumFrm,INF_TREE *Inf,Int16 size_x,Int16 size_y)
 
663
int16_t CreateTreePlainTxt1(BOUND BndTxt,STRET *LineV,int16_t NumLV,STRET *LineH,
 
664
    int16_t NumLH,FRAME **frm,int16_t NumFrm,INF_TREE *Inf,int16_t size_x,int16_t size_y)
665
665
//====
666
666
{
667
 
        Int16     i,nVmax=3*MAX_COL,nHmax=3*MAX_COL,nV,nH,j;
668
 
        Int16     nT=nVmax+1,fl,tmp,InBegFrm,NumF,ThresX,ThresY;
669
 
        Int16     left,right,top,bottom,NumMax=3*MAX_COL,MaxOld;
670
 
        Int16     *intr,*begI,*endI,NumT=nVmax+1;
671
 
        Int16     k_colnt,k_colnt1,k_colt,minz;
672
 
        Int16     fl_beg/*������� ������� ����������� �� �������*/;
673
 
        Int16     order/*��� ������� ���������������:HOR - ��������. ��� VER - ��������.*/;
674
 
        Int16     kf,kcol,del,del1;
 
667
        int16_t     i,nVmax=3*MAX_COL,nHmax=3*MAX_COL,nV,nH,j;
 
668
        int16_t     nT=nVmax+1,fl,tmp,InBegFrm,NumF,ThresX,ThresY;
 
669
        int16_t     left,right,top,bottom,NumMax=3*MAX_COL,MaxOld;
 
670
        int16_t     *intr,*begI,*endI,NumT=nVmax+1;
 
671
        int16_t     k_colnt,k_colnt1,k_colt,minz;
 
672
        int16_t     fl_beg/*Признак первого расщепления на колонки*/;
 
673
        int16_t     order/*Тип искомой упорядоченности:HOR - горизонт. или VER - вертикал.*/;
 
674
        int16_t     kf,kcol,del,del1;
675
675
        TREE2     Tree;
676
676
        BOUND     bndc;
677
677
        KNOTT     *PrevChild,*Child;
682
682
 
683
683
        CONS_MESS1("===  CreateTreePlainTxt1  === ");
684
684
 
685
 
        //LineVK, LineHK - ����������� ���� ����������� ����� ���������,
686
 
        //   ������������ ��������� �������, � ������� ���� ����� �����������
687
 
        //   ��������. � ��������. ������������ �������
 
685
        //LineVK, LineHK - виртуальные либо натуральные линии разграфки,
 
686
        //   сепарирующие найденные колонки, с помощью этих линий производитс
 
687
        //   горизонт. и вертикал. выравнивание колонок
688
688
        LineVK=(LINE_KNOT*)malloc((nVmax+2)*sizeof(LINE_KNOT));
689
689
        LineHK=(LINE_KNOT*)malloc((nHmax+2)*sizeof(LINE_KNOT));
690
 
        intr=(Int16*)malloc(NumMax*sizeof(Int16));
691
 
        begI=(Int16*)malloc(NumMax*sizeof(Int16));
692
 
        endI=(Int16*)malloc(NumMax*sizeof(Int16));
693
 
        //������� � ��������� �������. ����� ����� �� ���������������
694
 
        //-- ��������� ������� H- � V-����� � ����� �� ����� ����� --
 
690
        intr=(int16_t*)malloc(NumMax*sizeof(int16_t));
 
691
        begI=(int16_t*)malloc(NumMax*sizeof(int16_t));
 
692
        endI=(int16_t*)malloc(NumMax*sizeof(int16_t));
 
693
        //Заносим в разграфку натурал. линии после их ортогонализации
 
694
        //-- Замыкание системы H- и V-линий с краев по рамке листа --
695
695
        LineVK[0].beg=BndTxt.left;
696
696
        LineVK[1].beg=BndTxt.right;
697
697
        LineHK[0].beg=BndTxt.up  ;
708
708
                CONS_MESS9("NOT_ALLOC 609");
709
709
                return NOT_ALLOC;
710
710
        }
711
 
        //--�������� ���������� ������-�� � ����� ������--
 
711
        //--Создание спискового простр-ва и корня дерева--
712
712
        Tree.NumKnot=NumMax*2;
713
713
        Tree.NumSeg=-1;
714
714
        if((fl=init_lst(&Tree.ArrSeg,&Tree.NumSeg,Tree.NumKnot,(KNOT**)&Tree.free,sizeof(KNOTT)))!=0)
723
723
        }
724
724
        FillFieldKNOTT1(Tree.Root,0,1,0,1,0,NumFrm,IN_NO,UNSORT,ROOT,TRUE,ALG_BEG,ALG_BEG,NULL);
725
725
        colnt[k_colnt=0]=Tree.Root; k_colt=-1;
726
 
        fl_beg=1; order=VER;//��� ������� ��� RTF-converter
727
 
        ThresX=ThresY=(Int16)(1.5*size_y);
 
726
        fl_beg=1; order=VER;//Так удобнее для RTF-converter
 
727
        ThresX=ThresY=(int16_t)(1.5*size_y);
728
728
 
729
 
        Int16 MaxAllowLev,flTerm;
 
729
        int16_t MaxAllowLev,flTerm;
730
730
        MaxAllowLev=6;
731
731
        MaxLev=0; flTerm=FALSE;
732
732
 
733
 
        //������� �������, ��� ��� ��������� �������� ���� �������,
734
 
        //������� ���� ����������� - �� ������ �������� MaxLev �����������
735
 
        //������� ��������� �� ����-�������, ������� ���� �� ���� ������
736
 
        //� ��� ��� �����-�������, ������� ����������, ������ ��������
737
 
        //����-���������� �� ��������� ������ MaxLev+1
738
 
        //colnt[k_colnt]   - ������ ����� �������� ������ MaxLev
739
 
        //colnt1[k_colnt1] - ������ ����� ���������� ������ MaxLev+1
740
 
        //colt[k_colt] - ������ ������������ �������
741
 
        //������� ����� �������� - �� ��������� ������ ��� �����, �.�. �� ����
742
 
        //�� ����� ����������� ������ �� ������� ����������
 
733
        //вначале считаем, что все фрагменты образуют одну колонку,
 
734
        //внешний цикл колонизации - на каждой итерации MaxLev производитс
 
735
        //попытка разделить те узлы-колонки, которые есть на этом уровне
 
736
        //и для тех узлов-колонок, которые поделились, строим дочерние
 
737
        //узлы-подколонки на следующем уровне MaxLev+1
 
738
        //colnt[k_colnt]   - массив узлов текущего уровня MaxLev
 
739
        //colnt1[k_colnt1] - массив узлов следующего уровня MaxLev+1
 
740
        //colt[k_colt] - массив терминальных колонок
 
741
        //признак конца итераций - на очередном уровне нет узлов, т.е. ни один
 
742
        //из узлов предыдущего уровня не удалось раздробить
743
743
 
744
744
        while(k_colnt >= 0)
745
745
        {
746
 
                if(++MaxLev > MaxAllowLev) //����������� Word-a �� ������� ������
 
746
                if(++MaxLev > MaxAllowLev) //ограничение Word-a на глубину дерева
747
747
                        flTerm=TRUE;
748
748
 
749
 
                k_colnt1=-1; /*����� ����������. ������� ����. ������*/
750
 
                //--���� ������� ��������� ���� ����� �������� ������--
 
749
                k_colnt1=-1; /*Число нетерминал. колонок след. уровня*/
 
750
                //--цикл попытки дробления всех узлов текущего уровня--
751
751
                CONS_MESS1("while....................  k_colnt=%d ",k_colnt);
752
752
 
753
753
                do0(i,0,k_colnt)
754
754
                {
755
755
                        CONS_MESS1("beg......................1 ");
756
756
                        CONS_MESS1("i=%d ",i);
757
 
                        ptr=colnt[i];          //������� ����
758
 
                        left=ptr->InBegFrm;    //������ ������ ����� (���������) ����
759
 
                        kf=ptr->NumFrm-1;      //����� �����(����������)����
760
 
                        ptr->OrderChild=UNSORT;//������� �������, ��� ����� ���� �������������
761
 
                                                                                                                 //���� �� ���� ������� �������, �� �������
762
 
                                                                                                                 //���� ������������ ���������������� ��� ��������
763
 
                                                                                                                 //����� (V- ��� H-�������)
 
757
                        ptr=colnt[i];          //текущий узел
 
758
                        left=ptr->InBegFrm;    //индекс первой рамки (фрагмента) узла
 
759
                        kf=ptr->NumFrm-1;      //число рамок(фрагментов)узла
 
760
                        ptr->OrderChild=UNSORT;//вначале считаем, что рамки узла неупорядочены
 
761
                                                                                                                 //если же узел удастся разбить, то порядок
 
762
                                                                                                                 //узла определяется упорядоченностью его дочерних
 
763
                                                                                                                 //узлов (V- или H-порядок)
764
764
                        CONS_MESS1("(index first fragm)left=%d , (count fragm) kf=%d ",left,kf);
765
 
             //bndc - ����� ����
 
765
             //bndc - рамка узла
766
766
                        if(!fl_beg)
767
 
                                bound_frm(&frm[left],kf,&bndc); //����� ���� ���� ����� �������� � ���� ����� ����������
 
767
                                bound_frm(&frm[left],kf,&bndc); //рамка узла есть рамка входящих в узел рамок фрагментов
768
768
                        else
769
 
                                bndc=BndTxt; //������� ����� ����-����� ���� ����� ����� �����
 
769
                                bndc=BndTxt; //вначале рамка узла-корня есть рамка всего листа
770
770
                        CONS_MESS1("fl_beg=%d, bndc : left=%d,  right=%d,  up=%d,  down=%d",fl_beg,bndc.left,bndc.right,bndc.up,bndc.down);
771
771
                        //---
772
772
                        MaxOld=NumMax;
773
 
                        //-- ������� ��������� ���� ����� ���������� ���������������� --
774
 
                        //   �������: �� ��� Ox ��� order=HOR ��� �� ��� Oy ��� order=VER
775
 
                        //   � ������ �� ��� ����������� �������
 
773
                        //-- попытка разбиение узла путем построения соответствующего --
 
774
                        //   профиля: на ось Ox для order=HOR или на ось Oy для order=VER
 
775
                        //   и поиска на нем межколонных зазоров
776
776
                        if(flTerm)
777
777
                                {fl=kcol=0;}
778
778
                        else
795
795
 
796
796
                        if(!fl && fl_beg)
797
797
                        {
798
 
                        //� I-�� ��� ������� ������������� ����������� ���������,
799
 
                        //���� �� ������� ��������� � ������ �����������
 
798
                        //В I-ый раз пробуем ортогональное направления разбиения,
 
799
                        //если не удалось разбиение в прямом направлении
800
800
 
801
 
                        //������-�� ����� ������� � �������� ���� �� ���������������� �����
802
 
                        //����������� ������� ���������, ���� ��������� ��� �����������,
803
 
                        //� ����� ���� �����������, �� ������� ����� ��������� ������� �����
 
801
                        //вообще-то лучше сделать в корневом узле не предопределенный выбор
 
802
                        //направления первого разбиения, если допустимы оба направления,
 
803
                        //а выбор того направления, на котором между колонками больший зазор
804
804
 
805
805
                                order = order == HOR ? VER:HOR;
806
806
                                MaxOld=NumMax;
817
817
                                return NOT_ALLOC;
818
818
                                }
819
819
                        }
820
 
                        if(fl) //���� ��������� �������, ����������� ���� �������, ������������ ������������ ��������
 
820
                        if(fl) //если разбиение удалось, присваиваем узлу порядок, определяемый направлением разбиени
821
821
                                ptr->OrderChild=order;
822
822
 
823
823
                        if(kcol > 0)
829
829
                                if(fl_beg && ptr->OrderChild == HOR)
830
830
                                        --MaxAllowLev;
831
831
 
832
 
                                //��������� ������� => ������� � ������ �������� ���� ���������� ������� ����
 
832
                                //Разбиение удалось => заносим в дерево дочерний куст подколонок данного узла
833
833
                                PrevChild=NULL;
834
 
                                do0(j,0,kcol) //���� �������� ������� � ������
 
834
                                do0(j,0,kcol) //цикл внесению дочерей в дерево
835
835
                                {
836
 
                                //��������� �������� ���� � ������:
837
 
                                //      ptr - ����-��������
838
 
                                //      PrevChild - ���������� ���
839
 
                                //      Tree.free - ��������� ��������� ������������ ������
 
836
                                //вставляем дочерний узел в дерево:
 
837
                                //      ptr - узел-родитель
 
838
                                //      PrevChild - предыдущее дит
 
839
                                //      Tree.free - свободное списковое пространство дерева
840
840
                                        CONS_MESS1("beg------------------3");
841
841
                                        CONS_MESS1("j=%d",j);
842
842
                                        if((Child=IncKnot(ptr,PrevChild,&Tree.free)) == NULL)
845
845
                                                return -7;
846
846
                                        }
847
847
 
848
 
                                        //����� ���������� ��������� InBegFrm � ����� ���������� NumF ������ �������
 
848
                                        //номер начального фрагмента InBegFrm и число фрагментов NumF данной колонки
849
849
                                        tmp=j ? intr[j-1]+1 : 0;
850
850
                                        InBegFrm=ptr->InBegFrm+tmp;
851
851
                                        NumF=intr[j]-tmp+1;
852
852
                                        CONS_MESS1("InBegFrm=%d ,  NumF=%d",InBegFrm,NumF);
853
 
                                        //--���� ������� ����� ��� ������� ����� ��� ������ �������--
 
853
                                        //--ищем близкие линии или генерим новые для границ колонки--
854
854
                                        bound_frm(&frm[InBegFrm],NumF-1,&b);
855
855
                                        del=begI[j]-(j ? endI[j-1] : 0);
856
856
                                        if(order == HOR)
859
859
                                                CONS_MESS1("order == HOR");
860
860
                                                minz=MIN(ThresX,del);
861
861
                                                if((left= !j ? ptr->Rect.left :
862
 
                                                        AddLine1(&LineVK,&nV,&nVmax,(Int16)endI[j-1],minz)) < 0)
 
862
                                                        AddLine1(&LineVK,&nV,&nVmax,(int16_t)endI[j-1],minz)) < 0)
863
863
                                                {
864
864
                                                        CONS_MESS9("819       left-100");
865
865
                                                        return left-100;
871
871
                                                        return right-200;
872
872
                                                }
873
873
                                        //top=ptr->Rect.top; bottom=ptr->Rect.bottom;
874
 
                                        //!!!��� ������������ ������� ����� �������� � ����� � ����!!!
875
 
                                        //�� ����� �������� ���������� ����� ����� �������
 
874
                                        //!!!для разновысоких колонок можно уточнять и верхи и низы!!!
 
875
                                        //но тогда придется рассчитать рамки новых колонок
876
876
                                                del1=b.down-b.up;
877
877
                                                minz=MIN(ThresY,del1);
878
878
                                                if((top=AddLine1(&LineHK,&nH,&nHmax,b.up,minz)) < 0)
905
905
                                                        return bottom-400;
906
906
                                                }
907
907
                                        //left=ptr->Rect.left; right=ptr->Rect.right;
908
 
                                        //!!!��� ������������ ������� ����� �������� � ������� �����!!!
 
908
                                        //!!!для разношироких колонок можно уточнять и боковые линии!!!
909
909
                                                del1=b.right-b.left;
910
910
                                                minz=MIN(ThresX,del1);
911
911
                                                if((left=AddLine1(&LineVK,&nV,&nVmax,b.left,minz)) < 0)
921
921
                                                CONS_MESS1("end------------------5");
922
922
                                        }
923
923
 
924
 
                                //--���������� ������������ ��������� �������� ��������� � ��������--
925
 
                                //  ������ ��� ������������� �������
926
 
                                        if(left == right) //����� �������
 
924
                                //--разрешение противоречия равенства индексов начальной и конечной--
 
925
                                //  границ для малоразмерных колонок
 
926
                                        if(left == right) //узкая колонка
927
927
                                        {
928
 
                                                CONS_MESS1("left == right <<����� �������>>");
 
928
                                                CONS_MESS1("left == right <<узкая колонка>>");
929
929
                                                if(j != kcol || !fl)
930
930
                                                {
931
931
                                          //minz=fl ? (order==HOR ? begI[j]:b.right) : bnd.right;
947
947
                                                        }
948
948
                                                }
949
949
                                        }
950
 
                                        if(top == bottom) //������ �������
 
950
                                        if(top == bottom) //низкая колонка
951
951
                                        {
952
 
                                                CONS_MESS1("top == bottom <<������ �������>>");
 
952
                                                CONS_MESS1("top == bottom <<низкая колонка>>");
953
953
                                                if(j != kcol || !fl)
954
954
                                                {
955
955
                //                               minz=fl ? (order==VER ? begI[j]:b.down) : bnd.down;
973
973
 
974
974
                                        if(LineVK[left].beg-30 >= LineVK[right].beg ||
975
975
                                                                LineHK[top].beg -10 >= LineHK[bottom].beg)  //LineHK[top].beg >= LineHK[bottom].beg)
976
 
                                                LDPUMA_Console(" ������������ ���������� ���������!!! ");
 
976
                                                LDPUMA_Console(" Неправильные координаты фрагмента!!! ");
977
977
 
978
978
 
979
979
                                        if(LineVK[left].beg-30 >= LineVK[right].beg ||
983
983
                                                return -6;
984
984
                                        }
985
985
 
986
 
                                        //��������� ���� ������ ���� �������
987
 
                                        //!!! ���� left,right,top,bottom ����� ����� �������� ����� ���������
 
986
                                        //заполняем поля нового узла колонки
 
987
                                        //!!! поля left,right,top,bottom имеют смысл индексов линий разграфки
988
988
                                        FillFieldKNOTT1(Child,left,right,top,bottom,
989
989
                                                InBegFrm,NumF,IN_NO,UNSORT,CELL,TRUE,ALG_BEG,ALG_BEG,NULL);
990
990
                                        if(fl)
991
991
                                        {
992
992
                                                if(++k_colnt1 >= NumMax)
993
993
                                                {
994
 
                                                        Int16 old=NumMax;
995
 
                                                        NumMax=(Int16)(NumMax*1.5);
 
994
                                                        int16_t old=NumMax;
 
995
                                                        NumMax=(int16_t)(NumMax*1.5);
996
996
                                                        if(Realloc2(&colt,&colnt,&colnt1,&begI,&endI,&intr,old,NumMax) == NOT_ALLOC)
997
997
                                        {
998
998
                                                                CONS_MESS9("976    NOT_ALLOC");
999
999
                                                                return NOT_ALLOC;
1000
1000
                                                        }
1001
1001
                                                }
1002
 
                                                colnt1[k_colnt1]=Child;//���������� ��������� ����������. �������
 
1002
                                                colnt1[k_colnt1]=Child;//Запоминаем очередную нетерминал. колонку
1003
1003
                                        }
1004
1004
                                PrevChild=Child;
1005
1005
                                        CONS_MESS1("end------------------3");
1006
1006
                                }
1007
1007
                                CONS_MESS1("end------------------2");
1008
1008
                        }
1009
 
                        else /*���������� ��������. �������*/
 
1009
                        else /*Обнаружена терминал. колонка*/
1010
1010
                        {
1011
 
                                CONS_MESS1("���������� ��������. �������");
 
1011
                                CONS_MESS1("Обнаружена терминал. колонка");
1012
1012
                                CONS_MESS1("beg------------------2.1");
1013
1013
                                if(++k_colt >= NumMax)
1014
1014
                                {
1015
 
                                        Int16 old=NumMax;
1016
 
                                        NumMax=(Int16)(NumMax*1.5);
 
1015
                                        int16_t old=NumMax;
 
1016
                                        NumMax=(int16_t)(NumMax*1.5);
1017
1017
                                        if(Realloc2(&colt,&colnt,&colnt1,&begI,&endI,&intr,old,NumMax)
1018
1018
                                        == NOT_ALLOC)
1019
1019
                                        {
1022
1022
                                         }
1023
1023
                                }
1024
1024
                                colt[k_colt]=ptr;
1025
 
                                //��������� ���� ���������� ��������. ����
 
1025
                                //заполняем поля очередного терминал. узла
1026
1026
                                ptr->OrderChild=TERM;
1027
1027
                                colt[k_colt]->InColA=(int)frm[left]->start_pos;
1028
1028
                                CONS_MESS1("end------------------2.1");
1029
1029
                        }
1030
1030
                        CONS_MESS1("end------------------1");
1031
1031
                }
1032
 
                //������������ ���� ���������� ������ � ������� ������� ��� ����.��������
 
1032
                //переписываем узлы следующего уровня в текущий уровень для след.итерации
1033
1033
                do0(i,0,k_colnt1) colnt[i]=colnt1[i];
1034
1034
                k_colnt=k_colnt1;
1035
1035
                fl_beg=0;
1036
 
                order = order==HOR ? VER:HOR;//������ ������� �� ������������� ��� ����.��������
 
1036
                order = order==HOR ? VER:HOR;//меняем порядок на ортогональный для след.итерации
1037
1037
                if(flTerm == TRUE)
1038
1038
                        break;
1039
1039
        } //end of while
1045
1045
        free(endI);
1046
1046
        tmp=k_colt;
1047
1047
 
1048
 
        //��������� ����� ��������� � ������������ �� � ����� ������
 
1048
        //сортируем линии разграфки и перенумеруем их в узлах дерева
1049
1049
        if((fl=SortHorLine1(LineHK,nH,LineVK,nV,Tree.Root,&colt,&k_colt,frm)))
1050
1050
    {
1051
1051
                CONS_MESS9("1047    fl-260");
1059
1059
#ifdef alDebug
1060
1060
        pTheGeomStep = pTheGeomStep2;
1061
1061
        for(i=0; i <= k_colt; ++i)
1062
 
    ImageKnot1(colt[i],LineVK,LineHK,14,(Int16)0xFFFF,_GBORDER,(Int16)-1,frm,NumFrm,nV,nH);
 
1062
    ImageKnot1(colt[i],LineVK,LineHK,14,(int16_t)0xFFFF,_GBORDER,(int16_t)-1,frm,NumFrm,nV,nH);
1063
1063
 
1064
1064
        pTheGeomStep = pTheGeomStep1;
1065
1065
        FlagGraphic1=1;
1067
1067
        fl=ImageTree1(Tree.Root,LineVK,LineHK,frm,NumFrm,nV,nH);
1068
1068
        FlagGraphic1=0;
1069
1069
#endif
1070
 
        //������� � �������� "����������" ��������� ������ � ��� ����������
1071
 
        Inf->Tree=Tree;           //������
 
1070
        //заносим в выходную "деревянную" структуру дерево и его причандалы
 
1071
        Inf->Tree=Tree;           //дерево
1072
1072
        Inf->StatCell=StatCell;   //
1073
 
        Inf->LineVK=LineVK;       //V-��������� ������ LineVK[nV]
 
1073
        Inf->LineVK=LineVK;       //V-разграфка дерева LineVK[nV]
1074
1074
        Inf->nV=nV;               //
1075
 
        Inf->LineHK=LineHK;       //H-��������� ������ LineHK[nH]
 
1075
        Inf->LineHK=LineHK;       //H-разграфка дерева LineHK[nH]
1076
1076
        Inf->nH=nH;               //
1077
 
        Inf->ColT=colt;           //��������. ������� ������ colt[NumT]
 
1077
        Inf->ColT=colt;           //терминал. колонки дерева colt[NumT]
1078
1078
        Inf->NumT=k_colt;         //
1079
1079
        if(!(Inf->bnd_col=(BOUND*)malloc((k_colt+1)*sizeof(BOUND))))
1080
1080
        {
1084
1084
 
1085
1085
        for(i=0; i <= k_colt; ++i)
1086
1086
        {
1087
 
                Int16 in;
 
1087
                int16_t in;
1088
1088
 
1089
1089
                in=colt[i]->InColA;
1090
1090
                colt[i]->AllowOCR=1;
1101
1101
}
1102
1102
 
1103
1103
//Return:
1104
 
// >= 0 - ����� ������������ ����� ������� ������� � ������ Thres (�� ������)
1105
 
//        ��� ������������� ����� (�� ������)
 
1104
// >= 0 - среди существующих линий найдена близкая в смысле Thres (ее индекс)
 
1105
//        или сгенерирована новая (ее индекс)
1106
1106
// < 0 - ERR
1107
 
//����:               Coor - x-����-�� ��� V-����� ��� y-����-�� ��� H-�����
1108
 
//                                                                              Thres - ����� �������� �������������� �����
1109
 
//�������� ���������: Line1[nCurr] - ������� �����
1110
 
//                    nMax - ������������ ����� �����
 
1107
//Вход:               Coor - x-коор-та для V-линии или y-коор-та для H-линии
 
1108
//                                                                              Thres - порог грубости отождествления линий
 
1109
//Обменные параметры: Line1[nCurr] - система линий
 
1110
//                    nMax - максимальное число линий
1111
1111
//==
1112
 
Int16 AddLine1(LINE_KNOT **Line1,Int16 *nCurr,Int16 *nMax,Int16 Coor,Int16 Thres)
 
1112
int16_t AddLine1(LINE_KNOT **Line1,int16_t *nCurr,int16_t *nMax,int16_t Coor,int16_t Thres)
1113
1113
//==
1114
1114
{
1115
 
        Int16 i,fl=-1,n; LINE_KNOT *Line=*Line1;
 
1115
        int16_t i,fl=-1,n; LINE_KNOT *Line=*Line1;
1116
1116
        for(i=0; i < *nCurr; ++i)
1117
1117
                if(abs(Line[i].beg-Coor) < Thres)
1118
1118
                        return i;
1119
1119
 
1120
1120
        n=*nCurr;//Add new Line
1121
 
        if(n >= *nMax) //��������� ������������ ������� �����
 
1121
        if(n >= *nMax) //обработка переполнение массива линий
1122
1122
        {
1123
 
                *nMax=(Int16)(*nMax*1.5);
 
1123
                *nMax=(int16_t)(*nMax*1.5);
1124
1124
                if((Line=(LINE_KNOT*)realloc_m(Line,n*sizeof(LINE_KNOT),*nMax*sizeof(LINE_KNOT))
1125
1125
                )==NULL)
1126
1126
                        return NOT_ALLOC;
1132
1132
        return n;
1133
1133
}
1134
1134
 
1135
 
/*������������� ����� �� �������� ����� ���������� ��������� �����������
1136
 
�������� ������������� ��������
1137
 
����: frm[k_frm] - ����� ��������� (����������);
1138
 
      bnd - �������� �������� ����;
1139
 
      ave_x,ave_y - ������� ��������� ����� ����������;
1140
 
                        NumMax - ��������.����� �������
1141
 
�����:frm[k_frm]  - ����� ��������������� ���������, ���� ������� ����������;
1142
 
      intr1[kcol] - ������ ������� ��������� ������� � ������� frm,
1143
 
      begI,endI   - �������������� ������� ��������. ����������
 
1135
/*Классификация рамок по колонкам после устранения перекосов рекурсивным
 
1136
делением ортогональных профилей
 
1137
Вход: frm[k_frm] - рамки компонент (фрагментов);
 
1138
      bnd - габариты текущего узла;
 
1139
      ave_x,ave_y - среднее габаритов рамки компоненты;
 
1140
                        NumMax - максимал.число колонок
 
1141
Выход:frm[k_frm]  - рамки переупорядочены поколонно, если колонки обнаружены;
 
1142
      intr1[kcol] - правые границы найденных колонок в массиве frm,
 
1143
      begI,endI   - геометрические границы межколон. интервалов
1144
1144
Return:
1145
 
   0 - ���� ������� �� ����������,
1146
 
   kcol, ���� ����������,
 
1145
   0 - если колонки не обнаружены,
 
1146
   kcol, если обнаружены,
1147
1147
   < 0 - ERR*/
1148
1148
 
1149
1149
//==
1150
 
Int16 SearchColHist1(FRAME **frm,Int16 k_frm,BOUND *bnd,Int16 ave_x,Int16 ave_y,
1151
 
    Int16 reg,Int16 *k_int,Int16 **intr1,Int16 **begI,Int16 **endI,Int16 *NumMax)
 
1150
int16_t SearchColHist1(FRAME **frm,int16_t k_frm,BOUND *bnd,int16_t ave_x,int16_t ave_y,
 
1151
    int16_t reg,int16_t *k_int,int16_t **intr1,int16_t **begI,int16_t **endI,int16_t *NumMax)
1152
1152
//==
1153
1153
{
1154
 
        Int16 ave_dir,ave_ort,i,kcol,x,in,kf,fl,ki,MaxOld=*NumMax;
 
1154
        int16_t ave_dir,ave_ort,i,kcol,x,in,kf,fl,ki,MaxOld=*NumMax;
1155
1155
        int k_bloc;
1156
 
        Int16 *intr=*intr1;
 
1156
        int16_t *intr=*intr1;
1157
1157
        KNOT4 *Free,**knot,**beg=(KNOT4**)malloc(*NumMax*sizeof(PTR)),*ptr;
1158
1158
 
1159
1159
        CONS_MESS3("===beg    SearchColHist1   ===");
1178
1178
        }
1179
1179
        if(MaxOld != *NumMax)
1180
1180
        {
1181
 
                if((intr=(Int16*)realloc_m(intr,MaxOld*sizeof(Int16),*NumMax*sizeof(Int16)))==NULL ||
 
1181
                if((intr=(int16_t*)realloc_m(intr,MaxOld*sizeof(int16_t),*NumMax*sizeof(int16_t)))==NULL ||
1182
1182
                (beg=(KNOT4**)realloc_m(beg,MaxOld*sizeof(PTR),*NumMax*sizeof(PTR)))==NULL)
1183
1183
                        return NOT_ALLOC;
1184
1184
        }
1196
1196
                return -fl-50;
1197
1197
 
1198
1198
        CONS_MESS3("k_frm=%d",k_frm);
1199
 
        do0(i,0,k_frm) /*��������� ����� � ������ �������*/
 
1199
        do0(i,0,k_frm) /*занесение рамок в списки колонок*/
1200
1200
        {
1201
1201
                x=(reg==HOR) ? frm[i]->left: frm[i]->up;
1202
1202
                if(kcol < 2)
1232
1232
}
1233
1233
 
1234
1234
 
1235
 
/*����� ������� �� ��������� ���� ����������� - ������� ��������� ������ ����
1236
 
        ������� ������� ������
1237
 
����: frm[k_frm] - ����� ��������� (����������);
1238
 
      bnd - �������� �������� ����;
1239
 
                        ave_dir,ave_ort - ������� ������� �����-���������� � ������ � ���������������� ����.
1240
 
                        NumMax - ��������.����� �������
1241
 
      reg - ����� ����������� (HOR - �������������-������������� �������,
1242
 
                               VER - ����������� --//--).
1243
 
�����:frm[k_frm]  - ����� ��������������� ���������, ���� ������� ����������;
1244
 
      intr1[kcol] - ������ ������� ��������� ������� � ������� frm,
1245
 
      beg1,end1   - [k_int1] �������������� ������� ��������. ����������
1246
 
�����:intr[k_int1]-�������� ��������� ����������� ����������
1247
 
reg=HOR - ���� ��������. ������������� �������,VER - �����������-�������������
 
1235
/*Поиск колонок по вертикали либо горизонтали - функция разбиения одного узла
 
1236
        методом анализа профил
 
1237
Вход: frm[k_frm] - рамки компонент (фрагментов);
 
1238
      bnd - габариты текущего узла;
 
1239
                        ave_dir,ave_ort - среднее размера буквы-компоненты в прямом и перпендикулярном напр.
 
1240
                        NumMax - максимал.число колонок
 
1241
      reg - режим колонизации (HOR - горизонтально-упорядоченные колонки,
 
1242
                               VER - вертикально --//--).
 
1243
Выход:frm[k_frm]  - рамки переупорядочены поколонно, если колонки обнаружены;
 
1244
      intr1[kcol] - правые границы найденных колонок в массиве frm,
 
1245
      beg1,end1   - [k_int1] геометрические границы межколон. интервалов
 
1246
Выход:intr[k_int1]-середины найденных межколонных интервалов
 
1247
reg=HOR - ищем горизонт. упорядоченные колонки,VER - вертикально-упорядоченные
1248
1248
Return:
1249
 
  0 - ��������� �� ���������,
1250
 
  1 - ��������� ���������,
 
1249
  0 - разбиение не произошло,
 
1250
  1 - разбиение произошло,
1251
1251
  < 0 - ERR*/
1252
1252
 
1253
1253
//===
1254
 
Int16 SearchInterval1(FRAME **frm,Int16 k_frm,Int16 **beg1,Int16 **end1,
1255
 
    Int16 *k_int1,BOUND *bnd,Int16 ave_dir,Int16 ave_ort,Int16 reg,Int16 *NumMax)
 
1254
int16_t SearchInterval1(FRAME **frm,int16_t k_frm,int16_t **beg1,int16_t **end1,
 
1255
    int16_t *k_int1,BOUND *bnd,int16_t ave_dir,int16_t ave_ort,int16_t reg,int16_t *NumMax)
1256
1256
//===
1257
1257
{
1258
 
        Int16 k_int,pos,min_col,min_int,maxh,minh,midh,kstr,len,len_group,i,j;
1259
 
        Int16 beg_int,end_int,sumh,ave_h,mi,ma,Home,Fin;
1260
 
        Int16 *his,*his_first_group,*his_second_group,last_real_line,
 
1258
        int16_t k_int,pos,min_col,min_int,maxh,minh,midh,kstr,len,len_group,i,j;
 
1259
        int16_t beg_int,end_int,sumh,ave_h,mi,ma,Home,Fin;
 
1260
        int16_t *his,*his_first_group,*his_second_group,last_real_line,
1261
1261
                    *Beg=*beg1,*End=*end1,tmp_pos;
1262
1262
 
1263
 
        //--������ ���������� ���������� �����������--
1264
 
        min_col=1;//�����. ����� ������� � ��������
1265
 
        min_int=ave_dir*2;//�����. ����� ��������� � ��������
1266
 
        maxh   =0;//����.���������� ������ ����������� � ���������-�������� �������.������ ���������
1267
 
        midh   =0;//����.���������� ������� ������ ����-�� � ���������
1268
 
        minh   =1;//���.���������� ������ ����������� � �������-�������� �������.������ �������
1269
 
            //����� ���������� ��������� � � ������ ���� �����
 
1263
        //--Расчет параметров одномерной колонизации--
 
1264
        min_col=1;//миним. длина колонки в пикселах
 
1265
        min_int=ave_dir*2;//миним. длина интервала в пикселах
 
1266
        maxh   =0;//Макс.допустимая высота гистограммы в интервале-критерий обнаруж.начала интервала
 
1267
        midh   =0;//Макс.допустимая средняя высота гист-мы в интервале
 
1268
        minh   =1;//Мин.допустимая высота гистограммы в колонке-критерий обнаруж.начала колонки
 
1269
            //после настоящего интервала и с левого края листа
1270
1270
 
1271
1271
        if(reg==HOR)
1272
1272
                min_int=5;/*ave_dir * 1.5*/;  //~~~
1286
1286
                CONS_MESS2("reg==VER; Home=%d; Fin=%d;",Home,Fin);
1287
1287
        }
1288
1288
 
1289
 
        //������ ����� �����(HOR)����� /������ ����� � ��������(VER)
1290
 
        kstr = (Int16) (reg==HOR ? (bnd->down-bnd->up)/(2*ave_ort) :
 
1289
        //Оценка числа строк(HOR)листа /ширины листа в символах(VER)
 
1290
        kstr = (int16_t) (reg==HOR ? (bnd->down-bnd->up)/(2*ave_ort) :
1291
1291
                   (bnd->right-bnd->left)/(1.2*ave_ort));
1292
 
  //--���������� �������-����������� ����� ���������, �������������� � ������ ������--
1293
 
        len=Fin-Home+2;//����� �����������
 
1292
  //--Вычисление профиля-гистограммы числа компонент, проецирующихся в данный пиксел--
 
1293
        len=Fin-Home+2;//длина гистограммы
1294
1294
        CONS_MESS2("kstr=%d  len_hist=%d",kstr,len);
1295
 
        if( (his=(Int16*)malloc(len*sizeof(Int16))) == NULL)
 
1295
        if( (his=(int16_t*)malloc(len*sizeof(int16_t))) == NULL)
1296
1296
                return NOT_ALLOC;
1297
 
        memset(his,0,len*sizeof(Int16));
 
1297
        memset(his,0,len*sizeof(int16_t));
1298
1298
        --len;
1299
1299
 
1300
1300
        if(reg==VER)
1304
1304
                        CONS_MESS21("begin len_group=%d ",len_group);
1305
1305
                        len_group=0;
1306
1306
                }
1307
 
                if((his_first_group=(Int16*)malloc((len_group+4)*sizeof(Int16))) == NULL)
 
1307
                if((his_first_group=(int16_t*)malloc((len_group+4)*sizeof(int16_t))) == NULL)
1308
1308
                        return NOT_ALLOC;
1309
 
                if((his_second_group=(Int16*)malloc((len_group+4)*sizeof(Int16))) == NULL)
 
1309
                if((his_second_group=(int16_t*)malloc((len_group+4)*sizeof(int16_t))) == NULL)
1310
1310
                        return NOT_ALLOC;
1311
1311
                last_real_line=0;
1312
1312
                --len_group;
1355
1355
        }
1356
1356
#ifdef alDebug
1357
1357
        *CountRect = pTheGeomTemp->size();
1358
 
        CONS_MESS2("---����� ��������. ����������---");
 
1358
        CONS_MESS2("---Поиск межколон. интервалов---");
1359
1359
        if(det0) MyDrawForDebug();
1360
1360
#endif
1361
 
        //--����� ��������. ����������--
 
1361
        //--Поиск межколон. интервалов--
1362
1362
        k_int=-1; pos=-1;
1363
 
        while((Int16)his[++pos] < minh) /*����� I ������� ������*/
 
1363
        while((int16_t)his[++pos] < minh) /*поиск I позиции текста*/
1364
1364
    {
1365
1365
                if(pos>=len)
1366
1366
            {
1371
1371
                        }
1372
1372
                        free(his);
1373
1373
                        *k_int1=-1;
1374
 
                        CONS_MESS2("===������� �� ����������===");
 
1374
                        CONS_MESS2("===колонки не обнаружены===");
1375
1375
                        return 0;
1376
 
                } /*������� �� ����������*/
 
1376
                } /*колонки не обнаружены*/
1377
1377
        }
1378
1378
 
1379
1379
        do
1380
 
        { /*���� I ������� ���������*/
1381
 
                while(pos < len-min_int-min_col && (Int16)his[++pos] > maxh);
 
1380
        { /*ищем I позицию интервала*/
 
1381
                while(pos < len-min_int-min_col && (int16_t)his[++pos] > maxh);
1382
1382
                if(pos >= len-min_int-min_col)
1383
1383
            {
1384
1384
                        CONS_MESS2("!!!!!! pos >= len-min_int-min_col");
1385
1385
                        break;
1386
1386
                }
1387
1387
                beg_int=pos;
1388
 
    /*���� ������������������ �� ����� ��� min_int ������� < maxh*/
1389
 
                while((Int16)his[++pos] <= maxh)
 
1388
    /*ищем последовательность не менее чем min_int высотой < maxh*/
 
1389
                while((int16_t)his[++pos] <= maxh)
1390
1390
                        if(pos >= len || pos-beg_int >= min_int)
1391
1391
                                break;
1392
1392
                if(pos - beg_int < min_int &&
1401
1401
                do0(i,beg_int,pos)   sumh+=his[i];
1402
1402
                ave_h=sumh/(pos-beg_int+1);
1403
1403
                CONS_MESS2("ave_h=%d",ave_h);
1404
 
                if(ave_h <= midh)/*�������� ������, ���� ��� �����*/
 
1404
                if(ave_h <= midh)/*интервал найден, ищем его конец*/
1405
1405
                {
1406
 
                        while((Int16)his[++pos] <= maxh)
 
1406
                        while((int16_t)his[++pos] <= maxh)
1407
1407
                        {
1408
1408
                                sumh+=his[pos];
1409
1409
                                ave_h=sumh/(pos-beg_int+1);
1410
1410
                                if(ave_h > midh || pos >= len-min_col)
1411
 
                                        break; /*��������� ����� ���������*/
 
1411
                                        break; /*Обнаружен конец интервала*/
1412
1412
                        }
1413
1413
                        end_int=pos;
1414
1414
 
1429
1429
                        if(det0) MyDrawForDebug();
1430
1430
                #endif
1431
1431
 
1432
 
                        if(pos < len-min_col) //�� ����������� �������� - �.�. ��� �� ������ �������
 
1432
                        if(pos < len-min_col) //не тривиальный интервал - т.е. еще не правая граница
1433
1433
                        {
1434
1434
                                Beg[++k_int]=beg_int+Home;
1435
1435
                                End[k_int]=end_int+Home;
1436
 
        //��������� �������� ���� � ������ ����������� ����� �������
 
1436
        //Фиксируем интервал лишь в случае достаточной длины колонки
1437
1437
                                if((k_int > 0 && Beg[k_int] - End[k_int-1] < min_col) ||
1438
1438
                                (Beg[k_int] - Home < min_col))
1439
1439
                                {
1440
1440
                                        --k_int;
1441
 
                                        CONS_MESS2(" ������� �����,�������� �� �����������! ");
 
1441
                                        CONS_MESS2(" колонка узкая,интервал не принимается! ");
1442
1442
                                    continue;
1443
1443
                                }
1444
1444
                                last_real_line=end_int;
1445
1445
                                if(k_int > *NumMax-2)
1446
1446
                                {
1447
 
                                        Int16 MaxOld=*NumMax;
1448
 
                                        *NumMax=(Int16)(*NumMax*1.5);
1449
 
                                        if((Beg=(Int16*)realloc_m(Beg,MaxOld*sizeof(Int16),*NumMax*sizeof(Int16)))==NULL ||
1450
 
                                        (End=(Int16*)realloc_m(End,MaxOld*sizeof(Int16),*NumMax*sizeof(Int16)))==NULL)
 
1447
                                        int16_t MaxOld=*NumMax;
 
1448
                                        *NumMax=(int16_t)(*NumMax*1.5);
 
1449
                                        if((Beg=(int16_t*)realloc_m(Beg,MaxOld*sizeof(int16_t),*NumMax*sizeof(int16_t)))==NULL ||
 
1450
                                        (End=(int16_t*)realloc_m(End,MaxOld*sizeof(int16_t),*NumMax*sizeof(int16_t)))==NULL)
1451
1451
                                        {
1452
1452
                                                free(his);
1453
1453
                                                if(reg==VER)
1460
1460
                                }
1461
1461
                        }
1462
1462
                }
1463
 
                pos+=min_col; /*��� ��������� ������ �������,���� end_pos - ������ ���������*/
 
1463
                pos+=min_col; /*для попадания внутрь колонки,если end_pos - внутри интервала*/
1464
1464
        } while(pos < len-min_int-min_col);
1465
1465
        free(his);
1466
1466
        if(reg==VER)
1478
1478
 
1479
1479
//////////////        Check_IsItFalseHorLine
1480
1480
////
1481
 
Int16 Check_IsItFalseHorLine(Int16 last_real_line,Int16 reg,FRAME **frm,Int16 *his,Int16 pos,
1482
 
                                                                                                                 Int16 len,Int16 maxh,Int16 sum,Int16 len_group,
1483
 
                                                                                                                 Int16 *his_first_group,
1484
 
                                                                                                                 Int16 *his_second_group,BOUND *bnd,Int16 k_frm)
 
1481
int16_t Check_IsItFalseHorLine(int16_t last_real_line,int16_t reg,FRAME **frm,int16_t *his,int16_t pos,
 
1482
                                                                                                                 int16_t len,int16_t maxh,int16_t sum,int16_t len_group,
 
1483
                                                                                                                 int16_t *his_first_group,
 
1484
                                                                                                                 int16_t *his_second_group,BOUND *bnd,int16_t k_frm)
1485
1485
{
1486
 
        Int16 Home,Fin,old_pos,i,j,mi,ma,beg_white_int,end_white_int,k_frm_first,k_frm_second;
 
1486
        int16_t Home,Fin,old_pos,i,j,mi,ma,beg_white_int,end_white_int,k_frm_first,k_frm_second;
1487
1487
        std::vector<tagRECT>  First_Group;
1488
1488
        std::vector<tagRECT>  Second_Group;
1489
1489
 
1508
1508
        k_frm_first=First_Group.size()-1;
1509
1509
        CONS_MESS2(" new_count_frm-first=%d ",k_frm_first+1);
1510
1510
 
1511
 
        memset(his_first_group,0,(len_group+1)*sizeof(Int16));
 
1511
        memset(his_first_group,0,(len_group+1)*sizeof(int16_t));
1512
1512
        do0(i,0,k_frm_first)
1513
1513
        {
1514
1514
                mi=First_Group[i].left  - Home;
1524
1524
 
1525
1525
////////////////////////// Second_Group   ////////////////////////////////////////////////
1526
1526
        old_pos=pos;
1527
 
        while(pos <= len  && (Int16)his[++pos] > maxh);
 
1527
        while(pos <= len  && (int16_t)his[++pos] > maxh);
1528
1528
        CONS_MESS2("Second_Group new pos = %d",pos);
1529
1529
        do0(i,0,k_frm)
1530
1530
        {
1539
1539
        k_frm_second=Second_Group.size()-1;
1540
1540
        CONS_MESS2("Second_Group new_count_frm=%d ",k_frm_second+1);
1541
1541
 
1542
 
        memset(his_second_group,0,(len_group+1)*sizeof(Int16));
 
1542
        memset(his_second_group,0,(len_group+1)*sizeof(int16_t));
1543
1543
        do0(i,0,k_frm_second)
1544
1544
        {
1545
1545
                mi=Second_Group[i].left -Home;
1555
1555
/////////  Compary white intervals //////////////////////////////
1556
1556
        do0(i,0,len_group)
1557
1557
        {
1558
 
                while(i<= len_group && (Int16)his_first_group[++i] <= maxh);
1559
 
                while(i<= len_group && (Int16)his_first_group[++i] >  maxh);
 
1558
                while(i<= len_group && (int16_t)his_first_group[++i] <= maxh);
 
1559
                while(i<= len_group && (int16_t)his_first_group[++i] >  maxh);
1560
1560
                if(i>=len_group)
1561
1561
                        break;
1562
1562
 
1563
 
                while(i<= len_group && (Int16)his_first_group[++i] > maxh);
 
1563
                while(i<= len_group && (int16_t)his_first_group[++i] > maxh);
1564
1564
                beg_white_int=i;
1565
1565
                CONS_MESS2("First Group beg_white_int=%d ",i);
1566
 
                while(i<= len_group && (Int16)his_first_group[++i] <= maxh);
 
1566
                while(i<= len_group && (int16_t)his_first_group[++i] <= maxh);
1567
1567
                end_white_int=i;
1568
1568
                if(end_white_int>=len_group)
1569
1569
                        break;
1583
1583
 
1584
1584
        do0(i,0,len_group)
1585
1585
        {
1586
 
                while(i<= len_group && (Int16)his_second_group[++i] <= maxh);
1587
 
                while(i<= len_group && (Int16)his_second_group[++i] >  maxh);
 
1586
                while(i<= len_group && (int16_t)his_second_group[++i] <= maxh);
 
1587
                while(i<= len_group && (int16_t)his_second_group[++i] >  maxh);
1588
1588
                if(i>=len_group)
1589
1589
                        break;
1590
1590
 
1591
 
                while(i<= len_group && (Int16)his_second_group[++i] > maxh);
 
1591
                while(i<= len_group && (int16_t)his_second_group[++i] > maxh);
1592
1592
                beg_white_int=i;
1593
1593
                CONS_MESS2("Second Group beg_white_int=%d ",i);
1594
1594
 
1595
 
                while(i<= len_group && (Int16)his_second_group[++i] <= maxh);
 
1595
                while(i<= len_group && (int16_t)his_second_group[++i] <= maxh);
1596
1596
                end_white_int=i;
1597
1597
                if(end_white_int>=len_group)
1598
1598
                        break;
1620
1620
        return 0;
1621
1621
}
1622
1622
 
1623
 
Int16 check_white_int(Int16 beg_white_int,Int16 end_white_int,Int16 maxh,
1624
 
                                                                                        Int16 *his_second_group)
 
1623
int16_t check_white_int(int16_t beg_white_int,int16_t end_white_int,int16_t maxh,
 
1624
                                                                                        int16_t *his_second_group)
1625
1625
{
1626
 
 Int16 i,count_white_picsels=0;
 
1626
 int16_t i,count_white_picsels=0;
1627
1627
 
1628
1628
 do0(i,beg_white_int,end_white_int)
1629
1629
 {
1630
 
  if((Int16)his_second_group[++i] <= maxh) ++count_white_picsels;
 
1630
  if((int16_t)his_second_group[++i] <= maxh) ++count_white_picsels;
1631
1631
 }
1632
1632
 if (count_white_picsels>=2)
1633
1633
         return 1;
1636
1636
}
1637
1637
 
1638
1638
 
1639
 
/*�������� ���� � ������ ����� ��������� ��-�� after ����-�������� up:
1640
 
���� after=NULL, ��������� � ������ ������ ������� ���� up,
1641
 
���� up=NULL, ������� ������ ������,
1642
 
up - ����-�������� �� ������,
1643
 
after - ����-����, ����� ���. ������� �������� ����� ����,
1644
 
free - ������ ������ ������ ������. ������ ������*/
1645
 
//============return: ��������� �� ����� �������. � ������ ���� ��� NULL
 
1639
/*Добавить узел в дерево после дочернего эл-та after узла-родителя up:
 
1640
если after=NULL, добавляем в начало списка дочерей узла up,
 
1641
если up=NULL, создаем корень дерева,
 
1642
up - узел-родитель по дереву,
 
1643
after - узел-дочь, после кот. следует вставить новый узел,
 
1644
free - голова общего списка свобод. памяти дерева*/
 
1645
//============return: указатель на новый включен. в дерево узел или NULL
1646
1646
KNOTT* IncKnot(KNOTT *up,KNOTT *after,KNOTT **free)
1647
1647
//==
1648
1648
{ KNOTT *New;
1657
1657
        }
1658
1658
        else
1659
1659
        { New=NULL;
1660
 
          New=(KNOTT*)inc_lst((KNOT**)&New,(KNOT**)free);//������
 
1660
          New=(KNOTT*)inc_lst((KNOT**)&New,(KNOT**)free);//корень
1661
1661
        }
1662
1662
        New->up=up; New->down=NULL;
1663
1663
        return New;
1664
1664
}
1665
 
//===���������� ����� ���� KNOTT ���������. ������ TREE2
1666
 
void FillFieldKNOTT1(KNOTT *ptr,Int16 Left,Int16 Right,Int16 Top,Int16 Bottom,
1667
 
  Int16 InBegFrm,Int16 NumFrm,Int16 InColA,
 
1665
//===Заполнение полей узла KNOTT ортогонал. дерева TREE2
 
1666
void FillFieldKNOTT1(KNOTT *ptr,int16_t Left,int16_t Right,int16_t Top,int16_t Bottom,
 
1667
  int16_t InBegFrm,int16_t NumFrm,int16_t InColA,
1668
1668
  uint OrderChild,uint Type,uint AllowOCR,uint JustH,uint JustV,char *Name)
1669
1669
//==
1670
1670
{
1671
 
        ptr->Rect.top=Top;          //������ ����� - ������� �������
1672
 
        ptr->Rect.bottom=Bottom;    //--/-- ������
1673
 
        ptr->Rect.left=Left;        //--/-- �����
1674
 
        ptr->Rect.right=Right;      //--/-- ������
1675
 
        ptr->InBegFrm=InBegFrm;     //������ �����. ��������� �������
1676
 
        ptr->NumFrm=NumFrm;         //����� ���������� ������� (��������� ����� ������� ���� � ������� frm ������)
1677
 
        ptr->InColA=InColA;         //������ ������� ��������� ������ �������
1678
 
        ptr->OrderChild=OrderChild; //������� ������� ����
 
1671
        ptr->Rect.top=Top;          //индекс линии - верхней границы
 
1672
        ptr->Rect.bottom=Bottom;    //--/-- нижней
 
1673
        ptr->Rect.left=Left;        //--/-- левой
 
1674
        ptr->Rect.right=Right;      //--/-- правой
 
1675
        ptr->InBegFrm=InBegFrm;     //индекс начал. фрагмента колонки
 
1676
        ptr->NumFrm=NumFrm;         //число фрагментов колонки (фрагменты одной колонки идут в массиве frm подряд)
 
1677
        ptr->InColA=InColA;         //индекс первого фрагмента данной колонки
 
1678
        ptr->OrderChild=OrderChild; //порядок дочерей узла
1679
1679
        ptr->Type=Type;             //
1680
1680
        ptr->AllowOCR=AllowOCR;     //
1681
1681
        ptr->JustH=JustH;           //
1684
1684
        ptr->RefOrt=ptr->RefH=NULL; //
1685
1685
}
1686
1686
//==
1687
 
Int16 compINDEX_SORT1(INDEX_SORT *a,INDEX_SORT *b)
 
1687
int16_t compINDEX_SORT1(INDEX_SORT *a,INDEX_SORT *b)
1688
1688
//==
1689
1689
        {return (a->value >= b->value ? 1:-1);}
1690
1690
//==
1691
 
Int16 compLINE_KNOT1(LINE_KNOT *a,LINE_KNOT *b)
 
1691
int16_t compLINE_KNOT1(LINE_KNOT *a,LINE_KNOT *b)
1692
1692
//==
1693
1693
        {return (a->beg >= b->beg ? 1:-1);}
1694
 
//���������� H-����� ������ �� ���������
1695
 
//� �������� ���������� ������� ��������. V-������� (k_colt1 - ������)
1696
 
//���� V-����� �� �����������, ��� ����� ����������
 
1694
//сортировка H-линий дерева по вертикали
 
1695
//и попутное заполнение массива терминал. V-колонок (k_colt1 - индекс)
 
1696
//если V-линии не упорядочены, они также сортируютс
1697
1697
//==
1698
 
Int16 SortHorLine1(LINE_KNOT *LineHK,Int16 NumH,LINE_KNOT *LineVK,Int16 NumV,
1699
 
    KNOTT *Root,KNOTT ***colt1,Int16 *k_colt1,FRAME **frm)
 
1698
int16_t SortHorLine1(LINE_KNOT *LineHK,int16_t NumH,LINE_KNOT *LineVK,int16_t NumV,
 
1699
    KNOTT *Root,KNOTT ***colt1,int16_t *k_colt1,FRAME **frm)
1700
1700
//==
1701
1701
{
1702
1702
        INDEX_SORT *Ind=(INDEX_SORT *)malloc(MAX(NumH,NumV)*sizeof(INDEX_SORT));
1703
1703
  STAT_CELL StDefault;
1704
 
  Int16 *Index=(Int16 *)malloc(NumH*sizeof(Int16)),
1705
 
        *IndexV=(Int16 *)malloc(NumV*sizeof(Int16));
1706
 
  Int16 i,DepthTree=20,flV;
 
1704
  int16_t *Index=(int16_t *)malloc(NumH*sizeof(int16_t)),
 
1705
        *IndexV=(int16_t *)malloc(NumV*sizeof(int16_t));
 
1706
  int16_t i,DepthTree=20,flV;
1707
1707
  STACK St;
1708
1708
        KNOTT *Curr,**colt;
1709
 
        Int16 k_colt;
 
1709
        int16_t k_colt;
1710
1710
 
1711
1711
        StDefault.dyLow=NORM_SCAN(20);
1712
 
  //--���������� H-�����--
 
1712
  //--сортировка H-линий--
1713
1713
  for(i=0; i < NumH; ++i) {Ind[i].ind=i;Ind[i].value=LineHK[i].beg;}
1714
1714
  u4sort(Ind,NumH,sizeof(INDEX_SORT),(COMP_FUN)compINDEX_SORT1);
1715
1715
  u4sort(LineHK,NumH,sizeof(LINE_KNOT),(COMP_FUN)compLINE_KNOT1);
1716
1716
  for(i=0; i < NumH; ++i) Index[Ind[i].ind]=i;
1717
 
  //--���������� V-�����--
 
1717
  //--сортировка V-линий--
1718
1718
  flV=0;
1719
1719
  for(i=0; i < NumV; ++i)
1720
1720
  { Ind[i].ind=i;Ind[i].value=LineVK[i].beg;
1721
1721
    if(i && LineVK[i-1].beg > LineVK[i].beg) flV=1;
1722
1722
  }
1723
 
  if(flV)//V-����� �������������
 
1723
  if(flV)//V-линии неупорядочены
1724
1724
  { u4sort(Ind,NumV,sizeof(INDEX_SORT),(COMP_FUN)compINDEX_SORT1);
1725
1725
    u4sort(LineVK,NumV,sizeof(LINE_KNOT),(COMP_FUN)compLINE_KNOT1);
1726
1726
  }
1727
1727
  for(i=0; i < NumV; ++i) IndexV[Ind[i].ind]=i;
1728
1728
  free(Ind);
1729
 
  if(NewStack(DepthTree,&St)) //������� ���� ��� ������ ������
 
1729
  if(NewStack(DepthTree,&St)) //создать стек для обхода дерева
1730
1730
                return NOT_ALLOC;
1731
1731
 
1732
1732
        Curr=Root; k_colt=0;
1733
 
  while(Curr != NULL)//I ������ TREE-������������� H-����� � ������ ����� TERM Cell
 
1733
  while(Curr != NULL)//I проход TREE-перенумерация H-линий и расчет числа TERM Cell
1734
1734
  {
1735
1735
                Curr->Rect.top=Index[Curr->Rect.top];
1736
1736
    Curr->Rect.bottom=Index[Curr->Rect.bottom];
1738
1738
    Curr->Rect.right=IndexV[Curr->Rect.right];
1739
1739
    if(Curr->NumFrm > 0)
1740
1740
                        ++k_colt;
1741
 
    Curr=NextKnot(Curr,&St); //������� � ���������� ����
1742
 
    if(OverflowStack(&St)) //�������� ������������ �����
 
1741
    Curr=NextKnot(Curr,&St); //перейти к следующему узлу
 
1742
    if(OverflowStack(&St)) //проверка переполнения стека
1743
1743
                        return NOT_ALLOC;
1744
1744
  }
1745
1745
 
1746
1746
        if((colt=(KNOTT**)malloc(k_colt*sizeof(KNOTT*))) == NULL)
1747
1747
                return NOT_ALLOC;
1748
 
  ClearStack(&St);//��� ������.������� �� ������ ������ ����
 
1748
  ClearStack(&St);//Для повтор.прохода по дереву чистим стек
1749
1749
  Curr=Root;
1750
1750
        k_colt=-1;
1751
1751
  #define VER_ORDER_QUE_STR
1752
1752
  #ifdef VER_ORDER_QUE_STR
1753
 
          while(Curr != NULL)//II ������ - ���������� ������� TERM Cell
 
1753
          while(Curr != NULL)//II проход - заполнение массива TERM Cell
1754
1754
          { if(Curr->down == NULL && Curr->AllowOCR && Curr->InBegFrm != IN_NO &&
1755
1755
              Curr->NumFrm > 0)
1756
1756
                                colt[++k_colt]=Curr;
1758
1758
          }
1759
1759
  #else
1760
1760
          while(Curr != NULL)
1761
 
          { if(Curr->InBegFrm == IN_NO && Curr->down == NULL) //����. H-����
 
1761
          { if(Curr->InBegFrm == IN_NO && Curr->down == NULL) //Терм. H-узел
1762
1762
            { while(CurrV)
1763
1763
              { if(CurrV->down == NULL && CurrV->AllowOCR && CurrV->InBegFrm != IN_NO &&
1764
1764
                  CurrV->NumFrm > 0) colt[++k_colt]=CurrV;
1777
1777
 
1778
1778
 
1779
1779
#define MAX_STYLE 100
1780
 
Int16  K_PointInInch=72;
 
1780
int16_t  K_PointInInch=72;
1781
1781
extern float Twips;
1782
1782
float HalfPoint;
1783
1783
static uint cr=13,lf=10;
1784
1784
#define FONT_OCR struct h_font_ocr
1785
1785
#define STYLE struct h_style
1786
1786
#define PARAG struct h_parag
1787
 
STYLE { Int16 Alignment;
1788
 
        Int16 IndentFirst,IndentLeft,IndentRight;
1789
 
        Int16 SpaceBefore,SpaceAfter,SpaceBetwLine;
1790
 
        Int16 Font,SizeFont;};
1791
 
PARAG { Int16 NumStyle; //������ � ����. ������
1792
 
        Int16 BegStr, EndStr; //������. ������ ������
 
1787
STYLE { int16_t Alignment;
 
1788
        int16_t IndentFirst,IndentLeft,IndentRight;
 
1789
        int16_t SpaceBefore,SpaceAfter,SpaceBetwLine;
 
1790
        int16_t Font,SizeFont;};
 
1791
PARAG { int16_t NumStyle; //Индекс в табл. стилей
 
1792
        int16_t BegStr, EndStr; //Гранич. строки абзаца
1793
1793
        SRECT bnd;
1794
 
        Int16 MaxSize; };       //
1795
 
COLH { SRECT bnd;/*����� �����������*/};
 
1794
        int16_t MaxSize; };       //
 
1795
COLH { SRECT bnd;/*рамка объединения*/};
1796
1796
FONT_OCR { char *FileBase; };
1797
1797
 
1798
1798
//==
1799
 
Int16 CalcNumDau(KNOTT *Knot)
 
1799
int16_t CalcNumDau(KNOTT *Knot)
1800
1800
//==
1801
1801
{
1802
 
        Int16 n=0;
 
1802
        int16_t n=0;
1803
1803
        KNOTT *ptr;
1804
1804
 
1805
1805
        if(!Knot)
1812
1812
 
1813
1813
//Return:
1814
1814
//0 - OK.
1815
 
// ����� ������ USE_FRAME_AND_COLUMN
1816
 
//=========��������� �������� �� �������
1817
 
//         ������� �� �������������� �������
1818
 
//         �������������� ������� �� ������������ �������
1819
 
//         ����������� �������������� ������������ �������
1820
 
//  ����������� RtfPage.
1821
 
BOOL PageTree( FILE *InFileName, CRtfPage* RtfPage, const char* OutFileName)
 
1815
// Режим работы USE_FRAME_AND_COLUMN
 
1816
//=========Разбиение страницы на сектора
 
1817
//         Секторы на горизантальные колонки
 
1818
//         Горизантальные колонки на вертикальные колонки
 
1819
//         Определение терминальности вертикальных колонок
 
1820
//  Запольнение RtfPage.
 
1821
Bool PageTree( FILE *InFileName, CRtfPage* RtfPage, const char* OutFileName)
1822
1822
{
1823
 
        Int16  nc,ns,nw,nz,fl,i,i_ns1,i_nsb,i_nse,j,ih,iv,iv1,kp,kp1,kp2,
 
1823
        int16_t  nc,ns,nw,nz,fl,i,i_ns1,i_nsb,i_nse,j,ih,iv,iv1,kp,kp1,kp2,
1824
1824
                      n_beg,dist_hor_col=240,dist_sec=360,flag_vse_term=1,OldNumCol;
1825
 
        Int16    FlagBadColumn;
 
1825
        int16_t  FlagBadColumn;
1826
1826
        const char   *err="PageTree";
1827
1827
        SRECT  bnd;
1828
 
        Int16  ***Colt,K_Sect,*K_Hor,**K_Ver_Flag_Term,**K_Ver_Add_On,**K_Ver_Offset,**K_Ver;
 
1828
        int16_t  ***Colt,K_Sect,*K_Hor,**K_Ver_Flag_Term,**K_Ver_Add_On,**K_Ver_Offset,**K_Ver;
1829
1829
        COLH   **ColH,**ColH_New;
1830
1830
        INF_TREE Inf;
1831
1831
        FRAME **frm;
1832
 
        BOOL  FlagBadBad = FALSE;
 
1832
        Bool  FlagBadBad = FALSE;
1833
1833
        KNOTT *RootUdal=NULL;
1834
1834
 
1835
1835
 
1868
1868
        Inf.TypeDoc=PLAIN;
1869
1869
 
1870
1870
        FlagOdinSectorOdnaColonka = TRUE;
1871
 
        //--������������� �������:������ internal-�����--
 
1871
        //--Инициализация системы:чтение internal-файла--
1872
1872
        #define TRUE_READ_ED   //Alik 17.04.97
1873
1873
        FlagBadColumn = 0;
1874
1874
 
1894
1894
        setup.size_x=setup.size_y=SizeYGlob;
1895
1895
        OldNumCol = NumCol;
1896
1896
        ++NumCol;
1897
 
        // �������������� ��������� ����������
 
1897
        // Форматирование текстовых фрагментов
1898
1898
        if(fl=GenerateTreeByFragm(RectFragm,NumCol,&setup,&frm,&Inf))
1899
1899
        {
1900
1900
                --NumCol;
1903
1903
                goto BadReturn;
1904
1904
        }
1905
1905
        CONS_MESS22("GenerateTreeByFragm ");
1906
 
         //---���������� ���������� ������������� ��������� ���������� � �������---
 
1906
         //---объединяем результаты распознавания текстовых фрагментов в колонки---
1907
1907
        if( Inf.NumT )
1908
1908
                FlagOdinSectorOdnaColonka=FALSE;
1909
1909
        for(i=0; i <= Inf.NumT; ++i)
1910
1910
        {
1911
 
                Int16 num,inCol,nc,ns,r,l,t,b,TotalNumStr,m;
 
1911
                int16_t num,inCol,nc,ns,r,l,t,b,TotalNumStr,m;
1912
1912
 
1913
1913
                l     = Inf.bnd_col[i].left;
1914
1914
                r     = Inf.bnd_col[i].right;
1949
1949
 
1950
1950
                CONS_MESS6("beg=%d num=%d inCol=%d",n_beg,num,NumCol-inCol);
1951
1951
        #ifdef alDebug
1952
 
                 if(det6 && num>1 && !Inf.ColT[i]->Type) {ConsMess(" �������� �� ������������ !!! ");
 
1952
                 if(det6 && num>1 && !Inf.ColT[i]->Type) {ConsMess(" Фрагмент не отсортирован !!! ");
1953
1953
                                                         ConsMess("********* end multiframe ********");}
1954
1954
        #endif
1955
 
   //���������������� ������� => ���������� ������ ����������
 
1955
   //многофрагментная колонка => объединяем строки фрагментов
1956
1956
                if( num>1 && (Inf.ColT[i]->Type  || ( FlagOdinSectorOdnaColonka && !Inf.NumT ) ))
1957
1957
                {
1958
1958
                        TotalNumStr=0;
1964
1964
 
1965
1965
                        for(j=0; j < num; ++j)
1966
1966
                        {
1967
 
                                nc=(Int16)frm[n_beg+j]->start_pos;
 
1967
                                nc=(int16_t)frm[n_beg+j]->start_pos;
1968
1968
                                TotalNumStr += NumStr[nc]+1;
1969
1969
                        }
1970
1970
 
1980
1980
 
1981
1981
                        for(j=0; j<num; ++j)
1982
1982
                        {
1983
 
                                nc = (Int16)frm[n_beg+j]->start_pos;  //��������� ������ ������� nc � inCol
 
1983
                                nc = (int16_t)frm[n_beg+j]->start_pos;  //прибавить строки колонки nc к inCol
1984
1984
                                if(j)
1985
1985
                                        TitleStr[nc][0].S_Attr=1;
1986
1986
                        #ifdef alDebug
1993
1993
                                        Z[m]  = Zn[nc][ns];
1994
1994
                                        m++;
1995
1995
                                }
1996
 
                                NumStr[nc]=-1; //��� �������������� �������� �� ������ ��� ���������
 
1996
                                NumStr[nc]=-1; //для неосвобождения повторно их памяти или уплотнени
1997
1997
                        }
1998
1998
 
1999
1999
                        if(FlagOdinSectorOdnaColonka)
2008
2008
 
2009
2009
        pRoot=Inf.Tree.Root;
2010
2010
        Inf.StatCell=(STAT_CELL*)malloc(NumCol*sizeof(STAT_CELL));
2011
 
        Inf.StatCell[0].HeiStr=42;//~�.�. �� ED-����� �������� �������� �������
 
2011
        Inf.StatCell[0].HeiStr=42;//~т.к. из ED-файла приходит неверные значени
2012
2012
        Inf.MonoSpaceTrue     =22;//~
2013
2013
        Inf.k_str=NumStr;
2014
2014
 
2015
 
         //---���������� ��������� ������� K_Sect,K_Hor,K_Ver,Colt,ColH---***********************
 
2015
         //---Заполнение структуры колонок K_Sect,K_Hor,K_Ver,Colt,ColH---***********************
2016
2016
        k_lev=MaxLev-1;
2017
2017
        --NumCol;
2018
2018
        if(FlagOdinSectorOdnaColonka)
2021
2021
                NumCol=0;
2022
2022
        }
2023
2023
 
2024
 
        //converter from Inf, ��� ����� ������, � ������������� WORD-�����
2025
 
         //������������� �������� �������:
 
2024
        //converter from Inf, где лежит дерево, в трехуровневую uint16_t-схему
 
2025
         //представления иерархии колонок:
2026
2026
         // K_Sect
2027
2027
         //             K_Hor[K_Sect]
2028
2028
         //                     K_Ver[K_Sect][K_Hor[K_Sect]]
2029
 
         // K_Ver_Flag_Term ��������� �������� ������� :
2030
 
         // 0----������� �������; 1----������� ������� c ����. �����������; 2----- ������� �������
 
2029
         // K_Ver_Flag_Term указывает свойства колонки :
 
2030
         // 0----простая колонка; 1----простая колонка c терм. фрагментами; 2----- сложная колонка
2031
2031
        {
2032
2032
                k_col[1]=CalcNumDau(pRoot)-1;
2033
 
   /*****************     �����. ������� - �������. *********************************/
 
2033
   /*****************     Начал. порядок - горизон. *********************************/
2034
2034
                if(pRoot->OrderChild == HOR)
2035
2035
                {
2036
 
                        CONS_MESS4("�����. ������� - �������.");
2037
 
                        CONS_MESS4("���������� ����� =%d",k_col[1]+1);
 
2036
                        CONS_MESS4("Начал. порядок - горизон.");
 
2037
                        CONS_MESS4("Количество колон =%d",k_col[1]+1);
2038
2038
 
2039
2039
                        K_Sect=0;
2040
 
                        K_Hor=(Int16*)malloc((K_Sect+1)*sizeof(Int16));
 
2040
                        K_Hor=(int16_t*)malloc((K_Sect+1)*sizeof(int16_t));
2041
2041
                        K_Hor[0]=k_col[1];
2042
 
                        K_Ver=(Int16**)malloc((K_Sect+1)*sizeof(Int16*));
2043
 
                        K_Ver_Flag_Term=(Int16**)malloc((K_Sect+1)*sizeof(Int16*));
2044
 
                        Colt=(Int16***)malloc((K_Sect+1)*sizeof(Int16**));
 
2042
                        K_Ver=(int16_t**)malloc((K_Sect+1)*sizeof(int16_t*));
 
2043
                        K_Ver_Flag_Term=(int16_t**)malloc((K_Sect+1)*sizeof(int16_t*));
 
2044
                        Colt=(int16_t***)malloc((K_Sect+1)*sizeof(int16_t**));
2045
2045
                        if(K_Hor==NULL||K_Ver_Flag_Term==NULL||K_Ver==NULL||Colt==NULL)
2046
2046
                                return NOT_ALLOC;
2047
 
                        if((K_Ver[0]=(Int16*) malloc((K_Hor[0]+1)*sizeof(Int16)))==NULL||
2048
 
                           (K_Ver_Flag_Term[0]=(Int16*) malloc((K_Hor[0]+1)*sizeof(Int16)))==NULL||
2049
 
                                (Colt [0]=(Int16**)malloc((K_Hor[0]+1)*sizeof(PTR)))==NULL)
 
2047
                        if((K_Ver[0]=(int16_t*) malloc((K_Hor[0]+1)*sizeof(int16_t)))==NULL||
 
2048
                           (K_Ver_Flag_Term[0]=(int16_t*) malloc((K_Hor[0]+1)*sizeof(int16_t)))==NULL||
 
2049
                                (Colt [0]=(int16_t**)malloc((K_Hor[0]+1)*sizeof(PTR)))==NULL)
2050
2050
                                return NOT_ALLOC;
2051
2051
 
2052
2052
                        for(ih=0,ptr=pRoot->down; ih <= K_Hor[0]; ++ih,ptr=ptr->next)
2055
2055
                                iv=0;
2056
2056
                                kp=CalcNumDau(ptr)-1;
2057
2057
                                CONS_MESS4(" #Col=%d",ih+1);
2058
 
                                if(kp < 0) //��������.�������
 
2058
                                if(kp < 0) //Терминал.колонка
2059
2059
                                {
2060
2060
                                        if(ptr->NumFrm>1 && !ptr->Type)
2061
2061
                                        {
2065
2065
                                        else
2066
2066
                                                K_Ver[0][ih]=0;
2067
2067
 
2068
 
                                        if((Colt[0][ih]=(Int16*)malloc((K_Ver[0][ih]+1)*sizeof(Int16)))==NULL)
 
2068
                                        if((Colt[0][ih]=(int16_t*)malloc((K_Ver[0][ih]+1)*sizeof(int16_t)))==NULL)
2069
2069
                                                return NOT_ALLOC;
2070
2070
                                        Get_all_term_fragms1( ptr,Colt[0][ih],&iv,NumCol,frm );
2071
2071
                                #ifdef alDebug
2072
2072
                                        if(det4 && ptr->NumFrm>1 && !ptr->Type)
2073
 
                                                ConsMess("������� ������� ��������� (������) ");
 
2073
                                                ConsMess("Колонка сложной структуры (фреймы) ");
2074
2074
                                 #endif
2075
2075
                                }
2076
2076
                                else
2077
2077
                                {
2078
2078
                                        K_Ver[0][ih]=ptr->NumFrm-1;
2079
 
                                        if((Colt[0][ih]=(Int16*)malloc((K_Ver[0][ih]+1)*sizeof(Int16)))==NULL)
 
2079
                                        if((Colt[0][ih]=(int16_t*)malloc((K_Ver[0][ih]+1)*sizeof(int16_t)))==NULL)
2080
2080
                                                return NOT_ALLOC;
2081
2081
                                #ifdef alDebug
2082
 
                                        if(det4 && dets) ConsMess(" ��������� ������ ��� %d term fragm",ptr->NumFrm);
 
2082
                                        if(det4 && dets) ConsMess(" Выдельяем память для %d term fragm",ptr->NumFrm);
2083
2083
                                #endif
2084
2084
 
2085
2085
                                        for(iv1=0,iv=0,ptr1=ptr->down; iv1 <= kp; ++iv1,ptr1=ptr1->next)
2086
2086
                                        {
2087
 
       //����� ������������ ����������
 
2087
       //Поиск терминальных фрагментов
2088
2088
                                                kp1=CalcNumDau(ptr1)-1;
2089
2089
                                                if(kp1 >= 0)
2090
2090
                                                {
2096
2096
                                                        if(ptr1->NumFrm>1 && !ptr1->Type)
2097
2097
                                                        {
2098
2098
                                                                K_Ver_Flag_Term[0][ih]=2;
2099
 
                                                                CONS_MESS4(">>> %d �� ��������������� ���������",ptr1->NumFrm);
 
2099
                                                                CONS_MESS4(">>> %d не отсортированных фрагмента",ptr1->NumFrm);
2100
2100
 
2101
2101
                                                                i_nse=ptr1->InBegFrm+ptr1->NumFrm;
2102
2102
                                                                for(i_nsb=ptr1->InBegFrm; i_nsb<i_nse; ++iv,++i_nsb)
2103
2103
                                                                {
2104
 
                                                                        Colt[0][ih][iv]=(Int16)frm[i_nsb]->start_pos;
 
2104
                                                                        Colt[0][ih][iv]=(int16_t)frm[i_nsb]->start_pos;
2105
2105
                                                                        CONS_MESS4(" #term=%d",NumCol+1-Colt[0][ih][iv]);
2106
2106
                                                                }
2107
2107
                                                        }
2116
2116
                                        }
2117
2117
                                        K_Ver[0][ih] = --iv;
2118
2118
                                #ifdef alDebug
2119
 
                                        if(det4 && dets) ConsMess("���-�� ����. �������=%d",K_Ver[0][ih]+1);
 
2119
                                        if(det4 && dets) ConsMess("Кол-во терм. колонок=%d",K_Ver[0][ih]+1);
2120
2120
                                 #endif
2121
2121
                                }
2122
2122
                        #ifdef alDebug
2123
2123
                                if(det4)
2124
2124
                                {
2125
 
                                        if(!K_Ver_Flag_Term[0][ih])  ConsMess("������� �������");
 
2125
                                        if(!K_Ver_Flag_Term[0][ih])  ConsMess("Колонка простая");
2126
2126
                                        else
2127
 
                                        if(det4 && K_Ver_Flag_Term[0][ih]==1) ConsMess("������� ������� � ������� �� ����.����-���");
2128
 
                                        else  ConsMess("������� ������� ��������� (������) ");
 
2127
                                        if(det4 && K_Ver_Flag_Term[0][ih]==1) ConsMess("Колонка простая и состоит из терм.фраг-тов");
 
2128
                                        else  ConsMess("Колонка сложной структуры (фреймы) ");
2129
2129
                                }
2130
2130
                        #endif
2131
2131
                        }
2132
2132
                }
2133
 
/*****************     �����. ������� - ��������. *********************************/
 
2133
/*****************     Начал. порядок - вертикал. *********************************/
2134
2134
                else
2135
2135
                if(pRoot->OrderChild == VER)
2136
2136
                {
2137
 
                        CONS_MESS4("�����. ������� - ��������.");
2138
 
                        CONS_MESS4("���������� ������ =%d",k_col[1]+1);
 
2137
                        CONS_MESS4("Начал. порядок - вертикал.");
 
2138
                        CONS_MESS4("Количество секций =%d",k_col[1]+1);
2139
2139
 
2140
2140
                        K_Sect=k_col[1];
2141
 
                        K_Hor=(Int16*)malloc((K_Sect+1)*sizeof(Int16));
2142
 
                        K_Ver=(Int16**)malloc((K_Sect+1)*sizeof(Int16*));
2143
 
                        K_Ver_Flag_Term=(Int16**)malloc((K_Sect+1)*sizeof(Int16*));
2144
 
                        Colt =(Int16***)malloc((K_Sect+1)*sizeof(Int16**));
 
2141
                        K_Hor=(int16_t*)malloc((K_Sect+1)*sizeof(int16_t));
 
2142
                        K_Ver=(int16_t**)malloc((K_Sect+1)*sizeof(int16_t*));
 
2143
                        K_Ver_Flag_Term=(int16_t**)malloc((K_Sect+1)*sizeof(int16_t*));
 
2144
                        Colt =(int16_t***)malloc((K_Sect+1)*sizeof(int16_t**));
2145
2145
                        if(K_Hor==NULL||K_Ver_Flag_Term==NULL||K_Ver==NULL||Colt==NULL)
2146
2146
                                return NOT_ALLOC;
2147
 
                        //******  ���� �� �������,������ ������ - �� 2-��������� �������� ***********
 
2147
                        //******  Цикл по секциям,внутри каждой - до 2-уровневой иерархии ***********
2148
2148
                        for(i=0,ptr=pRoot->down; i <= K_Sect; ++i,ptr=ptr->next)
2149
2149
                        {
2150
2150
                                kp=CalcNumDau(ptr)-1;
2151
 
                                CONS_MESS4("***������ #%d- ��   %d   �����. ������� ",i+1,kp<0?1:kp+1);
 
2151
                                CONS_MESS4("***Секция #%d- из   %d   гориз. колонок ",i+1,kp<0?1:kp+1);
2152
2152
 
2153
 
                                //������ - ���� ��������. �������
 
2153
                                //Секция - одна терминал. колонка
2154
2154
                                if(kp < 0)
2155
2155
                                {
2156
2156
                                        K_Hor[i]=0;
2157
 
                                        K_Ver[i]=(Int16*)malloc((K_Hor[i]+1)*sizeof(Int16));
2158
 
                                        K_Ver_Flag_Term[i]=(Int16*)malloc((K_Hor[i]+1)*sizeof(Int16));
2159
 
                                        Colt[i] =(Int16**)malloc((K_Hor[i]+1)*sizeof(Int16*));
 
2157
                                        K_Ver[i]=(int16_t*)malloc((K_Hor[i]+1)*sizeof(int16_t));
 
2158
                                        K_Ver_Flag_Term[i]=(int16_t*)malloc((K_Hor[i]+1)*sizeof(int16_t));
 
2159
                                        Colt[i] =(int16_t**)malloc((K_Hor[i]+1)*sizeof(int16_t*));
2160
2160
                                        if(K_Ver[i]==NULL||K_Ver_Flag_Term[i]==NULL||Colt[i]==NULL)
2161
2161
                                        return NOT_ALLOC;
2162
2162
 
2171
2171
                                                K_Ver_Flag_Term[i][0]=0;
2172
2172
                                        }
2173
2173
 
2174
 
                                        if((Colt[i][0]=(Int16*)malloc((K_Ver[i][0]+1)*sizeof(Int16)))==NULL)
 
2174
                                        if((Colt[i][0]=(int16_t*)malloc((K_Ver[i][0]+1)*sizeof(int16_t)))==NULL)
2175
2175
                                                return -3;
2176
2176
 
2177
2177
                                        if(ptr->NumFrm>1 && !ptr->Type)
2178
2178
                                        {
2179
 
                                                CONS_MESS4(">>> %d �� ��������������� ���������",ptr->NumFrm);
 
2179
                                                CONS_MESS4(">>> %d не отсортированных фрагмента",ptr->NumFrm);
2180
2180
 
2181
2181
                                                i_nse=ptr->InBegFrm+ptr->NumFrm;
2182
2182
                                                for(i_ns1=0,i_nsb=ptr->InBegFrm; i_nsb<i_nse; ++i_ns1,++i_nsb)
2183
2183
                                                {
2184
 
                                                        Colt[i][0][i_ns1]=(Int16)frm[i_nsb]->start_pos;
 
2184
                                                        Colt[i][0][i_ns1]=(int16_t)frm[i_nsb]->start_pos;
2185
2185
                                                        CONS_MESS4(" #term=%d",NumCol+1-Colt[i][0][i_ns1]);
2186
2186
                                                }
2187
 
                                                CONS_MESS4("������� ������� ��������� (������) ");
 
2187
                                                CONS_MESS4("Колонка сложной структуры (фреймы) ");
2188
2188
                                        }
2189
2189
                                        else
2190
2190
                                        {
2192
2192
                                                CONS_MESS4(" #term=%d",NumCol+1-Colt[i][0][0]);
2193
2193
                                        }
2194
2194
                                }
2195
 
        //������ - �� kp H-�������
 
2195
        //Секция - из kp H-колонок
2196
2196
                                else
2197
2197
                                {
2198
2198
                                        K_Hor[i]=kp;
2199
 
                                        K_Ver[i]=(Int16*)malloc((K_Hor[i]+1)*sizeof(Int16));
2200
 
                                        K_Ver_Flag_Term[i]=(Int16*)malloc((K_Hor[i]+1)*sizeof(Int16));
2201
 
                                        Colt[i] =(Int16**)malloc((K_Hor[i]+1)*sizeof(Int16*));
 
2199
                                        K_Ver[i]=(int16_t*)malloc((K_Hor[i]+1)*sizeof(int16_t));
 
2200
                                        K_Ver_Flag_Term[i]=(int16_t*)malloc((K_Hor[i]+1)*sizeof(int16_t));
 
2201
                                        Colt[i] =(int16_t**)malloc((K_Hor[i]+1)*sizeof(int16_t*));
2202
2202
                                        if(K_Ver[i]==NULL||K_Ver_Flag_Term[i]==NULL||Colt[i]==NULL)
2203
2203
                                                return NOT_ALLOC;
2204
 
                                        //************  ���� �� H-������� ������ ****************************
 
2204
                                        //************  цикл по H-дочерям секции ****************************
2205
2205
                                        for(ih=0,ptr1=ptr->down; ih <= kp; ++ih,ptr1=ptr1->next)
2206
2206
                                        {
2207
 
                                                kp1=CalcNumDau(ptr1)-1;//����� ������� H-col
 
2207
                                                kp1=CalcNumDau(ptr1)-1;//Число дочерей H-col
2208
2208
                                                K_Ver_Flag_Term[i][ih]=0;
2209
2209
                                                CONS_MESS4(" #Col=%d",ih+1);
2210
2210
 
2211
 
                                                if(kp1 < 0)            //����. H-col
 
2211
                                                if(kp1 < 0)            //Терм. H-col
2212
2212
                                                {
2213
2213
                                                        if(ptr1->NumFrm>1 && !ptr1->Type)
2214
2214
                                                        {
2221
2221
                                                                K_Ver_Flag_Term[i][ih]=0;
2222
2222
                                                        }
2223
2223
 
2224
 
                                                        if((Colt[i][ih]=(Int16*)malloc((K_Ver[i][ih]+1)*sizeof(Int16)))==NULL)
 
2224
                                                        if((Colt[i][ih]=(int16_t*)malloc((K_Ver[i][ih]+1)*sizeof(int16_t)))==NULL)
2225
2225
                                                                return -3;
2226
2226
 
2227
2227
                                                        if(ptr1->NumFrm>1 && !ptr1->Type)
2228
2228
                                                        {
2229
 
                                                                CONS_MESS4(">>> %d �� ��������������� ���������",ptr1->NumFrm);
 
2229
                                                                CONS_MESS4(">>> %d не отсортированных фрагмента",ptr1->NumFrm);
2230
2230
 
2231
2231
                                                                i_nse=ptr1->InBegFrm+ptr1->NumFrm;
2232
2232
                                                                for(i_ns1=0,i_nsb=ptr1->InBegFrm; i_nsb<i_nse; ++i_ns1,++i_nsb)
2233
2233
                                                                {
2234
 
                                                                        Colt[i][ih][i_ns1]=(Int16)frm[i_nsb]->start_pos;
 
2234
                                                                        Colt[i][ih][i_ns1]=(int16_t)frm[i_nsb]->start_pos;
2235
2235
                                                                        CONS_MESS4(" #term=%d",NumCol+1-Colt[i][ih][i_ns1]);
2236
2236
                                                                }
2237
2237
                                                        }
2244
2244
                                                else
2245
2245
                                                {
2246
2246
                                                        K_Ver[i][ih]=ptr1->NumFrm-1;
2247
 
                                                        if((Colt[i][ih]=(Int16*)malloc((K_Ver[i][ih]+1)*sizeof(Int16)))==NULL)
 
2247
                                                        if((Colt[i][ih]=(int16_t*)malloc((K_Ver[i][ih]+1)*sizeof(int16_t)))==NULL)
2248
2248
                                                                return -3;
2249
2249
                                                #ifdef alDebug
2250
 
                                                        if(det4 && dets) ConsMess(" ��������� ������ ��� %d term fragm",ptr1->NumFrm);
 
2250
                                                        if(det4 && dets) ConsMess(" Выдельяем память для %d term fragm",ptr1->NumFrm);
2251
2251
                                                #endif
2252
2252
 
2253
2253
                                                        for(iv1=0,iv=0,ptr2=ptr1->down; iv1 <= kp1; ++iv1,ptr2=ptr2->next)
2254
2254
                                                        {
2255
 
        //����� ������������ ����������
 
2255
        //Поиск терминальных фрагментов
2256
2256
                                                                kp2=CalcNumDau(ptr2)-1;
2257
2257
                                                                if(kp2 >= 0)
2258
2258
                                                                {
2264
2264
                                                                        if(ptr2->NumFrm>1 && !ptr2->Type)
2265
2265
                                                                        {
2266
2266
                                                                                K_Ver_Flag_Term[i][ih]=2;
2267
 
                                                                                CONS_MESS4(">>> %d �� ��������������� ���������",ptr2->NumFrm);
 
2267
                                                                                CONS_MESS4(">>> %d не отсортированных фрагмента",ptr2->NumFrm);
2268
2268
 
2269
2269
                                                                                i_nse=ptr2->InBegFrm+ptr2->NumFrm;
2270
2270
                                                                                for(i_nsb=ptr2->InBegFrm; i_nsb<i_nse; ++iv,++i_nsb)
2271
2271
                                                                                {
2272
 
                                                                                        Colt[i][ih][iv]=(Int16)frm[i_nsb]->start_pos;
 
2272
                                                                                        Colt[i][ih][iv]=(int16_t)frm[i_nsb]->start_pos;
2273
2273
                                                                                        CONS_MESS4(" #term=%d",NumCol+1-Colt[i][ih][iv]);
2274
2274
 
2275
2275
                                                                                }
2287
2287
                                                        }
2288
2288
                                                        K_Ver[i][ih] = --iv;
2289
2289
                                                #ifdef alDebug
2290
 
                                                        if(det4 && dets) ConsMess("���-�� ����. �������=%d",K_Ver[i][ih]+1);
 
2290
                                                        if(det4 && dets) ConsMess("Кол-во терм. колонок=%d",K_Ver[i][ih]+1);
2291
2291
                                                #endif
2292
2292
 
2293
2293
                                                }
2294
2294
                                        #ifdef alDebug
2295
2295
                                                if(det4){
2296
 
                                                if(!K_Ver_Flag_Term[i][ih])  ConsMess("������� �������");
 
2296
                                                if(!K_Ver_Flag_Term[i][ih])  ConsMess("Колонка простая");
2297
2297
                                                else
2298
 
                                                if(K_Ver_Flag_Term[i][ih]==1) ConsMess("������� ������� � ������� �� ����.����-���");
2299
 
                                                else  ConsMess("������� ������� ��������� (������) ");}
 
2298
                                                if(K_Ver_Flag_Term[i][ih]==1) ConsMess("Колонка простая и состоит из терм.фраг-тов");
 
2299
                                                else  ConsMess("Колонка сложной структуры (фреймы) ");}
2300
2300
                                        #endif
2301
2301
 
2302
2302
                                        }
2303
 
                                        //************ ����� ����� �� H-������� ������ ****************************
 
2303
                                        //************ Конец цикла по H-дочерям секции ****************************
2304
2304
                                }
2305
2305
                        }
2306
2306
                }
2309
2309
                        if(!NumCol) //090899 update
2310
2310
                        {
2311
2311
                                K_Sect=0;
2312
 
                                K_Hor=(Int16*)malloc((K_Sect+1)*sizeof(Int16));
 
2312
                                K_Hor=(int16_t*)malloc((K_Sect+1)*sizeof(int16_t));
2313
2313
                                K_Hor[0]=0;
2314
 
                                K_Ver=(Int16**)malloc((K_Sect+1)*sizeof(Int16*));
2315
 
                                K_Ver_Flag_Term=(Int16**)malloc((K_Sect+1)*sizeof(Int16*));
2316
 
                                Colt=(Int16***)malloc((K_Sect+1)*sizeof(Int16**));
 
2314
                                K_Ver=(int16_t**)malloc((K_Sect+1)*sizeof(int16_t*));
 
2315
                                K_Ver_Flag_Term=(int16_t**)malloc((K_Sect+1)*sizeof(int16_t*));
 
2316
                                Colt=(int16_t***)malloc((K_Sect+1)*sizeof(int16_t**));
2317
2317
                                if(K_Hor==NULL||K_Ver_Flag_Term==NULL||K_Ver==NULL||Colt==NULL)
2318
2318
                                        return NOT_ALLOC;
2319
 
                                if((K_Ver[0]=(Int16*) malloc((K_Hor[0]+1)*sizeof(Int16)))==NULL||
2320
 
                                        (K_Ver_Flag_Term[0]=(Int16*) malloc((K_Hor[0]+1)*sizeof(Int16)))==NULL||
2321
 
                                        (Colt [0]=(Int16**)malloc((K_Hor[0]+1)*sizeof(PTR)))==NULL)
 
2319
                                if((K_Ver[0]=(int16_t*) malloc((K_Hor[0]+1)*sizeof(int16_t)))==NULL||
 
2320
                                        (K_Ver_Flag_Term[0]=(int16_t*) malloc((K_Hor[0]+1)*sizeof(int16_t)))==NULL||
 
2321
                                        (Colt [0]=(int16_t**)malloc((K_Hor[0]+1)*sizeof(PTR)))==NULL)
2322
2322
                                return NOT_ALLOC;
2323
2323
                                K_Ver_Flag_Term[0][0]=0;
2324
2324
                                K_Ver[0][0]=0;
2325
 
                                if((Colt[0][0]=(Int16*)malloc((K_Ver[0][0]+1)*sizeof(Int16)))==NULL)
 
2325
                                if((Colt[0][0]=(int16_t*)malloc((K_Ver[0][0]+1)*sizeof(int16_t)))==NULL)
2326
2326
                                        return NOT_ALLOC;
2327
2327
                                Colt[0][0][0]=0;
2328
2328
                        }
2331
2331
BadReturn:
2332
2332
                                FlagBadColumn   = 1;
2333
2333
                                K_Sect          = 0;
2334
 
                                K_Hor           = (Int16*)malloc((K_Sect+1)*sizeof(Int16));
 
2334
                                K_Hor           = (int16_t*)malloc((K_Sect+1)*sizeof(int16_t));
2335
2335
                                K_Hor[0]        = 0;
2336
 
                                K_Ver           = (Int16**)malloc((K_Sect+1)*sizeof(Int16*));
2337
 
                                K_Ver_Flag_Term = (Int16**)malloc((K_Sect+1)*sizeof(Int16*));
2338
 
                                Colt            = (Int16***)malloc((K_Sect+1)*sizeof(Int16**));
 
2336
                                K_Ver           = (int16_t**)malloc((K_Sect+1)*sizeof(int16_t*));
 
2337
                                K_Ver_Flag_Term = (int16_t**)malloc((K_Sect+1)*sizeof(int16_t*));
 
2338
                                Colt            = (int16_t***)malloc((K_Sect+1)*sizeof(int16_t**));
2339
2339
 
2340
2340
                                if( K_Hor==NULL || K_Ver_Flag_Term==NULL || K_Ver==NULL || Colt==NULL )
2341
2341
                                        return NOT_ALLOC;
2342
2342
 
2343
 
                                if(( K_Ver[0]           = (Int16*) malloc((K_Hor[0]+1)*sizeof(Int16)))==NULL  ||
2344
 
                                                ( K_Ver_Flag_Term[0] = (Int16*) malloc((K_Hor[0]+1)*sizeof(Int16)))==NULL  ||
2345
 
                                                ( Colt [0]           = (Int16**)malloc((K_Hor[0]+1)*sizeof(PTR)))  ==NULL)
 
2343
                                if(( K_Ver[0]           = (int16_t*) malloc((K_Hor[0]+1)*sizeof(int16_t)))==NULL  ||
 
2344
                                                ( K_Ver_Flag_Term[0] = (int16_t*) malloc((K_Hor[0]+1)*sizeof(int16_t)))==NULL  ||
 
2345
                                                ( Colt [0]           = (int16_t**)malloc((K_Hor[0]+1)*sizeof(PTR)))  ==NULL)
2346
2346
                                        return NOT_ALLOC;
2347
2347
 
2348
2348
                                K_Ver_Flag_Term[0][0]=2;
2349
2349
                                K_Ver[0][0]=NumCol;
2350
2350
 
2351
 
                                if((Colt[0][0]=(Int16*)malloc((K_Ver[0][0]+1)*sizeof(Int16)))==NULL)
 
2351
                                if((Colt[0][0]=(int16_t*)malloc((K_Ver[0][0]+1)*sizeof(int16_t)))==NULL)
2352
2352
                                        return NOT_ALLOC;
2353
2353
 
2354
2354
                                do0(i,0,NumCol)
2367
2367
                        do0(iv,0,K_Ver[i][ih])
2368
2368
                        {
2369
2369
                                nc=Colt[i][ih][iv];
2370
 
                                RectFragm[nc].left   = (Int16)(RectFragm[nc].left   * Twips);
2371
 
                                RectFragm[nc].right  = (Int16)(RectFragm[nc].right  * Twips);
2372
 
                                RectFragm[nc].top    = (Int16)(RectFragm[nc].top    * Twips);
2373
 
                                RectFragm[nc].bottom = (Int16)(RectFragm[nc].bottom * Twips);
 
2370
                                RectFragm[nc].left   = (int16_t)(RectFragm[nc].left   * Twips);
 
2371
                                RectFragm[nc].right  = (int16_t)(RectFragm[nc].right  * Twips);
 
2372
                                RectFragm[nc].top    = (int16_t)(RectFragm[nc].top    * Twips);
 
2373
                                RectFragm[nc].bottom = (int16_t)(RectFragm[nc].bottom * Twips);
2374
2374
                        }
2375
2375
                }
2376
2376
        }
2377
2377
 
2378
2378
 
2379
2379
//////////////////////////////////////////////////////////////////////////////////////////
2380
 
//  �������� ������� ����������� ������� Colh--*****************************************//
2381
 
//  ������-��� �� 3-��������� � 2-��������� ������� �������  (ideal size)               //
 
2380
//  Создание массива укрупненных колонок Colh--*****************************************//
 
2381
//  преобр-ние из 3-уровневой в 2-уровневую систему колонок  (ideal size)               //
2382
2382
//////////////////////////////////////////////////////////////////////////////////////////
2383
2383
        if((ColH=(COLH**)malloc((K_Sect+1)*sizeof(COLH*)))==NULL)
2384
2384
                return -3;
2385
2385
 
2386
 
        K_Ver_Add_On = (Int16**)malloc((K_Sect+1)*sizeof(Int16*));
2387
 
        K_Ver_Offset = (Int16**)malloc((K_Sect+1)*sizeof(Int16*));
 
2386
        K_Ver_Add_On = (int16_t**)malloc((K_Sect+1)*sizeof(int16_t*));
 
2387
        K_Ver_Offset = (int16_t**)malloc((K_Sect+1)*sizeof(int16_t*));
2388
2388
        if(K_Ver_Add_On==NULL||K_Ver_Offset==NULL)
2389
2389
                return NOT_ALLOC;
2390
2390
 
2392
2392
        {
2393
2393
                SRECT BndTmp;
2394
2394
                if((ColH[i]=(COLH*)malloc((K_Hor[i]+1)*sizeof(COLH)))==NULL)return -3;
2395
 
                K_Ver_Add_On[i]=(Int16*)malloc((K_Hor[i]+1)*sizeof(Int16));
2396
 
                K_Ver_Offset[i]=(Int16*)malloc((K_Hor[i]+1)*sizeof(Int16));
 
2395
                K_Ver_Add_On[i]=(int16_t*)malloc((K_Hor[i]+1)*sizeof(int16_t));
 
2396
                K_Ver_Offset[i]=(int16_t*)malloc((K_Hor[i]+1)*sizeof(int16_t));
2397
2397
                if(K_Ver_Add_On[i]==NULL||K_Ver_Offset[i]==NULL)
2398
2398
                        return NOT_ALLOC;
2399
2399
 
2407
2407
                        {
2408
2408
                                nc=Colt[i][ih][iv];
2409
2409
                                if(!iv)
2410
 
                                        ConvertRect16ToBnd(&RectFragm[nc],&bnd); //!! ��� ����� �� ������ � �������������
 
2410
                                        ConvertRect16ToBnd(&RectFragm[nc],&bnd); //!! или берем по линиям с выравниванием
2411
2411
                                else
2412
2412
                                {
2413
2413
                                        ConvertRect16ToBnd(&RectFragm[nc],&BndTmp);
2421
2421
                }
2422
2422
        }
2423
2423
 
2424
 
        CONS_MESS20("������� ������� �������� ������ ");
 
2424
        CONS_MESS20("Подсчет реалных размеров кеглей ");
2425
2425
/////////////////////////////////////////////////////////////////////////////////////////
2426
2426
//                                                                                     //
2427
 
//                  ������� ������� �������� ������                                    //
 
2427
//                  Подсчет реалных размеров кеглей                                    //
2428
2428
//                                                                                     //
2429
2429
/////////////////////////////////////////////////////////////////////////////////////////
2430
2430
        do0(i,0,K_Sect)
2447
2447
                                pRtfFragment->m_rect.right    = RectFragm[nc].right;
2448
2448
                                pRtfFragment->m_rect.top      = RectFragm[nc].top;
2449
2449
                                pRtfFragment->m_rect.bottom   = RectFragm[nc].bottom;
2450
 
                                pRtfFragment->m_Flag          = FragFlag [nc]; //nega_str ������� ���� � ������� � ������ RtfString �������� ������������
 
2450
                                pRtfFragment->m_Flag          = FragFlag [nc]; //nega_str сделать цикл и занести в массив RtfString признаки негативности
2451
2451
 
2452
2452
                                do0(ns,0,NumStr[nc])
2453
2453
                                {       //str. begin
2456
2456
                                        pRtfFragment->m_arStrings.push_back( new CRtfString() );
2457
2457
 
2458
2458
                                        pRtfString=pRtfFragment->m_arStrings[ns];
2459
 
                                        pRtfString->m_wWordsCount = TitleStr[nc][ns].S_Gen.S_NumWord;//nega_str �������� m_Flag � RtfString � ������� ���� ������� NEGATIVE
 
2459
                                        pRtfString->m_wWordsCount = TitleStr[nc][ns].S_Gen.S_NumWord;//nega_str добавить m_Flag в RtfString и занести туда признак NEGATIVE
2460
2460
                                        pRtfString->S_Flags       = TitleStr[nc][ns].S_Flags; //NEGA_STR
2461
2461
 
2462
2462
                                        do0(nw,0,TitleStr[nc][ns].S_Gen.S_NumWord-1)
2485
2485
                                                                pRtfChar->m_chrVersions[alt].m_bChar        = Zn[nc][ns][nw][nz].Alt[alt].a_Code;
2486
2486
                                                                pRtfChar->m_chrVersions[alt].m_bProbability = Zn[nc][ns][nw][nz].Alt[alt].a_Prob;
2487
2487
                                                        }
2488
 
                                                        pRtfChar->m_bFlg_spell_nocarrying    = Zn[nc][ns][nw][nz].Alt[0].a_SpellNoCarrying; //~ �� ���� ��������, � ����� � ����� (��: ������-�����)
 
2488
                                                        pRtfChar->m_bFlg_spell_nocarrying    = Zn[nc][ns][nw][nz].Alt[0].a_SpellNoCarrying; //~ не знак переноса, а дефис в слове (пр: красно-белый)
2489
2489
                                                        pRtfChar->m_bFlg_cup_drop            = Zn[nc][ns][nw][nz].Alt[0].a_FlagCupDrop;
2490
2490
                                                        pRtfChar->m_blanguage                = Zn[nc][ns][nw][nz].Alt[0].a_language;
2491
2491
                                                        pRtfChar->m_bFlg_spell               = Zn[nc][ns][nw][nz].Alt[0].a_Spell;
2505
2505
        RtfPage->ChangeKegl();  // it is properly writing
2506
2506
 
2507
2507
//////////////////////////////////////////////////////////////////////////////////////////
2508
 
//����� ���������� ���.������� ����� ��������� ����. �������� ���.��� , �����. � �����  //
 
2508
//Новые координаты гор.колонок после пересчета реал. размеров вер.кол , параг. и строк  //
2509
2509
//////////////////////////////////////////////////////////////////////////////////////////
2510
2510
        if((ColH_New=(COLH**)malloc((K_Sect+1)*sizeof(COLH*)))==NULL)     return -3;
2511
2511
        do0(i,0,K_Sect)
2522
2522
 
2523
2523
//                                                                                     //
2524
2524
/////////////////////////////////////////////////////////////////////////////////////////
2525
 
// ��������� ����������������� ��������� ��������� (Page).
 
2525
// Добавляем отформатированные текстовые фрагменты (Page).
2526
2526
        RtfPage->Count.RtfSectors = K_Sect;
2527
2527
        do0(i,0,K_Sect)
2528
2528
        {       //sect begin
2561
2561
 
2562
2562
                                pRtfVerticalColumn->m_wFragmentsCount = 1;
2563
2563
                                pRtfVerticalColumn->m_arFragments.push_back( new CRtfFragment() );
2564
 
                                pRtfFragment=pRtfVerticalColumn->m_arFragments[/*iv*/ 0]; //nega ~? �.�. [iv] ������ [0]?
 
2564
                                pRtfFragment=pRtfVerticalColumn->m_arFragments[/*iv*/ 0]; //nega ~? м.б. [iv] вместо [0]?
2565
2565
                                pRtfFragment->m_wType = FT_TEXT;
2566
2566
                                RtfAssignRect_CRect_Rect16( &pRtfVerticalColumn->m_rect,     &RectFragm[nc] );
2567
2567
                                RtfAssignRect_CRect_Rect16( &pRtfVerticalColumn->m_rectReal, &RectFragm[nc] );
2673
2673
 
2674
2674
        if(FlagOdinSectorOdnaColonka)
2675
2675
        {
2676
 
                Int16 tmpNumCol;
 
2676
                int16_t tmpNumCol;
2677
2677
                tmpNumCol = NumCol;
2678
2678
                NumCol    = OldNumCol;
2679
2679
                if(NumStr)
2708
2708
        return TRUE;
2709
2709
}
2710
2710
 
2711
 
void Get_all_term_fragms1( KNOTT* ptr,Int16* Colt,Int16* iv,Int16 NumCol,FRAME **frm)
 
2711
void Get_all_term_fragms1( KNOTT* ptr,int16_t* Colt,int16_t* iv,int16_t NumCol,FRAME **frm)
2712
2712
 {
2713
 
  Int16 i_nsb,i_nse;
 
2713
  int16_t i_nsb,i_nse;
2714
2714
 
2715
2715
  if(ptr->NumFrm>1 && !ptr->Type)
2716
2716
                {
2717
2717
                        #ifdef alDebug
2718
 
    if(det4) ConsMess(">>> %d �� ��������������� ���������",ptr->NumFrm);
 
2718
    if(det4) ConsMess(">>> %d не отсортированных фрагмента",ptr->NumFrm);
2719
2719
                        #endif
2720
2720
 
2721
2721
   i_nse=ptr->InBegFrm+ptr->NumFrm;
2722
2722
   for(i_nsb=ptr->InBegFrm; i_nsb<i_nse; ++*iv,++i_nsb)
2723
2723
                        {
2724
 
    Colt[*iv]=(Int16)frm[i_nsb]->start_pos;
 
2724
    Colt[*iv]=(int16_t)frm[i_nsb]->start_pos;
2725
2725
                                #ifdef alDebug
2726
2726
     if(det4)  ConsMess(" #term=%d",NumCol+1-Colt[*iv]);
2727
2727
                                #endif
2736
2736
                }
2737
2737
}
2738
2738
 
2739
 
void Get_all_term_fragms( KNOTT* ptr,Int16* Colt,Int16* iv,Int16 NumCol,FRAME **frm)
 
2739
void Get_all_term_fragms( KNOTT* ptr,int16_t* Colt,int16_t* iv,int16_t NumCol,FRAME **frm)
2740
2740
 {
2741
 
        Int16 i,i1,i2,i3,kp,kp1,kp2,kp3,kp4;
 
2741
        int16_t i,i1,i2,i3,kp,kp1,kp2,kp3,kp4;
2742
2742
  KNOTT *ptr1,*ptr2,*ptr3,*ptr4;
2743
2743
 
2744
2744
  kp=CalcNumDau(ptr)-1;
2745
2745
  for(i=0,ptr1=ptr->down; i <= kp; ++i,ptr1=ptr1->next)
2746
2746
                {
2747
 
                 kp1=CalcNumDau(ptr1)-1;//����� ������� col
2748
 
   if(kp1 < 0)            //����. col
 
2747
                 kp1=CalcNumDau(ptr1)-1;//Число дочерей col
 
2748
   if(kp1 < 0)            //Терм. col
2749
2749
    Get_all_term_fragms1( ptr1, Colt, iv, NumCol,frm);
2750
2750
   else
2751
2751
                        {
2752
2752
    for(i1=0,ptr2=ptr1->down; i1 <= kp1; ++i1,ptr2=ptr2->next)
2753
2753
                                {
2754
2754
                                 kp2=CalcNumDau(ptr2)-1;
2755
 
     if(kp2 < 0)            //����. col
 
2755
     if(kp2 < 0)            //Терм. col
2756
2756
                                         Get_all_term_fragms1( ptr2, Colt, iv, NumCol,frm);
2757
2757
     else
2758
2758
                                        {
2759
2759
      for(i2=0,ptr3=ptr2->down; i2 <= kp2; ++i2,ptr3=ptr3->next)
2760
2760
                                                {
2761
2761
                                   kp3=CalcNumDau(ptr3)-1;
2762
 
                                          if(kp3 < 0)            //����. col
 
2762
                                          if(kp3 < 0)            //Терм. col
2763
2763
                                                        Get_all_term_fragms1( ptr3, Colt, iv, NumCol,frm);
2764
2764
       else
2765
2765
                                                        {
2766
2766
        for(i3=0,ptr4=ptr3->down; i3 <= kp3; ++i3,ptr4=ptr4->next)
2767
2767
                                                                {
2768
2768
                                     kp4=CalcNumDau(ptr4)-1;
2769
 
                                                   if(kp4 < 0)            //����. col
 
2769
                                                   if(kp4 < 0)            //Терм. col
2770
2770
                                                                        Get_all_term_fragms1( ptr4, Colt, iv, NumCol,frm);
2771
2771
                                                                                #ifdef alDebug
2772
2772
            else
2773
 
                 if(det11)  ConsMess("   ������ !!!   ");
 
2773
                 if(det11)  ConsMess("   Ошибка !!!   ");
2774
2774
                                                                        #endif
2775
2775
 
2776
2776
                                                                }
2824
2824
 
2825
2825
void    RtfCalcRectSizeInTwips(tagRECT *s1, float Twips)
2826
2826
{
2827
 
 s1->left   = (Int32)(s1->left   * Twips);
2828
 
 s1->right  = (Int32)(s1->right  * Twips);
2829
 
 s1->top    = (Int32)(s1->top    * Twips);
2830
 
 s1->bottom = (Int32)(s1->bottom * Twips);
 
2827
 s1->left   = (int32_t)(s1->left   * Twips);
 
2828
 s1->right  = (int32_t)(s1->right  * Twips);
 
2829
 s1->top    = (int32_t)(s1->top    * Twips);
 
2830
 s1->bottom = (int32_t)(s1->bottom * Twips);
2831
2831
}
2832
2832
 
2833
 
//==����������� ���� �����
 
2833
//==Объединение пары рамок
2834
2834
void MyUnionRect(SRECT *s1,SRECT *s2,SRECT *u)
2835
2835
//==
2836
2836
{
2841
2841
}
2842
2842
 
2843
2843
//==
2844
 
char *get2_param(char *str,char *param,Int16 max_len)
 
2844
char *get2_param(char *str,char *param,int16_t max_len)
2845
2845
//==
2846
 
{ Int16 len;
2847
 
  len=-1; while(str[++len]==' '); str+=len;/*������� ������� ����� �� ���������*/
 
2846
{ int16_t len;
 
2847
  len=-1; while(str[++len]==' '); str+=len;/*Убираем пробелы слева от параметра*/
2848
2848
  len=-1;
2849
 
  while(++len < max_len && str[len] != ' ') /*����� ������� ������� ������*/
 
2849
  while(++len < max_len && str[len] != ' ') /*Поиск первого пробела справа*/
2850
2850
  { if( (param[len]=str[len]) == 0) break; /*Detect END STRING*/
2851
2851
    if(len && (uint)str[len-1] == cr && (uint)str[len] == lf) /*Detect <cr><lf>*/
2852
2852
      { --len; break; }
2853
2853
  }
2854
 
  /*���� �������� ����� �������, ���������� ������� ��� ���������*/
 
2854
  /*Если параметр очень длинный, возвращаем неудачу его выделения*/
2855
2855
  if(len < max_len-1) param[len]=0; else param[len=0]=0;
2856
2856
  return str+len;
2857
2857
}