PixelLine.h

# ifndef Conjecture_PixelLine_h
# define Conjecture_PixelLine_h Conjecture_PixelLine_h

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

# include "Root.h"  // parent

namespace Conjecture {
    class OptIm;  // friend declaration
    
    // IMPLEMENTATION NOTES:
    //   - this class is designed for highly efficient space utiliation,
    //     while also providing support for highly efficient feature
    //     analysis.
    //   - some "auxillary" methods are quite slow (i.e. 'set' and
    //     'clear' - this class is meant to be used primarily on
    //     frozen images, so setting and clearing bits is not a
    //     priority for efficient implementation.
    //   - does NOT store the size of the pixel line (assumed to be
    //     be maintained elsewhere). This implies that the number of
    //     white pixels cannot be reported without obtaining the size
    //     (#black is stored, and #white = total - #black).
    //   - not using setters internally in some situations because
    //     bit-specifiers cause temporaries to be used in returns

    class PixelLine : public Root {
      public:
        static const u1 MaxPixels = 31;

        // Constructors/Destructors
        PixelLine(u4 pixels);
        
        // Accessors
        inline u1   holes()  const { return this->_holes;  }
        inline u4   pixels() const { return this->_pixels; }
        inline u1   black()  const { return this->_black;  }
        
        // Input/Output
        
        // Interface

        inline bool get(unsigned i) const {
            return (this->pixels() & (1<<i)) ? true : false;
        }
        
        void set(unsigned i);

        void clear(unsigned i);
        
        std::string str(char on = '#', char off = '.', u1 size = 31) const;
        inline std::string str(u1 size) const { return this->str('#','.',size); }

        void assign(const PixelLine& other, u1 rightdel = 0);

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

      protected:
        // Accessors
        inline const bool &    updated() const { return this->_updated; }
        inline void            updatedIs(const bool & updated) { this->_updated = updated; }
        inline void            blackIs(const u1 & black) { this->_black = black; }
        inline void            holesIs(const u1 & holes)   { this->_holes = holes; }
        inline void            pixelsIs(const u4 & pixels) { this->_pixels = pixels; }
        
        // Methods 
        inline void rawset(unsigned i)   { this->_pixels |= (1<<i);  }
        inline void rawclear(unsigned i) { this->_pixels &= ~(1<<i); }

        inline void rawline(u4 pixels) { this->_pixels = pixels; this->updatedIs(false); }

        
      private: 
        * PixFilt needs access to rawset and rawclear for efficiency
        friend class PixFilt;
        * OptIm needs to set the pixel data
        friend class OptIm;

        // Accessors
        
        // Methods 
        void updateMeta();

        // State

        u4              _pixels;

        unsigned int    _holes:4;

        u1              _black:5;

        bool            _updated;

    };
}

# endif // Conjecture_PixelLine_h

---