vislu_frame.cpp

Go to the documentation of this file.

#include "vislu_frame.h"
#include <wx/filedlg.h>
#include <wx/msgdlg.h>
#include <wx/valgen.h>
#include <wx/valtext.h>
#include <wx/aboutdlg.h>

namespace
{
    // table that maps GUI values to Viewmode enumerants used by the VolumeCanvas control
    static struct { int value; Viewmode mode; } viewmodemap[] = {
        {0, VM_3D},
        {1, VM_SLICE_X},
        {2, VM_SLICE_Y},
        {3, VM_SLICE_Z}
    };

    int ViewmodeFromVolumeCanvas(Viewmode vm)
    {
        for (int i = 0; i < 4; ++i)
            if (viewmodemap[i].mode == vm) return viewmodemap[i].value;
        return 0;
    }

    Viewmode ViewmodeToVolumeCanvas(int vm)
    {
        for (int i = 0; i < 4; ++i)
            if (viewmodemap[i].value == vm) return viewmodemap[i].mode;
        return VM_SLICE_X;
    }
}

VisLUFrame::VisLUFrame(wxWindow* parent) :
    VisLUFrameBase(parent)
{
    SetExtraStyle(GetExtraStyle() | wxWS_EX_VALIDATE_RECURSIVELY);

    // create the OpenGL canvas and attach it to the appropriate panel
    m_volcanvas = new VolumeCanvas(m_volcanvas_panel, wxID_ANY);
    m_volcanvas_sizer->Add(m_volcanvas, 1, wxEXPAND);

    m_volcanvas_sizer->Layout();

    m_viewmode = ViewmodeFromVolumeCanvas(m_volcanvas->GetViewmode());

    m_slice = 50;
    m_rotx = m_roty = m_rotz = 0;

    // add validators to the controls which transfer the ui state into variables
    m_viewmode_box->SetValidator(wxGenericValidator(&m_viewmode));
    m_slice_slider->SetValidator(wxGenericValidator(&m_slice));
    m_rotx_slider->SetValidator(wxGenericValidator(&m_rotx));
    m_roty_slider->SetValidator(wxGenericValidator(&m_roty));
    m_rotz_slider->SetValidator(wxGenericValidator(&m_rotz));

    // transfer the above settings to the gui.
    TransferDataToWindow();

    SyncUIState();

    // make sure the main frame is shown in the center of the screen
    Center(wxBOTH);
}

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

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 VisLUFrame::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_volcanvas->GetClientRect().GetSize().GetWidth();
    long screenshot_height = m_volcanvas->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 / 2));
        settings_dlg.m_TB_height->SetValidator(ResolutionValidator(&screenshot_height, 100, max_buffer_size / 2));

        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_volcanvas->RenderToFile(full_name, screenshot_width, screenshot_height);
        }
    }
}

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

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

void VisLUFrame::OnOpenTraFu(wxCommandEvent& event)
{
    TraFuData old_data = m_trafu_data;

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

namespace
{
    void ShowLoadingError(wxWindow* parent, const wxString* info)
    {
        wxString message(_("Failed to load volume data."));
        if (info) message += _("\n\nReason:\n") + *info;
        wxMessageBox(message, _("Error"), wxOK | wxCENTER | wxICON_ERROR, parent);
    }
}

void VisLUFrame::OnOpen(wxCommandEvent& event)
{
    wxString caption = _("Open Data File");
    wxString wildcard = _("Volume Data Files (*.dat)|*.dat|All Files (*.*)|*.*");
    wxFileDialog dlg(this, caption, wxEmptyString, wxEmptyString, wildcard, wxOPEN | wxFILE_MUST_EXIST);

    if (dlg.ShowModal() == wxID_OK) {
        try {
            m_volcanvas->OpenFile(dlg.GetPath().fn_str());
            TransferFunctionSamplerFromTraFuDialogData tmp(m_trafu_data);
            m_volcanvas->UpdateTransferFunction(&tmp);
        } catch (const std::exception &e) {
            wxString info = wxString::FromAscii(e.what());
            ShowLoadingError(this, &info);
        } catch (...) {
            ShowLoadingError(this, 0);
        }
    }

    SyncUIState();
}

void VisLUFrame::SyncUIState()
{
    TransferDataFromWindow();

    // update the slider range which selects the slice
    int size;
    switch (m_viewmode) {
    case 1:
        size = m_volcanvas->GetSizeX();
        break;
    case 2:
        size = m_volcanvas->GetSizeY();
        break;
    case 3:
        size = m_volcanvas->GetSizeZ();
        break;
    default:
        size = 100;
        break;
    }

    if (size == 0) size = 100;
    m_slice_slider->SetMax(size);

    m_volcanvas->SetViewmode(ViewmodeToVolumeCanvas(m_viewmode));
    m_volcanvas->SetSlice(m_slice);
    m_volcanvas->Set3dOrientation(m_rotx, m_roty, m_rotz);
    m_volcanvas->Refresh();

    TransferDataToWindow();
}

void VisLUFrame::OnViewmodeChanged(wxCommandEvent& event)
{
    SyncUIState();
}

void VisLUFrame::OnSliceChanged(wxScrollEvent& event)
{
    SyncUIState();
}

void VisLUFrame::OnOrientationChanged(wxScrollEvent& event)
{
    SyncUIState();
}

void VisLUFrame::OnVolcanvasEraseBackground(wxEraseEvent& event)
{
    // do nothing to prevent flickering
}

void VisLUFrame::OnTraFuChanged()
{
    TransferFunctionSamplerFromTraFuDialogData tmp(m_trafu_data);
    m_volcanvas->UpdateTransferFunction(&tmp);
}

---