ImGuiImageWindow< T > Class Template Reference

#include <ImGuiImageWindow.h>

Public Member Functions
	ImGuiImageWindow (const std::string &title, GLuint *tex_id, bool auto_render, int data_cmap, GIM_Flags flags=GIM_Flags::None, bool *visible=nullptr)
void	set_data (int width, int height, std::vector< T > *data)
void	render_window (bool b_redraw, int last_y, int render_update_offset, bool b_trigger_update)
void	render_window (bool b_redraw, int last_y, bool b_trigger_update)
void	reset_min_max ()
void	set_nx_ny (int width, int height)

Public Attributes
bool *	pb_open
ImGuiImageWindow< float > *	fft_window
bool	b_trigger_update

Detailed Description

template<class T>
class ImGuiImageWindow< T >

Definition at line 47 of file ImGuiImageWindow.h.

Constructor & Destructor Documentation

ImGuiImageWindow()

template<typename T >

ImGuiImageWindow< T >::ImGuiImageWindow	(	const std::string &	title,
		GLuint *	tex_id,
		bool	auto_render,
		int	data_cmap,
		GIM_Flags	flags = GIM_Flags::None,
		bool *	visible = nullptr
	)

Definition at line 247 of file ImGuiImageWindow.cpp.

{
 
    this->title = title;
    this->flags = flags;
    this->tex_id = tex_id;
    this->pb_open = visible;
    this->auto_render = auto_render;
    this->data_cmap = data_cmap;
    this->last_y = 0;
    this->last_idr = 0;
    this->last_img = 0;
    this->zoom = 1.0f;
    this->power = 1.0f;
    this->ny = 1;
    this->nx = 1;
    this->nxy = 1;
    this->render_update_offset = 0;
    this->b_trigger_update = false;
    this->bin_factor = 1;
    this->bin_factor_idx = 0;
    saveFileDialog = ImGui::FileBrowser(ImGuiFileBrowserFlags_EnterNewFilename | ImGuiFileBrowserFlags_CreateNewDir);
    saveFileDialog.SetTitle("Save " + title + " image as .png");
    saveDataDialog = ImGui::FileBrowser(ImGuiFileBrowserFlags_EnterNewFilename | ImGuiFileBrowserFlags_CreateNewDir);
    saveDataDialog.SetTitle("Save " + title + "-data as numpy array (.npy)");
 
    uv_min = ImVec2(0.0f, 0.0f);                 // Top-left
    uv_max = ImVec2(1.0f, 1.0f);                 // Lower-right
    tint_col = ImVec4(1.0f, 1.0f, 1.0f, 1.0f);   // No tint
    border_col = ImVec4(1.0f, 1.0f, 1.0f, 0.5f); // 50% opaque white
    sdl_srf = SDL_CreateRGBSurface(0, this->nx, this->ny, 32, 0, 0, 0, 0);
    if (sdl_srf == NULL)
    {
        std::cout << "Surface could not be created! SDL Error: " << SDL_GetError() << std::endl;
    }
    this->b_data_set = false;
}

Member Function Documentation

render_window() [1/2]

template<typename T >

void ImGuiImageWindow< T >::render_window	(	bool	b_redraw,
		int	last_y,
		bool	b_trigger_update
	)

Definition at line 421 of file ImGuiImageWindow.cpp.

{
    ImGui::SetNextWindowSize(ImVec2{256, 256}, ImGuiCond_FirstUseEver);
    bool t_open = ImGui::Begin(title.c_str(), pb_open, ImGuiWindowFlags_NoScrollbar);
    if (t_open)
    {
        bool fr_switch = detect_frame_switch(fr_count);
        b_trigger_update = b_trigger_update || b_trigger_ext || fr_switch;
        if (b_trigger_update)
        {
            render_image();
        }
 
        if (this->has(GIM_Flags::SaveImButton))
        {
            ImGui::SameLine();
            if (ImGui::Button("Save Image as..."))
            {
                saveFileDialog.Open();
            }
            saveFileDialog.Display();
            if (saveFileDialog.HasSelected())
            {
                std::string img_file = saveFileDialog.GetSelected().string();
                saveFileDialog.ClearSelected();
                save_image(&img_file, sdl_srf);
            }
        }
 
        if (this->has(GIM_Flags::SaveDataButton))
        {
            ImGui::SameLine();
            if (ImGui::Button("Save Data as..."))
            {
                saveDataDialog.Open();
            }
            saveDataDialog.Display();
            if (saveDataDialog.HasSelected())
            {
                std::string com_file = saveDataDialog.GetSelected().string();
                saveDataDialog.ClearSelected();
                save_numpy(&com_file, nx, ny, data);
            }
        }
 
        if (this->has(GIM_Flags::FftButton))
        {
            ImGui::SameLine();
            bool fft_button_press = ImGui::Button("Compute FFT");
            if (fft_button_press)
            {
                *fft_window->pb_open = true;
            }
            if (fft_button_press || (*fft_window->pb_open && b_trigger_update))
            {
                if (b_data_set)
                {
                    compute_fft();
                    fft_window->set_data(nx, ny, &data_fft_f);
                    fft_window->b_trigger_update = true;
                }
                else
                {
                    std::cout << "FFT was not performed, because no data was found in " + this->title + "!" << std::endl;
                }
            }
        }
 
        if (this->has(GIM_Flags::PowerSlider))
        {
            ImGui::SameLine();
            ImGui::SetNextItemWidth(64);
            if (ImGui::DragFloat("Power", &power, 0.05f, 0.05f, 2.0f, "%.2f"))
            {
                this->last_idr = 0;
                this->last_y = 0;
                render_image((fr_count == 0) ? nxy : fr_count);
                b_trigger_update = true;
            }
        }
 
        if (this->has(GIM_Flags::ColormapSelector))
        {
            ImGui::SameLine();
            ImGui::SetNextItemWidth(100);
            if (ImGui::Combo("Colormap", &data_cmap, cmaps, IM_ARRAYSIZE(cmaps)))
            {
                this->last_idr = 0;
                this->last_y = 0;
                render_image((fr_count == 0) ? nxy : fr_count);
                b_trigger_update = true;
            }
        }
 
        // Binning selector
        ImGui::SameLine();
        ImGui::SetNextItemWidth(60);
        if (ImGui::Combo("Bin", &bin_factor_idx, bin_options, IM_ARRAYSIZE(bin_options)))
        {
            bin_factor = 1 << bin_factor_idx;  // 0->1, 1->2, 2->4, 3->8
            recreate_surface();
            this->last_idr = 0;
            this->last_y = 0;
            render_image((fr_count == 0) ? nxy : fr_count);
            b_trigger_update = true;
        }
 
        if (b_redraw && auto_render && fr_count > 0)
            render_image(fr_count);
 
        ImGui::SetNextWindowBgAlpha(0.0f);
        ImGui::BeginChildFrame(ImGui::GetID("ImageFrame"), ImVec2(0.0f, 0.0f), ImGuiWindowFlags_NoScrollbar | ImGuiWindowFlags_NoScrollWithMouse);
        ImVec2 vAvail = ImGui::GetContentRegionAvail();
        float scale = (std::min)(vAvail.x / sdl_srf->w, vAvail.y / sdl_srf->h);
        float tex_h = sdl_srf->h * scale;
        float tex_w = sdl_srf->w * scale;
        float tex_h_z = tex_h * zoom;
        float tex_w_z = tex_w * zoom;
        if (b_redraw || b_trigger_update)
        {
            glBindTexture(GL_TEXTURE_2D, (*tex_id));
            glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, sdl_srf->w, sdl_srf->h, 0,
                         GL_BGRA, GL_UNSIGNED_BYTE, sdl_srf->pixels);
        }
        ImVec2 pos = ImGui::GetCursorScreenPos();
        ImGui::Image((ImTextureID)(*tex_id), ImVec2(tex_w_z, tex_h_z), uv_min, uv_max, tint_col, border_col);
        if (ImGui::IsItemHovered())
        {
 
            // Get Mouse Inputs
            float dz = (float)io.MouseWheel;
            ImVec2 xy = ImGui::GetMousePos();
 
            // Compute relative cursor positions
            float rel_x = xy.x - pos.x - ImGui::GetScrollX();
            float rel_y = xy.y - pos.y - ImGui::GetScrollY();
 
            // Adjust Scroll positions
            // Capture Start position of scroll or drag/pan
            if ((std::abs(dz) > 0.0f) || ImGui::IsMouseClicked(ImGuiMouseButton_Left))
            {
                start_x = rel_x;
                start_y = rel_y;
                start_xs = ImGui::GetScrollX();
                start_ys = ImGui::GetScrollY();
            }
 
            // Panning
            if (ImGui::IsMouseDown(ImGuiMouseButton_Left))
            {
                ImGui::SetScrollX(start_xs - (rel_x - start_x));
                ImGui::SetScrollY(start_ys - (rel_y - start_y));
            }
 
            // Zooming
            if (std::abs(dz) > 0.0f)
            {
 
                float zoom2 = zoom + dz * 0.1;
                zoom2 = (std::max)(1.0f, zoom2);
 
                float dx = ((xy.x - pos.x) / tex_w_z) * tex_w * (zoom2 - zoom);
                float dy = ((xy.y - pos.y) / tex_h_z) * tex_h * (zoom2 - zoom);
 
                ImGui::SetScrollX(start_xs + dx);
                ImGui::SetScrollY(start_ys + dy);
 
                zoom = zoom2;
            }
 
            // Value Popup
            if (ImGui::IsMouseDown(ImGuiMouseButton_Right))
            {
                float scale_fct = scale * zoom;
                int x = (int)std::floor((xy.x - pos.x) / scale_fct);
                int y = (int)std::floor((xy.y - pos.y) / scale_fct);
                value_tooltip(x, y, zoom);
            }
            if (ImGui::IsMouseDoubleClicked(ImGuiMouseButton_Left))
            {
                zoom = 1.0f;
                ImGui::SetScrollX(0.0f);
                ImGui::SetScrollY(0.0f);
            }
        }
        ImGui::EndChildFrame();
    }
    ImGui::End();
    b_trigger_update = false;
}

render_window() [2/2]

template<typename T >

void ImGuiImageWindow< T >::render_window	(	bool	b_redraw,
		int	last_y,
		int	render_update_offset,
		bool	b_trigger_update
	)

Definition at line 341 of file ImGuiImageWindow.cpp.

{
    this->render_update_offset = render_update_offset;
    render_window(b_redraw, last_y, b_trigger_update);
}

reset_min_max()

template<typename T >

void ImGuiImageWindow< T >::reset_min_max

(

)

Definition at line 348 of file ImGuiImageWindow.cpp.

{
    data_min = FLT_MAX;
    data_max = -FLT_MAX;
    data_range = FLT_MAX;
}

set_data()

template<typename T >

void ImGuiImageWindow< T >::set_data	(	int	width,
		int	height,
		std::vector< T > *	data
	)

Definition at line 286 of file ImGuiImageWindow.cpp.

{
    this->data = data;
    set_nx_ny(width, height);
    reset_limits();
    if (!auto_render)
    {
        render_image();
    };
    b_data_set = true;
}

set_nx_ny()

template<typename T >

void ImGuiImageWindow< T >::set_nx_ny	(	int	width,
		int	height
	)

Definition at line 310 of file ImGuiImageWindow.cpp.

{
    this->nx = width;
    this->ny = height;
    this->nxy = height * width;
 
    data_fft.resize(nxy);
    data_fft_f.resize(nxy);
    data_val.resize(nxy);
 
    reset_limits();
    recreate_surface();
}

Member Data Documentation

b_trigger_update

template<class T >

bool ImGuiImageWindow< T >::b_trigger_update

Definition at line 58 of file ImGuiImageWindow.h.

fft_window

template<class T >

ImGuiImageWindow<float>* ImGuiImageWindow< T >::fft_window

Definition at line 57 of file ImGuiImageWindow.h.

pb_open

template<class T >

bool* ImGuiImageWindow< T >::pb_open

Definition at line 56 of file ImGuiImageWindow.h.

---

The documentation for this class was generated from the following files:

• src/ImGuiImageWindow.h
• src/ImGuiImageWindow.cpp