/* -*-C-*-
********************************************************************************
*
* File: choices.c (Formerly choices.c)
* Description: Handle the new ratings choices for Wise Owl
* Author: Mark Seaman, OCR Technology
* Created: Fri Sep 22 14:05:51 1989
* Modified: Wed May 22 14:12:34 1991 (Mark Seaman) marks@hpgrlt
* Language: C
* Package: N/A
* Status: Experimental (Do Not Distribute)
*
* (c) Copyright 1989, Hewlett-Packard Company.
** 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 "choices.h"
#include "emalloc.h"
#include "globals.h"
#include "host.h"
#include "danerror.h"
#include "structures.h"
#include "tordvars.h"
#include "tprintf.h"
#include "unicharset.h"
#include "dict.h"
#include "image.h"
/*----------------------------------------------------------------------
Variables
------------------------------------------------------------------------*/
#define CHOICEBLOCK 100 /* Cells per block */
makestructure (newchoice, oldchoice, printchoice, A_CHOICE,
freechoice, CHOICEBLOCK, "A_CHOICE", choicecount)
/*----------------------------------------------------------------------
F u n c t i o n s
----------------------------------------------------------------------*/
/**********************************************************************
* append_char_choice
*
* Create a new choice record. Store the string value in a safe place.
* Add the new choice record to the list.
*
* NB - This is only used by matchers, so permuter is always NO_PERM
* SPC 16/9/92
**********************************************************************/
CHOICES append_char_choice(CHOICES ratings,
const char *string,
const char *lengths,
float rating,
float certainty,
inT8 config,
int script_id) {
A_CHOICE *this_choice;
this_choice = new_choice (string, lengths, rating, certainty,
config, script_id, NO_PERM, false, NULL);
ratings = push_last (ratings, (LIST) this_choice);
return (ratings);
}
/**********************************************************************
* copy_choices
*
* Copy a list of choices. This means that there will be two copies
* in memory.
**********************************************************************/
CHOICES copy_choices(CHOICES choices) {
CHOICES l;
CHOICES result = NIL;
iterate_list(l, choices) {
A_CHOICE *choice = (A_CHOICE *)(first_node(l));
result = push (result,
(LIST) new_choice (class_string(choice),
class_lengths(choice),
class_rating(choice),
class_certainty(choice),
class_config(choice),
class_script_id(choice),
class_permuter(choice),
class_fragment_mark(choice),
class_fragment_lengths(choice)));
}
return (reverse_d (result));
}
/**********************************************************************
* clone_choice
*
* Copy the contents of the given values to the corresponding values in
* a given choice replacing any previous values it might have had.
**********************************************************************/
void clone_choice(A_CHOICE *choice, const char *string,
const char *lengths, float rating, float certainty,
inT8 permuter, bool fragment_mark,
const char *fragment_lengths) {
if (choice->string) strfree (class_string (choice));
if (choice->lengths) strfree (class_lengths (choice));
if (choice->fragment_lengths) strfree(choice->fragment_lengths);
choice->string = strsave (string);
choice->lengths = strsave (lengths);
choice->rating = rating;
choice->certainty = certainty;
choice->permuter = permuter;
choice->fragment_mark = fragment_mark;
choice->fragment_lengths =
fragment_lengths ? strsave(fragment_lengths) : NULL;
}
/**********************************************************************
* clear_choice
*
* Set the fields in this choice to be defaulted bad initial values.
**********************************************************************/
void clear_choice(A_CHOICE *choice) {
choice->string = NULL;
choice->lengths = NULL;
choice->rating = MAX_FLOAT32;
choice->certainty = -MAX_FLOAT32;
choice->fragment_mark = false;
choice->fragment_lengths = NULL;
}
/**********************************************************************
* free_choice
*
* Free up the memory taken by one choice rating.
**********************************************************************/
void free_choice(void *arg) { //LIST choice)
A_CHOICE *this_choice;
LIST choice = (LIST) arg;
this_choice = (A_CHOICE *) choice;
if (this_choice) {
if (this_choice->string)
strfree (this_choice->string);
if (this_choice->lengths)
strfree (this_choice->lengths);
if (this_choice->fragment_lengths)
strfree (this_choice->fragment_lengths);
oldchoice(this_choice);
}
}
/**********************************************************************
* get_best_free_other
*
* Returns the best of two choices and frees the other (worse) choice.
* A choice is better if it has a non-NULL string and has a lower rating
* than the other choice.
**********************************************************************/
A_CHOICE *get_best_free_other(A_CHOICE *choice_1, A_CHOICE *choice_2) {
if (!choice_1) return choice_2;
if (!choice_2) return choice_1;
if (class_rating (choice_1) < class_rating (choice_2) ||
class_string (choice_2) == NULL) {
free_choice(choice_2);
return choice_1;
} else {
free_choice(choice_1);
return choice_2;
}
}
/**********************************************************************
* new_choice
*
* Create a new choice record. Store the string value in a safe place.
**********************************************************************/
A_CHOICE *new_choice(const char *string,
const char *lengths,
float rating,
float certainty,
inT8 config,
int script_id,
char permuter,
bool fragment_mark,
const char *fragment_lengths) {
A_CHOICE *this_choice;
this_choice = newchoice();
this_choice->string = strsave(string);
this_choice->lengths = strsave(lengths);
this_choice->rating = rating;
this_choice->certainty = certainty;
this_choice->config = config;
this_choice->permuter = permuter;
this_choice->script_id = script_id;
this_choice->fragment_mark = fragment_mark;
this_choice->fragment_lengths =
fragment_lengths ? strsave(fragment_lengths) : NULL;
return (this_choice);
}
A_CHOICE *new_choice(const char *string,
const char *lengths,
float rating,
float certainty,
inT8 config,
char permuter) {
return new_choice(string, lengths, rating, certainty,
config, -1, permuter, false, NULL);
}
/**********************************************************************
* print_choices
*
* Print the rating for a particular blob or word.
**********************************************************************/
namespace tesseract {
void Dict::print_choices(const char *label,
CHOICES choices) { // List of (A_CHOICE*).
tprintf("%s\n", label);
if (choices == NIL)
tprintf(" No rating ");
iterate(choices) {
tprintf("%.2f %.2f", best_rating(choices), best_certainty(choices));
print_word_string(best_string(choices));
}
tprintf("\n");
}
/**********************************************************************
* print_word_choice
*
* Print the string in a human-readable format and ratings for a word.
**********************************************************************/
void Dict::print_word_choice(const char *label, A_CHOICE* choice) {
tprintf("%s : ", label);
if (choice == NULL) {
tprintf("No rating\n");
} else {
tprintf("%.2f %.2f", class_rating(choice), class_certainty(choice));
print_word_string(class_string(choice));
tprintf("\n");
}
}
/**********************************************************************
* print_word_string
*
* Print the string in a human-readable format.
* The output is not newline terminated.
**********************************************************************/
void Dict::print_word_string(const char* str) {
int step = 1;
for (int i = 0; str[i] != '\0'; i += step) {
step = (getUnicharset().get_fragment(str) ?
strlen(str) : getUnicharset().step(str + i));
int unichar_id = getUnicharset().unichar_to_id(str + i, step);
tprintf(" : %s ", getUnicharset().debug_str(unichar_id).string());
}
}
} // namespace tesseract