ImageCanvasCheckerboardExtract.cpp

#include <Base/Common/BIASpragmaStart.hh> 
#include "ImageCanvasCheckerboardExtract.hh"
#include <FeatureDetector/CheckerboardDetector.hh>
#include <FeatureDetector/CheckerboardDetectorCrossFilter.hh>
#include <Base/Image/ImageConvert.hh>
#include <Base/ImageUtils/ImageDraw.hh>
#include <Base/Image/ColourRGB.hh>
#include <Base/Geometry/HomgPoint2D.hh>
#include <Utils/IOUtils.hh>
#include <Base/Common/BIASpragmaEnd.hh> 
using namespace BIAS;
using namespace std;


ICECCallbackInterface::ICECCallbackInterface()
{}

ICECCallbackInterface::~ICECCallbackInterface()
{}

void ICECCallbackInterface::
CheckerboardSelected(std::vector<BIAS::HomgPoint2D > &corners,
                     bool bOnlyFourPointsGiven, bool valid)
{
  BIASERR("error: function of derived class should be called");
}

/////////////////////////////////////////////////////////////////

ImageCanvasCheckerboardExtract::
ImageCanvasCheckerboardExtract(wxWindow* parent,
                               wxStatusBar* sbar,
                               int sbarid, wxWindowID id,
                               const wxPoint& pos,
                               const wxSize& size,
                               long style,
                               const wxString& name)
  : ImageCanvas(parent, sbar, sbarid, id, pos, size, style, name)
{
  NumLeftClicks_=0;
  SelectCheckerboard_=false;
  CallbackObj_=NULL;
  bEnforceAllCorners_=false;
  SelectCheckerboard_=false;
  DisplayCheckerboard_ = false;
  bSelectable_=true;
  checkerboardDetectorMethod_ = 0;
}

ImageCanvasCheckerboardExtract::
~ImageCanvasCheckerboardExtract()
{
  allCheckerboardCorners_.clear();
  CallbackObj_ = NULL;
}


void ImageCanvasCheckerboardExtract::
SetPatternParameters (unsigned int xCorners, unsigned int yCorners) {
  xCorners_ = xCorners;
  yCorners_ = yCorners;
  allCheckerboardCorners_.clear();
  allCheckerboardCorners_.resize(xCorners_*yCorners_);
  for(unsigned i=0;i<allCheckerboardCorners_.size();i++)
    allCheckerboardCorners_[i] = HomgPoint2D(0.0,0.0,1.0);
}
void ImageCanvasCheckerboardExtract::
EnableCornerSelection(bool selectable){
    bSelectable_ = selectable;
}

void ImageCanvasCheckerboardExtract::
SelectCheckerboardCorners(ICECCallbackInterface& obj,
                          bool allCorners,bool autoInvalidate)
{
  //signal that we are in selection mode
  SelectCheckerboard_ = true;
  DisplayCheckerboard_ = false;
  NumLeftClicks_=0;
  bEnforceAllCorners_= allCorners;
  CallbackObj_=&obj;

  //Here we try to automatically extract the checkerboard
  t_CoordVecf coords;
  const int numCorners = xCorners_*yCorners_;
  coords.resize(numCorners, std::pair<float,float>(0.0f,0.0f));
  //int memory = IOUtils::GetApplicationMemory();
  int res = -1;
  if(numCorners > 5)
    switch(checkerboardDetectorMethod_){
      case 0:// Use OpenCV:
        res = CheckerboardDetector::Compute(rgbim_,xCorners_,yCorners_,coords);
        break;

    case 1:  // Use OpenCV with CrossFilter fallback:
        res = CheckerboardDetector::Compute(rgbim_,xCorners_,yCorners_,coords);
        if (res != 0)
        res = CheckerboardDetectorCrossFilter::Compute(rgbim_,xCorners_,yCorners_,coords);
        break;

    case 2: // Use CrossFilter
        res = CheckerboardDetectorCrossFilter::Compute(rgbim_,xCorners_,yCorners_,coords);
        break;
  }
  //   int memorydiff = IOUtils::GetApplicationMemory()-memory;
  //   cout<<"After Compute = +"<<memorydiff*4<<"kB "<<memorydiff/256<<"MB"<<endl;
  if(res!= 0){
    if(autoInvalidate){
      for(unsigned i=0;i<allCheckerboardCorners_.size();i++)
        allCheckerboardCorners_[i] = HomgPoint2D(-1.0,-1.0,1.0); //invalid
      SelectCheckerboard_ = false;
      NumLeftClicks_=0;
      CallbackObj_->CheckerboardSelected(allCheckerboardCorners_, false,false);
      //   int memorydiff = IOUtils::GetApplicationMemory()-memory;
      //       cout<<"detecting failed auto = +"<<memorydiff*4<<"kB "<<memorydiff/256<<"MB"<<endl;
      return;
    }
    else{
      for(unsigned i=0;i<allCheckerboardCorners_.size();i++)
        allCheckerboardCorners_[i] = HomgPoint2D(0.0,0.0,1.0);
      //       int memorydiff = IOUtils::GetApplicationMemory()-memory;
      //       cout<<"detecting failed = +"<<memorydiff*4<<"kB "<<memorydiff/256<<"MB"<<endl;
      return;
    }
  }
  else{
    for(unsigned int i=0;i< coords.size();i++){
      allCheckerboardCorners_[i] =
        HomgPoint2D(coords[i].first,coords[i].second,1);
    }
    //draw it
    DrawCheckerboardCorners_();
    //reset flags
    SelectCheckerboard_=false;
    DisplayCheckerboard_=true;
    NumLeftClicks_=0;
    //signal
    CallbackObj_->CheckerboardSelected(allCheckerboardCorners_, false,true);
#ifdef WIN32
    this->Refresh();
#else
    wxPaintEvent pe;
    wxPostEvent(this->GetEventHandler(),pe);
#endif
  }
  //   memorydiff = IOUtils::GetApplicationMemory()-memory;
  //   cout<<"detecting corners = +"<<memorydiff*4<<"kB "<<memorydiff/256<<"MB"<<endl;

}


void ImageCanvasCheckerboardExtract::
DisplayCheckerboardCorners(std::vector<HomgPoint2D > &corners,
                           double rescaleFactor){

  bool oldAllC = bEnforceAllCorners_;
  bEnforceAllCorners_ = true;
  DisplayCheckerboard_ = true;
  SelectCheckerboard_=false;
  NumLeftClicks_ = 0;
  if(corners.size() != allCheckerboardCorners_.size()){
    BIASERR("Inconsistent number of corners:"<<corners.size()<<" vs. "
            <<allCheckerboardCorners_.size());
    return;
  }
  for(unsigned i=0;i<corners.size();i++)
    allCheckerboardCorners_[i] = corners[i];
  DrawCheckerboardCorners_(rescaleFactor);
  bEnforceAllCorners_ = oldAllC;
}

void ImageCanvasCheckerboardExtract::
DisplayCheckerboardCorners(std::vector< BIAS::Vector2<double> > &corners,
                           double rescaleFactor){
  //performance warning : double copy of corners

  for(unsigned i=0;i<corners.size();i++)
    allCheckerboardCorners_[i] = HomgPoint2D(corners[i][0],corners[i][1],1.0);
  DisplayCheckerboardCorners(allCheckerboardCorners_,rescaleFactor);
}

void ImageCanvasCheckerboardExtract::SetCheckerboardDetector( int detector){
  if (detector >= 0 && detector <= 2)
    checkerboardDetectorMethod_ = detector;
}

BEGIN_EVENT_TABLE (ImageCanvasCheckerboardExtract, ImageCanvas)
    EVT_LEFT_DOWN  (ImageCanvasCheckerboardExtract::OnLeftMouseButton)
    EVT_RIGHT_DOWN  (ImageCanvasCheckerboardExtract::OnRightMouseButton)
    EVT_MOTION      (ImageCanvasCheckerboardExtract::OnMouseMove)
    EVT_PAINT       (ImageCanvasCheckerboardExtract::OnPaint)
END_EVENT_TABLE()


void ImageCanvasCheckerboardExtract::
OnLeftMouseButton(wxMouseEvent &event)
{
  if(bSelectable_ && SelectCheckerboard_){
    wxClientDC dc(this);
    PrepareDC(dc);
    wxPoint pos = event.GetPosition();
    double x =  dc.DeviceToLogicalX( pos.x );
    double y =  dc.DeviceToLogicalY( pos.y );
    //    cout<<"Selected:"<<x<<","<<y<<endl;
    HomgPoint2D point(x,y),pointZero(0.0,0.0);

    if(bEnforceAllCorners_){
      allCheckerboardCorners_[NumLeftClicks_] = point;
      if(NumLeftClicks_ == 0){
        for(unsigned i=1;i<allCheckerboardCorners_.size();i++)
          allCheckerboardCorners_[i] = HomgPoint2D(0.0,0.0,1.0);
      }
      NumLeftClicks_++;

      DrawCheckerboardCorners_();
      if(NumLeftClicks_ == xCorners_*yCorners_){
        SelectCheckerboard_=false;
        DisplayCheckerboard_ = true;
        NumLeftClicks_=0;
        CallbackObj_->CheckerboardSelected(allCheckerboardCorners_,false,true);
      }
    }//end if(bEnforceAllCorners_)
    else{
      if(NumLeftClicks_ == 0){
        allCheckerboardCorners_[0] = point;
        allCheckerboardCorners_[xCorners_-1]=pointZero;
        allCheckerboardCorners_[(xCorners_*yCorners_-1)] =pointZero;
        allCheckerboardCorners_[(yCorners_-1)*(xCorners_)] =pointZero;
      }
      else if (NumLeftClicks_ == 1){
        allCheckerboardCorners_[xCorners_-1] = point;
      }
      else if (NumLeftClicks_ == 2){
        allCheckerboardCorners_[(xCorners_*yCorners_-1)] = point;
      }
      else if (NumLeftClicks_ == 3){
        allCheckerboardCorners_[(yCorners_-1)*(xCorners_)] = point;
      }
      NumLeftClicks_++;

      if(NumLeftClicks_ == 4){
        DrawCheckerboardCorners_();
        SelectCheckerboard_=false;
        DisplayCheckerboard_ = true;
        NumLeftClicks_=0;
        CallbackObj_->CheckerboardSelected(allCheckerboardCorners_,true,true);
      }
    }
  }//end if(selectable && ....)
  else
    event.Skip();
}



void ImageCanvasCheckerboardExtract::
OnRightMouseButton(wxMouseEvent &event)
{
    if(bSelectable_){
        //if we come from display, we allow to define new corners
        if(DisplayCheckerboard_){
            SelectCheckerboard_ = true;
            DisplayCheckerboard_= false;
        }
        if(SelectCheckerboard_){
            NumLeftClicks_ = 0;
            for(unsigned i=0;i<allCheckerboardCorners_.size();i++)
                allCheckerboardCorners_[i] = HomgPoint2D(0.0,0.0,1.0);

            RefreshDrawIm_();

#ifdef WIN32
            this->Refresh();
#else
            wxPaintEvent pe;
            wxPostEvent(this->GetEventHandler(),pe);
#endif
        }
    }
    else
    event.Skip();
}

void ImageCanvasCheckerboardExtract::
OnPaint(wxPaintEvent &event)
{
    ImageCanvas::OnPaint(event);
}


void ImageCanvasCheckerboardExtract::
OnMouseMove(wxMouseEvent &event)
{
  if(bSelectable_ && SelectCheckerboard_ &&
     !bEnforceAllCorners_ && NumLeftClicks_>=1){
    wxClientDC dc(this);
    PrepareDC(dc);

    wxPoint pos = event.GetPosition();
    int x = dc.DeviceToLogicalX( pos.x );
    int y = dc.DeviceToLogicalY( pos.y );

    HomgPoint2D point(x,y,1);

    if(NumLeftClicks_ == 0){
      allCheckerboardCorners_[0] = point;
    }
    else if (NumLeftClicks_ == 1){
      allCheckerboardCorners_[xCorners_-1] = point;
    }
    else if (NumLeftClicks_ == 2){
      allCheckerboardCorners_[(xCorners_*yCorners_-1)] = point;
    }
    else if (NumLeftClicks_ == 3){
      allCheckerboardCorners_[(yCorners_-1)*(xCorners_)] = point;
    }

    DrawCheckerboardCorners_();
  }

  event.Skip();
}

void ImageCanvasCheckerboardExtract::
DrawCheckerboardCorners_(double rescaleFactor)
{
  unsigned char red[]={255, 0, 0};
  unsigned char green[]={0,255, 0};
  unsigned char blue[]={0,0,255};

  RefreshDrawIm_();

  unsigned nrCorners = allCheckerboardCorners_.size()-1;

  if(bEnforceAllCorners_){
    for(unsigned i =0 ;i<allCheckerboardCorners_.size();i++){
      stringstream text;
      text<<i;

      if((rgbim_.GetWidth() % 4) == 0){
        ImageDraw<unsigned char>::
          Text(rgbim_,text.str().c_str(),
               (unsigned)(allCheckerboardCorners_[i][0]*rescaleFactor),
               (unsigned)(allCheckerboardCorners_[i][1]*rescaleFactor),
               ColourRGB<unsigned char>(255, 0, 0));
      }
      if(i==0)
        ImageDraw<unsigned char>::
          CircleCenterFilled(rgbim_,
                             (unsigned)(allCheckerboardCorners_[i][0]*rescaleFactor),
                             (unsigned)(allCheckerboardCorners_[i][1]*rescaleFactor), 3,green);
      else if(i==nrCorners)
        ImageDraw<unsigned char>::
          CircleCenterFilled (rgbim_,
                              (unsigned)(allCheckerboardCorners_[i][0]*rescaleFactor),
                              (unsigned)(allCheckerboardCorners_[i][1]*rescaleFactor), 3,blue);

      else
        ImageDraw<unsigned char>::
          CircleCenterFilled (rgbim_,
                              (unsigned)(allCheckerboardCorners_[i][0]*rescaleFactor),
                              (unsigned)(allCheckerboardCorners_[i][1]*rescaleFactor), 3,red);
    }
  }
  else{
    unsigned int start[2], stop[2];

    if(allCheckerboardCorners_[0][0]>0.0 &&
       allCheckerboardCorners_[0][1]>0.0 &&
       allCheckerboardCorners_[xCorners_-1][0]>0.0 &&
       allCheckerboardCorners_[xCorners_-1][1]>0.0)
      {
        start[0] = (int)(allCheckerboardCorners_[0][0]*rescaleFactor);
        start[1] = (int)(allCheckerboardCorners_[0][1]*rescaleFactor);
        stop[0] = (int)(allCheckerboardCorners_[xCorners_-1][0]*rescaleFactor);
        stop[1] = (int)(allCheckerboardCorners_[xCorners_-1][1]*rescaleFactor);
        ImageDraw<unsigned char>::Line(rgbim_, start,stop, green);

        if(allCheckerboardCorners_[(xCorners_*yCorners_-1)][0]>0.0 &&
           allCheckerboardCorners_[(xCorners_*yCorners_-1)][1]>0.0){
          start[0] = (int)(allCheckerboardCorners_[xCorners_-1][0]*rescaleFactor);
          start[1] = (int)(allCheckerboardCorners_[xCorners_-1][1]*rescaleFactor);
          stop[0] = (int)(allCheckerboardCorners_[(xCorners_*yCorners_-1)][0]*rescaleFactor);
          stop[1] = (int)(allCheckerboardCorners_[(xCorners_*yCorners_-1)][1]*rescaleFactor);
          ImageDraw<unsigned char>::Line(rgbim_,start,stop, green);
        }
        if(allCheckerboardCorners_[(yCorners_-1)*(xCorners_)][0]>0.0 &&
           allCheckerboardCorners_[(yCorners_-1)*(xCorners_)][1]>0.0){
          start[0] = (int)(allCheckerboardCorners_[(xCorners_*yCorners_-1)][0]*rescaleFactor);
          start[1] = (int)(allCheckerboardCorners_[(xCorners_*yCorners_-1)][1]*rescaleFactor);
          stop[0] = (int)(allCheckerboardCorners_[(yCorners_-1)*(xCorners_)][0]*rescaleFactor);
          stop[1] = (int)(allCheckerboardCorners_[(yCorners_-1)*(xCorners_)][1]*rescaleFactor);
          ImageDraw<unsigned char>::Line(rgbim_,start,stop, blue);
          start[0] = (int)(allCheckerboardCorners_[(yCorners_-1)*(xCorners_)][0]*rescaleFactor);
          start[1] = (int)(allCheckerboardCorners_[(yCorners_-1)*(xCorners_)][1]*rescaleFactor);
          stop[0] = (int)(allCheckerboardCorners_[0][0]*rescaleFactor);
          stop[1] = (int)(allCheckerboardCorners_[0][1]*rescaleFactor);
          ImageDraw<unsigned char>::Line(rgbim_,start,stop, red);

        }
      }
  }

#ifdef WIN32
  this->Refresh();
#else
  wxPaintEvent pe;
  wxPostEvent(this->GetEventHandler(),pe);
#endif
}

void ImageCanvasCheckerboardExtract::RefreshDrawIm_()
{
  Image<unsigned char> tmprgb;
  if (origim_.GetColorModel()!=ImageBase::CM_RGB){
    if (ImageConvert::Convert(origim_, tmprgb, ImageBase::CM_RGB)!=0){
      BIASERR("error converting image");
    }
  } else {
    tmprgb=origim_;
  }
  Show(origim_, tmprgb, ImageName_);
}