tesseract::BitVector Class Reference

#include <bitvector.h>

Public Member Functions
	BitVector ()
	BitVector (int length)
	BitVector (const BitVector &src)
BitVector &	operator= (const BitVector &src)
	~BitVector ()
void	Init (int length)
int	size () const
bool	Serialize (FILE *fp) const
bool	DeSerialize (bool swap, FILE *fp)
void	SetAllFalse ()
void	SetAllTrue ()
void	SetBit (int index)
void	ResetBit (int index)
void	SetValue (int index, bool value)
bool	At (int index) const
bool	operator[] (int index) const
int	NextSetBit (int prev_bit) const
int	NumSetBits () const
void	operator|= (const BitVector &other)
void	operator &= (const BitVector &other)
void	operator^= (const BitVector &other)
void	SetSubtract (const BitVector &v1, const BitVector &v2)

Static Public Attributes
static const uint8_t	lsb_index_ [256]
static const uint8_t	lsb_eroded_ [256]
static const int	hamming_table_ [256]

Detailed Description

Definition at line 33 of file bitvector.h.

Constructor & Destructor Documentation

BitVector() [1/3]

tesseract::BitVector::BitVector

(

)

Definition at line 110 of file bitvector.cpp.

: bit_size_(0), array_(nullptr) {}

BitVector() [2/3]

tesseract::BitVector::BitVector ( int  length )

explicit

Definition at line 112 of file bitvector.cpp.

                               : bit_size_(length) {
  array_ = new uint32_t[WordLength()];
  SetAllFalse();
}

BitVector() [3/3]

tesseract::BitVector::BitVector

(

const BitVector &

src

)

Definition at line 117 of file bitvector.cpp.

                                         : bit_size_(src.bit_size_) {
  array_ = new uint32_t[WordLength()];
  memcpy(array_, src.array_, ByteLength());
}

~BitVector()

tesseract::BitVector::~BitVector

(

)

Definition at line 128 of file bitvector.cpp.

                      {
  delete [] array_;
}

Member Function Documentation

At()

bool tesseract::BitVector::At ( int  index ) const

inline

Definition at line 84 of file bitvector.h.

                           {
    return (array_[WordIndex(index)] & BitMask(index)) != 0;
  }

DeSerialize()

bool tesseract::BitVector::DeSerialize	(	bool	swap,
		FILE *	fp
	)

Definition at line 147 of file bitvector.cpp.

                                               {
  uint32_t new_bit_size;
  if (!tesseract::DeSerialize(fp, &new_bit_size)) return false;
  if (swap) {
    ReverseN(&new_bit_size, sizeof(new_bit_size));
  }
  Alloc(new_bit_size);
  int wordlen = WordLength();
  if (!tesseract::DeSerialize(fp, &array_[0], wordlen)) return false;
  if (swap) {
    for (int i = 0; i < wordlen; ++i)
      ReverseN(&array_[i], sizeof(array_[i]));
  }
  return true;
}

Init()

void tesseract::BitVector::Init

(

int

length

)

Definition at line 133 of file bitvector.cpp.

                               {
  Alloc(length);
  SetAllFalse();
}

NextSetBit()

int tesseract::BitVector::NextSetBit

(

int

prev_bit

)

const

Definition at line 172 of file bitvector.cpp.

                                            {
  // Move on to the next bit.
  int next_bit = prev_bit + 1;
  if (next_bit >= bit_size_) return -1;
  // Check the remains of the word containing the next_bit first.
  int next_word = WordIndex(next_bit);
  int bit_index = next_word * kBitFactor;
  int word_end = bit_index + kBitFactor;
  uint32_t word = array_[next_word];
  uint8_t byte = word & 0xff;
  while (bit_index < word_end) {
    if (bit_index + 8 > next_bit && byte != 0) {
      while (bit_index + lsb_index_[byte] < next_bit && byte != 0)
        byte = lsb_eroded_[byte];
      if (byte != 0)
        return bit_index + lsb_index_[byte];
    }
    word >>= 8;
    bit_index += 8;
    byte = word & 0xff;
  }
  // next_word didn't contain a 1, so find the next word with set bit.
  ++next_word;
  int wordlen = WordLength();
  while (next_word < wordlen && (word = array_[next_word]) == 0) {
    ++next_word;
    bit_index += kBitFactor;
  }
  if (bit_index >= bit_size_) return -1;
  // Find the first non-zero byte within the word.
  while ((word & 0xff) == 0) {
    word >>= 8;
    bit_index += 8;
  }
  return bit_index + lsb_index_[word & 0xff];
}

NumSetBits()

int tesseract::BitVector::NumSetBits

(

)

const

Definition at line 210 of file bitvector.cpp.

                                {
  int wordlen = WordLength();
  int total_bits = 0;
  for (int w = 0; w < wordlen; ++w) {
    uint32_t word = array_[w];
    for (int i = 0; i < 4; ++i) {
      total_bits += hamming_table_[word & 0xff];
      word >>= 8;
    }
  }
  return total_bits;
}

operator &=()

void tesseract::BitVector::operator&=

(

const BitVector &

other

)

operator=()

BitVector & tesseract::BitVector::operator=

(

const BitVector &

src

)

Definition at line 122 of file bitvector.cpp.

                                                    {
  Alloc(src.bit_size_);
  memcpy(array_, src.array_, ByteLength());
  return *this;
}

operator[]()

bool tesseract::BitVector::operator[] ( int  index ) const

inline

Definition at line 87 of file bitvector.h.

                                   {
    return (array_[WordIndex(index)] & BitMask(index)) != 0;
  }

operator^=()

void tesseract::BitVector::operator^=

(

const BitVector &

other

)

Definition at line 237 of file bitvector.cpp.

                                                 {
  int length = std::min(WordLength(), other.WordLength());
  for (int w = 0; w < length; ++w)
    array_[w] ^= other.array_[w];
}

operator|=()

void tesseract::BitVector::operator|=

(

const BitVector &

other

)

Definition at line 225 of file bitvector.cpp.

                                                 {
  int length = std::min(WordLength(), other.WordLength());
  for (int w = 0; w < length; ++w)
    array_[w] |= other.array_[w];
}

ResetBit()

void tesseract::BitVector::ResetBit ( int  index )

inline

Definition at line 75 of file bitvector.h.

                           {
    array_[WordIndex(index)] &= ~BitMask(index);
  }

Serialize()

bool tesseract::BitVector::Serialize

(

FILE *

fp

)

const

Definition at line 139 of file bitvector.cpp.

                                        {
  if (!tesseract::Serialize(fp, &bit_size_)) return false;
  int wordlen = WordLength();
  return tesseract::Serialize(fp, &array_[0], wordlen);
}

SetAllFalse()

void tesseract::BitVector::SetAllFalse

(

)

Definition at line 163 of file bitvector.cpp.

                            {
  memset(array_, 0, ByteLength());
}

SetAllTrue()

void tesseract::BitVector::SetAllTrue

(

)

Definition at line 166 of file bitvector.cpp.

                           {
  memset(array_, ~0, ByteLength());
}

SetBit()

void tesseract::BitVector::SetBit ( int  index )

inline

Definition at line 72 of file bitvector.h.

                         {
    array_[WordIndex(index)] |= BitMask(index);
  }

SetSubtract()

void tesseract::BitVector::SetSubtract	(	const BitVector &	v1,
		const BitVector &	v2
	)

Definition at line 243 of file bitvector.cpp.

                                                                    {
  Alloc(v1.size());
  int length = std::min(v1.WordLength(), v2.WordLength());
  for (int w = 0; w < length; ++w)
    array_[w] = v1.array_[w] ^ (v1.array_[w] & v2.array_[w]);
  for (int w = WordLength() - 1; w >= length; --w)
    array_[w] = v1.array_[w];
}

SetValue()

void tesseract::BitVector::SetValue ( int  index, bool  value  )

inline

Definition at line 78 of file bitvector.h.

                                       {
    if (value)
      SetBit(index);
    else
      ResetBit(index);
  }

size()

int tesseract::BitVector::size ( ) const

inline

Definition at line 56 of file bitvector.h.

                   {
    return bit_size_;
  }

Member Data Documentation

hamming_table_

const int tesseract::BitVector::hamming_table_

static

Initial value:

= {
    0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4,
    1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5,
    1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5,
    2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
    1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5,
    2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
    2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
    3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,
    1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5,
    2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
    2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
    3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,
    2, 3, 3, 4, 3, 4, 4, 5, 3, 4, 4, 5, 4, 5, 5, 6,
    3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,
    3, 4, 4, 5, 4, 5, 5, 6, 4, 5, 5, 6, 5, 6, 6, 7,
    4, 5, 5, 6, 5, 6, 6, 7, 5, 6, 6, 7, 6, 7, 7, 8
}

Definition at line 43 of file bitvector.h.

lsb_eroded_

const uint8_t tesseract::BitVector::lsb_eroded_

static

Definition at line 41 of file bitvector.h.

lsb_index_

const uint8_t tesseract::BitVector::lsb_index_

static

Initial value:

= {
  255, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,
  4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,
  5, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,
  4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,
  6, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,
  4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,
  5, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,
  4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,
  7, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,
  4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,
  5, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,
  4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,
  6, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,
  4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,
  5, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0,
  4, 0, 1, 0, 2, 0, 1, 0, 3, 0, 1, 0, 2, 0, 1, 0
}

Definition at line 38 of file bitvector.h.

---

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

• /usr/src/tesseract-ocr.master/src/ccutil/bitvector.h
• /usr/src/tesseract-ocr.master/src/ccutil/bitvector.cpp