Glyph.h

# ifndef Conjecture_Glyph_h
# define Conjecture_Glyph_h Conjecture_Glyph_h

// C Dependencies
//  - FUTURE FIX: these headers are only needed while the C++ interface
//    relies on the underlying C code.

# include "pnm.h"
# include "gocr.h"  // Box

// C++ Dependencies
# include <vector>
# include "Element.h"
# include "ImageArgs.h"
# include "GlyphFeatures.h"  // LineType, has-a

namespace Conjecture {

# define GlyphLoopStart(self, glyph) \
{ \
    std::vector<Glyph*> __glyphs; \
    (self)->allGlyphs(__glyphs); \
    for (std::vector<Glyph*>::iterator __it = __glyphs.begin(); __it != __glyphs.end(); ++__it) { \
      Glyph* glyph = *__it;

# define ConstGlyphLoopStart(self, glyph) \
{ \
    std::vector<const Glyph*> __glyphs; \
    (self)->allGlyphs(__glyphs); \
    for (std::vector<const Glyph*>::const_iterator __it = __glyphs.begin(); __it != __glyphs.end(); ++__it) { \
      const Glyph* glyph = *__it;

# define GlyphLoopEnd \
    } \
}

  class Glyph : public Element {
  public:
    // ********
    // Types
    class Char {
      public:
      Char(wchar_t c,int w) { this->c = c; this->weight = w; }
      wchar_t c;
      int weight;
    };

    // *******
    // Methods

    Glyph(Element* parent = NULL, void* internal = NULL);

    Glyph(Glyph* glyph);

    virtual Glyph* asGlyph()             { return this; }
    virtual const Glyph* asGlyph() const { return this; }

    inline void setUnicode(wchar_t unicode) { this->unicodeIs(unicode); }

    virtual void printSummary(std::ostream& os = std::cerr, const std::string& indent = "", int index = -1) const;

    void addChar(const Glyph::Char& chr);

    GlyphFeatures::LineType lineType() const;

    // ---------------------------------------------------------------
    // DEBUGGING METHODS

    virtual void writeText(std::ostream& os) const;

    static void test(int argc = 0, const char* argv[] = NULL);

    wchar_t unicode() const { return this->_unicode; }
    const std::vector<Char>& charset() const { return this->_charset; }

    // Accessors
    inline int  best() const { return this->_best; }
    virtual int type() const { return Type; }
    // we provide 'box' publically because it is temporary - need to
    // remove it anyway, and Page often needs the Box within Glyph.
    inline const Box* box() const { return this->_box; }
    inline void boxIs(Box* box)   { this->_box = box; }
    inline Box* & boxRef()        { return this->_box; }

  protected:
    // ********
    // Methods

    // ********
    // Accessors
    inline void bestIs(const int & best) { this->_best = best; }
    inline int & bestRef() { return this->_best; }
    wchar_t& unicodeRef() { return this->_unicode; }
    void unicodeIs(wchar_t unicode) { this->_unicode = unicode; }
    std::vector<Char>& charset() { return this->_charset; }

  private:
    // ********
    // Methods

    // ********
    // Accessors

    // ********
    // State
    wchar_t           _unicode;

    static const ElementType Type = ELEMENT_GLYPH;

    // Are any of these really necessary?
    Box*              _box;   // old gocr data-structure
    int               _best; // inex into _charset (best match)
    std::vector<Char> _charset;
  };
};

# endif // Conjecture_Glyph_h

---