ImageViewer Struct Reference

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. More...
int	quit ()
	a deriver pour detruire les objets openGL. renvoie -1 pour indiquer une erreur, 0 sinon. More...
int	render ()
	a deriver pour afficher les objets. renvoie 1 pour continuer, 0 pour fermer l'application. More...
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. More...
virtual int	update (const float time, const float delta)
	a deriver et redefinir pour animer les objets en fonction du temps. More...
int	run ()
	execution de l'application. More...

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
int	m_width
int	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.

Member Function Documentation

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;
    }

---

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

• src/image_viewer.cpp