lib/devices/ocr.c

   1 /* ocr.c
   2
   3    Part of the swftools package.
   4
   5    Copyright (c) 2007 Matthias Kramm <kramm@quiss.org>
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 2 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program; if not, write to the Free Software
  19    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
  20
  21 #include <stdlib.h>
  22 #include <stdio.h>
  23 #include <stdarg.h>
  24 #include <unistd.h>
  25 #include <memory.h>
  26 #include "../types.h"
  27 #include "../mem.h"
  28 #include "../gfxdevice.h"
  29 #include "../gfxtools.h"
  30 #include "render.h"
  31
  32 #include "../gocr/pnm.h"
  33 #include "../gocr/pgm2asc.h"
  34
  35 typedef struct _textpage {
  36     char*text;
  37     int textpos;
  38     struct _textpage*next;
  39 } textpage_t;
  40
  41 typedef struct _internal {
  42     gfxdevice_t*render;
  43     int pages;
  44
  45     textpage_t*first_page;
  46     textpage_t*current_page;
  47 } internal_t;
  48
  49 int ocr_setparameter(gfxdevice_t*dev, const char*key, const char*value)
  50 {
  51     internal_t*i = (internal_t*)dev->internal;
  52     return i->render->setparameter(i->render,key,value);
  53 }
  54
  55 void ocr_startpage(gfxdevice_t*dev, int width, int height)
  56 {
  57     internal_t*i = (internal_t*)dev->internal;
  58     if(i->render) {
  59         fprintf(stderr, "Call endpage() before calling startpage()\n");
  60         return;
  61     }
  62     i->render = malloc(sizeof(gfxdevice_t));
  63     gfxdevice_render_init(i->render);
  64     i->render->startpage(i->render,width,height);
  65     i->pages++;
  66 }
  67 /* passthrough */
  68 void ocr_startclip(gfxdevice_t*dev, gfxline_t*line) { ((internal_t*)dev->internal)->render->startclip(((internal_t*)dev->internal)->render,line); }
  69 void ocr_endclip(gfxdevice_t*dev) { ((internal_t*)dev->internal)->render->endclip(((internal_t*)dev->internal)->render); }
  70 void ocr_stroke(gfxdevice_t*dev, gfxline_t*line, gfxcoord_t width, gfxcolor_t*color, gfx_capType cap_style, gfx_joinType joint_style, gfxcoord_t miterLimit) { ((internal_t*)dev->internal)->render->stroke(((internal_t*)dev->internal)->render, line, width, color, cap_style, joint_style, miterLimit); }
  71 void ocr_fill(gfxdevice_t*dev, gfxline_t*line, gfxcolor_t*color) { ((internal_t*)dev->internal)->render->fill(((internal_t*)dev->internal)->render, line, color); }
  72 void ocr_fillbitmap(gfxdevice_t*dev, gfxline_t*line, gfximage_t*img, gfxmatrix_t*matrix, gfxcxform_t*cxform) { ((internal_t*)dev->internal)->render->fillbitmap(((internal_t*)dev->internal)->render, line, img, matrix, cxform); }
  73 void ocr_fillgradient(gfxdevice_t*dev, gfxline_t*line, gfxgradient_t*gradient, gfxgradienttype_t type, gfxmatrix_t*matrix) { ((internal_t*)dev->internal)->render->fillgradient(((internal_t*)dev->internal)->render, line, gradient, type, matrix); }
  74 void ocr_addfont(gfxdevice_t*dev, gfxfont_t*font) { ((internal_t*)dev->internal)->render->addfont(((internal_t*)dev->internal)->render, font); }
  75 void ocr_drawchar(gfxdevice_t*dev, gfxfont_t*font, int glyphnr, gfxcolor_t*color, gfxmatrix_t*matrix) { ((internal_t*)dev->internal)->render->drawchar(((internal_t*)dev->internal)->render, font, glyphnr, color, matrix); }
  76 void ocr_drawlink(gfxdevice_t*dev, gfxline_t*line, const char*action) { ((internal_t*)dev->internal)->render->drawlink(((internal_t*)dev->internal)->render, line, action); }
  77
  78 void ocr_result_write(gfxresult_t*r, int filedesc)
  79 {
  80     textpage_t*i= (textpage_t*)r->internal;
  81 }
  82 int ocr_result_save(gfxresult_t*r, const char*filename)
  83 {
  84     textpage_t*i= (textpage_t*)r->internal;
  85     if(!i) {
  86         return 0; // no pages drawn
  87     }
  88     FILE*fi = fopen(filename, "wb");
  89     if(!fi)
  90         return 0;
  91     while(i) {
  92         fwrite(i->text, i->textpos, 1, fi);
  93         i = i->next;
  94     }
  95     fclose(fi);
  96     return 1;
  97 }
  98
  99 void*ocr_result_get(gfxresult_t*r, const char*name)
 100 {
 101     textpage_t*i= (textpage_t*)r->internal;
 102     if(!strcmp(name,"text")) {
 103         textpage_t*j = i;
 104         int len = 0;
 105         while(j) {
 106             len += i->textpos;
 107             j = j->next;
 108         }
 109         char*text = (char*)malloc(len);
 110         int pos = 0;
 111         j = i;
 112         while(j) {
 113             memcpy(&text[pos], i->text, i->textpos);
 114             pos += i->textpos;
 115             j = j->next;
 116         }
 117         text[pos] = 0;
 118         return text;
 119     } else if(!strncmp(name,"page",4)) {
 120         int pagenr = atoi(&name[4]);
 121         if(pagenr<0)
 122             pagenr=0;
 123         while(pagenr>0) {
 124             i = i->next;
 125             if(!i)
 126                 return 0;
 127             pagenr++;
 128         }
 129         i->text[i->textpos] = 0;
 130         return strdup(i->text);
 131     }
 132     return 0;
 133 }
 134 void ocr_result_destroy(gfxresult_t*r)
 135 {
 136     textpage_t*i= (textpage_t*)r->internal;
 137     int t;
 138     r->internal = 0;
 139     while(i) {
 140         textpage_t*next = i->next;
 141         free(i->text);i->text = 0;
 142         free(i);
 143         i = next;
 144     }
 145     free(r);
 146 }
 147
 148 job_t*JOB;
 149
 150 void ocr_endpage(gfxdevice_t*dev)
 151 {
 152     internal_t*i = (internal_t*)dev->internal;
 153     i->render->endpage(i->render);
 154
 155     gfxdevice_t*out = i->render;
 156     gfxresult_t* r = out->finish(out);
 157     free(i->render);i->render = 0;
 158
 159     gfximage_t*img = (gfximage_t*)r->get(r, "page");
 160
 161     job_t job;
 162     JOB = &job;
 163
 164     job_init(&job);
 165     job.cfg.out_format=UTF8;
 166
 167     job.src.fname = "<none>";
 168     job.src.p.p = malloc(img->width*img->height);
 169     job.src.p.bpp = 1;
 170     job.src.p.x = img->width;
 171     job.src.p.y = img->height;
 172     int size=img->width*img->height;
 173     int t;
 174     for(t=0;t<size;t++) {
 175         job.src.p.p[t] = (img->data[t].r+img->data[t].g+img->data[t].b)/3;
 176     }
 177
 178     pgm2asc(&job);
 179
 180     int linecounter;
 181     const char *line = 0;
 182     int len = 0;
 183     linecounter = 0;
 184     line = getTextLine(linecounter++);
 185     while (line) {
 186       len += strlen(line)+1;
 187       line = getTextLine(linecounter++);
 188     }
 189
 190     textpage_t*page = malloc(sizeof(textpage_t));
 191     page->next = 0;
 192     page->text = malloc(len+1);
 193     page->textpos = 0;
 194     if(!i->first_page) {
 195         i->first_page = i->current_page = page;
 196     } else {
 197         i->current_page->next = page;
 198         i->current_page = page;
 199     }
 200
 201     linecounter = 0;
 202     line = getTextLine(linecounter++);
 203     while (line) {
 204       int l = strlen(line);
 205       memcpy(&page->text[page->textpos], line, l);
 206       page->textpos += l;
 207       page->text[page->textpos++] = '\n';
 208
 209       line = getTextLine(linecounter++);
 210     }
 211     page->text[page->textpos++] = 0;
 212
 213     free_textlines();
 214
 215     job_free(&job);JOB=0;
 216
 217     r->destroy(r);
 218 }
 219
 220 gfxresult_t* ocr_finish(gfxdevice_t*dev)
 221 {
 222     internal_t*i = (internal_t*)dev->internal;
 223
 224     gfxresult_t*r = (gfxresult_t*)rfx_calloc(sizeof(gfxresult_t));
 225
 226     r->internal = i->first_page;
 227     r->write = ocr_result_write;
 228     r->save = ocr_result_save;
 229     r->get = ocr_result_get;
 230     r->destroy = ocr_result_destroy;
 231
 232     free(dev->internal); dev->internal = 0; i = 0;
 233
 234     return r;
 235 }
 236
 237 void gfxdevice_ocr_init(gfxdevice_t*dev, gfxdevice_t*out)
 238 {
 239     internal_t*i = (internal_t*)rfx_calloc(sizeof(internal_t));
 240     memset(dev, 0, sizeof(gfxdevice_t));
 241
 242     dev->name = "ocr";
 243
 244     dev->internal = i;
 245
 246     dev->setparameter = ocr_setparameter;
 247     dev->startpage = ocr_startpage;
 248     dev->startclip = ocr_startclip;
 249     dev->endclip = ocr_endclip;
 250     dev->stroke = ocr_stroke;
 251     dev->fill = ocr_fill;
 252     dev->fillbitmap = ocr_fillbitmap;
 253     dev->fillgradient = ocr_fillgradient;
 254     dev->addfont = ocr_addfont;
 255     dev->drawchar = ocr_drawchar;
 256     dev->drawlink = ocr_drawlink;
 257     dev->endpage = ocr_endpage;
 258     dev->finish = ocr_finish;
 259
 260     i->pages = 0;
 261 }
 262