typedef struct ReInit_tag { char version[8]; int rel_grid_maxlen; int rel_graph_maxlen; int rel_result_maxlen; int options; void *rep_memory; long rep_memory_size; void * (*zip_open) (const char *file_title, const char *mode); void * (*zip_wopen) (const wchar_t *file_title, const char *mode); int (*zip_compressed) (const char *file_title); int (*zip_wcompressed) (const wchar_t *file_title); int (*zip_read) (void *file, void *buf, unsigned long len); int (*zip_close)(void *file); INT_PTR interna1[4]; INT_PTR interna2[4]; } ReInit;
version[8]
rel_grid_maxlen
rel_grid
.rel_graph_maxlen
rel_graph
.rel_result_maxlen
in rel_result
.options
*rep_memory
rep_result
(s).rep_memory_size
rep_do()
.*zip_open
*zip_wopen
*zip_compressed
zip_compressed
is not specified, the extension ".gz" signals compression.*zip_wcompressed
zip_(w)compressed
is not specified, the extension ".gz" signals compression.*zip_read
*zip_close
interna1[4]
interna2[4]
During recognition of a text image, a lot of information is retrieved, which may be important for further processing.
The amount of this information not only depends on the image size, but also on the number of text lines as well as on the
number of single characters in the image. To deliver this information the module needs memory, and after processing
this memory must be given back to the system. This means memory allocation and management is the responsibility of the
respective application. The value of rep_memory
must be set with a pointer to this memory, the value of
rep_memory_size
must be set to the size of this memory in bytes. Before the initialization the parameter
rel_result_maxlen
must be set to the maximum number of expected characters per line (see also
rel_graph_len
and rel_result_len
in the structure RelData
). Before the initialization
rel_grid_maxlen
has to be set to the maximum number of grid elements per image (if required) for which memory
has been provided to hold recognition results. How much memory is required dependens upon the structures containing the
recognition results. They include RelGrid
, RelGraph
, and RelResult
for the results
of one text line and RepResult
for the results of the REP module. For each text line, a structure
RepResult
is returned, and for every single character of every line, two structures RelGraph
and RelResult
, for possible alternative segmentation points appropriate more. If information about line
elements is wanted, than memory for the related structures RelGrid
has to be provided for every text line.
Pointer rep_result
, RepResult[0]
optionally includes grid information RelGrid
.
Ponter rep_result
, ein RepResult
for each text line.
Pointer rel_grid
, ein RelGrid
per line element.
Pointer rel_graph
, ein RelGraph
for each segmentation point.
Pointer rel_result
, ein RelResult
per character of a text line.
If MAX_LINE
contains the maximum value of expected textlines, MAX_GRID
the maximum value of
grid elements, and MAX_CHAR
the maximum value of expected characters per line, then the value of
rep_memory_size
can be determined by the following formula:
rep.init.rep_memory_size = MAX_LINE*sizeof(RepResult) + MAX_GRID*sizeof(RelGrid) + MAX_LINE*MAX_CHAR*sizeof(RelGraph) + MAX_LINE*MAX_CHAR*sizeof(RelResult);
⚠️ If the provided memory area rep_memory is too small, the main effect will be the loss of some recognition results.
Memory not necessarily has to be allocated, and values ofrep_memory
andrep_memory_size
may be set to NULL resp. 0. Then, after callingrep_do()
there will be no results available underrep_result
. In this case the recognition results have to be retrieved from a functionrel_hook()
using the messagesWM_USER REP_LINE_CNT
andWM_USER REP_RESULT
.
options
makes it possible to read only parts of big classifiers (REC files). This has the same effect as the
restriction of classifiers by Chopper.exe and can yield huge reductions of computing time. How to apply: Before the
call of re?_init()
you have to set ReInit.options
to OPTIONS_RESTRICT_LABELS
and you have to set the parameters ReParm.labels_size
, ReParm.labels
, and
ReParm.rejects
, the latter to the required labels and rejects. Now the subsequent call of
re?_init()
only reads the specified part of the classifier into memory, which is needed to recognize these
labels and rejects.