Inheritance diagram for ImageViewer:

Public Member Functions
	ImageViewer (std::vector< const char * > &filenames)
void	range (const Image &image)
Image	tone (const Image &image, const float saturation, const float gamma)
Image	gray (const Image &image)
void	title (const int index)
Image	read (const char *filename)
int	init ()
	a deriver pour creer les objets openGL. renvoie -1 pour indiquer une erreur, 0 sinon.
int	quit ()
	a deriver pour detruire les objets openGL. renvoie -1 pour indiquer une erreur, 0 sinon.
int	render ()
	a deriver pour afficher les objets. renvoie 1 pour continuer, 0 pour fermer l'application.
Public Member Functions inherited from App
	App (const int width, const int height, const int major=3, const int minor=3, const int samples=0)
	constructeur, dimensions de la fenetre et version d'openGL.
virtual int	update (const float time, const float delta)
	a deriver et redefinir pour animer les objets en fonction du temps.
int	run ()
	execution de l'application.

Protected Attributes
Widgets	m_widgets
std::vector< std::string >	m_filenames
std::vector< size_t >	m_times
std::vector< Image >	m_images
std::vector< GLuint >	m_textures
unsigned	m_width
unsigned	m_height
GLuint	m_program
GLuint	m_vao
GLuint	m_sampler_nearest
int	m_red
int	m_green
int	m_blue
int	m_alpha
int	m_gray
int	m_smooth
int	m_difference
float	m_compression
float	m_saturation
float	m_saturation_step
float	m_saturation_max
float	m_zoom
int	m_index
int	m_reference_index
int	m_graph
Protected Attributes inherited from App
Window	m_window
Context	m_context
bool	sync

Additional Inherited Members
Protected Member Functions inherited from App
virtual int	prerender ()
virtual int	postrender ()
void	vsync_off ()

Detailed Description

Definition at line 20 of file image_viewer.cpp.

Constructor & Destructor Documentation

◆ ImageViewer()

ImageViewer::ImageViewer ( std::vector< const char * > & filenames )

inline

Definition at line 22 of file image_viewer.cpp.

                                                      : App(1024, 640), m_filenames() 
    {
        for(unsigned i= 0; i < filenames.size(); i++)
            m_filenames.push_back(filenames[i]);
    }

Member Function Documentation

◆ range()

void ImageViewer::range ( const Image & image )

inline

Definition at line 28 of file image_viewer.cpp.

    {
        int bins[100] = {};
        float ymin= FLT_MAX;
        float ymax= 0.f;
        for(unsigned y= 0; y < image.height(); y++)
        for(unsigned x= 0; x < image.width(); x++)
        {
            Color color= image(x, y);
            float y= color.r + color.g + color.b;
            if(y < ymin) ymin= y;
            if(y > ymax) ymax= y;
        }
        
        for(unsigned y= 0; y < image.height(); y++)
        for(unsigned x= 0; x < image.width(); x++)
        {
            Color color= image(x, y);
            float y= color.r + color.g + color.b;
            int b= (y - ymin) * 100.f / (ymax - ymin);
            if(b >= 99) b= 99;
            if(b < 0) b= 0;
            bins[b]++;
        }
 
        printf("range [%f..%f]\n", ymin, ymax);
        //~ for(int i= 0; i < 100; i++)
            //~ printf("%f ", ((float) bins[i] * 100.f / (m_width * m_height)));
        //~ printf("\n");
        
        float qbins= 0;
        for(int i= 0; i < 100; i++)
        {
            if(qbins > .75f)
            {
                m_saturation= ymin + (float) i / 100.f * (ymax - ymin);
                m_saturation_step= m_saturation / 40.f;
                m_saturation_max= ymax;
                break;
            }
            
            qbins= qbins + (float) bins[i] / (m_width * m_height);
        }
        m_compression= 2.2f;        
    }

◆ tone()

Image ImageViewer::tone	(	const Image &	image,
		const float	saturation,
		const float	gamma )

inline

Definition at line 74 of file image_viewer.cpp.

    {
        Image tmp(image.width(), image.height());
        
        float invg= 1 / gamma;
        float k= 1 / std::pow(saturation, invg);
        for(unsigned i= 0; i < image.size(); i++)
        {
            Color color= image(i);
            if(std::isnan(color.r) || std::isnan(color.g) || std::isnan(color.b))
                // marque les pixels pourris avec une couleur improbable...            
                color= Color(1, 0, 1);
            else
                // sinon transformation gamma rgb -> srgb
                color= Color(k * std::pow(color.r, invg), k * std::pow(color.g, invg), k * std::pow(color.b, invg));
            
            tmp(i)= Color(color, 1);
        }
        
        return tmp;
    }

◆ gray()

Image ImageViewer::gray ( const Image & image )

inline

Definition at line 96 of file image_viewer.cpp.

    {
        Image tmp(image.width(), image.height());
        
        for(unsigned i= 0; i < image.size(); i++)
        {
            Color color= image(i);
            float g= (color.r + color.b + color.b) / 3;
            //~ float g= std::max(color.r, std::max(color.g, std::max(color.b, float(0))));
            tmp(i)= Color(g);
        }
        
        return tmp;
    }

◆ title()

void ImageViewer::title ( const int index )

inline

Definition at line 112 of file image_viewer.cpp.

    {
        char tmp[1024];
        sprintf(tmp, "buffer %02d: %s", index, m_filenames[index].c_str());
        SDL_SetWindowTitle(m_window, tmp);        
    }

◆ read()

Image ImageViewer::read ( const char * filename )

inline

Definition at line 119 of file image_viewer.cpp.

    {
        Image image;
        if(is_pfm_image(filename))
            image= read_image_pfm(filename);
        else if(is_hdr_image(filename))
            image= read_image_hdr(filename);
        else
            image= read_image(filename);
        
        return image;
    }

◆ init()

int ImageViewer::init ( )

inlinevirtual

a deriver pour creer les objets openGL. renvoie -1 pour indiquer une erreur, 0 sinon.

Implements App.

Definition at line 132 of file image_viewer.cpp.

    {
        m_width= 0;
        m_height= 0;
        
        for(unsigned i= 0; i < m_filenames.size(); i++)
        {
            printf("loading buffer %u...\n", i);
            
            Image image= read(m_filenames[i].c_str());
            if(image.size() == 0)
                continue;
            
            m_images.push_back(image);
            m_times.push_back(timestamp(m_filenames[i].c_str()));
            
            m_textures.push_back(make_texture(0, image));
            
            glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_BORDER);
            glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_BORDER);
            
            m_width= std::max(m_width, image.width());
            m_height= std::max(m_height, image.height());
        }
        
        if(m_images.empty())
        {
            printf("no image...\n");
            return -1;
        }
        
        // change le titre de la fenetre
        title(0);
        
        // redminsionne la fenetre
        SDL_SetWindowSize(m_window, m_width, m_height);
        
        glGenVertexArrays(1, &m_vao);
        glBindVertexArray(m_vao);
        
        m_program= read_program( smart_path("data/shaders/tonemap.glsl") );
        program_print_errors(m_program);
        
        // 
        m_red= 1;
        m_green= 1;
        m_blue= 1;
        m_alpha= 1;
        m_gray= 0;
        m_smooth= 1;
        m_difference= 0;
        m_compression= 2.2f;
        m_saturation= 1;
        m_saturation_step= 1;
        m_saturation_max= 1000;
        m_index= 0;
        m_reference_index= -1;
        m_zoom= 4;
        m_graph= 0;
        
        // parametres d'exposition / compression
        range(m_images.front());
        
        //
        m_widgets= create_widgets();
        
        //
        glGenSamplers(1, &m_sampler_nearest);
        glSamplerParameteri(m_sampler_nearest, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
        glSamplerParameteri(m_sampler_nearest, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
        glSamplerParameteri(m_sampler_nearest, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_BORDER);
        glSamplerParameteri(m_sampler_nearest, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_BORDER);
        
        // etat openGL par defaut
        glUseProgram(0);
        glBindVertexArray(0);
        glBindTexture(GL_TEXTURE_2D, 0);
        
        glDisable(GL_DEPTH_TEST);
        glDisable(GL_CULL_FACE);
        return 0;
    }

◆ quit()

int ImageViewer::quit ( )

inlinevirtual

a deriver pour detruire les objets openGL. renvoie -1 pour indiquer une erreur, 0 sinon.

Implements App.

Definition at line 215 of file image_viewer.cpp.

    {
        glDeleteVertexArrays(1, &m_vao);
        glDeleteTextures(m_textures.size(), m_textures.data());
        
        release_program(m_program);
        release_widgets(m_widgets);
        return 0;
    }

◆ render()

int ImageViewer::render ( )

inlinevirtual

a deriver pour afficher les objets. renvoie 1 pour continuer, 0 pour fermer l'application.

Implements App.

Definition at line 225 of file image_viewer.cpp.

    {
        // effacer l'image
        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
        
        if(key_state('r'))
        {
            clear_key_state('r');
            reload_program(m_program, smart_path("data/shaders/tonemap.glsl") );
            program_print_errors(m_program);
        }
        
        if(key_state(SDLK_LEFT))
        {
            clear_key_state(SDLK_LEFT);
            m_index= (m_index -1 + m_textures.size()) % m_textures.size();
            // change aussi le titre de la fenetre
            title(m_index);
        }
        
        if(key_state(SDLK_RIGHT))
        {
            clear_key_state(SDLK_RIGHT);
            m_index= (m_index +1 + m_textures.size()) % m_textures.size();
            // change aussi le titre de la fenetre
            title(m_index);
        }
        
        // verification de la date de l'image
        static float last_time= 0;
        // quelques fois par seconde, ca suffit, pas tres malin de le faire 60 fois par seconde...
        if(global_time() > last_time + 400)
        {
            size_t time= timestamp(m_filenames[m_index].c_str());
            if(time != m_times[m_index])
            {
                // date modifiee, recharger l'image
                printf("reload image '%s'...\n", m_filenames[m_index].c_str());
                
                Image image= read(m_filenames[m_index].c_str());
                if(image.size())
                {
                    m_times[m_index]= time;
                    m_images[m_index]= image;
                    
                    // transfere la nouvelle version
                    glBindTexture(GL_TEXTURE_2D, m_textures[m_index]);
                    glTexImage2D(GL_TEXTURE_2D, 0,
                        GL_RGBA32F, image.width(), image.height(), 0,
                        GL_RGBA, GL_FLOAT, image.data());
                    
                    glGenerateMipmap(GL_TEXTURE_2D);
                }
            }
            
            last_time= global_time();
        }
        
        if(drop_events().size())
        {
            for(unsigned i= 0; i < drop_events().size(); i++)
            {
                const char *filename= drop_events()[i].c_str();
                if(filename && filename[0])
                {
                    //~ printf("drop file [%d] '%s'...\n", int(m_filenames.size()), filename);
                    
                    Image image= read(filename);
                    if(image.size())
                    {
                        m_images.push_back( image );
                        m_filenames.push_back( filename );
                        m_times.push_back( timestamp(filename) );
                        m_textures.push_back( make_texture(0, image) );
                        
                        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_BORDER);
                        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_BORDER);
                    }
                }
                
                printf("index %d\n", m_index);
                for(unsigned i= 0; i < m_filenames.size(); i++)
                    printf("images[%d] '%s'\n", i, m_filenames[i].c_str());
            }
            
            clear_drop_events();
            assert(drop_events().size() == 0);
        }
        
        
        int xmouse, ymouse;
        unsigned int bmouse= SDL_GetMouseState(&xmouse, &ymouse);
        
        glBindVertexArray(m_vao);
        glUseProgram(m_program);
        
        // selection des buffers + filtrage
        GLuint sampler= 0;
        if(!m_smooth)
            sampler= m_sampler_nearest;
        
        program_use_texture(m_program, "image", 0, m_textures[m_index], sampler);
        if(m_reference_index == -1)
            program_use_texture(m_program, "image_next", 1, m_textures[(m_index +1) % m_textures.size()], sampler);
        else
            program_use_texture(m_program, "image_next", 1, m_textures[m_reference_index], sampler);
        
        // activer le split de l'ecran
        if(bmouse & SDL_BUTTON(1))
            program_uniform(m_program, "split", (int) xmouse);
        else
            program_uniform(m_program, "split", (int) window_width() +2);
        
        // parametres
        program_uniform(m_program, "channels", Color(m_red, m_green, m_blue, m_alpha));
        program_uniform(m_program, "gray", float(m_gray));
        program_uniform(m_program, "difference", float(m_difference));
        program_uniform(m_program, "compression", m_compression);
        program_uniform(m_program, "saturation", m_saturation);
        
        // zoom
        if(bmouse & SDL_BUTTON(3))
        {
            SDL_MouseWheelEvent wheel= wheel_event();
            if(wheel.y != 0)
            {
                m_zoom= m_zoom + float(wheel.y) / 4.f;
                if(m_zoom < .1f) m_zoom= .1f;
                if(m_zoom > 10.f) m_zoom= 10.f;
            }
        }
    
        program_uniform(m_program, "center", vec2( float(xmouse) / float(window_width()), float(window_height() - ymouse -1) / float(window_height())));
        if(bmouse & SDL_BUTTON(3))
            program_uniform(m_program, "zoom", m_zoom);
        else
            program_uniform(m_program, "zoom", 1.f);
        
        // graphes / courbes
        if(key_state('g'))
        {
            clear_key_state('g');
            m_graph= (m_graph +1) % 2;
        }
 
        program_uniform(m_program, "graph", int(m_graph));
        program_uniform(m_program, "line", vec2(float(window_height() - ymouse -1) / float(window_height()), float(window_height() - ymouse -1)));
        
        // dessine 1 triangle plein ecran
        glDrawArrays(GL_TRIANGLES, 0, 3);
        
        // actions
        if(key_state('c'))
        {
            clear_key_state('c');
            
            // change l'extension
            std::string file= m_filenames[m_index];
            size_t ext= file.rfind(".");
            if(ext != std::string::npos)
                file= file.substr(0, ext) + "-tone.png";
            
            printf("writing '%s'...\n", file.c_str());
            screenshot(file.c_str());
        }
        
        begin(m_widgets);
            value(m_widgets, "saturation", m_saturation, 0.f, m_saturation_max*10, m_saturation_step);
            value(m_widgets, "compression", m_compression, .1f, 10.f, .1f);
        
            int reset= 0; 
            button(m_widgets, "reset", reset);
            if(reset) range(m_images[m_index]);
 
            int reload= 0; 
            button(m_widgets, "reload", reload);
            if(reload)
            {
                Image image= read(m_filenames[m_index].c_str());
                {
                    m_images[m_index]= image;
                    m_times[m_index]= timestamp(m_filenames[m_index].c_str());
                    
                    // transfere la nouvelle version
                    glBindTexture(GL_TEXTURE_2D, m_textures[m_index]);
                    glTexImage2D(GL_TEXTURE_2D, 0,
                        GL_RGBA32F, image.width(), image.height(), 0,
                        GL_RGBA, GL_FLOAT, image.data());
                    
                    glGenerateMipmap(GL_TEXTURE_2D);                    
                }
            }
            
            int reference= (m_index == m_reference_index) ? 1 : 0;
            if(button(m_widgets, "reference", reference))
            {
                if(reference) m_reference_index= m_index;       // change de reference
                else m_reference_index= -1;     // deselectionne la reference
            }
        
            int export_all= 0;
            button(m_widgets, "export all", export_all);
            if(export_all)
            {
                #pragma omp parallel for
                for(unsigned i= 0; i < m_images.size(); i++)
                {
                    Image image;
                    if(m_gray)
                        image= tone(gray(m_images[i]), m_saturation, m_compression);
                    else
                        image= tone(m_images[i], m_saturation, m_compression);
                    
                    char filename[1024];
                    sprintf(filename, "%s-tone.png", m_filenames[i].c_str());
                    printf("exporting '%s'...\n", filename);
                    write_image(image, filename);
                }
            }
            
        begin_line(m_widgets);
        {
            int px= xmouse;
            int py= window_height() - ymouse -1;
            float x= px / float(window_width()) * m_images[m_index].width();
            float y= py / float(window_height()) * m_images[m_index].height();
            Color pixel= m_images[m_index](x, y);
            label(m_widgets, "pixel %d %d: %f %f %f", int(x), int(y), pixel.r, pixel.g, pixel.b);
        }
 
        begin_line(m_widgets);
            button(m_widgets, "R", m_red);
            button(m_widgets, "G", m_green);
            button(m_widgets, "B", m_blue);
            button(m_widgets, "A", m_alpha);
            button(m_widgets, "gray", m_gray);
            button(m_widgets, "smooth", m_smooth);
            
            if(m_reference_index != -1)
                button(m_widgets, "diff to reference", m_difference);
        
        begin_line(m_widgets);
        {
            static int list= 0;
            button(m_widgets, "select image...", list);
            if(list)
            {
                char tmp[1024];
                for(unsigned i= 0; i < m_filenames.size(); i++)
                {
                    begin_line(m_widgets);
                    sprintf(tmp, "[%u] %s", i, m_filenames[i].c_str());
                    select(m_widgets, tmp, i, m_index);
                }
            }
        }
        
        end(m_widgets);
        
        draw(m_widgets, window_width(), window_height());
        
        if(key_state('s'))
        {
            clear_key_state('s');
            
            static int calls= 0;
            screenshot("screenshot", ++calls);
            printf("screenshot %d...\n", calls);
        }
        
        if(key_state(SDLK_LCTRL) && key_state('w'))
        {
            clear_key_state('w');
            
            m_filenames.erase(m_filenames.begin() + m_index);
            m_times.erase(m_times.begin() + m_index);
            m_images.erase(m_images.begin() + m_index);
            m_textures.erase(m_textures.begin() + m_index);
            if(m_reference_index == m_index)
                m_reference_index= -1;
            
            if(m_textures.empty())
                return 0;
            
            m_index= m_index % int(m_textures.size());
            // change aussi le titre de la fenetre
            title(m_index);
        }
        
        return 1;
    }

Member Data Documentation

◆ m_widgets

Widgets ImageViewer::m_widgets

protected

Definition at line 518 of file image_viewer.cpp.

◆ m_filenames

std::vector<std::string> ImageViewer::m_filenames

protected

Definition at line 520 of file image_viewer.cpp.

◆ m_times

std::vector<size_t> ImageViewer::m_times

protected

Definition at line 521 of file image_viewer.cpp.

◆ m_images

std::vector<Image> ImageViewer::m_images

protected

Definition at line 522 of file image_viewer.cpp.

◆ m_textures

std::vector<GLuint> ImageViewer::m_textures

protected

Definition at line 523 of file image_viewer.cpp.

◆ m_width

unsigned ImageViewer::m_width

protected

Definition at line 524 of file image_viewer.cpp.

◆ m_height

unsigned ImageViewer::m_height

protected

Definition at line 524 of file image_viewer.cpp.

◆ m_program

GLuint ImageViewer::m_program

protected

Definition at line 526 of file image_viewer.cpp.

◆ m_vao

GLuint ImageViewer::m_vao

protected

Definition at line 527 of file image_viewer.cpp.

◆ m_sampler_nearest

GLuint ImageViewer::m_sampler_nearest

protected

Definition at line 528 of file image_viewer.cpp.

◆ m_red

int ImageViewer::m_red

protected

Definition at line 530 of file image_viewer.cpp.

◆ m_green

int ImageViewer::m_green

protected

Definition at line 530 of file image_viewer.cpp.

◆ m_blue

int ImageViewer::m_blue

protected

Definition at line 530 of file image_viewer.cpp.

◆ m_alpha

int ImageViewer::m_alpha

protected

Definition at line 530 of file image_viewer.cpp.

◆ m_gray

int ImageViewer::m_gray

protected

Definition at line 530 of file image_viewer.cpp.

◆ m_smooth

int ImageViewer::m_smooth

protected

Definition at line 531 of file image_viewer.cpp.

◆ m_difference

int ImageViewer::m_difference

protected

Definition at line 532 of file image_viewer.cpp.

◆ m_compression

float ImageViewer::m_compression

protected

Definition at line 534 of file image_viewer.cpp.

◆ m_saturation

float ImageViewer::m_saturation

protected

Definition at line 535 of file image_viewer.cpp.

◆ m_saturation_step

float ImageViewer::m_saturation_step

protected

Definition at line 536 of file image_viewer.cpp.

◆ m_saturation_max

float ImageViewer::m_saturation_max

protected

Definition at line 537 of file image_viewer.cpp.

◆ m_zoom

float ImageViewer::m_zoom

protected

Definition at line 539 of file image_viewer.cpp.

◆ m_index

int ImageViewer::m_index

protected

Definition at line 540 of file image_viewer.cpp.

◆ m_reference_index

int ImageViewer::m_reference_index

protected

Definition at line 541 of file image_viewer.cpp.

◆ m_graph

int ImageViewer::m_graph

protected

Definition at line 542 of file image_viewer.cpp.

The documentation for this struct was generated from the following file:

src/image_viewer.cpp

Public Member Functions

Protected Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ ImageViewer()

Member Function Documentation

◆ range()

◆ tone()

◆ gray()

◆ title()

◆ read()

◆ init()

◆ quit()

◆ render()

Member Data Documentation

◆ m_widgets

◆ m_filenames

◆ m_times

◆ m_images

◆ m_textures

◆ m_width

◆ m_height

◆ m_program

◆ m_vao

◆ m_sampler_nearest

◆ m_red

◆ m_green

◆ m_blue

◆ m_alpha

◆ m_gray

◆ m_smooth

◆ m_difference

◆ m_compression

◆ m_saturation

◆ m_saturation_step

◆ m_saturation_max

◆ m_zoom

◆ m_index

◆ m_reference_index

◆ m_graph