examples/surfNaive/surf.cpp

/*
 *      Copyright (C) 2007, 2008. PARP Research Group.
 *      <http://perception.inf.um.es>
 *      University of Murcia, Spain.
 *
 *      This file is part of the QVision library.
 *
 *      QVision 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, version 3 of the License.
 *
 *      QVision 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 QVision. If not, see <http://www.gnu.org/licenses/>.
 */


#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <iostream>
#include <QDebug>
#include <QVector>
#include <QMap>

#include <qvcore/qvapplication.h>
#include <qvcameras/qvmplayercamera.h>
#include <qvgui/qvdefaultgui.h>
#include <qvip/qvipp/qvipp.h>
#include <qvip/qvpolyline.h>
#include <qvdta/qvdta.h>

#ifndef DOXYGEN_IGNORE_THIS



QList<QPoint> MaxIPP( QVImage<sFloat> &image1, QVImage<sFloat> &image2, QVImage<sFloat> &image3, float threshold)  // blockSize(3x3x3) = 3
{ 
  
  QList<QPoint> listMax;
  float max1, min1, aux; int xmax, ymax;
  float max2, min2;
  float max3, min3;
  float max, min;
  QRect image1ROI=image1.getROI();
  QRect image2ROI=image2.getROI();
  QRect image3ROI=image3.getROI();

  int rows=image3.getRows(), cols=image3.getCols();
  QVImage<sFloat> imageMax1(cols,rows), imageMax2(cols,rows), imageMax3(cols,rows);
  int beginx=image3.getROI().x(), beginy=image3.getROI().y();
  int endx=image3.getROI().width()+beginx, endy=image3.getROI().height()+beginy;
  imageMax1.setMarginROI(beginx);
  imageMax2.setMarginROI(beginx);
  imageMax3.setMarginROI(beginx);

  image1.setMarginROI(beginx);
  imageMax1.setMarginROI(beginx);
  FilterMax(image1,imageMax1,3,3,QPoint(beginx+1,beginy+1));
  image2.setMarginROI(beginx);
  imageMax2.setMarginROI(beginx);
  FilterMax(image2,imageMax2,3,3,QPoint(beginx+1,beginy+1));
  imageMax3.setMarginROI(beginx);
  FilterMax(image3,imageMax3,3,3,QPoint(beginx+1,beginy+1));

  // dejamos los ROI como estaban
  image1.setROI(image1ROI);
  image2.setROI(image2ROI);
  image3.setROI(image3ROI);


  // aqui hay que examinar los tres maximos para encontrar el maximo vertical y marcarlo en imageMax2

  QVIMAGE_INIT_READ(sFloat,imageMax1);
  QVIMAGE_INIT_WRITE(sFloat,imageMax2)
  QVIMAGE_INIT_READ(sFloat,imageMax3);
  QVIMAGE_INIT_READ(sFloat,image2);

  QMap<sFloat,QPoint> listMap;
  sFloat faux, fmaxvalue=-1e30, fminvalue=1e30;
  for(int i=beginx; i<endx; ++i)
  {  for(int j=beginy; j<endy; ++j)
     { faux = QVIMAGE_PIXEL(imageMax2,i,j,0);
       if ((faux == QVIMAGE_PIXEL(image2,i,j,0)) && (faux > QVIMAGE_PIXEL(imageMax1,i,j,0)) && (faux > QVIMAGE_PIXEL(imageMax3,i,j,0)))
         {  listMap.insertMulti(faux,QPoint(i,j));
         }
     }
  }
 QList<QPoint> valuesList = listMap.values();
 QList<QPoint> listFiltered;
 int miThreshold = threshold * valuesList.size();  // threshold es el % de elementos a mostrar
 for(int i=valuesList.size()-miThreshold; i<valuesList.size(); ++i)
   listFiltered.append(valuesList[i]);
 return(listFiltered);
}



float applyDxx(const QVImage<sFloat> &integralImage, int x, int y, int octave, int scale) 
        { 
        // las octavas comienzan en 0 y el incremento se multiplica por 2^octava antes de usarse
        // dim = dim + scale*(6 << octave)
        int w = 5 + 4*octave + scale*(4 << octave);  // ancho de la máscara de 9x9 (5x3) e incremento de ese ancho en cada escala (4 pixels)
        int h = 3 + 2*octave + scale*(2 << octave);  // alto de la máscara de 9x9 (5x3) e incremento de ese alto en cada escala (2 pixels)

        float a,b,c,d,e,f,g,hh;
        QVIMAGE_INIT_READ(sFloat,integralImage);
        a = QVIMAGE_PIXEL(integralImage,x-h/2-h,  y-w/2,0);
        b = QVIMAGE_PIXEL(integralImage,x-h/2,    y-w/2,0);
        c = QVIMAGE_PIXEL(integralImage,x+h/2+1,  y-w/2,0);
        d = QVIMAGE_PIXEL(integralImage,x+h+h/2+1,    y-w/2,0);
        e = QVIMAGE_PIXEL(integralImage,x-h/2-h,  y+w/2+1,0);
        f = QVIMAGE_PIXEL(integralImage,x-h/2,  y+w/2+1,0);
        g = QVIMAGE_PIXEL(integralImage,x+h/2+1,y+w/2+1,0);
        hh = QVIMAGE_PIXEL(integralImage,x+h/2+h+1,y+w/2+1,0);

        return((a+hh-d-e+3*(f+c-b-g))/(w*h));
        }

float applyDyy(const QVImage<sFloat> &integralImage, int x, int y, int octave, int scale) 
        { 
        // las octavas comienzan en 0 y el incremento se multiplica por 2^octava antes de usarse
        // dim = dim + scale*(6 << octave)
        int w = 5 + 4*octave + scale*(4 << octave);  // ancho de la máscara de 9x9 (5x3) e incremento de ese ancho en cada escala (4 pixels)
        int h = 3 + 2*octave + scale*(2 << octave);  // alto de la máscara de 9x9 (5x3) e incremento de ese alto en cada escala (2 pixels)
        float a,b,c,d,e,f,g,hh;
        QVIMAGE_INIT_READ(sFloat,integralImage);
        a = QVIMAGE_PIXEL(integralImage,x-w/2,y-h-h/2,0);
        c = QVIMAGE_PIXEL(integralImage,x-w/2,y-h/2,0);
        e = QVIMAGE_PIXEL(integralImage,x-w/2,y+h/2+1,0);
        g = QVIMAGE_PIXEL(integralImage,x-w/2,y+h+h/2+1,0);
        b = QVIMAGE_PIXEL(integralImage,x+w/2+1,y-h-h/2,0);
        d = QVIMAGE_PIXEL(integralImage,x+w/2+1,y-h/2,0);
        f = QVIMAGE_PIXEL(integralImage,x+w/2+1,y+h/2+1,0);
        hh = QVIMAGE_PIXEL(integralImage,x+w/2+1,y+h+h/2+1,0);

        return((a-b+hh-g+3*(d+e-c-f))/(w*h));

        }

float applyDxy(const QVImage<sFloat> &integralImage, int x, int y, int octave, int scale) 
        { 
        // las octavas comienzan en 0 y el incremento se multiplica por 2^octava antes de usarse
        // dim = dim + scale*(6 << octave)
        int w = 3 + 2*octave + scale*(2 << octave);  // ancho de la máscara de 9x9 (5x3) e incremento de ese ancho en cada escala (4 pixels)
        int h = 3 + 2*octave + scale*(2 << octave);  // alto de la máscara de 9x9 (5x3) e incremento de ese alto en cada escala (2 pixels)
        float a,b,c,d,e,f,g,hh,i,j,k,l,m,n,o,p;
        QVIMAGE_INIT_READ(sFloat,integralImage);
        a = QVIMAGE_PIXEL(integralImage,x-w,y-h,0);
        c = QVIMAGE_PIXEL(integralImage,x-w,y,0);
        i = QVIMAGE_PIXEL(integralImage,x-w,y+1,0);
        k = QVIMAGE_PIXEL(integralImage,x-w,y+h+1,0);
        b = QVIMAGE_PIXEL(integralImage,x,y-h,0);
        d = QVIMAGE_PIXEL(integralImage,x,y,0);
        j = QVIMAGE_PIXEL(integralImage,x,y+1,0);
        l = QVIMAGE_PIXEL(integralImage,x,y+h+1,0);
        e = QVIMAGE_PIXEL(integralImage,x+1,y-h,0);
        g = QVIMAGE_PIXEL(integralImage,x+1,y,0);
        m = QVIMAGE_PIXEL(integralImage,x+1,y+1,0);
        o = QVIMAGE_PIXEL(integralImage,x+1,y+h+1,0);
        f = QVIMAGE_PIXEL(integralImage,x+w+1,y-h,0);
        hh = QVIMAGE_PIXEL(integralImage,x+w+1,y,0);
        n = QVIMAGE_PIXEL(integralImage,x+w+1,y+1,0);
        p = QVIMAGE_PIXEL(integralImage,x+w+1,y+h+1,0);

        return(((a+d-b-c)+(m+p-n-o)-(e+hh-f-g)-(i+l-j-k))/(w*h));
        }



void detHessian(const QVImage<sFloat> &integral, QVImage<sFloat> &hessian, int octave, int scale)
{  // OJO. Se aplica la máscara dando saltos dependiendo de la octava en la que estemos. step=2^octava.
        QVIMAGE_INIT_WRITE(sFloat,hessian);
        sFloat det;
        int cols = integral.getCols(), rows = integral.getRows();
        int sizeMask=9 + 6*octave + scale*(6 << octave);
        int step= 1 << octave;
        int colsHessian = cols/step, rowsHessian = rows/step;
        int marginHessian = ((sizeMask)/2)/step+1; // Obtenemos un margen para el ROI de la imagen del hessiano.
        int marginImage = marginHessian*step;  // Obtenemos un margen para el ROI de la imagen integral.
        for(int j=marginImage,jh=marginHessian; j<rows-marginImage;j+=step,++jh) //j=j+(1<<octave))
                for(int i=marginImage,ih=marginHessian; i<cols-marginImage;i+=step,++ih) // i=i+(1<<octave))
                        { const float Dxy_apply=applyDxy(integral,i,j,octave,scale);
                        det = ( applyDxx(integral,i,j,octave,scale)
                                *
                                applyDyy(integral,i,j,octave,scale)
                                -0.81*Dxy_apply*Dxy_apply
                                );
                        det = (det < 0.0) ? 0.0 : det;
                        QVIMAGE_PIXEL(hessian,ih,jh,0) = det;
                        }
        hessian.setMarginROI(marginHessian);
        integral.setMarginROI(marginImage);
}


QList<QVPolyline> addBlobs(QList<QVPolyline> listBlobs, QList<QPoint> listPoints, int octave, int scale)
{ int radius=4+3*octave+scale*(3<<octave);
  int sizeMask=9 + 6*octave + scale*(6 << octave);
  int step= 1 << octave;

  for(QList<QPoint>::const_iterator i=listPoints.constBegin(); i!=listPoints.constEnd(); ++i)
        listBlobs.append(QVPolyline::ellipse(10,i->x()*step,i->y()*step,radius,radius,0));
  return(listBlobs);
}

QList<QVPolyline> getBlobs(QVImage<sFloat> &integralFloat, float THRESHOLD)
{       int cols=integralFloat.getCols(), rows=integralFloat.getRows();
        QVImage<sFloat> approxHessian0[4]={QVImage<sFloat>(cols,rows),QVImage<sFloat>(cols,rows),
                                        QVImage<sFloat>(cols,rows),QVImage<sFloat>(cols,rows)};
        QVImage<sFloat> approxHessian1[4]={QVImage<sFloat>(cols/2,rows/2),QVImage<sFloat>(cols/2,rows/2),
                                        QVImage<sFloat>(cols/2,rows/2),QVImage<sFloat>(cols/2,rows/2)};
        QVImage<sFloat> approxHessian2[4]={QVImage<sFloat>(cols/4,rows/4),QVImage<sFloat>(cols/4,rows/4),
                                        QVImage<sFloat>(cols/4,rows/4),QVImage<sFloat>(cols/4,rows/4)};
        QList<QVPolyline> listBlobs;

        int oct=0;
        for(int sca=0; sca<4; ++sca)
          detHessian(integralFloat,approxHessian0[sca],oct,sca);
        listBlobs=addBlobs(listBlobs,MaxIPP(approxHessian0[0],approxHessian0[1],approxHessian0[2], THRESHOLD),oct,1);
        listBlobs=addBlobs(listBlobs,MaxIPP(approxHessian0[1],approxHessian0[2],approxHessian0[3], THRESHOLD),oct,2);

        oct=1;
        Resize(approxHessian0[1], approxHessian1[0],IPPI_INTER_NN);
        detHessian(integralFloat,approxHessian1[1],oct,1);
        detHessian(integralFloat,approxHessian1[2],oct,2);
        detHessian(integralFloat,approxHessian1[3],oct,3);
        listBlobs=addBlobs(listBlobs,MaxIPP(approxHessian1[0],approxHessian1[1],approxHessian1[2], THRESHOLD),oct,1);
        listBlobs=addBlobs(listBlobs,MaxIPP(approxHessian1[1],approxHessian1[2],approxHessian1[3], THRESHOLD),oct,2);

        oct=2;
        Resize(approxHessian1[1], approxHessian2[0],IPPI_INTER_NN);
        detHessian(integralFloat,approxHessian2[1],oct,1);
        detHessian(integralFloat,approxHessian2[2],oct,2);
        detHessian(integralFloat,approxHessian2[3],oct,3);
        listBlobs=addBlobs(listBlobs,MaxIPP(approxHessian2[0],approxHessian2[1],approxHessian2[2], THRESHOLD),oct,1);
        listBlobs=addBlobs(listBlobs,MaxIPP(approxHessian2[1],approxHessian2[2],approxHessian2[3], THRESHOLD),oct,2);


        return(listBlobs);
}



class MyWorker: public QVWorker
        {
        public:
                MyWorker(QString name): QVWorker(name)
                        { 
                        addProperty<double>("Threshold", inputFlag, 1.0, "Threshold",0.01,1.0);
                        addProperty<bool>("Percentage",inputFlag,true);
                        addProperty< QVImage<uChar> >("Input image", inputFlag|outputFlag);
                        addProperty< QVImage<uChar> >("Output image 1", outputFlag);
                        addProperty< QList<QVPolyline> >("BlobsMax1",outputFlag);
                        }

                void iterate()
                        {
                        sFloat THRESHOLD = getPropertyValue<sFloat>("Threshold");
                        QVImage<uChar> input0 = getPropertyValue< QVImage<uChar> >("Input image");
                        uInt rows = input0.getRows()*2, cols = input0.getCols()*2;

                        QVImage<uChar> input(cols, rows);
                        Resize(input0, input,IPPI_INTER_NN); // duplicamos el tamaño de la imagen

                        timeFlag("double size");

                        QVImage<sFloat> imageGaussian(cols,rows);  // aplicamos filtro gaussiano
                        FilterGauss(input,imageGaussian,3);
                        timeFlag("gaussian");

                        ++cols; ++rows;
                        QVImage<sFloat> integralFloat(cols,rows);  // Calculamos la integral
                        Integral(imageGaussian,integralFloat,0);

                        timeFlag("integral");


                        QList<QVPolyline> listBlobs1=getBlobs(integralFloat,THRESHOLD);

                        timeFlag("hessiano");


                        setPropertyValue< QVImage<uChar> >("Output image 1", imageGaussian);
                        setPropertyValue< QList<QVPolyline > >("BlobsMax1",listBlobs1);
                        timeFlag("shows");

                        }
        };

int main(int argc, char *argv[])
        {   ippSetNumThreads(1);
        QVApplication app(argc, argv,
                "Example program for QVision library. It is an implementation of the SURF algorithm."
                );

        QVMPlayerCamera camera1("Video 1");
        MyWorker worker("Surf Worker");

        camera1.link(&worker,"Input image");

        QVDefaultGUI interface;


        QVImageCanvas imageCanvas("Output image 1");
        imageCanvas.linkProperty(worker,"Output image 1");
        imageCanvas.linkProperty(worker,"BlobsMax1", Qt::green);

        return app.exec();
        }

#endif