tesseract::DocumentData Class Reference

#include <imagedata.h>

Public Member Functions
TESS_API	DocumentData (const std::string &name)
TESS_API	~DocumentData ()
TESS_API bool	LoadDocument (const char *filename, int start_page, int64_t max_memory, FileReader reader)
void	SetDocument (const char *filename, int64_t max_memory, FileReader reader)
TESS_API bool	SaveDocument (const char *filename, FileWriter writer)
TESS_API void	AddPageToDocument (ImageData *page)
const std::string &	document_name () const
int	NumPages () const
size_t	PagesSize () const
int64_t	memory_used () const
void	LoadPageInBackground (int index)
TESS_API const ImageData *	GetPage (int index)
bool	IsPageAvailable (int index, ImageData **page)
ImageData *	TakePage (int index)
bool	IsCached () const
int64_t	UnCache ()
void	Shuffle ()

Detailed Description

Definition at line 169 of file imagedata.h.

Constructor & Destructor Documentation

DocumentData()

tesseract::DocumentData::DocumentData ( const std::string &  name )

explicit

Definition at line 381 of file imagedata.cpp.

    : document_name_(name),
      pages_offset_(-1),
      total_pages_(-1),
      memory_used_(0),
      max_memory_(0),
      reader_(nullptr) {}

~DocumentData()

tesseract::DocumentData::~DocumentData

(

)

Definition at line 389 of file imagedata.cpp.

                            {
  if (thread.joinable()) {
    thread.join();
  }
  std::lock_guard<std::mutex> lock_p(pages_mutex_);
  std::lock_guard<std::mutex> lock_g(general_mutex_);
  for (auto data : pages_) {
    delete data;
  }
}

Member Function Documentation

AddPageToDocument()

void tesseract::DocumentData::AddPageToDocument

(

ImageData *

page

)

Definition at line 433 of file imagedata.cpp.

                                                    {
  std::lock_guard<std::mutex> lock(pages_mutex_);
  pages_.push_back(page);
  set_memory_used(memory_used() + page->MemoryUsed());
}

document_name()

const std::string & tesseract::DocumentData::document_name ( ) const

inline

Definition at line 190 of file imagedata.h.

                                         {
    std::lock_guard<std::mutex> lock(general_mutex_);
    return document_name_;
  }

GetPage()

const ImageData * tesseract::DocumentData::GetPage

(

int

index

)

Definition at line 467 of file imagedata.cpp.

                                                {
  ImageData *page = nullptr;
  while (!IsPageAvailable(index, &page)) {
    // If there is no background load scheduled, schedule one now.
    pages_mutex_.lock();
    bool needs_loading = pages_offset_ != index;
    pages_mutex_.unlock();
    if (needs_loading) {
      LoadPageInBackground(index);
    }
    // We can't directly load the page, or the background load will delete it
    // while the caller is using it, so give it a chance to work.
    std::this_thread::yield();
  }
  return page;
}

IsCached()

bool tesseract::DocumentData::IsCached ( ) const

inline

Definition at line 234 of file imagedata.h.

                        {
    return NumPages() >= 0;
  }

IsPageAvailable()

bool tesseract::DocumentData::IsPageAvailable	(	int	index,
		ImageData **	page
	)

Definition at line 487 of file imagedata.cpp.

                                                              {
  std::lock_guard<std::mutex> lock(pages_mutex_);
  int num_pages = NumPages();
  if (num_pages == 0 || index < 0) {
    *page = nullptr; // Empty Document.
    return true;
  }
  if (num_pages > 0) {
    index = Modulo(index, num_pages);
    if (pages_offset_ <= index &&
        static_cast<unsigned>(index) < pages_offset_ + pages_.size()) {
      *page = pages_[index - pages_offset_]; // Page is available already.
      return true;
    }
  }
  return false;
}

LoadDocument()

bool tesseract::DocumentData::LoadDocument	(	const char *	filename,
		int	start_page,
		int64_t	max_memory,
		FileReader	reader
	)

Definition at line 402 of file imagedata.cpp.

                                                                       {
  SetDocument(filename, max_memory, reader);
  pages_offset_ = start_page;
  return ReCachePages();
}

LoadPageInBackground()

void tesseract::DocumentData::LoadPageInBackground

(

int

index

)

Definition at line 441 of file imagedata.cpp.

                                                 {
  ImageData *page = nullptr;
  if (IsPageAvailable(index, &page)) {
    return;
  }
  {
    std::lock_guard<std::mutex> lock(pages_mutex_);
    if (pages_offset_ == index) {
      return;
    }
    pages_offset_ = index;
    for (auto page : pages_) {
      delete page;
    }
    pages_.clear();
  }
  if (thread.joinable()) {
    thread.join();
  }
  // Don't run next statement asynchronously because that would
  // create too many threads on Linux (see issue #3111).
  ReCachePages();
}

memory_used()

int64_t tesseract::DocumentData::memory_used ( ) const

inline

Definition at line 201 of file imagedata.h.

                              {
    std::lock_guard<std::mutex> lock(general_mutex_);
    return memory_used_;
  }

NumPages()

int tesseract::DocumentData::NumPages ( ) const

inline

Definition at line 194 of file imagedata.h.

                       {
    std::lock_guard<std::mutex> lock(general_mutex_);
    return total_pages_;
  }

PagesSize()

size_t tesseract::DocumentData::PagesSize ( ) const

inline

Definition at line 198 of file imagedata.h.

                           {
    return pages_.size();
  }

SaveDocument()

bool tesseract::DocumentData::SaveDocument	(	const char *	filename,
		FileWriter	writer
	)

Definition at line 421 of file imagedata.cpp.

                                                                       {
  std::lock_guard<std::mutex> lock(pages_mutex_);
  TFile fp;
  fp.OpenWrite(nullptr);
  if (!fp.Serialize(pages_) || !fp.CloseWrite(filename, writer)) {
    tprintf("Serialize failed: %s\n", filename);
    return false;
  }
  return true;
}

SetDocument()

void tesseract::DocumentData::SetDocument	(	const char *	filename,
		int64_t	max_memory,
		FileReader	reader
	)

Definition at line 410 of file imagedata.cpp.

                                                  {
  std::lock_guard<std::mutex> lock_p(pages_mutex_);
  std::lock_guard<std::mutex> lock(general_mutex_);
  document_name_ = filename;
  pages_offset_ = -1;
  max_memory_ = max_memory;
  reader_ = reader;
}

Shuffle()

void tesseract::DocumentData::Shuffle

(

)

Definition at line 523 of file imagedata.cpp.

                           {
  TRand random;
  // Different documents get shuffled differently, but the same for the same
  // name.
  random.set_seed(document_name_.c_str());
  int num_pages = pages_.size();
  // Execute one random swap for each page in the document.
  for (int i = 0; i < num_pages; ++i) {
    int src = random.IntRand() % num_pages;
    int dest = random.IntRand() % num_pages;
    std::swap(pages_[src], pages_[dest]);
  }
}

TakePage()

ImageData * tesseract::DocumentData::TakePage ( int  index )

inline

Definition at line 226 of file imagedata.h.

                                 {
    std::lock_guard<std::mutex> lock(pages_mutex_);
    ImageData *page = pages_[index];
    pages_[index] = nullptr;
    return page;
  }

UnCache()

int64_t tesseract::DocumentData::UnCache

(

)

Definition at line 507 of file imagedata.cpp.

                              {
  std::lock_guard<std::mutex> lock(pages_mutex_);
  int64_t memory_saved = memory_used();
  for (auto page : pages_) {
    delete page;
  }
  pages_.clear();
  pages_offset_ = -1;
  set_total_pages(-1);
  set_memory_used(0);
  tprintf("Unloaded document %s, saving %" PRId64 " memory\n",
          document_name_.c_str(), memory_saved);
  return memory_saved;
}

---

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

• /media/home/debian/src/github/tesseract-ocr/tesseract/src/ccstruct/imagedata.h
• /media/home/debian/src/github/tesseract-ocr/tesseract/src/ccstruct/imagedata.cpp