gdal_simplesurf.h

Go to the documentation of this file.

/******************************************************************************
 * $Id: gdal_simplesurf.h 36666 2016-12-04 04:32:31Z goatbar $
 * Project:  GDAL
 * Purpose:  Correlator
 * Author:   Andrew Migal, migal.drew@gmail.com
 *
 ******************************************************************************
 * Copyright (c) 2012, Andrew Migal
 *
 * Permission is hereby granted, free of charge, to any person obtaining a
 * copy of this software and associated documentation files (the "Software"),
 * to deal in the Software without restriction, including without limitation
 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
 * and/or sell copies of the Software, and to permit persons to whom the
 * Software is furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included
 * in all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
 * DEALINGS IN THE SOFTWARE.
 ****************************************************************************/

#ifndef GDALSIMPLESURF_H_
#define GDALSIMPLESURF_H_

#include "gdal_priv.h"
#include "cpl_conv.h"
#include <list>

class GDALFeaturePoint
{
public:
    GDALFeaturePoint();

    GDALFeaturePoint(const GDALFeaturePoint& fp);

    GDALFeaturePoint(int nX, int nY, int nScale, int nRadius, int nSign);
    virtual ~GDALFeaturePoint();

    GDALFeaturePoint& operator=(const GDALFeaturePoint& point);

    double& operator[](int nIndex);

    static const int DESC_SIZE = 64;

    int GetX() const;

    void SetX(int nX);

    int GetY() const;

    void SetY(int nY);

    int GetScale() const ;

    void SetScale(int nScale);

    int  GetRadius() const;

    void SetRadius(int nRadius);

    int GetSign() const;

    void SetSign(int nSign);

private:
    // Coordinates of point in image
    int nX;
    int nY;
    // --------------------
    int nScale;
    int nRadius;
    int nSign;
    // Descriptor array
    double *padfDescriptor;
};

class GDALIntegralImage
{
public:
    GDALIntegralImage();
    virtual ~GDALIntegralImage();

    void Initialize(const double **padfImg, int nHeight, int nWidth);

    double GetValue(int nRow, int nCol);

    double GetRectangleSum(int nRow, int nCol, int nWidth, int nHeight);

    double HaarWavelet_X(int nRow, int nCol, int nSize);

    double HaarWavelet_Y(int nRow, int nCol, int nSize);

    int GetHeight();

    int GetWidth();

private:
    double **pMatrix;
    int nWidth;
    int nHeight;
};

class GDALOctaveLayer
{
public:
    GDALOctaveLayer();

    GDALOctaveLayer(int nOctave, int nInterval);
    virtual ~GDALOctaveLayer();

    void ComputeLayer(GDALIntegralImage *poImg);

    int octaveNum;
    int filterSize;
    int radius;
    int scale;
    int width;
    int height;
    double **detHessians;
    int **signs;
};

class GDALOctaveMap
{
    CPL_DISALLOW_COPY_ASSIGN( GDALOctaveMap )

public:
    GDALOctaveMap(int nOctaveStart, int nOctaveEnd);
    virtual ~GDALOctaveMap();

    void ComputeMap(GDALIntegralImage *poImg);

    static bool PointIsExtremum(int row, int col, GDALOctaveLayer *bot,
                         GDALOctaveLayer *mid, GDALOctaveLayer *top, double threshold);

    GDALOctaveLayer ***pMap;

    static const int INTERVALS = 4;

    int octaveStart;

    int octaveEnd;
};

class GDALSimpleSURF
{
private:
    class MatchedPointPairInfo
    {
    public:
        MatchedPointPairInfo(int nInd_1, int nInd_2, double dfDist)
            {
                ind_1 = nInd_1;
                ind_2 = nInd_2;
                euclideanDist = dfDist;
            }

        int ind_1;
        int ind_2;
        double euclideanDist;
    };

    CPL_DISALLOW_COPY_ASSIGN( GDALSimpleSURF )

public:
    GDALSimpleSURF(int nOctaveStart, int nOctaveEnd);
    virtual ~GDALSimpleSURF();

    static CPLErr ConvertRGBToLuminosity(
        GDALRasterBand *red,
        GDALRasterBand *green,
        GDALRasterBand *blue,
        int nXSize, int nYSize,
        double **padfImg, int nHeight, int nWidth);

    std::vector<GDALFeaturePoint>*
    ExtractFeaturePoints(GDALIntegralImage *poImg, double dfThreshold);

    static CPLErr MatchFeaturePoints(
        std::vector<GDALFeaturePoint*> *poMatchPairs,
        std::vector<GDALFeaturePoint> *poFirstCollect,
        std::vector<GDALFeaturePoint> *poSecondCollect,
        double dfThreshold);

private:
    static double GetEuclideanDistance(
        GDALFeaturePoint &firstPoint, GDALFeaturePoint &secondPoint);

    static void NormalizeDistances(std::list<MatchedPointPairInfo> *poList);

    static void SetDescriptor(GDALFeaturePoint *poPoint, GDALIntegralImage *poImg);

private:
    int octaveStart;
    int octaveEnd;
    GDALOctaveMap *poOctMap;
};

#endif /* GDALSIMPLESURF_H_ */