---

modules.c

/*
GOCR Copyright (C) 2000  Joerg Schulenburg Joerg.Schulenburg@physik.uni-magdeburg.de 
GOCR API Copyright (C) 2001 Bruno Barberi Gnecco <brunobg@sourceforge.net>

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

*/

/* NOTE: this was the first piece of code I wrote for GOCR API, and it really
seems so. Apart from a review I'm doing, some functions may be completely
rewritten.
One of the things that may happen is using hash tables instead of linked lists,
for liblist. Module functions need to be linked lists, since order matters. */

#include <string.h>
#include <ltdl.h>
#include "_gocr.h"
#include "gocr.h"

List liblist;
List modulefunclist[allModules];

static currentid = 0, currentlibid = 0;

struct _gocr_lib {
  void    *handle;
  int     id;
  int     (*setAttrib) (void *, void *);
};

struct _gocr_modulefunction {
  int id;
  struct _gocr_lib *l;
  char *name;
  void *data;

  union {
    void (*grayImageFilter) ( int x, int y, unsigned char **data, void *v );
    int (*grayToBW) ( gocrImage *img, void *v );
    void (*bwImageFilter) ( gocrImage *img, void *v );
    void (*blockFinder) ( gocrImage *img, void *v );
    int (*charFinder) ( gocrBlock *b, void *v );
    int (*charRecognizer) ( gocrImage *pix, gocrBox *b, void *v );
    void (*contextCorrection) ( gocrImage *pix, gocrBox *b, void *v );
    void (*outputFormatter) ( void *v );
  } func;
};

/*
 * Internal functions
 */

int _gocr_initModule ( void ) {
  gocr_moduleType i;
  struct _gocr_modulefunction *m;
  int r;

  /* init lists */
  list_init(&liblist);
  for ( i = 0; i < allModules; i++ ) {
    list_init(&modulefunclist[i]);
  }

  /* init libltdl */
  r = lt_dlinit();
  if ( r )
    return r;
#if 0
  lt_dladdsearchdir(GOCR_PATH);
#endif
  return 0;
}

void _gocr_endModule ( void ) {
  gocr_moduleType i;
  struct _gocr_modulefunction *m;

  for ( i = 0; i < allModules; i++ ) {
    for_each_data(&modulefunclist[i]) {
      m = (struct _gocr_modulefunction *)list_get_current(&modulefunclist[i]);
      if (m) {
        if (m->name)
          free(m->name);
        free(m);
      }
    } end_for_each(&modulefunclist[i]);
    list_free(&modulefunclist[i]);
  }

  for_each_data(&liblist) {
    struct _gocr_lib *t = (struct _gocr_lib *)list_get_current(&liblist);
    lt_dlclose(t->handle);
  } end_for_each(&liblist);
  list_free(&liblist);

  lt_dlexit();
}

/*
 * External Functions
 */

int gocr_moduleLoad ( char *filename ) {
  struct _gocr_lib *l;
  int (*init_func)(void);

  _gocr_debug(3, fprintf(_data.error, "gocr_loadModule(%s)\n", filename);)
  l = (struct _gocr_lib *)malloc(sizeof(struct _gocr_lib));
  if ( !l ) {
    _gocr_debug(1, fprintf(_data.error, "Not enough memory\n");)
    return -1;
  }

  l->handle = lt_dlopen( filename );
  if ( !l->handle ) {
    _gocr_debug(1, fprintf(_data.error, "Could not open module %s: %s\n", filename, dlerror());)
    return -1;
  }

  /* try to open an init function */
  init_func = lt_dlsym( l->handle, "initModule" );
  if ( init_func ) {
    int r;

    _gocr_debug(3, fprintf(_data.error, "Running init_func\n");)
    r = init_func();
    if ( r != 0 ) {
      lt_dlclose(l->handle);
      free(l);
      _gocr_debug(1, fprintf(_data.error, "%s init function returned %d\n", filename, r );)
      return -1;
    }
  }

  /* try to open the setAttrib function */
  l->setAttrib = lt_dlsym( l->handle, "setAttribute" );
  l->id = currentlibid++;

  list_app(&liblist, l);
  return l->id;
}

void gocr_moduleClose ( int id ) {
  void (*close)(void);
  struct _gocr_lib *l;
  struct _gocr_modulefunction *m;
  gocr_moduleType t;

  _gocr_debug(3, fprintf(_data.error, "gocr_closeModule(%d)\n", id);)
  /* search module */
  for_each_data(&liblist) {
    l = (struct _gocr_lib *)list_get_current(&liblist);
    if ( l->id == id )
      break;
  } end_for_each(&liblist);

  if ( l->id != id ) {/* module not found */
    _gocr_debug(1, fprintf(_data.error, "Module not found\n", id);)
    return;
  }

  close = lt_dlsym( l->handle, "closeModule" );
  if ( close )
    close();

  for ( t = 0; t < allModules; t++ ) {
    for_each_data(&modulefunclist[t]) {
      m = (struct _gocr_modulefunction *)list_get_current(&modulefunclist[t]);
      if ( m->l == l ) {
        if ( m->name )
          free(m->name);
        list_del(&modulefunclist[t], m);
        free(m);
      }
    } end_for_each(&modulefunclist[t]);
  }

  lt_dlclose(l->handle);
  list_del(&liblist, l);
  free(l);
}

int gocr_moduleSetAttribute ( int id, void *a, void *b ) {
  struct _gocr_lib *l;

  _gocr_debug(3, fprintf(_data.error, "gocr_setModuleAttribute(%d, %p, %p)\n", id, a, b);)
  for_each_data(&liblist) {
    l = (struct _gocr_lib *)list_get_current(&liblist);
    if ( l->id == id )
      break;
  } end_for_each(&liblist);

  if ( l->id == id ) { /* module not found */
    _gocr_debug(1, fprintf(_data.error, "Module library not found, setModuleAttrib\n");)
    return -1;
  }

  if ( l->setAttrib == NULL ) { /* no such function */
    _gocr_debug(1, fprintf(_data.error, "Module library doesn't contain setAttrib, setModuleAttrib\n");)
    return -1;
  }

  return l->setAttrib( a, b );
}

int gocr_functionInsertBefore ( gocr_moduleType t, char *functionname, 
    void *data, int id ) {
  struct _gocr_modulefunction *m;
  int i = 0;

  _gocr_debug(3, fprintf(_data.error, "gocr_insertModuleBefore(%d, %s, %p, %d)", 
      (int)t, functionname, data, id);) 
  m = (struct _gocr_modulefunction *)malloc(sizeof(struct _gocr_modulefunction));
  if (!m) {
    _gocr_debug(1, fprintf(_data.error, "Not enough memory\n");)
    return -1;
  }

  /* open module function; search the opened modules. */
  for_each_data(&liblist) {
    switch (t) {
      case grayImageFilter:
        m->func.grayImageFilter = lt_dlsym(list_get_current(&liblist), functionname);
        i++;
        break;
      case grayToBW:
        m->func.grayToBW = lt_dlsym(list_get_current(&liblist), functionname);
        i++;
        break;
      case bwImageFilter:
        m->func.grayImageFilter = lt_dlsym(list_get_current(&liblist), functionname);
        i++;
        break;
      case blockFinder:
        m->func.blockFinder = lt_dlsym(list_get_current(&liblist), functionname);
        i++;
        break;
      case charFinder:
        m->func.charFinder = lt_dlsym(list_get_current(&liblist), functionname);
        i++;
        break;
      case charRecognizer:
        m->func.charRecognizer = lt_dlsym(list_get_current(&liblist), functionname);
        i++;
        break;
      case contextCorrection:
        m->func.contextCorrection = lt_dlsym(list_get_current(&liblist), functionname);
        i++;
        break;
      case outputFormatter:
        m->func.outputFormatter = lt_dlsym(list_get_current(&liblist), functionname);
        i++;
        break;
    }
    m->l = list_get_current(&liblist);
    if ( i )  /* found the module */
      break;
  } end_for_each(&liblist);

  if ( !i ) { /* module not found */
    _gocr_debug(1, fprintf(_data.error, "Module function %s not found\n", functionname);)
    return -1;
  }

  m->id = currentid++;
  m->name = strdup(functionname);
  m->data = data;

  /* there can be only one Highlander. I mean, grayToBW. */
  if ( t == grayToBW ) {
    struct _gocr_modulefunction *n = 
        (struct _gocr_modulefunction *)list_get_header(&modulefunclist[t]);
    gocr_functionDeleteById(n->id);
    id = -1;
  }

  /* and add to the list! */
  if ( id == -1 )
    list_app(&modulefunclist[t], m);
  else {
    struct _gocr_modulefunction *n;

    for_each_data(&modulefunclist[t]) {
      n = (struct _gocr_modulefunction *)list_get_current(&modulefunclist[t]);
      if ( n->id == id ) 
        break;
    } end_for_each(&modulefunclist[t]);
    if ( n == NULL )
      list_app(&modulefunclist[t], m);
    else
      list_ins(&modulefunclist[t], n, m);
  }

  return m->id; 
}

int gocr_functionAppend ( gocr_moduleType t, char *functionname, 
    void *data ) {
  return gocr_functionInsertBefore(t, functionname, data, -1);
}

void *gocr_functionDeleteById ( int id ) {
  gocr_moduleType t;
  struct _gocr_modulefunction *m;
  void *data;

  _gocr_debug(3, fprintf(_data.error, "gocr_functionDeleteById(%d)", id);)
  for ( t = 0; t < allModules; t++ ) {
    for_each_data(&modulefunclist[t]) {
      m = (struct _gocr_modulefunction *)list_get_current(&modulefunclist[t]);
      if ( m->id == id ) {
        list_del(&modulefunclist[t], m);
        if ( m->name )
          free(m->name);
        data = m->data;
        free(m);
        return data;
      }
    } end_for_each(&modulefunclist[t]);
  }

  _gocr_debug(1, fprintf(_data.error, "functionDelete: Module function with id %d not found.\n", id );)
  return NULL;
}

#if 0
int gocr_runModuleFunction ( int id ) {
  struct _gocr_modulefunction *m;
  gocr_moduleType i;
  int done = 0;

  _gocr_debug(3, fprintf(_data.error, "gocr_runModuleFunction(%d)", id);)
  for ( i = 0; i < allModules; i++ ) {
    for_each_data(&modulefunclist[i]) {
      m = (struct _gocr_modulefunction *)list_get_current(&modulefunclist[i]);
      if ( m->id == id ) {
        switch (i) {
          case grayImageFilter:
            m->func.grayImageFilter(currentimage->x, currentimage->y, 
                (unsigned char **)currentimage->data, m->data);
            done++;
            break;
          case grayToBW:
            m->func.grayToBW(currentimage, m->data);
            done++;
            break;
          case bwImageFilter:
            m->func.bwImageFilter(currentimage, m->data);
            done++;
            break;
          case blockFinder:
            m->func.blockFinder(currentimage, m->data);
            done++;
            break;
          case charFinder:
            m->func.charFinder(block, m->data);
            done++;
            break;
          case charRecognizer:
            m->func.charRecognizer(pix, box, m->data);
            done++;
            break;
          case contextCorrection:
            m->func.contextCorrection(pix, box, m->data);
            done++;
            break;
          case outputFormatter:
            m->func.outputFormatter(m->data);
            done++;
            break;
        }
      }
      if ( done ) break;
    } end_for_each(&modulefunclist[i]);
    if ( done ) return 0;
  }

  _gocr_debug(1, fprintf(_data.error, "runModuleFunction: no such id\n");)
  return -1;
}

int gocr_runModuleType ( gocr_moduleType t ) {
  struct _gocr_modulefunction *m;

  _gocr_debug(3, fprintf(_data.error, "gocr_runModuleType(%d)\n", t);)
  for_each_data(&modulefunclist[t]) {
    m = (struct _gocr_modulefunction *)list_get_current(&modulefunclist[t]);
//    m->func(m->data);
  } end_for_each(&modulefunclist[t]);
}
#endif

int gocr_runAllModules ( void ) {
  struct _gocr_modulefunction *m;
  gocrImage *image;

  _gocr_debug(3, fprintf(_data.error, "gocr_runAllModules\n");)

  /* if the image is gray, apply the gray* modules */
  if ( currentimage->type == GRAY ) {
    for_each_data(&modulefunclist[grayImageFilter]) {
      m = (struct _gocr_modulefunction *)list_get_current(&modulefunclist[grayImageFilter]);
      _gocr_debug(3, fprintf(_data.error, "module grayImageFilter:%s\n", m->name);)
      m->func.grayImageFilter(currentimage->x, currentimage->y,
          (unsigned char **)currentimage->data, m->data);
    } end_for_each(&modulefunclist[grayImageFilter]);

    m = (struct _gocr_modulefunction *)list_get_header(&modulefunclist[grayToBW]);
    if ( m == NULL ) {
      _gocr_debug(3, fprintf(_data.error, "module grayToBW: internal\n");)
      if ( otsu(currentimage, NULL) != 0 ) {
        _gocr_debug(1, fprintf(_data.error, "grayToBW returned -1\n");)
        return -1;
      }
    }
    else { /* user supplied one */
      _gocr_debug(3, fprintf(_data.error, "module grayToBW: %s\n", m->name);)
      if ( m->func.grayToBW(currentimage, m->data) != 0 ) {
        _gocr_debug(1, fprintf(_data.error, "grayToBW returned -1\n");)
        return -1;
      }
      /* and clean the gocrPixel structure, except the value field */
      {
        int i, j;
        gocrPixel p;
        unsigned char **data = (unsigned char **)currentimage->data, *c;

        memset(&p, 0, sizeof(gocrPixel));
        p.value = 1;
        c = (unsigned char *)&p;

        for ( i = 0; i < currentimage->x; i++ )
          for ( j = 0; j < currentimage->y; j++ )
            data[i][j] &= *c;
      }
    }
    currentimage->type = BLACK_AND_WHITE;
  }

  /* b&w filters */
  for_each_data(&modulefunclist[bwImageFilter]) {
    m = (struct _gocr_modulefunction *)list_get_current(&modulefunclist[bwImageFilter]);
    _gocr_debug(3, fprintf(_data.error, "module bwImageFilter:%s\n", m->name);)
    m->func.bwImageFilter(currentimage, m->data);
  } end_for_each(&modulefunclist[bwImageFilter]);

  /* find blocks */
  for_each_data(&modulefunclist[blockFinder]) {
    m = (struct _gocr_modulefunction *)list_get_current(&modulefunclist[blockFinder]);
    _gocr_debug(3, fprintf(_data.error, "module blockFinder:%s\n", m->name);)
    m->func.blockFinder(currentimage, m->data);
  } end_for_each(&modulefunclist[blockFinder]);

  /* frame characters in each block */
  for_each_data(&currentimage->blocklist) {
    currentblock  = (gocrBlock *)list_get_current(&currentimage->blocklist);
    for_each_data(&modulefunclist[charFinder]) {
      m = (struct _gocr_modulefunction *)list_get_current(&modulefunclist[charFinder]);
      _gocr_debug(3, fprintf(_data.error, "module charFinder:%s\n", m->name);)
      if ( m->func.charFinder((gocrBlock *)list_get_current(&currentimage->blocklist), 
          m->data) == 0 ) /* function took care */
          break;
    } end_for_each(&modulefunclist[charFinder]);
  } end_for_each(&currentimage->blocklist);

#if 0
  /* recognize each character */
  for_each_data(&currentimage->blocklist) {
    currentblock  = (gocrBlock *)list_get_current(&currentimage->blocklist);
    for_each_data(&currentblock->boxlist) {
      int i;

      currentbox = (gocrBox *)list_get_current(&currentblock->boxlist);

      /* these is a simple but bad solution. The best thing to do is to use
        realloc or something; very little waste, much more speed. */
      _gocr_imageCopy(currentimage, currentbox->x0, currentbox->y0, 
          currentbox->x1, currentbox->y1, image);

      for_each_data(&modulefunclist[charRecognizer]) {
        m = (struct _gocr_modulefunction *)list_get_current(&modulefunclist[charRecognizer]);
        _gocr_debug(3, fprintf(_data.error, "module charRecognizer:%s\n", m->name);)
        _gocr_debug(3, gocr_printBox(currentbox);)
        if (m->func.charRecognizer(image, currentbox, m->data))
          break;
      } end_for_each(&modulefunclist[charRecognizer]);

      gocr_imageFree(image);
  
    } end_for_each(&currentblock->boxlist);
  } end_for_each(&currentimage->blocklist);
#endif

#if 0
  /* do something with unrecognized characters */
  for_each_data(&currentimage->blocklist) {
    currentblock  = (gocrBlock *)list_get_current(&currentimage->blocklist);
    for_each_data(&currentblock->boxlist) {
      for_each_data(&modulefunclist[contextCorrection]) {
        m = (struct _gocr_modulefunction *)list_get_current(&modulefunclist[contextCorrection]);
        _gocr_debug(3, fprintf(_data.error, "module contextCorrection:%s\n", m->name);)
        if (m->func((gocrBox *)list_get_current(&currentblock->boxlist), m->data))
          break;
      } end_for_each(&modulefunclist[contextCorrection]);
    } end_for_each(&currentblock->boxlist);
  } end_for_each(&currentimage->blocklist);

  /* output */
  for_each_data(&modulefunclist[outputFormatter]) {
    _gocr_debug(3, fprintf(_data.error, "module outputFormatter:%s\n", m->name);)
    m = (struct _gocr_modulefunction *)list_get_current(&modulefunclist[outputFormatter]);
    m->func(block?);
  } end_for_each(&modulefunclist[outputFormatter]);
#endif
}

---