FilterDialogMean.cpp

/*
 This file is part of the BIAS library (Basic ImageAlgorithmS).

 Copyright (C) 2003-2009    (see file CONTACT for details)
 Multimediale Systeme der Informationsverarbeitung
 Institut fuer Informatik
 Christian-Albrechts-Universitaet Kiel


 BIAS is free software; you can redistribute it and/or modify
 it under the terms of the GNU Lesser General Public License as published by
 the Free Software Foundation; either version 2.1 of the License, or
 (at your option) any later version.

 BIAS is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU Lesser General Public License for more details.

 You should have received a copy of the GNU Lesser General Public License
 along with BIAS; if not, write to the Free Software
 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */

#include <Gui/FilterDialogMean.hh>

using namespace BIAS;

template <class InputST, class OutputST>
FilterDialogMean<InputST, OutputST>
::FilterDialogMean(const Image<InputST>& origImage,
                   wxWindow* parent,
                   wxWindowID id,
                   const wxString& title,
                   const wxString& name)
: FilterDialogBase<InputST, OutputST>(origImage, parent, id, title, name),  
  MeanFilter(Mean<InputST, OutputST>()),
  OldParamVal(1)
{
    this->SizeLabel = new wxStaticText(this,
                                                                         wxID_STATIC,
                                                                         wxT("Size:"),
                                                                         wxDefaultPosition,
                                                                         wxDefaultSize,
                                                                         0);
  this->SizeSpinCtrl = new wxSpinCtrl(this,
                                                                            this->ID_SPINCTRL_MEAN,
                                                                            wxEmptyString,
                                                                            wxDefaultPosition,
                                                                            wxDefaultSize,
                                                                            wxSP_ARROW_KEYS,
                                                                            1,
                                                                            100,
                                                                            1);
  this->SizeSlider = new wxSlider(this,
                                                                    this->ID_SLIDER_MEAN,
                                                                    1,
                                                                    1,
                                                                    100,
                                                                    wxDefaultPosition,
                                                                    wxSize(300, -1),
                                                                    wxSL_HORIZONTAL | wxSL_AUTOTICKS);

    // spinctrl, slider, spacer/spinctrl
    wxBoxSizer* paramSizer = this->GetParamSizer();
    paramSizer->Add(this->SizeLabel, 0, wxALIGN_CENTER_VERTICAL | wxALL, 5);
    paramSizer->Add(this->SizeSpinCtrl, 0, wxALIGN_CENTER_VERTICAL | wxALL, 5);
    paramSizer->Add(this->SizeSlider, 1, wxALIGN_CENTER_VERTICAL | wxALL | wxGROW, 5);

  this->Connect(BIAS::ID_BTN_FILTER_FDB,
                  wxEVT_COMMAND_BUTTON_CLICKED,
                  wxCommandEventHandler(FilterDialogMean::OnFilterButton));

    this->Connect(this->ID_SLIDER_MEAN,
                  wxEVT_SCROLL_CHANGED,
                  wxScrollEventHandler(FilterDialogMean::OnSlider));

    this->Connect(this->ID_SPINCTRL_MEAN,
                  wxEVT_COMMAND_SPINCTRL_UPDATED,
                  wxSpinEventHandler(FilterDialogMean::OnSpinCtrl));

    this->GetParent()->Disable();
    this->CreateStatusBar(1);
    this->GetSizer()->Fit(this);
    this->Centre();
}


template <class InputST, class OutputST>
FilterDialogMean<InputST, OutputST>::~FilterDialogMean()
{
  if (!this->GetParent()->IsEnabled()) {
    this->GetParent()->Enable();
  }
}


/******************************************************************************/
/* ============================== protected ================================= */
/******************************************************************************/

template <class InputST, class OutputST>
void FilterDialogMean<InputST, OutputST>
::OnFilterButton(wxCommandEvent& WXUNUSED(event))
{
  // disable some buttons to avoid interference, e.g. pressing preview during
  // filtering...
  this->EnableSaveButton(false);
  this->EnableFilterButton(false);
  this->EnablePreviewButton(false);
  this->EnableResetButton(false);
  this->EnableCancelButton(false);

  unsigned int size = this->SizeSpinCtrl->GetValue();

  if ((size != this->OldParamVal) && (size > 1)) {

    this->MeanFilter.SetSize(size);
    Image<OutputST> dstImg;

    if (0 != this->MeanFilter.Filter(this->GetOriginalImage(), dstImg)) {

      BIASERR("FilterDialogMean::OnFilterButton: Filter Error");
      this->SetImageIsFiltered(false);
      this->SetStatusText(wxT("ERROR during FILTER"));

    } else {

      this->SetFilteredImage(dstImg);
      this->SetImageIsFiltered(true);
      this->OldParamVal = size;
      wxString msg;
      msg.Printf(wxT("Image Successfully Filtered With Size: %i"), size);
      this->SetStatusText(msg);

    }

  } else if ((size == 1) && (this->GetImageIsFiltered())) {

    this->CopyOriginalImage();
    this->SetImageIsFiltered(false);
    this->OldParamVal = 1;
    this->SetStatusText(wxT("Reseted To Original Image Values"));

  } else { // size == 1 or size == OldParamVal

    this->SetStatusText(wxT("Nothing Done To The Filtered Image"));
  }

  // enable the buttons again
  this->EnableSaveButton();
  this->EnableFilterButton();
  this->EnablePreviewButton();
  this->EnableResetButton();
  this->EnableCancelButton();
}


template <class InputST, class OutputST>
void FilterDialogMean<InputST, OutputST>
::OnResetButton(wxCommandEvent& event)
{
  // call the Base's class OnResetButton() method and pass the event
  this->FilterDialogBase<InputST, OutputST>::OnResetButton(event);
  this->SetImageIsFiltered(false);
  this->SetStatusText(wxT("Filtered Image Reseted"));
}


/******************************************************************************/
/* =============================== private ================================== */
/******************************************************************************/

template <class InputST, class OutputST>
void FilterDialogMean<InputST, OutputST>
::OnSpinCtrl(wxSpinEvent& WXUNUSED(event))
{
    this->SizeSlider->SetValue(this->SizeSpinCtrl->GetValue());
}


template <class InputST, class OutputST>
void FilterDialogMean<InputST, OutputST>
::OnSlider(wxScrollEvent& WXUNUSED(event))
{
    this->SizeSpinCtrl->SetValue(this->SizeSlider->GetValue());
}


/* =================== supported storagetype combinations =================== */
namespace BIAS{
template class FilterDialogMean<unsigned char, unsigned char>;
template class FilterDialogMean<unsigned char, float>;
//template class FilterDialogMean<float, unsigned char>;
template class FilterDialogMean<float, float>;
}