flowvis_frame.cpp

Go to the documentation of this file.

#include "flowvis_frame.h"
#include "trafu_dialog.h"

#include <wx/filedlg.h>
#include <wx/image.h>
#include <wx/valgen.h>
#include <wx/spinctrl.h>
#include <wx/aboutdlg.h>
#include <wx/msgdlg.h>
#include <wx/valtext.h>

#include <stdexcept>

namespace
{
    struct TransferFunctionSamplerFromTraFuDialogData: public TransferFunctionSampler {
        Mapping_point_vector_t density_vector;

        TransferFunctionSamplerFromTraFuDialogData(TraFuData &data)
        {
            density_vector = data.createDensityVector(4096);
        }

        Color MapDensity(float density)
        {
            const int index = static_cast<int> (density * 4095);
            const Mapping_point_t &temp = density_vector[index];
            Color result;
            result.r = temp.m_colour.red / 255.0f;
            result.g = temp.m_colour.green / 255.0f;
            result.b = temp.m_colour.blue / 255.0f;
            result.a = temp.m_opacity;
            return result;
        }
    };
}

FlowVisFrame::FlowVisFrame(wxWindow* parent)
    : FlowVisFrameBase(parent)
    , m_data(0)
{
    SyncUI();

    // create the OpenGL canvas and attach it to the appropriate panel
    try
    {
        m_flowcanvas = new FlowVisCanvas(m_flowcanvas_panel, wxID_ANY);
        m_flowcanvas_sizer->Add(m_flowcanvas, 1, wxEXPAND);

        m_flowcanvas_sizer->Layout();

        TransferSLPlotSettings();
        TransferCalcSettings();
    }catch(std::runtime_error &e)
    {
        //TODO: Code for problems with shader initialization
        wxMessageBox(wxString::FromAscii((e.what())), _T("Critical Error"), wxOK);
        Close();
    }
}

void FlowVisFrame::OnExit(wxCommandEvent &event)
{
    Close();
}

void FlowVisFrame::OnOpen(wxCommandEvent &event)
{
    wxString caption = _("Choose Grid File");
    wxString wildcard = _("Flowdata Grid Files (*.gri)|*.gri|All Files (*.*)|*.*");
    wxFileDialog dlg(this, caption, wxEmptyString, wxEmptyString, wildcard, wxOPEN | wxFILE_MUST_EXIST);

    if(dlg.ShowModal() == wxID_OK)
    {
        try
        {
            m_data = std::auto_ptr<FlowVisData>(new FlowVisData());

            wxString sole_name = dlg.GetFilename();
            m_data->LoadFromFile(dlg.GetPath().fn_str());

            m_trafu_datas.clear();
            for(int i = 0; i < m_data->GetNrSets(); i++)
            {
                m_trafu_datas.push_back(TraFuData());
            }

            SyncUI();

            m_flowcanvas->SetData(m_data);

            OnTraFuChanged();
        }catch(...)
        {
            //TODO: React on loading errors
        }
    }
}

void FlowVisFrame::SyncUI()
{
    if(m_trafu_datas.size())
    {
        m_BG_TF->Enable(true);
        m_B_apply_settings->Enable(true);
    }else
    {
        m_BG_TF->Enable(false);
        m_B_apply_settings->Enable(false);
    }

    m_BG_sets->Clear();
    
    int i = 0;

    for(; m_data.get() && i < m_data->GetNrSets(); i++)
    {
        wxString entry(wxT("Data - "));
        entry << i;
        m_BG_sets->Append(entry);
    }

    if(i)
    {
        m_BG_sets->Enable(true);
        m_BG_sets->SetSelection(0);
        m_current_set = 0;
    }else
    {
        m_BG_sets->Enable(false);
    }
}

void FlowVisFrame::OnBGOpenTraFu(wxCommandEvent& event)
{
    TraFuData old_data = m_trafu_datas[m_current_set];

    TraFuDialog dialog(this, &(m_trafu_datas[m_current_set]), 0);
    if (wxID_OK == dialog.ShowModal()) {
        // update the transfer function.
        TransferFunctionSamplerFromTraFuDialogData tmp(m_trafu_datas[m_current_set]);
        //m_volcanvas->UpdateTransferFunction(&tmp);
    } else {
        m_trafu_datas[m_current_set] = old_data;
    }
}

void FlowVisFrame::OnBGComboChange(wxCommandEvent& event)
{
    m_current_set = m_BG_sets->GetSelection();
    m_flowcanvas->SetBackgroundSet(m_BG_sets->GetSelection());
    OnTraFuChanged();
}

void FlowVisFrame::OnTraFuChanged()
{
    TransferFunctionSamplerFromTraFuDialogData tmp(m_trafu_datas[m_current_set]);
    m_flowcanvas->UpdateTransferFunction(&tmp, m_current_set);
}

void FlowVisFrame::OnChangeNrArrows(wxSpinEvent& event)
{
    m_flowcanvas->SetArrows(m_arrows_x_spin->GetValue(), m_arrows_y_spin->GetValue());
}

void FlowVisFrame::OnArrowOpenTraFu(wxCommandEvent& event)
{
}

void FlowVisFrame::OnPlotSettingsChange(wxCommandEvent& event)
{
    m_flowcanvas->SetArrowPlot(m_CB_plot_arrows->GetValue());
    m_flowcanvas->SetBackgroundPlot(m_CB_plot_background->GetValue());
}

void FlowVisFrame::OnAbout(wxCommandEvent& event)
{
    wxAboutDialogInfo info;
    info.SetVersion(wxT("1.0.0"));
    info.SetDescription(_("Flow visualisation tool for the VisLU lab course"));
    info.AddDeveloper(wxT("Markus Trenkwalder"));
    info.AddDeveloper(wxT("Stefan Kollmann"));
    wxAboutBox(info);
}

void FlowVisFrame::OnGlyphDensitChanged(wxScrollEvent& event)
{
    TransferSLPlotSettings();
    m_flowcanvas->Refresh();
}

void FlowVisFrame::OnSLColorChange(wxColourPickerEvent& event)
{
    TransferSLPlotSettings();
    m_flowcanvas->Refresh();
}

void FlowVisFrame::OnSLPlotSettingsChange(wxCommandEvent& event)
{
    TransferSLPlotSettings();
    m_flowcanvas->Refresh();
}

void FlowVisFrame::TransferSLPlotSettings()
{
    m_flowcanvas->SetStreamlinePlot(m_CB_plot_streamlines->GetValue());
    m_flowcanvas->SetLineColor(m_CC_streamline_color->GetColour());
    m_flowcanvas->SetLineTapering(m_CB_plot_tapering->GetValue());
    m_flowcanvas->SetLineGlyphs(m_CB_plot_glyphs->GetValue());
    m_flowcanvas->SetGlyphDensity(m_SL_gyph_density->GetValue());
}

void FlowVisFrame::OnApplyCalcSettings(wxCommandEvent& event)
{
    TransferCalcSettings();
    m_flowcanvas->Prepare_Streamlines();
    m_flowcanvas->Refresh();
}

void FlowVisFrame::TransferCalcSettings()
{
    m_flowcanvas->SetIntegType(m_C_streamline_interpolation->GetSelection());
    m_flowcanvas->SetMaxIter(m_SL_maxiter->GetValue());
    m_flowcanvas->SetDtest(m_SP_dtest->GetValue() / 1024.0f);
    m_flowcanvas->SetDsep(m_SP_dsep->GetValue() / 1024.0f);
    m_flowcanvas->SetStepSize(m_SP_stepsize->GetValue() / 1024.0f);
}

namespace {
    class ResolutionValidator : public wxTextValidator
    {
    public:
        ResolutionValidator(long *target, int min_value, int max_value)
            : wxTextValidator(wxFILTER_NUMERIC, &m_string_target)
            , m_target(target)
            , m_max_value(max_value)
            , m_min_value(min_value)
            , m_string_target(wxT(""))
        {
            m_string_target.sprintf(wxT("%d"), *target);
        }

        bool TransferFromWindow()
        {
            //Transfer data from control to local string member AND further to remote int member (*m_target)
            return (wxTextValidator::TransferFromWindow())?(m_string_target.ToLong(m_target)):(false);
        }

        bool Validate(wxWindow *parent)
        {
            long temp_value;

            //return if Base-wxTextValidator fails
            if(!wxTextValidator::Validate(parent)) return false;
            //return if data of text control can not be converted to int
            if(!static_cast<wxTextCtrl *>(GetWindow())->GetValue().ToLong(&temp_value, 10)) return false;
            //return if entered value doesn't meet min/max requirements
            if(temp_value > m_max_value || temp_value < m_min_value) return false;
            //return successfull if all of the above worked
            return true;
        }

        wxObject* Clone() const
        {
            return new ResolutionValidator(m_target, m_min_value, m_max_value);
        }

    private:
        wxString m_string_target;
        long *m_target;
        int m_max_value;
        int m_min_value;
    };
}

void FlowVisFrame::OnSave(wxCommandEvent& event)
{
    wxString caption = _("Save Screenshot");
    wxList image_handlers = wxImage::GetHandlers();
    wxImageHandler *current_handler = static_cast<wxImageHandler *>(image_handlers[0]);
    wxString wildcard = current_handler->GetName() + wxT(" (*.") + current_handler->GetExtension() + wxT(")|*.") + current_handler->GetExtension();
    int filter_index_png;

    for(unsigned int i = 1; i < image_handlers.GetCount(); i++)
    {
        current_handler = static_cast<wxImageHandler *>(image_handlers[i]);
        wildcard.append(wxT("|") + current_handler->GetName() + wxT(" (*.") + current_handler->GetExtension() + wxT(")|*.") + current_handler->GetExtension());
        if(current_handler->GetExtension() == wxT("png"))
        {
            filter_index_png = i;
        }
    }

    wxFileDialog dlg(this, caption, wxEmptyString, wxEmptyString, wildcard, wxSAVE);

    GLint max_buffer_size;
    long screenshot_width = m_flowcanvas->GetClientRect().GetSize().GetWidth();
    long screenshot_height = m_flowcanvas->GetClientRect().GetSize().GetHeight();

    glGetIntegerv(GL_MAX_RENDERBUFFER_SIZE_EXT, &max_buffer_size);

    dlg.SetFilterIndex(filter_index_png);

    if (dlg.ShowModal() == wxID_OK) {
        ScreenShotDialog settings_dlg(this);

        settings_dlg.m_TB_width->SetValidator(
            ResolutionValidator(&screenshot_width, 100, max_buffer_size));
        settings_dlg.m_TB_height->SetValidator(ResolutionValidator(&screenshot_height, 100, max_buffer_size));

        if (settings_dlg.ShowModal() == wxID_OK) {
            //Retrieve filename and complete it if neccessary
            wxString full_name = dlg.GetPath();
            if (full_name.rfind(wxT(".")) == -1) {
                full_name.append(wxT("."));
                full_name.append(static_cast<wxImageHandler *> (image_handlers[dlg.GetFilterIndex()])->GetExtension());
            }
            m_flowcanvas->RenderToFile(full_name, screenshot_width, screenshot_height);
        }
    }
}

---