PageRenderTime 64ms CodeModel.GetById 14ms RepoModel.GetById 1ms app.codeStats 1ms

/Spikes/GocrDemo/ocr0.c

http://stp-iphone.googlecode.com/
C | 6756 lines | 5455 code | 438 blank | 863 comment | 4512 complexity | ffa277b2d87e6c78c5649170766ee916 MD5 | raw file
Possible License(s): Apache-2.0

Large files files are truncated, but you can click here to view the full file

    

  1. /*
    2. 

  2.   rule based OCR engine, partly rewritten for edges (old=pixel)
    3. 

  3.  */ 
    4. 

  4. /*
    5. 

  5. This is a Optical-Character-Recognition program
    6. 

  6. Copyright (C) 2000-2009 Joerg Schulenburg
    7. 

    8. 

  8. This program is free software; you can redistribute it and/or
    9. 

  9. modify it under the terms of the GNU General Public License
    10. 

  10. as published by the Free Software Foundation; either version 2
    11. 

  11. of the License, or (at your option) any later version.
    12. 

    13. 

  13. This program is distributed in the hope that it will be useful,
    14. 

  14. but WITHOUT ANY WARRANTY; without even the implied warranty of
    15. 

  15. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    16. 

  16. GNU General Public License for more details.
    17. 

    18. 

  18. You should have received a copy of the GNU General Public License
    19. 

  19. along with this program; if not, write to the Free Software
    20. 

  20. Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
    21. 

    22. 

  22.  see README for email address
    23. 

    24. 

  24.  >>>  DO NOT EDIT THIS FILE IF YOU NOT REALLY KNOW WHAT YOU ARE DOING! <<<
    25. 

  25.   
    26. 

  26.   I have invested lot of time, to write this part of the program.
    27. 

  27.   This engine should recognize chars allways right or return UNKNOWN.
    28. 

  28.   If you change something, test all other example files too, 
    29. 

  29.   to be sure that all things work better.   (JoergS)
    30. 

  30.   
    31. 

  31.   This engine was pixelbased until 0.40 which was not successfull enough.
    32. 

  32.   Also code changes always hade side effects. The vectorisation of the code
    33. 

  33.   starts from version 0.41 with the chars XNz and seems to be much better
    34. 

  34.   to handle. Vectorization means we frame each character by a chain of
    35. 

  35.   vectors and dont care about pixels anymore. Unfortunatly I have to
    36. 

  36.   replace all the pixel codes, which is a long process. Old code will be lost.
    37. 

  37.   (JorgS)
    38. 

    39. 

    40. 

  40. ToDo:
    41. 

  41.   - if box1->p and b differ, reduce probability
    42. 

  42.   - probability makes life much easier here
    43. 

  43.   - use only one box!?, may be bits have usefull infos
    44. 

  44.   - divide this file, suggestion: classify chars:
    45. 

  45.       high=ABCDEFGHIJKLMNOPQRSTUVWXYZbdfhklt, low=acegijmnopqrsuvwxyz
    46. 

  46.       or
    47. 

  47.       often_used=etianmsurwdkgo     rarely_used=hvjcflpqxyz.,:
    48. 

  48.       or
    49. 

  49.       every char (large overhead)
    50. 

  50.   - two-pass version (first pass without tolerance)
    51. 

  51.     2nd pass with tolerance (ex: one tiny more in sdata->holes)
    52. 

    53. 

  53.   general feature extraction:
    54. 

  54.    - white holes at middle, upper, lower position (cost much time)
    55. 

  55.    - test lines and triangles insteat of rectangles
    56. 

  56.    
    57. 

  57.    char is removed, wchar_t is used  (better code)
    58. 

  58.    
    59. 

  59.    making a static global variable-set x.x0,x.x1, and call test_a,
    60. 

  60.       test_b ... (faster compilation, but not reentrant!)
    61. 

  61.       
    62. 

  62.    - adding slant-angle (if detected) to distinguish between l and / ?
    63. 

  63.    - ac (alternate chars) as string add_ac(box1,"/") => box1->ac="Il/";
    64. 

  64.      for better context correction or output: "Ha[lI][lI]o!"
    65. 

    66. 

  66. */
    67. 

  67. 

  68. #include <stdlib.h>
    69. 

  69. #include <stdio.h>
    70. 

  70. // #include "pgm2asc.h"
    71. 

  71. #include "ocr0.h"
    72. 

  72. // #include "ocr1.h"
    73. 

  73. #include "amiga.h"
    74. 

  74. #include "pnm.h"
    75. 

  75. #include "gocr.h"
    76. 

  76. 

  77. #define IFV if(JOB->cfg.verbose&4)
    78. 

  78. #define MM {IFV fprintf(stderr,"\nDBG %c L%04d (%d,%d): ",(char)c_ask,__LINE__,box1->x0,box1->y0);}
    79. 

  79. 

  80. // the old debug mode (0.40) was only for a special char, for another char
    81. 

  81. //   code must be recompiled with C_ASK='char'
    82. 

  82. // new debug mode (0.41) explains why char is declined or accepted as ABC...
    83. 

  83. //   the output can be filtered by external scripts
    84. 

  84. //   ToDo: we could reduce output to filter string
    85. 

  85. #ifndef DO_DEBUG       /* can be defined outside (configure --with-debug) */
    86. 

  86. #define DO_DEBUG 0     /* 0 is the default */
    87. 

  87. #endif
    88. 

  88. 

  89. /* this macro is for debugging output: "if char is declined, why?" */
    90. 

  90. #if DO_DEBUG   /* 0=Work mode, 1=debugging mode */
    91. 

  91. // Setac: output, that char is choosen with a probability
    92. 

  92. // Break: output, why the char is not choosen
    93. 

  93. // MSG: debugging functions for char C_ASK, mostly messages
    94. 

  94. // DBG: definitions usefull only for debugging
    95. 

  95. #define Setac(box1,ac,ad)  { MM;IFV fprintf(stderr,"setac %d",ad);setac(box1,ac,ad); }
    96. 

  96. #define Break              { MM;IFV fprintf(stderr,"break"); break; }
    97. 

  97. #define MSG(x)             { MM;IFV x }
    98. 

  98. #define DBG(x) x
    99. 

  99. #else
    100. 

  100. #define Setac(box1,ac,ad)  setac(box1,ac,ad)
    101. 

  101. #define Break break
    102. 

  102. #define MSG(x)
    103. 

  103. #define DBG(x)
    104. 

  104. #endif
    105. 

  105. 

  106. /* extern "C"{ */
    107. 

  107. 

  108. // static inline int sq(int x) { return x*x; } /* square */
    109. 

  109. 

  110. /*
    111. 

  111.  * go from vector j1 to vector j2 and measure maximum deviation of
    112. 

  112.  *   the steps from the line connecting j1 and j2
    113. 

  113.  * return the squared maximum distance
    114. 

  114.  *   in units of the box size times 1024
    115. 

  115.  *   ToDo: 1) better give back max-dx and max-dy ???
    116. 

  116.  *         errors if j1 and j2 are in different frames or belong to
    117. 

  117.  *         more then one frame?
    118. 

  118.  *         2) Better get deviation from a complete vector graphic?
    119. 

  119.  *         The vectorgraphic is the ideal test char adapted to the
    120. 

  120.  *         extrem vertices of the real char.
    121. 

  121.  */ 
    122. 

  122. int line_deviation( struct box *box1, int j1, int j2 ) {
    123. 

  123.   int r1x, r1y, r2x, r2y, r3x, r3y, i, x, y, d, dist, maxdist=0, frame, l2;
    124. 

  124.   r1x=box1->frame_vector[j1][0];
    125. 

  125.   r1y=box1->frame_vector[j1][1];
    126. 

  126.   r2x=box1->frame_vector[j2][0];
    127. 

  127.   r2y=box1->frame_vector[j2][1];
    128. 

  128.   if (!box1->num_frames) return(-1);
    129. 

  129.   if (j1<0 || j1>box1->num_frame_vectors[box1->num_frames-1] ||
    130. 

  130.       j2<0 || j2>box1->num_frame_vectors[box1->num_frames-1]) {
    131. 

  131.       fprintf(stderr,"Error in "__FILE__" L%d: idx out of range",__LINE__);
    132. 

  132.       return(-1);
    133. 

  133.   }
    134. 

  134.    /* get the frame the endvector belongs to */
    135. 

  135.   for (i=0;i<box1->num_frames;i++)
    136. 

  136.      if (j2<box1->num_frame_vectors[i]) break;
    137. 

  137.   frame=i;
    138. 

  138.    /* frame(j1)<=frame(j2) possible */
    139. 

  139.   for (i=j1;;i++) { // do it for each vector between j1 and j2
    140. 

  140.      if     (i >= box1->num_frame_vectors[frame])
    141. 

  141.        i=((frame)?box1->num_frame_vectors[frame-1]:0); /* go around */
    142. 

  142.      if (i==j2) break;
    143. 

  143.    // for (i=j1;i!=j2;i=(i+1)%box1->num_frame_vectors[0]) {~}
    144. 

  144.     r3x=box1->frame_vector[i][0];
    145. 

  145.     r3y=box1->frame_vector[i][1];
    146. 

  146.     // Language=german
    147. 

  147.     // german: Abstand Punkt von Strecke, Laenge Lotrechte
    148. 

  148.     // germ.Strecke  : l1=(r1+r2)/2+d*(r2-r1)/2    for  d=-1..1
    149. 

  149.     // germ.Lotrechte: l2=r3+b*[-(r2-r1).y,(r2-r1).x]
    150. 

  150.     // Schnittpunkt  : l1=l2,
    151. 

  151.     // eq1x: (r1x+r2x)/2-r3x+d*(r2x-r1x)/2+b*(r2y-r1y)=0
    152. 

  152.     // eq1y: (r1y+r2y)/2-r3y+d*(r2y-r1y)/2-b*(r2x-r1x)=0
    153. 

  153.     // eq2x: b*(r2x-r1x)*(r2y-r1y)=-((r1x+r2x)/2-r3x+d*(r2x-r1x)/2)*(r2x-r1x)
    154. 

  154.     // eq2y: b*(r2x-r1x)*(r2y-r1y)= ((r1y+r2y)/2-r3y+d*(r2y-r1y)/2)*(r2y-r1y)
    155. 

  155.     // eq2y-eq2x: ... in units of 1024 (fast integer rounded correctly)
    156. 

  156.     l2=sq(r2x-r1x)+sq(r2y-r1y); // square of distance r2-r1
    157. 

  157.     if (l2==0) { 
    158. 

  158.       // fprintf(stderr,"ocr0 L%d: r1==r2 r1= %d %d",__LINE__, r1x, r1y); // debugging
    159. 

  159.       d=-1024;
    160. 

  160.     } else 
    161. 

  161.     d=-( ((r1x+r2x)-2*r3x)*(r2x-r1x)
    162. 

  162.         +((r1y+r2y)-2*r3y)*(r2y-r1y))*1024/l2;  // ..-1024..+1024..
    163. 

  163.     if (d<=-1024) { x=r1x; y=r1y; }  // starting point
    164. 

  164.       else {
    165. 

  165.         if (d>=1024) { x=r2x; y=r2y; }  // end point
    166. 

  166.           else {
    167. 

  167.             x=((r1x+r2x)+1)/2+(d*(r2x-r1x))/2048;
    168. 

  168.             y=((r1y+r2y)+1)/2+(d*(r2y-r1y))/2048;
    169. 

  169.             /* we have the crossing point x,y now */
    170. 

  170.           }
    171. 

  171.       }
    172. 

  172.     dist=sq((x-r3x)*1024/(box1->x1-box1->x0+1))
    173. 

  173.         +sq((y-r3y)*1024/(box1->y1-box1->y0+1)); // 0..2*sq(1024)
    174. 

  174.     if (dist>maxdist) maxdist=dist;
    175. 

  175.     // for debugging:
    176. 

  176.     // fprintf(stderr,"\nDBG dev: %d-%d-%d dist=%5d max=%5d d=%d %d,%d-%d,%d"
    177. 

  177.     //                "  vector= %d %d  crosspoint= %d %d ",
    178. 

  178.     //               j1,i,j2,dist,maxdist,d,r1x,r1y,r2x,r2y,r3x,r3y,x,y);
    179. 

  179.   }
    180. 

  180.   return maxdist;
    181. 

  181. }
    182. 

  182. 

  183. /*
    184. 

  184.  * search vectors between j1 and j2 for nearest point a to point r 
    185. 

  185.  * example:
    186. 

  186.  * 
    187. 

  187.  *     r-> $$...$$   $ - mark vectors
    188. 

  188.  *         @@$..@@   @ - black pixels
    189. 

  189.  *         @@$..@@   . - white pixels
    190. 

  190.  *         @@@@.$@
    191. 

  191.  *     a-> @@$@$@@
    192. 

  192.  *         @$.@@@@
    193. 

  193.  *         @@..$@@
    194. 

  194.  *         @@..$@@
    195. 

  195.  *  j1 --> $$...$$ <-- j2
    196. 

  196.  *     
    197. 

  197.  * ToDo: vector aa[5] = {rx,ry,x,y,d^2,idx} statt rx,ry?
    198. 

  198.  *          j1 and j2 must be in the same frame
    199. 

  199.  *          return aa?
    200. 

  200.  *  2009-07:
    201. 

  201.  *     - change from normalized (dx=128,dy=128) to absolute distance
    202. 

  202.  *     - simpler and no squeeze effect (problem getting right i2 for "3")
    203. 

  203.  */
    204. 

  204. int nearest_frame_vector( struct box *box1, int j1, int j2, int rx, int ry) {
    205. 

  205.    int x,y,d,i,aa[4]; /* x,y,normalized_distance^2,vector_index */
    206. 

  206.    int frame=0;
    207. 

  207.    // int x0=box1->x0, y0=box1->y0,
    208. 

  208.    //     x1=box1->x1, y1=box1->y1;
    209. 

  209.    // int          dx=box1->x1-x0+1, dy=box1->y1-y0+1;
    210. 

  210.    if (!box1->num_frames) return(-1);
    211. 

  211.    if (j1<0 || j1>box1->num_frame_vectors[box1->num_frames-1] ||
    212. 

  212.        j2<0 || j2>box1->num_frame_vectors[box1->num_frames-1]) {
    213. 

  213.       fprintf(stderr,"Error in "__FILE__" L%d: idx %d-%d out of range\n",__LINE__,j1,j2);
    214. 

  214.       out_x(box1);
    215. 

  215.       return(-1);
    216. 

  216.    }
    217. 

  217.    aa[0]=x=box1->frame_vector[j2][0]; /* x */
    218. 

  218.    aa[1]=y=box1->frame_vector[j2][1]; /* y */
    219. 

  219.    /* maximum is (distance*128)^2 if r is inside the box */
    220. 

  220.    // aa[2]=d=2*sq(128)+sq((rx-(x0+x1)/2)*128/dx)+sq((ry-(y0+y1)/2)*128/dy);
    221. 

  221.    aa[2]=d=2*(sq(x-rx)+sq(y-ry)); /* must be greater than min. dist, Jul09 */
    222. 

  222.    aa[3]=j2;          /* vector index */
    223. 

  223.    /* get the frame the endvector belongs to */
    224. 

  224.    for (i=0;i<box1->num_frames;i++)
    225. 

  225.      if (j2<box1->num_frame_vectors[i]) break;
    226. 

  226.    frame=i;
    227. 

  227.    /* frame(j1)<=frame(j2) possible */
    228. 

  228.    for (i=j1;;i++) {
    229. 

  229.      if     (i >= box1->num_frame_vectors[frame])
    230. 

  230.        i=((frame)?box1->num_frame_vectors[frame-1]:0); /* go around */
    231. 

  231.      x=box1->frame_vector[i][0]; /* take a vector */
    232. 

  232.      y=box1->frame_vector[i][1];
    233. 

  233.      /* distance to upper left end, normalized to 128 */
    234. 

  234.      // d=sq((x-rx)*128/dx)+sq((y-ry)*128/dy); // old 2009-07
    235. 

  235.      d=sq(x-rx)+sq(y-ry);
    236. 

  236.      if (d<aa[2]) { aa[0]=x; aa[1]=y; aa[2]=d; aa[3]=i; }
    237. 

  237.      if (i==j2) break;
    238. 

  238.    }
    239. 

  239.    return aa[3];
    240. 

  240. }
    241. 

  241. 

  242. // test for umlauts, if ret>0 and m==1 box1 is changed
    243. 

  243. // m>0   modify box1->dots
    244. 

  244. // m==2  modify box1->y0
    245. 

  245. // called by pgm2asc + ocr0(?)
    246. 

  246. int testumlaut(struct box *box1, int cs, int m, wchar_t *modifier){
    247. 

  247.    // pix p=*(box1->p);
    248. 

  248.    int  r,y,x,x0,x1,y0,y1,dx,dy,m1,m2,m3,
    249. 

  249.         xl,xr,yu,yl;  // left, right, upper and lower border of dots
    250. 

  250.    wchar_t mod='\0';	/* (TeX-) modifier ~"'` for compose() */
    251. 

  251.    DBG( wchar_t c_ask='"'; )
    252. 

  252.    r=0;
    253. 

  253.    x0=box1->x0; x1=box1->x1; dx=x1-x0+1;
    254. 

  254.    y0=box1->y0; y1=box1->y1; dy=y1-y0+1;
    255. 

  255.    m1=box1->m1; m2=box1->m2; m3=box1->m3;
    256. 

  256.    xl=x0; xr=x1; yu=yl=y0;
    257. 

  257.    if( dy < 5  ||   4*y0 > 3*m2+m3 ) return 0;  // no low chars: .,-=
    258. 

  258.    /* modifier in box included? */
    259. 

  259.    if( 2*y1 > m1+m2 ){
    260. 

  260.     /* modifier in box included? */
    261. 

  261.     for(y=y0;2*y<y0+y1;y++)if( get_bw(xl,xr,y,y,box1->p,cs,1)==0 ) break;
    262. 

  262.     if( 2*y<y0+y1 ){ /* yes => extract */
    263. 

  263.       yl=y;
    264. 

  264.       while( get_bw(xl,xr,y,y,box1->p,cs,1)==0 && 2*y<=y0+y1) y++;
    265. 

  265.       if( m&2 ) box1->y0=y;	/* set new upper bond */
    266. 

  266.     } 
    267. 

  267.    }
    268. 

  268.    if( yu>=yl ) { if(m) box1->dots=0; return 0; } /* nothing found */
    269. 

  269.    if(    get_bw(xl-1,xl-1,yu,yl-1,box1->p,cs,1)==1 ) // neighbour overlap?
    270. 

  270.    while( get_bw(xl  ,xl  ,yu,yl-1,box1->p,cs,1)==1 && 2*xl<x0+x1) xl++;
    271. 

  271.    for(;xl<x1;xl++)if( get_bw(xl,xl,yu,yl,box1->p,cs,1)==1 ) break;
    272. 

  272.    for(;xr>xl;xr--)if( get_bw(xr,xr,yu,yl,box1->p,cs,1)==1 ) break;
    273. 

  273. 

  274.    if ( yl-1>yu ) {  // tall box ij"a"o"u
    275. 

  275. #if 0
    276. 

  276.      x=box1->y0; box1->y0=m1; out_x(box1); box1->y0=x;
    277. 

  277.      fprintf(stderr,"\n#testumlaut x= %d %d m1=%d m2=%d",x0,y0,m1-y0,m2-y0);
    278. 

  278.      fprintf(stderr," yu=%d yl=%d xl=%d xr=%d",yu-y0,yl-y0,xl-x0,xr-x0);
    279. 

  279. #define DEBUG 1
    280. 

  280. #endif
    281. 

  281.      {
    282. 

  282. 

  283.        x=xl;y=yu;
    284. 

  284.        if( get_bw(xl,x1+1,yu,yl-1,box1->p,cs,1)==0 ) r=0; // neighbour overlap?
    285. 

  285.        else
    286. 

  286.        if( get_bw(xl  ,xl  ,yu,yl-1,box1->p,cs,1)==0
    287. 

  287.         || get_bw(xl-1,xl-1,yu,yl-1,box1->p,cs,1)==0 ) // be sure there are gap to neighbours
    288. 

  288.        if( get_bw(xr  ,xr  ,yu,yl-1,box1->p,cs,1)==0
    289. 

  289.         || get_bw(xr+1,xr+1,yu,yl-1,box1->p,cs,1)==0 )
    290. 

  290.        { int i,j,x;
    291. 

  291.          r=1;
    292. 

  292.          //  ...@@@....  RING_ABOVE //  ..@@@..@@.  TILDE
    293. 

  293.          //  ..@...@...             //  @@.@@@@@..
    294. 

  294.          //  ..@...@...             //  @.........
    295. 

  295.          //  ..@..@@...
    296. 

  296.          //  ...@@@....
    297. 

  297.          for (i=yu;i<yl;i++) if (get_bw(xl,xr,i,i,box1->p,cs,1)==1) break;
    298. 

  298.          for (    ;i<yl;i++) if (get_bw(xl,xr,i,i,box1->p,cs,1)==0) break;
    299. 

  299.          for (j=xl;j<xr;j++) if (get_bw(j,j,yu,i,box1->p,cs,1)==1) break;
    300. 

  300.          for (    ;j<xr;j++) if (get_bw(j,j,yu,i,box1->p,cs,1)==0) break;
    301. 

  301.          for ( x=j;x<xr;x++) if (get_bw(x,x,yu,i,box1->p,cs,1)==1) break;
    302. 

  302.          // vert. gap detected
    303. 

  303.          if( j<xr && x<xr && j<x && xr-xl>2
    304. 

  304.           && num_obj(xl,xr,yu,yl-1,box1->p,cs)>=2  // not best!!!
    305. 

  305.           && num_cross(xl,xr,yu  +(yl-yu)/4,yu+  (yl-yu)/4,box1->p,cs) == 2 
    306. 

  306.           && num_cross(xl,xr,yl-1-(yl-yu)/2,yl-1-(yl-yu)/2,box1->p,cs) == 2
    307. 

  307.             ){    // may be the following lines are not quite ok
    308. 

  308.            while( get_bw(xl,xr,yl,yl,box1->p,cs,1)==0 && 2*yl<y0+y1) yl++;
    309. 

  309.            r=2; 
    310. 

  310. // out_x(box1);printf(" x,y=%d,%d i=%d xl=%d xr=%d yu=%d yl=%d",x0,y0,i-x0,xl-x0,xr-x0,yu-y0,yl-y0);
    311. 

  311. 	   mod = DIAERESIS;
    312. 

  312.          }
    313. 

  313.          if( m&2 ) box1->y0=yl;
    314. 

  314. /*         if( m&2 ) box1->y0= ( (r==1) ? yu : yl ); */
    315. 

  315.          // out_x(box1);
    316. 

  316.        }
    317. 

  317.        if(r==0){ // divided fr != fi
    318. 

  318.          while( get_bw(x0,x1,yu,yu,box1->p,cs,1)==0 && 2*yu<y0+y1) yu++;
    319. 

  319.          if(m)box1->y0=yu;
    320. 

  320.        }
    321. 

  321.        if( r==1 ){ yl--;
    322. 

  322. //        .@@@.    ..@@.
    323. 

  323. //        .@@..    .@@..
    324. 

  324. //        .@...    .@@..
    325. 

  325. //
    326. 

  326. //         if( loop(box1->p,xl,yu,xr-xl,cs,0,RI)
    327. 

  327. //           > loop(box1->p,xl,yl,xr-xl,cs,0,RI) // +dx/8
    328. 

  328. //          && loop(box1->p,xr,yu,xr-xl,cs,0,LE)
    329. 

  329. //           < loop(box1->p,xr,yl,xr-xl,cs,0,LE)) // -dx/8 ) // &eacute; Nov03 
    330. 

  330.          if( loop(box1->p,xl,yu,xr-xl,cs,0,RI)
    331. 

  331.            - loop(box1->p,xr,yu,xr-xl,cs,0,LE)
    332. 

  332.            > loop(box1->p,xl,yl,xr-xl,cs,0,RI) // +dx/8
    333. 

  333.            - loop(box1->p,xr,yl,xr-xl,cs,0,LE)+1) // -dx/8 ) // &eacute; Nov03 
    334. 

  334. 	   mod = ACUTE_ACCENT; // '
    335. 

  335. 

  336.          if(  xr-xl+1 > 3*(yl-yu+1)
    337. 

  337.            && get_bw(xl,xr,yu,yl,box1->p,cs,2)==0 )
    338. 

  338. 	   mod = MACRON; // "-" above
    339. 

  339. 

  340. //        .@@@.   .@@..
    341. 

  341. //        ..@@.   ..@@.
    342. 

  342. //        ...@.   ..@@.
    343. 

  343. //
    344. 

  344. //         if( loop(box1->p,xl,yu,xr-xl,cs,0,RI)
    345. 

  345. //           < loop(box1->p,xl,yl,xr-xl,cs,0,RI) // -dx/8
    346. 

  346. //          && loop(box1->p,xr,yu,xr-xl,cs,0,LE)
    347. 

  347. //           > loop(box1->p,xr,yl,xr-xl,cs,0,LE) ) // +dx/8 ) &agrave; Nov03
    348. 

  348.          if( loop(box1->p,xl,yu,xr-xl,cs,0,RI)
    349. 

  349.            - loop(box1->p,xr,yu,xr-xl,cs,0,LE)
    350. 

  350.            < loop(box1->p,xl,yl,xr-xl,cs,0,RI) // -dx/8
    351. 

  351.            - loop(box1->p,xr,yl,xr-xl,cs,0,LE) -1 ) // +dx/8 ) &agrave; Nov03
    352. 

  352. 	   mod = GRAVE_ACCENT; // ` 
    353. 

  353. 

  354. #ifdef DEBUG
    355. 

  355.      fprintf(stderr,"\n#testumlaut x= %d %d m1=%d m2=%d",x0,y0,m1-y0,m2-y0);
    356. 

  356.      fprintf(stderr," yu=%d yl=%d xl=%d xr=%d",yu-y0,yl-y0,xl-x0,xr-x0);
    357. 

  357. #endif
    358. 

  358.          if(    (xr-xl+1)   < 2*(yl-yu+1)+2
    359. 

  359.            && 2*(xr-xl+1)+2 >   (yl-yu+1) )  {
    360. 

  360.            int i,i1,i2,i3,i4;
    361. 

  361.            i1=loop(box1->p,xl   ,(yu+yl)/2,xr-xl+1,cs,0,RI);
    362. 

  362.            i1=loop(box1->p,xl+i1,(yu+yl)/2,xr-xl+1,cs,1,RI);
    363. 

  363.            i2=loop(box1->p,(xl+xr)/2,yu   ,yl-yu+1,cs,0,DO);
    364. 

  364.            i2=loop(box1->p,(xl+xr)/2,yu+i2,yl-yu+1,cs,1,DO);
    365. 

  365.            for (i=0;i<xr-xl+1 && i<yl-yu+1;i++)
    366. 

  366.              if (getpixel(box1->p,xl+i,yu+i)< cs) break; i3=i;
    367. 

  367.            for (   ;i<xr-xl+1 && i<yl-yu+1;i++)
    368. 

  368.              if (getpixel(box1->p,xl+i,yu+i)>=cs) break; i3=i-i3;
    369. 

  369.            for (i=0;i<xr-xl+1 && i<yl-yu+1;i++)
    370. 

  370.              if (getpixel(box1->p,xr-i,yu+i)< cs) break; i4=i;
    371. 

  371.            for (   ;i<xr-xl+1 && i<yl-yu+1;i++)
    372. 

  372.              if (getpixel(box1->p,xr-i,yu+i)>=cs) break; i4=i-i4;
    373. 

  373. #ifdef DEBUG
    374. 

  374.            fprintf(stderr,"\n#DEBUG DOT_ABOVE %d %d %d %d",i1,i2,i3,i4);
    375. 

  375. #endif
    376. 

  376.            if ( (xr-xl<5 && yl-yu<8)   /* to small */
    377. 

  377.              || (i1>=(xr-xl+1)/2+2 && i2>=(yl-yu+1)/2+2 /* symmetrical */
    378. 

  378.               && abs(i3-i4)<=i1/4+2 && abs(i1-i2)<=i1/4+2
    379. 

  379.               && abs(i3-i1)<=i1/4+4 && abs(i4-i2)<=i1/4+4)
    380. 

  380.            )
    381. 

  381. 	   mod = DOT_ABOVE; // "." above, ToDo: improve it!
    382. 

  382.          }
    383. 

  383. 

  384.          if( ( loop(box1->p,xl,yu  ,xr-xl,cs,0,RI)
    385. 

  385.              > loop(box1->p,xl,yl  ,xr-xl,cs,0,RI)-dx/8
    386. 

  386.             || loop(box1->p,xl,yu  ,xr-xl,cs,0,RI)
    387. 

  387.              > loop(box1->p,xl,yl-1,xr-xl,cs,0,RI)-dx/8 )
    388. 

  388.           && ( loop(box1->p,xr,yu  ,xr-xl,cs,0,LE)
    389. 

  389.              > loop(box1->p,xr,yl  ,xr-xl,cs,0,LE)-dx/8
    390. 

  390.             || loop(box1->p,xr,yu  ,xr-xl,cs,0,LE)
    391. 

  391.              > loop(box1->p,xr,yl-1,xr-xl,cs,0,LE)-dx/8 )
    392. 

  392.          &&   num_cross(xl,xr,yu  ,yu  ,box1->p,cs) == 1 
    393. 

  393.          && ( num_cross(xl,xr,yl  ,yl  ,box1->p,cs) == 2
    394. 

  394.            || num_cross(xl,xr,yl-1,yl-1,box1->p,cs) == 2 )) 
    395. 

  395. 	   mod = CIRCUMFLEX_ACCENT; // "^"
    396. 

  396.          
    397. 

  397.          if( ( loop(box1->p,xl,yu  ,xr-xl,cs,0,RI)
    398. 

  398.              < loop(box1->p,xl,yl  ,xr-xl,cs,0,RI)-dx/10
    399. 

  399.            ||  loop(box1->p,xl,yu+1,xr-xl,cs,0,RI)
    400. 

  400.              < loop(box1->p,xl,yl  ,xr-xl,cs,0,RI)-dx/10 )
    401. 

  401.           && ( loop(box1->p,xr,yu  ,xr-xl,cs,0,LE)
    402. 

  402.              < loop(box1->p,xr,yl  ,xr-xl,cs,0,LE)-dx/10
    403. 

  403.             || loop(box1->p,xr,yu+1,xr-xl,cs,0,LE)
    404. 

  404.              < loop(box1->p,xr,yl  ,xr-xl,cs,0,LE)-dx/10 )
    405. 

  405.          && ( num_cross(xl,xr,yu  ,yu  ,box1->p,cs) == 2
    406. 

  406.            || num_cross(xl,xr,yu+1,yu+1,box1->p,cs) == 2 )
    407. 

  407.          &&   num_cross(xl,xr,yl  ,yl  ,box1->p,cs) == 1 ) 
    408. 

  408. 	   mod = CARON;   // "v" above
    409. 

  409.          
    410. 

  410.          if(  /* test for bow (new0.3.6) */
    411. 

  411.                  loop(box1->p,xl,yu       ,xr-xl,cs,0,RI)
    412. 

  412.              +   loop(box1->p,xl,yl       ,xr-xl,cs,0,RI)
    413. 

  413.              - 2*loop(box1->p,xl,(yl+yu)/2,xr-xl,cs,0,RI) > dx/16+1
    414. 

  414.            && xr-xl>10)
    415. 

  415.          if( ( loop(box1->p,xl,yu  ,xr-xl,cs,0,RI)
    416. 

  416.              < loop(box1->p,xl,yl  ,xr-xl,cs,0,RI)-dx/10
    417. 

  417.            ||  loop(box1->p,xl,yu+1,xr-xl,cs,0,RI)
    418. 

  418.              < loop(box1->p,xl,yl  ,xr-xl,cs,0,RI)-dx/10 )
    419. 

  419.           && ( loop(box1->p,xr,yu  ,xr-xl,cs,0,LE)
    420. 

  420.              < loop(box1->p,xr,yl  ,xr-xl,cs,0,LE)-dx/10
    421. 

  421.             || loop(box1->p,xr,yu+1,xr-xl,cs,0,LE)
    422. 

  422.              < loop(box1->p,xr,yl  ,xr-xl,cs,0,LE)-dx/10 )
    423. 

  423.          && ( num_cross(xl,xr,yu  ,yu  ,box1->p,cs) == 2
    424. 

  424.            || num_cross(xl,xr,yu+1,yu+1,box1->p,cs) == 2 )
    425. 

  425.          &&   num_cross(xl,xr,yl  ,yl  ,box1->p,cs) == 1 ) 
    426. 

  426. 	   mod = BREVE;   // round "u" above
    427. 

  427.          
    428. 

  428.         if( xr-xl>3 && yl-yu>1 )
    429. 

  429.          if( loop(box1->p,xl,yu,xr-xl,cs,0,RI)
    430. 

  430.            > loop(box1->p,xl,yl,xr-xl,cs,0,RI)
    431. 

  431.           && loop(box1->p,xr,yu,xr-xl,cs,0,LE)
    432. 

  432.            < loop(box1->p,xr,yl,xr-xl,cs,0,LE)
    433. 

  433.          && num_cross(xl,xr,yu,yu,box1->p,cs) == 2 
    434. 

  434.          && num_cross(xl,xr,yl,yl,box1->p,cs) == 2 ) 
    435. 

  435. 	   mod = TILDE;
    436. 

  436. 

  437.         if( xr-xl>2 && yl-yu>2)
    438. 

  438.         if( num_cross(xl,xr,(yu+yl)/2,(yu+yl)/2,box1->p,cs) >1 )
    439. 

  439.         if( num_cross((xl+xr)/2,(xl+xr)/2,yu,yl,box1->p,cs) >1 )
    440. 

  440.         if( num_hole(xl,xr,yu,yl,box1->p,cs,NULL) == 1 )
    441. 

  441. 	   mod = RING_ABOVE;
    442. 

  442. 

  443. #ifdef DEBUG
    444. 

  444. 	printf("\n#DEBUG umlaut mod=0x%04x x=%d..%d y=%d..%d r=%d %s",
    445. 

  445. 	  (int)mod,yu-box1->y0,yl-box1->y0,
    446. 

  446. 	           xl-box1->x0,xr-box1->x0,r,((mod==CARON)?"CARON":
    447. 

  447. 	                                     ((mod==ACUTE_ACCENT)?"ACUTE":
    448. 

  448. 	                                     ((mod==TILDE)?"TILDE":"?"))));
    449. 

  449. 	out_x(box1);
    450. 

  450. #endif
    451. 

  451. 

  452.        }
    453. 

  453.      }
    454. 

  454.      if (m) box1->dots=r; // set to 0 also possible after division
    455. 

  455.      if (m) box1->modifier=mod; /* should be resetted after compose ??? */
    456. 

  456.      MSG(fprintf(stderr,"umlaut mod=%s dots=%d y0o=%d",decode(mod,ASCII),r,y0);)
    457. 

  457.    }
    458. 

  458. //   printf(" modifier=%c",mod);
    459. 

  459.    if (modifier) *modifier=mod;	/* set modifier */
    460. 

  460.    return r;
    461. 

  461. }
    462. 

  462. 

  463.  
    464. 

  464. static wchar_t ocr0_eE(ocr0_shared_t *sdata){
    465. 

  465.    struct box *box1=sdata->box1;
    466. 

  466.    int	i,i1,i2,j,d,x,y,hchar=sdata->hchar,gchar=sdata->gchar,bad_e=0,
    467. 

  467.         x0=box1->x0,x1=box1->x1,y0=box1->y0,y1=box1->y1,cs=sdata->cs;
    468. 

  468.    int  dx=x1-x0+1,dy=y1-y0+1,	/* size */
    469. 

  469.         ad;	/* tmp-vars */
    470. 

  470.    int (*aa)[4]=sdata->aa;    /* corner-points, (x,y,dist^2,vector_idx) */
    471. 

  471. 

  472.    // --- most frequent letter e first!!!
    473. 

  473.    // --- test e ---------------------------------------------------
    474. 

  474.    for(ad=d=100;dx>2 && dy>3;){     // min 3x4 (smallest seen is 5x6)
    475. 

  475.       DBG( wchar_t c_ask='e'; )
    476. 

  476.       if (sdata->holes.num > 2) Break; /* tolerant against a tiny hole */
    477. 

  477.       if (sdata->holes.num != 1) ad=97*ad/100;
    478. 

  478.       /* ToDo: may be a two pass version intolerant/tolerant is better */
    479. 

  479.       if( loop(box1->p,x0,y0+dy/2,x1-x0,cs,0,RI)>dx/3 ) Break; // rough test
    480. 

  480.       if( loop(box1->p,x0+dx/2,y0,y1-y0,cs,0,DO)>dy/3 ) Break;
    481. 

  481.       if( loop(box1->p,x0+dx/2,y1,y1-y0,cs,0,UP)>dy/3 ) Break;
    482. 

  482.       if( num_cross(x0,x1,y0+dy/4  ,y0+dy/4  ,box1->p,cs) > 2
    483. 

  483.        && num_cross(x0,x1,y0+dy/4+1,y0+dy/4+1,box1->p,cs) > 2 ) Break; // gt
    484. 

  484.       x=(x0+x1)/2;i= num_cross(x,x,y0,y1,box1->p,cs); // v0.40
    485. 

  485.       if (i!=3) { x=(x0+2*x1)/3;i= num_cross(x,x,y0,y1,box1->p,cs); }
    486. 

  486.       if (i!=3) { x=(x0+3*x1)/4;i= num_cross(x,x,y0,y1,box1->p,cs); }
    487. 

  487.       if (i!=3) { i= num_cross((x0+2*x1)/3,(x0+x1)/2,y0,y1,box1->p,cs); }
    488. 

  488.       i=loop(box1->p,x0,y0+dy/2,x1-x0,cs,0,RI); if( i>dx/2 ) Break;
    489. 

  489.       j=loop(box1->p,x0,y0     ,x1-x0,cs,0,RI); if( j<i    ) Break;
    490. 

  490.       j=loop(box1->p,x0,y1     ,x1-x0,cs,0,RI); if( j<i    ) Break;
    491. 

  491.       i=loop(box1->p,x0+dx/2,y0,y1-y0,cs,0,DO); if( i>dx/2 ) Break;
    492. 

  492.       j=loop(box1->p,x1-dx/3,y0,y1-y0,cs,0,DO); if( j<i ) i=j;
    493. 

  493.       j=loop(box1->p,x0     ,y0,y1-y0,cs,0,DO); if( j<i    ) Break;
    494. 

  494.       j=loop(box1->p,x1     ,y0,y1-y0,cs,0,DO); if( j<i    ) Break;
    495. 

  495.       i=loop(box1->p,x0+dx/2,y1,y1-y0,cs,0,UP); if( i>dx/2 ) Break;
    496. 

  496.       j=loop(box1->p,x0     ,y1,y1-y0,cs,0,UP); if( j<i    ) Break;
    497. 

  497.       j=loop(box1->p,x1     ,y1,y1-y0,cs,0,UP); if( j<i    ) Break;
    498. 

  498.       j=2*loop(box1->p,x0,  (y0+y1)/2,x1-x0,cs,0,RI)
    499. 

  499.          -loop(box1->p,x0,(3*y0+y1)/4,x1-x0,cs,0,RI)
    500. 

  500.          -loop(box1->p,x0,(y0+3*y1)/4,x1-x0,cs,0,RI);
    501. 

  501.       if (dx>3 && j>=dx/4) Break; // ~g 4x6font
    502. 

  502.       for(y=1;y<dy/2;y++) if( num_cross(x0,x1,y0+y,y0+y,box1->p,cs) == 2 ) break;
    503. 

  503.       if( y==dy/2 ) Break;  // v0.2.5 ~ bad_t
    504. 

  504.       for(i=0,j=x0+dx/4;j<=x1-dx/4 && i<=dx/4;j++)
    505. 

  505.         if( num_cross(j,j,y0,y1,box1->p,cs) == 3 ) i++;
    506. 

  506.       if( dx>4 && dy>5 && (i<dx/4-1 || i==0) ) Break;  //  ~g but 4x6-e
    507. 

  507.       // look for horizontal white line (right gap) => set x,y
    508. 

  508.       for(x=0,y=i=y0+dy/3;i<y1-dy/6;i++){
    509. 

  509.         j=loop(box1->p,x1,i,y1-y0,cs,0,LE);
    510. 

  510.         if(j>=x) { x=j;y=i; }
    511. 

  511.       }
    512. 

  512.       if (x<dx/2){ // no gap found, fat font???
    513. 

  513.        // check smallest thickness left > 2* smallest thickness right
    514. 

  514.        for(i1=dx,i=y0+dy/3;i<y1-dy/6;i++){
    515. 

  515.         j =loop(box1->p,x0  ,i,y1-y0,cs,0,RI); if (j>dx/2) break;
    516. 

  516.         j =loop(box1->p,x0+j,i,y1-y0,cs,1,RI);
    517. 

  517.         if (j<i1) i1=j; // smallest thickness on left bow
    518. 

  518.        }
    519. 

  519.        for(i2=dx,y=i=y0+dy/3;i<y1-dy/6;i++){
    520. 

  520.         j =loop(box1->p,x1  ,i,y1-y0,cs,0,LE);
    521. 

  521.         j =loop(box1->p,x1-j,i,y1-y0,cs,1,LE);
    522. 

  522.         if(j<i2) { i2=j;y=i; }
    523. 

  523.        } if (3*i2>2*i1) Break; // not accepted, if right line is not very thinn 
    524. 

  524.        x =loop(box1->p,x1  ,y,y1-y0,cs,0,LE);
    525. 

  525.        x+=loop(box1->p,x1-x,y,y1-y0,cs,1,LE);
    526. 

  526.        x+=loop(box1->p,x1-x,y,y1-y0,cs,0,LE);
    527. 

  527.        if (3*i2>i1) ad=99*ad/100;
    528. 

  528.        if (2*i2>i1) ad=99*ad/100;
    529. 

  529.        bad_e=60; // used later?
    530. 

  530.       }
    531. 

  531.       if (x<dx/2) Break;
    532. 

  532.       for(i=1,j=x0+dx/6;j<x1-dx/6 && i;j++)
    533. 

  533.         if( num_cross(j,j,y0,y,box1->p,cs) > 1 ) i=0;
    534. 

  534.       if( i ) Break;
    535. 

  535. // ..@@@@...<-
    536. 

  536. // .@@@@@@;.
    537. 

  537. // @@,...@@.
    538. 

  538. // @@.....@,
    539. 

  539. // @@@@@@@@@
    540. 

  540. // @@.,;.@,.  <- problem (y) == bad_e>50
    541. 

  541. // @@.....@.
    542. 

  542. // @@,...@@.
    543. 

  543. // .@@@,@@@.
    544. 

  544. // ..@@@@;..<-
    545. 

  545.       if (dy>11 && bad_e<50)
    546. 

  546.       if ( num_cross(x0,x1,y,y,box1->p,cs) != 1 ) Break; // except "geschwungenem e"
    547. 

  547.       if ( num_cross(x0,x1-dx/3,y  ,y  ,box1->p,cs) != 1
    548. 

  548.         && num_cross(x0,x1-dx/3,y+1,y+1,box1->p,cs) != 1 ) Break;
    549. 

  549.       // if( num_hole(x0, x1, y0 , y  ,box1->p,cs,NULL) <  1 ){
    550. 

  550.       if( sdata->holes.num == 0 || sdata->holes.hole[0].y1 >= y-y0){
    551. 

  551.         if( sdata->hchar ) Break; // ~ \it t
    552. 

  552.         // look if thinn font (may be h-line is broken) Mai00
    553. 

  553.         for(j=0,i=x0+dx/8;i<x1-1;i++)
    554. 

  554.         if( get_bw(i,i,y0+dy/4,y,box1->p,cs,1) == 1 ) j++;
    555. 

  555.         if(j<2*dx/4) Break;
    556. 

  556.       }
    557. 

  557.       if( sdata->holes.num>0 && sdata->holes.hole[0].y0 > y-y0) Break;
    558. 

  558.       if( sdata->holes.num>1 && sdata->holes.hole[1].y0 > y-y0) Break;
    559. 

  559.       if( sdata->holes.num==1 && sdata->holes.hole[0].x0 >= dx/2) {
    560. 

  560.          ad=95*ad/100; } /* 8*10 @ (=at) is not an e */
    561. 

  561.       // look for horizontal gap
    562. 

  562.       for(x=0,y=i=y0+dy/4;i<y1-dy/4;i++){
    563. 

  563.         j=loop(box1->p,x0,i,x1-x0,cs,0,RI);
    564. 

  564.         if(j>=x) { x=j;y=i; }
    565. 

  565.       }
    566. 

  566.       if (y>y0+dy/4 && y<y1-dy/4 && x>dx/2) Break; // s
    567. 

  567.       if (x>dx/4) ad=99*ad/100;
    568. 

  568. 

  569.       if( num_cross(x0+dx/2,x1  ,y1-dy/4,y1  ,box1->p,cs) == 0
    570. 

  570.        && num_cross(x0+dx/2,x1-1,y1-dy/4,y1  ,box1->p,cs) == 0
    571. 

  571.        && num_cross(x0+dx/2,x1  ,y1-dy/4,y1-1,box1->p,cs) == 0 ) {
    572. 

  572.         if (sdata->gchar) Break; // ~p
    573. 

  573.         ad=99*ad/100;
    574. 

  574.       }
    575. 

  575.       /* upper case is for 5x6 box */
    576. 

  576.       if( sdata->hchar  // broken B ? should also work when linedetection fails
    577. 

  577.        && loop(box1->p,x1,y1-dy/3,dx,cs,0,LE)<=dx/8 ) {
    578. 

  578.         x = loop(box1->p,x0,y0+dy/2,dx,cs,0,RI);
    579. 

  579.         if( loop(box1->p,x0,y0+dy/4,dx,cs,0,RI)<=x
    580. 

  580.          && loop(box1->p,x0,y0+dy/8,dx,cs,0,RI)<=x ) Break;
    581. 

  581.         if( loop(box1->p,x0,y1-dy/4,dx,cs,0,RI)<=x
    582. 

  582.          && loop(box1->p,x0,y1-dy/8,dx,cs,0,RI)<=x ) Break;
    583. 

  583.       }
    584. 

  584.       x = loop(sdata->bp,0,dy-2     ,dx,cs,0,RI);
    585. 

  585.       if( loop(sdata->bp,0,dy-1-dy/8,dx,cs,0,RI)>x && dy>16) Break; // some Q
    586. 

  586.       if (box1->m2) {
    587. 

  587.         if (sdata->gchar) ad=99*ad/100;
    588. 

  588.         if (sdata->hchar) ad=99*ad/100;
    589. 

  589.       } else              ad=99*ad/100;
    590. 

  590. 

  591.       Setac(box1,(wchar_t)'e',ad);
    592. 

  592.       if (ad>=100) return 'e';
    593. 

  593.       break;
    594. 

  594.    }
    595. 

  595.    // --- test E ---------------------------------------------------
    596. 

  596.    for(ad=d=100;dx>2 && dy>4 ;){     // min 3x4
    597. 

  597.      // rewritten for vectors 0.43
    598. 

  598.      int i1, i2, i3, i4, i5;  // line derivation + corners
    599. 

  599.      DBG( wchar_t c_ask='E'; )
    600. 

  600.      if (sdata->holes.num > 1) Break; /* tolerant against a tiny hole */
    601. 

  601.      /* half distance to the center */
    602. 

  602.      d=2*sq(128/4);
    603. 

  603.      /* now we check for the upper right end of the h */
    604. 

  604.      if (aa[3][2]>d/2) Break;  /* [2] = distance, ~dj... */
    605. 

  605.      if (aa[0][2]>d/2) Break;  /* upper left end */
    606. 

  606.      if (aa[1][2]>d/2) Break;  /* lower left end */
    607. 

  607.      if (aa[2][2]>d/2) Break;  /* lowerright end */
    608. 

  608. /*
    609. 

  609.            E            f near E 
    610. 

  610.                   
    611. 

  611.          OOOOOOOO         OOOO
    612. 

  612.           O5    O        O
    613. 

  613.           O4             O
    614. 

  614.           OOOO3        OOOOOO
    615. 

  615.           O2             O
    616. 

  616.           O              O
    617. 

  617.           O1    O        O
    618. 

  618.          OOOOOOOO      OOOOOO
    619. 

  619. */
    620. 

  620.      // check the bow from below
    621. 

  621.      for (i=aa[1][3];i!=aa[2][3];i=(i+1)%box1->num_frame_vectors[0]) {
    622. 

  622.        if (y1-box1->frame_vector[ i][1]>dy/4) break; // fatal!
    623. 

  623.      } if (i!=aa[2][3]) Break; // ~AHKMNRX
    624. 

  624.      // search most left+down between bottom right and top right
    625. 

  625.      i1=nearest_frame_vector(box1, aa[2][3],aa[3][3], x0, y1);
    626. 

  626.      i5=nearest_frame_vector(box1,       i1,aa[3][3], x0, y0);
    627. 

  627.      i3=nearest_frame_vector(box1, i1, i5,     x1, (y0+y1)/2);
    628. 

  628.      i2=nearest_frame_vector(box1, i1, i3,   x0, (2*y0+y1)/3);
    629. 

  629.      i4=nearest_frame_vector(box1, i3, i5,   x0, (y0+2*y1)/3);
    630. 

  630.      i =nearest_frame_vector(box1, aa[0][3],aa[1][3], x0-dx/4, (y0+y1)/2);
    631. 

  631.      if (2*box1->frame_vector[i][0] < aa[0][0]+aa[1][0]-1-dx/16) Break;
    632. 

  632.      if (2*box1->frame_vector[i][0] < aa[0][0]+aa[1][0]) ad=99*ad/100; // f
    633. 

  633. 

  634.      MSG(fprintf(stderr,"i1-5 %d %d %d %d %d",i1,i2,i3,i4,i5);)
    635. 

  635.       // holes right open?
    636. 

  636.       for( i=1,y=y0; y<y0+dy/4 && i; y++ ) // long black line
    637. 

  637.         if( get_bw(x0+dx/3,x1-dx/6,y,y,box1->p,cs,2) == 0 ) i=0;
    638. 

  638.       if( i ) Break;
    639. 

  639.       for( i=1,y=y1; y>y1-dy/4 && i; y-- ) // long black line
    640. 

  640.         if( get_bw(x0+dx/6,x1-dx/4,y,y,box1->p,cs,2) == 0 ) i=0;
    641. 

  641.       if( i ) Break;
    642. 

  642.       for( i=1,y=y0+dy/3; y<y1-dy/3 && i; y++ ){ // black line
    643. 

  643.         j=loop(box1->p,x0  ,y,dx,cs,0,RI);
    644. 

  644.         j=loop(box1->p,x0+j,y,dx,cs,1,RI); if( j>dx/3 ) i=0;
    645. 

  645.       } if( i ) Break;
    646. 

  646.       x=x1-dx/3; y=y0;		// von oben durchbohren!
    647. 

  647.       turmite(box1->p,&x,&y,x0,x1,y0,y1,cs,DO,ST); if( y>y0+dy/4 ) Break;
    648. 

  648.       turmite(box1->p,&x,&y,x0,x1,y0,y1,cs,ST,DO); if( y>y0+dy/3 ) Break;
    649. 

  649.       turmite(box1->p,&x,&y,x0,x1,y0,y1,cs,RI,DO); if( x<=x1 || y>y0+dy/2 ) Break;
    650. 

  650.       x=x1-dx/3; y=y1;		// von unten durchbohren!
    651. 

  651.       turmite(box1->p,&x,&y,x0,x1,y0,y1,cs,UP,ST); if( y<y1-dy/4 ) Break;
    652. 

  652.       turmite(box1->p,&x,&y,x0,x1,y0,y1,cs,ST,UP); if( y<y0-dy/3 ) Break;
    653. 

  653.       turmite(box1->p,&x,&y,x0,x1,y0,y1,cs,RI,UP); if( x<=x1 || y<y0+dy/2 ) Break;
    654. 

  654.       x=x1-dx/3; y=y0;		// von oben durchbohren!
    655. 

  655.       turmite(box1->p,&x,&y,x0,x1,y0,y1,cs,DO,ST); if( y>y0+dy/4 ) Break;
    656. 

  656.       turmite(box1->p,&x,&y,x0,x1,y0,y1,cs,ST,DO); if( y>y0+dy/3 ) Break;
    657. 

  657.       y+=dy/15;
    658. 

  658.       turmite(box1->p,&x,&y,x0,x1,y0,y1,cs,LE,ST); if( x<x0 ) Break;
    659. 

  659.       if (dx>15 && x==x0) ad=99*ad/100; // to thin
    660. 

  660.       x+=dx/15+1;
    661. 

  661.       turmite(box1->p,&x,&y,x0,x1,y0,y1,cs,DO,ST); if( y>y1-dy/3 ) Break;
    662. 

  662.       // if( num_hole(x0, x1, y0 , y1  ,box1->p,cs,NULL) > 0 ) Break;
    663. 

  663.       if (sdata->holes.num > 0) Break;
    664. 

  664.       i=loop(box1->p,x0,y0+dy/4,dx,cs,0,RI); if(i>dx/2) Break;
    665. 

  665.       j=loop(box1->p,x0,y0+dy/2,dx,cs,0,RI); if(j<i-dx/4 || j>i+dx/8) Break; i=j;
    666. 

  666.       j=loop(box1->p,x0,y1-dy/4,dx,cs,0,RI); if(j<i-dx/4 || j>i+dx/8) Break;
    667. 

  667.       j=loop(box1->p,x1,y1-dy/4,dx,cs,0,LE); 
    668. 

  668.       for( x=dx,y=y0+dy/6; y<y1-dy/9; y++ ) // left border straight
    669. 

  669.       { i=loop(box1->p,x0,y,dx,cs,0,RI); 
    670. 

  670.         if (i>j/2 && ad>98) ad=99*ad/100;
    671. 

  671.         if (i>dx/4) break;
    672. 

  672.         if(i<x) x=i;
    673. 

  673.       } if( y<y1-dy/9 ) Break;	// t
    674. 

  674.       if(dy>3*dx)  // ~[
    675. 

  675.       if( get_bw(x0+dx/2,x0+dx/2,y0+dy/4,y1-dy/4,box1->p,cs,1) == 0 ) Break;
    676. 

  676. 

  677.       if (box1->m2) {
    678. 

  678.         if (!hchar) ad=ad*99/100;
    679. 

  679.         if ( gchar) ad=ad*99/100;
    680. 

  680.       }
    681. 

  681.       Setac(box1,(wchar_t)'E',ad);
    682. 

  682.       if (ad>=100) return 'E';
    683. 

  683.       break;
    684. 

  684.    }
    685. 

  685.    return box1->c;
    686. 

  686. }
    687. 

  687. 

  688. static wchar_t ocr0_n(ocr0_shared_t *sdata){
    689. 

  689.    struct box *box1=sdata->box1;
    690. 

  690.    int	i,j,d,x,y,i1,i2,i3,handwritten=0,
    691. 

  691.         x0=box1->x0,x1=box1->x1,y0=box1->y0,y1=box1->y1,cs=sdata->cs;
    692. 

  692.    int  dx=x1-x0+1,dy=y1-y0+1,	/* size */
    693. 

  693.         ad;	/* tmp-vars */
    694. 

  694. 

  695.    // --- test n ---------------------------------------------------
    696. 

  696.    // glued rm is very similar to glued nn -> thickness of h-line should grow
    697. 

  697.    // may02: tested for 8x12 font
    698. 

  698.    for(ad=d=100;dx>2 && dy>3;){     // min 3x4
    699. 

  699.       DBG( wchar_t c_ask='n'; )
    700. 

  700.       if (sdata->holes.num > 1) Break; /* tolerant against a tiny hole */
    701. 

  701.       i= num_cross( 0,dx-1,dy/4,dy/4,sdata->bp,cs);
    702. 

  702.       j= num_cross( 0,dx-1,dy/2,dy/2,sdata->bp,cs);
    703. 

  703.       if( (i<2 || i>3) && j!=2 ) Break;
    704. 

  704.       if( loop(sdata->bp,dx/2,0,dy,cs,0,DO) > dy/8 && sdata->hchar ) Break;  /* tt */
    705. 

  705.       y=5*dy/8;  /* also for handwritten n, where first bow goes not down enough */
    706. 

  706.       if( num_cross(   0,dx/2,y  ,y  ,sdata->bp,cs) != 1
    707. 

  707.        && num_cross(   0,dx/2,y-1,y-1,sdata->bp,cs) != 1
    708. 

  708.        && num_cross(dx/2,dx-1,y  ,y  ,sdata->bp,cs) <  1 ) Break; // n rr
    709. 

  709.       // ~thick_w
    710. 

  710.       y=loop(sdata->bp,dx-1-dx/4,0,dy,cs,0,DO); if(y>dy/2) Break;
    711. 

  711.       if(y>1)if( get_bw(dx-1-dx/4,dx-1,0,y-2,sdata->bp,cs,1) == 1 ) Break;
    712. 

  712. 

  713.       y=3*dy/4;
    714. 

  714.       if( num_cross(0,   dx/2,y  ,y  ,sdata->bp,cs) == 1
    715. 

  715.        && num_cross(dx/2,dx-1,y  ,y  ,sdata->bp,cs) == 0 ) Break; // ~p
    716. 

  716.       y=dy/2;
    717. 

  717.       if( num_cross(0,dx-1,dy/2-dy/8,dy/2-dy/8,sdata->bp,cs) == 2
    718. 

  718.        && num_cross(0,dx-1,dy/2,     dy/2     ,sdata->bp,cs) == 2 ) { // n rr
    719. 

  719.                 /* printed n */
    720. 

  720.         x =loop(sdata->bp,0,y,dx  ,cs,0,RI); if(x>  dx/4) Break; // search 1st v-line
    721. 

  721.         x+=loop(sdata->bp,x,y,dx-x,cs,1,RI); if(x>  dx/2) Break; i1=x; // 1st gap
    722. 

  722.         x+=loop(sdata->bp,x,y,dx-x,cs,0,RI); if(x<  dx/2) Break; i2=x; // 2nd v-line
    723. 

  723.         x+=loop(sdata->bp,x,y,dx-x,cs,1,RI); if(x<3*dx/4) Break; i3=x; // 2nd gap
    724. 

  724.         i=dy/4; y=13*dy/16;
    725. 

  725.         if( num_cross(dx/2,dx-1,y,y,sdata->bp,cs)==2 ) i=3*dy/8; // \it n
    726. 

  726.         if (i<2 && i<dy/2) i++; // correct for small fonts like 8x12
    727. 

  727.         // the same game for the lower part =>l1 l2 l3 l4 ???
    728. 

  728.         for(x=i1;x<i2;x++) if( loop(sdata->bp,x,   0,dy,cs,0,DO)>=i ) break;
    729. 

  729.         if(x <i2) Break; // gap detected
    730. 

  730.         for(x=i1;x<i2;x++) if( loop(sdata->bp,x,dy-1,dy,cs,0,UP) >dy/4 ) break;
    731. 

  731.         if(x==i2) Break; // no gap detected (glued serifs ??? )
    732. 

  732.         // glued rm as nn ???
    733. 

  733.         for(y=0,x=(i1+i2)/2;x<i2;x++){
    734. 

  734.            i=loop(sdata->bp,x,0,dy,cs,0,DO); 
    735. 

  735.            i=loop(sdata->bp,x,i,dy,cs,1,DO); // measure thickness
    736. 

  736.            if( i>y ) y=i; if( i<y/2 ) break;
    737. 

  737.         }
    738. 

  738.         if(x <i2) Break; // unusual property for n
    739. 

  739.         if( dy>7 )
    740. 

  740.         if(  loop(sdata->bp,dx-1,dy-1-dy/8,dx,cs,0,LE)
    741. 

  741.             +loop(sdata->bp,   0,dy-1-dy/8,dx,cs,0,RI)-dx/8-1
    742. 

  742.            > loop(sdata->bp,dx-1,dy-1-dy/2,dx,cs,0,LE)
    743. 

  743.             +loop(sdata->bp,   0,dy-1-dy/2,dx,cs,0,RI) ) ad=90*ad/100; // broken o
    744. 

  744.         if( dy>7 && dx>7 )
    745. 

  745.         if(  loop(sdata->bp,dx-1,     dy/2,dx,cs,0,LE)==0
    746. 

  746.           && loop(sdata->bp,dx-1,dy-1-dy/8,dx,cs,0,RI)>dx/8 ) ad=98*ad/100; // broken o
    747. 

  747.       } else {  /* check handwritten n */
    748. 

  748.         if( num_cross(0,dx-1,dy/2,     dy/2     ,sdata->bp,cs) != 3
    749. 

  749.          && num_cross(0,dx-1,dy/2-dy/8,dy/2-dy/8,sdata->bp,cs) != 3 ) Break;
    750. 

  750.         i =loop(sdata->bp,0,dy/2-dy/8,dx,cs,0,RI); if (i>dx/4) Break;
    751. 

  751.         i+=loop(sdata->bp,i,dy/2-dy/8,dx,cs,1,RI); if (i>dx/2) Break;
    752. 

  752.         i+=loop(sdata->bp,i,dy/2-dy/8,dx,cs,0,RI);
    753. 

  753.         if( num_cross(i,i,   0,dy/2-2*dy/8,sdata->bp,cs) != 0 ) Break;
    754. 

  754.         i+=loop(sdata->bp,i,dy/2-dy/8,dx,cs,1,RI);
    755. 

  755.         if( num_cross(i,i,dy/2+1,     dy-1,sdata->bp,cs) != 0 ) Break;
    756. 

  756.         handwritten=80; 
    757. 

  757.       }
    758. 

  758. 

  759.       i= loop(sdata->bp,dx-1  ,dy/2,dx,cs,0,LE); if(i>5)
    760. 

  760.       if( get_bw(dx-1-i/2,dx-1-i/2,0,dy/2,sdata->bp,cs,1) == 1 ) Break; // ~rr
    761. 

  761.       i+=loop(sdata->bp,dx-1-i,dy/2,dx,cs,1,LE);
    762. 

  762.       if( get_bw(dx-1-i  ,dx-1-i  ,0,dy/2,sdata->bp,cs,1) == 0 ) Break; // ~rv
    763. 

  763. 

  764.       if( get_bw(dx/2,dx/2,dy/4,dy/4,sdata->bp,cs,1) == 0
    765. 

  765.        && get_bw(dx/2,dx-1,dy-2,dy-2,sdata->bp,cs,1) == 0
    766. 

  766.        && get_bw(dx/2,dx/2,dy/4,dy-2,sdata->bp,cs,1) == 1 ) Break; // ~P
    767. 

  767. 

  768.       // glued ri ???
    769. 

  769.       if( box1->dots>0 && box1->m1 )
    770. 

  770.       if( get_bw((x1+x0)/2,x1,box1->m1,y0-1,box1->p,cs,1) == 1 )
    771. 

  771.       if( num_cross( 0,dx-1,0  ,0  ,sdata->bp,cs) >2
    772. 

  772.        || num_cross( 0,dx-1,1  ,1  ,sdata->bp,cs) >2 ) Break;
    773. 

  773. 

  774. 

  775.       i=loop(sdata->bp,dx-1,     dy-1,dx,cs,0,LE); if (i>dx/2)
    776. 

  776.       i=loop(sdata->bp,dx-1,     dy-2,dx,cs,0,LE);
    777. 

  777.       x=loop(sdata->bp,dx-1,dy-1-dy/4,dx,cs,0,LE);
    778. 

  778.       if (sdata->hchar && i-x>1) Break; // &szlig;
    779. 

  779.       x=loop(sdata->bp,   0,dy-1,dx,cs,0,LE);  // check for serifs
    780. 

  780.       i=loop(sdata->bp,   0,dy-2,dx,cs,0,LE); if (i<x) x=i;
    781. 

  781.       i=loop(sdata->bp,   0,   1,dx,cs,0,LE); if (i<x) x=i;
    782. 

  782.       i=loop(sdata->bp,   0,   2,dx,cs,0,LE); if (i<x) x=i;
    783. 

  783.       if (sdata->hchar && x>0) Break; // fl
    784. 

  784. 

  785.       if (num_cross( 0,dx-1,dy/4,dy/4,sdata->bp,cs)>=3) ad=98*ad/100; // small M
    786. 

  786.       if (sdata->hchar || 2*y0<box1->m1+box1->m2) ad=96*ad/100;
    787. 

  787.       if (sdata->gchar) ad=96*ad/100; // &szlig; fl 
    788. 

  788.       if (dx<5) { // for small fonts no middle line is possible for m
    789. 

  789.         ad=99*ad/100; // 4x6 m
    790. 

  790.         if (num_cross(0,dx-1,dy/8,dy/8,sdata->bp,cs)>=2) {
    791. 

  791.           ad=97*ad/100; // ~m
    792. 

  792.           if (dy<=4) Setac(box1,'m',97); // only for 4x6 font!
    793. 

  793.         }
    794. 

  794.       }
    795. 

  795.       Setac(box1,'n',ad);
    796. 

  796.       break;
    797. 

  797.    }
    798. 

  798.    return box1->c;
    799. 

  799. }
    800. 

  800. 

  801. static wchar_t ocr0_M(ocr0_shared_t *sdata){
    802. 

  802.    struct box *box1=sdata->box1;
    803. 

  803.    pix *bp=sdata->bp;
    804. 

  804.    int	d,x,y,i0,i1,i2,i3,t1,hchar=sdata->hchar,gchar=sdata->gchar,
    805. 

  805.         x0=box1->x0,x1=box1->x1,y0=box1->y0,y1=box1->y1,cs=sdata->cs;
    806. 

  806.    int  dx=x1-x0+1,dy=y1-y0+1,	/* size */
    807. 

  807.         ad;	/* tmp-vars */
    808. 

  808. 

  809.    // ------------------ test M ---------------------------
    810. 

  810.    for(ad=d=100;dx>3 && dy>3;){	// dy<=dx nicht perfekt! besser mittleres
    811. 

  811. 				// min-suchen fuer m
    812. 

  812.       DBG( wchar_t c_ask='M'; )
    813. 

  813.       if (sdata->holes.num > 1) Break; /* tolerant against a tiny hole */
    814. 

  814.       for (y=dy/4;y<=3*dy/4;y++)
    815. 

  815.         if (num_cross(0,dx-1,y,y,bp,cs)>=3) break;
    816. 

  816.       if (y>3*dy/4 && dx>4) Break;
    817. 

  817.       if( num_cross(0,dx-1,  dy/4,  dy/4,bp,cs)<2
    818. 

  818.        && num_cross(0,dx-1,  dy/8,  dy/8,bp,cs)<2 ) Break; /* fat M */
    819. 

  819.       if( num_cross(0,dx-1,3*dy/4,3*dy/4,bp,cs)<2 ) Break;
    820. 

  820.       
    821. 

  821.       x = loop(bp,dx-1  ,dy-1,dx,cs,0,LE); // ~ melted kl
    822. 

  822.       x = loop(bp,dx-1-x,dy-1,dx,cs,1,LE); if( x>dx/2 ) Break;
    823. 

  823. 

  824.       if( loop(bp,   0,7*dy/16,dx,cs,0,RI)
    825. 

  825.         + loop(bp,dx-1,7*dy/16,dx,cs,0,LE) > dx/2 ) Break; // ~K
    826. 

  826. 

  827.       if( dy>8 /* following lines should be extend to range check */ 
    828. 

  828.        && loop(bp,  dx/4,dy-1,      dy,cs,0,UP)<dy/4
    829. 

  829.        && loop(bp,3*dx/8,dy-1,      dy,cs,0,UP)<dy/4 )
    830. 

  830.       if( loop(bp,   0,dy-1-dy/ 8,dx,cs,0,RI)
    831. 

  831.         < loop(bp,   0,dy-1-dy/16,dx,cs,0,RI)-dx/32 ) Break; // ~it_u
    832. 

  832.       if( num_cross(0,dx-1,  dy/2,  dy/2,bp,cs)==2
    833. 

  833.        && num_cross(0,dx-1,  dy/4,  dy/4,bp,cs)> 2 
    834. 

  834.        && num_cross(0,dx-1,3*dy/4,3*dy/4,bp,cs)> 2 ) Break; // ~it_u
    835. 

  835.       if( num_cross(0   ,dx-1,3*dy/4,3*dy/4,bp,cs)==2
    836. 

  836.        && num_cross(dx/2,dx/2,3*dy/4,  dy-1,bp,cs)> 0 ) Break; // ~it_v
    837. 

  837. 

  838.       if( loop(bp,3*dx/4,   0,dy,cs,0,DO)
    839. 

  839.         > loop(bp,2*dx/4,   0,dy,cs,0,DO)
    840. 

  840.        && loop(bp,3*dx/4,dy-1,dy,cs,0,UP)
    841. 

  841.         < loop(bp,2*dx/4,dy-1,dy,cs,0,UP) ) Break; // ~N 
    842. 

  842.       if( loop(bp,3*dx/4,     dy/8,dy,cs,0,DO)
    843. 

  843.         > loop(bp,2*dx/4,     dy/8,dy,cs,0,DO)
    844. 

  844.        && loop(bp,3*dx/4,dy-1-dy/8,dy,cs,0,UP)
    845. 

  845.         < loop(bp,2*dx/4,dy-1-dy/8,dy,cs,0,UP) ) Break; // ~serif_N 
    846. 

  846. 

  847.       // i0 is lower end of upper serifen (widest gap? )
    848. 

  848.       i0=0;
    849. 

  849.        
    850. 

  850.       if( num_cross(0,dx-1,dy/2,dy/2,bp,cs)!=4 ){ // Is it a N ?
    851. 

  851.         if( num_cross(0,dx-1,dy/2,dy/2,bp,cs)==3 ){
    852. 

  852.           for(y=dy/2+1;y<dy;y++){
    853. 

  853.             if( num_cross(0,dx-1,y,y,bp,cs)<3 ) break;
    854. 

  854.           }
    855. 

  855.           if( num_cross(0,dx-1,y,y,bp,cs)==2 ){
    856. 

  856.             x =loop(bp,dx-1  ,y-1,dx,cs,0,LE);
    857. 

  857.             x+=loop(bp,dx-1-x,y-1,dx,cs,1,LE);
    858. 

  858.             x+=loop(bp,dx-1-x,y-1,dx,cs,0,LE);
    859. 

  859.             if( loop(bp,dx-x,y-1,dy,cs,0,UP)>y-2 ) Break; // ~N
    860. 

  860.           }
    861. 

  861.         }
    862. 

  862.       }
    863. 

  863.       // MNWK
    864. 

  864.       for(i2=0,i1=x=dx/2;x<dx-dx/4;x++){ // lowest pixel
    865. 

  865.         y=loop(bp,x,0,dy,cs,0,DO); if(y>i2) {i2=y;i1=x;} else break; }
    866. 

  866.       i3=i2+loop(bp,i1,i2,dy-i2,cs,1,DO);
    867. 

  867.       if(i2<dy/4) {
    868. 

  868.         if (!sdata->hchar) Break;	// rm
    869. 

  869.         ad=99*ad/100;
    870. 

  870.       }
    871. 

  871.       if (i2==0 && dx>8 && dy>12) Break; // glued and bad splitted serifen-MN
    872. 

  872. 

  873.       // if( num_hole(x0, x1, y0 , y1 ,box1->p,cs,NULL) != 0 ) Break;  // small A
    874. 

  874.       if (sdata->holes.num != 0) Break;
    875. 

  875.       t1=loop(bp,0 ,3*dy/4,dx,cs,0,RI);
    876. 

  876.       t1=loop(bp,t1,3*dy/4,dx,cs,1,RI); // thickness of line?
    877. 

  877.       if( 7*(t1+1)<dx )
    878. 

  878.       if( num_cross(i1,dx-1,i2-1,i2-1,bp,cs)!=2
    879. 

  879.        || num_cross(0 ,i1  ,i2-1,i2-1,bp,cs)!=2 ) Break;  // too hard ???
    880. 

  880. 

  881.       // ~u_n-pair
    882. 

  882.       if( num_cross(0,dx-1,0,0,bp,cs)!=2
    883. 

  883.        && num_cross(0,dx-1,1,1,bp,cs)!=2
    884. 

  884.        && num_cross(0,dx-1,2,2,bp,cs)!=2 ) Break;
    885. 

  885. 

  886.       // ~nn v0.2.4a3 
    887. 

  887.       if( num_cross(0,dx-1,  dy/4,  dy/4,bp,cs)==4
    888. 

  888.        && num_cross(0,dx-1,3*dy/4,3*dy/4,bp,cs)==4 ){
    889. 

  889.         i1 =loop(bp, 0,  dy/4,dx,cs,0,RI);
    890. 

  890.         i1+=loop(bp,i1,  dy/4,dx,cs,1,RI);
    891. 

  891.         i1+=loop(bp,i1,  dy/4,dx,cs,0,RI);
    892. 

  892.         i2 =loop(bp, 0,3*dy/4,dx,cs,0,RI);
    893. 

  893.         i2+=loop(bp,i2,3*dy/4,dx,cs,1,RI);
    894. 

  894.         i2+=loop(bp,i2,3*dy/4,dx,cs,0,RI);
    895. 

  895.         if( i1>=i2 ) Break; // no good M
    896. 

  896.         i1+=loop(bp,i1,  dy/4,dx,cs,1,RI);
    897. 

  897.         i2+=loop(bp,i2,3*dy/4,dx,cs,1,RI);
    898. 

  898.         if( i1>=i2 ) Break; // no good M
    899. 

  899.         i1+=loop(bp,i1,  dy/4,dx,cs,0,RI);
    900. 

  900.         i2+=loop(bp,i2,3*dy/4,dx,cs,0,RI);
    901. 

  901.         if( i1<=i2 ) Break; // no good M
    902. 

  902.       }
    903. 

  903.       if( num_cross(0,dx-1,dy/2,dy/2,bp,cs)==2
    904. 

  904.        && num_cross(0,dx-1,dy/4,dy/4,bp,cs)==2 && !hchar ) Break; // ~ \it u
    905. 

  905. 

  906.       if (dy<17)
    907. 

  907.       if( num_cross(0,dx-1,     0,     0,bp,cs)<2 ) ad=99*ad/100;
    908. 

  908.       if (dx>5)  /* 4x6 font has only 1 cross at y=1 */
    909. 

  909.        if( num_cross(0,dx-1,     1,     1,bp,cs)<2 ) ad=96*ad/100; // kt
    910. 

  910.       if( num_cross(dx/2,dx/2,  0,  dy-1,bp,cs)!=1) ad=98*ad/100; // kt
    911. 

  911.       if (dx<5 && loop(bp,dx/2,0,dy,cs,0,DO)>=3*dy/8) ad=96*ad/100; // 4x6 H
    912. 

  912.       
    913. 

  913.       if( num_cross(0,dx-1,  dy/4,  dy/4,bp,cs)<=2
    914. 

  914.        && num_cross(0,dx-1,3*dy/4,3*dy/4,bp,cs)<=2 
    915. 

  915.        && dx>8 && dy>12 ){
    916. 

  916.         ad=98*ad/100;
    917. 

  917.         for(y=5*dy/16;y<5*dy/8;y++) // look for H-line
    918. 

  918.         if( num_cross(0,dx-1,y  ,y  ,bp,cs)==1 ) break;
    919. 

  919.         if( y<5*dy/8 ) ad=95*ad/100;
    920. 

  920.         if( y<5*dy/8 )
    921. 

  921.         if( num_cross(2+dx/6,dx-3-dx/6,y-2,y-2,bp,cs)==0
    922. 

  922.          || num_cross(2+dx/6,dx-3-dx/6,y-1,y-1,bp,cs)==0 ) Break; // ~H bad!
    923. 

  923.       }
    924. 

  924. 

  925.       if(  loop(bp,3*dx/8,   0,dy,cs,0,DO) >dy/2
    926. 

  926.         && loop(bp,5*dx/8,dy-1,dy,cs,0,UP) >dy/2 ) ad=95*ad/100;
    927. 

  927. 

  928.       if(!hchar){
    929. 

  929.         ad=98*ad/100; /* not sure */
    930. 

  930.         if(  loop(bp,0,     dy/4,dx,cs,0,RI)
    931. 

  931.            < loop(bp,0,dy-1-dy/8,dx,cs,0,RI)-dx/16 ) Break; // ~wi glued
    932. 

  932.       }
    933. 

  933.       if( gchar ) ad=98*ad/100;
    934. 

  934.       if (ad>99 && dx<8) ad=99*ad/100; /* give 5x8 N a chance */
    935. 

  935.       Setac(box1,'M',ad);
    936. 

  936.       break;
    937. 

  937.    }
    938. 

  938.    return box1->c;
    939. 

  939. }
    940. 

  940. 

  941. static wchar_t ocr0_N(ocr0_shared_t *sdata){
    942. 

  942.    struct box *box1=sdata->box1;
    943. 

  943.    int	d,x,y,i1,i2,i3,hchar=sdata->hchar,gchar=sdata->gchar,
    944. 

  944.         x0=box1->x0,x1=box1->x1,y0=box1->y0,y1=box1->y1;
    945. 

  945.    int  dx=x1-x0+1,dy=y1-y0+1,	/* size */
    946. 

  946.         (*aa)[4]=sdata->aa,    /* corner-points, (x,y,dist^2,vector_idx) */
    947. 

  947.         dbg[9],
    948. 

  948.         ad;	/* tmp-vars */
    949. 

  949. 

  950.    // --- test N ------- +hchar -gchar
    951. 

  951.    for(ad=d=100;dx>3 && dy>3;){  // 4x6font
    952. 

  952.       int j;
    953. 

  953.       DBG( wchar_t c_ask='N'; )
    954. 

  954.       if (sdata->holes.num > 1) Break; /* tolerant against a tiny hole */
    955. 

  955.       if (sdata->holes.num > 0) ad=98*ad/100; /* # */
    956. 

  956.       if (dx<6) ad=99*ad/100;
    957. 

  957.       if (dx<5) ad=99*ad/100;
    958. 

  958.       /* half distance to the center */
    959. 

  959.       d=2*sq(128/4);
    960. 

  960.       /* now we check for the 4 ends of the x */
    961. 

  961.       if (aa[0][2]>d) Break;
    962. 

  962.       if (aa[1][2]>d) Break;
    963. 

  963.       if (aa[2][2]>d) Break;
    964. 

  964.       if (aa[3][2]>d) Break;
    965. 

  965.       if (aa[3][0]-aa[0][0]<dx/2) Break;
    966. 

  966.       if (aa[2][0]-aa[1][0]<dx/2) Break;
    967. 

  967.       if (aa[1][1]-aa[0][1]<dy/2) Break;
    968. 

  968.       if (aa[2][1]-aa[3][1]<dy/2) Break;
    969. 

  969.       if (aa[3][0]-aa[0][0]<4-1) Break; /* to small to hold an N */
    970. 

  970.       if (aa[2][0]-aa[1][0]<4-1) Break; /* to small */
    971. 

  971.       if (abs(aa[3][1]-aa[0][1])>(dy+2)/5) Break; /* glued tu */
    972. 

  972.       if (abs(aa[3][1]-aa[0][1])>(dy+4)/8) ad=98*ad/100; /* glued tu */
    973. 

  973.       /* left and right vertical line */
    974. 

  974.       d=line_deviation(box1, aa[0][3], aa[1][3]); if (d>2*sq(1024/4)) Break;
    975. 

  975.       ad=(100-(d-sq(1024)/2)/sq(1024)/4)*ad/100;
    976. 

  976.       d=line_deviation(box1, aa[2][3], aa[3][3]); if (d>2*sq(1024/4)) Break;
    977. 

  977. 

  978.       /* i1: uppermost left ^ from bottom (near 0,0) */
    979. 

  979.       i1=nearest_frame_vector(box1,aa[1][3],aa[2][3], x0+dx/8, y0);
    980. 

  980.       x=box1->frame_vector[i1][0];
    981. 

  981.       y=box1->frame_vector[i1][1];
    982. 

  982.       MSG( fprintf(stderr,"i1= %d (%d,%d) left ^ from below", i1,x-x0,y-y0);)
    983. 

  983.       if (y-y0 > 5*dy/8) Break;
    984. 

  984.       if (x-x0 > 5*dx/8) Break;
    985. 

  985.       /* i3: uppermost right ^  ~H */
    986. 

  986.       i3=nearest_frame_vector(box1,aa[1][3],aa[2][3], x1, y0);
    987. 

  987.       MSG( fprintf(stderr,"i3= %d (%d,%d) right ^ (ad=%d)",\
    988. 

  988.         i3, box1->frame_vector[i3][0]-x0,box1->frame_vector[i3][1]-y0,ad);)
    989. 

  989. 

  990.       /* check lower border of diagonal line, may fail on fonts where
    991. 

  991.        *  line ends on middle of right vertical line (screen font) */
    992. 

  992.       dbg[0]=d=line_deviation(box1,i1, aa[2][3]);
    993. 

  993.       /* check right border of left vertical line */
    994. 

  994.       /* but split to possible lower left serif + vert. line */
    995. 

  995.       j=nearest_frame_vector(box1,aa[1][3],i1, x0+dx/2, y1+dy/2);
    996. 

  996.       dbg[1]=d=line_deviation(box1, aa[1][3],j );
    997. 

  997.               +line_deviation(box1,        j,i1);
    998. 

  998.       MSG(fprintf(stderr," i1-a2 %d a1_serif-i1 %d ad=%d",dbg[0],dbg[1],ad);)
    999. 

  999.       if (dbg[0] > sq(1024/4)) Break;
    1000. 

  1000.       if (dx>4 && dbg[1] > sq(1024/4)) ad=97*ad/100;  // d=0..2*sq(1024)
    1001. 

  1001.       if (dx>4 && dbg[1] > sq(1024/3)) Break;  // d=0..2*sq(1024)
    1002. 

  1002.       // serif N has d=sq(1024/3)=116508
    1003. 

  1003.       MSG( fprintf(stderr,"ad %d", ad); )
    1004. 

  1004. 

  1005.       /* i2: lowest right v from top, same frame? N-tilde etc.? */
    1006. 

  1006.       i2=nearest_frame_vector(box1,aa[3][3],aa[0][3], x1, y1-dy/8);
    1007. 

  1007.       x=box1->frame_vector[i2][0];
    1008. 

  1008.       y=box1->frame_vector[i2][1];
    1009. 

  1009.       MSG( fprintf(stderr,"i2= %d (%d,%d) lowest right v from top",\
    1010. 

  1010.         i2, box1->frame_vector[i2][0]-x0,box1->frame_vector[i2][1]-y0);)
    1011. 

  1011.       if (y-y0 < 3*dy/8) Break;
    1012. 

  1012.       if (x-x0 < 3*dx/8) Break;
    1013. 

  1013.       // test H
    1014. 

  1014.       if ( box1->frame_vector[i3][0]-box1->frame_vector[i1][0]> dx/4
    1015. 

  1015.         && box1->frame_vector[i3][1]-box1->frame_vector[i1][1]<=dy/8
    1016. 

  1016.         &&                        y<=box1->frame_vector[i1][1]) Break;
    1017. 

  1017.       /* check if upper left and lower right point are joined directly */
    1018. 

  1018.       /* but split to possible upper right serif + down line */
    1019. 

  1019.       j=nearest_frame_vector(box1,i2,aa[0][3], x0+dx/2, y0-dy/2);
    1020. 

  1020.       dbg[2]=d=line_deviation(box1,i2, j) 
    1021. 

  1021.               +line_deviation(box1, j, aa[0][3]); 
    1022. 

  1022.       /* check if upper right and lower right point are joined directly */
    1023. 

  1023.       /* but split to possible upper right serif + vert. line */
    1024. 

  1024.       j=nearest_frame_vector(box1,aa[3][3],i2, x0+dx/2, y0-dy/2);
    1025. 

  1025.       dbg[3]=d=line_deviation(box1, aa[3][3],j)
    1026. 

  1026.               +line_deviation(box1,       j,i2);  // ToDo: split once more?
    1027. 

  1027.       MSG( fprintf(stderr," i2-a0 %d a3-i2 %d ad %d",dbg[2],dbg[3], ad); )
    1028. 

  1028.       if (dbg[2] > sq(1024/4)) Break;
    1029. 

  1029.       // serif N, ToDo: do it better
    1030. 

  1030.       if (dbg[3] > sq(1024/4)) ad=97*ad/100;
    1031. 

  1031.       if (dbg[3] > sq(1024/3)) Break;
    1032. 

  1032.       MSG( fprintf(stderr,"ad %d", ad); )
    1033. 

  1033. 

  1034.       MSG( fprintf(stderr,"check against melted tu"); )
    1035. 

  1035.       // i1 = left ^ from below, i2 = lowest right v from top
    1036. 

  1036.       //  sample gocr_Device*: 3-8,dy=27
    1037. 

  1037.       if ( (box1->frame_vector[i1][1]-y0)
    1038. 

  1038.           -(y1-box1->frame_vector[i2][1])>dy/8) ad=99*ad/100; /* ~ tu */
    1039. 

  1039.       MSG( fprintf(stderr,"tu ad %d", ad); )
    1040. 

  1040.       if (box1->frame_vector[i2][0]
    1041. 

  1041.          -box1->frame_vector[i1][0]<=dx/8) Break; /* nonsignificant distance */
    1042. 

  1042.       MSG( fprintf(stderr,"i2-i1<=dx/8 ad %d", ad); )
    1043. 

  1043.       /* i1: uppermost left ^ from bottom (near 0,0) */
    1044. 

  1044.       /* i2: lowest right v from top, same frame? N-tilde etc.? */
    1045. 

  1045.       if (box1->frame_vector[i2][1]
    1046. 

  1046.          -box1->frame_vector[i1][1]<=dy/8) {
    1047. 

  1047.        // may happen on screen fonts 7x10
    1048. 

  1048.        if (dx>8) ad=97*ad/100; /* too flat (ff,H)  */
    1049. 

  1049.       }
    1050. 

  1050.       MSG( fprintf(stderr,"i2-i1<=dy/8 ad %d", ad); )
    1051. 

  1051.       if (box1->frame_vector[i2][1]
    1052. 

  1052.          -box1->frame_vector[i1][1]<=dy/2) ad=99*ad/100;
    1053. 

  1053.       MSG( \
    1054. 

  1054.        fprintf(stderr,"^v %d %d  %d %d line dev %d %d %d %d max %d %d ad %d",\
    1055. 

  1055.         box1->frame_vector[i1][0]-x0,box1->frame_vector[i1][1]-y0,\
    1056. 

  1056.         box1->frame_vector[i2][0]-x0,box1->frame_vector[i2][1]-y0,\
    1057. 

  1057.         dbg[0],dbg[1],dbg[2],dbg[3],sq(1024/4),sq(1024),ad);)
    1058. 

  1058.       ad=(100-(dbg[0]-sq(1024)/2)/sq(1024)/4)*ad/100;
    1059. 

  1059.       MSG( fprintf(stderr,"ad %d", ad); )
    1060. 

  1060.       ad=(100-(dbg[1]-sq(1024)/2)/sq(1024)/4)*ad/100;
    1061. 

  1061.       MSG( fprintf(stderr,"ad %d", ad); )
    1062. 

  1062.       ad=(100-(dbg[2]-sq(1024)/2)/sq(1024)/4)*ad/100;
    1063. 

  1063.       MSG( fprintf(stderr,"ad %d", ad); )
    1064. 

  1064.       ad=(100-(dbg[3]-sq(1024)/2)/sq(1024)/4)*ad/100;
    1065. 

  1065.       MSG( fprintf(stderr,"ad %d", ad); )
    1066. 

  1066. 

  1067.       if (!hchar) ad=99*ad/100;
    1068. 

  1068.       if ( gchar) ad=98*ad/100; // \sc N
    1069. 

  1069.       Setac(box1,'N',ad);
    1070. 

  1070.       break;
    1071. 

  1071.    }
    1072. 

  1072.    return box1->c;
    1073. 

  1073. }
    1074. 

  1074. 

  1075. static wchar_t ocr0_h(ocr0_shared_t *sdata){
    1076. 

  1076.    struct box *box1=sdata->box1;
    1077. 

  1077.    pix *bp=sdata->bp;
    1078. 

  1078.    int	i,d,x,y,hchar=sdata->hchar,gchar=sdata->gchar,
    1079. 

  1079.         x0=box1->x0,x1=box1->x1,y0=box1->y0,y1=box1->y1,cs=sdata->cs;
    1080. 

  1080.    int  dx=x1-x0+1,dy=y1-y0+1,	/* size */
    1081. 

  1081.         ad;	/* tmp-vars */
    1082. 

  1082.    int (*aa)[4]=sdata->aa;    /* corner-points, (x,y,dist^2,vector_idx) */
    1083. 

  1083.    
    1084. 

  1084.    // --- test h ---------------------------------------------------
    1085. 

  1085.    for(ad=d=100;dx>2 && dy>3;){     // min 3x4
    1086. 

  1086.      // rewritten for vectors 0.42
    1087. 

  1087.      int i1, i2, i3, i4, i5, i6, i7, i8;  // line derivation + corners
    1088. 

  1088.      DBG( wchar_t c_ask='h'; )
    1089. 

  1089.      if (sdata->holes.num > 1) Break; /* tolerant against a tiny hole */
    1090. 

  1090.      /* half distance to the center */
    1091. 

  1091.      d=2*sq(128/4);
    1092. 

  1092.      /* now we check for the upper right end of the h */
    1093. 

  1093.      if (aa[3][2]<d/4) Break;  /* [2] = distance, ~BCDEF... */
    1094. 

  1094.      if (aa[0][2]>d/2) Break;  /* upper left end */
    1095. 

  1095.      if (aa[1][2]>d/2) Break;  /* lower left end */
    1096. 

  1096.      if (aa[2][2]>d/2) Break;  /* lowerright end */
    1097. 

  1097. /*
    1098. 

  1098.   type     A         B=italic ???
    1099. 

  1099.        18             OOO
    1100. 

  1100.         O            O  O
    1101. 

  1101.         O              O
    1102. 

  1102.         O7OOO          OOOO
    1103. 

  1103.         O4   O        O    O
    1104. 

  1104.         O    O       O    O
    1105. 

  1105.         O    O      O    O  O
    1106. 

  1106.        2O3  5O6    O     OOO
    1107. 

  1107. */
    1108. 

  1108.      i1=i8=aa[0][3];
    1109. 

  1109.      i2=i3=aa[1][3];
    1110. 

  1110.      i5=i6=aa[2][3];
    1111. 

  1111.      // check the bow from below (fails on melted serifs)
    1112. 

  1112.      for (i4=i=i2;i!=i5;i=(i+1)%box1->num_frame_vectors[0]) {
    1113. 

  1113.        if (box1->frame_vector[ i][1]
    1114. 

  1114.           <box1->frame_vector[i4][1]) i4=i; // get next maximum
    1115. 

  1115.        if (box1->frame_vector[ i][1]<=y0) break; // fatal!
    1116. 

  1116.      }
    1117. 

  1117.      if (box1->frame_vector[i4][1]-y0<dy/4) Break; // ~MN
    1118. 

  1118.      if (y1-box1->frame_vector[i4][1]<dy/4) Break; // ~BCDEGIJLOQSUYZ
    1119. 

  1119.      // two steps for i7 to go around pitfalls on italic h
    1120. 

  1120.      i7=nearest_frame_vector(box1, i6, i8, (x0+x1)/2, (y0+y1)/2);
    1121. 

  1121.      i7=nearest_frame_vector(box1, i6, i7,        x0, (y0+y1)/2);
    1122. 

  1122.      i3=nearest_frame_vector(box1, i2, i4, (x0+x1)/2,        y1);
    1123. 

  1123.      i5=nearest_frame_vector(box1, i4, i6, (x0+x1)/2,        y1);
    1124. 

  1124. 

  1125.      MSG(fprintf(stderr,"i1-7 %d %d %d %d %d %d %d",i1,i2,i3,i4,i5,i6,i7);)
    1126. 

  1126.       /* ... new part /// old obsolete part ... */
    1127. 

  1127.       if( get_bw(0        ,dx/2,dy/8     ,dy/8     ,bp,cs,1) != 1 ) Break;
    1128. 

  1128.       if( get_bw(0        ,dx/2,dy/2     ,dy/2     ,bp,cs,1) != 1 ) Break;
    1129. 

  1129.       if( get_bw(dx/2     ,dx-1,dy-1-dy/3,dy-1-dy/3,bp,cs,1) != 1 ) Break;
    1130. 

  1130.       if( get_bw(dx/2     ,dx/2,dy/5     ,dy-1-dy/3,bp,cs,1) != 1 ) Break;
    1131. 

  1131.       if( get_bw(dx-1-dx/3,dx-1,0        ,1        ,bp,cs,1) == 1 ) Break;
    1132. 

  1132.       if( get_bw(dx-1-dx/3,dx-1,1        ,dy/6     ,bp,cs,1) == 1 ) Break;
    1133. 

  1133.       if( dy>18 )
    1134. 

  1134.       if( get_bw(dx-1-dx/3,dx-1,dy/6     ,dy/5     ,bp,cs,1) == 1 ) Break;
    1135. 

  1135.       if( get_bw(dx-1-dx/3,dx-1,dy-1-dy/4,dy-1     ,bp,cs,1) == 0 ) Break; // s-
    1136. 

  1136.       for( x=x0+dx/3;x<x1-dx/3;x++)
    1137. 

  1137.         if( get_bw(x, x,y1-dy/4, y1,     box1->p,cs,1) == 0 ) break;
    1138. 

  1138.       if( x>=x1-dx/3 ) Break;
    1139. 

  1139.       for(i=dy/4,y=y0+dy/3;y<=y1 && i;y++){
    1140. 

  1140.       …
    1141.

Large files files are truncated, but you can click here to view the full file