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

Go to the documentation of this file.

#include <string>
#include <stdexcept>

#include <gdkmm/pixbuf.h>

#include "image.hpp"

// @todo clean const_iterator... inhertance ?

Image::Image(const std::string &filepath): data(Gdk::Pixbuf::create_from_file(filepath)), regionalised(false),
                                           clip_x(0), clip_y(0), clip_dx(data->get_width()), clip_dy(data->get_height()) { }

Image::Image(const Image &other): data(other.data->copy()), regionalised(other.regionalised),
                                  clip_x(other.clip_x), clip_y(other.clip_y), clip_dx(other.clip_dx), clip_dy(other.clip_dy) {
}

Image::Image(unsigned height, unsigned width): data(Gdk::Pixbuf::create(Gdk::COLORSPACE_RGB, false, 8, width, height)), regionalised(false),
                                               clip_x(0), clip_y(0), clip_dx(width), clip_dy(height) { }

Image::Image(Image &&other) noexcept {
    swap(*this, other);
}

Image& Image::operator=(Image other) noexcept {
    swap(*this, other);
    return *this;
}

void swap(Image &lhs, Image &rhs) noexcept {
    using std::swap; // Enable ADL

    swap(lhs.data, rhs.data);
    swap(lhs.regionalised, rhs.regionalised);
    swap(lhs.clip_x, rhs.clip_x);
    swap(lhs.clip_y, rhs.clip_y);
    swap(lhs.clip_dx, rhs.clip_dx);
    swap(lhs.clip_dy, rhs.clip_dy);
}

void Image::save_img(const std::string &fp) const {
    std::string::const_reverse_iterator rdot=std::find(fp.rbegin(), fp.rend(), '.');
    if(rdot==fp.rend())
        throw std::runtime_error("No extension provided");
    std::string::const_iterator dot=rdot.base();
    std::string ext(dot, fp.end());
    std::vector<Gdk::PixbufFormat> sup=Gdk::Pixbuf::get_formats();
    for(Gdk::PixbufFormat format: sup)
        if(format.get_name()==ext && format.is_writable()){
            data->save(fp, format.get_name());
            return;
        }
    throw std::runtime_error("Unknow extension");
}

Pixel_proxy Image::at(unsigned y, unsigned x){
    return Pixel_proxy(this, y+clip_y, x+clip_x);
}

const_Pixel_proxy Image::at(unsigned y, unsigned x) const {
    return const_Pixel_proxy(this, y+clip_y, x+clip_x);
}

Image::iterator Image::begin() noexcept {
    return iterator(this, 0, 0);
}

Image::iterator Image::end() noexcept {
    return iterator(this, height(), 0);
}

Image::const_iterator Image::begin() const noexcept {
    return const_iterator(this, 0, 0);
}

Image::const_iterator Image::end() const noexcept {
    return const_iterator(this, height(), 0);
}

unsigned Image::width() const noexcept {
    return clip_dx;
}

unsigned Image::height() const noexcept {
    return clip_dy;
}

unsigned Image::rowstride() const noexcept {
    return data->get_rowstride();
}

unsigned Image::n_channels() const noexcept {
    return data->get_n_channels();
}

void Image::red(unsigned y, unsigned x, unsigned char v){
    *(data->get_pixels()+(clip_y+y)*rowstride()+n_channels()*(clip_x+x))=v;
}

void Image::green(unsigned y, unsigned x, unsigned char v){
    *(data->get_pixels()+(clip_y+y)*rowstride()+n_channels()*(clip_x+x)+1)=v;
}

void Image::blue(unsigned y, unsigned x, unsigned char v){
    *(data->get_pixels()+(clip_y+y)*rowstride()+n_channels()*(clip_x+x)+2)=v;
}

unsigned char Image::red(unsigned y, unsigned x) const {
    return *(data->get_pixels()+(clip_y+y)*rowstride()+n_channels()*(clip_x+x));
}

unsigned char Image::green(unsigned y, unsigned x) const {
    return *(data->get_pixels()+(clip_y+y)*rowstride()+n_channels()*(clip_x+x)+1);
}

unsigned char Image::blue(unsigned y, unsigned x) const {
    return *(data->get_pixels()+(clip_y+y)*rowstride()+n_channels()*(clip_x+x)+2);
}

unsigned char Image::m_red(int y, int x) const {
    y+=clip_y;
    x+=clip_x;
    // We are not mirroring if we can take the input from the non-regionalised image.
    if(y>=static_cast<int>(data->get_height())) y=data->get_height()-y-1;
    if(x>=static_cast<int>(data->get_width())) x=data->get_width()-x-1;
    if(y<0) y=-y;
    if(x<0) x=-x;
    return *(data->get_pixels()+y*rowstride()+n_channels()*x);
}

unsigned char Image::m_green(int y, int x) const {
    y+=clip_y;
    x+=clip_x;
    // We are not mirroring if we can take the input from the non-regionalised image.
    if(y>=static_cast<int>(data->get_height())) y=data->get_height()-y-1;
    if(x>=static_cast<int>(data->get_width())) x=data->get_width()-x-1;
    if(y<0) y=-y;
    if(x<0) x=-x;
    return *(data->get_pixels()+y*rowstride()+n_channels()*x+1);
}

unsigned char Image::m_blue(int y, int x) const {
    y+=clip_y;
    x+=clip_x;
    // We are not mirroring if we can take the input from the non-regionalised image.
    if(y>=static_cast<int>(data->get_height())) y=data->get_height()-y-1;
    if(x>=static_cast<int>(data->get_width())) x=data->get_width()-x-1;
    if(y<0) y=-y;
    if(x<0) x=-x;
    return *(data->get_pixels()+y*rowstride()+n_channels()*x+2);
}

unsigned Image::x_win() const {
    return clip_x;
}

unsigned Image::y_win() const {
    return clip_y;
}

bool Image::has_roi() const {
    return clip_y || clip_x || true_height()!=height() || true_width()!=width();
}

unsigned Image::true_height() const {
    return data->get_height();
}

unsigned Image::true_width() const {
    return data->get_width();
}

void Image::clip(unsigned y, unsigned x, unsigned dy, unsigned dx){
    clip_y=y;
    clip_x=x;
    clip_dy=dy;
    clip_dx=dx;
}

void Image::unclip(){
    clip_y=clip_x=0;
    clip_dy=true_height();
    clip_dx=true_width();
}

Row_proxy Image::operator[](unsigned y){
    if(y>height())
        throw std::runtime_error("Image out of bound access: trying to get the row "+std::to_string(y)+" on an image of height "+std::to_string(height()));
    return Row_proxy(this, y);
}

const_Row_proxy Image::operator[](unsigned y) const {
    if(y>height())
        throw std::runtime_error("Image out of bound access: trying to get the row "+std::to_string(y)+" on an image of height "+std::to_string(height()));
    return const_Row_proxy(this, y);
}

Row_proxy::Row_proxy(Image *img, unsigned y) noexcept : img(img), y(y+img->y_win()) {}

Pixel_proxy Row_proxy::operator[](unsigned x){
    if(x>img->width())
        throw std::runtime_error("Image out of bound access: trying to get the column "+std::to_string(x)+" on an image of width "+std::to_string(img->width()));
    return Pixel_proxy(img, y, img->x_win()+x);
}

const_Row_proxy::const_Row_proxy(const Image *img, unsigned y) noexcept : img(img), y(y+img->y_win()) {}

const_Pixel_proxy const_Row_proxy::operator[](unsigned x) const {
    if(x>img->width())
        throw std::runtime_error("Image out of bound access: trying to get the column "+std::to_string(x)+" on an image of width "+std::to_string(img->width()));
    return const_Pixel_proxy(img, y, img->x_win()+x);
}

Pixel_proxy::Pixel_proxy(Image *img, unsigned y, unsigned x) noexcept :
    r(*(img->data->get_pixels()+(y*img->rowstride()+img->n_channels()*x))),
    g(*(img->data->get_pixels()+(y*img->rowstride()+img->n_channels()*x)+1)),
    b(*(img->data->get_pixels()+(y*img->rowstride()+img->n_channels()*x)+2)) {}

Pixel_proxy& Pixel_proxy::operator=(std::initializer_list<int> values){
    switch(values.size()){
        case 0:
            r=g=b=0;
            break;
        case 1:
            r=g=b=*values.begin();
            break;
        case 3:
            r=values.begin()[0];
            g=values.begin()[1];
            b=values.begin()[2];
            break;
        default:
            throw std::runtime_error("Dimension error in pixel assignment, got "+std::to_string(values.size())+" values instead of 0, 1 or 3");
    }
    return *this;
}

Pixel_proxy& Pixel_proxy::operator=(const const_Pixel_proxy &rhs){
    r=rhs.r;
    g=rhs.g;
    b=rhs.b;
    return *this;
}

Pixel::Pixel(unsigned char r, unsigned char g, unsigned char b): r(r), g(g), b(b) {}
Pixel::Pixel(): r(), g(), b() {}

Image::iterator::iterator(Image *img, unsigned y, unsigned x): img(img), y(y), x(x), proxy(new Pixel_proxy(img, y, x)) { }

Image::iterator::iterator(const iterator &other): img(other.img), y(other.y), x(other.x), proxy(new Pixel_proxy(img, y, x)) {}

Image::iterator::iterator(iterator &&other) noexcept {
    swap(*this, other);
}

void swap(Image::iterator &lhs, Image::iterator &rhs) noexcept {
    using std::swap; // Enable ADL

    swap(lhs.img, rhs.img);
    swap(lhs.y, rhs.y);
    swap(lhs.x, rhs.x);
    swap(lhs.proxy, rhs.proxy);
}

Image::iterator& Image::iterator::operator=(iterator other) noexcept {
    swap(*this, other);
    return *this;
}

Image::iterator::operator Image::const_iterator() const noexcept {
    return Image::const_iterator(img, y, x);
}

bool Image::iterator::valid() const {
    return x<img->width() && y<img->height();
}

Pixel Image::iterator::get_copy() const {
    return Pixel(proxy->r, proxy->g, proxy->b);
}

Pixel_proxy* Image::iterator::operator->() noexcept {
    return proxy.get();
}

Pixel_proxy& Image::iterator::operator*() noexcept {
    return *proxy;
}

Pixel_proxy* Image::iterator::operator->() const noexcept {
    return proxy.get();
}

Pixel_proxy& Image::iterator::operator*() const noexcept {
    return *proxy;
}

unsigned char Image::iterator::red() const {
    return img->red(y, x);
}

unsigned char Image::iterator::green() const {
    return img->blue(y, x);
}

unsigned char Image::iterator::blue() const {
    return img->blue(y, x);
}

void Image::iterator::red(unsigned char v){
    img->red(y, x, v);
}

void Image::iterator::green(unsigned char v){
    img->green(y, x, v);
}

void Image::iterator::blue(unsigned char v){
    img->blue(y, x, v);
}

void Image::iterator::rebuild(){
    proxy.get()->~Pixel_proxy();
    new (proxy.get()) Pixel_proxy(img, y+img->y_win(), x+img->x_win());
    // proxy.reset(new Pixel_proxy(img, y, x));
}

Image::iterator& Image::iterator::operator++(){
    ++x;
    if(x>=img->width()){
        x=0;
        ++y;
    }

    rebuild();

    return *this;
}

Image::iterator Image::iterator::operator++(int){
    Image::iterator old(*this);
    ++x;
    if(x>=img->width()){
        x=0;
        ++y;
    }

    rebuild();

    return old;
}

Image::iterator& Image::iterator::operator--(){
    if(!x--){
        x=img->width()-1;
        --y;
    }

    rebuild();

    return *this;
}

Image::iterator Image::iterator::operator--(int){
    Image::iterator old(*this);
    if(!x--){
        x=img->width()-1;
        --y;
    }

    rebuild();

    return old;
}

Image::iterator& Image::iterator::operator+=(int rhs){
    x+=rhs;
    y+=x/img->width();
    x%=img->width();
    rebuild();
    return *this;
}

Image::iterator& Image::iterator::operator-=(int rhs){
    x+=rhs;
    y+=x/img->width();
    x%=img->width();
    rebuild();
    return *this;
}

Image::iterator operator+(Image::iterator lhs, int rhs){
    return lhs+=rhs;
}

Image::iterator operator+(int lhs, Image::iterator rhs){
    return rhs+=lhs;
}

Image::iterator operator-(Image::iterator lhs, int rhs){
    return lhs-=rhs;
}

int operator-(const Image::iterator &lhs, const Image::iterator &rhs){
    return (lhs.y-rhs.y)*lhs.img->width()+(lhs.x-rhs.x);
}

bool Image::iterator::operator==(const Image::iterator &o) const noexcept {
    return o.img==img && o.y==y && o.x==x;
}

bool Image::iterator::operator!=(const Image::iterator &o) const noexcept {
    return o.img!=img || o.y!=y || o.x!=x;
}

Image::const_iterator::const_iterator(const Image *img, unsigned y, unsigned x): img(img), y(y), x(x), proxy(new const_Pixel_proxy(img, y, x)) { }

Image::const_iterator::const_iterator(const const_iterator &other): img(other.img), y(other.y), x(other.x), proxy(new const_Pixel_proxy(img, y, x)) {}

Image::const_iterator::const_iterator(const_iterator &&other) noexcept {
    swap(*this, other);
}

void swap(Image::const_iterator &lhs, Image::const_iterator &rhs) noexcept {
    using std::swap; // Enable ADL

    swap(lhs.img, rhs.img);
    swap(lhs.y, rhs.y);
    swap(lhs.x, rhs.x);
    swap(lhs.proxy, rhs.proxy);
}

Image::const_iterator& Image::const_iterator::operator=(const_iterator other) noexcept {
    swap(*this, other);
    return *this;
}

bool Image::const_iterator::valid() const {
    return x<img->width() && y<img->height();
}

Pixel Image::const_iterator::get_copy() const {
    return Pixel(proxy->r, proxy->g, proxy->b);
}

const_Pixel_proxy* Image::const_iterator::operator->() noexcept {
    return proxy.get();
}

const_Pixel_proxy& Image::const_iterator::operator*() noexcept {
    return *proxy;
}

const_Pixel_proxy* Image::const_iterator::operator->() const noexcept {
    return proxy.get();
}

const_Pixel_proxy& Image::const_iterator::operator*() const noexcept {
    return *proxy;
}

unsigned char Image::const_iterator::red() const {
    return img->red(y, x);
}

unsigned char Image::const_iterator::green() const {
    return img->blue(y, x);
}

unsigned char Image::const_iterator::blue() const {
    return img->blue(y, x);
}

void Image::const_iterator::rebuild(){
    proxy.get()->~const_Pixel_proxy();
    new (proxy.get()) const_Pixel_proxy(img, y+img->y_win(), x+img->x_win());
}

Image::const_iterator& Image::const_iterator::operator++(){
    ++x;
    if(x>=img->width()){
        x=0;
        ++y;
    }

    rebuild();

    return *this;
}

Image::const_iterator Image::const_iterator::operator++(int){
    Image::const_iterator old(*this);
    ++x;
    if(x>=img->width()){
        x=0;
        ++y;
    }

    rebuild();

    return old;
}

Image::const_iterator& Image::const_iterator::operator--(){
    if(!x--){
        x=img->width()-1;
        --y;
    }

    rebuild();

    return *this;
}

Image::const_iterator Image::const_iterator::operator--(int){
    Image::const_iterator old(*this);
    if(!x--){
        x=img->width()-1;
        --y;
    }

    rebuild();

    return old;
}

Image::const_iterator& Image::const_iterator::operator+=(int rhs){
    x+=rhs;
    y+=x/img->width();
    x%=img->width();
    rebuild();
    return *this;
}

Image::const_iterator& Image::const_iterator::operator-=(int rhs){
    x+=rhs;
    y+=x/img->width();
    x%=img->width();
    rebuild();
    return *this;
}

Image::const_iterator operator+(Image::const_iterator lhs, int rhs){
    return lhs+=rhs;
}

Image::const_iterator operator+(int lhs, Image::const_iterator rhs){
    return rhs+=lhs;
}

Image::const_iterator operator-(Image::const_iterator lhs, int rhs){
    return lhs-=rhs;
}

int operator-(const Image::const_iterator &lhs, const Image::const_iterator &rhs){
    return (lhs.y-rhs.y)*lhs.img->width()+(lhs.x-rhs.x);
}

bool Image::const_iterator::operator==(const Image::const_iterator &o) const noexcept {
    return o.img==img && o.y==y && o.x==x;
}

bool Image::const_iterator::operator!=(const Image::const_iterator &o) const noexcept {
    return o.img!=img || o.y!=y || o.x!=x;
}


const_Pixel_proxy::const_Pixel_proxy(const Image *img, unsigned y, unsigned x) noexcept :
    r(*(img->data->get_pixels()+(y*img->rowstride()+img->n_channels()*x))),
    g(*(img->data->get_pixels()+(y*img->rowstride()+img->n_channels()*x)+1)),
    b(*(img->data->get_pixels()+(y*img->rowstride()+img->n_channels()*x)+2)) {}