HistoImageCanvas.cpp

#include "HistoImageCanvas.hh"

#include <Gui/StringConv.hh>

#include <wx/dcbuffer.h>

using namespace BIAS;
using namespace std;


HistoImageCanvas::
HistoImageCanvas(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)
{
  SetMinSize(wxSize(294, 219));
  
//  cout << "SIZE OF HISTOCANVAS INPUT " <<size.GetWidth()
//       << "x" << size.GetHeight() << endl;

  //default values
  histo_float_steps = 256;
  histo_type = -1;
  histo_channels = 0;

  histo_float_min = 0.0;
  histo_float_step = 0.0;

  //Pointer to the main statusbar in the histoframe
  SBar_ = sbar;
  //# of the field in the statusbar to be filled with histogramm-value
  SBarID_=sbarid;

  //Histogramm is shown 1step/1pxl (1xhistogramm)
  //  also available 2xZoom (1step/2pxl),
  //                 3xZoom and
  //                 4xZoom
  histoZoom_ = 1;

  //sometimes in WIN it doesn't repaint the canvas after initializing it
  wxPaintEvent ev;
  OnPaint(ev);
}


HistoImageCanvas::
~HistoImageCanvas()
{}


BEGIN_EVENT_TABLE (HistoImageCanvas, wxWindow)
  EVT_MOTION        (HistoImageCanvas::OnMouseMove)
  EVT_LEAVE_WINDOW  (HistoImageCanvas::OnMouseLeave)
  EVT_PAINT         (HistoImageCanvas::OnPaint)
  //EVT_MOTION      (HistoImageCanvas::OnMouseMove)
  //EVT_CHAR        (HistoFrame::OnKey)
  EVT_SIZE          (HistoImageCanvas::OnResize)
  //EVT_LEAVE_WINDOW(HistoImageCanvas::OnMouseLeave)
END_EVENT_TABLE()


void HistoImageCanvas::
OnMouseLeave(wxMouseEvent&)
{
  if (SBar_){ SBar_->SetStatusText(wxT(""), SBarID_); }
  mousex_=mousey_=0;
}


void HistoImageCanvas::
OnMouseMove(wxMouseEvent &event)
{
  wxClientDC dc(this);
  PrepareDC(dc);
  wxPoint pos = event.GetPosition();
  mousex_ = dc.DeviceToLogicalX( pos.x );
  mousey_ = dc.DeviceToLogicalY( pos.y );
  UpdateStatusBar((unsigned) mousex_, (unsigned) mousey_);
}


void HistoImageCanvas::
UpdateStatusBar(unsigned mouseX, unsigned mouseY)
{
  wxPoint pos = GetPosition();
  // compute original coordinate for HistoImageCanvas canvas
  int ix=(int)mouseX-(int)pos.x;
  int iy=(int)mouseY-(int)pos.y;

  wxSize sz = GetClientSize();
  int hei = sz.y;
#ifdef WIN32
  //fixing some strange bug in windows when painting things
  hei-=40;
  ix+=2;
#endif

  int slice = (int)((hei-20)/histo_channels);

  ostringstream os;
  int cur_step = (int)((ix-10)/histoZoom_);
  int cur_channel = (int)((iy-10)/slice);

  if(cur_channel>=0 && cur_channel<histo_channels){
    if(histo_type == 0 && cur_step>=0 && cur_step<256){
      os << "UnsignedChar (Channel " << cur_channel
         << ") - Value " << cur_step
         << " (" << 100.0*histo_percentage [cur_channel][cur_step]
         << "% Total)";
    }
    else if(histo_type == 1 && cur_step>=0 && cur_step<histo_float_steps &&
            histo_float_step != 0.0){
      os << "Float (Channel " << cur_channel
         << ") - Value " << histo_float_step*(float)cur_step + histo_float_min
         << " to " << histo_float_step*((float)cur_step+1.0) + histo_float_min
         << " (" << 100.0*histo_percentage [cur_channel][cur_step]
         << "% Total)";
    }
  }

  //display Histogramm value:
  SBar_->SetStatusText(AsciiToWx(os.str()), SBarID_);
}


//CALCULATE HISTOGRAMM OF CURRENT IMAGE
void HistoImageCanvas::
UpdateHistogramm(ImageBase image){

  histo_size = image.GetWidth()*image.GetHeight();

  //little pixelsum-check
  if(histo_size <= 0)
        BIASERR("No image for HISTOGRAMMS presented!");

  histo_channels = image.GetChannelCount();
  if(histo_channels<=0 || histo_channels>=9){
    cout << "Invalid amount of channels (allowed only 1, 2, 3, ..., 8 "
         << "channels in the image" << endl;
    histo_type = -1;
    histo_channels = 0;
    return;
  }

  //preaparations
  histo_percentage.clear();
  histo_percentage_biggest.clear();

  std::vector<float> dummy_percentage;

  histo_type = -1;
  switch (image.GetStorageType()){
  case ImageBase::ST_unsignedchar:
    {
      //debug-message
      //cout << "UNSIGNED CHAR" << endl;

      histo_type = 0;

      histo_UC.clear();

      //preparations
      std::vector<int>   dummy;
      for (int i = 0; i < histo_channels; i++){
        dummy.clear();
        dummy_percentage.clear();
        for (int j = 0; j < 256; j++){
          dummy.push_back(0);
          dummy_percentage.push_back(0.0);
        }
        histo_UC.push_back(dummy);
        histo_percentage.push_back(dummy_percentage);

        histo_percentage_biggest.push_back(0.0);
      }

      //compute histogramm
      unsigned char* data = (unsigned char*)image.GetImageData();

      int index;

      //HISTOGRAMM FOR PLANAR IMAGES
      index = 0;
      if(image.IsPlanar()){
        for(int i = 0; i < histo_channels; i++){
          for(int j = 0; j < histo_size; j++){
            histo_UC[i][(int)data[index]]++;
            index++;
          }
        }
      }
      //HISTOGRAMM FOR INTERLEAVED IMAGES
      else if(image.IsInterleaved()){
        for(int j = 0; j < histo_size; j++){
          for(int i = 0; i < histo_channels; i++){
            histo_UC[i][(int)data[index]]++;
            index++;
          }
        }
      }

      //filling percentages and giving debug info out

      for(int i = 0; i < histo_channels; i++){
        float sum = 0.0;
       // cout << "CHANNEL " << i << ":" << endl << endl;
        for (int j = 0; j < 256; j++){
          float perc = (float)histo_UC[i][j]/(float)histo_size;
          histo_percentage[i][j] = perc;
          sum += perc;

          if(perc > histo_percentage_biggest[i])
          histo_percentage_biggest[i] = perc;
        }
      }
      break;
    }

  case ImageBase::ST_float:
    {
      //debug-message
     // cout << "FLOAT" << endl;

      //TO-DO (probably) - enable float-histo for any number of steps,
      //                   not only 256 as it is right now
      histo_float_steps = 256;
      //histo_float_steps = GetClientSize().x;

      histo_type = 1;

      histo_float.clear();

      //preparations
      std::vector<Histo_Entry_Float> dummy;
      for (int i = 0; i < histo_channels; i++){
        dummy.clear();
        dummy_percentage.clear();
        for (int j = 0; j < histo_float_steps; j++){
          Histo_Entry_Float dummy_content;
          dummy_content.value_count = 0;

          dummy.push_back(dummy_content);
          dummy_percentage.push_back(0.0);
        }
        histo_float.push_back(dummy);
        histo_percentage.push_back(dummy_percentage);

        histo_percentage_biggest.push_back(0.0);
      }

      float* data = (float*)image.GetImageData();

      //get min and max-values in the image and compute scale-step
      float min =  100000.0;
      float max = -100000.0;

      for (int i = 0; i < histo_size; i++){
        if((float)data[i] > max){
          max = (float)data[i];
          //          int x = (int)(i/image.GetWidth());
          //          int y = i - x*image.GetWidth();
          //cout << "max (" << y << ", " << x << ") value: " << max << endl;
        }
        if((float)data[i] < min)
          min = (float)data[i];
      }

      if(min >= 100000.0 || max <= -100000.0)
        BIASERR("Image has only pixels above 10^5 values or under -10^5");

      float step = (max-min)/histo_float_steps;

      histo_float_min = min;
      histo_float_step = step;

      //compute histogramm

      //FOR PLANAR FLOAT-IMAGES
      if(image.IsPlanar()){
        for (int i = 0; i < histo_channels; i++){
          for (int j = 0; j < histo_size; j++){

            int index = 0;
            if(step != 0.0){
              index = (int)(((float)data[j]-min)/step);
            }

            //---COMPUTING HISTOGRAMM---
            //correcting slight errors while doing it with float-images
            if(index == histo_float_steps)
              index--;
            else if(index == -1)
              index = 0;
            //if the float-error is too big while counting histogramm
            else if(index < -1 || index > histo_float_steps){
//              cout << "BAD pixel for histogramm: " << endl;
//              cout << "data[j]: " << data[j]
//                   << " min-data: " << min
//                   << " max-data: " << max
//                   << " index: " << index << endl;
              BIASERR("HISTOGRAMM IS WRONG, maybe TOO MANY STEPS/TOO WIDE RANGE");
            }
            //--------------------------

            histo_float[i][index].value_count++;
          }
        }
      }
      //FOR INTERLEAVED IMAGES
      else if(image.IsInterleaved()){
        for (int j = 0; j < histo_size; j++){
          for (int i = 0; i < histo_channels; i++){

            int index = 0;
            if(step != 0.0){
              index = (int)(((float)data[j]-min)/step);
            }

            if(index == histo_float_steps)
              index--;
            else if(index == -1)
              index = 0;
            else if(index < -1 || index > histo_float_steps){
//              cout << "BAD pixel for histogramm: " << endl;
//              cout << "data[j]: " << data[j]
//                   << " min-data: " << min
//                   << " max-data: " << max
//                   << " index: " << index << endl;
              BIASERR("HISTOGRAMM IS WRONG, maybe TOO MANY STEPS/TOO WIDE RANGE");
            }

            histo_float[i][index].value_count++;
          }
        }
      }

      for (int i = 0; i < histo_channels; i++){

        //cout << "CHANNEL " << i << ":" << endl << endl;

        //filling percentages and giving debug info out
        float sum = 0.0;
        float begin = min;
        float end = min + step;
        for (int j = 0; j < histo_float_steps; j++){
          histo_float[i][j].value_begin = begin;
          histo_float[i][j].value_end   = end;

          if(begin <= 0.0 && end >= 0.0){
            histo_float_zero = j;
          }

          begin += step; end += step;

          float perc = (float)histo_float[i][j].value_count/(float)histo_size;
          histo_percentage[i][j] = perc;
          sum += perc;

          if(perc > histo_percentage_biggest[i])
            histo_percentage_biggest[i] = perc;
        }
//        cout << sum*100 << "% total" << endl;
//        cout << histo_float_steps << " steps in float-histogramm used" << endl;
      }
      break;
    }

  default:
    break;
  }

  //cout << "HISTOGRAMM UPDATED" << endl;

  wxPaintEvent ev;
  OnPaint(ev);

  //Testing if the statusbar is correctly shown and enabled
#ifdef WIN32
  Refresh();
#endif
}


//Paints Histogramm in HistoFrame, channel after channel
//(ordered from upper side of the frame to the bottom:
// channel 0,
// channel 1,
// ...)
void HistoImageCanvas::
OnPaint(wxPaintEvent& event){
  //prepare painter and get size of the window
  wxBufferedPaintDC dc(this);
  wxSize sz = GetClientSize();
  int wid = sz.x;
  int hei = sz.y;
  //cout << wid << "; " << hei << endl;

  //CLEAR
  dc.SetPen(*wxGREY_PEN);
  dc.SetBrush(*wxGREY_BRUSH);

  wxRect rectToDraw(0, 0, wid, hei);
  //wxRect rectToDraw(4, 4, wid-8, hei-8);
  dc.DrawRectangle(rectToDraw);

  dc.SetPen(*wxWHITE_PEN);
  dc.SetBrush(*wxWHITE_BRUSH);

  //---------CONFIGURE PARAMETERS OF HISTOGRAMM------
  wxCoord h;
  histoZoom_ = 1;

  //paint original histogramm
  if(wid <= 512+16)
    histoZoom_=1;
  //paint 2xhistogramm
  else if(wid <= 768+16)
    histoZoom_=2;
  //paint 3xhistogramm
  else if(wid <= 1024+16)
    histoZoom_=3;
  //paint 4xhistogramm
  else
    histoZoom_=4;

#ifdef WIN32
  //fixing some strange bug in windows when painting things
  hei-=40;
#endif
  //-------------------------------------------------

  wxRect rectToDraw2(6, 6, 256*histoZoom_+4, hei-12);
  //wxRect rectToDraw2(7, 7, wid-14, hei-14);
  dc.DrawRectangle(rectToDraw2);

  dc.SetPen(*wxLIGHT_GREY_PEN);
  dc.SetBrush(*wxLIGHT_GREY_BRUSH);

  int slice = (int)
    ((float)(hei-16-(histo_channels-1)*2)/float(histo_channels));

  for(int i=0; i<histo_channels; i++){
    wxRect rectToDraw3(8, hei-8-(2+slice)*i-slice,
                       histoZoom_*256, slice);
    dc.DrawRectangle(rectToDraw3);
  }

  //-----

  dc.SetPen(*wxBLACK_PEN);
  dc.SetBrush(*wxBLACK_BRUSH);

  int end = 0;

  //CRITICAL: if the picture is too wide (looks bad) or
  //          not as wide as 256 pixels -> no histo
  if(histo_type == 0){
    end = 256;
//    cout << "Painting " << histoZoom_
//         << "xHistogramm for unsigned-char image" << endl;
  }
  if(histo_type == 1){
    //for future flexible resizeable float-histogramm
    //(not only 1x, 2x, 3x, 4x versions of the same one
    end = histo_float_steps;
//    cout << "Painting " << histoZoom_
//         << "xHistogramm for float image" << endl;
  }

  for(int i=0; i<histo_channels; i++){
    for(int j = 0; j < end; j++){
      h = (int)(((float)slice)*
                histo_percentage[i][j]/histo_percentage_biggest[i]);
      wxRect rectToDraw(histoZoom_*j+8,
                        hei-h-8-(histo_channels-i-1)*(slice+2),
                        histoZoom_,
                        h);
      dc.DrawRectangle(rectToDraw);
    }
  }
}


void HistoImageCanvas::
RefitHistogramm(){
  wxSize sz = GetClientSize();
  int wid = sz.x;
  int hei = sz.y;
  cout << "RESIZED-1 TO " << wid << ", " << hei << endl << endl;
}


void HistoImageCanvas::
NewImage(BIAS::ImageBase& im){
  UpdateHistogramm(im);
}


bool HistoImageCanvas::
SameName(wxString name, bool settothenewone){
  if(histo_name != name){
    if(settothenewone)
      histo_name = name;
    return false;
  }
  return true;
}


void HistoImageCanvas::
OnResize(wxSizeEvent & event){
  wxPaintEvent ev;
  OnPaint(ev);
}