mirror of
https://github.com/tesseract-ocr/tesseract.git
synced 2024-12-12 07:29:07 +08:00
524a61452d
Squashed commit from https://github.com/tesseract-ocr/tesseract/tree/more-doxygen closes #14 Commits:6317305
doxygen9f42f69
doxygen0fc4d52
doxygen37b4b55
fix typobded8f1
some more doxy020eb00
slight tweak524666d
doxygenify2a36a3e
doxygenify229d218
doxygenify7fd28ae
doxygenifya8c64bc
doxygenifyf5d21b6
fix5d8ede8
doxygenifya58a4e0
language_model.cppfa85709
lm_pain_points.cpp lm_state.cpp6418da3
merge06190ba
Merge branch 'old_doxygen_merge' into more-doxygen84acf08
Merge branch 'master' into more-doxygen50fe1ff
pagewalk.cpp cube_reco_context.cpp2982583
change to relative192a24a
applybox.cpp, take one8eeb053
delete docs for obsolete params52e4c77
modernise classify/ocrfeatures.cpp2a1cba6
modernise cutil/emalloc.cpp773e006
silence doxygen warningaeb1731
silence doxygen warningf18387f
silence doxygen; new params are unused?15ad6bd
doxygenify cutil/efio.cppc8b5dad
doxygenify cutil/danerror.cpp784450f
the globals and exceptions parts are obsolete; remove8bca324
doxygen classify/normfeat.cpp9bcbe16
doxygen classify/normmatch.cppaa9a971
doxygen ccmain/cube_control.cppc083ff2
doxygen ccmain/cube_reco_context.cppf842850
params changed5c94f12
doxygen ccmain/cubeclassifier.cpp15ba750
case sensitivef5c71d4
case sensitivef85655b
doxygen classify/intproto.cpp4bbc7aa
partial doxygen classify/mfx.cppdbb6041
partial doxygen classify/intproto.cpp2aa72db
finish doxygen classify/intproto.cpp0b8de99
doxygen training/mftraining.cpp0b5b35c
partial doxygen ccstruct/coutln.cppb81c766
partial doxygen ccstruct/coutln.cpp40fc415
finished? doxygen ccstruct/coutln.cpp6e4165c
doxygen classify/clusttool.cpp0267dec
doxygen classify/cutoffs.cpp7f0c70c
doxygen classify/fpoint.cpp512f3bd
ignore ~ files5668a52
doxygen classify/intmatcher.cpp84788d4
doxygen classify/kdtree.cpp29f36ca
doxygen classify/mfoutline.cpp40b94b1
silence doxygen warnings6c511b9
doxygen classify/mfx.cppf9b4080
doxygen classify/outfeat.cppaa1df05
doxygen classify/picofeat.cppcc5f466
doxygen training/cntraining.cppcce044f
doxygen training/commontraining.cpp167e216
missing param9498383
renamed params37eeac2
renamed paramd87b5dd
casec8ee174
renamed paramsb858db8
typo4c2a838
h2 context?81a2c0c
fix some param names; add some missing params, no docsbcf8a4c
add some missing params, no docsaf77f86
add some missing params, no docs; fix some param names01df24e
fix some params6161056
fix some params68508b6
fix some params285aeb6
doxygen complains here no matter what529bcfa
rm some missing params, typoscd21226
rm some missing params, add some new ones48a4bc2
fix paramsc844628
missing param312ce37
missing param; rename oneec2fdec
missing param05e15e0
missing paramsd515858
change "<" to < to make doxygen happyb476a28
wrong place
467 lines
15 KiB
C++
467 lines
15 KiB
C++
/******************************************************************************
|
|
** Filename: clustertool.c
|
|
** Purpose: Misc. tools for use with the clustering routines
|
|
** Author: Dan Johnson
|
|
** History: 6/6/89, DSJ, Created.
|
|
**
|
|
** (c) Copyright Hewlett-Packard Company, 1988.
|
|
** Licensed under the Apache License, Version 2.0 (the "License");
|
|
** you may not use this file except in compliance with the License.
|
|
** You may obtain a copy of the License at
|
|
** http://www.apache.org/licenses/LICENSE-2.0
|
|
** Unless required by applicable law or agreed to in writing, software
|
|
** distributed under the License is distributed on an "AS IS" BASIS,
|
|
** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
** See the License for the specific language governing permissions and
|
|
** limitations under the License.
|
|
******************************************************************************/
|
|
|
|
//--------------------------Include Files----------------------------------
|
|
#include "clusttool.h"
|
|
#include "const.h"
|
|
#include "danerror.h"
|
|
#include "emalloc.h"
|
|
#include "scanutils.h"
|
|
#include <stdio.h>
|
|
#include <math.h>
|
|
|
|
//---------------Global Data Definitions and Declarations--------------------
|
|
#define TOKENSIZE 80 //< max size of tokens read from an input file
|
|
#define MAXSAMPLESIZE 65535 //< max num of dimensions in feature space
|
|
//#define MAXBLOCKSIZE 65535 //< max num of samples in a character (block size)
|
|
|
|
/**
|
|
* This routine reads a single integer from the specified
|
|
* file and checks to ensure that it is between 0 and
|
|
* MAXSAMPLESIZE.
|
|
* @param File open text file to read sample size from
|
|
* @return Sample size
|
|
* @note Globals: None
|
|
* @note Exceptions: ILLEGALSAMPLESIZE illegal format or range
|
|
* @note History: 6/6/89, DSJ, Created.
|
|
*/
|
|
uinT16 ReadSampleSize(FILE *File) {
|
|
int SampleSize;
|
|
|
|
if ((tfscanf(File, "%d", &SampleSize) != 1) ||
|
|
(SampleSize < 0) || (SampleSize > MAXSAMPLESIZE))
|
|
DoError (ILLEGALSAMPLESIZE, "Illegal sample size");
|
|
return (SampleSize);
|
|
}
|
|
|
|
/**
|
|
* This routine reads textual descriptions of sets of parameters
|
|
* which describe the characteristics of feature dimensions.
|
|
*
|
|
* Exceptions:
|
|
* - ILLEGALCIRCULARSPEC
|
|
* - ILLEGALESSENTIALSPEC
|
|
* - ILLEGALMINMAXSPEC
|
|
* @param File open text file to read N parameter descriptions from
|
|
* @param N number of parameter descriptions to read
|
|
* @return Pointer to an array of parameter descriptors.
|
|
* @note Globals: None
|
|
* @note History: 6/6/89, DSJ, Created.
|
|
*/
|
|
PARAM_DESC *ReadParamDesc(FILE *File, uinT16 N) {
|
|
int i;
|
|
PARAM_DESC *ParamDesc;
|
|
char Token[TOKENSIZE];
|
|
|
|
ParamDesc = (PARAM_DESC *) Emalloc (N * sizeof (PARAM_DESC));
|
|
for (i = 0; i < N; i++) {
|
|
if (tfscanf(File, "%s", Token) != 1)
|
|
DoError (ILLEGALCIRCULARSPEC,
|
|
"Illegal circular/linear specification");
|
|
if (Token[0] == 'c')
|
|
ParamDesc[i].Circular = TRUE;
|
|
else
|
|
ParamDesc[i].Circular = FALSE;
|
|
|
|
if (tfscanf(File, "%s", Token) != 1)
|
|
DoError (ILLEGALESSENTIALSPEC,
|
|
"Illegal essential/non-essential spec");
|
|
if (Token[0] == 'e')
|
|
ParamDesc[i].NonEssential = FALSE;
|
|
else
|
|
ParamDesc[i].NonEssential = TRUE;
|
|
if (tfscanf(File, "%f%f", &(ParamDesc[i].Min), &(ParamDesc[i].Max)) != 2)
|
|
DoError (ILLEGALMINMAXSPEC, "Illegal min or max specification");
|
|
ParamDesc[i].Range = ParamDesc[i].Max - ParamDesc[i].Min;
|
|
ParamDesc[i].HalfRange = ParamDesc[i].Range / 2;
|
|
ParamDesc[i].MidRange = (ParamDesc[i].Max + ParamDesc[i].Min) / 2;
|
|
}
|
|
return (ParamDesc);
|
|
}
|
|
|
|
/**
|
|
* This routine reads a textual description of a prototype from
|
|
* the specified file.
|
|
*
|
|
* Exceptions:
|
|
* - ILLEGALSIGNIFICANCESPEC
|
|
* - ILLEGALSAMPLECOUNT
|
|
* - ILLEGALMEANSPEC
|
|
* - ILLEGALVARIANCESPEC
|
|
* - ILLEGALDISTRIBUTION
|
|
* @param File open text file to read prototype from
|
|
* @param N number of dimensions used in prototype
|
|
* @return List of prototypes
|
|
* @note Globals: None
|
|
* @note History: 6/6/89, DSJ, Created.
|
|
*/
|
|
PROTOTYPE *ReadPrototype(FILE *File, uinT16 N) {
|
|
char Token[TOKENSIZE];
|
|
int Status;
|
|
PROTOTYPE *Proto;
|
|
int SampleCount;
|
|
int i;
|
|
|
|
if ((Status = tfscanf(File, "%s", Token)) == 1) {
|
|
Proto = (PROTOTYPE *) Emalloc (sizeof (PROTOTYPE));
|
|
Proto->Cluster = NULL;
|
|
if (Token[0] == 's')
|
|
Proto->Significant = TRUE;
|
|
else
|
|
Proto->Significant = FALSE;
|
|
|
|
Proto->Style = ReadProtoStyle (File);
|
|
|
|
if ((tfscanf(File, "%d", &SampleCount) != 1) || (SampleCount < 0))
|
|
DoError (ILLEGALSAMPLECOUNT, "Illegal sample count");
|
|
Proto->NumSamples = SampleCount;
|
|
|
|
Proto->Mean = ReadNFloats (File, N, NULL);
|
|
if (Proto->Mean == NULL)
|
|
DoError (ILLEGALMEANSPEC, "Illegal prototype mean");
|
|
|
|
switch (Proto->Style) {
|
|
case spherical:
|
|
if (ReadNFloats (File, 1, &(Proto->Variance.Spherical)) == NULL)
|
|
DoError (ILLEGALVARIANCESPEC, "Illegal prototype variance");
|
|
Proto->Magnitude.Spherical =
|
|
1.0 / sqrt ((double) (2.0 * PI * Proto->Variance.Spherical));
|
|
Proto->TotalMagnitude =
|
|
pow (Proto->Magnitude.Spherical, (float) N);
|
|
Proto->LogMagnitude = log ((double) Proto->TotalMagnitude);
|
|
Proto->Weight.Spherical = 1.0 / Proto->Variance.Spherical;
|
|
Proto->Distrib = NULL;
|
|
break;
|
|
case elliptical:
|
|
Proto->Variance.Elliptical = ReadNFloats (File, N, NULL);
|
|
if (Proto->Variance.Elliptical == NULL)
|
|
DoError (ILLEGALVARIANCESPEC, "Illegal prototype variance");
|
|
Proto->Magnitude.Elliptical =
|
|
(FLOAT32 *) Emalloc (N * sizeof (FLOAT32));
|
|
Proto->Weight.Elliptical =
|
|
(FLOAT32 *) Emalloc (N * sizeof (FLOAT32));
|
|
Proto->TotalMagnitude = 1.0;
|
|
for (i = 0; i < N; i++) {
|
|
Proto->Magnitude.Elliptical[i] =
|
|
1.0 /
|
|
sqrt ((double) (2.0 * PI * Proto->Variance.Elliptical[i]));
|
|
Proto->Weight.Elliptical[i] =
|
|
1.0 / Proto->Variance.Elliptical[i];
|
|
Proto->TotalMagnitude *= Proto->Magnitude.Elliptical[i];
|
|
}
|
|
Proto->LogMagnitude = log ((double) Proto->TotalMagnitude);
|
|
Proto->Distrib = NULL;
|
|
break;
|
|
case mixed:
|
|
Proto->Distrib =
|
|
(DISTRIBUTION *) Emalloc (N * sizeof (DISTRIBUTION));
|
|
for (i = 0; i < N; i++) {
|
|
if (tfscanf(File, "%s", Token) != 1)
|
|
DoError (ILLEGALDISTRIBUTION,
|
|
"Illegal prototype distribution");
|
|
switch (Token[0]) {
|
|
case 'n':
|
|
Proto->Distrib[i] = normal;
|
|
break;
|
|
case 'u':
|
|
Proto->Distrib[i] = uniform;
|
|
break;
|
|
case 'r':
|
|
Proto->Distrib[i] = D_random;
|
|
break;
|
|
default:
|
|
DoError (ILLEGALDISTRIBUTION,
|
|
"Illegal prototype distribution");
|
|
}
|
|
}
|
|
Proto->Variance.Elliptical = ReadNFloats (File, N, NULL);
|
|
if (Proto->Variance.Elliptical == NULL)
|
|
DoError (ILLEGALVARIANCESPEC, "Illegal prototype variance");
|
|
Proto->Magnitude.Elliptical =
|
|
(FLOAT32 *) Emalloc (N * sizeof (FLOAT32));
|
|
Proto->Weight.Elliptical =
|
|
(FLOAT32 *) Emalloc (N * sizeof (FLOAT32));
|
|
Proto->TotalMagnitude = 1.0;
|
|
for (i = 0; i < N; i++) {
|
|
switch (Proto->Distrib[i]) {
|
|
case normal:
|
|
Proto->Magnitude.Elliptical[i] = 1.0 /
|
|
sqrt ((double)
|
|
(2.0 * PI * Proto->Variance.Elliptical[i]));
|
|
Proto->Weight.Elliptical[i] =
|
|
1.0 / Proto->Variance.Elliptical[i];
|
|
break;
|
|
case uniform:
|
|
case D_random:
|
|
Proto->Magnitude.Elliptical[i] = 1.0 /
|
|
(2.0 * Proto->Variance.Elliptical[i]);
|
|
break;
|
|
case DISTRIBUTION_COUNT:
|
|
ASSERT_HOST(!"Distribution count not allowed!");
|
|
}
|
|
Proto->TotalMagnitude *= Proto->Magnitude.Elliptical[i];
|
|
}
|
|
Proto->LogMagnitude = log ((double) Proto->TotalMagnitude);
|
|
break;
|
|
}
|
|
return (Proto);
|
|
}
|
|
else if (Status == EOF)
|
|
return (NULL);
|
|
else {
|
|
DoError (ILLEGALSIGNIFICANCESPEC, "Illegal significance specification");
|
|
return (NULL);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* This routine reads an single token from the specified
|
|
* text file and interprets it as a prototype specification.
|
|
* @param File open text file to read prototype style from
|
|
* @return Prototype style read from text file
|
|
* @note Globals: None
|
|
* @note Exceptions: ILLEGALSTYLESPEC illegal prototype style specification
|
|
* @note History: 6/8/89, DSJ, Created.
|
|
*/
|
|
PROTOSTYLE ReadProtoStyle(FILE *File) {
|
|
char Token[TOKENSIZE];
|
|
PROTOSTYLE Style;
|
|
|
|
if (tfscanf(File, "%s", Token) != 1)
|
|
DoError (ILLEGALSTYLESPEC, "Illegal prototype style specification");
|
|
switch (Token[0]) {
|
|
case 's':
|
|
Style = spherical;
|
|
break;
|
|
case 'e':
|
|
Style = elliptical;
|
|
break;
|
|
case 'm':
|
|
Style = mixed;
|
|
break;
|
|
case 'a':
|
|
Style = automatic;
|
|
break;
|
|
default:
|
|
Style = elliptical;
|
|
DoError (ILLEGALSTYLESPEC, "Illegal prototype style specification");
|
|
}
|
|
return (Style);
|
|
}
|
|
|
|
/**
|
|
* This routine reads N floats from the specified text file
|
|
* and places them into Buffer. If Buffer is NULL, a buffer
|
|
* is created and passed back to the caller. If EOF is
|
|
* encountered before any floats can be read, NULL is
|
|
* returned.
|
|
* @param File open text file to read floats from
|
|
* @param N number of floats to read
|
|
* @param Buffer pointer to buffer to place floats into
|
|
* @return Pointer to buffer holding floats or NULL if EOF
|
|
* @note Globals: None
|
|
* @note Exceptions: ILLEGALFLOAT
|
|
* @note History: 6/6/89, DSJ, Created.
|
|
*/
|
|
FLOAT32* ReadNFloats(FILE * File, uinT16 N, FLOAT32 Buffer[]) {
|
|
int i;
|
|
int NumFloatsRead;
|
|
|
|
if (Buffer == NULL)
|
|
Buffer = reinterpret_cast<FLOAT32*>(Emalloc(N * sizeof(FLOAT32)));
|
|
|
|
for (i = 0; i < N; i++) {
|
|
NumFloatsRead = tfscanf(File, "%f", &(Buffer[i]));
|
|
if (NumFloatsRead != 1) {
|
|
if ((NumFloatsRead == EOF) && (i == 0)) {
|
|
Efree(Buffer);
|
|
return NULL;
|
|
} else {
|
|
DoError(ILLEGALFLOAT, "Illegal float specification");
|
|
}
|
|
}
|
|
}
|
|
return Buffer;
|
|
}
|
|
|
|
/**
|
|
* This routine writes an array of dimension descriptors to
|
|
* the specified text file.
|
|
* @param File open text file to write param descriptors to
|
|
* @param N number of param descriptors to write
|
|
* @param ParamDesc array of param descriptors to write
|
|
* @return None
|
|
* @note Globals: None
|
|
* @note Exceptions: None
|
|
* @note History: 6/6/89, DSJ, Created.
|
|
*/
|
|
void
|
|
WriteParamDesc (FILE * File, uinT16 N, PARAM_DESC ParamDesc[]) {
|
|
int i;
|
|
|
|
for (i = 0; i < N; i++) {
|
|
if (ParamDesc[i].Circular)
|
|
fprintf (File, "circular ");
|
|
else
|
|
fprintf (File, "linear ");
|
|
|
|
if (ParamDesc[i].NonEssential)
|
|
fprintf (File, "non-essential ");
|
|
else
|
|
fprintf (File, "essential ");
|
|
|
|
fprintf (File, "%10.6f %10.6f\n", ParamDesc[i].Min, ParamDesc[i].Max);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* This routine writes a textual description of a prototype
|
|
* to the specified text file.
|
|
* @param File open text file to write prototype to
|
|
* @param N number of dimensions in feature space
|
|
* @param Proto prototype to write out
|
|
* @return None
|
|
* @note Globals: None
|
|
* @note Exceptions: None
|
|
* @note History: 6/12/89, DSJ, Created.
|
|
*/
|
|
void WritePrototype(FILE *File, uinT16 N, PROTOTYPE *Proto) {
|
|
int i;
|
|
|
|
if (Proto->Significant)
|
|
fprintf (File, "significant ");
|
|
else
|
|
fprintf (File, "insignificant ");
|
|
WriteProtoStyle (File, (PROTOSTYLE) Proto->Style);
|
|
fprintf (File, "%6d\n\t", Proto->NumSamples);
|
|
WriteNFloats (File, N, Proto->Mean);
|
|
fprintf (File, "\t");
|
|
|
|
switch (Proto->Style) {
|
|
case spherical:
|
|
WriteNFloats (File, 1, &(Proto->Variance.Spherical));
|
|
break;
|
|
case elliptical:
|
|
WriteNFloats (File, N, Proto->Variance.Elliptical);
|
|
break;
|
|
case mixed:
|
|
for (i = 0; i < N; i++)
|
|
switch (Proto->Distrib[i]) {
|
|
case normal:
|
|
fprintf (File, " %9s", "normal");
|
|
break;
|
|
case uniform:
|
|
fprintf (File, " %9s", "uniform");
|
|
break;
|
|
case D_random:
|
|
fprintf (File, " %9s", "random");
|
|
break;
|
|
case DISTRIBUTION_COUNT:
|
|
ASSERT_HOST(!"Distribution count not allowed!");
|
|
}
|
|
fprintf (File, "\n\t");
|
|
WriteNFloats (File, N, Proto->Variance.Elliptical);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* This routine writes a text representation of N floats from
|
|
* an array to a file. All of the floats are placed on one line.
|
|
* @param File open text file to write N floats to
|
|
* @param N number of floats to write
|
|
* @param Array array of floats to write
|
|
* @return None
|
|
* @note Globals: None
|
|
* @note Exceptions: None
|
|
* @note History: 6/6/89, DSJ, Created.
|
|
*/
|
|
void WriteNFloats(FILE * File, uinT16 N, FLOAT32 Array[]) {
|
|
for (int i = 0; i < N; i++)
|
|
fprintf(File, " %9.6f", Array[i]);
|
|
fprintf(File, "\n");
|
|
}
|
|
|
|
/**
|
|
* This routine writes to the specified text file a word
|
|
* which represents the ProtoStyle. It does not append
|
|
* a carriage return to the end.
|
|
* @param File open text file to write prototype style to
|
|
* @param ProtoStyle prototype style to write
|
|
* @return None
|
|
* @note Globals: None
|
|
* @note Exceptions: None
|
|
* @note History: 6/8/89, DSJ, Created.
|
|
*/
|
|
void WriteProtoStyle(FILE *File, PROTOSTYLE ProtoStyle) {
|
|
switch (ProtoStyle) {
|
|
case spherical:
|
|
fprintf (File, "spherical");
|
|
break;
|
|
case elliptical:
|
|
fprintf (File, "elliptical");
|
|
break;
|
|
case mixed:
|
|
fprintf (File, "mixed");
|
|
break;
|
|
case automatic:
|
|
fprintf (File, "automatic");
|
|
break;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* This routine writes a textual description of each prototype
|
|
* in the prototype list to the specified file. It also
|
|
* writes a file header which includes the number of dimensions
|
|
* in feature space and the descriptions for each dimension.
|
|
* @param File open text file to write prototypes to
|
|
* @param N number of dimensions in feature space
|
|
* @param ParamDesc descriptions for each dimension
|
|
* @param ProtoList list of prototypes to be written
|
|
* @param WriteSigProtos TRUE to write out significant prototypes
|
|
* @param WriteInsigProtos TRUE to write out insignificants
|
|
* @note Globals: None
|
|
* @return None
|
|
* @note Exceptions: None
|
|
* @note History: 6/12/89, DSJ, Created.
|
|
*/
|
|
|
|
void WriteProtoList(
|
|
FILE *File,
|
|
uinT16 N,
|
|
PARAM_DESC ParamDesc[],
|
|
LIST ProtoList,
|
|
BOOL8 WriteSigProtos,
|
|
BOOL8 WriteInsigProtos)
|
|
{
|
|
PROTOTYPE *Proto;
|
|
|
|
/* write file header */
|
|
fprintf(File,"%0d\n",N);
|
|
WriteParamDesc(File,N,ParamDesc);
|
|
|
|
/* write prototypes */
|
|
iterate(ProtoList)
|
|
{
|
|
Proto = (PROTOTYPE *) first_node ( ProtoList );
|
|
if (( Proto->Significant && WriteSigProtos ) ||
|
|
( ! Proto->Significant && WriteInsigProtos ) )
|
|
WritePrototype( File, N, Proto );
|
|
}
|
|
}
|