tesseract  5.0.0-alpha-619-ge9db
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 "callcpp.h"
25 #include "ratngs.h"
26 #include "tprintf.h"
27 #include "unicharset.h"
28 
29 // Destructor.
30 // It is defined here, so the compiler can create a single vtable
31 // instead of weak vtables in every compilation unit.
32 MATRIX::~MATRIX() = default;
33 
34 // Returns true if there are any real classification results.
35 bool MATRIX::Classified(int col, int row, int wildcard_id) const {
36  if (get(col, row) == NOT_CLASSIFIED) return false;
37  BLOB_CHOICE_IT b_it(get(col, row));
38  for (b_it.mark_cycle_pt(); !b_it.cycled_list(); b_it.forward()) {
39  BLOB_CHOICE* choice = b_it.data();
40  if (choice->IsClassified())
41  return true;
42  }
43  return false;
44 }
45 
46 // Expands the existing matrix in-place to make the band wider, without
47 // losing any existing data.
48 void MATRIX::IncreaseBandSize(int bandwidth) {
50 }
51 
52 // Returns a bigger MATRIX with a new column and row in the matrix in order
53 // to split the blob at the given (ind,ind) diagonal location.
54 // Entries are relocated to the new MATRIX using the transformation defined
55 // by MATRIX_COORD::MapForSplit.
56 // Transfers the pointer data to the new MATRIX and deletes *this.
58  int dim = dimension();
59  int band_width = bandwidth();
60  // Check to see if bandwidth needs expanding.
61  for (int col = ind; col >= 0 && col > ind - band_width; --col) {
62  if (array_[col * band_width + band_width - 1] != empty_) {
63  ++band_width;
64  break;
65  }
66  }
67  auto* result = new MATRIX(dim + 1, band_width);
68 
69  for (int col = 0; col < dim; ++col) {
70  for (int row = col; row < dim && row < col + bandwidth(); ++row) {
71  MATRIX_COORD coord(col, row);
72  coord.MapForSplit(ind);
73  BLOB_CHOICE_LIST* choices = get(col, row);
74  if (choices != nullptr) {
75  // Correct matrix location on each choice.
76  BLOB_CHOICE_IT bc_it(choices);
77  for (bc_it.mark_cycle_pt(); !bc_it.cycled_list(); bc_it.forward()) {
78  BLOB_CHOICE* choice = bc_it.data();
79  choice->set_matrix_cell(coord.col, coord.row);
80  }
81  ASSERT_HOST(coord.Valid(*result));
82  result->put(coord.col, coord.row, choices);
83  }
84  }
85  }
86  delete this;
87  return result;
88 }
89 
90 // Makes and returns a deep copy of *this, including all the BLOB_CHOICEs
91 // on the lists, but not any LanguageModelState that may be attached to the
92 // BLOB_CHOICEs.
93 MATRIX* MATRIX::DeepCopy() const {
94  int dim = dimension();
95  int band_width = bandwidth();
96  auto* result = new MATRIX(dim, band_width);
97  for (int col = 0; col < dim; ++col) {
98  for (int row = col; row < dim && row < col + band_width; ++row) {
99  BLOB_CHOICE_LIST* choices = get(col, row);
100  if (choices != nullptr) {
101  auto* copy_choices = new BLOB_CHOICE_LIST;
102  copy_choices->deep_copy(choices, &BLOB_CHOICE::deep_copy);
103  result->put(col, row, copy_choices);
104  }
105  }
106  }
107  return result;
108 }
109 
110 // Print the best guesses out of the match rating matrix.
111 void MATRIX::print(const UNICHARSET &unicharset) const {
112  tprintf("Ratings Matrix (top 3 choices)\n");
113  int dim = dimension();
114  int band_width = bandwidth();
115  int row, col;
116  for (col = 0; col < dim; ++col) {
117  for (row = col; row < dim && row < col + band_width; ++row) {
118  BLOB_CHOICE_LIST *rating = this->get(col, row);
119  if (rating == NOT_CLASSIFIED) continue;
120  BLOB_CHOICE_IT b_it(rating);
121  tprintf("col=%d row=%d ", col, row);
122  for (b_it.mark_cycle_pt(); !b_it.cycled_list(); b_it.forward()) {
123  tprintf("%s rat=%g cert=%g " ,
124  unicharset.id_to_unichar(b_it.data()->unichar_id()),
125  b_it.data()->rating(), b_it.data()->certainty());
126  }
127  tprintf("\n");
128  }
129  tprintf("\n");
130  }
131  tprintf("\n");
132  for (col = 0; col < dim; ++col) tprintf("\t%d", col);
133  tprintf("\n");
134  for (row = 0; row < dim; ++row) {
135  for (col = 0; col <= row; ++col) {
136  if (col == 0) tprintf("%d\t", row);
137  if (row >= col + band_width) {
138  tprintf(" \t");
139  continue;
140  }
141  BLOB_CHOICE_LIST *rating = this->get(col, row);
142  if (rating != NOT_CLASSIFIED) {
143  BLOB_CHOICE_IT b_it(rating);
144  int counter = 0;
145  for (b_it.mark_cycle_pt(); !b_it.cycled_list(); b_it.forward()) {
146  tprintf("%s ",
147  unicharset.id_to_unichar(b_it.data()->unichar_id()));
148  ++counter;
149  if (counter == 3) break;
150  }
151  tprintf("\t");
152  } else {
153  tprintf(" \t");
154  }
155  }
156  tprintf("\n");
157  }
158 }
MATRIX::ConsumeAndMakeBigger
MATRIX * ConsumeAndMakeBigger(int ind)
Definition: matrix.cpp:56
MATRIX::MATRIX
MATRIX(int dimension, int bandwidth)
Definition: matrix.h:576
ASSERT_HOST
#define ASSERT_HOST(x)
Definition: errcode.h:87
MATRIX::print
void print(const UNICHARSET &unicharset) const
Definition: matrix.cpp:110
MATRIX_COORD::Valid
bool Valid(const MATRIX &m) const
Definition: matrix.h:614
GENERIC_2D_ARRAY< BLOB_CHOICE_LIST * >::array_
BLOB_CHOICE_LIST * * array_
Definition: matrix.h:504
MATRIX
Definition: matrix.h:574
MATRIX::IncreaseBandSize
void IncreaseBandSize(int bandwidth)
Definition: matrix.cpp:47
MATRIX_COORD::MapForSplit
void MapForSplit(int ind)
Definition: matrix.h:625
ratngs.h
BLOB_CHOICE::set_matrix_cell
void set_matrix_cell(int col, int row)
Definition: ratngs.h:151
GENERIC_2D_ARRAY< BLOB_CHOICE_LIST * >::ResizeWithCopy
void ResizeWithCopy(int size1, int size2)
Definition: matrix.h:111
NOT_CLASSIFIED
#define NOT_CLASSIFIED
Definition: matrix.h:40
unicharset.h
GENERIC_2D_ARRAY< BLOB_CHOICE_LIST * >::get
BLOB_CHOICE_LIST * get(ICOORD pos) const
Definition: matrix.h:227
matrix.h
UNICHARSET
Definition: unicharset.h:145
tprintf.h
callcpp.h
MATRIX::DeepCopy
MATRIX * DeepCopy() const
Definition: matrix.cpp:92
BLOB_CHOICE::deep_copy
static BLOB_CHOICE * deep_copy(const BLOB_CHOICE *src)
Definition: ratngs.h:158
BandTriMatrix< BLOB_CHOICE_LIST * >::bandwidth
int bandwidth() const
Definition: matrix.h:534
BLOB_CHOICE
Definition: ratngs.h:49
MATRIX_COORD
Definition: matrix.h:604
MATRIX_COORD::col
int col
Definition: matrix.h:632
GENERIC_2D_ARRAY< BLOB_CHOICE_LIST * >::empty_
BLOB_CHOICE_LIST * empty_
Definition: matrix.h:505
tprintf
DLLSYM void tprintf(const char *format,...)
Definition: tprintf.cpp:34
MATRIX_COORD::row
int row
Definition: matrix.h:633
MATRIX::~MATRIX
~MATRIX() override
UNICHARSET::id_to_unichar
const char * id_to_unichar(UNICHAR_ID id) const
Definition: unicharset.cpp:290
BLOB_CHOICE::IsClassified
bool IsClassified() const
Definition: ratngs.h:133
BandTriMatrix< BLOB_CHOICE_LIST * >::dimension
int dimension() const
Definition: matrix.h:532
MATRIX::Classified
bool Classified(int col, int row, int wildcard_id) const
Definition: matrix.cpp:34