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