OptIm.h

# ifndef Conjecture_OptIm_h
# define Conjecture_OptIm_h Conjecture_OptIm_h

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

# include <vector>
# include "Root.h"  // parent
# include "PixelLine.h" // has-a

# include "GlyphFeatures.h"  // Variant


namespace Conjecture {
    class Image;
    class ImageArgs;
    
    class OptIm : public Root {
        friend class PixFilt;

      public:
        // Types
        typedef std::vector<PixelLine> PixelMatrix;

        // Constructors/Destructors
        OptIm(const std::vector<unsigned int>& rows, u1 width = PixelLine::MaxPixels);
        OptIm(const Image* image, const ImageArgs& config);
        
        //static u1 BitImage(const Image* image, const ImageArgs& args, std::vector<u4>& rows);

        // Accessors
        inline const u1 & width() const { return this->_width; }
        inline const PixelMatrix & cols() const { return this->_cols; }
        inline const PixelMatrix & rows() const { return this->_rows; }
        
        // Input/Output
        
        // Interface
        void updateMeta();

        // FUTURE FIX: These methods currently return 0 if the
        // instance isn't updated. Should we just be updateding the image
        // automatically? Or should we throw asserts that are removed
        // in production code?

        int rblack(u1 i) const { return (this->updated() ? this->rows()[i].black() : 0); }

        int rholes(u1 i) const { return (this->updated() ? this->rows()[i].holes() : 0); }

        int cblack(u1 i) const { return (this->updated() ? this->cols()[i].black() : 0); }

        int choles(u1 i) const { return (this->updated() ? this->cols()[i].holes() : 0); }

        u1 height() const { return this->rows().size(); } 

        inline bool get(u2 x, u2 y) const { int w = this->width(); return this->rows()[y].get(w-1-x); }

        inline std::string str(char on = '#', char off = '.') const { return this->str("",0,on,off); }

        std::string str(const std::string& title, int valign = 0, char on = '#', char off = '.') const;

        bool crop(int level = 0);
        bool crop(int topthick, int bottomthick, int leftthick, int rightthick);
        bool crop(int topthick, int bottomthick, int leftthick, int rightthick, int& topref, int& bottomref, int& leftref, int& rightref);

        void identifyFeatures(GlyphFeatures& features);
        
        inline const PixelLine& row(int i) const {
            if ( i < 0 ) { i += this->height(); }
            return this->rows()[i];
        }

        bool removeBottomSerifs();

        bool removeTopSerifs();

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

        inline void print(ostream& os = cout) const { os << this->str() << endl; }
        
      protected:
        // Accessors
        inline bool  updated() const                                 { return this->_updated; }
        inline void  updatedIs(const bool & updated)                   { this->_updated = updated; }
        inline void  widthIs(const u1 & width)                     { this->_width = width; }
        inline void  colsIs(const PixelMatrix & cols) { this->_cols  = cols;  }
        inline void  rowsIs(const PixelMatrix & rows) { this->_rows  = rows;  }
        
        // Methods 
        std::string rawstr(const PixelMatrix& vec, char on = '1', char off = '0', unsigned char size = PixelLine::MaxPixels) const;

        * Obtain a specific writeable PixelLine by row. Negative
        * indexes are relative to the end (-1 is last index, -2 is
        * second last, etc.)
        inline PixelLine& row(int i) {
            if ( i < 0 ) { i += this->height(); }
            return this->rowsRef()[i];
        }

        GlyphFeatures::Variant analyzeLines(u1 min, u2 max, const PixelMatrix& matrix, u1 dom, u1 rec, u1 halfn);
        
      private: 
        // Accessors
        inline bool& updatedRef()                   { return this->_updated; }
        inline u1& widthRef()                       { return this->_width; }
        inline PixelMatrix& colsRef()  { return this->_cols;  }
        inline PixelMatrix& rowsRef()  { return this->_rows;  }
        
        // Methods 
        
        // State

        bool                     _updated;

        u1                       _width;

        PixelMatrix _rows;

        PixelMatrix _cols;
    };
}

# endif // Conjecture_OptIm_h

---