← Back to branch summary

~ubuntu-branches/debian/wheezy/cuneiform/wheezy

« back to all changes in this revision

Viewing changes to cuneiform_src/Kern/dif/src/diffr.c

  • Committer: Bazaar Package Importer
  • Author(s): Daniel Baumann
  • Date: 2009-07-10 17:58:10 UTC
  • Revision ID: james.westby@ubuntu.com-20090710175810-rqc89d2i3tki9m89
Tags: upstream-0.7.0+dfsg
Import upstream version 0.7.0+dfsg

Show diffs side-by-side

added added

removed removed

Lines of Context:
cuneiform_src/Kern/dif/src/diffr.c
 
1
/*
 
2
Copyright (c) 1993-2008, Cognitive Technologies
 
3
All rights reserved.
 
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
�������� ��� ������ ���� ���� �������� � ����������� ����� ������� � ������.
 
32
 
 
33
Redistribution and use in source and binary forms, with or without modification,
 
34
are permitted provided that the following conditions are met:
 
35
 
 
36
    * Redistributions of source code must retain the above copyright notice,
 
37
      this list of conditions and the following disclaimer.
 
38
    * Redistributions in binary form must reproduce the above copyright notice,
 
39
      this list of conditions and the following disclaimer in the documentation
 
40
      and/or other materials provided with the distribution.
 
41
    * Neither the name of the Cognitive Technologies nor the names of its
 
42
      contributors may be used to endorse or promote products derived from this
 
43
      software without specific prior written permission.
 
44
 
 
45
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
 
46
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 
47
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 
48
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
 
49
FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 
50
DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
 
51
SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
 
52
CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
 
53
OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 
54
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
55
*/
 
56
 
 
57
/* DIFFR.C : diskrimintion functions for russian language */
 
58
 
 
59
#include <string.h>
 
60
#include <stdio.h>
 
61
#include <stdlib.h>
 
62
#include "difdefs.h"
 
63
#include "dif.h"
 
64
#include "minmax.h"
 
65
extern  Word8 broken_flag;
 
66
  Word8 rec5_flag=1,font_type=0,omni=1;
 
67
Int16  NumVertInterval(Word8 *RASTER,Int16 D_X, Int16 dy, Int16 i);
 
68
Int16  VertSum(Word8 *rastr,Int16 D_X, Int16 dy, Int16 i);
 
69
Int16  SumBits(Word8 *rastr,Int16 D_X);
 
70
Int16  NumHorizInterval(Word8 *,Int16);
 
71
Int16  FOOT(Word8 *raster,Int16 DX,Word8 dx,Word8 Ly,
 
72
    Word8 sign_filter);
 
73
Int16 FOOT3( Word8 *RASTER, Int16 Wx, Word8 START, Word8 NWIDTH, Word8 NLENGTH, Int16 SHIFT);
 
74
Int16 EndBlackInterval(Word8 *RASTER, Int16 NWIDTH);
 
75
Int16 FOOT3_2( Word8 *RASTER, Int16 Wx, Word8 NWIDTH, Word8 NLENGTH);
 
76
Int16 FOOT_HEI( Word8 *RASTER, Int16 Wx, Word8 NWIDTH, Word8 NLENGTH);
 
77
 
 
78
Int16 MinMaxLeft( Word8 *RASTER, Int16 Wx, Word8 NWIDTH, Word8 NHEIGHT,
 
79
                Int16 *Pmin, Int16 *Pmax);
 
80
Int16 MinMaxRight( Word8 *RASTER, Int16 Wx, Word8 NWIDTH, Word8 NHEIGHT,
 
81
                Int16 *Pmin, Int16 *Pmax);
 
82
Int16 DiskrRight(Word8 *RASTR,Int16 D_X,Int16 dx,Int16 dy,Int16 L);
 
83
Int16 Num2Interval(Word8 *r,Int16 D_X,Int16 dx,Int16 dy);
 
84
Int16 broken_M(Word8 * r,Int16 D_X,Int16 dy,Int16 left_lim,Int16 ll);
 
85
Int16  FOOT_A(Word8 *raster,Int16 DX,Word8 dx,Word8 Ly);
 
86
Int16 fill_center_zone(Word8 *raster,Int16 D_X,Int16 dy,
 
87
      Int16 beg, Int16 end, Int16 II);
 
88
Int16 up_down_hist_M(Word8 *rastr,Int16 D_X, Int16 Dx,Int16 dy);
 
89
Int16 small_density(Word8 *RAST,Int16 n,Int16 D_X,Int16 bw);
 
90
Int16  LeftDistance(Word8 *RASTER,Int16 dx);
 
91
Int16  RightDistance(Word8 *RASTER,Int16 dx);
 
92
Int16  SumIntervalBits(Word8 *RASTER,Int16 bx,Int16 ex);
 
93
Int16  CenterVertInterval(Word8 *,Int16 ,Int16 ,Int16, Int16 *,Int16 *);
 
94
void init_diskrim(Word8* raster,Int16 height ,Int16 width);
 
95
Int16 DiskrLeftBig(Word8 *RASTR,Int16 D_X,Int16 dx,Int16 dy, Int16 L);
 
96
Int16 DiskrRightBig(Word8 *RASTR,Int16 D_X,Int16 dx,Int16 dy,Int16 L);
 
97
 
 
98
static void DiskrIN(Word8 *RASTR,Int16 D_X,Int16 dy, Int16 wb,Int16 dx);
 
99
static Int16 DiskrHorizIN(Word8 *RASTR,Int16 D_X,Int16 dy);
 
100
Int16 no_serific(Word8 *RASTR,Int16 dy,Int16 dx,Int16 wb);
 
101
 
 
102
#define bytlen(bits)  (REC_GW_WORD8(bits))
 
103
 
 
104
extern Word8 BUFFER[256];        /* ���⨪��쭠�   ��o����              */
 
105
extern Word8 LOCAL[50];          /* ���न����     ���             */
 
106
extern Word8 LOCAL_W[50];        /* �ਭ�         ���             */
 
107
extern Word8 end1,beg2;          /* ����� 1 � ��砫� 2-�� ��� ���  */
 
108
extern broken_ii;               /* 䫠� ���� �����                        */
 
109
extern Int16 dnri_hook; // bottom right hook in small russian italic II,III
 
110
extern Int16 uple_hook; // bottom left  hook in small russian italic II,III
 
111
extern Int16 up_jack  ; // upper jack
 
112
 
 
113
static Int16 upper_skip_lines,lower_skip_lines;
 
114
static Int16 diskr_f2,diskr_tsh,diskr_ii,
 
115
    diskr_sh,diskr_g,diskr_tsh,diskr_ju,diskr_m,diskr_ii,diskr_p,diskr_N,
 
116
    diskr_c, diskr_o, diskr_e,diskr_b,diskr_3,
 
117
    IN_N_Bonus,IN_equ,IN_P_Bonus,
 
118
    IN_I_Bonus,IN_IN_Monus,IN_dis,diskr_i,diskr_n,IN_N,IN_I,IN_M,IN_pics,
 
119
    mii;
 
120
 
 
121
 Int16 left_dist[4], right_dist[4], num_foot, c_or_e,d_c,d_e,
 
122
    right_max,left_max,left_line,right_line,
 
123
    left_dist_big[4], right_dist_big[4],lower_long_line;
 
124
Int16 av_tl, av_bl,av_br, rotate;
 
125
/* g-�, sh-�, b-B, k-K, ju-�, f2-���, tsh-�, ii-�, o-O, c-C, e-E,
 
126
   h-�, ja-�, z-�, ee-�, d-�, ce-�  */
 
127
Int16 fill_center,up_down_serif,up_down_serif_B,IN_horiz_dis,broken_M_pen;
 
128
 
 
129
static Int16 DiskrSymSh( Word8 *RASTER, Int16 Wx, Word8 NWIDTH, Word8 NLENGTH);
 
130
static Int16 DiskrSh(Word8 *RASTR,Int16 D_X,Int16 dx,Int16 Ly);
 
131
static Int16 DiskrLeft(Word8 *RASTR,Int16 D_X,Int16 dx,Int16 dy, Int16 L);
 
132
static Int16 DiskrSh0(Word8 *RASTR,Int16 D_X,Int16 dx,Int16 dy,Int16 dx0);
 
133
static Int16 DiskrJ0(Word8 *RASTR,Int16 D_X,Int16 dx,Int16 Ly,Int16 lim);
 
134
static Int16 DiskrJ(Word8 *RASTR,Int16 D_X,Int16 dx,Int16 dy);
 
135
static Int16 DiskrTsh(Word8 *RASTR,Int16 D_X,Int16 dx,Int16 dy,Int16 Dx);
 
136
static Int16 average_br_angle(Word8 *RASTER, Int16 D_X, Int16 dx, Int16 dy,Int16 t);
 
137
static Int16 average_angle(Word8 *RASTER, Int16 D_X, Int16 dx, Int16 dy,
 
138
       Int16  (*Distance)(Word8 *, Int16), Int16 t);
 
139
static Int16 DiskrJu(Word8 *RASTR,Int16 D_X,Int16 dx,Int16 Ly);
 
140
static Int16 DiskrimM1(Word8 *RAST,Int16 D_X,Int16 dx,Int16 dy);
 
141
static Int16 DiskrimM(Word8 *RAST,Int16 D_X,Int16 dx,Int16 dy);
 
142
static Int16 whiteMeanBitRight(Word8 *RAST,Int16 D_X,Int16 dx,Int16 meanBit);
 
143
static Int16 whiteMeanBitLeft(Word8 *RAST,Int16 D_X,Int16 meanBit);
 
144
static Int16 up_down_zones(Word8 *raster, Int16 D_X, Int16 dx, Int16 dx0,
 
145
      Int16 start1, Int16 stop1,   Int16 start2, Int16 stop2);
 
146
static Int16 DiskrVertCE(Word8 *RASTR,Int16 D_X,Int16 dx,Int16 dy,Int16 X,
 
147
                        Word8 let, Word8 inc);
 
148
static Int16 AngleBottomRight(Word8 *raster,Int16 D_X,Int16 hei);
 
149
static Int16 AngleTopRight(Word8 *raster,Int16 D_X,Int16 hei);
 
150
static Int16 BonusAnglesCurve(Word8 *raster,Int16 D_X,Int16 dy);
 
151
static Bool32 DiskrJuCut(Int16 nfoot, Int16 dx);
 
152
 
 
153
/*  clear diskrimination flags */
 
154
void init_diskrim(Word8* raster,Int16 height ,Int16 width)
 
155
{
 
156
Int16 i, D_X=bytlen(width);
 
157
Word8* r;
 
158
 
 
159
rotate=0;
 
160
diskr_f2=diskr_ii=
 
161
diskr_N=diskr_sh=diskr_g=diskr_tsh=diskr_ju=diskr_m=diskr_ii=diskr_p=
 
162
diskr_c=diskr_o=diskr_e=diskr_b=diskr_3=
 
163
left_dist_big[1]= right_dist_big[1]= left_dist[1]= right_dist[1]=
 
164
left_dist_big[2]= right_dist_big[2]= left_dist[2]= right_dist[2]=
 
165
left_dist_big[3]= right_dist_big[3]= left_dist[3]= right_dist[3]=
 
166
num_foot= c_or_e=d_c=d_e=
 
167
fill_center=IN_dis=diskr_i=diskr_n=IN_equ=IN_N=IN_I=IN_M=
 
168
IN_pics=up_down_serif=up_down_serif_B=IN_horiz_dis=
 
169
broken_M_pen=
 
170
lower_long_line=right_max=left_max=-1;
 
171
av_tl=av_bl=av_br=-1;
 
172
mii=-101;
 
173
 
 
174
IN_N_Bonus=0;
 
175
IN_P_Bonus=0;
 
176
IN_I_Bonus=0;
 
177
IN_IN_Monus=0;
 
178
 
 
179
r = raster;
 
180
for(  i=0;i<height && SumBits( r ,D_X)<3;i++,r+=D_X);
 
181
upper_skip_lines = i;
 
182
 
 
183
r = raster + D_X*(height-1);
 
184
for(  i=0;i<2 && SumBits( r ,D_X)<3;i++,r-=D_X);
 
185
lower_skip_lines = i;
 
186
 
 
187
return;
 
188
}
 
189
 
 
190
Bool32 LeftHole(Word8 *rastr, Int16 D_X, Int16 Dx, Int16 Hy)
 
191
{
 
192
int i,n,t, mi, ma;
 
193
 
 
194
if( Hy>10 )
 
195
    {
 
196
    i=Hy>>3;
 
197
    Hy-=i;
 
198
    }
 
199
else
 
200
    {
 
201
    i=1;
 
202
    Hy--;
 
203
    }
 
204
n=0;
 
205
mi=10000; ma=0;
 
206
for(;i<Hy;i++,rastr+=D_X)
 
207
    {
 
208
    t=LeftDistance(rastr,D_X);
 
209
    if( t>=0 )
 
210
        {
 
211
        if( mi>t )
 
212
            mi=t;
 
213
        if( ma<t )
 
214
            ma=t;
 
215
        n++;
 
216
        }
 
217
    }
 
218
if( !n )
 
219
    return FALSE;
 
220
if( Dx<10 )
 
221
    return FALSE;
 
222
i = 5;
 
223
return (mi>Dx/2 && abs(mi-ma)<i);
 
224
}
 
225
 
 
226
/* Diskrim : diskrimination function for diapason 0-255    */
 
227
/* PARAMETRS :                                             */
 
228
/*      let    - name of letter                            */
 
229
/*      raster - bit map( work raster )                    */
 
230
/*      D_X    - whidth of bit map( length bit string )    */
 
231
/*      X,Y    - coordinats of first point in raster       */
 
232
/*      dx,dy  - whidth and height work raster             */
 
233
/*                                                         */
 
234
/*   RETURN :   0 - good letter                            */
 
235
/*             >0 - decreasing code                        */
 
236
 
 
237
Int16 Diskrim(Word8 let,Word8* raster,
 
238
      Int16 D_X,Int16 dx,Int16 dy,Word8 cg_flag, Int16 inc)
 
239
{
 
240
Int16 P=0,F=0,Dx,Hy,bw, n, r;
 
241
Word8 *rastr,*rastr0;
 
242
Int16 d_l, d_r;
 
243
Int16 X=0, Y=0;
 
244
#define  step_diskr 20
 
245
 
 
246
rotate= (inc>180) ;
 
247
if( upper_skip_lines )
 
248
        {
 
249
        raster += bytlen(D_X)*upper_skip_lines;
 
250
        dy-=upper_skip_lines;
 
251
        }
 
252
if( lower_skip_lines )
 
253
        {
 
254
        dy-=lower_skip_lines;
 
255
        }
 
256
 
 
257
if( dy<8 || dx<3 )
 
258
        return(step_diskr*10);
 
259
 
 
260
D_X = bytlen(D_X);
 
261
Dx = dx + (X&7);
 
262
bw = bytlen(Dx);
 
263
rastr0= raster + Y*D_X+(X>>3);
 
264
rastr = rastr0 + D_X*(dy>>2);
 
265
Hy = dy-2*(dy>>2);
 
266
d_l = (X&7)+(dx>>2);
 
267
d_r = ((bytlen(Dx))<<3)-dx-(X&7)+(dx>>2);
 
268
 
 
269
switch( let ){
 
270
// russian small & capital E, Ze, 3
 
271
case '3' :
 
272
case (Word8)'�' :  case (Word8)'�' :
 
273
case (Word8)'�' :  case (Word8)'�' :
 
274
    if( diskr_3<0 )
 
275
       {
 
276
       if( LeftHole(rastr, D_X, Dx, Hy) )
 
277
            { // need mount on the central zone
 
278
            P+=60;
 
279
            }
 
280
 
 
281
       diskr_3 = P;
 
282
       }
 
283
       else P = diskr_3;
 
284
    break;
 
285
// russian small & capital B
 
286
case (Word8)'�' :      case (Word8)'�' :
 
287
    if( diskr_b<0 )
 
288
       {
 
289
       if( !DiskrRight(rastr0, D_X, Dx, dy,1) )
 
290
            { // need pimple
 
291
            //if( BonusAnglesCurve(rastr0,D_X,dy)<2 )
 
292
                P+=9*1;
 
293
            //else
 
294
            //    P+=step_diskr;
 
295
            }
 
296
 
 
297
       diskr_b = P;
 
298
       }
 
299
       else P = diskr_b;
 
300
    break;
 
301
// russian e
 
302
case (Word8)'�' :
 
303
    if( diskr_e<0 )
 
304
       {
 
305
       if( (n=DiskrVertCE(rastr0, D_X, dx, dy, X,(Word8)'�',(Word8)inc))>2  )
 
306
        P+=(n-2)*step_diskr;
 
307
       diskr_e = P;
 
308
       }
 
309
       else  P = diskr_e;
 
310
    break;
 
311
// russian o,O
 
312
//  case '0' :
 
313
  case (Word8)'�' :  case (Word8)'�' :
 
314
    if( diskr_o<0 )
 
315
       {
 
316
       if( DiskrRight(rastr0, D_X, Dx, dy, 2) )
 
317
        P = step_diskr;
 
318
       diskr_o = P;
 
319
       }
 
320
       else  P = diskr_o;
 
321
    break;
 
322
// russian c,C
 
323
  case (Word8)'�' :  case (Word8)'�' :
 
324
    if( diskr_c<0 )
 
325
       {
 
326
       if( !DiskrRight(rastr0, D_X, Dx, dy, 2) )
 
327
        P = step_diskr;
 
328
        if( (n=DiskrVertCE(rastr0, D_X, dx, dy, X,(Word8)'�',(Word8)inc))!=0 )
 
329
          P+=n*step_diskr;
 
330
       diskr_c = P;
 
331
       }
 
332
       else  P = diskr_c;
 
333
    break;
 
334
// capital N
 
335
  case (Word8)'N' :
 
336
                if( diskr_N<0 )
 
337
                {
 
338
        Word8 rasterN[4096];
 
339
        int i,ii,iii;
 
340
 
 
341
        for(iii=D_X*(dy-1),ii=i=0;i<dy;i++,ii+=D_X,iii-=D_X)
 
342
            memcpy(rasterN+iii,raster+ii,D_X);
 
343
        rastr0= rasterN + Y*D_X+(X>>3);
 
344
        rastr = rastr0 + D_X*(dy>>2);
 
345
        F = FOOT(rastr, D_X,(Word8)Dx, (Word8)Hy,1);
 
346
                if( F!=2 || MIN(LOCAL_W[0],LOCAL_W[1])>3 && beg2-end1<3 )
 
347
                        {
 
348
                        if( dy>13 )
 
349
                                F=FOOT(rastr0+2*D_X, D_X,(Word8)Dx, (Word8)(dy-4),0);
 
350
                        else
 
351
                                F=FOOT(rastr0, D_X,(Word8)Dx, (Word8)dy,0);
 
352
                        }
 
353
                if( F!=2 )
 
354
                        {
 
355
                        if( small_density(rastr,Hy,D_X,bw) )
 
356
                                P = 6*step_diskr;
 
357
                        else
 
358
                                P += step_diskr;
 
359
                        if( F==3 )
 
360
                                P +=6*step_diskr;
 
361
                        }
 
362
                   else
 
363
                   {
 
364
           IN_dis=-1;
 
365
                   DiskrIN(rastr0,D_X,dy,bw,dx);
 
366
                   IN_dis=-1;
 
367
           if( 2*LOCAL[0]>5*LOCAL_W[0] && 2*(dx-LOCAL[1])<3*LOCAL_W[1])
 
368
            P += 2*step_diskr;
 
369
                   if( IN_I<3 )
 
370
                        P += MIN(2*(7-IN_I+IN_equ) * step_diskr,160)/2;
 
371
                   else if( IN_I==3 && IN_equ>2 )
 
372
                        P += IN_equ*step_diskr;
 
373
                   //if( IN_I>10 && IN_M==0 )
 
374
            //P += 40;
 
375
                   }
 
376
 
 
377
      if( inc>0 )  // OLEG : ERECTION conditions : 09-12-95 07:29pm
 
378
        P >>= 1;
 
379
 
 
380
                diskr_N = P;
 
381
                }
 
382
                else P=diskr_N;
 
383
        IN_dis=-1;
 
384
        IN_IN_Monus=0;
 
385
        IN_pics=1;
 
386
        IN_M=0;
 
387
                break;
 
388
 
 
389
// capital & small I/I
 
390
  case (Word8)'�' :  case (Word8)'�' :
 
391
                if( diskr_i<0 )
 
392
                {
 
393
                F = FOOT(rastr, D_X,(Word8)Dx, (Word8)Hy,1);
 
394
        if( F==2 && LOCAL[1]*2<=Dx )
 
395
            {
 
396
            diskr_i = P=120;
 
397
                break;
 
398
            }
 
399
                if( F!=2 || MIN(LOCAL_W[0],LOCAL_W[1])>3 && beg2-end1<3 )
 
400
                        {
 
401
                        if( dy>13 )
 
402
                                F=FOOT(rastr0+2*D_X, D_X,(Word8)Dx, (Word8)(dy-4),0);
 
403
                        else
 
404
                                F=FOOT(rastr0, D_X,(Word8)Dx, (Word8)dy,0);
 
405
                        }
 
406
                if( F!=2 )
 
407
                        {
 
408
                        if( small_density(rastr,Hy,D_X,bw) )
 
409
                                P = 6*step_diskr;
 
410
                        else
 
411
                                P += step_diskr;
 
412
                        if( F==3 )
 
413
                                P +=6*step_diskr;
 
414
                        }
 
415
                   else
 
416
                   {
 
417
                           /*
 
418
       if( rotate && dnri_hook )
 
419
        fill_center_zone(rastr+D_X*(Hy>>2),(Int16)D_X,(Int16)(Hy-(Hy>>2)),(Int16)end1,(Int16)beg2,0);
 
420
      else
 
421
        fill_center_zone(rastr,D_X,Hy,end1,beg2,0);
 
422
                */
 
423
                   DiskrIN(rastr0,D_X,dy,bw,dx);
 
424
                   /*
 
425
                   if( fill_center==0 )
 
426
                        {
 
427
                        if( broken_flag )
 
428
                                {
 
429
                                if( IN_I<=3 || IN_pics==0 )
 
430
                                        P += 2*step_diskr;
 
431
                                }
 
432
                        else
 
433
                                P += 8*step_diskr;
 
434
                        }
 
435
                        */
 
436
           if( 2*LOCAL[0]>5*LOCAL_W[0] )
 
437
            P += 2*step_diskr;
 
438
                   if( IN_I<3 )
 
439
                        P += MIN(2*(7-IN_I+IN_equ) * step_diskr,160)/2;
 
440
                   else if( IN_I==3 && IN_equ>2 )
 
441
                        P += IN_equ*step_diskr;
 
442
                   /*
 
443
      if( IN_I>=9 )
 
444
        { // �祭� ����ਧ��⠫쭠� ��४������
 
445
        if( (F=up_down_hist_M(rastr0+D_X, (Int16)D_X,(Int16)Dx, (Int16)(dy-2)))>0 )
 
446
          P += F*step_diskr>>2;
 
447
        if( LOCAL[1]>(Dx>>1) &&
 
448
        broken_M(rastr0+2*D_X, D_X,(Int16)(dy-4),(Int16)(LOCAL[0]-LOCAL_W[0]/2),
 
449
          (Int16)(LOCAL[1]-LOCAL_W[1]/2)) )
 
450
          P += 4*step_diskr;
 
451
        }
 
452
                   */
 
453
                   }
 
454
 
 
455
      if( inc>0 )  // OLEG : ERECTION conditions : 09-12-95 07:29pm
 
456
        P >>= 1;
 
457
      if(     IN_I_Bonus && broken_flag && (broken_ii ||
 
458
                        !IN_IN_Monus &&
 
459
                        Num2Interval(rastr0+2*D_X, (Int16)D_X,(Int16)Dx, (Int16)(dy-4))) )
 
460
                        P =(IN_I_Bonus==2)?-254:-250;
 
461
 
 
462
                diskr_i = P;
 
463
                }
 
464
                else P=diskr_i;
 
465
                break;
 
466
// capital & small H
 
467
  case (Word8)'�' :  case (Word8)'�' :
 
468
                if( diskr_n<0 )
 
469
                {
 
470
                F =FOOT(rastr, D_X,(Word8)Dx, (Word8)Hy,1);
 
471
                if( F!=2 || MIN(LOCAL_W[0],LOCAL_W[1])>3 && beg2-end1<3 )
 
472
                        {
 
473
                        if( dy>13 )
 
474
                                F=FOOT(rastr0+2*D_X, D_X,(Word8)Dx,(Word8)(dy-4),0);
 
475
                        else
 
476
                                F=FOOT(rastr0, D_X,(Word8)Dx, (Word8)dy,0);
 
477
                        }
 
478
                if( F!=2 )
 
479
                        P = 6*step_diskr;
 
480
                else
 
481
                   {
 
482
                        /*
 
483
      if( rotate && dnri_hook )
 
484
        fill_center_zone(rastr+D_X*(Hy>>2),(Int16)D_X,(Int16)(Hy-(Hy>>2)),(Int16)end1,(Int16)beg2,0);
 
485
      else
 
486
        fill_center_zone(rastr,D_X,Hy,end1,beg2,0);
 
487
                */
 
488
                   DiskrIN(rastr0,D_X,dy,bw,dx);
 
489
                   if( DiskrHorizIN(rastr0,D_X,dy) )
 
490
                        {   // ��ୠ� ��४������
 
491
                        IN_N=3;
 
492
                        IN_I=2;
 
493
                        }
 
494
                   /*
 
495
                   if( fill_center==0 )
 
496
                        {
 
497
                        if( broken_flag )
 
498
                                {
 
499
                                if( IN_N>=3 || IN_pics==0 )
 
500
                                        P += 2*step_diskr;
 
501
                                }
 
502
                        else
 
503
                                P += 8*step_diskr;
 
504
                        }
 
505
                   */
 
506
                   if( IN_N>3 )
 
507
                        P += MIN(IN_N * step_diskr,160)/2;
 
508
                   /*
 
509
                   if( DiskrRight(rastr0, (Int16)D_X, (Int16)Dx, (Int16)dy,(Int16)(dy>22?3:2)) )
 
510
                        P += 3*step_diskr;
 
511
                   if( omni )
 
512
                        {
 
513
                        if( LOCAL_W[0]>(LOCAL_W[1]<<1) &&
 
514
                        (LOCAL_W[1]>1 || LOCAL_W[1]==1 && LOCAL_W[0]>3 ) )
 
515
                                P += 2*step_diskr;
 
516
                        }
 
517
                        */
 
518
                   }
 
519
 
 
520
    if( IN_N_Bonus && broken_flag && (broken_ii ||
 
521
                        !IN_IN_Monus &&
 
522
                        Num2Interval(rastr0+2*D_X, (Int16)D_X,(Int16)Dx, (Int16)(dy-4))) )
 
523
                        P =(IN_N_Bonus==2)?-254:-250;
 
524
 
 
525
                diskr_n = P;
 
526
                }
 
527
                else P=diskr_n;
 
528
                break;
 
529
// capital & small II
 
530
  case (Word8)'�' :  case (Word8)'�' :
 
531
    if( diskr_p )
 
532
      {
 
533
      if( dy>13 )
 
534
        F=FOOT(rastr0+2*D_X, D_X,(Word8)Dx, (Word8)(dy-4),0);
 
535
      else
 
536
        F=FOOT(rastr0, D_X,(Word8)Dx, (Word8)dy,0);
 
537
      if( F!=2 )
 
538
        P = 6*step_diskr;
 
539
      else
 
540
        { // F==2
 
541
        if( rotate && (dnri_hook/*||dy<22&&up_jack>1*/) )
 
542
          fill_center_zone(rastr+D_X*(Hy>>2),D_X,(Int16)(Hy-(Hy>>2)),end1,beg2,1);
 
543
        else
 
544
          //fill_center_zone(rastr,D_X,Hy,end1,beg2,0);
 
545
          fill_center_zone(rastr+D_X*(Hy>>2),D_X,(Int16)(Hy-(Hy>>2)),end1,beg2,1);
 
546
        {
 
547
        Int16 f_c=fill_center;
 
548
        DiskrIN(rastr0,D_X,dy,bw,dx);
 
549
        if( !(rotate && (dnri_hook/*||dy<22&&up_jack>1*/)) )
 
550
          f_c = fill_center;
 
551
        if( f_c==1 )
 
552
          P += 8*step_diskr;
 
553
        }
 
554
      }
 
555
 
 
556
      if( (n=up_down_zones(rastr0,D_X,Dx,dx,0,(Int16)(dy>>2),Hy,dy))!=0 )
 
557
        {
 
558
        if( omni )
 
559
        {
 
560
        if( n!=1 )
 
561
          P += 4*step_diskr*n;
 
562
        }
 
563
        else
 
564
        { /* no omni  */
 
565
        if( !broken_flag || n==2 )
 
566
          P += 4*step_diskr*n;
 
567
        else
 
568
          P += 1*step_diskr;
 
569
        }
 
570
        }
 
571
 
 
572
      if(   IN_P_Bonus && broken_flag && (broken_ii ||
 
573
        !IN_IN_Monus &&
 
574
        Num2Interval(rastr0+2*D_X, D_X,Dx, (Int16)(dy-4))) )
 
575
          P =(IN_P_Bonus==2)?-254:-250;
 
576
 
 
577
      diskr_p = P;
 
578
      }
 
579
    else P = diskr_p;
 
580
    break;
 
581
// capital & small III
 
582
  case (Word8)'�' :  case (Word8)'�' :
 
583
    if( diskr_sh<0 )
 
584
       {
 
585
       FOOT(rastr, D_X,(Word8)Dx, (Word8)Hy,0);
 
586
       if( rotate ) // OLEG : ERECTION conditions : 09-20-95
 
587
        {
 
588
/*
 
589
        F=FOOT3(rastr, D_X, uple_hook?LOCAL[0]-LOCAL_W[0]/2:0 ,
 
590
                            dnri_hook?LOCAL[2]+LOCAL_W[2]/2:Dx, Hy,Hy<10?1:2);
 
591
*/
 
592
        if( F!=3 )
 
593
          P  = 10*step_diskr;
 
594
        }
 
595
      else
 
596
        {
 
597
        if( (F=FOOT3(rastr, D_X, 0, (Word8)Dx, (Word8)Hy,2))!=3 )
 
598
          P  = 10*step_diskr;
 
599
        else
 
600
          P += (step_diskr>>1)*DiskrSymSh(rastr, D_X, (Word8)Dx, (Word8)Hy);
 
601
        }
 
602
       if( inc<=0 && !broken_flag && DiskrSh0(rastr0, D_X, Dx, dy, dx)==0 )
 
603
        P +=step_diskr;
 
604
       F = FOOT(rastr, D_X,(Word8)Dx, (Word8)Hy,0);
 
605
       // OLEG : ERECTION conditions : 09-20-95 08:34pm
 
606
       if( inc>0 && dnri_hook )
 
607
        {
 
608
        if( F>1 && DiskrSh(rastr, D_X, (Int16)(LOCAL[2]+LOCAL_W[2]/2), Hy) )
 
609
          P += step_diskr;
 
610
        }
 
611
       else
 
612
        {
 
613
        if( F>1 && (n=DiskrSh(rastr, D_X, Dx, Hy))!=0 )
 
614
          P += n*step_diskr;
 
615
        }
 
616
       if( F!=3  )
 
617
        P += 12*step_diskr;
 
618
       if( DiskrLeft(rastr0, D_X, Dx, dy,2) )
 
619
        P += step_diskr/2;
 
620
       if( DiskrRight(rastr0, D_X, Dx, dy,2) )
 
621
        P += step_diskr/2;
 
622
       if( FOOT3_2(rastr0,D_X,(Word8)Dx,(Word8)dy) )
 
623
        P += step_diskr*3;
 
624
       diskr_sh = P;
 
625
       P=MAX(P,0);
 
626
       }
 
627
       else  P = diskr_sh;
 
628
    break;
 
629
// capital & small >I<
 
630
    case (Word8)'�' :  case (Word8)'�' :
 
631
    if( diskr_g<0 )
 
632
       {
 
633
       if( !DiskrLeftBig(rastr0, D_X, Dx, dy,2) )
 
634
        P+=3*step_diskr;
 
635
       if( !DiskrRightBig(rastr0, D_X, Dx, dy,2) )
 
636
        P+=3*step_diskr;
 
637
       F = FOOT(rastr, D_X,(Word8)Dx, (Word8)Hy,0);
 
638
       if( F!=3 && (n=DiskrJ0(rastr, D_X, Dx, Hy,(Int16)(dy<18?4:5)))!=0 )
 
639
        { /* middle tail have'nt 3-interval lines */
 
640
        if( !DiskrJ(rastr0, D_X, Dx, dy) )
 
641
          P+=2*n*step_diskr;
 
642
        }
 
643
       if( F!=3 && (n=DiskrJ0(rastr0, D_X, Dx, Hy,(Int16)(dy<18?2:3)))!=0 )
 
644
        { /* upper tail have'nt 3-interval lines  */
 
645
        if( !DiskrJ(rastr0, D_X, Dx, dy) )
 
646
          P+=2*n*step_diskr;
 
647
        }
 
648
       diskr_g = P;
 
649
       }
 
650
       else P = diskr_g;
 
651
    break;
 
652
// capital & small III,
 
653
    case (Word8)'�' :  case (Word8)'�' :
 
654
    if( diskr_tsh<0 )
 
655
       {
 
656
       F= ((Word8)let==(Word8)'�' )?4:2;
 
657
       if( (F=FOOT(rastr0+F*D_X, D_X,(Word8)Dx,(Word8)Hy,0))!=3 )
 
658
        P = 10*step_diskr;
 
659
       else
 
660
        {
 
661
        P += (step_diskr>>1)*DiskrSymSh(rastr, D_X, (Word8)Dx, (Word8)Hy);
 
662
        if( DiskrTsh(rastr0+D_X,D_X,dx,dy,Dx)==1 )
 
663
          P += 3*step_diskr ;
 
664
        }
 
665
      if( average_br_angle(rastr0,D_X,Dx,dy,0)>d_r )
 
666
        P += 4*step_diskr;
 
667
      P=MAX(P,0);
 
668
      diskr_tsh = P;
 
669
      }
 
670
    else  P = diskr_tsh;
 
671
    break;
 
672
// capiatl & small IO
 
673
    case (Word8)'�' :  case (Word8)'�' :
 
674
                //{
 
675
                //Int32 ret=DIF_GetNoCutPoint(rastr0, (Word8)dx, (Word8)dy);
 
676
                //}
 
677
    if( diskr_ju<0 )
 
678
       {
 
679
       r=FOOT_HEI( rastr0, D_X, (Word8)dx, (Word8)dy);
 
680
       if( DiskrJuCut(r,dx) && r>1)
 
681
            P += 3*step_diskr;
 
682
       if( DiskrLeft(rastr0, D_X, Dx, dy,2) )
 
683
            P += 3*step_diskr;
 
684
       if( DiskrRight(rastr0, D_X, Dx, dy,2) )
 
685
            P += 3*step_diskr;
 
686
       if( (n=DiskrJu(rastr, D_X, Dx, Hy)) )
 
687
            P += n*step_diskr;
 
688
       diskr_ju = P;
 
689
       }
 
690
       else P = diskr_ju;
 
691
    break;
 
692
// capital & small M
 
693
    case (Word8)'�' :  case (Word8)'�' :
 
694
      if( diskr_m<0 )
 
695
      {
 
696
      if( mii<-100 ){
 
697
         if(broken_flag)
 
698
            mii = DiskrimM1(rastr0, D_X, dx, dy );
 
699
         else
 
700
            mii = DiskrimM(rastr0, D_X, dx, dy );
 
701
      }
 
702
    if(mii>0)
 
703
      P+= mii*step_diskr;
 
704
    if(mii==0)
 
705
             P+= 5*step_diskr;
 
706
 
 
707
    if( dy>13 )
 
708
      F=FOOT(rastr0+2*D_X, D_X,(Word8)Dx, (Word8)(dy-4),0);
 
709
    else
 
710
      F=FOOT(rastr0, D_X, (Word8)Dx, (Word8)dy,0);
 
711
 
 
712
                   if( F==2 )
 
713
      {
 
714
      DiskrIN(rastr0,D_X,dy,bw,dx);
 
715
      if( LOCAL[0] > dx/4)
 
716
        P >>=2 ;
 
717
      P += IN_M;
 
718
      }
 
719
 
 
720
                        diskr_m = P;
 
721
      }
 
722
    else  P = diskr_m;
 
723
    break;
 
724
// capital & small bl
 
725
    case (Word8)'�' :  case (Word8)'�' :
 
726
    if( diskr_ii<0 )
 
727
      {
 
728
      if( mii<-100 )
 
729
          {
 
730
          if(broken_flag)
 
731
             mii = DiskrimM1(rastr0, D_X, dx, dy );
 
732
          else
 
733
             mii = DiskrimM(rastr0, D_X, dx, dy );
 
734
          }
 
735
      if(mii<0)
 
736
         P += (-mii)*step_diskr;
 
737
      if(mii==0)
 
738
         P+= 5*step_diskr;
 
739
 
 
740
      diskr_ii = P;
 
741
      }
 
742
    else  P = diskr_ii;
 
743
    break;
 
744
 default:
 
745
    break;
 
746
 }
 
747
return(P & 0xFFFF);
 
748
}
 
749
 
 
750
 
 
751
 
 
752
Int16 small_density(Word8 *RAST,Int16 n,Int16 D_X,Int16 bw)
 
753
{
 
754
Int16 i,l,w,d;
 
755
Int16 b = bw << 3;
 
756
 
 
757
if( !omni && font_type==0 )
 
758
        return(1);
 
759
 
 
760
for(l=i=0;i<n;i++,RAST+=D_X)
 
761
        {
 
762
        w = b - RightDistance(RAST,bw) - LeftDistance(RAST,bw);
 
763
        d = SumBits(RAST,bw);
 
764
        l += (d>w-2);
 
765
        }
 
766
 
 
767
return( l<=(n/3) );
 
768
}
 
769
 
 
770
Int16 no_serific(Word8 *RASTR,Int16 dy,Int16 dx,Int16 wb)
 
771
{
 
772
Int16 l0=VertSum(RASTR,wb,dy,0);
 
773
Int16 l1=VertSum(RASTR,wb,dy,1);
 
774
Int16 l2=VertSum(RASTR,wb,dy,2);
 
775
Int16 r0=VertSum(RASTR,wb,dy,(Int16)(dx-1));
 
776
Int16 r1=VertSum(RASTR,wb,dy,(Int16)(dx-2));
 
777
Int16 r2=VertSum(RASTR,wb,dy,(Int16)(dx-3));
 
778
dy -= 2;
 
779
if( l0<dy && l1<=dy && l1>dy-2 && l2>dy )
 
780
        l1=l2;
 
781
if( r0<dy && r1<=dy && r1>dy-2 && r2>dy )
 
782
        r1=r2;
 
783
//return ( l0>dy || l1>dy ) && ( r0>dy || r1>dy ) ;
 
784
return 1;
 
785
}
 
786
 
 
787
Int16 vert_stairs(Int16 arr[], Int16 lim)
 
788
{
 
789
Int16 i,old,jmp;
 
790
for(jmp=0,i=1,old=arr[0];i<lim;i++)
 
791
        {
 
792
        if( arr[i]==-1 )
 
793
                continue;
 
794
        if( old<arr[i] )
 
795
                jmp++;
 
796
        if( old>arr[i] )
 
797
                return 0;
 
798
        old = arr[i];
 
799
        }
 
800
return ( jmp );
 
801
}
 
802
 
 
803
/***************************************************************************/
 
804
/*                                                                         */
 
805
/*  �����頥�   �業�� �����⠭�� �।�� ���ࢠ��� ��ફ����� ��       */
 
806
/*                                                                         */
 
807
/***************************************************************************/
 
808
static void DiskrIN(Word8 *RASTR,Int16 D_X,Int16 dy,Int16 bw,Int16 dx)
 
809
/***************************************************************************/
 
810
/****     *RASTR     㪠��⥫�   ��  ���ᨢ                         ********/
 
811
/****      dy        k�����⢮  ��ப                              ********/
 
812
/****      D_X       ������⢮  ���⮢  �  ��ப�                  ********/
 
813
/***************************************************************************/
 
814
{  Word8  n[256],hist[256];
 
815
   Int16   ua[256],da[256];
 
816
   Int16  i,n2=dy-2*(dy>>2),n4,mean,fine;
 
817
   Int16  incr,decr,old,neue,equ;
 
818
   Int16  l=beg2-end1-1,l_real,t,jump,rmin,rmax;
 
819
   Int16  ol=1,or=1;  /* ����� ᫥�� � �ࠢ� */
 
820
   Word8 *RAST ,*R;
 
821
 
 
822
 
 
823
n4 = MAX(dy/4,(LOCAL_W[0]+LOCAL_W[1])/4);
 
824
if( n4>dy/3 ) n4=dy/4;
 
825
n2 = dy - (n4<<1);
 
826
RAST = RASTR+D_X*n4;
 
827
 
 
828
if( IN_dis>0 )
 
829
        return;
 
830
IN_IN_Monus=0;
 
831
IN_pics=1;
 
832
IN_M=0;
 
833
 
 
834
if( l+ol+or<2 && dy>19 )
 
835
        {
 
836
        if( small_density(RAST,n2,D_X,bw) )
 
837
                {                       /* ��� ������� */
 
838
                IN_N=4;
 
839
                IN_I=2;
 
840
                }
 
841
        else
 
842
                {                       /* �������      */
 
843
                IN_N=4;
 
844
                IN_I=3;
 
845
                }
 
846
        IN_dis=1;
 
847
        IN_equ=0;
 
848
        return;
 
849
        }
 
850
 
 
851
memset(hist,0,dy);
 
852
if( l<3 )
 
853
        {       /* �⬥���� ������ */
 
854
        or=ol=0;
 
855
        l=beg2-end1+1-ol-or;
 
856
        }
 
857
if( l>3 )
 
858
{
 
859
Int16 up_space=-1, down_space=-1;
 
860
Int16 up_fill=0,down_fill=0,d;
 
861
for(R=RAST,i=n4;i<=dy-2;i++,R+=D_X)
 
862
        {
 
863
        d=SumIntervalBits(R,(Int16)(end1+ol),(Int16)(beg2-or+1))/3;
 
864
        hist[i]=(Word8)d;
 
865
        if( d==l && !up_fill )
 
866
                up_fill=i;
 
867
        if( d==l && i<n4+n2 )
 
868
                down_fill=i;
 
869
        }
 
870
 
 
871
if( up_fill && down_fill && up_fill>n4 &&
 
872
        (hist[up_fill-1]==0||hist[up_fill-2]==0) &&
 
873
        (hist[down_fill+1]==0||hist[down_fill+2]==0) )
 
874
        {
 
875
        IN_N=3;
 
876
        IN_I= 2;
 
877
        IN_dis=1;
 
878
        IN_equ=1;
 
879
        return;
 
880
        }
 
881
 
 
882
for( old=hist[n4],i=n4+1;i<=n2;i++)
 
883
        {
 
884
        neue = hist[i];
 
885
        if( up_space==-1 )
 
886
        if( old==1 && neue>=l && hist[i+1]>=l ||
 
887
            old==0 && neue>=l-1 && hist[i+1]>=l )
 
888
            {
 
889
            if( NumHorizInterval(RASTR+D_X*(i+1),bw)==1 )
 
890
        {
 
891
        Int16 j,d;
 
892
        up_space = (neue==l ? 0 : 1);
 
893
 
 
894
        for(j=i+1;j<dy-2 && hist[j]>=l-1;j++);
 
895
        if( j<dy-2 )
 
896
          {
 
897
          for(d=0;j<dy-2;j++)
 
898
            d+=(hist[j]<hist[j-1]);
 
899
          if( d>2 )
 
900
            {
 
901
            up_space=-1;
 
902
            break;
 
903
            }
 
904
          if( d<3 )
 
905
            {
 
906
            down_space=0;
 
907
            break;
 
908
            }
 
909
          }
 
910
      }
 
911
  }
 
912
        if( down_space==-1 )
 
913
        if( neue==1 && old>=l && hist[i-2]>=l ||
 
914
            neue==0 && old>=l-1 && hist[i-2]>=l )
 
915
            {
 
916
            if( NumHorizInterval(RASTR+D_X*(i-2),bw)==1 )
 
917
        down_space = (old==l ? 0 : 1);
 
918
            }
 
919
        old = neue;
 
920
        }
 
921
 
 
922
if( up_space!=-1 && down_space!=-1 )
 
923
        {
 
924
        IN_N=3;
 
925
        IN_I= MIN(up_space,down_space);
 
926
        IN_dis=1;
 
927
        IN_equ=2;
 
928
        return;
 
929
        }
 
930
memset(hist,0,dy<<1);
 
931
} /* end of horiz study */
 
932
 
 
933
if( no_serific(RASTR,dy,dx,bw) )
 
934
        {
 
935
        n4 = dy>17 ? 4 : 2;
 
936
        n2 = dy - (n4<<1);
 
937
        RAST = RASTR+D_X*n4;
 
938
        }
 
939
memset(ua,0xFF,dy<<1);
 
940
memset(da,0xFF,dy<<1);
 
941
i = end1+ol-1;
 
942
n[i] =(Word8) CenterVertInterval( RAST, D_X, n2, i,&ua[i],&da[i] );
 
943
                                /* ����᭮� ���� �����            */
 
944
for(mean=l_real=0,i=end1+ol;i<=beg2-or;i++)
 
945
        {       /* ⠡��� ���⮢ �।�� ���⨪����� ���ࢠ���     */
 
946
        n[i] =(Word8)CenterVertInterval( RAST, D_X, n2, i,&ua[i],&da[i] );
 
947
        mean += n[i];
 
948
        if( n[i] )              /* mean   - �㬬�   ����⮢         */
 
949
                l_real++;       /* l_real - �᫮ ���㫥��� ����⮢    */
 
950
        }
 
951
n[i] = (Word8)CenterVertInterval( RAST, D_X, n2, i,&ua[i],&da[i]);
 
952
                                /* ����᭮� �����                         */
 
953
if( l!=l_real && (l_real==2 || (n[end1]|n[end1+1]) && (n[beg2]|n[beg2-1])) )
 
954
        {               /* ������⢨� ��४������                   */
 
955
        IN_N_Bonus=2;
 
956
        IN_I_Bonus=2;
 
957
        if( l_real==2 )
 
958
                IN_P_Bonus=1;
 
959
        }
 
960
if( l_real<=1 && ((n[end1]==0&&n[end1+1]==0) || (n[beg2]==0&&n[beg2-1]==0)) )
 
961
        {               /* ������⢨� ��४������                   */
 
962
        IN_N_Bonus=1;
 
963
        IN_P_Bonus=1;
 
964
        IN_I_Bonus=1;
 
965
        if( n[end1]==0 && n[end1+1]==0 && n[beg2]==0 && n[beg2-1]==0 )
 
966
                {
 
967
                IN_P_Bonus=2;
 
968
                IN_N_Bonus=1;
 
969
                IN_I_Bonus=1;
 
970
                }
 
971
        }
 
972
 
 
973
if( no_serific(RASTR,dy,dx,bw) )
 
974
        {       /* ����� ������ � ���ࢠ� ���� [dy/4,dy-dy/4] */
 
975
  Int16 nn4,nn2,h;
 
976
        nn4 = MAX(dy>>2,(LOCAL_W[0]+LOCAL_W[1])>>1);
 
977
  if( nn4>dy/3 ) nn4=dy/4;
 
978
  nn2 = dy - (nn4<<1);
 
979
  RAST = RASTR+D_X*n4;
 
980
        for(mean=l_real=0,i=end1;i<=beg2;i++)
 
981
                {
 
982
                h = n2+n4-(n[i]>>1);
 
983
                if( h<nn4 || h>nn4+nn2 )
 
984
                        n[i]=0;
 
985
                else
 
986
                        {
 
987
                        n[i] += ((nn2+nn4-n2-n4)<<1);
 
988
                        if( n[i]>=(nn2<<1) )
 
989
                                n[i]=0;
 
990
                        else if( n[i] &&
 
991
                                 (i!=end1||i==end1&&ol==0) &&
 
992
                                 (i!=beg2||i==beg2&&or==0) )
 
993
                                {
 
994
        mean += n[i];
 
995
                                l_real++;
 
996
                                }
 
997
                        }
 
998
                }
 
999
        n2=nn2;
 
1000
        n4=nn4;
 
1001
        }
 
1002
if( l_real<4 )
 
1003
         {
 
1004
         i = beg2-or+1;
 
1005
         if( or && n[i] && VertSum(RAST, D_X, n2, i)<n2-1 &&
 
1006
                NumVertInterval(RAST, D_X, n2, i)==1 )
 
1007
                {       /* ���뢠�� ��᫥���� ����� */
 
1008
                mean += n[i];
 
1009
                or--;
 
1010
                l_real++;
 
1011
                l++;
 
1012
                }
 
1013
         i = end1+ol-1;
 
1014
         if( ol && n[i] && VertSum(RAST, D_X, n2, i)<n2-1 &&
 
1015
                NumVertInterval(RAST, D_X, n2, i)==1 )
 
1016
                {       /* ���뢠�� ��᫥���� ����� */
 
1017
                mean += n[i];
 
1018
                ol--;
 
1019
                l_real++;
 
1020
                l++;
 
1021
                }
 
1022
         }
 
1023
if( l_real<=1 )
 
1024
{
 
1025
Int16 dy1=n2/*dy>>1*/,nn,mm,mm1,minup,mindown,zaz;
 
1026
Word8 *rrrr,*rrrr1;
 
1027
zaz = beg2 - end1;
 
1028
for(    minup=mindown=zaz, rrrr=RASTR, rrrr1=RASTR+(dy-1)*D_X, i=0;
 
1029
        i<3;    i++, rrrr+=D_X, rrrr1-=D_X)
 
1030
        {
 
1031
        mm = zaz-SumIntervalBits(rrrr,end1,beg2)/3;
 
1032
        if( minup>mm )
 
1033
                minup = mm;
 
1034
        mm1 = zaz-SumIntervalBits(rrrr1,end1,beg2)/3;
 
1035
        if( mindown>mm1 )
 
1036
                mindown = mm1;
 
1037
        nn=dx-SumBits(rrrr,bw);
 
1038
        if( nn<2 )
 
1039
                break;
 
1040
        }
 
1041
if( i<3 || (minup*2<mindown && minup*3<zaz && zaz>3) )
 
1042
        { /* ���� ������ ���誠 */
 
1043
        IN_N_Bonus=IN_I_Bonus=1;IN_P_Bonus=2;
 
1044
        }
 
1045
else
 
1046
        {
 
1047
        if( (nn=n[end1+ol])>0 )
 
1048
                {
 
1049
                IN_N_Bonus=IN_I_Bonus=IN_P_Bonus=1;
 
1050
                if( abs(nn-dy1)<3 )
 
1051
                        IN_N_Bonus=2;
 
1052
                else if( nn<dy1-2 )
 
1053
                        IN_I_Bonus=2;
 
1054
                }
 
1055
        else    if( (nn=n[beg2-or])>0 )
 
1056
                {
 
1057
                IN_N_Bonus=IN_I_Bonus=IN_P_Bonus=1;
 
1058
                if( abs(nn-dy1)<3 )
 
1059
                        IN_N_Bonus=2;
 
1060
                else if( nn>dy1+2 )
 
1061
                        IN_I_Bonus=2;
 
1062
                }
 
1063
        }
 
1064
}
 
1065
{
 
1066
Int16 z=beg2-end1+1;
 
1067
if( z>4 && l_real*2>z )
 
1068
        IN_IN_Monus=1;  /* � ��४������ ࠧ�� � �����쪨� ! */
 
1069
if(     l_real>4        ||      l-l_real<=3 && l>5 ||
 
1070
        l_real==4 && fill_center ||
 
1071
        l_real<2 && z<4 && n4<6 ||
 
1072
        z>10 && l_real<3 )
 
1073
        {
 
1074
    if( l_real>1 )
 
1075
            IN_P_Bonus=0;
 
1076
    /*IN_P_Bonus=*/IN_I_Bonus=IN_N_Bonus=0;
 
1077
        }
 
1078
 
 
1079
}
 
1080
 
 
1081
if( l_real>1 )
 
1082
        {
 
1083
        for(i=end1+ol;i<=beg2-or;i++)
 
1084
                if( (neue=n[i])!=0 )
 
1085
                        hist[ neue ]++;
 
1086
 
 
1087
        mean=mean/l_real+((mean%l_real)>(l_real>>1));
 
1088
                                /* mean   - �।��� �����         */
 
1089
 
 
1090
        if( hist[mean-1]>l_real-2 )
 
1091
                mean--;
 
1092
        if( hist[mean+1]>l_real-2 )
 
1093
                mean++;
 
1094
 
 
1095
if( l_real!=l && !(l_real==l-1 && (n[end1]==0||n[beg2]==0) ) )
 
1096
if( !fill_center && l_real<=4 || l_real<=3 )
 
1097
        {
 
1098
  Int16 an[2],en[2],ll,dy1=n2,san[2],sen[2],z;
 
1099
        /* ���� ���饩 �� '�' �� �।��� ����� */
 
1100
        an[0]=n[end1];
 
1101
        an[1]=n[end1+1];
 
1102
        en[0]=n[beg2-1];
 
1103
        en[1]=n[beg2];
 
1104
        for(ll=i=0;i<2;i++)
 
1105
                {
 
1106
                sen[i]=n[beg2-i];
 
1107
                san[i]=n[end1+i];
 
1108
                if( an[i]>0 )
 
1109
                        {
 
1110
                        if( abs(an[i]-dy1)>2 )
 
1111
                                an[i]=-1;
 
1112
                        else
 
1113
                                n[end1+i]=(Word8)dy1,ll++;
 
1114
                        }
 
1115
                if( en[i]>0 )
 
1116
                        {
 
1117
                        if( abs(en[i]-dy1)>2 )
 
1118
                                en[i]=-1;
 
1119
                        else
 
1120
                                n[beg2-i]=(Word8)dy1,ll++;
 
1121
                        }
 
1122
                }
 
1123
        if( IN_I_Bonus==2 && ll==1 )
 
1124
                IN_I_Bonus=1;
 
1125
        if( ll>2 || ll==2 && broken_flag )
 
1126
                {
 
1127
                for(i=0;i<2;i++)
 
1128
                        {
 
1129
                        if( an[i]>0 )
 
1130
                                n[end1+i]=(Word8)dy1;
 
1131
                        if( en[i]>0 )
 
1132
                                n[beg2-i]=(Word8)dy1;
 
1133
                        }
 
1134
                mean =  dy1;
 
1135
                fill_center=1;
 
1136
                IN_N_Bonus=2;
 
1137
                IN_P_Bonus=IN_I_Bonus=0;
 
1138
                }
 
1139
        else
 
1140
                {
 
1141
                for(i=0;i<2;i++)
 
1142
                        {
 
1143
                        n[beg2-i]=(Word8)sen[i];
 
1144
                        n[end1+i]=(Word8)san[i];
 
1145
                        }
 
1146
        /* ���� ���饩 �� '�' �� ࠧ�� ��஭� �� �।��� ����� */
 
1147
                an[0]=n[end1];
 
1148
                an[1]=n[end1+1];
 
1149
                en[0]=n[beg2-1];
 
1150
                en[1]=n[beg2];
 
1151
                for(ll=i=0;i<2;i++)
 
1152
                        {
 
1153
                        z=VertSum(RAST, D_X, n2, (Int16)(end1+i));
 
1154
                        if( an[i]>0 && an[i]<dy1-2 && z<n4 )
 
1155
                                ll++;
 
1156
                        z=VertSum(RAST, D_X, n2, (Int16)(beg2-i));
 
1157
                        if( en[i]>0 && en[i]>dy1+2 && z<n4)
 
1158
                                ll++;
 
1159
                        }
 
1160
#ifndef Int16ERSEPTOR
 
1161
    if( ll>2 || ll==2 && broken_flag && !rotate)
 
1162
#else
 
1163
    if( ll>3 || ll==2 && broken_flag && !rotate)
 
1164
#endif
 
1165
                        {
 
1166
                        fill_center=1;
 
1167
                        IN_I_Bonus=2;
 
1168
                        IN_P_Bonus=IN_N_Bonus=0;
 
1169
                        }
 
1170
                }
 
1171
        }
 
1172
else
 
1173
{
 
1174
if( fill_center && l_real>l-3 && l>2 )
 
1175
{
 
1176
Int16 lim = (beg2-or-end1+ol)>>1;
 
1177
for(t=0,i=end1+ol;i<=lim;i++)
 
1178
        if( n[i]>((n2-2)<<1) )
 
1179
                t++;
 
1180
        if( t>=MAX(2,(l_real>>1)) )
 
1181
        {               /* ��४������ ᫨誮� ��᮪�                   */
 
1182
        fill_center=0;  /* ���४�� ���� �� �������⢨� ��४������   */
 
1183
        IN_N=4;
 
1184
        IN_I=1;
 
1185
        IN_dis=1;
 
1186
        return;
 
1187
        }
 
1188
}
 
1189
 
 
1190
if( fill_center && l_real<2 && l>4 )
 
1191
        {               /* ������ ������⢨� ��४������            */
 
1192
        fill_center=0;  /* ���४�� ���� �� �������⢨� ��४������   */
 
1193
        IN_N=4;
 
1194
        IN_I=1;
 
1195
        IN_dis=1;
 
1196
        return;
 
1197
        }
 
1198
}
 
1199
 
 
1200
 
 
1201
for(old=incr=decr=fine=0,i=end1+ol,rmin=dy,rmax=0;i<=beg2-or;i++)
 
1202
        if( (neue=n[i])!=0 )
 
1203
                {       /* fine - �㬬� ����ﭨ� �� �।����  */
 
1204
                if( old==0 )
 
1205
                        old = neue;/* ���� ���㫥��� �����        */
 
1206
                if( neue>rmax )
 
1207
                        rmax=neue;
 
1208
                if( neue<rmin )
 
1209
                        rmin=neue;
 
1210
                if( neue>mean )
 
1211
                        fine += neue - mean;
 
1212
                else
 
1213
                        fine += mean-neue;
 
1214
                if( neue>old )
 
1215
                        incr++;   /* �᫮ ᪠窮� �����⠭��    */
 
1216
                else if( neue<old )
 
1217
                        decr++;   /* �᫮ ᪠窮� �뢠���       */
 
1218
                old = neue;
 
1219
                }
 
1220
if( fine && rmax-rmin<=2 && !(l_real==3 && incr==2) )
 
1221
        fine=0; /* �� ������ � 2-� ������ */
 
1222
if( fine && l_real==3 && incr==2 )
 
1223
        fine+=2;        /* 2 ᪠窠 � 3-� �⮫��� */
 
1224
 
 
1225
if( omni ){
 
1226
Int16 fin=fine,inc=incr,dec=decr;
 
1227
 
 
1228
neue = n[end1];
 
1229
if( ol && neue && neue<n[end1+1] )
 
1230
        {
 
1231
        if( neue>mean )
 
1232
                fin += neue - mean;
 
1233
        else
 
1234
                fin += mean-neue;
 
1235
        inc++;   /* �᫮ ᪠窮� �����⠭��     */
 
1236
        }
 
1237
 
 
1238
neue = n[beg2];
 
1239
if( or && neue && neue>n[beg2-1])
 
1240
        {
 
1241
        if( neue>mean )
 
1242
                fin += neue - mean;
 
1243
        else
 
1244
                fin += mean-neue;
 
1245
        inc++;   /* �᫮ ᪠窮� �����⠭��     */
 
1246
        }
 
1247
/* ����讥 �室�⢮ � '�' */
 
1248
if( fin>10 && inc>3 && dec<1  && LOCAL[0] <= dx/4)
 
1249
        IN_M=80;
 
1250
else if( fin>10 && inc>2 && dec==0 && LOCAL[0] <= dx/4)
 
1251
        IN_M=80;
 
1252
else
 
1253
        IN_M=0;
 
1254
        }
 
1255
if(     abs(incr-decr)<2 &&     /* ������� ���祭�� ᪠窮�   */
 
1256
        (incr>1 &&              /* ����� 1 �����⠭��             */
 
1257
        decr>1 ||               /* ����� 1 �뢠���                */
 
1258
        incr && decr && incr+decr<4 ) &&        /* ���� ᪠窮� */
 
1259
        fine<=l                 /* ����� ��ᯥ���         */
 
1260
  )
 
1261
                fine=0;
 
1262
if( incr<2   &&            /* ������� �����⠭��   */
 
1263
    l_real>4 &&            /* �� �ப�� ��४������ */
 
1264
    decr && incr+decr<4 )  /* ᪠窮� �������        */
 
1265
 fine=0;
 
1266
if( incr*2<decr && l_real>4 ) /* too many incr */
 
1267
    fine = 0;
 
1268
        if( fine>2 && incr<2 && decr>1 && l>3 )
 
1269
                fine -= 2;              /* �ᥣ� 1 �����⠭��               */
 
1270
        t = (incr<=1)&&(decr<=1);
 
1271
        for(i=end1+ol; n[i]==0 && i<=beg2-or;i++); /* skip empty columns */
 
1272
        for(equ=incr=0,old=n[i++];i<=beg2-or;i++)
 
1273
                {
 
1274
                if( n[i] )
 
1275
                        neue=n[i];
 
1276
                else
 
1277
                        continue;
 
1278
                if( neue>old )
 
1279
                        incr += neue-old;
 
1280
                old = neue;
 
1281
                }
 
1282
        if( t==0 )              /* ����� 1-�� �����⠭�� ��� �뢠���        */
 
1283
                fine += incr ;  /* �������� ���� �� �����⠭��    */
 
1284
        for(t=equ=i=0;i<dy;i++)
 
1285
                if( hist[i]>equ )
 
1286
                        equ=hist[(t=i)];
 
1287
        if(     fine>1 && equ>2 && t==mean && or==0 && ol==0 &&
 
1288
                n[end1]<mean && mean<n[beg2] && equ+2==l_real )
 
1289
                        fine=0; /* 1-� � ��᫥���� ᪠窨 �   */
 
1290
                                /* ࠧ�ࢠ���� ����, ���ࢠ�  */
 
1291
                                /* ������⢠ ����� 3              */
 
1292
        if( equ>1 && fine<6 )
 
1293
                {
 
1294
    Int16 fineold=fine;
 
1295
                t = n4 + n2 - (t>>1);
 
1296
                for( RAST=RASTR+D_X*(t-2),i=t-2;i<=t+2;i++,RAST+=D_X)
 
1297
                        if( SumIntervalBits(RAST,end1,(Int16)(beg2+1))==
 
1298
                                (beg2-end1+1)*3 )
 
1299
                                {               /* ���� ��४������ */
 
1300
                                fine=0;
 
1301
                                break;
 
1302
                                }
 
1303
                if( equ==2 && (ol&&n[end1+ol] || or&&n[beg2-or]) )
 
1304
                        fine=fineold;
 
1305
                }
 
1306
 
 
1307
        if( l_real<5 && equ>2 )
 
1308
                fine=0;         /* 3 �� 4(��� <4) ᮢ������               */
 
1309
        if( l_real>4 && equ>l_real-2 )
 
1310
                fine = 0;       /* ᮢ������ l-1 �� l ����⮢               */
 
1311
        jump=0;
 
1312
        if( equ==l-1 )
 
1313
                {               /* �����⢥��� �ᯫ��                       */
 
1314
                i=end1+ol;
 
1315
                if( n[i]!=0 && n[i]<n[i+1] && n[i+2]==n[i+1] )
 
1316
                        {
 
1317
                        fine=0; /* �����⢥��� ���� �ᯫ��          */
 
1318
                        jump=1;
 
1319
                        }
 
1320
                else
 
1321
                        {
 
1322
                        i=beg2-or;
 
1323
                        if( n[i-1]!=0 && n[i]>n[i-1] && n[i-2]==n[i-1] )
 
1324
                                {
 
1325
                                fine=0;
 
1326
                                /* �����⢥��� �ࠢ� �ᯫ��           */
 
1327
                                jump=1;
 
1328
                                }
 
1329
                        }
 
1330
                }
 
1331
if( l_real>2 )
 
1332
        {               /* ��ନ஢�� ������������ ����     */
 
1333
        fine <<= 5;     /* *32 ?????????????                    */
 
1334
        fine /= l_real; /* ��⨭��� �ਭ�                   */
 
1335
        fine /= n2;     /* ����                         */
 
1336
        }
 
1337
 
 
1338
        }
 
1339
else
 
1340
        {
 
1341
        fine=0;         /* l_real<2 : �� ����� �業��� ��ࠧ        */
 
1342
        IN_dis=1;
 
1343
        IN_equ=IN_N=0;
 
1344
        IN_I=3;
 
1345
        IN_pics=0;
 
1346
        if( fill_center && l>2 )
 
1347
                fill_center=0;  /* ���४�� ���� �� �������⢨� ��४������ */
 
1348
        if(     !fill_center && l_real==1 &&
 
1349
                (NumVertInterval(RAST, D_X, n2, end1)==1 &&
 
1350
                 VertSum(RAST,D_X,n2,end1)<n4 &&
 
1351
                 n[end1] && abs(n[end1]-(dy>>1))<3 ||
 
1352
                 NumVertInterval(RAST, D_X, n2, beg2)==1 &&
 
1353
                 VertSum(RAST,D_X,n2,beg2)<n4 &&
 
1354
                 n[beg2] && abs(n[beg2]-(dy>>1))<3) )
 
1355
                fill_center=2;
 
1356
 
 
1357
        return;
 
1358
        }
 
1359
 
 
1360
IN_N=IN_I = fine;       /*           ���� �� �����⠭��   */
 
1361
if( incr<2 && l_real>5 && decr>4 )
 
1362
        {
 
1363
        if( fine>6 )
 
1364
                IN_N=5;
 
1365
        IN_I=1;   /* similar to N */
 
1366
  }
 
1367
if( incr<1 && l_real>3 && decr>l_real/2 )
 
1368
        {
 
1369
    IN_N=6;
 
1370
        IN_I=1;   /* similar to N */
 
1371
    }
 
1372
if( !fine && IN_M==0 && l_real>3 && decr>=l_real/3 && decr>1 )
 
1373
    {
 
1374
    IN_N=6;
 
1375
        IN_I=1;   /* similar to M */
 
1376
    }
 
1377
if( fine==0 && jump )
 
1378
        IN_I=3;
 
1379
if( !fill_center && (l_real>3 || l_real>l-3) && l>2 && mean*4<dy*3 )
 
1380
        {
 
1381
        if( l_real>2 || n[end1] && n[beg2] )
 
1382
#ifdef Int16ERSEPTOR
 
1383
  if( l_real>5 )
 
1384
#endif
 
1385
  if( !rotate || l_real>3 )
 
1386
  fill_center=1;  /* ���४�� ���� �� �������⢨� ��४������ */
 
1387
        }
 
1388
if( fine>5 && l_real==2 && !broken_flag && incr==0 && decr==1 )
 
1389
        {
 
1390
        IN_N=4;
 
1391
        IN_I=2;
 
1392
        fill_center=0;
 
1393
        }
 
1394
IN_dis=1;
 
1395
equ -= l-2;
 
1396
IN_equ = (equ>0)?2+equ:0;       /* IN_equ -���� �� ������⢮ */
 
1397
 
 
1398
if( DiskrHorizIN(RASTR,D_X,dy) )
 
1399
                        {   /* ��ୠ� ��४������ */
 
1400
                        IN_N=3;
 
1401
                        IN_I=2;
 
1402
                        }
 
1403
if( omni )
 
1404
        {       /* '�' ��⠥��� � '�' */
 
1405
  Int16 i,le,ri,nnn=(beg2+end1+ol-or)/2;
 
1406
        if( fine>15 && decr>3 || fine>20 && decr>2 ||
 
1407
            fine>10 && incr<1 && decr>3 ) //RUS_ENG_LANG
 
1408
                IN_I=1;
 
1409
        if( l_real>4 && fine>9 )
 
1410
        {
 
1411
        for(old=n[end1+ol],le=0,i=end1+ol;i<nnn;i++)
 
1412
                {
 
1413
                neue = n[i];
 
1414
                if( neue )
 
1415
                        {
 
1416
                        if( neue<old )
 
1417
                                le++;
 
1418
                        old=neue;
 
1419
                        }
 
1420
                }
 
1421
        for(old=n[i],ri=0;i<beg2-or;i++)
 
1422
                {
 
1423
                neue = n[i];
 
1424
                if( neue )
 
1425
                        {
 
1426
                        if( neue>old )
 
1427
                                ri++;
 
1428
                        old=neue;
 
1429
                        }
 
1430
                }
 
1431
        if( le>3 && ri>3 )
 
1432
                IN_I=1;
 
1433
        }
 
1434
        }
 
1435
 
 
1436
{
 
1437
Int16 up_skip=vert_stairs(&ua[end1],(Int16)(beg2-end1+1));
 
1438
Int16 down_skip=vert_stairs(&da[end1],(Int16)(beg2-end1+1));
 
1439
 
 
1440
if( IN_I<=3 )
 
1441
if( up_skip>3 && down_skip>3 ||
 
1442
    up_skip>1 && down_skip>1 && up_skip+down_skip>4 )
 
1443
        {
 
1444
        IN_N=4;
 
1445
        IN_I= 4;
 
1446
        IN_dis=1;
 
1447
        IN_equ=0;
 
1448
        return;
 
1449
        }
 
1450
}
 
1451
 
 
1452
return;
 
1453
}                       /*              DiskrIN                 */
 
1454
 
 
1455
/***************************************************************************/
 
1456
Int16 DiskrHorizIN(Word8 *RASTR,Int16 D_X,Int16 dy)
 
1457
/***************************************************************************/
 
1458
/****     *RASTR     㪠��⥫�   ��  ���ᨢ                         ********/
 
1459
/****      dy        k�����⢮  ��ப                              ********/
 
1460
/****      D_X       ������⢮  ���⮢  �  ��ப�                  ********/
 
1461
/***************************************************************************/
 
1462
{  Word8 n[256];
 
1463
   Int16  i,j,n2=dy-2*(dy>>2),n4=dy>>2,imax,nmax,kmax;
 
1464
   Int16 l = beg2 - end1 ,h;
 
1465
   Word8 *RAST = RASTR+D_X*n4;
 
1466
 
 
1467
 
 
1468
if( IN_horiz_dis>=0 )
 
1469
        return(IN_horiz_dis);
 
1470
 
 
1471
if( l<4 )
 
1472
        { /* ����� ����ﭨ� */
 
1473
        IN_horiz_dis=0;
 
1474
        return(IN_horiz_dis);
 
1475
        }
 
1476
 
 
1477
for(imax=nmax=kmax=-1,i=n4,j=0;j<=n2;j++,i++,RAST+=D_X)
 
1478
        {       /* ������� �����        */
 
1479
        n[i] = SumIntervalBits(RAST,end1,beg2)/3;
 
1480
        if( n[i]>nmax )
 
1481
                {
 
1482
                nmax = n[i];
 
1483
                imax = i;
 
1484
                kmax=1;
 
1485
                }
 
1486
        else if( n[i]==nmax )
 
1487
                kmax++;
 
1488
        }
 
1489
 
 
1490
if( imax>0 && nmax==l && kmax>1 )
 
1491
        {
 
1492
        for(i=imax;n[i]==nmax;i--);
 
1493
        h = ( n[i-1]==0 && n[i]<3 || n[i]<2 ) ;
 
1494
        for(i=imax;n[i]==nmax;i++);
 
1495
        l = ( n[i+1]==0 && n[i]<3 || n[i]<2 ) ;
 
1496
        }
 
1497
else
 
1498
        l=h=0;
 
1499
 
 
1500
return (IN_horiz_dis= (h&&l) ) ;
 
1501
}                       /*              DiskrHorizIN            */
 
1502
 
 
1503
Int16 fill_center_zone(Word8 *raster,Int16 D_X,Int16 dy,
 
1504
      Int16 beg, Int16 end, Int16 II)
 
1505
{
 
1506
Int16 i,num,l,ny,d=((end-beg)>>1),p, white, w;
 
1507
Word8 *r=raster;
 
1508
 
 
1509
#ifdef INTERSEPTOR
 
1510
end--;beg++;
 
1511
d=((end-beg)>>1);
 
1512
#endif
 
1513
 
 
1514
if( fill_center>=0 )
 
1515
        return( fill_center );
 
1516
 
 
1517
p = (end-beg>3 );
 
1518
if( rotate )    p=0; // OLEG : ERECTION CONDITION
 
1519
white=end+p-beg+1;
 
1520
 
 
1521
for(ny=num=i=0;i<dy;i++,r+=D_X)
 
1522
        {
 
1523
        l = SumIntervalBits(r,beg,(Int16)(end+p))/3;
 
1524
        if( i==0 && l>=d )
 
1525
                continue;
 
1526
    w = end+p-beg-l;
 
1527
        if( white>w )
 
1528
        white=w;
 
1529
    if( l )
 
1530
                {
 
1531
                num += l;   // SUM of black bits in critical lines
 
1532
        //if( l>d )
 
1533
                //      num+=l;
 
1534
        ny++;       // num of critical lines
 
1535
                }
 
1536
        }
 
1537
 
 
1538
if( ny  )
 
1539
        {
 
1540
  if( !(rotate && (dnri_hook||II) ) )
 
1541
                {
 
1542
                if( end - beg < 5 )
 
1543
                        fill_center = ( num>ny ) ;
 
1544
                else
 
1545
                        fill_center = ( num>(ny<<1) );
 
1546
                }
 
1547
        else
 
1548
                {
 
1549
                fill_center = 0;
 
1550
    if( rotate )
 
1551
      {
 
1552
      if( white<2 && dnri_hook )
 
1553
        fill_center = 1;
 
1554
      else if( d>2 && white<d )
 
1555
        fill_center = 1;
 
1556
      }
 
1557
                }
 
1558
        }
 
1559
else
 
1560
        fill_center = 0;
 
1561
return( fill_center );
 
1562
}
 
1563
 
 
1564
Int16 up_down_hist_M(Word8 *rastr,Int16 D_X, Int16 Dx,Int16 dy)
 
1565
{
 
1566
Int16 i,j,d,h=dy>>1,s,t,n;
 
1567
Word8 *r;
 
1568
 
 
1569
Dx =  bytlen(Dx);
 
1570
for(s=j=0,i=0,r=rastr+i*D_X;i<h;j++,i++,r+=D_X)
 
1571
        {
 
1572
        n = NumHorizInterval( r, Dx ) ;
 
1573
        s += (n==2);
 
1574
        if( s>2 )               break;
 
1575
        if( j>3 && s==0 )       break;
 
1576
        }
 
1577
if( s<2 )                       return(0);
 
1578
 
 
1579
for(t=d=j=0,i=dy-1,r=rastr+i*D_X; i>=h;i--,j++,r-=D_X)
 
1580
        {
 
1581
        n = NumHorizInterval( r, Dx ) ;
 
1582
        t += (n==3);
 
1583
        d += (n==2);
 
1584
        if( d>2 )               break;
 
1585
        if( t>2 )               break;
 
1586
        if( j>3 && t==0 )       break;
 
1587
        }
 
1588
 
 
1589
if( t<2 )                       return(0);
 
1590
 
 
1591
if( s>3 && t>3 )                return( 8 );
 
1592
return(4);
 
1593
}
 
1594
 
 
1595
Int16 broken_M(Word8 * r,Int16 D_X,Int16 dy,Int16 left_lim,Int16 ll)
 
1596
{
 
1597
Int16 i,old,neue,dest,sign,fc,maxd,incr;
 
1598
Word8 *rr;
 
1599
if( broken_M_pen>=0 )
 
1600
        return broken_M_pen;
 
1601
old=RightDistance(r,D_X);
 
1602
for(rr=r+D_X,i=1;i<dy;i++,rr+=D_X)
 
1603
        {
 
1604
        neue=RightDistance(rr,D_X);
 
1605
        if( abs(neue-old)>1 )
 
1606
                return (broken_M_pen=0);/* ����אַ� �ࠢ� ���� */
 
1607
        old=neue;
 
1608
        }
 
1609
/* ��אַ� �ࠢ� ���� */
 
1610
old=LeftDistance(r,D_X);
 
1611
dest=old;
 
1612
 
 
1613
for(maxd=fc=sign=incr=0,dest=old,rr=r+D_X,i=1;i<dy;i++,rr+=D_X)
 
1614
        {
 
1615
        neue=LeftDistance(rr,D_X);
 
1616
        if( neue<old )
 
1617
                {
 
1618
                if( neue==old-1 )
 
1619
                        {
 
1620
                        if( sign )      return (broken_M_pen=0);
 
1621
                        else            sign=1;
 
1622
                        }
 
1623
                else
 
1624
                return(broken_M_pen=0);/* ������⮭����� ������ ���� */
 
1625
                }
 
1626
        if( neue>=ll )  fc++;
 
1627
        if( maxd<neue )
 
1628
                maxd=neue;
 
1629
  if( neue>=old  ) incr++;
 
1630
        old=neue;
 
1631
        }
 
1632
dest = neue - dest;             /* ᪠箪 ����⮭���� ������ ���� */
 
1633
if( left_lim==ll )
 
1634
        left_lim=3;
 
1635
return(broken_M_pen= ((dest>left_lim ||
 
1636
  (dest>left_lim-2&&left_lim>5||dest==left_lim&&left_lim>4)&&incr>dy/2)
 
1637
                        && fc<3 && maxd>3) );
 
1638
}
 
1639
 
 
1640
 
 
1641
Int16 Num2Interval(Word8 *r,Int16 D_X,Int16 dx,Int16 dy)
 
1642
{
 
1643
Int16 i,n2,p,d;
 
1644
d = bytlen(dx);
 
1645
for(i=1;i<3;i++)
 
1646
if(     (p=NumHorizInterval(r-D_X*i,d))==1 &&
 
1647
        (n2=SumBits(r-D_X*i,d))>dx-2 )
 
1648
        return(0);
 
1649
for(n2=i=0;i<dy; i++, r+=D_X )
 
1650
        {
 
1651
        p=NumHorizInterval(r,d);
 
1652
        /*  NumHorizInterval : number of intervals in line  */
 
1653
        n2 += (p==2 );
 
1654
        }
 
1655
return ( n2==dy );
 
1656
}
 
1657
/* DiskrRight : check left hole */
 
1658
Int16 DiskrRight(Word8 *RASTR,Int16 D_X,Int16 dx,Int16 dy,Int16 L)
 
1659
{
 
1660
Int16 sum,p,x,dl,Ly,i,p_old,curr_sum,h;
 
1661
Int16 minr,maxr,ddy;
 
1662
Word8 *RASTER=RASTR+D_X*(dy>>2),*R;
 
1663
if( right_dist[L]>=0 )
 
1664
        return( right_dist[L] );
 
1665
 
 
1666
Ly=dy-2*(dy>>2);
 
1667
h=Ly;
 
1668
R=RASTER;
 
1669
 
 
1670
dl=(((dx+7)>>3)<<3);
 
1671
ddy = dy>30 ? (dy>>3):(dy>>2);
 
1672
MinMaxRight(RASTER,D_X,(Word8)dx,(Word8)Ly,&minr,&maxr);
 
1673
x = maxr - minr;
 
1674
if( maxr-((dx&7)?(8-(dx&7)):0)>(dx>>1) )
 
1675
        {
 
1676
  right_max = maxr-minr;
 
1677
  right_line=0;
 
1678
        return( (right_dist[L]=1) );
 
1679
        }
 
1680
right_dist[L] = ( x>=L );
 
1681
if( right_dist[L] )       /* big hole */
 
1682
        {
 
1683
        right_line=0;
 
1684
        if( dy>17 )
 
1685
        while( VertSum(R,D_X,h,(Int16)(dl-minr))<ddy && minr<maxr)minr++;
 
1686
        for(p_old=-1,sum=curr_sum=0,i=minr ; i<=maxr ; i++ )
 
1687
                {
 
1688
                p = NumVertInterval(R, D_X, h, (Int16)(dl-i));
 
1689
                if( p>=2 )
 
1690
                        {          /* ��begin 2-intervals�series of columns */
 
1691
                        if( p_old<2 )
 
1692
                                curr_sum=1;
 
1693
                        else curr_sum++;  /* ��account width of hole */
 
1694
                        if( curr_sum>L )break;
 
1695
                        }
 
1696
                else if( p_old>=2 )
 
1697
                        {      /* end 2-intervals�series of columns */
 
1698
                        if(  curr_sum>sum )
 
1699
                                sum=curr_sum;
 
1700
                        if( sum>=L )break;
 
1701
                        }
 
1702
                p_old=p;
 
1703
                }
 
1704
  if( sum==0 && curr_sum )
 
1705
                sum = curr_sum;
 
1706
        right_dist[L]=( sum>=L); /* hole */
 
1707
        }
 
1708
else
 
1709
        right_line=1;
 
1710
 
 
1711
right_max = maxr-minr;
 
1712
return( right_dist[L] );
 
1713
}
 
1714
 
 
1715
 
 
1716
static Int16 DiskrSymSh( Word8 *RASTER, Int16 Wx, Word8 NWIDTH, Word8 NLENGTH)
 
1717
{
 
1718
  Int16 i,old,l,k,d;
 
1719
  Word8 c,w,minw=255,maxw=0;
 
1720
 
 
1721
  FOOT_A(RASTER,Wx,NWIDTH,NLENGTH);   /* projection to horiz axes */
 
1722
 
 
1723
d=(NLENGTH+1)>>1;
 
1724
for(i=0;i<NWIDTH;i++)
 
1725
  BUFFER[i] = (BUFFER[i]>=d); /* binarazing */
 
1726
 
 
1727
for(old=l=k=i=0;i<=NWIDTH;i++)
 
1728
  {
 
1729
    c = (i<NWIDTH) ? BUFFER[i] : 0;
 
1730
  if( old^c )
 
1731
    {
 
1732
        if( c )
 
1733
      l=i;      /* black : ��begin of foot */
 
1734
    else
 
1735
            {               /* white   : end of foot  */
 
1736
            w=i-l;
 
1737
            if (w>maxw)  maxw=w;
 
1738
            if (w<minw)  minw=w;
 
1739
            LOCAL_W[k]=w;    /* width of foot   */
 
1740
            LOCAL[k]=(l+i);  /* center+1/2. Accuracy 1/2 pixel� */
 
1741
            k++;
 
1742
      }
 
1743
    }
 
1744
  old=c;
 
1745
  }
 
1746
 
 
1747
  if ( k != 3 || maxw-minw>1 )
 
1748
    return(0);    // enigmatic image
 
1749
  i=LOCAL[2]+LOCAL[0]-(LOCAL[1]<<1);          //�assimetry
 
1750
  if (i==0)
 
1751
    return (-2);
 
1752
  if (i<0) i=-i;
 
1753
  if( i<3 && NWIDTH>22 )  i=1;  //Oleg:02-13-96: too small for wide image
 
1754
  i=(i<<6)/(32+NWIDTH);
 
1755
  if (i==1)
 
1756
     i=0;
 
1757
  return(i);
 
1758
}
 
1759
 
 
1760
static Int16 DiskrSh(Word8 *RASTR,Int16 D_X,Int16 dx,Int16 Ly)
 
1761
{
 
1762
Word8 *RASTER=RASTR;
 
1763
Int16 i,num,n2,p,ddx;
 
1764
ddx = bytlen(dx);
 
1765
for(n2=num=i=0;i<Ly; i++, RASTER+=D_X )
 
1766
  {
 
1767
  p=NumHorizInterval(RASTER,ddx);
 
1768
  /*  NumHorizInterval : number of intervals in line */
 
1769
  num += ( p!=3 );
 
1770
  n2 += (p==2 );
 
1771
  }
 
1772
 
 
1773
if( n2 )
 
1774
{ /* 2-interval lines are exist */
 
1775
Int16 b=(LOCAL[0]+LOCAL[1])/2,dd=(LOCAL[1]-LOCAL[0])+(LOCAL_W[1]+LOCAL_W[0])/2;
 
1776
i = Ly<<1;
 
1777
i = Ly/3-(Ly>>2);
 
1778
Ly -= i;
 
1779
for(RASTER=RASTR+D_X*i;i<Ly;i++, RASTER+=D_X)
 
1780
  {
 
1781
  p =  SumIntervalBits(RASTER,b,dx)/3;
 
1782
  if( p>=dd && NumHorizInterval(RASTER,ddx)==2 )
 
1783
    return 4;
 
1784
  }
 
1785
}
 
1786
return( num>2?num-2:0 );
 
1787
}
 
1788
 
 
1789
/* for letters III */
 
1790
static Int16 DiskrSh0(Word8 *RASTR,Int16 D_X,Int16 dx,Int16 dy,Int16 dx0)
 
1791
{
 
1792
Word8 *RASTER=RASTR+D_X*(dy-(dy>>2));
 
1793
Int16 i,num,l=dx0-(dx0>>2);
 
1794
if( lower_long_line<0 )
 
1795
{
 
1796
dx = bytlen(dx);
 
1797
for(num=0,i=dy-(dy>>2);i<dy; i++, RASTER+=D_X )
 
1798
  num += ( NumHorizInterval(RASTER,dx)==1 && SumBits(RASTER, dx)>l );
 
1799
    /*  num : number of lines haved one long interval */
 
1800
lower_long_line=num;   /* number of filled lines */
 
1801
}
 
1802
return( lower_long_line );
 
1803
}
 
1804
 
 
1805
/*  DiskrLeft : check left hole */
 
1806
Int16 DiskrLeft(Word8 *RASTR,Int16 D_X,Int16 dx,Int16 dy, Int16 L)
 
1807
{
 
1808
Int16 sum,p,x,i,Ly,p_old,curr_sum,h;
 
1809
Int16 minr,maxr;
 
1810
Word8 *RASTER=RASTR+D_X*(dy>>2),*R;
 
1811
if( left_dist[L]>=0 )
 
1812
  return( left_dist[L] );
 
1813
Ly=dy-2*(dy>>2);
 
1814
h=Ly;
 
1815
R=RASTER;
 
1816
 
 
1817
MinMaxLeft(RASTER,D_X,(Word8)dx,(Word8)Ly,&minr,&maxr);
 
1818
if( minr && maxr )
 
1819
  {
 
1820
  minr--; maxr--;
 
1821
  }
 
1822
x = maxr - minr;
 
1823
if( minr>(dx>>1) )
 
1824
  {
 
1825
  left_max = maxr-minr;
 
1826
  left_line=0;
 
1827
  return( (left_dist[L]=1) );
 
1828
  }
 
1829
left_dist[L]=(x>=L);
 
1830
if( left_dist[L] )              /* big hole */
 
1831
  {
 
1832
        left_line=0;
 
1833
  if( dy>17 )
 
1834
  while( VertSum(R,D_X,h,minr)<(dy>>2) && minr<maxr)minr++;
 
1835
  for(p_old=-1,curr_sum=sum=0,i=minr ; i<=maxr ; i++ )
 
1836
    {
 
1837
    p = NumVertInterval(R, D_X, h, i);
 
1838
    if( p>=2 )
 
1839
      {          /* begin 2-intervals�series of columns */
 
1840
      if( p_old!=2 )
 
1841
        curr_sum=1;
 
1842
      else curr_sum++;  /* ��account width of hole */
 
1843
      if( curr_sum>L )break;
 
1844
                        }
 
1845
    else if( p_old>=2 )
 
1846
      {      /* end 2-intervals�series of columns */
 
1847
      if(  curr_sum>sum )
 
1848
        sum=curr_sum;
 
1849
      if( sum>=L )break;
 
1850
      }
 
1851
    p_old=p;
 
1852
    }
 
1853
  if( sum==0 && curr_sum )
 
1854
    sum = curr_sum;
 
1855
  left_dist[L]=( sum>=L); /* hole */
 
1856
  }
 
1857
else
 
1858
  left_line=1;
 
1859
left_max = maxr-minr;
 
1860
return( left_dist[L] );
 
1861
}
 
1862
 
 
1863
/*  DiskrLeftBig : check big left hole� */
 
1864
Int16 DiskrLeftBig(Word8 *RASTR,Int16 D_X,Int16 dx,Int16 dy, Int16 L)
 
1865
{
 
1866
Int16 sum,p,x,i,Ly,p_old,curr_sum,h;
 
1867
Int16 minr,maxr;
 
1868
Word8 *RASTER=RASTR+D_X,*R;
 
1869
if( left_dist_big[L]>=0 )
 
1870
  return( left_dist_big[L] );
 
1871
 
 
1872
Ly=dy-2;
 
1873
h =  dy ;
 
1874
R =  RASTR;
 
1875
 
 
1876
MinMaxLeft(RASTER,D_X,(Word8)dx,(Word8)Ly,&minr,&maxr);
 
1877
if( minr && maxr )
 
1878
  {
 
1879
  minr--; maxr--;
 
1880
  }
 
1881
x = maxr - minr;
 
1882
left_dist_big[L]=(x>=L);
 
1883
if( left_dist_big[L] )              /* big hole */
 
1884
  {
 
1885
  if( dy>17 )
 
1886
  while( VertSum(R,D_X,h,minr)<(dy>>2) && minr<maxr)minr++;
 
1887
  for(p_old=-1,curr_sum=sum=0,i=minr ; i<=maxr ; i++ )
 
1888
    {
 
1889
    p = NumVertInterval(R, D_X, h, i);
 
1890
    if( p>=2 )
 
1891
      {          /* ��begin 2-intervals�series of columns */
 
1892
      if( p_old!=2 )
 
1893
        curr_sum=1;
 
1894
      else curr_sum++;  /* ��account width of hole */
 
1895
      if( curr_sum>L )break;
 
1896
      }
 
1897
    else if( p_old>=2 )
 
1898
      {      /* end 2-intervals�series of columns */
 
1899
      if(  curr_sum>sum )
 
1900
        sum=curr_sum;
 
1901
      if( sum>=L )break;
 
1902
      }
 
1903
    p_old=p;
 
1904
    }
 
1905
  if( sum==0 && curr_sum )
 
1906
    sum = curr_sum;
 
1907
  left_dist_big[L]=( sum>=L); /* hole */
 
1908
  }
 
1909
 
 
1910
return( left_dist_big[L] );
 
1911
}
 
1912
 
 
1913
/*  DiskrRightBig : check big right hole */
 
1914
Int16 DiskrRightBig(Word8 *RASTR,Int16 D_X,Int16 dx,Int16 dy,Int16 L)
 
1915
{
 
1916
Int16 sum,p,x,dl,Ly,i,p_old,curr_sum,h;
 
1917
Int16 minr,maxr;
 
1918
Word8 *RASTER=RASTR+D_X,*R;
 
1919
if( right_dist_big[L]<0 )
 
1920
{
 
1921
Ly=dy-2;
 
1922
h =  dy ;
 
1923
R =  RASTR;
 
1924
 
 
1925
dl=(((dx+7)>>3)<<3);
 
1926
MinMaxRight(RASTER,D_X,(Word8)dx,(Word8)Ly,&minr,&maxr);
 
1927
x = maxr - minr;
 
1928
right_dist_big[L] = ( x>=L );
 
1929
if( right_dist_big[L] )       /* big hole */
 
1930
  {
 
1931
  if( dy<13 || VertSum(RASTR, D_X, dy, (Int16)(dl-minr))<dy-2)
 
1932
  {
 
1933
  if( dy>17 )
 
1934
  while( VertSum(R,D_X,h,(Int16)(dl-minr))<(dy>>2) && minr<maxr)minr++;
 
1935
  for(p_old=-1,sum=curr_sum=0,i=minr ; i<=maxr ; i++ )
 
1936
    {
 
1937
    p = NumVertInterval(R, D_X, h, (Int16)(dl-i));
 
1938
    if( p>=2 )
 
1939
      {          /* begin 2-intervals�series of columns */
 
1940
      if( p_old<2 )
 
1941
        curr_sum=1;
 
1942
      else curr_sum++;  /* account width of hole */
 
1943
                        if( curr_sum>L )
 
1944
                          {
 
1945
                          sum = curr_sum;
 
1946
                          break;
 
1947
                          }
 
1948
                        }
 
1949
    else if( p_old>=2 )
 
1950
      {      /* end 2-intervals�series of columns */
 
1951
      if(  curr_sum>sum )
 
1952
        sum=curr_sum;
 
1953
      if( sum>=L )break;
 
1954
      }
 
1955
    p_old=p;
 
1956
    }
 
1957
        if( sum==0 && curr_sum )
 
1958
    sum = curr_sum;
 
1959
  right_dist_big[L]=( sum>=L); /* hole */
 
1960
  }
 
1961
  else   right_dist_big[L]=0;  /* no hole - vert line */
 
1962
  }
 
1963
 
 
1964
} /* calc right_dist */
 
1965
return( right_dist_big[L] );
 
1966
}
 
1967
 
 
1968
/* for letters >|< */
 
1969
static Int16 DiskrJ0(Word8 *RASTR,Int16 D_X,Int16 dx,Int16 Ly,Int16 lim)
 
1970
{
 
1971
Word8 *RASTER=RASTR;
 
1972
Int16 i,three,n,all,ret,one;
 
1973
 
 
1974
dx = bytlen(dx);
 
1975
for(one=all=three=i=0;i<Ly; i++, RASTER+=D_X )
 
1976
  {
 
1977
  n = NumHorizInterval(RASTER,dx);
 
1978
  /*  NumHorizInterval : number of intervals in line */
 
1979
  three += ( n==3 );
 
1980
  all   += ( n>=3 );
 
1981
  one   += ( n==1 );
 
1982
  }
 
1983
 
 
1984
if( Ly>9 )
 
1985
        {
 
1986
  ret = (three<lim)?lim-three:0 ;
 
1987
  if( all==Ly && lim>3 )  /* on middle */
 
1988
                ret = 2;
 
1989
        }
 
1990
else
 
1991
  { /* small >|< */
 
1992
  if( three>=lim )
 
1993
    ret = 0;
 
1994
  else
 
1995
    ret = (all<lim)?lim-all:0 ;
 
1996
  }
 
1997
if( lim<=3 && ret && one+all>Ly-3 )
 
1998
  ret=0;
 
1999
return( ret );
 
2000
}
 
2001
 
 
2002
static Int16 DiskrJ(Word8 *RASTR,Int16 D_X,Int16 dx,Int16 dy)
 
2003
{
 
2004
Int16 i,t,tu,td,Ly=dy>>2,ly=dy-2*Ly,p,l=dy>>1;
 
2005
dx = bytlen(dx);
 
2006
for(tu=i=0;i<Ly; i++, RASTR+=D_X )
 
2007
  tu += ( NumHorizInterval(RASTR,dx)==3 );
 
2008
for(td=t=0;i<ly; i++, RASTR+=D_X )
 
2009
        {
 
2010
        p = NumHorizInterval(RASTR,dx);
 
2011
  t += (p==1);
 
2012
  if( i<l )
 
2013
    tu += (p==3);
 
2014
        if( i>l )
 
2015
                td += (p==3);
 
2016
        }
 
2017
for(;i<dy; i++, RASTR+=D_X )
 
2018
  td += ( NumHorizInterval(RASTR,dx)==3 );
 
2019
    /*  NumHorizInterval : number of intervlas in line */
 
2020
return  (
 
2021
  tu>3 && t>=2 && td>3 ||
 
2022
  tu>1 && t>2 && td>1 && tu+td>3
 
2023
  );
 
2024
}
 
2025
 
 
2026
//***************************************************************************
 
2027
//*   return       1 if stick glued to rusian D, otherwise 0                *
 
2028
//***************************************************************************
 
2029
static Int16 DiskrTsh(Word8 *RASTR,Int16 D_X,Int16 dx,Int16 dy,Int16 Dx)
 
2030
{  Word8  j,n4=dy>>2,bool_foot=1;
 
2031
   Word8  bit0,bit1,bit2;
 
2032
   Int16            i,fine=0;
 
2033
   Word8  *RAST;
 
2034
 
 
2035
//****************   check existance two hooks  ******************
 
2036
 
 
2037
 
 
2038
   for (RAST=RASTR+(dy-3)*D_X,i=dy-3;;i--,RAST-=D_X){
 
2039
      j=SumIntervalBits( RAST,(Int16)0,(Int16)dx )/3 ;
 
2040
      if(  (j > 5*D_X) || (i<2*n4) ) break;
 
2041
      j=(Word8)NumHorizInterval( RAST, D_X );
 
2042
      if( j > 1 )  fine+=20;
 
2043
   }
 
2044
   if( fine < 30 ){     return ( 0 );   }
 
2045
 
 
2046
//****************    foots configuration       ******************
 
2047
 
 
2048
   bit0 = LOCAL[0] ;
 
2049
   bit1 = LOCAL[1] ;
 
2050
   bit2 = LOCAL[2] ;
 
2051
 
 
2052
//************   check gluing in upper left angle gluing  *************
 
2053
 
 
2054
fine=0;
 
2055
   for (RAST=RASTR,i=0;i<n4;i++,RAST+=D_X){
 
2056
      j=SumIntervalBits(RAST,(Int16)bit0,(Int16)bit1)/3;
 
2057
      if( j >  3*(bit1-bit0)/5 )    fine+=20;
 
2058
      if( j == (bit1-bit0) )        goto end;
 
2059
   }
 
2060
   if( fine < 40 )   { goto   bbb;}//* breaking
 
2061
 
 
2062
//******************  make histogramm   ********************************
 
2063
 
 
2064
   FOOT_A(RASTR, D_X, (Word8)Dx, (Word8)n4); bool_foot=0;
 
2065
 
 
2066
   for(i=bit0+1;i<bit1+1;i++){
 
2067
      if(BUFFER[i]==0)  goto   bbb;//* breaking
 
2068
   }
 
2069
   goto   end;//* gluing
 
2070
 
 
2071
//************   check gluing on upper right angle ************
 
2072
 
 
2073
bbb:fine=0;
 
2074
   for (RAST=RASTR,i=0;i<n4;i++,RAST+=D_X){
 
2075
      j=SumIntervalBits(RAST,(Int16)bit1,(Int16)bit2)/3;
 
2076
      if( j >  3*(bit2-bit1)/5 )     fine+=20;
 
2077
      if( j == (bit2-bit1) )             {  return(1); }
 
2078
   }
 
2079
   if( fine < 40 )   goto   end;// breaking
 
2080
 
 
2081
//******************  make histogramm  ********************************
 
2082
 
 
2083
   if( bool_foot ) FOOT_A(RASTR, D_X, (Word8)Dx, (Word8)n4);
 
2084
   for(i=bit1+1;i<bit2+1;i++){
 
2085
      if(BUFFER[i]==0)  goto   end; // breaking
 
2086
   }
 
2087
   return( 1 );// gluing
 
2088
 
 
2089
end: return ( 0 );
 
2090
 
 
2091
}  // DiskrTsh
 
2092
 
 
2093
 
 
2094
static Int16 average_br_angle(Word8 *RASTER, Int16 D_X, Int16 dx, Int16 dy,
 
2095
        Int16 t)
 
2096
{
 
2097
if( av_br<0 )
 
2098
  av_br=average_angle(RASTER+D_X*(dy-(dy>>2)),
 
2099
    D_X,dx,(Int16)(dy>>2),RightDistance,t);
 
2100
return(av_br);
 
2101
}
 
2102
 
 
2103
static Int16 average_angle(Word8 *RASTER, Int16 D_X, Int16 dx, Int16 dy,
 
2104
       Int16  (*Distance)(Word8 *, Int16), Int16 t)
 
2105
{
 
2106
Int16 i=0,n,p,H;
 
2107
if( t==0 )
 
2108
{       /* cut long lines for finding corners */
 
2109
while( SumBits(RASTER,(Int16)(bytlen(dx)))>(dx>>1) && i<dy )
 
2110
  {
 
2111
  i++;
 
2112
  RASTER+=D_X;  /* black strings */
 
2113
  }
 
2114
}
 
2115
for(H=n=0;i<dy; i++,RASTER+=D_X)
 
2116
  if( (p=Distance(RASTER,(Int16)(bytlen(dx))))>=0 )
 
2117
    {
 
2118
    H++;
 
2119
    n+=p; /* nonzero string */
 
2120
    }
 
2121
return(H?n/H:-1);
 
2122
}
 
2123
 
 
2124
static Int16 DiskrJu(Word8 *RASTR,Int16 D_X,Int16 dx,Int16 Ly)
 
2125
{
 
2126
Word8 *RASTER=RASTR;
 
2127
Int16 i,ret,r,s2,s3,n;
 
2128
dx = bytlen(dx);
 
2129
 
 
2130
for(n=s2=s3=i=0;i<Ly; i++, RASTER+=D_X,n++ )
 
2131
  {
 
2132
  r =  NumHorizInterval(RASTER,dx);
 
2133
  s2 += (r==2);
 
2134
  s3 += (r==3);
 
2135
  }
 
2136
  // NumHorizInterval : �᫮ ���ࢠ��� � ��ப�
 
2137
 
 
2138
n = Ly/3;
 
2139
ret = 0 ;
 
2140
if( s3<n ) ret += n - s3;
 
2141
if( !broken_flag && s2==0 ) ret += 2;
 
2142
return  (ret) ;
 
2143
}
 
2144
 
 
2145
static Int16 DiskrimM1(Word8 *RAST,Int16 D_X,Int16 dx,Int16 dy)
 
2146
{
 
2147
   Int16    n2,n4=dy>>2,meanBit=dx>>1; /* Oleg & Vova 09.03.94 */
 
2148
   Int16    i,j,k,up=0,down=0,cUp=0,cDown=0;
 
2149
   Int16    prev=0,byte=0;
 
2150
   Word8   *r;
 
2151
 
 
2152
/*  calculate  mean  of  hole  */
 
2153
   for(r=RAST+D_X,i=0;i<n4;i++,r+=D_X){
 
2154
      j = NumHorizInterval( r, D_X );
 
2155
      if( j == 2 ){
 
2156
   if( ( j = NumHorizInterval( r+D_X, D_X ) ) ==2 ){
 
2157
      r += D_X;
 
2158
   }
 
2159
   for(k=0;k<dx;k++){
 
2160
      byte=k>>3;
 
2161
      byte=*(r+byte);
 
2162
      byte >>= ( 7- (k % 8) );
 
2163
      byte &= 0x1;
 
2164
      if( !byte && prev  && !down )  down = k;
 
2165
      if(  byte && !prev && down )   up   = k;
 
2166
      prev = byte;
 
2167
   }
 
2168
   meanBit = ( up+down+(dx>>1) )/3;
 
2169
   /* for  no  wide  letters */
 
2170
   if( (up-down < 5) || (dx<dy) )  meanBit = ( up+down )/2;
 
2171
   break;
 
2172
      }
 
2173
   }
 
2174
 
 
2175
/*  calculate  heigth  of  hole  */
 
2176
   r=RAST+D_X;
 
2177
   byte = 0;
 
2178
   prev = whiteMeanBitLeft(r,D_X,meanBit);
 
2179
   for(i=1;i<dy-1;i++,r+=D_X){
 
2180
      j = whiteMeanBitLeft(r,D_X,meanBit);
 
2181
      if( (j == 0) && (i > n4+1) ){  break;  }
 
2182
      byte += (prev-j);
 
2183
      /* for  'bl */
 
2184
      if( (byte < 1) && (i > n4+2) ){
 
2185
   break;
 
2186
      }
 
2187
      prev = j;
 
2188
   }
 
2189
   if( i > dy-2 )  i = 2*dy/3;
 
2190
   n4 = i>>1;  n2 = 2*n4;
 
2191
 
 
2192
/*  calculate  symetry  of  hole  */
 
2193
   down = up = byte = 0;
 
2194
   r=RAST+D_X;
 
2195
   prev = whiteMeanBitLeft(r,D_X,meanBit);
 
2196
   for(i=1;i<=n2;i++,r+=D_X){
 
2197
      j = whiteMeanBitLeft(r,D_X,meanBit);
 
2198
      if( i<=n4 ){  up   += j;  cUp++;    }
 
2199
      else       {  down += j;  cDown++;  }
 
2200
      /* too  wide  hole */
 
2201
      if( (i>n4) && (j>dx/5) ){
 
2202
   if( (cUp==0) || (cDown==0) )  return(0);
 
2203
   if( up*cDown <= down*cUp )    return(4);  /* bl - too  wide  hole */
 
2204
   if( byte < 1 )                return(3);  /* bl - too  wide  hole */
 
2205
      }
 
2206
      byte += (prev-j);
 
2207
      if( (prev-j > 3) && (i>n4) )  return(5);      /* bl - too  big  jump */
 
2208
      if( (byte > 1+dx/8) && (i>n4) )  return( -6 ); /* M - too  big  angle  for  cursive */
 
2209
      prev = j;
 
2210
   }
 
2211
 
 
2212
   if( (cUp != cDown) && (cDown) ){  down *= cUp;  down /= cDown;  }
 
2213
   if( down >= up )  return(5);  /* bl - wide  hole on  the  bottom */
 
2214
   if( down < up )  return(-5); /* M - wide  hole on  the  top */
 
2215
   if( !cDown )  return(6);  /* bl - hole is absent */
 
2216
 
 
2217
   return(0);
 
2218
}  /* DiskrM1 */
 
2219
 
 
2220
static Int16 DiskrimM(Word8 *RAST,Int16 D_X,Int16 dx,Int16 dy)
 
2221
{
 
2222
   Int16    n2,n4=dy>>2,meanBit=dx>>1; /* Oleg & Vova 09.03.94 */
 
2223
   Int16    i,j,k,up=0,down=0,cUp=0,cDown=0;
 
2224
   Int16    prev=0,byte=0;
 
2225
   Word8   *r;
 
2226
 
 
2227
/*  calculate  mean  of  hole  */
 
2228
   for(r=RAST+D_X,i=0;i<n4;i++,r+=D_X){
 
2229
      j = NumHorizInterval( r, D_X );
 
2230
      if( j == 2 ){
 
2231
   for(k=0;k<dx;k++){
 
2232
      byte=k>>3;
 
2233
      byte=*(r+byte);
 
2234
      byte >>= ( 7- (k % 8) );
 
2235
      byte &= 0x1;
 
2236
      if( !byte && prev  && !down )  down = k;
 
2237
      if(  byte && !prev && down )   up   = k;
 
2238
      prev = byte;
 
2239
   }
 
2240
   meanBit = ( up+down+(dx>>1) )/3;
 
2241
   /* for  no  wide  letters */
 
2242
   if( (up-down < 5) || (dx<dy) )  meanBit = ( up+down )/2;
 
2243
   break;
 
2244
      }
 
2245
   }
 
2246
if( down==0 && up==0 )  return(2); /* M - hole is absent */
 
2247
 
 
2248
/*  calculate  heigth  of  hole  */
 
2249
   r=RAST+D_X;
 
2250
   byte = 0;
 
2251
   prev = whiteMeanBitLeft(r,D_X,meanBit) +
 
2252
    whiteMeanBitRight(r,D_X,dx,meanBit);
 
2253
   for(i=1;i<dy-1;i++,r+=D_X){
 
2254
      j = whiteMeanBitLeft(r,D_X,meanBit) +
 
2255
    whiteMeanBitRight(r,D_X,dx,meanBit);
 
2256
      if( (j == 0) && (i > n4+1) ){  break;  }
 
2257
      byte += (prev-j);
 
2258
      /* for  'bl' */
 
2259
      if( (byte < 2) && (i > n4+2) ){
 
2260
         break;
 
2261
      }
 
2262
      prev = j;
 
2263
   }
 
2264
   if( i > dy-2 )  i = 2*dy/3;
 
2265
   n4 = i>>1;  n2 = 2*n4;
 
2266
/*  calculate  symetry  of  hole  */
 
2267
   down = up = byte = 0;
 
2268
   r=RAST+D_X;
 
2269
   prev = whiteMeanBitLeft(r,D_X,meanBit) +
 
2270
          whiteMeanBitRight(r,D_X,dx,meanBit);
 
2271
   for(i=1;i<=n2;i++,r+=D_X){
 
2272
      j = whiteMeanBitLeft(r,D_X,meanBit) +
 
2273
    whiteMeanBitRight(r,D_X,dx,meanBit);
 
2274
      if( i<=n4 ){  up   += j;  cUp++;    }
 
2275
      else       {  down += j;  cDown++;  }
 
2276
      /* too  wide  hole */
 
2277
      if( (i>n4) && (j>dx/3) ){
 
2278
   if( (cUp==0) || (cDown==0) )  return(0);
 
2279
   if( up*cDown <= down*cUp )    return(4);  /* bl - too  wide  hole */
 
2280
   if( byte < 3 )                return(3);  /* bl - too  wide  hole */
 
2281
      }
 
2282
      byte += (prev-j);
 
2283
      if( (prev-j > 3) && (i>n4) )  return(5);      /* bl - too  big  jump */
 
2284
      if( (byte >= dx/4) && (i>n4) )  return( -6 ); /* M - too  big  angle  for  cursive */
 
2285
      prev = j;
 
2286
   }
 
2287
 
 
2288
   if( (cUp != cDown) && (cDown) ){  down *= cUp;  down /= cDown;  }
 
2289
   if( down >= up )  return(5);  /* bl - wide  hole on  the  bottom */
 
2290
   if( down < up )  return(-5); /* M - wide  hole on  the  top */
 
2291
   if( !cDown )  return(6);  /* bl - hole is absent */
 
2292
 
 
2293
   return(0);
 
2294
}  /* DiskrM */
 
2295
 
 
2296
 
 
2297
static Int16 whiteMeanBitLeft(Word8 *RAST,Int16 D_X,Int16 meanBit)
 
2298
{
 
2299
   Int16    meanByte, byte;
 
2300
   Int16    i,counter=0;
 
2301
 
 
2302
   for(i=meanBit;i>=0;i--){
 
2303
      meanByte = i>>3;
 
2304
      byte = *(RAST+meanByte);
 
2305
      byte >>= ( 7- (i % 8) );
 
2306
      byte &= 0x1;
 
2307
      if(byte){
 
2308
         meanByte = (i-1)>>3;
 
2309
   byte = *(RAST+meanByte);
 
2310
   byte >>= ( 7- ((i-1) % 8) );
 
2311
   byte &= 0x1;
 
2312
   if(byte)  break;
 
2313
   else{
 
2314
      meanByte = i>>3;
 
2315
      byte = *(RAST+D_X+meanByte);
 
2316
      byte >>= ( 7- (i % 8) );
 
2317
      byte &= 0x1;
 
2318
            if(byte)  break;
 
2319
      else{
 
2320
         meanByte = i>>3;
 
2321
         byte = *(RAST-D_X+meanByte);
 
2322
         byte >>= ( 7- (i % 8) );
 
2323
         byte &= 0x1;
 
2324
         if(byte)  break;
 
2325
         else      counter++;
 
2326
      }
 
2327
         }
 
2328
      }
 
2329
      else  counter++;
 
2330
   }
 
2331
 
 
2332
   return( counter );
 
2333
}  /* whiteMeanBitLeft */
 
2334
 
 
2335
static Int16 whiteMeanBitRight(Word8 *RAST,Int16 D_X,Int16 dx,Int16 meanBit)
 
2336
{
 
2337
   Int16    meanByte, byte;
 
2338
   Int16    i,counter=0;
 
2339
 
 
2340
   for(i=meanBit+1;i<dx;i++){
 
2341
      meanByte = i>>3;
 
2342
      byte = *(RAST+meanByte);
 
2343
      byte >>= ( 7- (i % 8) );
 
2344
      byte &= 0x1;
 
2345
      if(byte){
 
2346
   meanByte = (i+1)>>3;
 
2347
   byte = *(RAST+meanByte);
 
2348
   byte >>= ( 7- ((i+1) % 8) );
 
2349
   byte &= 0x1;
 
2350
   if(byte)  break;
 
2351
   else{
 
2352
      meanByte = i>>3;
 
2353
      byte = *(RAST+D_X+meanByte);
 
2354
      byte >>= ( 7- (i % 8) );
 
2355
      byte &= 0x1;
 
2356
            if(byte)  break;
 
2357
      else{
 
2358
         meanByte = i>>3;
 
2359
         byte = *(RAST-D_X+meanByte);
 
2360
         byte >>= ( 7- (i % 8) );
 
2361
         byte &= 0x1;
 
2362
         if(byte)  break;
 
2363
         else      counter++;
 
2364
      }
 
2365
         }
 
2366
      }
 
2367
      else  counter++;
 
2368
   }
 
2369
 
 
2370
   return( counter );
 
2371
}  /* whiteMeanBitRight */
 
2372
 
 
2373
// check gluing roof and down zone for russian capital & small II
 
2374
Int16 up_down_zones(Word8 *raster, Int16 D_X, Int16 dx, Int16 dx0,
 
2375
      Int16 start1, Int16 stop1,
 
2376
      Int16 start2, Int16 stop2)
 
2377
{
 
2378
Int16 i,num1,num2,l=dx0-(dx0>>3);
 
2379
Word8 *r=raster;
 
2380
if( up_down_serif>=0 )
 
2381
  return( up_down_serif );
 
2382
 
 
2383
l = MIN(l,dx0-2);
 
2384
dx = bytlen(dx);
 
2385
for(r=raster+start1*D_X,num1=0,i=start1;i<stop1;i++,r+=D_X)
 
2386
  {
 
2387
  num1 += ( NumHorizInterval(r,dx)==1 && SumBits(r, dx)>=l );
 
2388
    /*  num1 : �᫮ ��ப � ����� ������ ���ࢠ��� �� ���� */
 
2389
  }
 
2390
 
 
2391
for(r=raster+start2*D_X,num2=0,i=start2;i<stop2;i++,r+=D_X)
 
2392
  {
 
2393
  num2 += ( NumHorizInterval(r,dx)==1 && SumBits(r, dx)>=l );
 
2394
    /*  num2 : �᫮ ��ப � ����� ������ ���ࢠ��� ����� */
 
2395
  }
 
2396
 
 
2397
if( num1==0 && num2>=1   ) /* ������ ���� ᫨�����, � ���� ࠧ�ࢠ�� */
 
2398
  return( (up_down_serif=2) );
 
2399
if( num1==0 && num2==0   ) /* ��� ����� */
 
2400
  return( (up_down_serif=1) );
 
2401
 
 
2402
return( (up_down_serif=0) );
 
2403
}
 
2404
 
 
2405
/* for letters 'C','c','e' */
 
2406
static Int16 DiskrVertCE(Word8 *RASTR,Int16 D_X,Int16 dx,Int16 dy,Int16 X,
 
2407
                        Word8 let, Word8 inc)
 
2408
{
 
2409
Word8 *RASTER=RASTR;
 
2410
Int16 i,p,n,s3,d=dx>>2,wid=bytlen(dx);
 
2411
Int16 ody=dy>>2;
 
2412
  Word8 *r=RASTR+ody*D_X;
 
2413
  Int16 t1,t2,t3,num1,num2,num3,minnum,n2;
 
2414
  Int16 l = dy -(ody<<1),num,z=dx-(dx>>3);
 
2415
  Int16 nn[7];
 
2416
 
 
2417
if( c_or_e<0 )
 
2418
  {
 
2419
  d_c=0;
 
2420
  /* ��ਧ��⠫�� ��᫥�������  */
 
2421
  for(minnum=dx,n2=num=num1=num2=num3=0,i=ody;i<l; i++, r+=D_X )
 
2422
    {
 
2423
    t1=NumHorizInterval(r,wid);
 
2424
    t2=SumBits(r, wid);
 
2425
    if( t1==2 )
 
2426
      {
 
2427
 
 
2428
      t3 = (wid<<3) - LeftDistance(r,wid)  -
 
2429
          RightDistance(r,wid) - t2;
 
2430
      if( n2>0 )
 
2431
        {
 
2432
        if( dx>10 && t3<3 )
 
2433
          num3++;
 
2434
        if( minnum>t3 )
 
2435
          minnum=t3;
 
2436
        }
 
2437
      n2++;
 
2438
      }
 
2439
    num  += (t1==1 && t2>=z);
 
2440
    num1 += (t1==1 && t2>=z-1);
 
2441
    num2 += (t2>=z);
 
2442
    }
 
2443
    /*  num : �᫮ ��ப � ����� ������ ���ࢠ��� */
 
2444
  if( num>1 || num1>2 || num2>3 || num3>1 )
 
2445
    {   /* ���� �����뢭�� ��४������ */
 
2446
    c_or_e = 1;     /* ��� ����� ������� ��ப       */
 
2447
    d_e = 0;
 
2448
    d_c = num;
 
2449
    if( num3 ) d_c += (minnum==1?4:3);
 
2450
    return( (let==(Word8)'�')?d_e:d_c );
 
2451
    }
 
2452
if( num==0 && num1==0  && num2==0 && dy<24 )
 
2453
{       /* ��� ���� ����⨢ ���� �ࠢ��� ண� */
 
2454
r=RASTR+ody*D_X;
 
2455
t2 = dx>>1;
 
2456
for(i=ody;i<l; i++, r+=D_X )
 
2457
    {
 
2458
    num1=SumIntervalBits(r,t2,dx);
 
2459
 
 
2460
    if( i>ody && num!=0 && num1==0 )
 
2461
      break;
 
2462
    num = num1;
 
2463
    }
 
2464
i -= 4;
 
2465
r = RASTR+i*D_X;
 
2466
for(t3=t2=0;t2<7;t2++,i++,r+=D_X)
 
2467
  {
 
2468
  nn[t2]=EndBlackInterval(r,wid);
 
2469
  t3+=(NumHorizInterval(r,wid)==2);
 
2470
  }
 
2471
for(t1=t2=nn[0],num=0,num1=1;num1<7;num1++)
 
2472
  {
 
2473
  if( t1>nn[num1] && nn[num1]>=0 )
 
2474
    t1=nn[num1];
 
2475
  if( t2<nn[num1] )
 
2476
    t2=nn[(num=num1)];
 
2477
  if( t2==nn[num1] && num==0 )
 
2478
    num=num1;
 
2479
  }
 
2480
for(num1=num-1;num1>=0;num1--)
 
2481
  if( nn[num1]<t2 )
 
2482
    break;
 
2483
for(num2=num+1;num2<7;num2++)
 
2484
  if( nn[num2]<t2 )
 
2485
    break;
 
2486
if( inc && t2-t1<3 )
 
2487
  t2=t1;  // Oleg : ERECTION conditions : 09-08-95 09:47pm
 
2488
if( t3>2 && t2>t1 && num1>=0 && num2<7 )
 
2489
  { /* ��� ���騪 */
 
2490
  c_or_e = 1;     /* ��� ����� ������� ��ப       */
 
2491
  d_e = 0;
 
2492
  d_c = 1+t2-t1;
 
2493
  if( (let==(Word8)'�') )
 
2494
  return( d_e );
 
2495
  }
 
2496
}
 
2497
  /* ����� ���⨪���� ��᫥�������  */
 
2498
 
 
2499
  dx-=d;
 
2500
  X &= 7;
 
2501
  for(n=s3=0,i=d;i<dx; i++)
 
2502
    {
 
2503
    p = NumVertInterval(RASTER, D_X, dy, (Int16)(i+X));
 
2504
    s3 += ( p==3 );
 
2505
    if( p==3 || p==2 )n++;
 
2506
    }
 
2507
    /*  NumVertInterval : �᫮ ����� � �⮫�� */
 
2508
  p =  n;
 
2509
  n *= 4;
 
2510
  n /= 10;  /* 40 % */
 
2511
  p -= n;   /* 60 % */
 
2512
 
 
2513
  c_or_e = 1;
 
2514
  d_e = (s3<p)?p-s3:0;
 
2515
  if( s3==0 && d_e<3 )
 
2516
    d_e = 4;
 
2517
  d_c = MAX(d_c,(s3>n)?s3-n+1:0);
 
2518
  }
 
2519
return( (let==(Word8)'�')?d_e:d_c );
 
2520
}
 
2521
 
 
2522
 
 
2523
Int16 AngleBottomRight(Word8 *raster,Int16 D_X,Int16 hei)
 
2524
{
 
2525
int i,old,neue,inc;
 
2526
Word8 *r;
 
2527
 
 
2528
raster += D_X * (hei-2);
 
2529
hei >>= 2;
 
2530
 
 
2531
old=RightDistance(raster,D_X);
 
2532
for(inc=0,r=raster-D_X,i=1;i<hei;i++,r-=D_X)
 
2533
  {
 
2534
  neue = RightDistance(r,D_X);
 
2535
  if( neue<old )    inc++;
 
2536
  if( neue>old )    break;
 
2537
  old  = neue;
 
2538
  }
 
2539
return inc;
 
2540
}
 
2541
 
 
2542
Int16 AngleTopRight(Word8 *raster,Int16 D_X,Int16 hei)
 
2543
{
 
2544
int i,old,neue,inc;
 
2545
Word8 *r;
 
2546
 
 
2547
raster += D_X;
 
2548
hei >>= 2;
 
2549
 
 
2550
old=RightDistance(raster,D_X);
 
2551
for(inc=0,r=raster+D_X,i=1;i<hei;i++,r+=D_X)
 
2552
  {
 
2553
  neue = RightDistance(r,D_X);
 
2554
  if( neue<old )    inc++;
 
2555
  if( neue>old )    break;
 
2556
  old  = neue;
 
2557
  }
 
2558
return inc;
 
2559
}
 
2560
 
 
2561
Int16 BonusAnglesCurve(Word8 *raster,Int16 D_X,Int16 hei)
 
2562
{
 
2563
int pen=0,inc;
 
2564
 
 
2565
inc = AngleTopRight(raster,D_X,hei);
 
2566
if( inc>3 || hei<23 && inc>2 ) pen++;
 
2567
 
 
2568
inc = AngleBottomRight(raster,D_X,hei);
 
2569
if( inc>3 || hei<23 && inc>2 ) pen++;
 
2570
 
 
2571
return pen;
 
2572
}
 
2573
 
 
2574
Bool32 DiskrJuCut(Int16 nfoot, Int16 dx)
 
2575
{
 
2576
int i,l,d;
 
2577
l = dx*3/4;
 
2578
d = dx/5;
 
2579
for(i=0;i<nfoot;i++)
 
2580
if( LOCAL[i]>l && LOCAL_W[i]>d )
 
2581
    return TRUE;
 
2582
return FALSE;
 
2583
}
 
2584
 
 
2585
DIF_FUNC(Int16) DIF_GetNoCutPoint(Word8 *RASTER, Int16 Wx, Word8 NWIDTH, Word8 NLENGTH)
 
2586
{
 
2587
Int16 f=FOOT_HEI( RASTER, Wx, NWIDTH, NLENGTH);
 
2588
if( f!=2 || f==2 && (LOCAL[0]-(LOCAL_W[0]+1)/2)>(LOCAL_W[0]+1)/2 )
 
2589
        return 0;
 
2590
return LOCAL[1]+(LOCAL_W[1]+1)/2;
 
2591
}