ScaledImageCanvas.cpp

#include "ScaledImageCanvas.hh"

#include <Gui/StringConv.hh>
#include <Base/Image/ImageConvert.hh>
#include <Image/PyramidImage.hh>

using namespace BIAS;
using namespace std;


namespace BIAS {

  enum ScaledImageCanvas_IDs {
    ID_Scale=1,
    ID_Offset,

    ID_Scale_L,
    ID_Scale_R,
    ID_Scale_Steps,

    ID_Offset_L,
    ID_Offset_R,
    ID_Offset_Steps,

    ID_Check_Auto_Sc_Of
  };
}


ScaledImageCanvas::
ScaledImageCanvas(wxWindow* parent, wxStatusBar* sbar,
                  int sbarid, wxWindowID id,
                  const wxPoint& pos, const wxSize& size,
                  long style, const wxString& name)
  : wxPanel(parent, id, pos, size, style, name), scaledf_()
{
  MiaScWi_ = new ImageCanvas(this, sbar, sbarid, -1, wxDefaultPosition,
                             //wxSize(320, 240),
                             wxDefaultSize, wxHSCROLL | wxVSCROLL, name);

  //count of steps in sliders
  slider_sc_digits = 100;
  slider_of_digits = 100;

  ///-------------SIZES---------------
  //Box for values of sliders/slider borders
  box_size.SetHeight(20);
  box_size.SetWidth(85);

  //Box for values of slider steps
  box_size_steps.SetHeight(20);
  box_size_steps.SetWidth(60);

  //Box for CheckBoxes
  box_size_checks.SetHeight(20);
  box_size_checks.SetWidth(150);
  ///---------------------------------

  ///---HISTO/AUTOSCALE CHECK BOXES---
  Check_Auto_Sc_Of_ = new wxCheckBox(this, ID_Check_Auto_Sc_Of,
                                wxT("Auto(Scale/Offset)"), wxDefaultPosition,
                                box_size_checks);
  ///---------------------------------

  wxBoxSizer *hbox_scale = new wxBoxSizer(wxHORIZONTAL);
  wxBoxSizer *hbox_offset = new wxBoxSizer(wxHORIZONTAL);

  //unimplemented !
  DrawRoi_=false;

  MinScale_ =    0.1;
  MaxScale_ =  100.0;
  MinOffSet_= -100.0;
  MaxOffSet_=  100.0;

  ///---SCALE SLIDER---
  int scale_value = (int)(slider_sc_digits/2);
  ScaleSL_ = new wxSlider(this, ID_Scale, scale_value, 0,
                          slider_sc_digits, wxDefaultPosition,
                          wxSize(-1, -1), wxSL_HORIZONTAL);
  scale_old = scale_value;

  double scal_v = ScaleSL_->GetValue();
  ostringstream sc_stream; sc_stream << scal_v;
  Scale_Text_ = new wxStaticText(this, -1, AsciiToWx(sc_stream.str()),
                                 wxDefaultPosition, box_size, wxSP_ARROW_KEYS);
  sc_stream.clear();
  Scale_L_ = new wxTextCtrl(this, ID_Scale_L, wxT("0.1"),
                            wxDefaultPosition, box_size, wxTE_PROCESS_ENTER);
  Scale_R_ = new wxTextCtrl(this, ID_Scale_R, wxT("100.0"),
                            wxDefaultPosition, box_size, wxTE_PROCESS_ENTER);

  //constructing steps-text-window and putting current value in it
  sc_stream << slider_sc_digits;
  wxString value_sc_steps = AsciiToWx(sc_stream.str());
  Scale_Steps_ = new wxSpinCtrl(this, ID_Scale_Steps, value_sc_steps,
                                wxDefaultPosition, box_size_steps,
                                wxSP_ARROW_KEYS, 1, 80000);

  hbox_scale->Add(new wxStaticText( this, -1, _T("Scale: ") ), 0, wxALL, 3);
  hbox_scale->Add(Scale_Text_);
  hbox_scale->Add(new wxStaticText( this, -1, _T(" [ ") ), 0, wxALL, 3);
  hbox_scale->Add(Scale_L_);
  hbox_scale->Add(ScaleSL_, 1, wxALL | wxGROW, 3);
  hbox_scale->Add(Scale_R_);
  hbox_scale->Add(new wxStaticText( this, -1, _T("] Steps: ") ), 0, wxALL, 3);
  hbox_scale->Add(Scale_Steps_);
  hbox_scale->Add(new wxStaticText( this, -1, _T(" | ") ), 0, wxALL, 3);

  wxStaticText* temp = new wxStaticText(this, -1, wxT(""),
                                 wxDefaultPosition, box_size_checks, wxSP_ARROW_KEYS);
  hbox_scale->Add(temp);

  ///------------------

  ///---OFFSET SLIDER---
  int offset_value = (int)(slider_of_digits/2);
  OffsSL_ = new wxSlider(this, ID_Offset, offset_value, 0,
                         slider_of_digits, wxDefaultPosition,
                         wxSize(-1, -1), wxSL_HORIZONTAL);
  offset_old = offset_value;

  ostringstream of_stream; of_stream << OffsSL_->GetValue();
  Offset_Text_ = new wxStaticText(this, -1, AsciiToWx(of_stream.str()),
                                 wxDefaultPosition, box_size, wxSP_ARROW_KEYS);
  of_stream.clear();
  Offset_L_ = new wxTextCtrl(this, ID_Offset_L, wxT("-100.0"),
                             wxDefaultPosition, box_size, wxTE_PROCESS_ENTER);
  Offset_R_ = new wxTextCtrl(this, ID_Offset_R, wxT("100.0"),
                             wxDefaultPosition, box_size, wxTE_PROCESS_ENTER);

  //constructing steps-text-window and putting current value in it
  of_stream << slider_of_digits;
  wxString value_of_steps = AsciiToWx(of_stream.str());
  Offset_Steps_ = new wxSpinCtrl(this, ID_Offset_Steps, value_of_steps,
                                 wxDefaultPosition, box_size_steps,
                                 wxSP_ARROW_KEYS, 1, 80000);

  hbox_offset->Add(new wxStaticText( this, -1, _T("Offset: ") ), 0, wxALL, 3);
  hbox_offset->Add(Offset_Text_);
  hbox_offset->Add(new wxStaticText( this, -1, _T(" [ ") ), 0, wxALL, 3);
  hbox_offset->Add(Offset_L_);
  hbox_offset->Add(OffsSL_, 1, wxALL | wxGROW, 3);
  hbox_offset->Add(Offset_R_);
  hbox_offset->Add(new wxStaticText( this, -1, _T("] Steps: ") ), 0, wxALL, 3);
  hbox_offset->Add(Offset_Steps_);
  hbox_offset->Add(new wxStaticText( this, -1, _T(" | ") ), 0, wxALL, 3);
  hbox_offset->Add(Check_Auto_Sc_Of_);
  ///-------------------

  wxBoxSizer *vbox = new wxBoxSizer(wxVERTICAL);

  vbox->Add(MiaScWi_, 1, wxALL | wxGROW, 0);
  vbox->Add(hbox_scale, 0, wxGROW, 0);
  vbox->Add(hbox_offset, 0, wxGROW, 0);
  vbox->SetSizeHints(this);
  SetSizer(vbox);

  p_StatBar=NULL;

  //Shut the AutoScale/Offset Box ON
  AutoadaptScale_ = true;
  Check_Auto_Sc_Of_->SetValue(AutoadaptScale_);


  //SetScaleRange(0.5, 50.0);
  //SetOffsetRange(-100.0, 100.0);
  SetRanges(0.5, 50.0, -100.0, 100.0);

  //Set that the ranges of sliders were:
  //scale: from 0.1*value to 10*value
  //offset:from value-100 to value+100
  //SetNiceRanges(10.0, 100.0);
}


ScaledImageCanvas::
~ScaledImageCanvas()
{
  if (MiaScWi_) { delete MiaScWi_; MiaScWi_ = NULL; }
  if (ScaleSL_) { delete ScaleSL_; ScaleSL_ = NULL; }
  if (OffsSL_) { delete OffsSL_; OffsSL_ = NULL; }
}


void ScaledImageCanvas::
SetStatusBarPtr(wxStatusBar* p_sbar)
{
  p_StatBar=p_sbar;
}

void ScaledImageCanvas::KeepScrollPosition(bool flag){
  MiaScWi_->KeepScrollPosition(flag);
}


void ScaledImageCanvas::
SetStatusText(const std::string & s){
  if(p_StatBar==NULL){
    wxMessageBox( AsciiToWx(string("p_StatBar NULL. " + s)) );
    return;
  }
  BIASASSERT(p_StatBar!=NULL);
  p_StatBar->SetStatusText(AsciiToWx(s));
}


void ScaledImageCanvas::
RaiseZoomWindow(const bool raise_or_lower)
{
  BIASASSERT(MiaScWi_);
  MiaScWi_->RaiseZoomWindow(raise_or_lower);
}


void ScaledImageCanvas::
Show(ImageBase& im, string name)
{
  ImageName_=name;
  switch (im.GetStorageType()) {
  case ImageBase::ST_float:
    origim_=im;
    break;
    //   case ImageBase::ST_unsignedshortint:
  default:
    ImageConvert::ConvertST(im, origim_, ImageBase::ST_float);
    break;
  }
  scaledf_=(Image<float>)origim_;
  if (AutoadaptScale_) {
    double scale=0, shift=0;
    scaledf_.CalcScaleShift(0.0, 255.0, scale, shift);
    //cout <<"Scale: "<<scale<<"  shift: "<<shift<<endl; 
    double a1, a2, b1, b2;
    if(scale < 0){
      a1 = scale*10; a2 = scale/10;
    }
    else if(scale > 0){
      a1 = scale/10; a2 = scale*10;
    }
    else{
      a1 = 0.0; a2 = 10.0;
    }

    if(shift < 0){
      b1 = shift*10; b2 = shift/10;
    }
    else if(shift > 0){
      b1 = shift/10; b2 = shift*10;
    }
    else{
      b1 = -50.0; b2 = 50.0;
    }

    SetRanges(a1, a2, b1, b2);

    SetOffset(shift, false);
    SetScale(scale, false);
  }
  UpdateScaleOffset();
}


void ScaledImageCanvas::
Show(PyramidImage<float>& pim, string name)
{
  Image<float> im;
  pim.GetSingleImage(im);
  Show(im, name);
}


int ScaledImageCanvas::
SetScale(double c_scale)
{
  return SetScale(c_scale, true);
}


int ScaledImageCanvas::
SetScale(double scale, bool update)
{
  if (scale<MinScale_){
    ScaleSL_->SetValue(0);
    cout << "invalid scale (too small) - clipping it to minimum" << endl;
  }
  else if (scale>MaxScale_){
    ScaleSL_->SetValue(slider_sc_digits);
    cout << "invalid scale (too big) - clipping it to maximum" << endl;
  }
  else{
    int value=(int)rint((scale-MinScale_)*(double)slider_sc_digits/
                        (MaxScale_-MinScale_));
    BIASASSERT(value>=0);
    //BIASASSERT(value<=1000);
    ScaleSL_->SetValue(value);
  }

  if(update)
    UpdateScaleOffset();
  return 0;
}


int ScaledImageCanvas::
SetOffset(double offset)
{
  return SetOffset(offset, true);
}


int ScaledImageCanvas::
SetOffset(double offset, bool update)
{
  if (offset < MinOffSet_){
    OffsSL_->SetValue(0);
    cout << "invalid offset (too small) - clipping it to minimum" << endl;
  }
  else if(offset > MaxOffSet_){
    OffsSL_->SetValue(slider_of_digits);
    cout << "invalid offset (too big) - clipping it to maximum" << endl;
  }
  else{
    int value=(int)rint((offset-MinOffSet_)*(double)slider_of_digits/
                        (MaxOffSet_-MinOffSet_));
    //BIASASSERT(value>=0);
    //BIASASSERT(value<=1000);
    OffsSL_->SetValue(value);
  }

  if(update)
    UpdateScaleOffset();
  return 0;
}

void ScaledImageCanvas::
UpdateScaleOffset()
{
  if (!origim_.IsEmpty()){
    scaledf_=(Image<float>)origim_;
    double sc=1.0, ofs=0.0;

    //REAL VALUES OF SCALE AND OFFSET
    sc=((double)(ScaleSL_->GetValue())*(MaxScale_-MinScale_)/
      (double)slider_sc_digits)+MinScale_;

    ofs=((double)(OffsSL_->GetValue())*(MaxOffSet_-MinOffSet_)/
      (double)slider_of_digits)+MinOffSet_;

    //VALUES OF SLIDERS
    scale_old = ScaleSL_->GetValue();
    offset_old = OffsSL_->GetValue();

    ostringstream sc_stream; sc_stream << sc;
    ostringstream of_stream; of_stream << ofs;

    wxString value_sc = AsciiToWx(sc_stream.str());
    wxString value_of = AsciiToWx(of_stream.str());

    Scale_Text_->SetLabel(value_sc);
    Offset_Text_->SetLabel(value_of);

    //Set NEW VALUES
    ScaleSL_->SetValue(scale_old);
    OffsSL_->SetValue(offset_old);

    //cerr << "Scale: "<<sc<<"\tOffset: "<<ofs<<endl;
    stringstream ss;
    ss<<"scale "<<sc<<" offset: "<<ofs;
    //if (p_parent!=NULL) {
    //  p_parent->SetStatusText(ss.str().c_str() );
    //} else {
    //cout<<ss.str()<<endl;
    //}

    scale_border_l_value = Scale_L_->GetValue();
    scale_border_r_value = Scale_R_->GetValue();
    offset_border_l_value = Offset_L_->GetValue();
    offset_border_r_value = Offset_R_->GetValue();

    scaledf_.ScaleShift(sc, ofs);
    Image<float> scaled_cropped(scaledf_);
    scaled_cropped.BelowThresholdToValue(0.0, 0.0);
    scaled_cropped.AboveThresholdToValue(255.0, 255.0);

    if (ImageConvert::ConvertST(scaled_cropped, ucim_, 
                                ImageBase::ST_unsignedchar)!=0){
        BIASERR("error converting to unsigned char");
      }
      if (ucim_.GetColorModel()!=ImageBase::CM_RGB){
        ImageConvert::Convert(ucim_, rgbim_, ImageBase::CM_RGB);
      } else {
        rgbim_=ucim_;
      }
      MiaScWi_->Show(origim_, rgbim_, ImageName_);

      //BIASASSERT(this->SBar_ != NULL);
      ss.str("");
      ss<<"scale= ";
      ss<<sc;
      ss<<" offset=";
      ss<<ofs;
      //MiaScWi_->SBar_->SetStatusText(ss.str(), 0); // SBarID_ );
      //     cout<<"DBG "<<ss.str()<<endl;
      /// \todo: write ofsfet and scale to StatusText instead of cout (JW)
  }
}


void ScaledImageCanvas::
UpdateScaleOffsetBorders()
{
  double scale = ((double)(ScaleSL_->GetValue())*(MaxScale_-MinScale_)/
                  (double)slider_sc_digits)+MinScale_;

  double offset = ((double)(OffsSL_->GetValue())*(MaxOffSet_-MinOffSet_)/
                   (double)slider_of_digits)+MinOffSet_;

  //CHECK IF VALUES IN BORDER-VALUE-TEXTS ARE CORRECT
  double scale_l = atof(WxToAscii(Scale_L_->GetValue()));
  double scale_r = atof(WxToAscii(Scale_R_->GetValue()));

  if(scale_l > scale_r){
    //that means that Scale-right-border was changed
    if(scale_l_old == scale_l){
      ostringstream sc_stream;
      sc_stream << scale_l;
      Scale_R_->SetValue(AsciiToWx(sc_stream.str()));
      scale_r = scale_l;
    }
    //that means that Scale-left-border was changed
    if(scale_r_old == scale_r){
      ostringstream sc_stream;
      sc_stream << scale_r;
      Scale_L_->SetValue(AsciiToWx(sc_stream.str()));
      scale_l = scale_r;
    }
  }

  //UPDATE MIN_SCALE, MAX_SCALE
  MinScale_ = scale_l;
  MaxScale_ = scale_r;

  scale_l_old = scale_l;
  scale_r_old = scale_r;

  //CHECK IF VALUES IN BORDER-VALUE-TEXTS ARE CORRECT
  double offset_l = atof(WxToAscii(Offset_L_->GetValue()));
  double offset_r = atof(WxToAscii(Offset_R_->GetValue()));

  if(offset_l > offset_r){
    //that means thant Scale-right-border was changed
    if(offset_r_old != offset_r){
      ostringstream of_stream;
      offset_r = offset_l;
      of_stream << offset_r;
      Offset_R_->SetValue(AsciiToWx(of_stream.str()));
    }
    //that means thant Scale-left-border was changed
    else if(offset_l_old != offset_l){
      ostringstream of_stream;
      offset_l = offset_r;
      of_stream << offset_l;
      Offset_L_->SetValue(AsciiToWx(of_stream.str()));
    }
  }

  offset_l_old = offset_l;
  offset_r_old = offset_r;

  //UPDATE MIN_OFFSET, MAX_OFFSET
  MinOffSet_ = offset_l;
  MaxOffSet_ = offset_r;

  //UPDATE SCALE OFFSET SLIDERS (+STEPS)

  int scale_new =(int)rint((scale - MinScale_)*(double)slider_sc_digits/
                           (MaxScale_ - MinScale_));
  int offset_new = (int)rint((offset - MinOffSet_)*(double)slider_of_digits/
                             (MaxOffSet_ - MinOffSet_));

  if(scale_new > (int)slider_sc_digits)
    ScaleSL_->SetValue((int)slider_sc_digits);
  else if(scale_new < 0)
    ScaleSL_->SetValue((int)0);
  else
    ScaleSL_->SetValue((int)scale_new);

  if(offset_new > (int)slider_of_digits)
    OffsSL_->SetValue((int)slider_of_digits);
  else if(offset_new < 0)
    OffsSL_->SetValue((int)0);
  else
    OffsSL_->SetValue((int)offset_new);
}


ImageCanvas* ScaledImageCanvas::
GetImageCanvas()
{
  return MiaScWi_;
}


BIAS::ImageBase & ScaledImageCanvas::
GetOrigimg()
{
  return origim_;
}

BIAS::ImageBase& ScaledImageCanvas::GetShownImage()
{
  return scaledf_;
}


BEGIN_EVENT_TABLE (ScaledImageCanvas, wxPanel)
EVT_CHECKBOX(ID_Check_Auto_Sc_Of, ScaledImageCanvas::OnAutoScaleOffset)

EVT_TEXT_ENTER(ID_Scale_L, ScaledImageCanvas::OnScaleOffsetBorders)
EVT_TEXT_ENTER(ID_Scale_R, ScaledImageCanvas::OnScaleOffsetBorders)
EVT_SPINCTRL(ID_Scale_Steps, ScaledImageCanvas::OnScaleOffsetSteps)

EVT_TEXT_ENTER(ID_Offset_L, ScaledImageCanvas::OnScaleOffsetBorders)
EVT_TEXT_ENTER(ID_Offset_R, ScaledImageCanvas::OnScaleOffsetBorders)
EVT_SPINCTRL(ID_Offset_Steps, ScaledImageCanvas::OnScaleOffsetSteps)
EVT_MOUSEWHEEL (ScaledImageCanvas::OnMouseWheel)
EVT_SCROLL(ScaledImageCanvas::OnScaleOffset)
END_EVENT_TABLE()


void ScaledImageCanvas::
SetRanges(double value_sc_double_l,
          double value_sc_double_r,
          double value_of_double_l,
          double value_of_double_r){
  ostringstream sc_stream_l; sc_stream_l << value_sc_double_l;
  Scale_L_->SetValue(AsciiToWx(sc_stream_l.str()));
  ostringstream sc_stream_r; sc_stream_r << value_sc_double_r;
  Scale_R_->SetValue(AsciiToWx(sc_stream_r.str()));

  ostringstream of_stream_l; of_stream_l << value_of_double_l;
  Offset_L_->SetValue(AsciiToWx(of_stream_l.str()));
  ostringstream of_stream_r; of_stream_r << value_of_double_r;
  Offset_R_->SetValue(AsciiToWx(of_stream_r.str()));

  UpdateScaleOffsetBorders();
  UpdateScaleOffset();
}


void ScaledImageCanvas::
GetScaleParameters(bool   &Auto,
                   double &value_sc_double_l,
                   double &value_sc_double_r,
                   double &value_of_double_l,
                   double &value_of_double_r,
                   double &scale,
                   double &offset,
                   int    &value_sc_steps,
                   int    &value_of_steps)
{
  value_sc_steps = Scale_Steps_->GetValue();
  value_of_steps = Offset_Steps_->GetValue();

  scale=((double)(ScaleSL_->GetValue())*(MaxScale_-MinScale_)/
         (double)slider_sc_digits)+MinScale_;

  offset=((double)(OffsSL_->GetValue())*(MaxOffSet_-MinOffSet_)/
          (double)slider_of_digits)+MinOffSet_;
   
  value_sc_double_l = atof(WxToAscii(Scale_L_->GetValue()));
  value_sc_double_r = atof(WxToAscii(Scale_R_->GetValue()));    
  value_of_double_l = atof(WxToAscii(Offset_L_->GetValue()));
  value_of_double_r = atof(WxToAscii(Offset_R_->GetValue()));
  Auto = AutoadaptScale_;
}


void ScaledImageCanvas::
SetScaleParameters(bool   Auto,
                   double value_sc_double_l,
                   double value_sc_double_r,
                   double value_of_double_l,
                   double value_of_double_r,
                   double scale,
                   double offset,
                   int    value_sc_steps,
                   int    value_of_steps)
{    
    
  Check_Auto_Sc_Of_->SetValue(Auto);   
  SetAutoadaptScale(Auto); 
  if(Auto)
    {
      AutoScale_();
    }
  else
    {         
      Scale_Steps_->SetValue(value_sc_steps);      
      Offset_Steps_->SetValue(value_of_steps);
      
      SetScaleRange(value_sc_double_l,value_sc_double_r); //sets  MinScale_,MaxScale_
      SetOffsetRange(value_of_double_l,value_of_double_r); //sets MinOffSet_, MaxOffSet_
               
      SetRanges(value_sc_double_l,value_sc_double_r
                ,value_of_double_l,value_of_double_r); 

      SetScale(scale);
      SetOffset(offset);          
    } 
}

void ScaledImageCanvas::
SetNiceRanges(double scale_factor,
                                      double offset_factor){
  //correct the real slider-values from the beginning
  ScaleSL_->SetValue((int)rint((double)(ScaleSL_->GetValue())));
  OffsSL_->SetValue((int)rint((double)(OffsSL_->GetValue())));

  if(scale_factor > 0.0 &&
     offset_factor > 0.0){
    //get real scale and offset values
    double value_sc_double = ((double)(ScaleSL_->GetValue())*
                              (MaxScale_-MinScale_)/
                              (double)slider_sc_digits)+MinScale_;
    double value_of_double = ((double)(OffsSL_->GetValue())*
                              (MaxOffSet_-MinOffSet_)/
                              (double)slider_of_digits)+MinOffSet_;

    //set borders of sliders as scale: (scale_value/scale_factor,
    //                                  scale_value*scale_factor);
    //                         offset: (offset_value-offset_factor,
    //                                  offset_value+offset_factor);

    double value_sc_double_l = value_sc_double/scale_factor;
    ostringstream sc_stream_l; sc_stream_l << value_sc_double_l;
    Scale_L_->SetValue(AsciiToWx(sc_stream_l.str()));
    double value_sc_double_r = value_sc_double*scale_factor;
    ostringstream sc_stream_r; sc_stream_r << value_sc_double_r;
    Scale_R_->SetValue(AsciiToWx(sc_stream_r.str()));

    double value_of_double_l = value_of_double-offset_factor;
    ostringstream of_stream_l; of_stream_l << value_of_double_l;
    Offset_L_->SetValue(AsciiToWx(of_stream_l.str()));
    double value_of_double_r = value_of_double+offset_factor;
    ostringstream of_stream_r; of_stream_r << value_of_double_r;
    Offset_R_->SetValue(AsciiToWx(of_stream_r.str()));

    UpdateScaleOffsetBorders();
    UpdateScaleOffset();
  }
}


void ScaledImageCanvas::
OnScaleOffset(wxScrollEvent & )
{
  if(scale_old != ScaleSL_->GetValue() ||
     offset_old != OffsSL_->GetValue()){
    AutoadaptScale_ = false;
    Check_Auto_Sc_Of_->SetValue(false);
    UpdateScaleOffset();
  }
}


void ScaledImageCanvas::
OnScaleOffsetBorders(wxCommandEvent & )
{
  if(scale_border_l_value != Scale_L_->GetValue() ||
     scale_border_r_value != Scale_R_->GetValue() ||
     offset_border_l_value != Offset_L_->GetValue() ||
     offset_border_r_value != Offset_R_->GetValue()){
    UpdateScaleOffsetBorders();
    /**
    cout << MinScale_ << " to " << MaxScale_ << " - Scale Bord" << endl;
    cout << MinOffSet_ << " to " << MaxOffSet_ << " - Offset Bord" << endl;
    **/
    UpdateScaleOffset();
    /**
    cout << MinScale_ << " to " << MaxScale_ << " - Scale Update" << endl;
    cout << MinOffSet_ << " to " << MaxOffSet_ << " - Offset Update" << endl;
    **/
  }
}


void ScaledImageCanvas::
OnScaleOffsetSteps(wxSpinEvent & )
{
  //UPDATE SLIDER-VALUES
  int value_sc_steps_new = Scale_Steps_->GetValue();
  int value_of_steps_new = Offset_Steps_->GetValue();

  double diff_sc = ((double)value_sc_steps_new)/((double)slider_sc_digits);
  if(diff_sc != 1.0){
    ScaleSL_->SetValue((int)rint((double)ScaleSL_->GetValue()*diff_sc));
    ScaleSL_->SetRange(0, value_sc_steps_new);
  }

  double diff_of = ((double)value_of_steps_new)/((double)slider_of_digits);
  if(diff_of != 1.0){
    OffsSL_->SetValue((int)rint((double)OffsSL_->GetValue()*diff_of));
    OffsSL_->SetRange(0, value_of_steps_new);
  }

  slider_sc_digits = value_sc_steps_new;
  slider_of_digits = value_of_steps_new;

  cout << endl;
  cout << slider_sc_digits << endl;
  cout << slider_of_digits << endl;

  UpdateScaleOffset();
}


void ScaledImageCanvas::
OnAutoScaleOffset(wxCommandEvent& /*event*/)
{
  if(origim_.GetStorageType() == ImageBase::ST_float) {
    AutoadaptScale_ = !AutoadaptScale_;
    AutoScale_();
    UpdateScaleOffset();
  }
}

void ScaledImageCanvas::
OnMouseWheel(wxMouseEvent &event){
   //should be handled by the ImageCanvas function OnMouseWheel
   event.Skip();
}


void ScaledImageCanvas::
AutoScale_()
{
  if (AutoadaptScale_) {
    double scale=0, shift=0;
    scaledf_=(Image<float>)origim_;
    scaledf_.CalcScaleShift(0.0, 255.0, scale, shift);

    double a1, a2, b1, b2;
    if(scale < 0){
      a1 = scale*10; a2 = scale/10;
    }
    else if(scale > 0){
      a1 = scale/10; a2 = scale*10;
    }
    else{
      a1 = 0.0; a2 = 10.0;
    }

    if(shift < 0){
      b1 = shift*10; b2 = shift/10;
    }
    else if(shift > 0){
      b1 = shift/10; b2 = shift*10;
    }
    else{
      b1 = -50.0; b2 = 50.0;
    }

    SetRanges(a1, a2, b1, b2);

    SetScale(scale, false);
    SetOffset(shift, false);
  }
}


void ScaledImageCanvas::
OnHisto(wxCommandEvent& /*event*/)
{}