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

Go to the documentation of this file.

#include <algorithm>
#include <sstream>
#include <tuple>
#include <memory>
#include <string>

#include <gtkmm/image.h>
#include <gtkmm/dialog.h>
#include <gtkmm/entry.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"

namespace{
    class Config: public Gtk::Dialog {
        public:
            Config(): tt("Epsilon:") {
                set_resizable(false);

                bt.set_text("0.1");
                get_vbox()->pack_start(tt);
                get_vbox()->pack_start(bt);

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

                show_all_children();
            }

            double epsilon() const {
                std::stringstream ss;
                ss << bt.get_text();
                double v;
                if(ss >> v)
                    return v;
                else
                    throw std::runtime_error("Not a number");
            }
        private:
            Gtk::Label tt;
            Gtk::Entry bt;
    };

    typedef std::tuple<unsigned char, unsigned char, unsigned char> Th_l;
    typedef std::pair<std::tuple<double, double, double>,std::tuple<double, double, double>> Ob_m;

    Ob_m compute_means(const Image *img, Th_l thresholds){
        unsigned ros=0, gos=0, bos=0, rbs=0, gbs=0, bbs=0;
        unsigned ron=0, gon=0, bon=0, rbn=0, gbn=0, bbn=0;

        for(Image::const_iterator it=img->begin(); it!=img->end(); ++it){
            (it->r>std::get<0>(thresholds)?ros:rbs)+=it->r;
            (it->g>std::get<1>(thresholds)?gos:gbs)+=it->g;
            (it->b>std::get<2>(thresholds)?bos:bbs)+=it->b;
            (it->r>std::get<0>(thresholds)?ron:rbn)++;
            (it->g>std::get<1>(thresholds)?gon:gbn)++;
            (it->b>std::get<2>(thresholds)?bon:bbn)++;
        }

        return Ob_m(std::tuple<double,double,double>(ros/static_cast<double>(ron), gos/static_cast<double>(gon), bos/static_cast<double>(bon)),
                    std::tuple<double,double,double>(rbs/static_cast<double>(rbn), gbs/static_cast<double>(gbn), bbs/static_cast<double>(bbn)));
    }

    Display_unit* impl(const Image_unit *in){
        Config config;
        if(config.run()!=Gtk::RESPONSE_OK)
            return nullptr;
        config.hide();
        double epsilon=config.epsilon();

        Th_l threshold, old_th;

        double vr=0, vg=0, vb=0;
        vr+=(*in)[0][0].r; vg+=(*in)[0][0].g; vb+=(*in)[0][0].b;
        vr+=(*in)[in->height()-1][0].r; vg+=(*in)[in->height()-1][0].g; vb+=(*in)[in->height()-1][0].b;
        vr+=(*in)[0][in->width()-1].r; vg+=(*in)[0][in->width()-1].g; vb+=(*in)[0][in->width()-1].b;
        vr+=(*in)[in->height()-1][in->width()-1].r; vg+=(*in)[in->height()-1][in->width()-1].g; vb+=(*in)[in->height()-1][in->width()-1].b;

        std::get<0>(threshold)=vr/4;
        std::get<1>(threshold)=vg/4;
        std::get<2>(threshold)=vb/4;

        do{
            old_th=threshold;
            Ob_m m=compute_means(in, threshold);
            std::get<0>(threshold)=(std::get<0>(m.first)+std::get<0>(m.second))/2;
            std::get<1>(threshold)=(std::get<1>(m.first)+std::get<1>(m.second))/2;
            std::get<2>(threshold)=(std::get<2>(m.first)+std::get<2>(m.second))/2;
        } while(  std::abs(std::get<0>(threshold)-std::get<0>(old_th))>epsilon
               || std::abs(std::get<1>(threshold)-std::get<1>(old_th))>epsilon
               || std::abs(std::get<2>(threshold)-std::get<2>(old_th))>epsilon);

        Image_unit *out(new Image_unit(*in));

        for(Image_unit::iterator it=out->begin(); it!=out->end(); ++it)
            *it={ it->r>std::get<0>(threshold)?255:0, it->g>std::get<1>(threshold)?255:0, it->b>std::get<2>(threshold)?255:0 };

        return out;
    }
}

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