Image.h

# ifndef Conjecture_Image_h
# define Conjecture_Image_h Conjecture_Image_h

// Insert SVN header substitution variable here
// Class Champion: Unassigned

// C++ Dependencies
# include <string>         // uses
# include "Coord.h"        // Coord, uint8_t
# include "ImageArgs.h"    // ImageArgs
# include "Page.h"         // needs friendship for special Image constructor

// C Dependencies
# include "pnm.h"    // struct pixmap

namespace Conjecture {
    class Image : public Root {
        
      public:
        Image(const std::string& file, bool verbose = false);
        
        /*
         * Create a copy of a sub-region of another Image.
         *
         * 'topleft' and 'bottomright' identify the pixel boundaries of
         * the desired region, and are relative to <0,0> in the top left
         * corner of 'src'.
         *
         * See the documentation of ImageConfig for the 'config' parameter.
         *
         */
        Image(const Image* src, const Coord& topleft, const Coord& bottomright, const ImageArgs& config);
        
        /*
         * Destructor for Image instances.
         *
         * This destructor is critical, because images may be created and
         * destroyed often (and allocate nested space).
         *
         */
        ~Image();
        
        /*
         * Obtain the pixel value for position <x,y>
         *
         */
        inline u1 get(u2 x, u2 y) const        { return this->_data->p[this->index(x,y)]; }
        inline u1 get(const Coord& pos) const  { return this->_data->p[this->index(pos.x,pos.y)]; }
        
        inline void set(u2 x, u2 y, int val)        { this->_data->p[this->index(x,y)] = val; }
        inline void set(const Coord& pos, int val)  { this->_data->p[this->index(pos.x,pos.y)] = val; }
        
        // Miscellaneous
        bool writeMono(const std::string& filebase, bool verbose = false) const;
        bool writeGrey(const std::string& filebase, bool verbose = false) const;
        bool writeColor(const std::string& filebase, bool verbose = false) const;
        
        /*
         * Images can be stored either monochrome, greyscale or color.
         * The latter uses 3 bytes per pixel, the former two use 1 byte
         * per pixel.  FUTURE FIX: I assume pbm packs 8 into one byte??
         *
         * FUTURE FIX: Should we not bother with color at all, and always
         * read images in greyscale? Problem with this is that color may
         * provide useful hints for partitioning and maybe even
         * identification. For now, we maintain support for color,
         * although the primary focus currently is on greyscale analysis.
         *
         */
        int  bytesPerPixel() const { return this->_data->bpp; }
        
        /*
         * Unit testing method.
         *
         * This static method should create instances of the class (and
         * instances of any other class necessary) and perform tests to
         * ensure that all methods within the class are working as
         * expected.
         *
         */
        static void test(int argc = 0, const char* argv[] = NULL);
        
        Coord size() const { return Coord(this->data()->x, this->data()->y); }
        
        uint16_t width() const { return this->size().x; }
        
        uint16_t height() const { return this->size().y; }
        
        // Accessors

        // This field must go away!
        inline const pix* data() const { return this->_data; }
        
      protected:
        // Accessors
        inline void dataIs(pix* data) { this->_data = data; }
        
        // Methods 
        
        inline int index(u2 x, u2 y) const { return x + y*this->_data->x; }
        
      private: 
        // Methods 
        
        // Accessors
        inline pix*          dataRef() { return this->_data; }
        
        // State
        
        // This field has no public access - dirty - must replace with
        // something cleaner!
        pix*           _data;
    };
};

# endif // Conjecture_Image_h

---