#include <matrix.h>

Inheritance diagram for MATRIX:

Public Member Functions
	MATRIX (int dimension, int bandwidth)

	~MATRIX () override

bool	Classified (int col, int row, int wildcard_id) const

void	IncreaseBandSize (int bandwidth)

MATRIX *	ConsumeAndMakeBigger (int ind)

MATRIX *	DeepCopy () const

void	print (const UNICHARSET &unicharset) const

Public Member Functions inherited from BandTriMatrix< BLOB_CHOICE_LIST * >
	BandTriMatrix (int dim1, int dim2, const BLOB_CHOICE_LIST * &empty)

int	dimension () const

int	bandwidth () const

int	index (int column, int row) const override

void	AttachOnCorner (BandTriMatrix< BLOB_CHOICE_LIST * > *array2)

Public Member Functions inherited from GENERIC_2D_ARRAY< BLOB_CHOICE_LIST * >
	GENERIC_2D_ARRAY (int dim1, int dim2, const BLOB_CHOICE_LIST * &empty, BLOB_CHOICE_LIST * *array)

	GENERIC_2D_ARRAY (int dim1, int dim2, const BLOB_CHOICE_LIST * &empty)

	GENERIC_2D_ARRAY ()

	GENERIC_2D_ARRAY (const GENERIC_2D_ARRAY< BLOB_CHOICE_LIST * > &src)

virtual	~GENERIC_2D_ARRAY ()

void	operator= (const GENERIC_2D_ARRAY< BLOB_CHOICE_LIST * > &src)

void	ResizeNoInit (int size1, int size2, int pad=0)

void	Resize (int size1, int size2, const BLOB_CHOICE_LIST * &empty)

void	ResizeWithCopy (int size1, int size2)

void	Clear ()

bool	Serialize (FILE *fp) const

bool	Serialize (tesseract::TFile *fp) const

bool	DeSerialize (bool swap, FILE *fp)

bool	DeSerialize (tesseract::TFile *fp)

bool	SerializeClasses (FILE *fp) const

bool	DeSerializeClasses (bool swap, FILE *fp)

int	dim1 () const

int	dim2 () const

virtual int	num_elements () const

void	put (ICOORD pos, const BLOB_CHOICE_LIST * &thing)

void	put (int column, int row, const BLOB_CHOICE_LIST * &thing)

BLOB_CHOICE_LIST *	get (ICOORD pos) const

BLOB_CHOICE_LIST *	get (int column, int row) const

const BLOB_CHOICE_LIST * &	operator() (int column, int row) const

BLOB_CHOICE_LIST * &	operator() (int column, int row)

BLOB_CHOICE_LIST * *	operator[] (int column)

const BLOB_CHOICE_LIST * *	operator[] (int column) const

void	operator+= (const GENERIC_2D_ARRAY< BLOB_CHOICE_LIST * > &addend)

void	operator+= (const BLOB_CHOICE_LIST * &addend)

void	operator-= (const GENERIC_2D_ARRAY< BLOB_CHOICE_LIST * > &minuend)

void	operator= (const BLOB_CHOICE_LIST &factor)

void	Clip (const BLOB_CHOICE_LIST * &rangemin, const BLOB_CHOICE_LIST * &rangemax)

bool	WithinBounds (const BLOB_CHOICE_LIST * &rangemin, const BLOB_CHOICE_LIST * &rangemax) const

double	Normalize ()

BLOB_CHOICE_LIST *	Max () const

BLOB_CHOICE_LIST *	MaxAbs () const

void	SumSquares (const GENERIC_2D_ARRAY< BLOB_CHOICE_LIST * > &src, const BLOB_CHOICE_LIST * &decay_factor)

void	AdamUpdate (const GENERIC_2D_ARRAY< BLOB_CHOICE_LIST * > &sum, const GENERIC_2D_ARRAY< BLOB_CHOICE_LIST * > &sqsum, const BLOB_CHOICE_LIST * &epsilon)

void	AssertFinite () const

void	RotatingTranspose (const int dims, int num_dims, int src_dim, int dest_dim, GENERIC_2D_ARRAY< BLOB_CHOICE_LIST > *result) const

void	delete_matrix_pointers ()

Additional Inherited Members
Protected Member Functions inherited from GENERIC_2D_ARRAY< BLOB_CHOICE_LIST * >
bool	SerializeSize (FILE *fp) const

bool	SerializeSize (tesseract::TFile *fp) const

bool	DeSerializeSize (bool swap, FILE *fp)

bool	DeSerializeSize (tesseract::TFile *fp)

Protected Attributes inherited from GENERIC_2D_ARRAY< BLOB_CHOICE_LIST * >
BLOB_CHOICE_LIST * *	array_

BLOB_CHOICE_LIST *	empty_

int	dim1_

int	dim2_

int	size_allocated_

Detailed Description

Definition at line 574 of file matrix.h.

Constructor & Destructor Documentation

◆ MATRIX()

MATRIX::MATRIX	(	int	dimension,
		int	bandwidth
	)

inline

Definition at line 576 of file matrix.h.

576 :

577 MATRIX(int dimension, int bandwidth)

◆ ~MATRIX()

MATRIX::~MATRIX ( )

overridedefault

Member Function Documentation

◆ Classified()

bool MATRIX::Classified	(	int	col,
		int	row,
		int	wildcard_id
	)		const

Definition at line 34 of file matrix.cpp.

                                                                {
   if (get(col, row) == NOT_CLASSIFIED) return false;
   BLOB_CHOICE_IT b_it(get(col, row));
   for (b_it.mark_cycle_pt(); !b_it.cycled_list(); b_it.forward()) {
     BLOB_CHOICE* choice = b_it.data();
     if (choice->IsClassified())
       return true;
   }
   return false;

◆ ConsumeAndMakeBigger()

MATRIX * MATRIX::ConsumeAndMakeBigger ( int ind )

Definition at line 56 of file matrix.cpp.

                                             {
   int dim = dimension();
   int band_width = bandwidth();
   // Check to see if bandwidth needs expanding.
   for (int col = ind; col >= 0 && col > ind - band_width; --col) {
     if (array_[col * band_width + band_width - 1] != empty_) {
       ++band_width;
       break;
     }
   }
   auto* result = new MATRIX(dim + 1, band_width);
  
   for (int col = 0; col < dim; ++col) {
     for (int row = col; row < dim && row < col + bandwidth(); ++row) {
       MATRIX_COORD coord(col, row);
       coord.MapForSplit(ind);
       BLOB_CHOICE_LIST* choices = get(col, row);
       if (choices != nullptr) {
         // Correct matrix location on each choice.
         BLOB_CHOICE_IT bc_it(choices);
         for (bc_it.mark_cycle_pt(); !bc_it.cycled_list(); bc_it.forward()) {
           BLOB_CHOICE* choice = bc_it.data();
           choice->set_matrix_cell(coord.col, coord.row);
         }
         ASSERT_HOST(coord.Valid(*result));
         result->put(coord.col, coord.row, choices);
       }
     }
   }
   delete this;
   return result;

◆ DeepCopy()

MATRIX * MATRIX::DeepCopy ( ) const

Definition at line 92 of file matrix.cpp.

                                {
   int dim = dimension();
   int band_width = bandwidth();
   auto* result = new MATRIX(dim, band_width);
   for (int col = 0; col < dim; ++col) {
     for (int row = col; row < dim && row < col + band_width; ++row) {
       BLOB_CHOICE_LIST* choices = get(col, row);
       if (choices != nullptr) {
         auto* copy_choices = new BLOB_CHOICE_LIST;
         copy_choices->deep_copy(choices, &BLOB_CHOICE::deep_copy);
         result->put(col, row, copy_choices);
       }
     }
   }
   return result;

◆ IncreaseBandSize()

void MATRIX::IncreaseBandSize ( int bandwidth )

Definition at line 47 of file matrix.cpp.

48 {

49 ResizeWithCopy(dimension(), bandwidth);

◆ print()

void MATRIX::print ( const UNICHARSET & unicharset ) const

Definition at line 110 of file matrix.cpp.

                                                      {
   tprintf("Ratings Matrix (top 3 choices)\n");
   int dim = dimension();
   int band_width = bandwidth();
   int row, col;
   for (col = 0; col < dim; ++col) {
     for (row = col; row < dim && row < col + band_width; ++row) {
       BLOB_CHOICE_LIST *rating = this->get(col, row);
       if (rating == NOT_CLASSIFIED) continue;
       BLOB_CHOICE_IT b_it(rating);
       tprintf("col=%d row=%d ", col, row);
       for (b_it.mark_cycle_pt(); !b_it.cycled_list(); b_it.forward()) {
         tprintf("%s rat=%g cert=%g " ,
                 unicharset.id_to_unichar(b_it.data()->unichar_id()),
                 b_it.data()->rating(), b_it.data()->certainty());
       }
       tprintf("\n");
     }
     tprintf("\n");
   }
   tprintf("\n");
   for (col = 0; col < dim; ++col) tprintf("\t%d", col);
   tprintf("\n");
   for (row = 0; row < dim; ++row) {
     for (col = 0; col <= row; ++col) {
       if (col == 0) tprintf("%d\t", row);
       if (row >= col + band_width) {
         tprintf(" \t");
         continue;
       }
       BLOB_CHOICE_LIST *rating = this->get(col, row);
       if (rating != NOT_CLASSIFIED) {
         BLOB_CHOICE_IT b_it(rating);
         int counter = 0;
         for (b_it.mark_cycle_pt(); !b_it.cycled_list(); b_it.forward()) {
           tprintf("%s ",
                   unicharset.id_to_unichar(b_it.data()->unichar_id()));
           ++counter;
           if (counter == 3) break;
         }
         tprintf("\t");
       } else {
         tprintf(" \t");
       }
     }
     tprintf("\n");
   }

The documentation for this class was generated from the following files:

/tesseract/src/ccstruct/matrix.h
/tesseract/src/ccstruct/matrix.cpp

Public Member Functions

Additional Inherited Members