← Back to branch summary

~ubuntu-branches/ubuntu/trusty/cuneiform/trusty

« back to all changes in this revision

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

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

Show diffs side-by-side

added added

removed removed

Lines of Context:
cuneiform_src/Kern/dif/src/diffrb.c
2
2
Copyright (c) 1993-2008, Cognitive Technologies
3
3
All rights reserved.
4
4
 
5
 
����������� ��������� ��������������� � ������������� ��� � ���� ��������� ����,
6
 
��� � � �������� �����, � ����������� ��� ���, ��� ���������� ��������� �������:
7
 
 
8
 
      * ��� ��������� ��������������� ��������� ���� ������ ���������� ���������
9
 
        ���� ����������� �� ��������� �����, ���� ������ ������� � �����������
10
 
        ����� �� ��������.
11
 
      * ��� ��������� ��������������� ��������� ���� � ������������ �/��� �
12
 
        ������ ����������, ������������ ��� ���������������, ������ �����������
13
 
        ��������� ���� ���������� �� ��������� �����, ���� ������ ������� �
14
 
        ����������� ����� �� ��������.
15
 
      * �� �������� Cognitive Technologies, �� ����� �� ����������� �� �����
16
 
        ���� ������������ � �������� �������� ��������� �/��� �����������
17
 
        ���������, ���������� �� ���� ��, ��� ���������������� �����������
18
 
        ����������.
19
 
 
20
 
��� ��������� ������������� ����������� ��������� ���� �/��� ������� ������ "���
21
 
��� ����" ��� ������-���� ���� ��������, ���������� ���� ��� ���������������,
22
 
������� �������� ������������ �������� � ����������� ��� ���������� ����, �� ��
23
 
������������� ���. �� �������� ��������� ���� � �� ���� ������ ����, �������
24
 
����� �������� �/��� �������� �������������� ���������, �� � ���� ������ ��
25
 
��Ѩ� ���������������, ������� ����� �����, ���������, ����������� ���
26
 
������������� ������, ��������� � �������������� ��� ���������� ����������
27
 
������������� ������������� ��������� (������� ������ ������, ��� ������,
28
 
������� ���������, ��� ������ �/��� ������ �������, ���������� ��-�� ��������
29
 
������� ��� �/��� ������ ��������� �������� ��������� � ������� �����������,
30
 
�� �� ������������� ����� ��������), �� �� ������������� ���, ���� ���� �����
31
 
�������� ��� ������ ���� ���� �������� � ����������� ����� ������� � ������.
 
5
╨рчЁх°рхЄё  яютЄюЁэюх ЁрёяЁюёЄЁрэхэшх ш шёяюы№чютрэшх ъръ т тшфх шёїюфэюую ъюфр,
 
6
Єръ ш т фтюшўэющ ЇюЁьх, ё шчьхэхэш ьш шыш схч, яЁш ёюсы■фхэшш ёыхфє■∙шї єёыютшщ:
 
7
 
 
8
      * ╧Ёш яютЄюЁэюь ЁрёяЁюёЄЁрэхэшш шёїюфэюую ъюфр фюыцэ√ юёЄртрЄ№ё  єърчрээюх
 
9
        т√°х єтхфюьыхэшх юс ртЄюЁёъюь яЁртх, ¤ЄюЄ ёяшёюъ єёыютшщ ш яюёыхфє■∙шщ
 
10
        юЄърч юЄ урЁрэЄшщ.
 
11
      * ╧Ёш яютЄюЁэюь ЁрёяЁюёЄЁрэхэшш фтюшўэюую ъюфр т фюъєьхэЄрЎшш ш/шыш т
 
12
        фЁєушї ьрЄхЁшрырї, яюёЄрты хь√ї яЁш ЁрёяЁюёЄЁрэхэшш, фюыцэ√ ёюїЁрэ Є№ё 
 
13
        єърчрээр  т√°х шэЇюЁьрЎш  юс ртЄюЁёъюь яЁртх, ¤ЄюЄ ёяшёюъ єёыютшщ ш
 
14
        яюёыхфє■∙шщ юЄърч юЄ урЁрэЄшщ.
 
15
      * ═ш эрчтрэшх Cognitive Technologies, эш шьхэр хх ёюЄЁєфэшъют эх ьюуєЄ
 
16
        с√Є№ шёяюы№чютрэ√ т ърўхёЄтх ёЁхфёЄтр яюффхЁцъш ш/шыш яЁюфтшцхэш 
 
17
        яЁюфєъЄют, юёэютрээ√ї эр ¤Єюь ╧╬, схч яЁхфтрЁшЄхы№эюую яшё№ьхээюую
 
18
        ЁрчЁх°хэш .
 
19
 
 
20
▌╥└ ╧╨╬├╨└╠╠└ ╧╨┼─╬╤╥└┬╦┼═└ ┬╦└─┼╦▄╓└╠╚ └┬╥╬╨╤╩╚╒ ╧╨└┬ ╚/╚╦╚ ─╨╙├╚╠╚ ╦╚╓└╠╚ "╩└╩
 
21
╬═└ ┼╤╥▄" ┴┼╟ ╩└╩╬├╬-╦╚┴╬ ┬╚─└ ├└╨└═╥╚╔, ┬█╨└╞┼══█╒ ▀┬═╬ ╚╦╚ ╧╬─╨└╟╙╠┼┬└┼╠█╒,
 
22
┬╩╦▐╫└▀ ├└╨└═╥╚╚ ╩╬╠╠┼╨╫┼╤╩╬╔ ╓┼══╬╤╥╚ ╚ ╧╨╚├╬─═╬╤╥╚ ─╦▀ ╩╬═╩╨┼╥═╬╔ ╓┼╦╚, ═╬ ═┼
 
23
╬├╨└═╚╫╚┬└▀╤▄ ╚╠╚. ═╚ ┬╦└─┼╦┼╓ └┬╥╬╨╤╩╚╒ ╧╨└┬ ╚ ═╚ ╬─═╬ ─╨╙├╬┼ ╦╚╓╬, ╩╬╥╬╨╬┼
 
24
╠╬╞┼╥ ╚╟╠┼═▀╥▄ ╚/╚╦╚ ╧╬┬╥╬╨═╬ ╨└╤╧╨╬╤╥╨└═▀╥▄ ╧╨╬├╨└╠╠╙, ═╚ ┬ ╩╬┼╠ ╤╦╙╫└┼ ═┼
 
25
═┼╤и╥ ╬╥┬┼╥╤╥┬┼══╬╤╥╚, ┬╩╦▐╫└▀ ╦▐┴█┼ ╬┴┘╚┼, ╤╦╙╫└╔═█┼, ╤╧┼╓╚└╦▄═█┼ ╚╦╚
 
26
╧╬╤╦┼─╬┬└┬╪╚┼ ╙┴█╥╩╚, ╤┬▀╟└══█┼ ╤ ╚╤╧╬╦▄╟╬┬└═╚┼╠ ╚╦╚ ╧╬═┼╤┼══█┼ ┬╤╦┼─╤╥┬╚┼
 
27
═┼┬╬╟╠╬╞═╬╤╥╚ ╚╤╧╬╦▄╟╬┬└═╚▀ ╧╨╬├╨└╠╠█ (┬╩╦▐╫└▀ ╧╬╥┼╨╚ ─└══█╒, ╚╦╚ ─└══█┼,
 
28
╤╥└┬╪╚┼ ═┼├╬─═█╠╚, ╚╦╚ ╙┴█╥╩╚ ╚/╚╦╚ ╧╬╥┼╨╚ ─╬╒╬─╬┬, ╧╬═┼╤┼══█┼ ╚╟-╟└ ─┼╔╤╥┬╚╔
 
29
╥╨┼╥▄╚╒ ╦╚╓ ╚/╚╦╚ ╬╥╩└╟└ ╧╨╬├╨└╠╠█ ╨└┴╬╥└╥▄ ╤╬┬╠┼╤╥═╬ ╤ ─╨╙├╚╠╚ ╧╨╬├╨└╠╠└╠╚,
 
30
═╬ ═┼ ╬├╨└═╚╫╚┬└▀╤▄ ▌╥╚╠╚ ╤╦╙╫└▀╠╚), ═╬ ═┼ ╬├╨└═╚╫╚┬└▀╤▄ ╚╠╚, ─└╞┼ ┼╤╦╚ ╥└╩╬╔
 
31
┬╦└─┼╦┼╓ ╚╦╚ ─╨╙├╬┼ ╦╚╓╬ ┴█╦╚ ╚╟┬┼┘┼═█ ╬ ┬╬╟╠╬╞═╬╤╥╚ ╥└╩╚╒ ╙┴█╥╩╬┬ ╚ ╧╬╥┼╨▄.
32
32
 
33
33
Redistribution and use in source and binary forms, with or without modification,
34
34
are permitted provided that the following conditions are met:
55
55
*/
56
56
 
57
57
/************************************************************************/
58
 
/* DIFFRB.C - ������ �㭪樨 ��� ���ਬ����஢                  */
59
 
/*             ( � Tiger-e �뫨 ����ᠭ� ��� TASM)                  */
60
 
/************************************************************************/
61
 
/* LeftDistance - ����ﭨ� �� ��ࢮ�� ᫥�� ���                       */
62
 
/* RightDistance -����ﭨ� �� ��ࢮ�� �ࠢ� ���                       */
63
 
/* SumIntervalBits  - ������� �㬬� ��� (��砫� � ����� - ���� )    */
64
 
/* SumBits - ������� �㬬� ��� � ��ப� ����                                */
65
 
/* VertSum - ������� �㬬� ��� � �⮫��                             */
66
 
/* MinMaxLeft - ���� min � max ����ﭨ� �� ����� ����             */
67
 
/* MinMaxRight - ���� min � max ����ﭨ� �� �ࠢ�� ����             */
68
 
/* NumHorizInterval - �᫮ ���ࢠ��� � ��ப�                         */
69
 
/* NumVertInterval - �᫮ ���ࢠ��� � �⮫��                  */
70
 
/* FOOT_A - ���᫨�� ���⨪����� �஥��� ����                         */
71
 
/* FOOT3 - ���᫨�� �᫮ ��� ( ��������� 3-����� �㪢�)               */
72
 
/* FOOT - ���᫨�� �᫮ ���                                                 */
73
 
/* Assym_let - �業��� ���⨪����� �ᨬ����� �㪢�                      */
74
 
/* CenterVertInterval - �।��� ���ࢠ�� � �⮫��                     */
75
 
/************************************************************************/
76
 
/* ��������� :  *********************************************************/
77
 
/*           RASTER - 㪠��⥫� �� ��ப� ��� �� ��砫� ࠡ�祭� ���� */
78
 
/*           Wx     - �ਭ� �.�.                                       */
79
 
/*           NWIDTH - �ਭ� �����窨 � �.�.  ��� ��ப�                */
80
 
/*           NHEIGHT- ������⢮ ��ப � �.�.                           */
81
 
/*           �olumn - �⮫���                                           */
 
58
/* DIFFRB.C - базовые функции для дискриминаторов                       */
 
59
/*             ( в Tiger-e были написаны под TASM)                      */
 
60
/************************************************************************/
 
61
/* LeftDistance - расстояние до первого слева бита                      */
 
62
/* RightDistance -расстояние до первого справа бита                     */
 
63
/* SumIntervalBits  - посчитать сумму бит (начало и конец - биты )      */
 
64
/* SumBits - посчитать сумму бит в строке байт                          */
 
65
/* VertSum - посчитать сумму бит в столбце                              */
 
66
/* MinMaxLeft - найти min и max расстояние на левом абрисе              */
 
67
/* MinMaxRight - найти min и max расстояние на правом абрисе            */
 
68
/* NumHorizInterval - число интервалов в строке                         */
 
69
/* NumVertInterval - число интервалов в столбце                         */
 
70
/* FOOT_A - вычислить вертикальную проекцию растра                      */
 
71
/* FOOT3 - вычислить число ног ( ожидается 3-ногая буква)               */
 
72
/* FOOT - вычислить число ног                                           */
 
73
/* Assym_let - оценить вертикальную асимметрию буквы                    */
 
74
/* CenterVertInterval - середина интервала в столбце                    */
 
75
/************************************************************************/
 
76
/* ПАРАМЕТРЫ :  *********************************************************/
 
77
/*           RASTER - указатель на строку или на начало рабочено растра */
 
78
/*           Wx     - ширина Р.Р.                                       */
 
79
/*           NWIDTH - ширина оболочки в Р.Р.  или строки                */
 
80
/*           NHEIGHT- количество строк в Р.Р.                           */
 
81
/*           Сolumn - столбец                                           */
82
82
/************************************************************************/
83
83
 
84
84
#include <string.h>
85
85
#include "difdefs.h"
86
86
 
87
 
#include "diskrtab.h"       /* ⠡����      */
 
87
#include "diskrtab.h"       /* таблицы      */
88
88
 
89
 
Word8 BUFFER[256];   /* ���⨪��쭠� �஥���  */
90
 
Word8 LOCAL[50];     /* ᯨ᮪ 業�஢ ���     */
91
 
Word8 LOCAL_W[50];   /* ᯨ᮪ �ਭ   ���     */
92
 
Word8 beg2, end1;    /* ��砫� 2-��, ����� 1-�� ���  */
 
89
uchar BUFFER[256];   /* вертикальная проекция  */
 
90
uchar LOCAL[50];     /* список центров ног     */
 
91
uchar LOCAL_W[50];   /* список ширин   ног     */
 
92
uchar beg2, end1;    /* начало 2-ой, конец 1-ой ног  */
93
93
 
94
94
#define bytlen(bits)  (REC_GW_WORD8(bits))
95
95
 
96
 
Int16 dnri_hook,broken_ii=0;
97
 
Word8 broken_flag=0;
98
 
 
99
 
 
100
 
/* LeftDistance - ����ﭨ� �� ��ࢮ�� ᫥�� ���                       */
101
 
Int16 LeftDistance(Word8 *RASTER, Int16 NWIDTH)
 
96
int16_t dnri_hook,broken_ii=0;
 
97
uchar broken_flag=0;
 
98
 
 
99
 
 
100
/* LeftDistance - расстояние до первого слева бита                      */
 
101
int16_t LeftDistance(uchar *RASTER, int16_t NWIDTH)
102
102
{
103
 
Int16 i;
 
103
int16_t i;
104
104
 
105
105
for(i=0;i<NWIDTH && (*RASTER)==0;i++,RASTER++);
106
106
 
110
110
return( (i<<3)+start_pos[*RASTER] );
111
111
}
112
112
 
113
 
/* RightDistance -����ﭨ� �� ��ࢮ�� �ࠢ� ���                       */
114
 
Int16 RightDistance(Word8 *RASTER, Int16 NWIDTH)
 
113
/* RightDistance -расстояние до первого справа бита                     */
 
114
int16_t RightDistance(uchar *RASTER, int16_t NWIDTH)
115
115
{
116
 
Int16 i;
 
116
int16_t i;
117
117
 
118
118
RASTER += NWIDTH-1;
119
119
 
125
125
return( (i<<3)+last_pos[*RASTER] );
126
126
}
127
127
 
128
 
/* SumIntervalBits  - ������� �㬬� ��� (��砫� � ����� - ���� )    */
129
 
Int16 SumIntervalBits( Word8 *RASTER, Int16 n1, Int16 n2)
 
128
/* SumIntervalBits  - посчитать сумму бит (начало и конец - биты )      */
 
129
int16_t SumIntervalBits( uchar *RASTER, int16_t n1, int16_t n2)
130
130
{
131
 
Int16 i,d,l;
 
131
int16_t i,d,l;
132
132
 
133
133
i=n1>>3;
134
134
l=n2>>3;
135
 
if( i==l )      /* ��砫� � ����� � ����� ���� */
 
135
if( i==l )      /* начало и конец в одном байте */
136
136
        return( 3*bit_cnt[ mask_l[n1&7] & RASTER[i] & mask_r[n2&7] ] );
137
137
 
138
138
d  = bit_cnt[ RASTER[i] & mask_l[n1&7] ];
139
139
d += bit_cnt[ RASTER[l] & mask_r[n2&7] ];
140
 
if( l==i+1 )    /* �� 㬥�⨫��� � 2 ����   */
 
140
if( l==i+1 )    /* все уместилось в 2 байта     */
141
141
        return( 3*d );
142
142
 
143
 
for(i++;i<l;i++)/* ����� 2-� ����               */
 
143
for(i++;i<l;i++)/* более 2-х байт               */
144
144
        d += bit_cnt[ RASTER[i] ];
145
145
return(3*d);
146
146
}
147
147
 
148
 
/* SumBits - ������� �㬬� ��� � ��ப� ����                                */
149
 
Int16 SumBits( Word8 *RASTER, Int16 NWIDTH)
 
148
/* SumBits - посчитать сумму бит в строке байт                          */
 
149
int16_t SumBits( uchar *RASTER, int16_t NWIDTH)
150
150
{
151
 
Int16 i,s;
 
151
int16_t i,s;
152
152
 
153
153
for(i=s=0;i<NWIDTH;i++,RASTER++)
154
154
        s += bit_cnt[*RASTER];
155
155
return(s);
156
156
}
157
157
 
158
 
/* VertSum - ������� �㬬� ��� � �⮫��                             */
159
 
Int16 VertSum( Word8 *RASTER, Int16 Wx, Int16 NHEIGHT, Int16 Column)
 
158
/* VertSum - посчитать сумму бит в столбце                              */
 
159
int16_t VertSum( uchar *RASTER, int16_t Wx, int16_t NHEIGHT, int16_t Column)
160
160
{
161
 
Int16 i,d;
162
 
Word8 mask=mask_byte[Column&7];
 
161
int16_t i,d;
 
162
uchar mask=mask_byte[Column&7];
163
163
 
164
164
RASTER += (Column>>3);
165
165
 
170
170
 
171
171
 
172
172
 
173
 
/* NumHorizInterval - �᫮ ���ࢠ��� � ��ப�                         */
174
 
Int16 NumHorizInterval( Word8 *RASTER, Int16 NWIDTH)
 
173
/* NumHorizInterval - число интервалов в строке                         */
 
174
int16_t NumHorizInterval( uchar *RASTER, int16_t NWIDTH)
175
175
{
176
 
Int16 i,d;
177
 
Word8 c,old;
 
176
int16_t i,d;
 
177
uchar c,old;
178
178
 
179
179
for( i=d=old=0;i<NWIDTH;i++,RASTER++)
180
180
        {
181
181
        c = *RASTER;
182
182
        d += piece_cnt[c];
183
183
        if( (c&0x80) && old )
184
 
                d--;    /* �த������� */
185
 
        old = ((c&0x01)!=0) ;   /* ��᫥���� ��� �।��饣� ���� */
 
184
                d--;    /* продолжение */
 
185
        old = ((c&0x01)!=0) ;   /* последний бит предыдущего байта */
186
186
        }
187
187
 
188
188
return(d);
189
189
}
190
190
 
191
 
/* NumVertInterval - �᫮ ���ࢠ��� � �⮫��                  */
192
 
Int16 NumVertInterval( Word8 *RASTER, Int16 Wx, Int16 NHEIGHT, Int16 Column)
 
191
/* NumVertInterval - число интервалов в столбце                         */
 
192
int16_t NumVertInterval( uchar *RASTER, int16_t Wx, int16_t NHEIGHT, int16_t Column)
193
193
{
194
 
Int16 i,d;
195
 
Word8 c,old,mask=mask_byte[Column&7];
 
194
int16_t i,d;
 
195
uchar c,old,mask=mask_byte[Column&7];
196
196
 
197
197
RASTER += (Column>>3);
198
198
 
200
200
        {
201
201
        c = (((*RASTER)&mask)!=0);
202
202
        if( c^old )
203
 
                d++;    /* ᪠箪 */
204
 
        old = c ;       /* �।��騩 ���� */
 
203
                d++;    /* скачок */
 
204
        old = c ;       /* предыдущий байт */
205
205
        }
206
206
if( old )
207
207
        d++;
210
210
return(d);
211
211
}
212
212
 
213
 
/* FOOT_A - ���᫨�� ���⨪����� �஥��� ����                         */
214
 
Int16 FOOT_A( Word8 *RASTER, Int16 Wx, Word8 NWIDTH, Word8 NLENGTH)
 
213
/* FOOT_A - вычислить вертикальную проекцию растра                      */
 
214
int16_t FOOT_A( uchar *RASTER, int16_t Wx, uchar NWIDTH, uchar NLENGTH)
215
215
{
216
 
Int16 i,j,k,d;
217
 
Word8 *p,c;
 
216
int16_t i,j,k,d;
 
217
uchar *p,c;
218
218
 
219
219
d=bytlen(NWIDTH);
220
220
memset(BUFFER,0,NWIDTH);
226
226
                c=*p++;
227
227
 
228
228
#ifndef __MAC__
229
 
    *((Word32 *)&BUFFER[k])   += tab_4bits_to_DWORD[c>>4];
230
 
    *((Word32 *)&BUFFER[k+4]) += tab_4bits_to_DWORD[c&15];
 
229
    *((uint32_t *)&BUFFER[k])   += tab_4bits_to_DWORD[c>>4];
 
230
    *((uint32_t *)&BUFFER[k+4]) += tab_4bits_to_DWORD[c&15];
231
231
 
232
232
#else
233
233
                BUFFER[k+7] += ((c&0x01)!=0);
241
241
#endif
242
242
                k+=8;
243
243
                }
244
 
        } /* �஥��� */
 
244
        } /* проекция */
245
245
return(0);
246
246
}
247
247
 
248
248
 
249
 
/* FOOT - ���᫨�� �᫮ ���                                                 */
250
 
Int16 FOOT( Word8 *RASTER, Int16 Wx, Word8 NWIDTH, Word8 NLENGTH,
251
 
    Word8 HARD_FILTER)
 
249
/* FOOT - вычислить число ног                                           */
 
250
int16_t FOOT( uchar *RASTER, int16_t Wx, uchar NWIDTH, uchar NLENGTH,
 
251
    uchar HARD_FILTER)
252
252
{
253
 
Int16 i,old,d,l,k;
254
 
Word8 c,curr,first,second;
 
253
int16_t i,old,d,l,k;
 
254
uchar c,curr,first,second;
255
255
memset(LOCAL,0,50);
256
256
memset(LOCAL_W,0,50);
257
 
FOOT_A(RASTER,Wx,NWIDTH,NLENGTH);       /* �஥��� */
 
257
FOOT_A(RASTER,Wx,NWIDTH,NLENGTH);       /* проекция */
258
258
 
259
259
d=NLENGTH;
260
260
d -= (d>>3);    /* 7/8 */
262
262
    if( old>BUFFER[i] )
263
263
        old=BUFFER[i];
264
264
for(i=0;i<NWIDTH;i++)
265
 
        BUFFER[i] = (BUFFER[i]>=d); /* ����ਧ��� */
 
265
        BUFFER[i] = (BUFFER[i]>=d); /* бинаризация */
266
266
 
267
267
for(old=d=i=0;i<NWIDTH;i++)
268
268
        {
270
270
        if( old==0 && c==1 )
271
271
                d++;
272
272
        old=c;
273
 
        }         /* d - �᫮ ��� */
 
273
        }         /* d - число ног */
274
274
 
275
275
if( HARD_FILTER==0 || d<=2 && HARD_FILTER!=2 )
276
 
        { /* ᫠�� 䨫��� */
 
276
        { /* слабый фильтр */
277
277
        first =BUFFER[0];
278
278
        second=BUFFER[1];
279
279
        for(i=2;i<NWIDTH;i++)
286
286
                }
287
287
        }
288
288
else
289
 
        { /* ᨫ�� 䨫��� */
 
289
        { /* сильный фильтр */
290
290
        first =BUFFER[0];
291
291
        second=BUFFER[1];
292
292
        for(i=2;i<NWIDTH;i++)
300
300
                second =  curr;
301
301
                }
302
302
        }
303
 
        /* ��䨫��஢��� */
 
303
        /* отфильтровали */
304
304
 
305
305
for(old=k=l=i=0;i<NWIDTH;i++)
306
306
        {
308
308
        if( old^c )
309
309
                {
310
310
                if( c )
311
 
                        l=i;                    /* �ୠ�  : ��砫� ���� */
 
311
                        l=i;                    /* черная  : начало ноги */
312
312
                else
313
 
                        LOCAL_W[k++]=i-l;       /* ����� : �ਭ� ����      */
 
313
                        LOCAL_W[k++]=i-l;       /* белая : ширина ноги   */
314
314
                }
315
315
        old=c;
316
316
        }
317
317
if( old  )
318
 
        LOCAL_W[k++]=i-l;   /* ��᫥���� �窠 �ୠ� : �ਭ� ���� */
 
318
        LOCAL_W[k++]=i-l;   /* последняя точка черная : ширина ноги */
319
319
 
320
320
for(old=d=l=k=i=0;i<NWIDTH;i++)
321
321
        {
324
324
                {
325
325
                d++;
326
326
                if( d%2 )
327
 
                        l=i;                    /* ��砫� ����    */
 
327
                        l=i;                    /* начало ноги  */
328
328
                else
329
329
                        {
330
 
                        LOCAL[k++]=(l+i)>>1;   /* ����� ����    */
 
330
                        LOCAL[k++]=(l+i)>>1;   /* конец ноги    */
331
331
                        }
332
332
                }
333
333
        old=c;
334
334
        }
335
335
if( old )
336
336
        {
337
 
        LOCAL[k++]=(l+i)>>1;   /* ����� ��᫥���� ���� */
 
337
        LOCAL[k++]=(l+i)>>1;   /* конец последней ноги */
338
338
        d++;
339
339
        }
340
 
d >>= 1;  /* d - �᫮ ᪠窮� */
 
340
d >>= 1;  /* d - число скачков */
341
341
 
342
342
if( d!=2 )
343
343
        return(d);
344
344
 
345
 
/* 2 ���� */
 
345
/* 2 ноги */
346
346
for(i=1;i<NWIDTH;i++)
347
347
        if( BUFFER[i]==0 && BUFFER[i-1]==1 )
348
348
                break;
349
 
end1 = (Word8)i;         /* ����� 1-�� ���� */
 
349
end1 = (uchar)i;         /* конец 1-ой ноги */
350
350
for(i=NWIDTH-2;i>=0;i--)
351
351
        if( BUFFER[i]==0 && BUFFER[i+1]==1 )
352
352
                break;
353
 
beg2 =(Word8) i;         /* ��砫� 2-�� ���� */
 
353
beg2 =(uchar) i;         /* начало 2-ой ноги */
354
354
 
355
355
return(2);
356
356
}
357
357
 
358
 
/* CenterVertInterval - �।��� ���ࢠ�� � �⮫��                     */
359
 
Int16 CenterVertInterval( Word8 *RASTER, Int16 Wx, Int16 NHEIGHT, Int16 Column,
360
 
      Int16 *up, Int16 *down)
 
358
/* CenterVertInterval - середина интервала в столбце                    */
 
359
int16_t CenterVertInterval( uchar *RASTER, int16_t Wx, int16_t NHEIGHT, int16_t Column,
 
360
      int16_t *up, int16_t *down)
361
361
{
362
 
Word8 mask = mask_byte[Column&7], c, old;
363
 
Int16 i,num,center,up_center;
 
362
uchar mask = mask_byte[Column&7], c, old;
 
363
int16_t i,num,center,up_center;
364
364
 
365
365
*up=*down=-1;
366
366
RASTER += (Column>>3);
369
369
        {
370
370
        *up=NHEIGHT;
371
371
        *down=0;
372
 
        return(0);                      /* ���� �⮫��� ��� */
 
372
        return(0);                      /* весь столбец черный */
373
373
        }
374
374
else
375
 
        up_center = i?i:(NHEIGHT<<1);   /* �।��� ���孥�� ���ࢠ�� */
 
375
        up_center = i?i:(NHEIGHT<<1);   /* середина верхнего интервала */
376
376
 
377
377
for(num=old=0;i<NHEIGHT;i++,RASTER+=Wx)
378
378
        {
380
380
        if( old^c )
381
381
                switch( num++)
382
382
                        {
383
 
                        case 0 :        /* ��砫� */
 
383
                        case 0 :        /* начало */
384
384
                                *up     = NHEIGHT - i;
385
385
                                center  = i;
386
386
                                break;
387
 
                        case 1 :        /* ����� */
 
387
                        case 1 :        /* конец */
388
388
                                *down   = NHEIGHT - i;
389
389
                                center += i;
390
390
                                break;
391
391
                        default:
392
 
                                return(0);      /* ����� 2 */
 
392
                                return(0);      /* более 2 */
393
393
                        }
394
394
        old = c;
395
395
        }
396
396
 
397
397
switch( num )
398
398
        {
399
 
        case 0 :        /* ���孨� ���ࢠ� */
 
399
        case 0 :        /* верхний интервал */
400
400
                center = up_center;
401
401
                if( *up==-1 )   *up  = NHEIGHT-0;
402
402
                if( *down==-1 ) *down= NHEIGHT-up_center;
403
403
                break;
404
 
        case 1 :        /* ������ ���ࢠ� */
 
404
        case 1 :        /* нижний интервал */
405
405
                center += NHEIGHT;
406
406
                if( *up==-1 )   *up=NHEIGHT-up_center;
407
407
                if( *down==-1 ) *down=NHEIGHT-NHEIGHT;
408
408
                break;
409
409
        }
410
410
 
411
 
return( (NHEIGHT<<1)-center);   /* 㤢������ ����ﭨ� �� ���� ���� */
 
411
return( (NHEIGHT<<1)-center);   /* удвоенное расстояние от низа растра */
412
412
}
413
413
 
414
 
Int16 MinMaxLeft( Word8 *RASTER, Int16 Wx, Word8 NWIDTH, Word8 NHEIGHT,
415
 
                Int16 *Pmin, Int16 *Pmax)
 
414
int16_t MinMaxLeft( uchar *RASTER, int16_t Wx, uchar NWIDTH, uchar NHEIGHT,
 
415
                int16_t *Pmin, int16_t *Pmax)
416
416
{
417
 
Int16 maxr=0,minr=100,r,i;
 
417
int16_t maxr=0,minr=100,r,i;
418
418
 
419
419
NWIDTH= bytlen(NWIDTH);
420
420
for( i=0;i<NHEIGHT;i++,RASTER+=Wx)
431
431
return(0);
432
432
}
433
433
 
434
 
/* MinMaxRight - ���� min � max ����ﭨ� �� �ࠢ�� ����             */
435
 
Int16 MinMaxRight( Word8 *RASTER, Int16 Wx, Word8 NWIDTH, Word8 NHEIGHT,
436
 
                Int16 *Pmin, Int16 *Pmax)
 
434
/* MinMaxRight - найти min и max расстояние на правом абрисе            */
 
435
int16_t MinMaxRight( uchar *RASTER, int16_t Wx, uchar NWIDTH, uchar NHEIGHT,
 
436
                int16_t *Pmin, int16_t *Pmax)
437
437
{
438
 
Int16 maxr=0,minr=100,r,i, end;
 
438
int16_t maxr=0,minr=100,r,i, end;
439
439
 
440
440
r = bytlen(NWIDTH);
441
441
end = (r-((NWIDTH+7)/8))*8;
442
 
NWIDTH = (Word8)r;
 
442
NWIDTH = (uchar)r;
443
443
for( i=0;i<NHEIGHT;i++,RASTER+=Wx)
444
444
        {
445
445
        r = RightDistance(RASTER,NWIDTH)-end;
455
455
}
456
456
 
457
457
 
458
 
/* FOOT3_2 - ���᫨�� �᫮ ��� ( ��������� 3-����� �㪢�)     */
459
 
/*           � ���孥� � ������ ���������                       */
460
 
Int16 FOOT3_2( Word8 *RASTER, Int16 Wx, Word8 NWIDTH, Word8 NLENGTH)
 
458
/* FOOT3_2 - вычислить число ног ( ожидается 3-ногая буква)     */
 
459
/*           в верхней и нижней половинах                       */
 
460
int16_t FOOT3_2( uchar *RASTER, int16_t Wx, uchar NWIDTH, uchar NLENGTH)
461
461
{
462
 
Int16 i,old,du,dd;
463
 
Word8 c;
464
 
FOOT_A(RASTER,Wx,NWIDTH,(Word8)(NLENGTH/2)); /* �஥��� */
 
462
int16_t i,old,du,dd;
 
463
uchar c;
 
464
FOOT_A(RASTER,Wx,NWIDTH,(uchar)(NLENGTH/2)); /* проекция */
465
465
 
466
466
for(i=0;i<NWIDTH;i++)
467
 
  BUFFER[i] = (BUFFER[i]>0); /* ����ਧ��� */
 
467
  BUFFER[i] = (BUFFER[i]>0); /* бинаризация */
468
468
 
469
469
for(old=du=i=0;i<NWIDTH;i++)
470
470
  {
475
475
  }
476
476
if( old )
477
477
  du++;
478
 
du >>= 1;  /* du - �᫮ ᪠窮� ������ */
 
478
du >>= 1;  /* du - число скачков вверху */
479
479
 
480
 
  FOOT_A(RASTER+(NLENGTH/2)*Wx,Wx,NWIDTH,(Word8)(NLENGTH/2)); /* �஥��� */
 
480
  FOOT_A(RASTER+(NLENGTH/2)*Wx,Wx,NWIDTH,(uchar)(NLENGTH/2)); /* проекция */
481
481
 
482
482
for(i=0;i<NWIDTH;i++)
483
 
  BUFFER[i] = (BUFFER[i]>0); /* ����ਧ��� */
 
483
  BUFFER[i] = (BUFFER[i]>0); /* бинаризация */
484
484
 
485
485
for(old=dd=i=0;i<NWIDTH;i++)
486
486
  {
491
491
  }
492
492
if( old )
493
493
  dd++;
494
 
dd >>= 1;  /* du - �᫮ ᪠窮� ������ */
 
494
dd >>= 1;  /* du - число скачков вверху */
495
495
return(dd==3&&du!=3);
496
496
}
497
497
 
498
 
/* FOOT3 - ���᫨�� �᫮ ��� ( ��������� 3-����� �㪢�)     */
499
 
Int16 FOOT3( Word8 *RASTER, Int16 Wx, Word8 START, Word8 NWIDTH, Word8 NLENGTH, Int16 SHIFT)
 
498
/* FOOT3 - вычислить число ног ( ожидается 3-ногая буква)     */
 
499
int16_t FOOT3( uchar *RASTER, int16_t Wx, uchar START, uchar NWIDTH, uchar NLENGTH, int16_t SHIFT)
500
500
{
501
 
Int16 i,old,d;
502
 
Word8 c;
503
 
FOOT_A(RASTER,Wx,NWIDTH,NLENGTH); /* �஥��� */
 
501
int16_t i,old,d;
 
502
uchar c;
 
503
FOOT_A(RASTER,Wx,NWIDTH,NLENGTH); /* проекция */
504
504
 
505
505
d=NLENGTH;
506
506
d = (d>>SHIFT); /* 1/4 */
507
507
for(i=0;i<NWIDTH;i++)
508
 
  BUFFER[i] = (BUFFER[i]>=d); /* ����ਧ��� */
 
508
  BUFFER[i] = (BUFFER[i]>=d); /* бинаризация */
509
509
 
510
510
for(old=d=0,i=START;i<NWIDTH;i++)
511
511
  {
516
516
  }
517
517
if( old )
518
518
  d++;
519
 
d >>= 1;  /* d - �᫮ ᪠窮� */
 
519
d >>= 1;  /* d - число скачков */
520
520
return(d);
521
521
}
522
522
 
523
 
/* EndBlackInterval - ����� ��᫥����� �୮�� ���   */
524
 
/* � ��ࢮ� ᫥�� ��窥 ���� ���      */
525
 
Int16 EndBlackInterval(Word8 *RASTER, Int16 NWIDTH)
 
523
/* EndBlackInterval - номер последнего черного бита   */
 
524
/* в первой слева пачке черных бит      */
 
525
int16_t EndBlackInterval(uchar *RASTER, int16_t NWIDTH)
526
526
{
527
 
Int16 i;
 
527
int16_t i;
528
528
 
529
529
for(i=0;i<NWIDTH && (*RASTER)==0;i++,RASTER++); /* skip white bytes    */
530
530
 
540
540
return( (i<<3)+tab_last_black_bit[*RASTER] );
541
541
}
542
542
 
543
 
void clear_right_bites(Word8 *RASTER, Int16 NWIDTH, Int16 WBYTE, Int16 NHEIGHT)
 
543
void clear_right_bites(uchar *RASTER, int16_t NWIDTH, int16_t WBYTE, int16_t NHEIGHT)
544
544
{
545
545
int w = NWIDTH&7, ww = (NWIDTH+7)/8, i;
546
546
RASTER += ww;
563
563
return;
564
564
}
565
565
 
566
 
Int16 FOOT_HEI( Word8 *RASTER, Int16 Wx, Word8 NWIDTH, Word8 NLENGTH)
 
566
int16_t FOOT_HEI( uchar *RASTER, int16_t Wx, uchar NWIDTH, uchar NLENGTH)
567
567
{
568
 
Int16 i,old,d,l,k;
569
 
Word8 c,curr,first,second;
 
568
int16_t i,old,d,l,k;
 
569
uchar c,curr,first,second;
570
570
memset(LOCAL,0,50);
571
571
memset(LOCAL_W,0,50);
572
 
FOOT_A(RASTER,Wx,NWIDTH,NLENGTH);       /* �஥��� */
 
572
FOOT_A(RASTER,Wx,NWIDTH,NLENGTH);       /* проекция */
573
573
 
574
574
d=NLENGTH;
575
575
d -= 2; // full heigh
577
577
    if( old>BUFFER[i] )
578
578
        old=BUFFER[i];
579
579
for(i=0;i<NWIDTH;i++)
580
 
        BUFFER[i] = (BUFFER[i]>=d); /* ����ਧ��� */
 
580
        BUFFER[i] = (BUFFER[i]>=d); /* бинаризация */
581
581
 
582
582
for(old=d=i=0;i<NWIDTH;i++)
583
583
        {
585
585
        if( old==0 && c==1 )
586
586
                d++;
587
587
        old=c;
588
 
        }         /* d - �᫮ ��� */
 
588
        }         /* d - число ног */
589
589
 
590
590
 
591
591
first =BUFFER[0];
599
599
        second = curr;
600
600
        }
601
601
 
602
 
        /* ��䨫��஢��� */
 
602
        /* отфильтровали */
603
603
 
604
604
for(old=k=l=i=0;i<NWIDTH;i++)
605
605
        {
607
607
        if( old^c )
608
608
                {
609
609
                if( c )
610
 
                        l=i;                    /* �ୠ�  : ��砫� ���� */
 
610
                        l=i;                    /* черная  : начало ноги */
611
611
                else
612
 
                        LOCAL_W[k++]=i-l;       /* ����� : �ਭ� ����      */
 
612
                        LOCAL_W[k++]=i-l;       /* белая : ширина ноги   */
613
613
                }
614
614
        old=c;
615
615
        }
616
616
if( old  )
617
 
        LOCAL_W[k++]=i-l;   /* ��᫥���� �窠 �ୠ� : �ਭ� ���� */
 
617
        LOCAL_W[k++]=i-l;   /* последняя точка черная : ширина ноги */
618
618
 
619
619
for(old=d=l=k=i=0;i<NWIDTH;i++)
620
620
        {
623
623
                {
624
624
                d++;
625
625
                if( d%2 )
626
 
                        l=i;                    /* ��砫� ����    */
 
626
                        l=i;                    /* начало ноги  */
627
627
                else
628
628
                        {
629
 
                        LOCAL[k++]=(l+i)>>1;   /* ����� ����    */
 
629
                        LOCAL[k++]=(l+i)>>1;   /* конец ноги    */
630
630
                        }
631
631
                }
632
632
        old=c;
633
633
        }
634
634
if( old )
635
635
        {
636
 
        LOCAL[k++]=(l+i)>>1;   /* ����� ��᫥���� ���� */
 
636
        LOCAL[k++]=(l+i)>>1;   /* конец последней ноги */
637
637
        d++;
638
638
        }
639
 
d >>= 1;  /* d - �᫮ ᪠窮� */
 
639
d >>= 1;  /* d - число скачков */
640
640
 
641
641
return(d);
642
642
}