OptIm15.h

# ifndef OptIm15_h
# define OptIm15_h OptIm15_h

// ####################################################################
// # Conjecture: An Extensible Optical Character Recognition Framework  #
// #                                                                  #
// # Copyright: GNU Public License                                    #
// #                                                                  #
// # Overview:                                                        #
// #  - Conjecture is a collection of C++ classes, and an OCR engine    #
// #  - Conjecture is designed to allow customization at all levels     #
// #    and to encourage individuals to contribute incremental        #
// #    improvements in algorithms.                                   #
// #  - Overall design discussions can be found in                    #
// #      $SNROOT/docs/doxygen/html/index.html                        #
// #  - Conjecture is designed to interact with and build on other      #
// #    open-source OCR programs.                                     #
// ####################################################################

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

namespace Conjecture {
  class Image;
  class ImageArgs;

  // ##################################################################

  // ##################################################################
  class OptIm15 : public Root {
  public:
    // Constructors/Destructors
    OptIm15(const Image* image, const ImageArgs& config);
    OptIm15(const std::vector<unsigned int>& rows, unsigned char width = 15);

    // **************
    // Accessors
    inline const uint8_t & width() const { return this->_width; }
    inline const std::vector<PixelLine15> & cols() const { return this->_cols; }
    inline const std::vector<PixelLine15> & rows() const { return this->_rows; }
    
    // **************
    // Input/Output
    
    // **************
    // Interface

    void init(const std::vector<unsigned int>& rows, unsigned char width);

    int rblack(unsigned char i) const { return this->rows()[i].black(); }
    int rholes(unsigned char i) const { return this->rows()[i].holes(); }
    int cblack(unsigned char i) const { return this->cols()[i].black(); }
    int choles(unsigned char i) const { return this->cols()[i].holes(); }

    std::string str(char on = '#', char off = '.') const; // , unsigned char size = 15) const;

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

  protected:
    // **************
    // Accessors
    inline void            widthIs(const uint8_t & width) { this->_width = width; }
    inline void            colsIs(const std::vector<PixelLine15> & cols) { this->_cols = cols; }
    inline void            rowsIs(const std::vector<PixelLine15> & rows) { this->_rows = rows; }
    
    // **************
    // Methods 
    std::string rawstr(const std::vector<PixelLine15>& vec, char on = '1', char off = '0', unsigned char size = 15) const;    
    
  private: 
    // **************
    // Accessors
    inline uint8_t&                widthRef() { return this->_width; }
    inline std::vector<PixelLine15>& colsRef()  { return this->_cols; }
    inline std::vector<PixelLine15>& rowsRef()  { return this->_rows; }
    
    // **************
    // Methods 

    // **************
    // State
    uint8_t                _width;
    std::vector<PixelLine15> _cols;
    std::vector<PixelLine15> _rows;
  };
}

# endif // OptIm15_h

---