GlyphFeatures.h

# ifndef Conjecture_GlyphFeatures_h
# define Conjecture_GlyphFeatures_h Conjecture_GlyphFeatures_h

// Insert SVN header substitution variable here
// Created 2006/06/10 by wade
// Class Champion: Unassigned

# include "Root.h"  // parent

// PRIVATE - will be removed later
# include <vector>

namespace Conjecture {
    class Glyph;
    
    class GlyphFeatures : public Root {
      public:
        // Types

        typedef float Confidence;

        typedef enum { 
            // CODE TANGLE #2: The ordinal values assigned to these
            // are tangled with the _LineTypes field init in the .cc
            LTUnknown = 0,
            Base      = 1, 
            Ascender  = 2, 
            Descender = 3, 
            Total     = 4,
            // this should always be last one
            __LTSIZE  = 5,
        } LineType;

        typedef enum {
            // CODE TANGLE #2: The ordinal values assigned to these
            // are tangled with the _Variants field init in the .cc!
            Center     = 1,
            Top        = 2,
            Bottom     = 3,
            Left       = 4,
            Right      = 5,
            Dominant   = 8,
            Recessive  = 9,
            HalfLine   = 10,
            // Undef should always be the highest ordinal value
            Undef      = 11,
        } Variant;

      private:
        static const char* _LineTypes[__LTSIZE+1];
        static std::string LineTypeStr(LineType v);

        static const char* _Variants[Undef+1];
        static std::string VariantStr(Variant v);

        typedef std::vector<Variant> VariantSet;
        typedef std::pair<Variant,Variant> Variant2;
        typedef std::vector<Variant2> Variant2Set;

      public:
        // Constructors/Destructors
        GlyphFeatures(LineType lineType = LTUnknown);

        GlyphFeatures(wchar_t unicode, LineType lineType, const std::string& spec);

        void init(wchar_t unicode, LineType lineType);
        
        // Accessors
        inline wchar_t unicode()          const { return this->_unicode; }
        inline bool xdisconnect()         const { return this->_xdisconnect; }
        inline bool ydisconnect()         const { return this->_ydisconnect; }
        inline float MostOfLength()       const { return this->_MostOfLength; }
        inline const LineType& lineType() const { return this->_lineType; }
        
        // Interface
        void addHorizontal(Variant position, Variant length);
        void addVertical(Variant position, Variant length);
        void addHole(Variant position);
        void addCup(Variant position);

        Variant hasHorizontal(Variant position) const;
        Variant hasVertical(Variant position) const;
        bool hasHole(Variant position) const;
        bool hasCup(Variant position) const;

        std::ostream& print(std::ostream& os = std::cout, const std::string& indent = "") const;

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

        Confidence matches(const GlyphFeatures& target) const;
        
      protected:
        // Accessors
        inline void            unicodeIs(const wchar_t & unicode)      { this->_unicode = unicode;           }
        inline void            xdisconnectIs(const bool & xdisconnect) { this->_xdisconnect = xdisconnect;   }
        inline void            ydisconnectIs(const bool & ydisconnect) { this->_ydisconnect = ydisconnect;   }
        inline void            lineTypeIs(const LineType & lineType)   { this->_lineType = lineType;         }
        inline void            MostOfLengthIs(float MostOfLength)      { this->_MostOfLength = MostOfLength; }

        // Placed at protected scope so as not to expose Variant[2]Set to public scope
        inline const Variant2Set & horizontal() const { return this->_horizontal; }
        inline const Variant2Set & vertical() const { return this->_vertical; }
        inline const VariantSet  & holes() const { return this->_holes; }
        inline const VariantSet  & cups() const { return this->_cups; }

        inline wchar_t &       unicodeRef()     { return this->_unicode; }
        inline bool &          xdisconnectRef() { return this->_xdisconnect; }
        inline bool &          ydisconnectRef() { return this->_ydisconnect; }
        inline LineType &      lineTypeRef()    { return this->_lineType;    }
        inline Variant2Set &   horizontalRef()  { return this->_horizontal;  }
        inline Variant2Set &   verticalRef()    { return this->_vertical;    }
        inline VariantSet &    holesRef()       { return this->_holes;       }
        inline VariantSet &    cupsRef()        { return this->_cups;        }
        
        // Methods
        Confidence lineMatch(Variant mine, Variant target) const;
        
      private: 
        // Accessors
        inline float &         MostOfLengthRef() { return this->_MostOfLength; }
        
        // Methods 
        
        // State
        wchar_t         _unicode;
        bool            _xdisconnect;
        bool            _ydisconnect;

        LineType               _lineType;

        Variant2Set            _horizontal;
        Variant2Set            _vertical;
        VariantSet             _holes;
        VariantSet             _cups;

        static float           _MostOfLength;
    };
}

# endif // Conjecture_GlyphFeatures_h

---