trafu_ctrl.cpp

Go to the documentation of this file.

#include <wx/settings.h>
#include <wx/textctrl.h>
#include <wx/colordlg.h>

#include "trafu_ctrl_event.h"
#include "trafu_ctrl.h"

BEGIN_EVENT_TABLE(TransferFunctionCtrlCanvas, wxControl)
    EVT_PAINT(TransferFunctionCtrlCanvas::OnPaint)
    EVT_MOUSE_EVENTS(TransferFunctionCtrlCanvas::OnMouseEvent)
    EVT_SIZE(TransferFunctionCtrlCanvas::OnSize)
END_EVENT_TABLE()

IMPLEMENT_DYNAMIC_CLASS(TransferFunctionCtrlCanvas, wxControl)

void TransferFunctionCtrlCanvas::OnSize(wxSizeEvent& event)
{
}

bool TransferFunctionCtrlCanvas::Create(wxWindow* parent,
                                    wxWindowID id,
                                    const wxPoint& pos,
                                    const wxSize& size,
                                    long style)
{
    if (!wxControl::Create(parent, id, pos, size, style))
        return false;

    SetBackgroundColour(wxSystemSettings::GetColour(wxSYS_COLOUR_WINDOW));

    SetInitialSize(size);

    return true;
}

void TransferFunctionCtrlCanvas::SetHistogramData(const HistogramData *histogramdata)
{
    m_hist_data = histogramdata;
}

void TransferFunctionCtrlCanvas::Init()
{
     m_button_radius = 4;
     
     m_points = 0;

     m_colour_range_height = 35;
}

void TransferFunctionCtrlCanvas::SetTraFuDataPointer(TraFuData *data)
{
    m_points = data;
    m_active_point = m_points->end();
}

void TransferFunctionCtrlCanvas::OnPaint(wxPaintEvent& event)
{
    wxBufferedPaintDC dc(this);

    dc.Clear();

    DrawHist(&dc);

    m_points->Sort();

    Mapping_point_iterator_t last_point;
    Mapping_point_iterator_t iterPoint = last_point = m_points->begin();

    dc.SetPen(wxPen(wxColour(0, 0, 0), 1, wxSOLID));

    for (++iterPoint;
        iterPoint != m_points->end();
        iterPoint++)
    {
        dc.DrawLine(GetPosition(last_point), GetPosition(iterPoint));
        last_point = iterPoint;
    }

    --iterPoint;
    dc.DrawLine(GetPosition(last_point), GetPosition(iterPoint));

    DrawPoints(&dc);

    if(m_active_point != m_points->end())
    {
        dc.SetPen(wxPen(*wxLIGHT_GREY_PEN));
        dc.DrawLine(GetPosition(m_active_point).x,
            0,
            GetPosition(m_active_point).x,
            GetSize().GetHeight());
        dc.DrawLine(0,
            GetPosition(m_active_point).y,
            GetSize().GetWidth(),
            GetPosition(m_active_point).y);
    }

    DrawRange(&dc);
}

void TransferFunctionCtrlCanvas::DrawPoints(wxDC *dc)
{
    wxBrush old_brush = dc->GetBrush();
    wxPen old_pen = dc->GetPen();

    dc->SetPen(wxPen(*wxBLACK));

    for (Mapping_point_iterator_t iterPoint = m_points->begin();
        iterPoint != m_points->end();
        iterPoint++)
    {
        dc->SetBrush(wxBrush(GetColour(*iterPoint)));
        dc->DrawRectangle(GetPosition(iterPoint) - wxPoint(5, 5), wxSize(10, 10));
    }

    dc->SetBrush(old_brush);
    dc->SetPen(old_pen);
}

void TransferFunctionCtrlCanvas::DrawHist(wxDC *dc)
{
    // safety check when there is no histogram data (e.g. no data set loaded yet)
    if (!m_hist_data) return;

    const int width = GetCanvasWidth();
    const unsigned height = GetCanvasHeight();

    const std::vector<float> hist_lines = m_hist_data->ResampleData(width);
    const float max_value = *std::max_element(hist_lines.begin(), hist_lines.end());
    const float scale_factor = height / max_value;

    const wxPen old_pen = dc->GetPen();

    dc->SetPen(wxPen(wxColour(150, 150, 150), 1, wxSOLID));

    for (int x = 0; x < width; ++x)
        dc->DrawLine(x, height - hist_lines[x] * scale_factor, x, height);

    dc->SetPen(old_pen);
}

void TransferFunctionCtrlCanvas::DrawRange(wxDC *dc)
{
    int range_start = GetSize().GetHeight() - m_colour_range_height;
    int range_end = range_start + m_colour_range_height;
    int canvas_width = GetCanvasWidth();

    Mapping_point_vector_t colors = m_points->createDensityVector(canvas_width);

    wxPen old_pen = dc->GetPen();

    for(int i = 0; i < canvas_width; i++)
    {
        dc->SetPen(wxPen(colors[i].m_colour.wx()));
        dc->DrawLine(i, range_start, i, range_end);
    }

    dc->SetPen(old_pen);
}

bool TransferFunctionCtrlCanvas::PointContains(Mapping_point_iterator_t point, const wxPoint &pos)
{
    wxPoint center = GetPosition(point);
    wxPoint margin(5, 5);

    return wxRect(center - margin, center + margin).Contains(pos);
}

Mapping_point_iterator_t TransferFunctionCtrlCanvas::GetHitPoint(const wxPoint &pos)
{
    for (Mapping_point_iterator_t iterPoint = m_points->begin(); iterPoint != m_points->end(); iterPoint++)
        if (PointContains(iterPoint, pos)) return iterPoint;

    return m_points->end();
}

void TransferFunctionCtrlCanvas::OnMouseEvent(wxMouseEvent& event)
{
    //Let's call this an (ugly) safety net
    try
    {
        if (event.GetPosition().y <= GetCanvasHeight()) {
            if (m_active_point != m_points->end()) SetPointPosition(m_active_point, event.GetPosition());

            if (event.ButtonDClick(wxMOUSE_BTN_LEFT)) {
                Mapping_point_iterator_t hit_point = GetHitPoint(event.GetPosition());
                if (hit_point != m_points->end()) {
                    SetMoving(m_active_point, false);

                    wxColourDialog colour_dlg(this);

                    if (wxID_OK == colour_dlg.ShowModal()) {
                        SetColour(*hit_point, colour_dlg.GetColourData().GetColour());
                        NotifyChange();
                    }
                } else AddNewPoint(event.GetPosition());

            } else {
                if (event.ButtonDown(wxMOUSE_BTN_RIGHT)) {
                    Mapping_point_iterator_t hit_point = GetHitPoint(event.GetPosition());
                    if (hit_point != m_points->end() && hit_point != m_active_point) {
                        DeletePoint(hit_point);
                        NotifyChange();
                    }
                }

                if (event.ButtonUp(wxMOUSE_BTN_LEFT)) {
                    Mapping_point_iterator_t hit_point = GetHitPoint(event.GetPosition());
                    if (hit_point == m_points->end()) {
                        if (m_active_point != m_points->end()) SetMoving(m_active_point, false);
                    } else SetMoving(hit_point, (hit_point == m_active_point) ? (false) : (true));
                }
            }
            Refresh();
        }
    }catch(...)
    {
        //Do nothing ... just don't crash
    }
}

void TransferFunctionCtrlCanvas::DeletePoint(Mapping_point_iterator_t target)
{
    if(target->m_flags == TFP_NONE)
    {
        m_points->Delete(target);
    }

    Refresh();
    NotifyChange();
}

void TransferFunctionCtrlCanvas::AddNewPoint(const wxPoint &pos)
{
    wxColourDialog colour_dlg(this);

    if(wxID_OK == colour_dlg.ShowModal())
    {
        m_points->Add(Mapping_data(Density(pos), Opacity(pos), colour_dlg.GetColourData().GetColour()));
        m_points->Sort();

        NotifyChange();
    }
}

void TransferFunctionCtrlCanvas::AddNewPoint(const wxPoint &pos, const wxColour &colour)
{
    m_points->Add(Mapping_data(Density(pos), Opacity(pos), colour));

    NotifyChange();
}

void TransferFunctionCtrlCanvas::SetMoving(Mapping_point_iterator_t target, bool holding)
{
    m_active_point = holding ? target : m_points->end();

    Refresh();
}

void TransferFunctionCtrlCanvas::SetPointPosition(Mapping_point_iterator_t point, const wxPoint &pos)
{
    int secure_x;
    int secure_y = std::min<int>(std::max<int>(pos.y, 0), GetCanvasHeight());

    switch (point->m_flags) {
    case TFP_START:
        secure_x = 0;
        break;
    case TFP_END:
        secure_x = GetCanvasWidth();
        break;
    case TFP_NONE:
        secure_x = std::min<int>(std::max<int>(pos.x, 0), GetCanvasWidth());
        break;
    default:
        break;
    }

    SetPosition(point, wxPoint(secure_x, secure_y));

    NotifyChange();
    Refresh();
}

void TransferFunctionCtrlCanvas::NotifyChange()
{
    wxTransferFunctionEvent event(
        wxEVT_COMMAND_TRANSFERFUNCTION_CHANGED,
        GetId());

    event.SetEventObject(this);
    GetEventHandler()->ProcessEvent(event);
}

---