← Back to branch summary

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

« back to all changes in this revision

Viewing changes to cuneiform_src/Kern/rstr/src/diffrang.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/rstr/src/diffrang.c
63
63
#include <string.h>
64
64
#include <stdio.h>
65
65
#include <stdlib.h>
66
 
 
67
 
        #include "nt_types.h"
68
66
        #include "status.h"
69
67
        #include "discrim.h"
70
68
        #include "tuner.h"
71
69
        #include "ligas.h"
72
70
 
73
71
/************************************************************/
74
 
extern INT  LeftDistance(BYTE *RASTER,INT dx);
75
 
extern INT  RightDistance(BYTE *RASTER,INT dx);
76
 
extern segment * go_line(segment *s,WORD num);
 
72
extern int16_t  LeftDistance(uchar *RASTER,int16_t dx);
 
73
extern int16_t  RightDistance(uchar *RASTER,int16_t dx);
 
74
extern segment * go_line(segment *s,uint16_t num);
77
75
 
78
76
/************************************************************/
79
 
static INT long_line( PBYTE seg,INT w,INT line,INT part);
 
77
static int16_t long_line( puchar seg,int16_t w,int16_t line,int16_t part);
80
78
 
81
79
 
82
80
#define bytlen(c) ((c+7)>>3)
95
93
#define N_C  16                 /* ⨯ "��� ��㣫����"              */
96
94
 
97
95
 
98
 
static INT height;
99
 
static INT buf_lines[NUM_LINES];        /* ���� ���� �����      */
 
96
static int16_t height;
 
97
static int16_t buf_lines[NUM_LINES];    /* ���� ���� �����      */
100
98
 
101
99
typedef struct
102
100
        {
103
 
        BYTE            tl,             /* ������� �����        */
 
101
        uchar           tl,             /* ������� �����        */
104
102
                        tr,             /* ������� ������       */
105
103
                        bl,             /* ������  �����        */
106
104
                        br;             /* ������  ������       */
112
110
CRN     angles,                         /* ���� 㣫��             */
113
111
*default_corners ;                      /* 㣫� �� 㬮�砭��    */
114
112
 
115
 
static INT non_similar_angles(BYTE def_a, BYTE a,
 
113
static int16_t non_similar_angles(uchar def_a, uchar a,
116
114
#ifdef UFA
117
 
  BYTE cut_sign,
 
115
  uchar cut_sign,
118
116
#endif
119
 
  INT dy)
 
117
  int16_t dy)
120
118
{
121
 
INT ret=0;
 
119
int16_t ret=0;
122
120
 
123
121
if( a==255 )
124
122
        return 0; /* angle have empty lines */
155
153
return ret;
156
154
}
157
155
 
158
 
INT corner_type( BYTE crn )
 
156
int16_t corner_type( uchar crn )
159
157
{
160
158
if( crn == SERIF )  return SERIF;
161
159
else if( crn == 0 ) return NON_CURVE;
168
166
}
169
167
 
170
168
/* ���ਬ����� �� ࠧ��稥 㣫�� �� ���᫥��� ⨯�� angles */
171
 
static INT check_angles(BYTE let,INT dy)
 
169
static int16_t check_angles(uchar let,int16_t dy)
172
170
{
173
 
INT non_sim=0,non_num=0,p;
174
 
INT deskr[]={0,40,80,200,240};  // 0, 50, 120, ...
 
171
int16_t non_sim=0,non_num=0,p;
 
172
int16_t deskr[]={0,40,80,200,240};      // 0, 50, 120, ...
175
173
 
176
174
/* default_corners - ������ 㣫� */
177
175
if( (p=non_similar_angles(default_corners[let].tl,angles.tl,
208
206
 
209
207
/* ��।����� ⨯ 㣫� �� NUM_LINES ����ﭨ� �� buf_lines       */
210
208
/* �饬 ⮫쪮 ⨯ CURVE                                        */
211
 
static BYTE calc_one_angle(INT h)
 
209
static uchar calc_one_angle(int16_t h)
212
210
{
213
 
INT i,old=buf_lines[0],neue,num_jmps,s;
214
 
 INT back_jmps,equ;
 
211
int16_t i,old=buf_lines[0],neue,num_jmps,s;
 
212
 int16_t back_jmps,equ;
215
213
 
216
214
 equ=0;
217
215
for(s=i=1,num_jmps=0;i<h;i++)
250
248
if( num_jmps==1 && back_jmps>=1 ||   /* 1+ 1- */
251
249
    num_jmps>1  && back_jmps>1 )     /* 2+ 2- */
252
250
        num_jmps   = 0;
253
 
return(BYTE)num_jmps ;
 
251
return(uchar)num_jmps ;
254
252
}
255
253
 
256
254
/* ���᫨�� NUM_LINES ����ﭨ� ᫥�� �� ����                  */
257
255
/* �ய�᪠�� ��砫�� ����� ��-�� ᪠窮� ����� DIST_LIN          */
258
256
/* ������ 㣫� ��।������ ���஬ � ��뢠�饩 �ணࠬ��               */
259
257
/* ���ࠢ����� �������� ������ D_X                                        */
260
 
static BYTE get_lines(BYTE *RASTER, INT D_X, INT dx,
261
 
                INT (*Distance)(BYTE *, INT) , INT h)
 
258
static uchar get_lines(uchar *RASTER, int16_t D_X, int16_t dx,
 
259
                int16_t (*Distance)(uchar *, int16_t) , int16_t h)
262
260
{
263
 
INT i,old,neue;
 
261
int16_t i,old,neue;
264
262
 
265
263
memset( buf_lines,0,sizeof(buf_lines));
266
264
 
302
300
return( calc_one_angle(h) );
303
301
}
304
302
 
305
 
BYTE Let_Width_Bottom_Right_Curve[]="�����";
 
303
uchar Let_Width_Bottom_Right_Curve[]="�����";
306
304
/* ���ਬ����� �� 㣫� ᨬ���� let, h - ����, type - ���ᨢ�����   */
307
 
INT discr_angles(BYTE let, INT h, INT type)
 
305
int16_t discr_angles(uchar let, int16_t h, int16_t type)
308
306
{
309
307
 
310
308
default_corners = (CRN *)(type ? def_corn_cs : def_corn);
311
309
 
312
310
memcpy(&cut_crn,&cut_crn0,sizeof(cut_crn));
313
311
#ifdef UFA
314
 
default_corners[(BYTE)'�'].tr=0;
 
312
default_corners[(uchar)'�'].tr=0;
315
313
if( MEMCHR(Let_Width_Bottom_Right_Curve,let,
316
314
    sizeof(Let_Width_Bottom_Right_Curve)) )
317
315
      memcpy(&cut_crn,&cut_crn1,sizeof(cut_crn));
319
317
 
320
318
if( multy_language )
321
319
  {
322
 
  default_corners[(BYTE)'5'].tl=N_C;
323
 
  default_corners[(BYTE)'5'].bl=A_C;
 
320
  default_corners[(uchar)'5'].tl=N_C;
 
321
  default_corners[(uchar)'5'].bl=A_C;
324
322
 
325
323
  if (!is_turkish_language(language)) // 21.05.2002 E.P.
326
 
        default_corners[(BYTE)'�'].tr=N_C;
 
324
        default_corners[(uchar)'�'].tr=N_C;
327
325
 
328
 
  default_corners[(BYTE)'�'].tr=N_C;
 
326
  default_corners[(uchar)'�'].tr=N_C;
329
327
  }
330
328
 
331
329
return check_angles(let,h);
332
330
}
333
331
 
334
332
/* ᪮�쪮 ��ப ���� �� �࠭��� ���������� */
335
 
static BYTE is_angle(BYTE *RASTER, INT D_X, INT dx,
336
 
                INT (*Distance)(BYTE *, INT) , INT h, INT dest)
 
333
static uchar is_angle(uchar *RASTER, int16_t D_X, int16_t dx,
 
334
                int16_t (*Distance)(uchar *, int16_t) , int16_t h, int16_t dest)
337
335
{
338
 
INT zero,i;
 
336
int16_t zero,i;
339
337
 
340
338
for(zero=i=0;i<h;i++,RASTER+=D_X)
341
339
  zero += ( Distance(RASTER,dx)==dest );
343
341
return zero>2;
344
342
}
345
343
 
346
 
void calc_angles(struct rst *_rst,PBYTE segment,BYTE ang[],BYTE cutl,BYTE cutr)
 
344
void calc_angles(struct rst *_rst,puchar segment,uchar ang[],uchar cutl,uchar cutr)
347
345
{
348
 
BYTE *rt,*rb;
349
 
INT D_X,dx;
350
 
INT skip,h;
351
 
INT right_dest;
 
346
uchar *rt,*rb;
 
347
int16_t D_X,dx;
 
348
int16_t skip,h;
 
349
int16_t right_dest;
352
350
 
353
351
        height = _rst->h;
354
352
        h = _rst->h<LARGE_KEGL?4:5;
361
359
memset(&cut_crn0,0,sizeof(cut_crn));
362
360
memset(&cut_crn1,0,sizeof(cut_crn));
363
361
 
364
 
        skip = long_line(segment,(INT)(_rst->w/3),0,0);
 
362
        skip = long_line(segment,(int16_t)(_rst->w/3),0,0);
365
363
        angles.tl =get_lines(rt+D_X*skip,D_X,dx,LeftDistance,h);
366
364
        if( cutl && is_angle(rt+D_X*skip,D_X,dx,LeftDistance,4,0) )
367
365
          cut_crn1.tl=1;
368
366
 
369
 
        skip = long_line(segment,(INT)(_rst->w/3),(INT)(_rst->h-1),0);
370
 
        angles.bl =get_lines(rb-D_X*skip,(INT)(-D_X),dx,LeftDistance,h);
371
 
        if( cutl && is_angle(rb-D_X*skip,(INT)(-D_X),dx,LeftDistance,4,0) )
 
367
        skip = long_line(segment,(int16_t)(_rst->w/3),(int16_t)(_rst->h-1),0);
 
368
        angles.bl =get_lines(rb-D_X*skip,(int16_t)(-D_X),dx,LeftDistance,h);
 
369
        if( cutl && is_angle(rb-D_X*skip,(int16_t)(-D_X),dx,LeftDistance,4,0) )
372
370
          cut_crn1.bl=1;
373
371
 
374
 
        skip = long_line(segment,(INT)(_rst->w/3),0,1);
 
372
        skip = long_line(segment,(int16_t)(_rst->w/3),0,1);
375
373
        angles.tr =get_lines(rt+D_X*skip,D_X,dx,RightDistance,h);
376
 
        if( cutr && is_angle(rt,(INT)(D_X*skip),dx,RightDistance,4,right_dest) )
 
374
        if( cutr && is_angle(rt,(int16_t)(D_X*skip),dx,RightDistance,4,right_dest) )
377
375
          cut_crn1.tr=1;
378
376
 
379
 
        skip = long_line(segment,(INT)(_rst->w/3),(INT)(_rst->h-1),1);
380
 
        angles.br =get_lines(rb-D_X*skip,(INT)(-D_X),dx,RightDistance,h);
381
 
        if( cutr && is_angle(rb-D_X*skip,(INT)(-D_X),dx,RightDistance,4,right_dest) )
 
377
        skip = long_line(segment,(int16_t)(_rst->w/3),(int16_t)(_rst->h-1),1);
 
378
        angles.br =get_lines(rb-D_X*skip,(int16_t)(-D_X),dx,RightDistance,h);
 
379
        if( cutr && is_angle(rb-D_X*skip,(int16_t)(-D_X),dx,RightDistance,4,right_dest) )
382
380
          cut_crn1.br=1;
383
381
 
384
382
memcpy(ang,&angles,4*sizeof(ang[0]));
385
383
return ;
386
384
}
387
385
 
388
 
INT long_line( PBYTE seg,INT w,INT line,INT part)
 
386
int16_t long_line( puchar seg,int16_t w,int16_t line,int16_t part)
389
387
{
390
388
segment * segm;
391
389