/homes/esi30/DCS339/coursework/src/Processes/resize.cpp

Go to the documentation of this file.

#include <memory>
#include <array>
#include <string>

#include <gtkmm/image.h>
#include <gtkmm/dialog.h>
#include <gtkmm/spinbutton.h>
#include <gtkmm/messagedialog.h>
#include <gtkmm/checkbutton.h>
#include <gtkmm/label.h>
#include <gtkmm/enums.h>
#include <gtkmm/stock.h>

#include "../display_unit.hpp"
#include "../processing_page.hpp"
#include "../processing_unit.hpp"
#include "../utils.hpp"
#include "../progress.hpp"

namespace{
    class Config: public Gtk::Dialog {
        public:
            Config(int w, int h): adjw(Gtk::Adjustment::create(w, 1, std::numeric_limits<int>::max(), 10, 100)), ttw("Width:"), btw(adjw),
                                  adjh(Gtk::Adjustment::create(h, 1, std::numeric_limits<int>::max(), 10, 100)), tth("Height:"), bth(adjh),
                                  bic("Bicubic interpolation"){
                set_resizable(false);
                bic.set_active(true);

                get_vbox()->pack_start(bic);
                get_vbox()->pack_start(ttw);
                get_vbox()->pack_start(btw);
                get_vbox()->pack_start(tth);
                get_vbox()->pack_start(bth);

                add_button(Gtk::Stock::OK, Gtk::RESPONSE_OK);
                add_button(Gtk::Stock::CANCEL, Gtk::RESPONSE_CANCEL);

                show_all_children();
            }

            unsigned getw() const { return btw.get_value(); }
            unsigned geth() const { return bth.get_value(); }
            unsigned getbic() const { return bic.get_active(); }
        private:
            Glib::RefPtr<Gtk::Adjustment> adjw;
            Gtk::Label ttw;
            Gtk::SpinButton btw;
            Glib::RefPtr<Gtk::Adjustment> adjh;
            Gtk::Label tth;
            Gtk::SpinButton bth;
            Gtk::CheckButton bic;
    };

    double cubic_interpolate(const std::array<double, 4> &p, double x){
        return p[1] + 0.5 * x*(p[2] - p[0] + x*(2.0*p[0] - 5.0*p[1] + 4.0*p[2] - p[3] + x*(3.0*(p[1] - p[2]) + p[3] - p[0])));
    }

    double bicubic_interpolate (const std::array<std::array<double, 4>, 4> &p, double y, double x) {
        std::array<double, 4> arr;
        arr[0] = cubic_interpolate(p[0], y);
        arr[1] = cubic_interpolate(p[1], y);
        arr[2] = cubic_interpolate(p[2], y);
        arr[3] = cubic_interpolate(p[3], y);
        return cubic_interpolate(arr, x);
    }

    Display_unit *impl(const Image_unit *in){
        if(in->has_roi()){
            Gtk::MessageDialog d("Can not apply Resize to a region of interest.");
            d.run();
            return nullptr;
        }

        Config c(in->width(), in->height());
        if(c.run()!=Gtk::RESPONSE_OK)
            return nullptr;
        c.hide();

        Image_unit *out(new Image_unit(in, c.geth(), c.getw()));

        if(c.getbic()){
            Progress prog;
            std::array<std::array<double, 4>, 4> red_neighbors, green_neighbors, blue_neighbors;
            for(unsigned y=0; y<out->height(); ++y){
                prog.advance(static_cast<double>(y)/out->height());
                for(unsigned x=0; x<out->width(); ++x){
                    double ny=y*in->height()/static_cast<double>(out->height());
                    double nx=x*in->width()/static_cast<double>(out->width());

                    for(int dx=-1; dx<=2; ++dx)
                        for(int dy=-1; dy<=2; ++dy){
                            red_neighbors[dy+1][dx+1]=in->m_red(ny+dy, nx+dx);
                            green_neighbors[dy+1][dx+1]=in->m_green(ny+dy, nx+dx);
                            blue_neighbors[dy+1][dx+1]=in->m_blue(ny+dy, nx+dx);
                        }
                    
                    double red=bicubic_interpolate(red_neighbors, nx-std::floor(nx), ny-std::floor(ny));
                    red=red>255?255:red<0?0:red;
                    double green=bicubic_interpolate(green_neighbors, nx-std::floor(nx), ny-std::floor(ny));
                    green=green>255?255:green<0?0:green;
                    double blue=bicubic_interpolate(blue_neighbors, nx-std::floor(nx), ny-std::floor(ny));
                    blue=blue>255?255:blue<0?0:blue;
                    out->red(y, x, red);
                    out->green(y, x, green);
                    out->blue(y, x, blue);
                }
            }
        } else {
            for(unsigned y=0; y<out->height(); ++y)
                for(unsigned x=0; x<out->width(); ++x){
                    double ny=y*in->height()/static_cast<double>(out->height());
                    double nx=x*in->width()/static_cast<double>(out->width());
                    out->red(y, x, in->m_red(ny, nx));
                    out->green(y, x, in->m_green(ny, nx));
                    out->blue(y, x, in->m_blue(ny, nx));
                }
        }
        return out;
    }
}

namespace Processes{
    void resize(){
        Gtk::Image icon(cmake_install_prefix+std::string("/share/egami/icons/resize.png"));
        std::shared_ptr<Processing_unit> pu(new Processing_unit(Processing(&impl), "Resize", icon, false));
        Processing_page::add_unit_to_page("Reshape", pu);
    }
}