29 #ifndef TESSERACT_CCSTRUCT_MATRIX_H_ 30 #define TESSERACT_CCSTRUCT_MATRIX_H_ 39 class BLOB_CHOICE_LIST;
41 #define NOT_CLASSIFIED static_cast<BLOB_CHOICE_LIST*>(0) 61 int new_size = dim1 *
dim2;
87 int new_size = size1 * size2;
98 void Resize(
int size1,
int size2,
const T& empty) {
107 int new_size = size1 * size2;
108 T* new_array =
new T[new_size];
109 for (
int col = 0; col < size1; ++col) {
110 for (
int row = 0; row < size2; ++row) {
111 int old_index = col *
dim2() + row;
112 int new_index = col * size2 + row;
114 new_array[new_index] =
array_[old_index];
116 new_array[new_index] =
empty_;
131 for (
int i = 0; i < total_size; ++i)
139 if (fwrite(&
empty_,
sizeof(
empty_), 1, fp) != 1)
return false;
141 if (fwrite(
array_,
sizeof(*
array_), size, fp) != size)
return false;
157 if (fread(&
empty_,
sizeof(
empty_), 1, fp) != 1)
return false;
160 if (fread(
array_,
sizeof(*
array_), size, fp) != size)
return false;
162 for (
int i = 0; i <
size; ++i)
179 if (!
empty_.Serialize(fp))
return false;
181 for (
int i = 0; i <
size; ++i) {
192 if (!
empty_.DeSerialize(swap, fp))
return false;
194 for (
int i = 0; i <
size; ++i) {
210 virtual int index(
int column,
int row)
const {
211 return (column *
dim2_ + row);
218 void put(
int column,
int row,
const T& thing) {
226 T
get(
int column,
int row)
const {
250 for (
int i = 0; i <
size; ++i) {
254 for (
int x = 0; x <
dim1_; x++) {
255 for (
int y = 0; y <
dim2_; y++) {
256 (*this)(x, y) += addend(x, y);
266 for (
int i = 0; i <
size; ++i) {
270 for (
int x = 0; x <
dim1_; x++) {
271 for (
int y = 0; y <
dim2_; y++) {
272 (*this)(x, y) -= minuend(x, y);
280 for (
int i = 0; i <
size; ++i) {
287 for (
int i = 0; i <
size; ++i) {
292 void Clip(
const T& rangemin,
const T& rangemax) {
294 for (
int i = 0; i <
size; ++i) {
302 for (
int i = 0; i <
size; ++i) {
303 const T& value =
array_[i];
304 if (value < rangemin || rangemax < value)
312 if (size <= 0)
return 0.0;
315 for (
int i = 0; i <
size; ++i) {
321 for (
int i = 0; i <
size; ++i) {
322 double normed =
array_[i] - mean;
324 sd += normed * normed;
326 sd = sqrt(sd / size);
329 for (
int i = 0; i <
size; ++i) {
339 if (size <= 0)
return empty_;
342 for (
int i = 1; i <
size; ++i) {
343 const T& value =
array_[i];
344 if (value > max_value) max_value = value;
352 if (size <= 0)
return empty_;
354 T max_abs =
static_cast<T
>(0);
355 for (
int i = 0; i <
size; ++i) {
356 T value =
static_cast<T
>(fabs(
array_[i]));
357 if (value > max_abs) max_abs = value;
365 for (
int i = 0; i <
size; ++i) {
374 for (
int i = 0; i <
size; ++i) {
381 for (
int i = 0; i <
size; ++i) {
412 int max_d =
MAX(src_dim, dest_dim);
413 int min_d =
MIN(src_dim, dest_dim);
422 int num_replicas = 1, move_size = 1, src_step = 1;
423 for (
int d = 0; d < min_d; ++d) num_replicas *= dims[d];
424 for (
int d = max_d + 1; d < num_dims; ++d) move_size *= dims[d];
425 for (
int d = src_dim + 1; d < num_dims; ++d) src_step *= dims[d];
426 if (src_dim > dest_dim) src_step *= dims[src_dim];
429 int wrap_size = move_size;
430 for (
int d = min_d; d <= max_d; ++d) wrap_size *= dims[d];
435 for (
int replica = 0; replica < num_replicas; ++replica) {
436 for (
int start = 0; start < src_step; start += move_size) {
437 for (
int pos = start; pos < wrap_size; pos += src_step) {
438 memcpy(dest, src + pos,
sizeof(*dest) * move_size);
449 for (
int i = 0; i <
size; ++i) {
450 T matrix_cell =
array_[i];
451 if (matrix_cell !=
empty_)
460 if (fwrite(&size,
sizeof(size), 1, fp) != 1)
return false;
462 if (fwrite(&size,
sizeof(size), 1, fp) != 1)
return false;
467 if (fp->
FWrite(&size,
sizeof(size), 1) != 1)
return false;
469 if (fp->
FWrite(&size,
sizeof(size), 1) != 1)
return false;
476 if (fread(&size1,
sizeof(size1), 1, fp) != 1)
return false;
477 if (fread(&size2,
sizeof(size2), 1, fp) != 1)
return false;
487 if (fp->
FReadEndian(&size1,
sizeof(size1), 1) != 1)
return false;
488 if (fp->
FReadEndian(&size2,
sizeof(size2), 1) != 1)
return false;
528 virtual int index(
int column,
int row)
const {
531 return column * this->dim2_ + row - column;
541 T* new_array =
new T[new_dim1 * new_dim2];
542 for (
int col = 0; col < new_dim1; ++col) {
543 for (
int j = 0; j < new_dim2; ++j) {
544 int new_index = col * new_dim2 + j;
546 new_array[new_index] = this->
get(col, col + j);
547 }
else if (col >= this->
dim1_ && j < array2->dim2_) {
548 new_array[new_index] = array2->
get(col - this->
dim1_,
549 col - this->
dim1_ + j);
552 new_array[new_index] = this->
empty_;
558 this->
dim1_ = new_dim1;
559 this->
dim2_ = new_dim2;
569 bool Classified(
int col,
int row,
int wildcard_id)
const;
573 void IncreaseBandSize(
int bandwidth);
580 MATRIX* ConsumeAndMakeBigger(
int ind);
588 void print(
const UNICHARSET &unicharset)
const;
602 return 0 <= col && col < m.
dimension() &&
614 if (col > ind) ++col;
615 if (row >= ind) ++row;
626 #endif // TESSERACT_CCSTRUCT_MATRIX_H_
void AdaGradScaling(const GENERIC_2D_ARRAY< T > &sqsum, int num_samples)
void ResizeWithCopy(int size1, int size2)
bool DeSerializeSize(bool swap, FILE *fp)
void Clip(const T &rangemin, const T &rangemax)
void MapForSplit(int ind)
T * operator[](int column)
bool SerializeSize(FILE *fp) const
void AttachOnCorner(BandTriMatrix< T > *array2)
void SumSquares(const GENERIC_2D_ARRAY< T > &src)
void operator*=(const T &factor)
bool DeSerializeClasses(bool swap, FILE *fp)
bool WithinBounds(const T &rangemin, const T &rangemax) const
void operator+=(const GENERIC_2D_ARRAY< T > &addend)
GENERIC_2D_ARRAY(int dim1, int dim2, const T &empty, T *array)
inT16 x() const
access function
MATRIX_COORD(int c, int r)
void Resize(int size1, int size2, const T &empty)
int FReadEndian(void *buffer, int size, int count)
bool Serialize(tesseract::TFile *fp) const
virtual int num_elements() const
const T & operator()(int column, int row) const
BandTriMatrix(int dim1, int dim2, const T &empty)
GENERIC_2D_ARRAY(int dim1, int dim2, const T &empty)
void operator+=(const T &addend)
static void Delete(void *arg)
bool SerializeClasses(FILE *fp) const
bool DeSerializeSize(tesseract::TFile *fp)
bool Serialize(FILE *fp) const
virtual ~GENERIC_2D_ARRAY()
bool DeSerialize(bool swap, FILE *fp)
inT16 y() const
access_function
T ClipToRange(const T &x, const T &lower_bound, const T &upper_bound)
void operator-=(const GENERIC_2D_ARRAY< T > &minuend)
virtual int index(int column, int row) const
bool DeSerialize(tesseract::TFile *fp)
int FWrite(const void *buffer, int size, int count)
virtual int index(int column, int row) const
void ResizeNoInit(int size1, int size2)
void RotatingTranspose(const int *dims, int num_dims, int src_dim, int dest_dim, GENERIC_2D_ARRAY< T > *result) const
bool SerializeSize(tesseract::TFile *fp) const
void put(ICOORD pos, const T &thing)
const T * operator[](int column) const
bool Valid(const MATRIX &m) const
MATRIX(int dimension, int bandwidth)
void delete_matrix_pointers()
T & operator()(int column, int row)
tesseract::KDPairInc< float, MATRIX_COORD > MatrixCoordPair
void operator=(const GENERIC_2D_ARRAY< T > &src)
GENERIC_2D_ARRAY(const GENERIC_2D_ARRAY< T > &src)
void AssertFinite() const
void put(int column, int row, const T &thing)
void ReverseN(void *ptr, int num_bytes)