tesseract v5.3.3.20231005
matrix.cpp
Go to the documentation of this file.
1/******************************************************************************
2 *
3 * File: matrix.cpp (Formerly matrix.c)
4 * Description: Ratings matrix code. (Used by associator)
5 * Author: Mark Seaman, OCR Technology
6 *
7 * (c) Copyright 1990, Hewlett-Packard Company.
8 ** Licensed under the Apache License, Version 2.0 (the "License");
9 ** you may not use this file except in compliance with the License.
10 ** You may obtain a copy of the License at
11 ** http://www.apache.org/licenses/LICENSE-2.0
12 ** Unless required by applicable law or agreed to in writing, software
13 ** distributed under the License is distributed on an "AS IS" BASIS,
14 ** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
15 ** See the License for the specific language governing permissions and
16 ** limitations under the License.
17 *
18 *****************************************************************************/
19/*----------------------------------------------------------------------
20 I n c l u d e s
21----------------------------------------------------------------------*/
22#include "matrix.h"
23
24#include "ratngs.h"
25#include "tprintf.h"
26#include "unicharset.h"
27
28namespace tesseract {
29
30// Destructor.
31// It is defined here, so the compiler can create a single vtable
32// instead of weak vtables in every compilation unit.
33MATRIX::~MATRIX() = default;
34
35// Returns true if there are any real classification results.
36bool MATRIX::Classified(int col, int row, int wildcard_id) const {
37 if (get(col, row) == NOT_CLASSIFIED) {
38 return false;
39 }
40 BLOB_CHOICE_IT b_it(get(col, row));
41 for (b_it.mark_cycle_pt(); !b_it.cycled_list(); b_it.forward()) {
42 BLOB_CHOICE *choice = b_it.data();
43 if (choice->IsClassified()) {
44 return true;
45 }
46 }
47 return false;
48}
49
50// Expands the existing matrix in-place to make the band wider, without
51// losing any existing data.
52void MATRIX::IncreaseBandSize(int bandwidth) {
54}
55
56// Returns a bigger MATRIX with a new column and row in the matrix in order
57// to split the blob at the given (ind,ind) diagonal location.
58// Entries are relocated to the new MATRIX using the transformation defined
59// by MATRIX_COORD::MapForSplit.
60// Transfers the pointer data to the new MATRIX and deletes *this.
62 int dim = dimension();
63 int band_width = bandwidth();
64 // Check to see if bandwidth needs expanding.
65 for (int col = ind; col >= 0 && col > ind - band_width; --col) {
66 if (array_[col * band_width + band_width - 1] != empty_) {
67 ++band_width;
68 break;
69 }
70 }
71 auto *result = new MATRIX(dim + 1, band_width);
72
73 for (int col = 0; col < dim; ++col) {
74 for (int row = col; row < dim && row < col + bandwidth(); ++row) {
75 MATRIX_COORD coord(col, row);
76 coord.MapForSplit(ind);
77 BLOB_CHOICE_LIST *choices = get(col, row);
78 if (choices != nullptr) {
79 // Correct matrix location on each choice.
80 BLOB_CHOICE_IT bc_it(choices);
81 for (bc_it.mark_cycle_pt(); !bc_it.cycled_list(); bc_it.forward()) {
82 BLOB_CHOICE *choice = bc_it.data();
83 choice->set_matrix_cell(coord.col, coord.row);
84 }
85 ASSERT_HOST(coord.Valid(*result));
86 result->put(coord.col, coord.row, choices);
87 }
88 }
89 }
90 delete this;
91 return result;
92}
93
94// Makes and returns a deep copy of *this, including all the BLOB_CHOICEs
95// on the lists, but not any LanguageModelState that may be attached to the
96// BLOB_CHOICEs.
98 int dim = dimension();
99 int band_width = bandwidth();
100 auto *result = new MATRIX(dim, band_width);
101 for (int col = 0; col < dim; ++col) {
102 for (int row = col; row < dim && row < col + band_width; ++row) {
103 BLOB_CHOICE_LIST *choices = get(col, row);
104 if (choices != nullptr) {
105 auto *copy_choices = new BLOB_CHOICE_LIST;
106 copy_choices->deep_copy(choices, &BLOB_CHOICE::deep_copy);
107 result->put(col, row, copy_choices);
108 }
109 }
110 }
111 return result;
112}
113
114// Print the best guesses out of the match rating matrix.
115void MATRIX::print(const UNICHARSET &unicharset) const {
116 tprintf("Ratings Matrix (top 3 choices)\n");
117 int dim = dimension();
118 int band_width = bandwidth();
119 int row, col;
120 for (col = 0; col < dim; ++col) {
121 for (row = col; row < dim && row < col + band_width; ++row) {
122 BLOB_CHOICE_LIST *rating = this->get(col, row);
123 if (rating == NOT_CLASSIFIED) {
124 continue;
125 }
126 BLOB_CHOICE_IT b_it(rating);
127 tprintf("col=%d row=%d ", col, row);
128 for (b_it.mark_cycle_pt(); !b_it.cycled_list(); b_it.forward()) {
129 tprintf("%s rat=%g cert=%g ", unicharset.id_to_unichar(b_it.data()->unichar_id()),
130 b_it.data()->rating(), b_it.data()->certainty());
131 }
132 tprintf("\n");
133 }
134 tprintf("\n");
135 }
136 tprintf("\n");
137 for (col = 0; col < dim; ++col) {
138 tprintf("\t%d", col);
139 }
140 tprintf("\n");
141 for (row = 0; row < dim; ++row) {
142 for (col = 0; col <= row; ++col) {
143 if (col == 0) {
144 tprintf("%d\t", row);
145 }
146 if (row >= col + band_width) {
147 tprintf(" \t");
148 continue;
149 }
150 BLOB_CHOICE_LIST *rating = this->get(col, row);
151 if (rating != NOT_CLASSIFIED) {
152 BLOB_CHOICE_IT b_it(rating);
153 int counter = 0;
154 for (b_it.mark_cycle_pt(); !b_it.cycled_list(); b_it.forward()) {
155 tprintf("%s ", unicharset.id_to_unichar(b_it.data()->unichar_id()));
156 ++counter;
157 if (counter == 3) {
158 break;
159 }
160 }
161 tprintf("\t");
162 } else {
163 tprintf(" \t");
164 }
165 }
166 tprintf("\n");
167 }
168}
169
170} // namespace tesseract
#define ASSERT_HOST(x)
Definition: errcode.h:54
#define NOT_CLASSIFIED
Definition: matrix.h:45
void tprintf(const char *format,...)
Definition: tprintf.cpp:41
void ResizeWithCopy(int size1, int size2)
Definition: matrix.h:117
BLOB_CHOICE_LIST * get(ICOORD pos) const
Definition: matrix.h:268
MATRIX * ConsumeAndMakeBigger(int ind)
Definition: matrix.cpp:61
bool Classified(int col, int row, int wildcard_id) const
Definition: matrix.cpp:36
MATRIX * DeepCopy() const
Definition: matrix.cpp:97
~MATRIX() override
MATRIX(int dimension, int bandwidth)
Definition: matrix.h:659
void IncreaseBandSize(int bandwidth)
Definition: matrix.cpp:52
void print(const UNICHARSET &unicharset) const
Definition: matrix.cpp:115
void MapForSplit(int ind)
Definition: matrix.h:708
bool Valid(const MATRIX &m) const
Definition: matrix.h:697
void set_matrix_cell(int col, int row)
Definition: ratngs.h:156
static BLOB_CHOICE * deep_copy(const BLOB_CHOICE *src)
Definition: ratngs.h:163
bool IsClassified() const
Definition: ratngs.h:139
const char * id_to_unichar(UNICHAR_ID id) const
Definition: unicharset.cpp:279