/homes/esi30/DCS339/coursework/src/image.hpp

Go to the documentation of this file.

#ifndef IMAGE_HPP_INCLUDED
#define IMAGE_HPP_INCLUDED

#include <memory>
#include <string>

#include <gdkmm/pixbuf.h>
#include <glibmm/refptr.h>

class Image;
class const_Pixel_proxy;

struct Pixel_proxy{
    Pixel_proxy(Image *img, unsigned y, unsigned x) noexcept;

    Pixel_proxy& operator=(std::initializer_list<int> values);
    Pixel_proxy& operator=(const const_Pixel_proxy &rhs);

    unsigned char &r, 
                  &g, 
                  &b; 
};

struct Pixel{
    Pixel();
    Pixel(unsigned char r, unsigned char g, unsigned char b);
    unsigned char r, g, b;
};

class Row_proxy{
    public:
        Row_proxy(Image *img, unsigned y) noexcept;

        Pixel_proxy operator[](unsigned x);

    private:
        Image *img; 
        unsigned y; 
};


struct const_Pixel_proxy{
    const_Pixel_proxy(const Image *img, unsigned y, unsigned x) noexcept;

    const unsigned char &r, 
                        &g, 
                        &b; 
};

class const_Row_proxy{
    public:
        const_Row_proxy(const Image *img, unsigned y) noexcept;
        const_Pixel_proxy operator[](unsigned x) const;

    private:
        const Image *img; 
        unsigned y; 
};

class Image{
    public:
        class iterator;
        class const_iterator;

        Image(const std::string &filepath);

        Image(unsigned height, unsigned width);

        Image() = default;
        Image(const Image&);
        Image(Image&&) noexcept;
        Image& operator=(Image) noexcept;
        friend void swap(Image &lhs, Image &rhs) noexcept;
        void save_img(const std::string &fp) const;

        Row_proxy operator[](unsigned y);

        const_Row_proxy operator[](unsigned y) const;

        Pixel_proxy at(unsigned y, unsigned x);
        const_Pixel_proxy at(unsigned y, unsigned x) const;

        iterator begin() noexcept;
        iterator end() noexcept;
        const_iterator begin() const noexcept;
        const_iterator end() const noexcept;

        unsigned char red(unsigned y, unsigned x) const;
        unsigned char green(unsigned y, unsigned x) const;
        unsigned char blue(unsigned y, unsigned x) const;
        unsigned char m_red(int y, int x) const;
        unsigned char m_green(int y, int x) const;
        unsigned char m_blue(int y, int x) const;
        void red(unsigned y, unsigned x, unsigned char v);
        void green(unsigned y, unsigned x, unsigned char v);
        void blue(unsigned y, unsigned x, unsigned char v);

        unsigned width() const noexcept;
        unsigned height() const noexcept;

        bool has_roi() const;
        unsigned true_width() const;
        unsigned true_height() const;

        unsigned x_win() const;
        unsigned y_win() const;
        void clip(unsigned y, unsigned x, unsigned dy, unsigned dx);
        void unclip();

    protected:
        Glib::RefPtr<Gdk::Pixbuf> data; 
        bool regionalised;
        unsigned clip_x, clip_y, clip_dx, clip_dy; 
        unsigned rowstride() const noexcept;
        unsigned n_channels() const noexcept;
        
        friend class Pixel_proxy;
        friend class const_Pixel_proxy;
};

class Image::iterator{
    public:
        iterator(Image *img, unsigned y, unsigned x);
        iterator(const iterator &other);
        iterator(iterator &&other) noexcept;
        friend void (::swap)(iterator &lhs, iterator &rhs) noexcept;
        iterator& operator=(iterator other) noexcept;

        bool valid() const;

        operator Image::const_iterator() const noexcept;

        Pixel get_copy() const;

        Pixel_proxy* operator->() noexcept;
        Pixel_proxy& operator*() noexcept;
        Pixel_proxy* operator->() const noexcept;
        Pixel_proxy& operator*() const noexcept;

        unsigned char red() const;
        unsigned char green() const;
        unsigned char blue() const;
        void red(unsigned char v);
        void green(unsigned char v);
        void blue(unsigned char v);

        Image::iterator& operator++();
        Image::iterator operator++(int);
        Image::iterator& operator--();
        Image::iterator operator--(int);
        Image::iterator& operator+=(int);
        Image::iterator& operator-=(int);
        bool operator==(const Image::iterator &o) const noexcept;
        bool operator!=(const Image::iterator &o) const noexcept;

        friend Image::iterator operator+(Image::iterator lhs, int rhs);
        friend Image::iterator operator+(int lhs, Image::iterator rhs);
        friend Image::iterator operator-(Image::iterator lhs, int rhs);
        friend int operator-(const Image::iterator &lhs, const Image::iterator &rhs);

    private:
        Image *img;
        unsigned y, x;
        std::unique_ptr<Pixel_proxy> proxy;

        void rebuild();
};

class Image::const_iterator{
    public:
        const_iterator(const Image *img, unsigned y, unsigned x);
        const_iterator(const const_iterator &other);
        const_iterator(const_iterator &&other) noexcept;
        friend void (::swap)(const_iterator &lhs, const_iterator &rhs) noexcept;
        const_iterator& operator=(const_iterator other) noexcept;

        bool valid() const;

        Pixel get_copy() const;

        const_Pixel_proxy* operator->() noexcept;
        const_Pixel_proxy& operator*() noexcept;
        const_Pixel_proxy* operator->() const noexcept;
        const_Pixel_proxy& operator*() const noexcept;

        unsigned char red() const;
        unsigned char green() const;
        unsigned char blue() const;

        Image::const_iterator& operator++();
        Image::const_iterator operator++(int);
        Image::const_iterator& operator--();
        Image::const_iterator operator--(int);
        Image::const_iterator& operator+=(int);
        Image::const_iterator& operator-=(int);
        bool operator==(const Image::const_iterator &o) const noexcept;
        bool operator!=(const Image::const_iterator &o) const noexcept;

        friend Image::const_iterator operator+(Image::const_iterator lhs, int rhs);
        friend Image::const_iterator operator+(int lhs, Image::const_iterator rhs);
        friend Image::const_iterator operator-(Image::const_iterator lhs, int rhs);
        friend int operator-(const Image::const_iterator &lhs, const Image::const_iterator &rhs);

    private:
        const Image *img;
        unsigned y, x;
        std::unique_ptr<const_Pixel_proxy> proxy;

        void rebuild();
};
#endif