Implement image hash modules (#688)
* first commit * first commit * adjust code layout * round mean value * add missed header * remove useless header * remove useless header * first commit * first commit * first commit * Encapsule function averageHash by class * remove export macro * encapsulate phash algo by class * first commit * fix bugs of createHash and fillBlcoks * 1 : add create function 2 : add overload functions * implement get set functions * fix bug--destination depth should be CV_32F * first commit * first commit * 1 : fix bug--forgot '"' 2 : forgot to include iostream * fix warnings * remove tab * remove trailing white space * remove trailing white space * remove trailing white space * remove trailing white space * remove trailing white space * remove trailing white space * first commit * remove trailing white space * remove trailing white space * remove trailing white space * reduce redundance operation * add explanation of img_hash * remove useless comments * remove trailing space * first commit * fix missed symbol * add new defgroup and change all defgroup to ihash * fix namespace confliction * change namespace from ihash to img_hash * change ihash to img_hash * change include guard * forbid implicit conversion * first commit * 1 : declare function findFeatureVector 2 : forward declare test class--RavialVarHashTester as friend * first commit * replace auto with explicit type * export some symbols, for initialization and testing * remove trailing white space * add namespace cv * fix type cast warning and define default constrcutor/destructor * declare and define RadialVarHashTester in namespace * remove default constructor/destructor * exports functions findFeatures and destructor * remove trailing white space * fix bug--wrong definition of destructor * remove trailing white space * implement findFeatureVector * add test case for findFeatureVector * 1 : fix bug--forgot to allocate space for input 2 : fix bug--compare the results of pixPerLine with wrong matrix * remove trailing space * implement hashCalculate * add test case for hashCalculate * remove trailing white space * avoid hiding parameter * refine codes and keep the original range * adjust expected hash value since the range of hash change * add comment * reduce scope * remove trailing white space * adjust format * add new function compare * implement compute functions * use array as buffer of cv::Mat, avoid memory allocation * remove trailing whitespace * 1 : implement cross-correlation rather than using matchTemplate since the results of matchTemplate are weird 2 : remove gamma param, although the paper said PHash apply gamma correction on the image, but the codes do not do that(I think it is a bug of PHash) 3 : create function can specify sigma and numOfAngleLine 4 : Use blurImg to replace normalizeImg 5 : remove useless parameters which related to gamma correction * add example of radial variance hash * use buffer to avoid memory allocation and use enum to specify hash size * remove useless header * fix bug--constructor only accept two params * add comments * transpose projection matrix, friendlier for cache hit * use pointer to access projection value * function able to specify sigma and numOfAngleLine * add get/set functions * implement image hash algo--block mean hash * include block mean hash and add comments * remove trailing whitespace * fix warning--compare with sign and unsigned value * implement destructor and change mode type to size_t * add example of block mean hash * compress the bits of hash * function--blockMeanHash able to set mode * fix type cast warning and style * change expected result to bool * compress the hash value from 16 bytes to 8 bytes * update comments * compress hash from 16 bytes to 8 bytes * use peak value of cross correlation as comparison result * add limit header * first commit * add group and header file of color moment hash * should not use auto, it is c++11 feature * support python binding * implement destructor of AverageHash * support python binding * support python binding * support python binding * change type to inputArray and outputArray, easier for python binding * all algorithms support input type CV_8UC4,CV_8UC3 and CV_8UC1 * Provide better instructions * Make it more pleasant to read * Add information of speed comparsion * remove trailing white space * remove useless blank line * refine comments of example * fix link error * refine title * 1 : implement function "getDefaultName" 2 : adjust style * Update README.md 1 : Fix wrong branch 2 : Add another solution to download img_hash * img_hash: refactored interfaces to use pImpl * remove trailing white space * img_hash: use type-safe pImpl * change name, easier to find the source file * 1 : narrow scope of ImgHashImpl 2 : use static cast to replace dynamic cast because class hierarchy of img_hash is very straightforward * should not declare ImgHashImpl api in the header file of ImgHashBase, this increase chance of breaking ABI * should not declare ImgHashImpl api in the header file of ImgHashBase, this increase chance of breaking ABI * fix warning, because unelaborated friend declaration is a C++11 extension * first commit * fix bug, except of windows, other platforms cannot access private member. pimpl only accessable by the class itself, therefore I think declare everything as public is quite safe * first commit comparison and computation charts * update chart linkpull/1247/head
Tham
8 years ago
committed by
Maksim Shabunin
parent
8ef2f71799
commit
a4a8b84e93
30 changed files with 2139 additions and 0 deletions
@ -0,0 +1,3 @@ |
|||||||
|
set(the_description "Image hash algorithms") |
||||||
|
set(OPENCV_MODULE_IS_PART_OF_WORLD OFF) |
||||||
|
ocv_define_module(img_hash opencv_imgproc opencv_core WRAP java python) |
||||||
@ -0,0 +1,5 @@ |
|||||||
|
Image Hashing algorithms |
||||||
|
======================== |
||||||
|
|
||||||
|
This module is intended to port the algorithms from PHash library and implement other image hash |
||||||
|
algorithm do not exist in PHash library yet. |
||||||
|
After Width: | Height: | Size: 110 KiB |
|
After Width: | Height: | Size: 44 KiB |
|
After Width: | Height: | Size: 46 KiB |
@ -0,0 +1,23 @@ |
|||||||
|
@misc{lookslikeit, |
||||||
|
author={Krawetz, Neal}, |
||||||
|
title={Looks Like It}, |
||||||
|
url={http://www.hackerfactor.com/blog/?/archives/432-Looks-Like-It.html} |
||||||
|
} |
||||||
|
|
||||||
|
@article{tang2012perceptual, |
||||||
|
title={Perceptual hashing for color images using invariant moments}, |
||||||
|
author={Tang, Zhenjun and Dai, Yumin and Zhang, Xianquan}, |
||||||
|
journal={Appl. Math}, |
||||||
|
volume={6}, |
||||||
|
number={2S}, |
||||||
|
pages={643S--650S}, |
||||||
|
year={2012}, |
||||||
|
url={http://www.phash.org/docs/pubs/thesis_zauner.pdf} |
||||||
|
} |
||||||
|
|
||||||
|
@article{zauner2010implementation, |
||||||
|
title={Implementation and benchmarking of perceptual image hash functions}, |
||||||
|
author={Zauner, Christoph}, |
||||||
|
year={2010}, |
||||||
|
publisher={na} |
||||||
|
} |
||||||
@ -0,0 +1,78 @@ |
|||||||
|
// This file is part of OpenCV project.
|
||||||
|
// It is subject to the license terms in the LICENSE file found in the top-level directory
|
||||||
|
// of this distribution and at http://opencv.org/license.html.
|
||||||
|
|
||||||
|
#ifndef OPENCV_IMG_HASH_H |
||||||
|
#define OPENCV_IMG_HASH_H |
||||||
|
|
||||||
|
#include "opencv2/img_hash/average_hash.hpp" |
||||||
|
#include "opencv2/img_hash/block_mean_hash.hpp" |
||||||
|
#include "opencv2/img_hash/color_moment_hash.hpp" |
||||||
|
#include "opencv2/img_hash/marr_hildreth_hash.hpp" |
||||||
|
#include "opencv2/img_hash/phash.hpp" |
||||||
|
#include "opencv2/img_hash/radial_variance_hash.hpp" |
||||||
|
|
||||||
|
/**
|
||||||
|
@defgroup img_hash The module brings implementations of different image hashing algorithms. |
||||||
|
|
||||||
|
Provide algorithms to extract the hash of images and fast way to figure out most similar images in |
||||||
|
huge data set. |
||||||
|
|
||||||
|
Namespace for all functions is cv::img_hash. |
||||||
|
|
||||||
|
### Supported Algorithms |
||||||
|
|
||||||
|
- Average hash (also called Different hash) |
||||||
|
- PHash (also called Perceptual hash) |
||||||
|
- Marr Hildreth Hash |
||||||
|
- Radial Variance Hash |
||||||
|
- Block Mean Hash (modes 0 and 1) |
||||||
|
- Color Moment Hash (this is the one and only hash algorithm resist to rotation attack(-90~90 degree)) |
||||||
|
|
||||||
|
You can study more about image hashing from following paper and websites: |
||||||
|
|
||||||
|
- "Implementation and benchmarking of perceptual image hash functions" @cite zauner2010implementation |
||||||
|
- "Looks Like It" @cite lookslikeit |
||||||
|
|
||||||
|
### Code Example |
||||||
|
|
||||||
|
@include samples/hash_samples.cpp |
||||||
|
|
||||||
|
### Performance under different attacks |
||||||
|
|
||||||
|
 |
||||||
|
|
||||||
|
### Speed comparison with PHash library (100 images from ukbench) |
||||||
|
|
||||||
|
 |
||||||
|
 |
||||||
|
|
||||||
|
As you can see, hash computation speed of img_hash module outperform [PHash library](http://www.phash.org/) a lot.
|
||||||
|
|
||||||
|
PS : I do not list out the comparison of Average hash, PHash and Color Moment hash, because I cannot |
||||||
|
find them in PHash. |
||||||
|
|
||||||
|
### Motivation |
||||||
|
|
||||||
|
Collects useful image hash algorithms into opencv, so we do not need to rewrite them by ourselves |
||||||
|
again and again or rely on another 3rd party library(ex : PHash library). BOVW or correlation |
||||||
|
matching are good and robust, but they are very slow compare with image hash, if you need to deal |
||||||
|
with large scale CBIR(content based image retrieval) problem, image hash is a more reasonable |
||||||
|
solution. |
||||||
|
|
||||||
|
### More info |
||||||
|
|
||||||
|
You can learn more about img_hash modules from following links, these links show you how to find |
||||||
|
similar image from ukbench dataset, provide thorough benchmark of different attacks(contrast, blur, |
||||||
|
noise(gaussion,pepper and salt), jpeg compression, watermark, resize). |
||||||
|
|
||||||
|
* [Introduction to image hash module of opencv](http://qtandopencv.blogspot.my/2016/06/introduction-to-image-hash-module-of.html)
|
||||||
|
* [Speed up image hashing of opencv(img_hash) and introduce color moment hash](http://qtandopencv.blogspot.my/2016/06/speed-up-image-hashing-of-opencvimghash.html)
|
||||||
|
|
||||||
|
### Contributors |
||||||
|
|
||||||
|
Tham Ngap Wei, thamngapwei@gmail.com |
||||||
|
|
||||||
|
*/ |
||||||
|
|
||||||
|
#endif // OPENCV_IMG_HASH_H
|
||||||
@ -0,0 +1,39 @@ |
|||||||
|
// This file is part of OpenCV project.
|
||||||
|
// It is subject to the license terms in the LICENSE file found in the top-level directory
|
||||||
|
// of this distribution and at http://opencv.org/license.html.
|
||||||
|
|
||||||
|
#ifndef OPENCV_AVERAGE_HASH_HPP |
||||||
|
#define OPENCV_AVERAGE_HASH_HPP |
||||||
|
|
||||||
|
#include "img_hash_base.hpp" |
||||||
|
|
||||||
|
namespace cv { |
||||||
|
namespace img_hash { |
||||||
|
|
||||||
|
//! @addtogroup img_hash
|
||||||
|
//! @{
|
||||||
|
|
||||||
|
/** @brief Computes average hash value of the input image
|
||||||
|
|
||||||
|
This is a fast image hashing algorithm, but only work on simple case. For more details, please |
||||||
|
refer to @cite lookslikeit |
||||||
|
*/ |
||||||
|
class CV_EXPORTS_W AverageHash : public ImgHashBase |
||||||
|
{ |
||||||
|
public: |
||||||
|
CV_WRAP static Ptr<AverageHash> create(); |
||||||
|
protected: |
||||||
|
AverageHash() {} |
||||||
|
}; |
||||||
|
|
||||||
|
/** @brief Calculates img_hash::AverageHash in one call
|
||||||
|
@param inputArr input image want to compute hash value, type should be CV_8UC4, CV_8UC3 or CV_8UC1. |
||||||
|
@param outputArr Hash value of input, it will contain 16 hex decimal number, return type is CV_8U |
||||||
|
*/ |
||||||
|
CV_EXPORTS_W void averageHash(cv::InputArray inputArr, cv::OutputArray outputArr); |
||||||
|
|
||||||
|
//! @}
|
||||||
|
|
||||||
|
}} // cv::img_hash::
|
||||||
|
|
||||||
|
#endif // OPENCV_AVERAGE_HASH_HPP
|
||||||
@ -0,0 +1,52 @@ |
|||||||
|
// This file is part of OpenCV project.
|
||||||
|
// It is subject to the license terms in the LICENSE file found in the top-level directory
|
||||||
|
// of this distribution and at http://opencv.org/license.html.
|
||||||
|
|
||||||
|
#ifndef OPENCV_BLOCK_MEAN_HASH_HPP |
||||||
|
#define OPENCV_BLOCK_MEAN_HASH_HPP |
||||||
|
|
||||||
|
#include "img_hash_base.hpp" |
||||||
|
|
||||||
|
namespace cv { |
||||||
|
namespace img_hash { |
||||||
|
|
||||||
|
//! @addtogroup img_hash
|
||||||
|
//! @{
|
||||||
|
|
||||||
|
enum BlockMeanHashMode |
||||||
|
{ |
||||||
|
BLOCK_MEAN_HASH_MODE_0 = 0, //!< use fewer block and generate 16*16/8 uchar hash value
|
||||||
|
BLOCK_MEAN_HASH_MODE_1 = 1, //!< use block blocks(step sizes/2), generate 31*31/8 + 1 uchar hash value
|
||||||
|
}; |
||||||
|
|
||||||
|
/** @brief Image hash based on block mean.
|
||||||
|
|
||||||
|
See @cite zauner2010implementation for details. |
||||||
|
*/ |
||||||
|
class CV_EXPORTS_W BlockMeanHash : public ImgHashBase |
||||||
|
{ |
||||||
|
public: |
||||||
|
/** @brief Create BlockMeanHash object
|
||||||
|
@param mode |
||||||
|
*/ |
||||||
|
CV_WRAP void setMode(int mode); |
||||||
|
CV_WRAP std::vector<double> getMean() const; |
||||||
|
CV_WRAP static Ptr<BlockMeanHash> create(int mode = BLOCK_MEAN_HASH_MODE_0); |
||||||
|
protected: |
||||||
|
BlockMeanHash() {} |
||||||
|
}; |
||||||
|
|
||||||
|
/** @brief Computes block mean hash of the input image
|
||||||
|
@param inputArr input image want to compute hash value, type should be CV_8UC4, CV_8UC3 or CV_8UC1. |
||||||
|
@param outputArr Hash value of input, it will contain 16 hex decimal number, return type is CV_8U |
||||||
|
@param mode |
||||||
|
*/ |
||||||
|
CV_EXPORTS_W void blockMeanHash(cv::InputArray inputArr, |
||||||
|
cv::OutputArray outputArr, |
||||||
|
int mode = BLOCK_MEAN_HASH_MODE_0); |
||||||
|
|
||||||
|
//! @}
|
||||||
|
|
||||||
|
}} // cv::img_hash::
|
||||||
|
|
||||||
|
#endif // OPENCV_BLOCK_MEAN_HASH_HPP
|
||||||
@ -0,0 +1,41 @@ |
|||||||
|
// This file is part of OpenCV project.
|
||||||
|
// It is subject to the license terms in the LICENSE file found in the top-level directory
|
||||||
|
// of this distribution and at http://opencv.org/license.html.
|
||||||
|
|
||||||
|
#ifndef OPENCV_COLOR_MOMENT_HASH_HPP |
||||||
|
#define OPENCV_COLOR_MOMENT_HASH_HPP |
||||||
|
|
||||||
|
#include "img_hash_base.hpp" |
||||||
|
|
||||||
|
namespace cv { |
||||||
|
namespace img_hash { |
||||||
|
|
||||||
|
//! @addtogroup img_hash
|
||||||
|
//! @{
|
||||||
|
|
||||||
|
/** @brief Image hash based on color moments.
|
||||||
|
|
||||||
|
See @cite tang2012perceptual for details. |
||||||
|
*/ |
||||||
|
class CV_EXPORTS_W ColorMomentHash : public ImgHashBase |
||||||
|
{ |
||||||
|
public: |
||||||
|
CV_WRAP static Ptr<ColorMomentHash> create(); |
||||||
|
protected: |
||||||
|
ColorMomentHash() {} |
||||||
|
}; |
||||||
|
|
||||||
|
/** @brief Computes color moment hash of the input, the algorithm
|
||||||
|
is come from the paper "Perceptual Hashing for Color Images |
||||||
|
Using Invariant Moments" |
||||||
|
@param inputArr input image want to compute hash value, |
||||||
|
type should be CV_8UC4, CV_8UC3 or CV_8UC1. |
||||||
|
@param outputArr 42 hash values with type CV_64F(double) |
||||||
|
*/ |
||||||
|
CV_EXPORTS_W void colorMomentHash(cv::InputArray inputArr, cv::OutputArray outputArr); |
||||||
|
|
||||||
|
//! @}
|
||||||
|
|
||||||
|
}} // cv::img_hash::
|
||||||
|
|
||||||
|
#endif // OPENCV_COLOR_MOMENT_HASH_HPP
|
||||||
@ -0,0 +1,46 @@ |
|||||||
|
// This file is part of OpenCV project.
|
||||||
|
// It is subject to the license terms in the LICENSE file found in the top-level directory
|
||||||
|
// of this distribution and at http://opencv.org/license.html.
|
||||||
|
|
||||||
|
#ifndef OPENCV_IMG_HASH_BASE_HPP |
||||||
|
#define OPENCV_IMG_HASH_BASE_HPP |
||||||
|
|
||||||
|
#include "opencv2/core.hpp" |
||||||
|
|
||||||
|
namespace cv { |
||||||
|
namespace img_hash { |
||||||
|
|
||||||
|
//! @addtogroup img_hash
|
||||||
|
//! @{
|
||||||
|
|
||||||
|
/** @brief The base class for image hash algorithms
|
||||||
|
*/ |
||||||
|
class CV_EXPORTS_W ImgHashBase : public Algorithm |
||||||
|
{ |
||||||
|
public: |
||||||
|
class ImgHashImpl; |
||||||
|
|
||||||
|
~ImgHashBase(); |
||||||
|
/** @brief Computes hash of the input image
|
||||||
|
@param inputArr input image want to compute hash value |
||||||
|
@param outputArr hash of the image |
||||||
|
*/ |
||||||
|
CV_WRAP void compute(cv::InputArray inputArr, cv::OutputArray outputArr); |
||||||
|
/** @brief Compare the hash value between inOne and inTwo
|
||||||
|
@param hashOne Hash value one |
||||||
|
@param hashTwo Hash value two |
||||||
|
@return value indicate similarity between inOne and inTwo, the meaning |
||||||
|
of the value vary from algorithms to algorithms |
||||||
|
*/ |
||||||
|
CV_WRAP double compare(cv::InputArray hashOne, cv::InputArray hashTwo) const; |
||||||
|
protected: |
||||||
|
ImgHashBase(); |
||||||
|
protected: |
||||||
|
Ptr<ImgHashImpl> pImpl; |
||||||
|
}; |
||||||
|
|
||||||
|
//! @}
|
||||||
|
|
||||||
|
} } // cv::img_hash::
|
||||||
|
|
||||||
|
#endif // OPENCV_IMG_HASH_BASE_HPP
|
||||||
@ -0,0 +1,64 @@ |
|||||||
|
// This file is part of OpenCV project.
|
||||||
|
// It is subject to the license terms in the LICENSE file found in the top-level directory
|
||||||
|
// of this distribution and at http://opencv.org/license.html.
|
||||||
|
|
||||||
|
#ifndef OPENCV_MARR_HILDRETH_HASH_HPP |
||||||
|
#define OPENCV_MARR_HILDRETH_HASH_HPP |
||||||
|
|
||||||
|
#include "img_hash_base.hpp" |
||||||
|
|
||||||
|
namespace cv { |
||||||
|
namespace img_hash { |
||||||
|
|
||||||
|
//! @addtogroup img_hash
|
||||||
|
//! @{
|
||||||
|
|
||||||
|
/** @brief Marr-Hildreth Operator Based Hash, slowest but more discriminative.
|
||||||
|
|
||||||
|
See @cite zauner2010implementation for details. |
||||||
|
*/ |
||||||
|
class CV_EXPORTS_W MarrHildrethHash : public ImgHashBase |
||||||
|
{ |
||||||
|
public: |
||||||
|
/**
|
||||||
|
* @brief self explain |
||||||
|
*/ |
||||||
|
CV_WRAP float getAlpha() const; |
||||||
|
|
||||||
|
/**
|
||||||
|
* @brief self explain |
||||||
|
*/ |
||||||
|
CV_WRAP float getScale() const; |
||||||
|
|
||||||
|
/** @brief Set Mh kernel parameters
|
||||||
|
@param alpha int scale factor for marr wavelet (default=2). |
||||||
|
@param scale int level of scale factor (default = 1) |
||||||
|
*/ |
||||||
|
CV_WRAP void setKernelParam(float alpha, float scale); |
||||||
|
|
||||||
|
/**
|
||||||
|
@param alpha int scale factor for marr wavelet (default=2). |
||||||
|
@param scale int level of scale factor (default = 1) |
||||||
|
*/ |
||||||
|
CV_WRAP static Ptr<MarrHildrethHash> create(float alpha = 2.0f, float scale = 1.0f); |
||||||
|
protected: |
||||||
|
MarrHildrethHash() {} |
||||||
|
}; |
||||||
|
|
||||||
|
/** @brief Computes average hash value of the input image
|
||||||
|
@param inputArr input image want to compute hash value, |
||||||
|
type should be CV_8UC4, CV_8UC3, CV_8UC1. |
||||||
|
@param outputArr Hash value of input, it will contain 16 hex |
||||||
|
decimal number, return type is CV_8U |
||||||
|
@param alpha int scale factor for marr wavelet (default=2). |
||||||
|
@param scale int level of scale factor (default = 1) |
||||||
|
*/ |
||||||
|
CV_EXPORTS_W void marrHildrethHash(cv::InputArray inputArr, |
||||||
|
cv::OutputArray outputArr, |
||||||
|
float alpha = 2.0f, float scale = 1.0f); |
||||||
|
|
||||||
|
//! @}
|
||||||
|
|
||||||
|
}} // cv::img_hash::
|
||||||
|
|
||||||
|
#endif // OPENCV_MARR_HILDRETH_HASH_HPP
|
||||||
@ -0,0 +1,41 @@ |
|||||||
|
// This file is part of OpenCV project.
|
||||||
|
// It is subject to the license terms in the LICENSE file found in the top-level directory
|
||||||
|
// of this distribution and at http://opencv.org/license.html.
|
||||||
|
|
||||||
|
#ifndef OPENCV_PHASH_HPP |
||||||
|
#define OPENCV_PHASH_HPP |
||||||
|
|
||||||
|
#include "img_hash_base.hpp" |
||||||
|
|
||||||
|
namespace cv { |
||||||
|
namespace img_hash { |
||||||
|
|
||||||
|
//! @addtogroup img_hash
|
||||||
|
//! @{
|
||||||
|
|
||||||
|
/** @brief pHash
|
||||||
|
|
||||||
|
Slower than average_hash, but tolerant of minor modifications |
||||||
|
|
||||||
|
This algorithm can combat more variation than averageHash, for more details please refer to @cite lookslikeit |
||||||
|
*/ |
||||||
|
class CV_EXPORTS_W PHash : public ImgHashBase |
||||||
|
{ |
||||||
|
public: |
||||||
|
CV_WRAP static Ptr<PHash> create(); |
||||||
|
protected: |
||||||
|
PHash() {} |
||||||
|
}; |
||||||
|
|
||||||
|
/** @brief Computes pHash value of the input image
|
||||||
|
@param inputArr input image want to compute hash value, |
||||||
|
type should be CV_8UC4, CV_8UC3, CV_8UC1. |
||||||
|
@param outputArr Hash value of input, it will contain 8 uchar value |
||||||
|
*/ |
||||||
|
CV_EXPORTS_W void pHash(cv::InputArray inputArr, cv::OutputArray outputArr); |
||||||
|
|
||||||
|
//! @}
|
||||||
|
|
||||||
|
} } // cv::img_hash::
|
||||||
|
|
||||||
|
#endif // OPENCV_PHASH_HPP
|
||||||
@ -0,0 +1,58 @@ |
|||||||
|
// This file is part of OpenCV project.
|
||||||
|
// It is subject to the license terms in the LICENSE file found in the top-level directory
|
||||||
|
// of this distribution and at http://opencv.org/license.html.
|
||||||
|
|
||||||
|
#ifndef OPENCV_RADIAL_VARIANCE_HASH_HPP |
||||||
|
#define OPENCV_RADIAL_VARIANCE_HASH_HPP |
||||||
|
|
||||||
|
#include "img_hash_base.hpp" |
||||||
|
|
||||||
|
namespace cv { |
||||||
|
namespace img_hash { |
||||||
|
|
||||||
|
//! @addtogroup img_hash
|
||||||
|
//! @{
|
||||||
|
|
||||||
|
|
||||||
|
/** @brief Image hash based on Radon transform.
|
||||||
|
|
||||||
|
See @cite tang2012perceptual for details. |
||||||
|
*/ |
||||||
|
class CV_EXPORTS_W RadialVarianceHash : public ImgHashBase |
||||||
|
{ |
||||||
|
public: |
||||||
|
CV_WRAP static Ptr<RadialVarianceHash> create(double sigma = 1, int numOfAngleLine = 180); |
||||||
|
|
||||||
|
CV_WRAP int getNumOfAngleLine() const; |
||||||
|
CV_WRAP double getSigma() const; |
||||||
|
|
||||||
|
CV_WRAP void setNumOfAngleLine(int value); |
||||||
|
CV_WRAP void setSigma(double value); |
||||||
|
|
||||||
|
// internals
|
||||||
|
std::vector<double> getFeatures(); |
||||||
|
cv::Mat getHash(); |
||||||
|
Mat getPixPerLine(Mat const &input); |
||||||
|
Mat getProjection(); |
||||||
|
protected: |
||||||
|
RadialVarianceHash() {} |
||||||
|
}; |
||||||
|
|
||||||
|
/** @brief Computes radial variance hash of the input image
|
||||||
|
@param inputArr input image want to compute hash value, |
||||||
|
type should be CV_8UC4, CV_8UC3, CV_8UC1. |
||||||
|
@param outputArr Hash value of input |
||||||
|
@param sigma Gaussian kernel standard deviation |
||||||
|
@param numOfAngleLine The number of angles to consider |
||||||
|
*/ |
||||||
|
CV_EXPORTS_W void radialVarianceHash(cv::InputArray inputArr, |
||||||
|
cv::OutputArray outputArr, |
||||||
|
double sigma = 1, |
||||||
|
int numOfAngleLine = 180); |
||||||
|
|
||||||
|
|
||||||
|
//! @}
|
||||||
|
|
||||||
|
}} // cv::img_hash::
|
||||||
|
|
||||||
|
#endif // OPENCV_RADIAL_VARIANCE_HASH_HPP
|
||||||
@ -0,0 +1,53 @@ |
|||||||
|
#include "opencv2/core.hpp" |
||||||
|
#include "opencv2/core/ocl.hpp" |
||||||
|
#include "opencv2/highgui.hpp" |
||||||
|
#include "opencv2/img_hash.hpp" |
||||||
|
|
||||||
|
#include <iostream> |
||||||
|
|
||||||
|
using namespace cv; |
||||||
|
using namespace cv::img_hash; |
||||||
|
using namespace std; |
||||||
|
|
||||||
|
template <typename T> |
||||||
|
inline void test_one(const std::string &title, const Mat &a, const Mat &b) |
||||||
|
{ |
||||||
|
cout << "=== " << title << " ===" << endl; |
||||||
|
TickMeter tick; |
||||||
|
Mat hashA, hashB; |
||||||
|
Ptr<ImgHashBase> func; |
||||||
|
func = T::create(); |
||||||
|
|
||||||
|
tick.reset(); tick.start(); |
||||||
|
func->compute(a, hashA); |
||||||
|
tick.stop(); |
||||||
|
cout << "compute1: " << tick.getTimeMilli() << " ms" << endl; |
||||||
|
|
||||||
|
tick.reset(); tick.start(); |
||||||
|
func->compute(b, hashB); |
||||||
|
tick.stop(); |
||||||
|
cout << "compute2: " << tick.getTimeMilli() << " ms" << endl; |
||||||
|
|
||||||
|
cout << "compare: " << func->compare(hashA, hashB) << endl << endl;; |
||||||
|
} |
||||||
|
|
||||||
|
int main(int argc, char **argv) |
||||||
|
{ |
||||||
|
if (argc != 3) |
||||||
|
{ |
||||||
|
cerr << "must input the path of input image and target image. ex : hash_samples lena.jpg lena2.jpg" << endl; |
||||||
|
return -1; |
||||||
|
} |
||||||
|
ocl::setUseOpenCL(false); |
||||||
|
|
||||||
|
Mat input = imread(argv[1]); |
||||||
|
Mat target = imread(argv[2]); |
||||||
|
|
||||||
|
test_one<AverageHash>("AverageHash", input, target); |
||||||
|
test_one<PHash>("PHash", input, target); |
||||||
|
test_one<MarrHildrethHash>("MarrHildrethHash", input, target); |
||||||
|
test_one<RadialVarianceHash>("RadialVarianceHash", input, target); |
||||||
|
test_one<BlockMeanHash>("BlockMeanHash", input, target); |
||||||
|
|
||||||
|
return 0; |
||||||
|
} |
||||||
@ -0,0 +1,86 @@ |
|||||||
|
// This file is part of OpenCV project.
|
||||||
|
// It is subject to the license terms in the LICENSE file found in the top-level directory
|
||||||
|
// of this distribution and at http://opencv.org/license.html.
|
||||||
|
|
||||||
|
#include "precomp.hpp" |
||||||
|
|
||||||
|
using namespace cv; |
||||||
|
using namespace std; |
||||||
|
using namespace img_hash; |
||||||
|
|
||||||
|
namespace { |
||||||
|
|
||||||
|
class AverageHashImpl : public ImgHashBase::ImgHashImpl |
||||||
|
{ |
||||||
|
private: |
||||||
|
cv::Mat bitsImg; |
||||||
|
cv::Mat grayImg; |
||||||
|
cv::Mat resizeImg; |
||||||
|
|
||||||
|
public: |
||||||
|
|
||||||
|
virtual void compute(cv::InputArray inputArr, cv::OutputArray outputArr) |
||||||
|
{ |
||||||
|
cv::Mat const input = inputArr.getMat(); |
||||||
|
CV_Assert(input.type() == CV_8UC4 || |
||||||
|
input.type() == CV_8UC3 || |
||||||
|
input.type() == CV_8U); |
||||||
|
|
||||||
|
cv::resize(input, resizeImg, cv::Size(8,8)); |
||||||
|
if(input.type() == CV_8UC3) |
||||||
|
{ |
||||||
|
cv::cvtColor(resizeImg, grayImg, CV_BGR2GRAY); |
||||||
|
} |
||||||
|
else if(input.type() == CV_8UC4) |
||||||
|
{ |
||||||
|
cv::cvtColor(resizeImg, grayImg, CV_BGRA2GRAY); |
||||||
|
} |
||||||
|
else |
||||||
|
{ |
||||||
|
grayImg = resizeImg; |
||||||
|
} |
||||||
|
|
||||||
|
uchar const imgMean = static_cast<uchar>(cvRound(cv::mean(grayImg)[0])); |
||||||
|
cv::compare(grayImg, imgMean, bitsImg, CMP_GT); |
||||||
|
bitsImg /= 255; |
||||||
|
outputArr.create(1, 8, CV_8U); |
||||||
|
cv::Mat hash = outputArr.getMat(); |
||||||
|
uchar *hash_ptr = hash.ptr<uchar>(0); |
||||||
|
uchar const *bits_ptr = bitsImg.ptr<uchar>(0); |
||||||
|
std::bitset<8> bits; |
||||||
|
for(size_t i = 0, j = 0; i != bitsImg.total(); ++j) |
||||||
|
{ |
||||||
|
for(size_t k = 0; k != 8; ++k) |
||||||
|
{ |
||||||
|
//avoid warning C4800, casting do not work
|
||||||
|
bits[k] = bits_ptr[i++] != 0; |
||||||
|
} |
||||||
|
hash_ptr[j] = static_cast<uchar>(bits.to_ulong()); |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
virtual double compare(cv::InputArray hashOne, cv::InputArray hashTwo) const |
||||||
|
{ |
||||||
|
return norm(hashOne, hashTwo, NORM_HAMMING); |
||||||
|
} |
||||||
|
}; |
||||||
|
|
||||||
|
} // namespace::
|
||||||
|
|
||||||
|
//==================================================================================================
|
||||||
|
|
||||||
|
namespace cv { namespace img_hash { |
||||||
|
|
||||||
|
Ptr<AverageHash> AverageHash::create() |
||||||
|
{ |
||||||
|
Ptr<AverageHash> res(new AverageHash()); |
||||||
|
res->pImpl = makePtr<AverageHashImpl>(); |
||||||
|
return res; |
||||||
|
} |
||||||
|
|
||||||
|
void averageHash(cv::InputArray inputArr, cv::OutputArray outputArr) |
||||||
|
{ |
||||||
|
AverageHashImpl().compute(inputArr, outputArr); |
||||||
|
} |
||||||
|
|
||||||
|
}} // cv::img_hash::
|
||||||
@ -0,0 +1,167 @@ |
|||||||
|
// This file is part of OpenCV project.
|
||||||
|
// It is subject to the license terms in the LICENSE file found in the top-level directory
|
||||||
|
// of this distribution and at http://opencv.org/license.html.
|
||||||
|
|
||||||
|
#include "precomp.hpp" |
||||||
|
|
||||||
|
using namespace cv; |
||||||
|
using namespace cv::img_hash; |
||||||
|
using namespace std; |
||||||
|
|
||||||
|
namespace { |
||||||
|
|
||||||
|
enum
|
||||||
|
{ |
||||||
|
imgWidth = 256, |
||||||
|
imgHeight = 256, |
||||||
|
blockWidth = 16, |
||||||
|
blockHeigth = 16, |
||||||
|
blockPerCol = imgHeight / blockHeigth, |
||||||
|
blockPerRow = imgWidth / blockWidth, |
||||||
|
rowSize = imgHeight - blockHeigth, |
||||||
|
colSize = imgWidth - blockWidth |
||||||
|
}; |
||||||
|
|
||||||
|
class BlockMeanHashImpl : public ImgHashBase::ImgHashImpl |
||||||
|
{ |
||||||
|
public: |
||||||
|
BlockMeanHashImpl(int mode) |
||||||
|
{ |
||||||
|
setMode(mode); |
||||||
|
} |
||||||
|
|
||||||
|
~BlockMeanHashImpl() {} |
||||||
|
|
||||||
|
virtual void compute(cv::InputArray inputArr, cv::OutputArray outputArr) |
||||||
|
{ |
||||||
|
cv::Mat const input = inputArr.getMat(); |
||||||
|
CV_Assert(input.type() == CV_8UC4 || |
||||||
|
input.type() == CV_8UC3 || |
||||||
|
input.type() == CV_8U); |
||||||
|
|
||||||
|
cv::resize(input, resizeImg_, cv::Size(imgWidth,imgHeight)); |
||||||
|
if(input.type() == CV_8UC3) |
||||||
|
{ |
||||||
|
cv::cvtColor(resizeImg_, grayImg_, CV_BGR2GRAY); |
||||||
|
} |
||||||
|
else if(input.type() == CV_8UC4) |
||||||
|
{ |
||||||
|
cv::cvtColor(resizeImg_, grayImg_, CV_BGRA2GRAY); |
||||||
|
} |
||||||
|
else |
||||||
|
{ |
||||||
|
grayImg_ = resizeImg_; |
||||||
|
} |
||||||
|
|
||||||
|
int pixColStep = blockWidth; |
||||||
|
int pixRowStep = blockHeigth; |
||||||
|
int numOfBlocks = 0; |
||||||
|
switch(mode_) |
||||||
|
{ |
||||||
|
case BLOCK_MEAN_HASH_MODE_0: |
||||||
|
{ |
||||||
|
numOfBlocks = blockPerCol * blockPerRow; |
||||||
|
break; |
||||||
|
} |
||||||
|
case BLOCK_MEAN_HASH_MODE_1: |
||||||
|
{ |
||||||
|
pixColStep /= 2; |
||||||
|
pixRowStep /= 2; |
||||||
|
numOfBlocks = (blockPerCol*2-1) * (blockPerRow*2-1); |
||||||
|
break; |
||||||
|
} |
||||||
|
default: |
||||||
|
break; |
||||||
|
} |
||||||
|
|
||||||
|
mean_.resize(numOfBlocks); |
||||||
|
findMean(pixRowStep, pixColStep); |
||||||
|
outputArr.create(1, numOfBlocks/8 + numOfBlocks % 8, CV_8U); |
||||||
|
cv::Mat hash = outputArr.getMat(); |
||||||
|
createHash(hash); |
||||||
|
} |
||||||
|
|
||||||
|
virtual double compare(cv::InputArray hashOne, cv::InputArray hashTwo) const |
||||||
|
{ |
||||||
|
return norm(hashOne, hashTwo, NORM_HAMMING); |
||||||
|
} |
||||||
|
|
||||||
|
void setMode(int mode) |
||||||
|
{ |
||||||
|
CV_Assert(mode == BLOCK_MEAN_HASH_MODE_0 || mode == BLOCK_MEAN_HASH_MODE_1); |
||||||
|
mode_ = mode; |
||||||
|
} |
||||||
|
|
||||||
|
void createHash(cv::Mat &hash) |
||||||
|
{ |
||||||
|
double const median = cv::mean(grayImg_)[0]; |
||||||
|
uchar *hashPtr = hash.ptr<uchar>(0); |
||||||
|
std::bitset<8> bits = 0; |
||||||
|
for(size_t i = 0; i < mean_.size(); ++i) |
||||||
|
{ |
||||||
|
size_t const residual = i%8; |
||||||
|
bits[residual] = mean_[i] < median ? 0 : 1; |
||||||
|
if(residual == 7) |
||||||
|
{ |
||||||
|
*hashPtr = static_cast<uchar>(bits.to_ulong()); |
||||||
|
++hashPtr; |
||||||
|
}else if(i == mean_.size() - 1) |
||||||
|
{ |
||||||
|
*hashPtr = bits[residual]; |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
void findMean(int pixRowStep, int pixColStep) |
||||||
|
{ |
||||||
|
size_t blockIdx = 0; |
||||||
|
for(int row = 0; row <= rowSize; row += pixRowStep) |
||||||
|
{ |
||||||
|
for(int col = 0; col <= colSize; col += pixColStep) |
||||||
|
{ |
||||||
|
mean_[blockIdx++] = cv::mean(grayImg_(cv::Rect(col, row, blockWidth, blockHeigth)))[0]; |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
cv::Mat grayImg_; |
||||||
|
std::vector<double> mean_; |
||||||
|
int mode_; |
||||||
|
cv::Mat resizeImg_; |
||||||
|
}; |
||||||
|
|
||||||
|
inline BlockMeanHashImpl *getLocalImpl(ImgHashBase::ImgHashImpl *ptr) |
||||||
|
{ |
||||||
|
BlockMeanHashImpl * impl = static_cast<BlockMeanHashImpl*>(ptr); |
||||||
|
CV_Assert(impl); |
||||||
|
return impl; |
||||||
|
} |
||||||
|
|
||||||
|
} |
||||||
|
|
||||||
|
//==================================================================================================
|
||||||
|
|
||||||
|
namespace cv { namespace img_hash { |
||||||
|
|
||||||
|
Ptr<BlockMeanHash> BlockMeanHash::create(int mode) |
||||||
|
{ |
||||||
|
Ptr<BlockMeanHash> res(new BlockMeanHash); |
||||||
|
res->pImpl = makePtr<BlockMeanHashImpl>(mode); |
||||||
|
return res; |
||||||
|
} |
||||||
|
|
||||||
|
void BlockMeanHash::setMode(int mode) |
||||||
|
{ |
||||||
|
getLocalImpl(pImpl)->setMode(mode); |
||||||
|
} |
||||||
|
|
||||||
|
std::vector<double> BlockMeanHash::getMean() const |
||||||
|
{ |
||||||
|
return getLocalImpl(pImpl)->mean_; |
||||||
|
} |
||||||
|
|
||||||
|
void blockMeanHash(cv::InputArray inputArr, cv::OutputArray outputArr, int mode) |
||||||
|
{ |
||||||
|
BlockMeanHashImpl(mode).compute(inputArr, outputArr); |
||||||
|
} |
||||||
|
|
||||||
|
}} // cv::img_hash::
|
||||||
@ -0,0 +1,95 @@ |
|||||||
|
// This file is part of OpenCV project.
|
||||||
|
// It is subject to the license terms in the LICENSE file found in the top-level directory
|
||||||
|
// of this distribution and at http://opencv.org/license.html.
|
||||||
|
|
||||||
|
#include "precomp.hpp" |
||||||
|
|
||||||
|
using namespace cv; |
||||||
|
using namespace cv::img_hash; |
||||||
|
using namespace std; |
||||||
|
|
||||||
|
namespace { |
||||||
|
|
||||||
|
class ColorMomentHashImpl : public ImgHashBase::ImgHashImpl |
||||||
|
{ |
||||||
|
public: |
||||||
|
~ColorMomentHashImpl() {} |
||||||
|
|
||||||
|
virtual void compute(cv::InputArray inputArr, cv::OutputArray outputArr) |
||||||
|
{ |
||||||
|
cv::Mat const input = inputArr.getMat(); |
||||||
|
CV_Assert(input.type() == CV_8UC4 || |
||||||
|
input.type() == CV_8UC3 || |
||||||
|
input.type() == CV_8U); |
||||||
|
|
||||||
|
if(input.type() == CV_8UC3) |
||||||
|
{ |
||||||
|
colorImg_ = input; |
||||||
|
} |
||||||
|
else if(input.type() == CV_8UC4) |
||||||
|
{ |
||||||
|
cv::cvtColor(input, colorImg_, CV_BGRA2BGR); |
||||||
|
} |
||||||
|
else |
||||||
|
{ |
||||||
|
cv::cvtColor(input, colorImg_, CV_GRAY2BGR); |
||||||
|
} |
||||||
|
|
||||||
|
cv::resize(colorImg_, resizeImg_, cv::Size(512,512), 0, 0, |
||||||
|
INTER_CUBIC); |
||||||
|
cv::GaussianBlur(resizeImg_, blurImg_, cv::Size(3,3), 0, 0); |
||||||
|
|
||||||
|
cv::cvtColor(blurImg_, colorSpace_, CV_BGR2HSV); |
||||||
|
cv::split(colorSpace_, channels_); |
||||||
|
outputArr.create(1, 42, CV_64F); |
||||||
|
cv::Mat hash = outputArr.getMat(); |
||||||
|
hash.setTo(0); |
||||||
|
computeMoments(hash.ptr<double>(0)); |
||||||
|
|
||||||
|
cv::cvtColor(blurImg_, colorSpace_, CV_BGR2YCrCb); |
||||||
|
cv::split(colorSpace_, channels_); |
||||||
|
computeMoments(hash.ptr<double>(0) + 21); |
||||||
|
} |
||||||
|
|
||||||
|
virtual double compare(cv::InputArray hashOne, cv::InputArray hashTwo) const |
||||||
|
{ |
||||||
|
return norm(hashOne, hashTwo, NORM_L2) * 10000; |
||||||
|
} |
||||||
|
|
||||||
|
private: |
||||||
|
void computeMoments(double *inout) |
||||||
|
{ |
||||||
|
for(size_t i = 0; i != channels_.size(); ++i) |
||||||
|
{ |
||||||
|
cv::HuMoments(cv::moments(channels_[i]), inout); |
||||||
|
inout += 7; |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
private: |
||||||
|
cv::Mat blurImg_; |
||||||
|
cv::Mat colorImg_; |
||||||
|
std::vector<cv::Mat> channels_; |
||||||
|
cv::Mat colorSpace_; |
||||||
|
cv::Mat resizeImg_; |
||||||
|
}; |
||||||
|
|
||||||
|
} |
||||||
|
|
||||||
|
//==================================================================================================
|
||||||
|
|
||||||
|
namespace cv { namespace img_hash { |
||||||
|
|
||||||
|
Ptr<ColorMomentHash> ColorMomentHash::create() |
||||||
|
{ |
||||||
|
Ptr<ColorMomentHash> res(new ColorMomentHash); |
||||||
|
res->pImpl = makePtr<ColorMomentHashImpl>(); |
||||||
|
return res; |
||||||
|
} |
||||||
|
|
||||||
|
void colorMomentHash(cv::InputArray inputArr, cv::OutputArray outputArr) |
||||||
|
{ |
||||||
|
ColorMomentHashImpl().compute(inputArr, outputArr); |
||||||
|
} |
||||||
|
|
||||||
|
} } // cv::img_hash::
|
||||||
@ -0,0 +1,28 @@ |
|||||||
|
// This file is part of OpenCV project.
|
||||||
|
// It is subject to the license terms in the LICENSE file found in the top-level directory
|
||||||
|
// of this distribution and at http://opencv.org/license.html.
|
||||||
|
|
||||||
|
#include "precomp.hpp" |
||||||
|
|
||||||
|
namespace cv { |
||||||
|
namespace img_hash{ |
||||||
|
|
||||||
|
ImgHashBase::ImgHashBase() |
||||||
|
{ |
||||||
|
} |
||||||
|
|
||||||
|
ImgHashBase::~ImgHashBase() |
||||||
|
{ |
||||||
|
} |
||||||
|
|
||||||
|
void ImgHashBase::compute(cv::InputArray inputArr, cv::OutputArray outputArr) |
||||||
|
{ |
||||||
|
pImpl->compute(inputArr, outputArr); |
||||||
|
} |
||||||
|
|
||||||
|
double ImgHashBase::compare(cv::InputArray hashOne, cv::InputArray hashTwo) const |
||||||
|
{ |
||||||
|
return pImpl->compare(hashOne, hashTwo); |
||||||
|
} |
||||||
|
|
||||||
|
} } // cv::img_hash::
|
||||||
@ -0,0 +1,212 @@ |
|||||||
|
// This file is part of OpenCV project.
|
||||||
|
// It is subject to the license terms in the LICENSE file found in the top-level directory
|
||||||
|
// of this distribution and at http://opencv.org/license.html.
|
||||||
|
|
||||||
|
#include "precomp.hpp" |
||||||
|
|
||||||
|
using namespace cv; |
||||||
|
using namespace cv::img_hash; |
||||||
|
using namespace std; |
||||||
|
|
||||||
|
namespace { |
||||||
|
|
||||||
|
void getMHKernel(float alpha, float level, cv::Mat &kernel) |
||||||
|
{ |
||||||
|
int const sigma = static_cast<int>(4*std::pow(alpha,level)); |
||||||
|
|
||||||
|
float const ratio = std::pow(alpha, -level); |
||||||
|
kernel.create(2*sigma+1, 2*sigma+1, CV_32F); |
||||||
|
for(int row = 0; row != kernel.rows; ++row) |
||||||
|
{ |
||||||
|
float const ydiff = static_cast<float>(row - sigma); |
||||||
|
float const ypos = ratio * ydiff; |
||||||
|
float const yposPow2 = ypos * ypos; |
||||||
|
float *kPtr = kernel.ptr<float>(row); |
||||||
|
for(int col = 0; col != kernel.cols; ++col) |
||||||
|
{ |
||||||
|
float const xpos = ratio * static_cast<float>((col - sigma)); |
||||||
|
float const a = xpos * xpos + yposPow2; |
||||||
|
kPtr[col] = (2-a)*std::exp(a/2); |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
void fillBlocks(cv::Mat const &freImg, cv::Mat &blocks) |
||||||
|
{ |
||||||
|
//TODO : use forEach may provide better speed, however,
|
||||||
|
//it is quite tedious to apply without lambda
|
||||||
|
blocks.setTo(0); |
||||||
|
for(int row = 0; row != blocks.rows; ++row) |
||||||
|
{ |
||||||
|
float *bptr = blocks.ptr<float>(row); |
||||||
|
int const rOffset = row*16; |
||||||
|
for(int col = 0; col != blocks.cols; ++col) |
||||||
|
{ |
||||||
|
cv::Rect const roi(rOffset,col*16,16,16); |
||||||
|
bptr[col] = |
||||||
|
static_cast<float>(cv::sum(freImg(roi))[0]); |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
void createHash(cv::Mat const &blocks, cv::Mat &hash) |
||||||
|
{ |
||||||
|
int hash_index = 0; |
||||||
|
int bit_index = 0; |
||||||
|
uchar hashbyte = 0; |
||||||
|
uchar *hashPtr = hash.ptr<uchar>(0); |
||||||
|
for (int row=0; row < 29; row += 4) |
||||||
|
{ |
||||||
|
for (int col=0; col < 29; col += 4) |
||||||
|
{ |
||||||
|
cv::Rect const roi(col,row,3,3); |
||||||
|
cv::Mat const blockROI = blocks(roi); |
||||||
|
float const avg = |
||||||
|
static_cast<float>(cv::sum(blockROI)[0]/9.0); |
||||||
|
for(int i = 0; i != blockROI.rows; ++i) |
||||||
|
{ |
||||||
|
float const *bptr = blockROI.ptr<float>(i); |
||||||
|
for(int j = 0; j != blockROI.cols; ++j) |
||||||
|
{ |
||||||
|
hashbyte <<= 1; |
||||||
|
if (bptr[j] > avg) |
||||||
|
{ |
||||||
|
hashbyte |= 0x01; |
||||||
|
} |
||||||
|
++bit_index; |
||||||
|
if ((bit_index%8) == 0) |
||||||
|
{ |
||||||
|
hash_index = (bit_index/8) - 1; |
||||||
|
hashPtr[hash_index] = hashbyte; |
||||||
|
hashbyte = 0x00; |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
class MarrHildrethHashImpl : public ImgHashBase::ImgHashImpl |
||||||
|
{ |
||||||
|
public: |
||||||
|
|
||||||
|
MarrHildrethHashImpl(float alpha = 2.0f, float scale = 1.0f) : alphaVal(alpha), scaleVal(scale) |
||||||
|
{ |
||||||
|
getMHKernel(alphaVal, scaleVal, mhKernel); |
||||||
|
blocks.create(31,31, CV_32F); |
||||||
|
} |
||||||
|
|
||||||
|
~MarrHildrethHashImpl() { } |
||||||
|
|
||||||
|
virtual void compute(cv::InputArray inputArr, cv::OutputArray outputArr) |
||||||
|
{ |
||||||
|
cv::Mat const input = inputArr.getMat(); |
||||||
|
CV_Assert(input.type() == CV_8UC4 || |
||||||
|
input.type() == CV_8UC3 || |
||||||
|
input.type() == CV_8U); |
||||||
|
|
||||||
|
if(input.type() == CV_8UC3) |
||||||
|
{ |
||||||
|
cv::cvtColor(input, grayImg, CV_BGR2GRAY); |
||||||
|
} |
||||||
|
else if(input.type() == CV_8UC4) |
||||||
|
{ |
||||||
|
cv::cvtColor(input, grayImg, CV_BGRA2GRAY); |
||||||
|
} |
||||||
|
else |
||||||
|
{ |
||||||
|
grayImg = input; |
||||||
|
} |
||||||
|
//pHash use Canny-deritch filter to blur the image
|
||||||
|
cv::GaussianBlur(grayImg, blurImg, cv::Size(7, 7), 0); |
||||||
|
cv::resize(blurImg, resizeImg, cv::Size(512, 512), 0, 0, INTER_CUBIC); |
||||||
|
cv::equalizeHist(resizeImg, equalizeImg); |
||||||
|
|
||||||
|
//extract frequency info by mh kernel
|
||||||
|
cv::filter2D(equalizeImg, freImg, CV_32F, mhKernel); |
||||||
|
fillBlocks(freImg, blocks); |
||||||
|
|
||||||
|
outputArr.create(1, 72, CV_8U); |
||||||
|
cv::Mat hash = outputArr.getMat(); |
||||||
|
createHash(blocks, hash); |
||||||
|
} |
||||||
|
|
||||||
|
virtual double compare(cv::InputArray hashOne, cv::InputArray hashTwo) const |
||||||
|
{ |
||||||
|
return norm(hashOne, hashTwo, NORM_HAMMING); |
||||||
|
} |
||||||
|
|
||||||
|
float getAlpha() const |
||||||
|
{ |
||||||
|
return alphaVal; |
||||||
|
} |
||||||
|
|
||||||
|
float getScale() const |
||||||
|
{ |
||||||
|
return scaleVal; |
||||||
|
} |
||||||
|
|
||||||
|
void setKernelParam(float alpha, float scale) |
||||||
|
{ |
||||||
|
alphaVal = alpha; |
||||||
|
scaleVal = scale; |
||||||
|
getMHKernel(alphaVal, scaleVal, mhKernel); |
||||||
|
} |
||||||
|
|
||||||
|
friend class MarrHildrethHash; |
||||||
|
|
||||||
|
private: |
||||||
|
float alphaVal; |
||||||
|
cv::Mat blocks; |
||||||
|
cv::Mat blurImg; |
||||||
|
cv::Mat equalizeImg; |
||||||
|
cv::Mat freImg; //frequency response image
|
||||||
|
cv::Mat grayImg; |
||||||
|
cv::Mat mhKernel; |
||||||
|
cv::Mat resizeImg; |
||||||
|
float scaleVal; |
||||||
|
}; |
||||||
|
|
||||||
|
inline MarrHildrethHashImpl *getLocalImpl(ImgHashBase::ImgHashImpl *ptr) |
||||||
|
{ |
||||||
|
MarrHildrethHashImpl * impl = static_cast<MarrHildrethHashImpl*>(ptr); |
||||||
|
CV_Assert(impl); |
||||||
|
return impl; |
||||||
|
} |
||||||
|
|
||||||
|
} |
||||||
|
|
||||||
|
//==================================================================================================
|
||||||
|
|
||||||
|
namespace cv { namespace img_hash { |
||||||
|
|
||||||
|
float MarrHildrethHash::getAlpha() const |
||||||
|
{ |
||||||
|
return getLocalImpl(pImpl)->getAlpha(); |
||||||
|
} |
||||||
|
|
||||||
|
float MarrHildrethHash::getScale() const |
||||||
|
{ |
||||||
|
return getLocalImpl(pImpl)->getScale(); |
||||||
|
} |
||||||
|
|
||||||
|
void MarrHildrethHash::setKernelParam(float alpha, float scale) |
||||||
|
{ |
||||||
|
getLocalImpl(pImpl)->setKernelParam(alpha, scale); |
||||||
|
} |
||||||
|
|
||||||
|
Ptr<MarrHildrethHash> MarrHildrethHash::create(float alpha, float scale) |
||||||
|
{ |
||||||
|
Ptr<MarrHildrethHash> res(new MarrHildrethHash); |
||||||
|
res->pImpl = makePtr<MarrHildrethHashImpl>(alpha, scale); |
||||||
|
return res; |
||||||
|
} |
||||||
|
|
||||||
|
void marrHildrethHash(cv::InputArray inputArr, |
||||||
|
cv::OutputArray outputArr, |
||||||
|
float alpha, float scale) |
||||||
|
{ |
||||||
|
MarrHildrethHashImpl(alpha, scale).compute(inputArr, outputArr); |
||||||
|
} |
||||||
|
|
||||||
|
} } // cv::img_hash::
|
||||||
@ -0,0 +1,93 @@ |
|||||||
|
// This file is part of OpenCV project.
|
||||||
|
// It is subject to the license terms in the LICENSE file found in the top-level directory
|
||||||
|
// of this distribution and at http://opencv.org/license.html.
|
||||||
|
|
||||||
|
#include "precomp.hpp" |
||||||
|
|
||||||
|
using namespace cv; |
||||||
|
using namespace cv::img_hash; |
||||||
|
using namespace std; |
||||||
|
|
||||||
|
namespace { |
||||||
|
|
||||||
|
class PHashImpl : public ImgHashBase::ImgHashImpl |
||||||
|
{ |
||||||
|
public: |
||||||
|
virtual void compute(cv::InputArray inputArr, cv::OutputArray outputArr) |
||||||
|
{ |
||||||
|
cv::Mat const input = inputArr.getMat(); |
||||||
|
CV_Assert(input.type() == CV_8UC4 || |
||||||
|
input.type() == CV_8UC3 || |
||||||
|
input.type() == CV_8U); |
||||||
|
|
||||||
|
cv::resize(input, resizeImg, cv::Size(32,32)); |
||||||
|
if(input.type() == CV_8UC3) |
||||||
|
{ |
||||||
|
cv::cvtColor(resizeImg, grayImg, CV_BGR2GRAY); |
||||||
|
} |
||||||
|
else if(input.type() == CV_8UC4) |
||||||
|
{ |
||||||
|
cv::cvtColor(resizeImg, grayImg, CV_BGRA2GRAY); |
||||||
|
} |
||||||
|
else |
||||||
|
{ |
||||||
|
grayImg = resizeImg; |
||||||
|
} |
||||||
|
|
||||||
|
grayImg.convertTo(grayFImg, CV_32F); |
||||||
|
cv::dct(grayFImg, dctImg); |
||||||
|
dctImg(cv::Rect(0, 0, 8, 8)).copyTo(topLeftDCT); |
||||||
|
topLeftDCT.at<float>(0, 0) = 0; |
||||||
|
float const imgMean = static_cast<float>(cv::mean(topLeftDCT)[0]); |
||||||
|
|
||||||
|
cv::compare(topLeftDCT, imgMean, bitsImg, CMP_GT); |
||||||
|
bitsImg /= 255; |
||||||
|
outputArr.create(1, 8, CV_8U); |
||||||
|
cv::Mat hash = outputArr.getMat(); |
||||||
|
uchar *hash_ptr = hash.ptr<uchar>(0); |
||||||
|
uchar const *bits_ptr = bitsImg.ptr<uchar>(0); |
||||||
|
std::bitset<8> bits; |
||||||
|
for(size_t i = 0, j = 0; i != bitsImg.total(); ++j) |
||||||
|
{ |
||||||
|
for(size_t k = 0; k != 8; ++k) |
||||||
|
{ |
||||||
|
//avoid warning C4800, casting do not work
|
||||||
|
bits[k] = bits_ptr[i++] != 0; |
||||||
|
} |
||||||
|
hash_ptr[j] = static_cast<uchar>(bits.to_ulong()); |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
virtual double compare(cv::InputArray hashOne, cv::InputArray hashTwo) const |
||||||
|
{ |
||||||
|
return norm(hashOne, hashTwo, NORM_HAMMING); |
||||||
|
} |
||||||
|
|
||||||
|
private: |
||||||
|
cv::Mat bitsImg; |
||||||
|
cv::Mat dctImg; |
||||||
|
cv::Mat grayFImg; |
||||||
|
cv::Mat grayImg; |
||||||
|
cv::Mat resizeImg; |
||||||
|
cv::Mat topLeftDCT; |
||||||
|
}; |
||||||
|
|
||||||
|
} // namespace::
|
||||||
|
|
||||||
|
//==================================================================================================
|
||||||
|
|
||||||
|
namespace cv { namespace img_hash { |
||||||
|
|
||||||
|
Ptr<PHash> PHash::create() |
||||||
|
{ |
||||||
|
Ptr<PHash> res(new PHash); |
||||||
|
res->pImpl = makePtr<PHashImpl>(); |
||||||
|
return res; |
||||||
|
} |
||||||
|
|
||||||
|
void pHash(cv::InputArray inputArr, cv::OutputArray outputArr) |
||||||
|
{ |
||||||
|
PHashImpl().compute(inputArr, outputArr); |
||||||
|
} |
||||||
|
|
||||||
|
} } // cv::img_hash::
|
||||||
@ -0,0 +1,29 @@ |
|||||||
|
// This file is part of OpenCV project.
|
||||||
|
// It is subject to the license terms in the LICENSE file found in the top-level directory
|
||||||
|
// of this distribution and at http://opencv.org/license.html.
|
||||||
|
|
||||||
|
#ifndef OPENCV_IMG_HASH_PRECOMP_H |
||||||
|
#define OPENCV_IMG_HASH_PRECOMP_H |
||||||
|
|
||||||
|
#include "opencv2/core.hpp" |
||||||
|
#include "opencv2/core/base.hpp" |
||||||
|
#include "opencv2/imgproc.hpp" |
||||||
|
#include "opencv2/imgproc/types_c.h" |
||||||
|
#include "opencv2/img_hash.hpp" |
||||||
|
|
||||||
|
#include <bitset> |
||||||
|
#include <iostream> |
||||||
|
|
||||||
|
namespace cv{ namespace img_hash { |
||||||
|
|
||||||
|
class ImgHashBase::ImgHashImpl |
||||||
|
{ |
||||||
|
public: |
||||||
|
virtual void compute(cv::InputArray inputArr, cv::OutputArray outputArr) = 0; |
||||||
|
virtual double compare(cv::InputArray hashOne, cv::InputArray hashTwo) const = 0; |
||||||
|
virtual ~ImgHashImpl() {} |
||||||
|
}; |
||||||
|
|
||||||
|
}} // cv::img_hash::
|
||||||
|
|
||||||
|
#endif // OPENCV_IMG_HASH_PRECOMP_H
|
||||||
@ -0,0 +1,361 @@ |
|||||||
|
// This file is part of OpenCV project.
|
||||||
|
// It is subject to the license terms in the LICENSE file found in the top-level directory
|
||||||
|
// of this distribution and at http://opencv.org/license.html.
|
||||||
|
|
||||||
|
#include "precomp.hpp" |
||||||
|
|
||||||
|
using namespace cv; |
||||||
|
using namespace cv::img_hash; |
||||||
|
using namespace std; |
||||||
|
|
||||||
|
namespace { |
||||||
|
|
||||||
|
enum
|
||||||
|
{ |
||||||
|
hashSize = 40, |
||||||
|
}; |
||||||
|
|
||||||
|
inline float roundingFactor(float val) |
||||||
|
{ |
||||||
|
return val >= 0 ? 0.5f : -0.5f; |
||||||
|
} |
||||||
|
|
||||||
|
inline int createOffSet(int length) |
||||||
|
{ |
||||||
|
float const center = static_cast<float>(length/2); |
||||||
|
return static_cast<int>(std::floor(center + roundingFactor(center))); |
||||||
|
} |
||||||
|
|
||||||
|
class RadialVarianceHashImpl : public ImgHashBase::ImgHashImpl |
||||||
|
{ |
||||||
|
public: |
||||||
|
cv::Mat blurImg_; |
||||||
|
std::vector<double> features_; |
||||||
|
cv::Mat grayImg_; |
||||||
|
int numOfAngelLine_; |
||||||
|
cv::Mat pixPerLine_; |
||||||
|
cv::Mat projections_; |
||||||
|
double sigma_; |
||||||
|
|
||||||
|
RadialVarianceHashImpl(double sigma, int numOfAngleLine) |
||||||
|
: numOfAngelLine_(numOfAngleLine), sigma_(sigma) |
||||||
|
{ |
||||||
|
} |
||||||
|
|
||||||
|
~RadialVarianceHashImpl() {} |
||||||
|
|
||||||
|
virtual void compute(cv::InputArray inputArr, cv::OutputArray outputArr) |
||||||
|
{ |
||||||
|
cv::Mat const input = inputArr.getMat(); |
||||||
|
CV_Assert(input.type() == CV_8UC4 || |
||||||
|
input.type() == CV_8UC3 || |
||||||
|
input.type() == CV_8U); |
||||||
|
|
||||||
|
if(input.type() == CV_8UC3) |
||||||
|
{ |
||||||
|
cv::cvtColor(input, grayImg_, CV_BGR2GRAY); |
||||||
|
} |
||||||
|
else if(input.type() == CV_8UC4) |
||||||
|
{ |
||||||
|
cv::cvtColor(input, grayImg_, CV_BGRA2GRAY); |
||||||
|
} |
||||||
|
else |
||||||
|
{ |
||||||
|
grayImg_ = input; |
||||||
|
} |
||||||
|
|
||||||
|
cv::GaussianBlur(grayImg_, blurImg_, cv::Size(0,0), sigma_, sigma_); |
||||||
|
radialProjections(blurImg_); |
||||||
|
findFeatureVector(); |
||||||
|
outputArr.create(1, hashSize, CV_8U); |
||||||
|
cv::Mat hash = outputArr.getMat(); |
||||||
|
hashCalculate(hash); |
||||||
|
} |
||||||
|
|
||||||
|
virtual double compare(cv::InputArray hashOne, cv::InputArray hashTwo) const |
||||||
|
{ |
||||||
|
cv::Mat const hashOneF = hashOne.getMat(); |
||||||
|
cv::Mat const hashTwoF = hashTwo.getMat(); |
||||||
|
CV_Assert(hashOneF.cols == hashSize && hashOneF.cols == hashTwoF.cols); |
||||||
|
|
||||||
|
float bufferOne[hashSize]; |
||||||
|
cv::Mat hashFloatOne(1, hashSize, CV_32F, bufferOne); |
||||||
|
hashOneF.convertTo(hashFloatOne, CV_32F); |
||||||
|
|
||||||
|
float bufferTwo[hashSize]; |
||||||
|
cv::Mat hashFloatTwo(1, hashSize, CV_32F, bufferTwo); |
||||||
|
hashTwoF.convertTo(hashFloatTwo, CV_32F); |
||||||
|
|
||||||
|
int const pixNum = hashFloatOne.rows * hashFloatOne.cols; |
||||||
|
cv::Scalar hOneMean, hOneStd, hTwoMean, hTwoStd; |
||||||
|
cv::meanStdDev(hashFloatOne, hOneMean, hOneStd); |
||||||
|
cv::meanStdDev(hashFloatTwo, hTwoMean, hTwoStd); |
||||||
|
|
||||||
|
// Compute covariance and correlation coefficient
|
||||||
|
hashFloatOne -= hOneMean; |
||||||
|
hashFloatTwo -= hTwoMean; |
||||||
|
double max = std::numeric_limits<double>::min(); |
||||||
|
for(int i = 0; i != hashSize; ++i) |
||||||
|
{ |
||||||
|
double const covar = (hashFloatOne).dot(hashFloatTwo) / pixNum; |
||||||
|
double const corre = covar / (hOneStd[0] * hTwoStd[0] + 1e-20); |
||||||
|
max = std::max(corre, max); |
||||||
|
//move last value to first position, first value to second position,
|
||||||
|
//second value to third position and so on
|
||||||
|
float const preValue = bufferTwo[hashSize-1]; |
||||||
|
std::copy_backward(bufferTwo, bufferTwo + hashSize - 1, bufferTwo + hashSize); |
||||||
|
bufferTwo[0] = preValue; |
||||||
|
} |
||||||
|
|
||||||
|
//return peak correlation coefficient
|
||||||
|
return max; |
||||||
|
} |
||||||
|
|
||||||
|
int getNumOfAngleLine() const |
||||||
|
{ |
||||||
|
return numOfAngelLine_; |
||||||
|
} |
||||||
|
double getSigma() const |
||||||
|
{ |
||||||
|
return sigma_; |
||||||
|
} |
||||||
|
|
||||||
|
void setNumOfAngleLine(int value) |
||||||
|
{ |
||||||
|
CV_Assert(value > 0); |
||||||
|
numOfAngelLine_ = value; |
||||||
|
} |
||||||
|
void setSigma(double value) |
||||||
|
{ |
||||||
|
CV_Assert(value >= 1.0); |
||||||
|
sigma_ = value; |
||||||
|
} |
||||||
|
|
||||||
|
void afterHalfProjections(cv::Mat const &input, int D, int xOff, int yOff) |
||||||
|
{ |
||||||
|
int *pplPtr = pixPerLine_.ptr<int>(0); |
||||||
|
int const init = 3*numOfAngelLine_/4; |
||||||
|
for(int k = init, j = 0; k < numOfAngelLine_; ++k, j += 2) |
||||||
|
{ |
||||||
|
float const theta = k*3.14159f/numOfAngelLine_; |
||||||
|
float const alpha = std::tan(theta); |
||||||
|
uchar *projDown = projections_.ptr<uchar>(k); |
||||||
|
uchar *projUp = projections_.ptr<uchar>(k-j); |
||||||
|
for(int x = 0; x < D; ++x) |
||||||
|
{ |
||||||
|
float const y = alpha*(x-xOff); |
||||||
|
int const yd = static_cast<int>(std::floor(y + roundingFactor(y))); |
||||||
|
if((yd + yOff >= 0)&&(yd + yOff < input.rows) && (x < input.cols)) |
||||||
|
{ |
||||||
|
projDown[x] = input.at<uchar>(yd+yOff, x); |
||||||
|
pplPtr[k] += 1; |
||||||
|
} |
||||||
|
if ((yOff - yd >= 0)&&(yOff - yd < input.cols)&& |
||||||
|
(2*yOff - x >= 0)&&(2*yOff- x < input.rows)&& |
||||||
|
(k != init)) |
||||||
|
{ |
||||||
|
projUp[x] = |
||||||
|
input.at<uchar>(-(x-yOff)+yOff, -yd+yOff); |
||||||
|
pplPtr[k-j] += 1; |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
void findFeatureVector() |
||||||
|
{ |
||||||
|
features_.resize(numOfAngelLine_); |
||||||
|
double sum = 0.0; |
||||||
|
double sumSqd = 0.0; |
||||||
|
int const *pplPtr = pixPerLine_.ptr<int>(0); |
||||||
|
for(int k=0; k < numOfAngelLine_; ++k) |
||||||
|
{ |
||||||
|
double lineSum = 0.0; |
||||||
|
double lineSumSqd = 0.0; |
||||||
|
//original implementation of pHash may generate zero pixNum, this
|
||||||
|
//will cause NaN value and make the features become less discriminative
|
||||||
|
//to avoid this problem, I add a small value--0.00001
|
||||||
|
double const pixNum = pplPtr[k] + 0.00001; |
||||||
|
double const pixNumPow2 = pixNum * pixNum; |
||||||
|
uchar const *projPtr = projections_.ptr<uchar>(k); |
||||||
|
for(int i = 0; i < projections_.cols; ++i) |
||||||
|
{ |
||||||
|
double const value = projPtr[i]; |
||||||
|
lineSum += value; |
||||||
|
lineSumSqd += value * value; |
||||||
|
} |
||||||
|
features_[k] = (lineSumSqd/pixNum) - |
||||||
|
(lineSum*lineSum)/(pixNumPow2); |
||||||
|
sum += features_[k]; |
||||||
|
sumSqd += features_[k]*features_[k]; |
||||||
|
} |
||||||
|
double const numOfALPow2 = numOfAngelLine_ * numOfAngelLine_; |
||||||
|
double const mean = sum/numOfAngelLine_; |
||||||
|
double const var = std::sqrt((sumSqd/numOfAngelLine_) - (sum*sum)/(numOfALPow2)); |
||||||
|
for(int i = 0; i < numOfAngelLine_; ++i) |
||||||
|
{ |
||||||
|
features_[i] = (features_[i] - mean)/var; |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
void firstHalfProjections(cv::Mat const &input, int D, int xOff, int yOff) |
||||||
|
{ |
||||||
|
int *pplPtr = pixPerLine_.ptr<int>(0); |
||||||
|
for(int k = 0; k < numOfAngelLine_/4+1; ++k) |
||||||
|
{ |
||||||
|
float const theta = k*3.14159f/numOfAngelLine_; |
||||||
|
float const alpha = std::tan(theta); |
||||||
|
uchar *projOne = projections_.ptr<uchar>(k); |
||||||
|
uchar *projTwo = projections_.ptr<uchar>(numOfAngelLine_/2-k); |
||||||
|
for(int x = 0; x < D; ++x) |
||||||
|
{ |
||||||
|
float const y = alpha*(x-xOff); |
||||||
|
int const yd = static_cast<int>(std::floor(y + roundingFactor(y))); |
||||||
|
if((yd + yOff >= 0)&&(yd + yOff < input.rows) && (x < input.cols)) |
||||||
|
{ |
||||||
|
projOne[x] = input.at<uchar>(yd+yOff, x); |
||||||
|
pplPtr[k] += 1; |
||||||
|
} |
||||||
|
if((yd + xOff >= 0) && (yd + xOff < input.cols) && |
||||||
|
(k != numOfAngelLine_/4) && (x < input.rows)) |
||||||
|
{ |
||||||
|
projTwo[x] = |
||||||
|
input.at<uchar>(x, yd+xOff); |
||||||
|
pplPtr[numOfAngelLine_/2-k] += 1; |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
void hashCalculate(cv::Mat &hash) |
||||||
|
{ |
||||||
|
double temp[hashSize]; |
||||||
|
double max = 0; |
||||||
|
double min = 0; |
||||||
|
size_t const featureSize = features_.size(); |
||||||
|
//constexpr is a better choice
|
||||||
|
double const sqrtTwo = 1.4142135623730950488016887242097; |
||||||
|
for(int k = 0; k < hash.cols; ++k) |
||||||
|
{ |
||||||
|
double sum = 0; |
||||||
|
for(size_t n = 0; n < featureSize; ++n) |
||||||
|
{ |
||||||
|
sum += features_[n]*std::cos((3.14159*(2*n+1)*k)/(2*featureSize)); |
||||||
|
} |
||||||
|
temp[k] = k == 0 ? sum/std::sqrt(featureSize) : |
||||||
|
sum*sqrtTwo/std::sqrt(featureSize); |
||||||
|
if(temp[k] > max) |
||||||
|
{ |
||||||
|
max = temp[k]; |
||||||
|
} |
||||||
|
else if(temp[k] < min) |
||||||
|
{ |
||||||
|
min = temp[k]; |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
double const range = max - min; |
||||||
|
if(range != 0) |
||||||
|
{ |
||||||
|
//std::transform is a better choice if lambda supported
|
||||||
|
uchar *hashPtr = hash.ptr<uchar>(0); |
||||||
|
for(int i = 0; i < hash.cols; ++i) |
||||||
|
{ |
||||||
|
hashPtr[i] = static_cast<uchar>((255*(temp[i] - min)/range)); |
||||||
|
} |
||||||
|
} |
||||||
|
else |
||||||
|
{ |
||||||
|
hash = 0; |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
void radialProjections(cv::Mat const &input) |
||||||
|
{ |
||||||
|
int const D = (input.cols > input.rows) ? input.cols : input.rows; |
||||||
|
//Different with PHash, this part reverse the row size and col size,
|
||||||
|
//because cv::Mat is row major but not column major
|
||||||
|
projections_.create(numOfAngelLine_, D, CV_8U); |
||||||
|
projections_ = 0; |
||||||
|
pixPerLine_.create(1, numOfAngelLine_, CV_32S); |
||||||
|
pixPerLine_ = 0; |
||||||
|
int const xOff = createOffSet(input.cols); |
||||||
|
int const yOff = createOffSet(input.rows); |
||||||
|
|
||||||
|
firstHalfProjections(input, D, xOff, yOff); |
||||||
|
afterHalfProjections(input, D, xOff, yOff); |
||||||
|
} |
||||||
|
}; |
||||||
|
|
||||||
|
inline RadialVarianceHashImpl *getLocalImpl(ImgHashBase::ImgHashImpl *ptr) |
||||||
|
{ |
||||||
|
RadialVarianceHashImpl * impl = static_cast<RadialVarianceHashImpl*>(ptr); |
||||||
|
CV_Assert(impl); |
||||||
|
return impl; |
||||||
|
} |
||||||
|
|
||||||
|
} // namespace::
|
||||||
|
|
||||||
|
//==================================================================================================
|
||||||
|
|
||||||
|
namespace cv { namespace img_hash { |
||||||
|
|
||||||
|
Ptr<RadialVarianceHash> RadialVarianceHash::create(double sigma, int numOfAngleLine) |
||||||
|
{ |
||||||
|
Ptr<RadialVarianceHash> res(new RadialVarianceHash); |
||||||
|
res->pImpl = makePtr<RadialVarianceHashImpl>(sigma, numOfAngleLine); |
||||||
|
return res; |
||||||
|
} |
||||||
|
|
||||||
|
int RadialVarianceHash::getNumOfAngleLine() const |
||||||
|
{ |
||||||
|
return getLocalImpl(pImpl)->getNumOfAngleLine(); |
||||||
|
} |
||||||
|
|
||||||
|
double RadialVarianceHash::getSigma() const |
||||||
|
{ |
||||||
|
return getLocalImpl(pImpl)->getSigma(); |
||||||
|
} |
||||||
|
|
||||||
|
void RadialVarianceHash::setNumOfAngleLine(int value) |
||||||
|
{ |
||||||
|
getLocalImpl(pImpl)->setNumOfAngleLine(value); |
||||||
|
} |
||||||
|
|
||||||
|
void RadialVarianceHash::setSigma(double value) |
||||||
|
{ |
||||||
|
getLocalImpl(pImpl)->setSigma(value); |
||||||
|
} |
||||||
|
|
||||||
|
std::vector<double> RadialVarianceHash::getFeatures() |
||||||
|
{ |
||||||
|
getLocalImpl(pImpl)->findFeatureVector(); |
||||||
|
return getLocalImpl(pImpl)->features_; |
||||||
|
} |
||||||
|
|
||||||
|
cv::Mat RadialVarianceHash::getHash() |
||||||
|
{ |
||||||
|
cv::Mat hash; |
||||||
|
getLocalImpl(pImpl)->hashCalculate(hash); |
||||||
|
return hash; |
||||||
|
} |
||||||
|
|
||||||
|
Mat RadialVarianceHash::getPixPerLine(Mat const &input) |
||||||
|
{ |
||||||
|
getLocalImpl(pImpl)->radialProjections(input); |
||||||
|
return getLocalImpl(pImpl)->pixPerLine_; |
||||||
|
} |
||||||
|
|
||||||
|
Mat RadialVarianceHash::getProjection() |
||||||
|
{ |
||||||
|
return getLocalImpl(pImpl)->projections_; |
||||||
|
} |
||||||
|
|
||||||
|
void radialVarianceHash(cv::InputArray inputArr, |
||||||
|
cv::OutputArray outputArr, |
||||||
|
double sigma, int numOfAngleLine) |
||||||
|
{ |
||||||
|
RadialVarianceHashImpl(sigma, numOfAngleLine).compute(inputArr, outputArr); |
||||||
|
} |
||||||
|
|
||||||
|
}} // cv::img_hash::
|
||||||
@ -0,0 +1,58 @@ |
|||||||
|
// This file is part of OpenCV project.
|
||||||
|
// It is subject to the license terms in the LICENSE file found in the top-level directory
|
||||||
|
// of this distribution and at http://opencv.org/license.html.
|
||||||
|
|
||||||
|
#include "test_precomp.hpp" |
||||||
|
|
||||||
|
#include <bitset> |
||||||
|
|
||||||
|
using namespace cv; |
||||||
|
|
||||||
|
class CV_AverageHashTest : public cvtest::BaseTest |
||||||
|
{ |
||||||
|
public: |
||||||
|
CV_AverageHashTest(); |
||||||
|
~CV_AverageHashTest(); |
||||||
|
protected: |
||||||
|
void run(int /* idx */); |
||||||
|
}; |
||||||
|
|
||||||
|
CV_AverageHashTest::CV_AverageHashTest(){} |
||||||
|
CV_AverageHashTest::~CV_AverageHashTest(){} |
||||||
|
|
||||||
|
void CV_AverageHashTest::run(int ) |
||||||
|
{ |
||||||
|
cv::Mat const input = (cv::Mat_<uchar>(8, 8) << |
||||||
|
1, 5, 4, 6, 3, 2, 7, 8, |
||||||
|
2, 4, 8, 9, 2, 1, 4, 3, |
||||||
|
3, 4, 5, 7, 9, 8, 7, 6, |
||||||
|
1, 2, 3, 4, 5, 6, 7, 8, |
||||||
|
8, 7, 2, 3, 6, 4, 5, 1, |
||||||
|
3, 4, 1, 2, 9, 8, 4, 2, |
||||||
|
6, 7, 8, 9, 7, 4, 3, 2, |
||||||
|
8, 7, 6, 5, 4, 3, 2, 1); |
||||||
|
cv::Mat hash; |
||||||
|
cv::img_hash::averageHash(input, hash); |
||||||
|
bool const expectResult[] = |
||||||
|
{ |
||||||
|
0,0,0,1,0,0,1,1, |
||||||
|
0,0,1,1,0,0,0,0, |
||||||
|
0,0,0,1,1,1,1,1, |
||||||
|
0,0,0,0,0,1,1,1, |
||||||
|
1,1,0,0,1,0,0,0, |
||||||
|
0,0,0,0,1,1,0,0, |
||||||
|
1,1,1,1,1,0,0,0, |
||||||
|
1,1,1,0,0,0,0,0 |
||||||
|
}; |
||||||
|
uchar const *hashPtr = hash.ptr<uchar>(0); |
||||||
|
for(int i = 0; i != hash.cols; ++i) |
||||||
|
{ |
||||||
|
std::bitset<8> const bits = hashPtr[i]; |
||||||
|
for(int j = 0; j != 8; ++j) |
||||||
|
{ |
||||||
|
EXPECT_EQ(bits[j], expectResult[i*8+j]); |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
TEST(average_hash_test, accuracy) { CV_AverageHashTest test; test.safe_run(); } |
||||||
@ -0,0 +1,212 @@ |
|||||||
|
// This file is part of OpenCV project.
|
||||||
|
// It is subject to the license terms in the LICENSE file found in the top-level directory
|
||||||
|
// of this distribution and at http://opencv.org/license.html.
|
||||||
|
|
||||||
|
#include "test_precomp.hpp" |
||||||
|
|
||||||
|
#include <bitset> |
||||||
|
|
||||||
|
using namespace cv; |
||||||
|
using namespace cv::img_hash; |
||||||
|
|
||||||
|
/**
|
||||||
|
*The expected results of this test case are come from the Phash library, |
||||||
|
*I use it as golden model |
||||||
|
*/ |
||||||
|
class CV_BlockMeanHashTest : public cvtest::BaseTest |
||||||
|
{ |
||||||
|
public: |
||||||
|
CV_BlockMeanHashTest(); |
||||||
|
protected: |
||||||
|
void run(int /* idx */); |
||||||
|
|
||||||
|
void testMeanMode0(); |
||||||
|
void testMeanMode1(); |
||||||
|
void testHashMode0(); |
||||||
|
void testHashMode1(); |
||||||
|
|
||||||
|
cv::Mat input; |
||||||
|
cv::Mat hash; |
||||||
|
Ptr<cv::img_hash::BlockMeanHash> bmh; |
||||||
|
}; |
||||||
|
|
||||||
|
CV_BlockMeanHashTest::CV_BlockMeanHashTest() |
||||||
|
{ |
||||||
|
input.create(256, 256, CV_8U); |
||||||
|
for(int row = 0; row != input.rows; ++row) |
||||||
|
{ |
||||||
|
uchar value = static_cast<uchar>(row); |
||||||
|
for(int col = 0; col != input.cols; ++col) |
||||||
|
{ |
||||||
|
input.at<uchar>(row, col) = value++; |
||||||
|
} |
||||||
|
} |
||||||
|
bmh = BlockMeanHash::create(BLOCK_MEAN_HASH_MODE_0); |
||||||
|
} |
||||||
|
|
||||||
|
void CV_BlockMeanHashTest::testMeanMode0() |
||||||
|
{ |
||||||
|
std::vector<double> const &features = bmh->getMean(); |
||||||
|
double const expectResult[] = |
||||||
|
{15,31,47,63,79,95,111,127,143,159,175,191,207,223,239,135, |
||||||
|
31,47,63,79,95,111,127,143,159,175,191,207,223,239,135,15, |
||||||
|
47,63,79,95,111,127,143,159,175,191,207,223,239,135,15,31, |
||||||
|
63,79,95,111,127,143,159,175,191,207,223,239,135,15,31,47, |
||||||
|
79,95,111,127,143,159,175,191,207,223,239,135,15,31,47,63, |
||||||
|
95,111,127,143,159,175,191,207,223,239,135,15,31,47,63,79, |
||||||
|
111,127,143,159,175,191,207,223,239,135,15,31,47,63,79,95, |
||||||
|
127,143,159,175,191,207,223,239,135,15,31,47,63,79,95,111, |
||||||
|
143,159,175,191,207,223,239,135,15,31,47,63,79,95,111,127, |
||||||
|
159,175,191,207,223,239,135,15,31,47,63,79,95,111,127,143, |
||||||
|
175,191,207,223,239,135,15,31,47,63,79,95,111,127,143,159, |
||||||
|
191,207,223,239,135,15,31,47,63,79,95,111,127,143,159,175, |
||||||
|
207,223,239,135,15,31,47,63,79,95,111,127,143,159,175,191, |
||||||
|
223,239,135,15,31,47,63,79,95,111,127,143,159,175,191,207, |
||||||
|
239,135,15,31,47,63,79,95,111,127,143,159,175,191,207,223, |
||||||
|
135,15,31,47,63,79,95,111,127,143,159,175,191,207,223,239,}; |
||||||
|
for(size_t i = 0; i != features.size(); ++i) |
||||||
|
{ |
||||||
|
ASSERT_NEAR(features[i], expectResult[i], 0.0001); |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
void CV_BlockMeanHashTest::testMeanMode1() |
||||||
|
{ |
||||||
|
std::vector<double> const &features = bmh->getMean(); |
||||||
|
double const expectResult[] = |
||||||
|
{15,23,31,39,47,55,63,71,79,87,95,103,111,119,127,135,143,151,159,167,175,183,191,199,207,215,223,231,239,219,135, |
||||||
|
23,31,39,47,55,63,71,79,87,95,103,111,119,127,135,143,151,159,167,175,183,191,199,207,215,223,231,239,219,135,43, |
||||||
|
31,39,47,55,63,71,79,87,95,103,111,119,127,135,143,151,159,167,175,183,191,199,207,215,223,231,239,219,135,43,15, |
||||||
|
39,47,55,63,71,79,87,95,103,111,119,127,135,143,151,159,167,175,183,191,199,207,215,223,231,239,219,135,43,15,23, |
||||||
|
47,55,63,71,79,87,95,103,111,119,127,135,143,151,159,167,175,183,191,199,207,215,223,231,239,219,135,43,15,23,31, |
||||||
|
55,63,71,79,87,95,103,111,119,127,135,143,151,159,167,175,183,191,199,207,215,223,231,239,219,135,43,15,23,31,39, |
||||||
|
63,71,79,87,95,103,111,119,127,135,143,151,159,167,175,183,191,199,207,215,223,231,239,219,135,43,15,23,31,39,47, |
||||||
|
71,79,87,95,103,111,119,127,135,143,151,159,167,175,183,191,199,207,215,223,231,239,219,135,43,15,23,31,39,47,55, |
||||||
|
79,87,95,103,111,119,127,135,143,151,159,167,175,183,191,199,207,215,223,231,239,219,135,43,15,23,31,39,47,55,63, |
||||||
|
87,95,103,111,119,127,135,143,151,159,167,175,183,191,199,207,215,223,231,239,219,135,43,15,23,31,39,47,55,63,71, |
||||||
|
95,103,111,119,127,135,143,151,159,167,175,183,191,199,207,215,223,231,239,219,135,43,15,23,31,39,47,55,63,71,79, |
||||||
|
103,111,119,127,135,143,151,159,167,175,183,191,199,207,215,223,231,239,219,135,43,15,23,31,39,47,55,63,71,79,87, |
||||||
|
111,119,127,135,143,151,159,167,175,183,191,199,207,215,223,231,239,219,135,43,15,23,31,39,47,55,63,71,79,87,95, |
||||||
|
119,127,135,143,151,159,167,175,183,191,199,207,215,223,231,239,219,135,43,15,23,31,39,47,55,63,71,79,87,95,103, |
||||||
|
127,135,143,151,159,167,175,183,191,199,207,215,223,231,239,219,135,43,15,23,31,39,47,55,63,71,79,87,95,103,111, |
||||||
|
135,143,151,159,167,175,183,191,199,207,215,223,231,239,219,135,43,15,23,31,39,47,55,63,71,79,87,95,103,111,119, |
||||||
|
143,151,159,167,175,183,191,199,207,215,223,231,239,219,135,43,15,23,31,39,47,55,63,71,79,87,95,103,111,119,127, |
||||||
|
151,159,167,175,183,191,199,207,215,223,231,239,219,135,43,15,23,31,39,47,55,63,71,79,87,95,103,111,119,127,135, |
||||||
|
159,167,175,183,191,199,207,215,223,231,239,219,135,43,15,23,31,39,47,55,63,71,79,87,95,103,111,119,127,135,143, |
||||||
|
167,175,183,191,199,207,215,223,231,239,219,135,43,15,23,31,39,47,55,63,71,79,87,95,103,111,119,127,135,143,151, |
||||||
|
175,183,191,199,207,215,223,231,239,219,135,43,15,23,31,39,47,55,63,71,79,87,95,103,111,119,127,135,143,151,159, |
||||||
|
183,191,199,207,215,223,231,239,219,135,43,15,23,31,39,47,55,63,71,79,87,95,103,111,119,127,135,143,151,159,167, |
||||||
|
191,199,207,215,223,231,239,219,135,43,15,23,31,39,47,55,63,71,79,87,95,103,111,119,127,135,143,151,159,167,175, |
||||||
|
199,207,215,223,231,239,219,135,43,15,23,31,39,47,55,63,71,79,87,95,103,111,119,127,135,143,151,159,167,175,183, |
||||||
|
207,215,223,231,239,219,135,43,15,23,31,39,47,55,63,71,79,87,95,103,111,119,127,135,143,151,159,167,175,183,191, |
||||||
|
215,223,231,239,219,135,43,15,23,31,39,47,55,63,71,79,87,95,103,111,119,127,135,143,151,159,167,175,183,191,199, |
||||||
|
223,231,239,219,135,43,15,23,31,39,47,55,63,71,79,87,95,103,111,119,127,135,143,151,159,167,175,183,191,199,207, |
||||||
|
231,239,219,135,43,15,23,31,39,47,55,63,71,79,87,95,103,111,119,127,135,143,151,159,167,175,183,191,199,207,215, |
||||||
|
239,219,135,43,15,23,31,39,47,55,63,71,79,87,95,103,111,119,127,135,143,151,159,167,175,183,191,199,207,215,223, |
||||||
|
219,135,43,15,23,31,39,47,55,63,71,79,87,95,103,111,119,127,135,143,151,159,167,175,183,191,199,207,215,223,231, |
||||||
|
135,43,15,23,31,39,47,55,63,71,79,87,95,103,111,119,127,135,143,151,159,167,175,183,191,199,207,215,223,231,239,}; |
||||||
|
for(size_t i = 0; i != features.size(); ++i) |
||||||
|
{ |
||||||
|
ASSERT_NEAR(features[i], expectResult[i], 0.0001); |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
void CV_BlockMeanHashTest::testHashMode0() |
||||||
|
{ |
||||||
|
bool const expectResult[] = |
||||||
|
{0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1, |
||||||
|
0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,0, |
||||||
|
0,0,0,0,0,0,1,1,1,1,1,1,1,1,0,0, |
||||||
|
0,0,0,0,0,1,1,1,1,1,1,1,1,0,0,0, |
||||||
|
0,0,0,0,1,1,1,1,1,1,1,1,0,0,0,0, |
||||||
|
0,0,0,1,1,1,1,1,1,1,1,0,0,0,0,0, |
||||||
|
0,0,1,1,1,1,1,1,1,1,0,0,0,0,0,0, |
||||||
|
0,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0, |
||||||
|
1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0, |
||||||
|
1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,1, |
||||||
|
1,1,1,1,1,1,0,0,0,0,0,0,0,0,1,1, |
||||||
|
1,1,1,1,1,0,0,0,0,0,0,0,0,1,1,1, |
||||||
|
1,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1, |
||||||
|
1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1, |
||||||
|
1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,1, |
||||||
|
1,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1, |
||||||
|
}; |
||||||
|
|
||||||
|
for(int i = 0; i != hash.cols; ++i) |
||||||
|
{ |
||||||
|
std::bitset<8> const bits = hash.at<uchar>(0, i); |
||||||
|
for(size_t j = 0; j != bits.size(); ++j) |
||||||
|
{ |
||||||
|
EXPECT_EQ(expectResult[i*8+j], bits[j]); |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
void CV_BlockMeanHashTest::testHashMode1() |
||||||
|
{ |
||||||
|
bool const expectResult[] = |
||||||
|
{0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, |
||||||
|
0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0, |
||||||
|
0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0, |
||||||
|
0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0, |
||||||
|
0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0, |
||||||
|
0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0, |
||||||
|
0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0, |
||||||
|
0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0, |
||||||
|
0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0, |
||||||
|
0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0, |
||||||
|
0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0, |
||||||
|
0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0, |
||||||
|
0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0, |
||||||
|
0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0, |
||||||
|
0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0, |
||||||
|
1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, |
||||||
|
1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, |
||||||
|
1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1, |
||||||
|
1,1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1, |
||||||
|
1,1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1, |
||||||
|
1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1, |
||||||
|
1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1, |
||||||
|
1,1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1, |
||||||
|
1,1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1, |
||||||
|
1,1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1, |
||||||
|
1,1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1, |
||||||
|
1,1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1, |
||||||
|
1,1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1, |
||||||
|
1,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1, |
||||||
|
1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1, |
||||||
|
1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1, |
||||||
|
}; |
||||||
|
|
||||||
|
for(int i = 0; i != hash.cols; ++i) |
||||||
|
{ |
||||||
|
std::bitset<8> const bits = hash.at<uchar>(0, i); |
||||||
|
if(i != hash.cols-1) |
||||||
|
{ |
||||||
|
for(size_t j = 0; j != bits.size(); ++j) |
||||||
|
{ |
||||||
|
EXPECT_EQ(expectResult[i*8+j], bits[j]); |
||||||
|
} |
||||||
|
} |
||||||
|
else |
||||||
|
{ |
||||||
|
//when mode == 1, there will be 961 block mean
|
||||||
|
//that is why we only check one bit at here
|
||||||
|
EXPECT_EQ(expectResult[i*8], bits[0]); |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
void CV_BlockMeanHashTest::run(int) |
||||||
|
{ |
||||||
|
bmh->compute(input, hash); |
||||||
|
testMeanMode0(); |
||||||
|
testHashMode0(); |
||||||
|
|
||||||
|
bmh->setMode(BLOCK_MEAN_HASH_MODE_1); |
||||||
|
bmh->compute(input, hash); |
||||||
|
testMeanMode1(); |
||||||
|
testHashMode1(); |
||||||
|
} |
||||||
|
|
||||||
|
TEST(block_mean_hash_test, accuracy) { CV_BlockMeanHashTest test; test.safe_run(); } |
||||||
@ -0,0 +1,7 @@ |
|||||||
|
// This file is part of OpenCV project.
|
||||||
|
// It is subject to the license terms in the LICENSE file found in the top-level directory
|
||||||
|
// of this distribution and at http://opencv.org/license.html.
|
||||||
|
|
||||||
|
#include "test_precomp.hpp" |
||||||
|
|
||||||
|
CV_TEST_MAIN("cv") |
||||||
@ -0,0 +1,60 @@ |
|||||||
|
// This file is part of OpenCV project.
|
||||||
|
// It is subject to the license terms in the LICENSE file found in the top-level directory
|
||||||
|
// of this distribution and at http://opencv.org/license.html.
|
||||||
|
|
||||||
|
#include "test_precomp.hpp" |
||||||
|
|
||||||
|
using namespace cv; |
||||||
|
|
||||||
|
class CV_MarrHildrethTest : public cvtest::BaseTest |
||||||
|
{ |
||||||
|
public: |
||||||
|
CV_MarrHildrethTest(); |
||||||
|
~CV_MarrHildrethTest(); |
||||||
|
protected: |
||||||
|
void run(int /* idx */); |
||||||
|
}; |
||||||
|
|
||||||
|
CV_MarrHildrethTest::CV_MarrHildrethTest(){} |
||||||
|
CV_MarrHildrethTest::~CV_MarrHildrethTest(){} |
||||||
|
|
||||||
|
void CV_MarrHildrethTest::run(int ) |
||||||
|
{ |
||||||
|
cv::Mat_<uchar> input(512,512); |
||||||
|
int val = 0; |
||||||
|
for(int row = 0; row != input.rows; ++row) |
||||||
|
{ |
||||||
|
for(int col = 0; col != input.cols; ++col) |
||||||
|
{ |
||||||
|
input.at<uchar>(row, col) = val % 256; |
||||||
|
++val; |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
cv::Mat hash; |
||||||
|
cv::img_hash::marrHildrethHash(input, hash); |
||||||
|
uchar const expectResult[] = |
||||||
|
{ |
||||||
|
252, 126, 63, 31, 143, 199, 227, 241, |
||||||
|
248, 252, 126, 63, 31, 143, 199, 227, |
||||||
|
241, 248, 252, 126, 63, 31, 143, 199, |
||||||
|
227, 241, 248, 252, 126, 63, 31, 143, |
||||||
|
199, 227, 241, 248, 31, 143, 199, 227, |
||||||
|
241, 248, 252, 126, 63, 252, 126, 63, |
||||||
|
31, 143, 199, 227, 241, 248, 252, 126, |
||||||
|
63, 31, 143, 199, 227, 241, 248, 252, |
||||||
|
126, 63, 31, 143, 199, 227, 241, 248 |
||||||
|
}; |
||||||
|
uchar const *hashPtr = hash.ptr<uchar>(0); |
||||||
|
for(int i = 0; i != 72; ++i) |
||||||
|
{ |
||||||
|
if(hashPtr[i] != expectResult[i]) |
||||||
|
{ |
||||||
|
ts->printf(cvtest::TS::LOG, "Wrong hash value \n"); |
||||||
|
ts->set_failed_test_info(cvtest::TS::FAIL_INVALID_TEST_DATA); |
||||||
|
return; |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
TEST(marr_hildreth_test, accuracy) { CV_MarrHildrethTest test; test.safe_run(); } |
||||||
@ -0,0 +1,58 @@ |
|||||||
|
// This file is part of OpenCV project.
|
||||||
|
// It is subject to the license terms in the LICENSE file found in the top-level directory
|
||||||
|
// of this distribution and at http://opencv.org/license.html.
|
||||||
|
|
||||||
|
#include "test_precomp.hpp" |
||||||
|
|
||||||
|
#include <bitset> |
||||||
|
|
||||||
|
using namespace cv; |
||||||
|
|
||||||
|
class CV_PHashTest : public cvtest::BaseTest |
||||||
|
{ |
||||||
|
public: |
||||||
|
CV_PHashTest(); |
||||||
|
~CV_PHashTest(); |
||||||
|
protected: |
||||||
|
void run(int /* idx */); |
||||||
|
}; |
||||||
|
|
||||||
|
CV_PHashTest::CV_PHashTest(){} |
||||||
|
CV_PHashTest::~CV_PHashTest(){} |
||||||
|
|
||||||
|
void CV_PHashTest::run(int ) |
||||||
|
{ |
||||||
|
cv::Mat input(32, 32, CV_8U); |
||||||
|
cv::Mat hash; |
||||||
|
|
||||||
|
uchar value = 0; |
||||||
|
uchar *inPtr = input.ptr<uchar>(0); |
||||||
|
for(size_t i = 0; i != 32*32; ++i) |
||||||
|
{ |
||||||
|
inPtr[i] = value++; |
||||||
|
} |
||||||
|
|
||||||
|
cv::img_hash::pHash(input, hash); |
||||||
|
bool const expectResult[] = |
||||||
|
{ |
||||||
|
1,0,1,1,1,1,1,1, |
||||||
|
0,1,1,1,1,1,1,1, |
||||||
|
1,1,1,1,1,1,1,1, |
||||||
|
0,1,1,1,1,1,1,1, |
||||||
|
1,1,1,1,1,1,1,1, |
||||||
|
0,1,1,1,1,1,1,1, |
||||||
|
1,1,1,1,1,1,1,1, |
||||||
|
0,1,1,1,1,1,1,1, |
||||||
|
}; |
||||||
|
uchar const *hashPtr = hash.ptr<uchar>(0); |
||||||
|
for(int i = 0; i != hash.cols; ++i) |
||||||
|
{ |
||||||
|
std::bitset<8> const bits = hashPtr[i]; |
||||||
|
for(int j = 0; j != 8; ++j) |
||||||
|
{ |
||||||
|
EXPECT_EQ(bits[j], expectResult[i*8+j]); |
||||||
|
} |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
TEST(average_phash_test, accuracy) { CV_PHashTest test; test.safe_run(); } |
||||||
@ -0,0 +1,20 @@ |
|||||||
|
#ifdef __GNUC__ |
||||||
|
# pragma GCC diagnostic ignored "-Wmissing-declarations" |
||||||
|
# if defined __clang__ || defined __APPLE__ |
||||||
|
# pragma GCC diagnostic ignored "-Wmissing-prototypes" |
||||||
|
# pragma GCC diagnostic ignored "-Wextra" |
||||||
|
# endif |
||||||
|
#endif |
||||||
|
|
||||||
|
#ifndef __OPENCV_TEST_PRECOMP_HPP__ |
||||||
|
#define __OPENCV_TEST_PRECOMP_HPP__ |
||||||
|
|
||||||
|
#include <iostream> |
||||||
|
#include "opencv2/ts.hpp" |
||||||
|
#include "opencv2/img_hash.hpp" |
||||||
|
#include "opencv2/imgproc.hpp" |
||||||
|
#include "opencv2/core/cvdef.h" |
||||||
|
#include "opencv2/core.hpp" |
||||||
|
#include "opencv2/highgui.hpp" |
||||||
|
|
||||||
|
#endif |
||||||
@ -0,0 +1,150 @@ |
|||||||
|
// This file is part of OpenCV project.
|
||||||
|
// It is subject to the license terms in the LICENSE file found in the top-level directory
|
||||||
|
// of this distribution and at http://opencv.org/license.html.
|
||||||
|
|
||||||
|
#include "test_precomp.hpp" |
||||||
|
|
||||||
|
using namespace cv; |
||||||
|
using namespace cv::img_hash; |
||||||
|
|
||||||
|
|
||||||
|
/**
|
||||||
|
*The expected results of this test case are come from the phash library, |
||||||
|
*I use it as golden model |
||||||
|
*/ |
||||||
|
class CV_RadialVarianceHashTest : public cvtest::BaseTest |
||||||
|
{ |
||||||
|
public: |
||||||
|
CV_RadialVarianceHashTest(); |
||||||
|
protected: |
||||||
|
void run(int /* idx */); |
||||||
|
|
||||||
|
//this test case do not use the original "golden data"
|
||||||
|
//of pHash library, I add a small value to nb_pixels in
|
||||||
|
//the function "ph_feature_vector" to avoid NaN value
|
||||||
|
void testComputeHash(); |
||||||
|
void testFeatures(); |
||||||
|
void testHash(); |
||||||
|
void testPixPerLine(); |
||||||
|
void testProjection(); |
||||||
|
|
||||||
|
cv::Mat input; |
||||||
|
Ptr<cv::img_hash::RadialVarianceHash> rvh; |
||||||
|
}; |
||||||
|
|
||||||
|
CV_RadialVarianceHashTest::CV_RadialVarianceHashTest() |
||||||
|
{ |
||||||
|
input.create(8, 8, CV_8U); |
||||||
|
uchar *inPtr = input.ptr<uchar>(0); |
||||||
|
for(size_t i = 0; i != input.total(); ++i) |
||||||
|
{ |
||||||
|
inPtr[i] = static_cast<uchar>(i); |
||||||
|
} |
||||||
|
rvh = RadialVarianceHash::create(1, 10); |
||||||
|
} |
||||||
|
|
||||||
|
void CV_RadialVarianceHashTest::testComputeHash() |
||||||
|
{ |
||||||
|
cv::Mat hashOne(1, 40, CV_8U); |
||||||
|
uchar buffer[] = |
||||||
|
{ |
||||||
|
52, 41, 49, 64, 40, 67, 76, 71, 69, |
||||||
|
55, 58, 68, 72, 78, 63, 73, 66, 77, |
||||||
|
60, 57, 48, 59, 62, 74, 70, 47, 46, |
||||||
|
51, 45, 44, 42, 61, 54, 75, 50, 79, |
||||||
|
65, 43, 53, 56 |
||||||
|
}; |
||||||
|
cv::Mat hashTwo(1, 40, CV_8U, buffer); |
||||||
|
for(uchar i = 0; i != 40; ++i) |
||||||
|
{ |
||||||
|
hashOne.at<uchar>(0, i) = i; |
||||||
|
} |
||||||
|
|
||||||
|
double const actual = rvh->compare(hashOne, hashTwo); |
||||||
|
ASSERT_NEAR(0.481051, actual, 0.0001); |
||||||
|
} |
||||||
|
|
||||||
|
void CV_RadialVarianceHashTest::testFeatures() |
||||||
|
{ |
||||||
|
std::vector<double> const &features = rvh->getFeatures(); |
||||||
|
double const expectResult[] = |
||||||
|
{-1.35784,-0.42703,0.908487,-1.39327,1.17313, |
||||||
|
1.47515,-0.0156121,0.774335,-0.116755,-1.02059}; |
||||||
|
for(size_t i = 0; i != features.size(); ++i) |
||||||
|
{ |
||||||
|
ASSERT_NEAR(features[i], expectResult[i], 0.0001); |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
void CV_RadialVarianceHashTest::testHash() |
||||||
|
{ |
||||||
|
cv::Mat const hash = rvh->getHash(); |
||||||
|
uchar const expectResult[] = |
||||||
|
{ |
||||||
|
127, 92, 0, 158, 101, |
||||||
|
88, 14, 136, 227, 160, |
||||||
|
127, 94, 27, 118, 240, |
||||||
|
166, 153, 96, 254, 162, |
||||||
|
127, 162, 255, 96, 153, |
||||||
|
166, 240, 118, 27, 94, |
||||||
|
127, 160, 227, 136, 14, |
||||||
|
88, 101, 158, 0, 92 |
||||||
|
}; |
||||||
|
for(int i = 0; i != hash.cols; ++i) |
||||||
|
{ |
||||||
|
EXPECT_EQ(hash.at<uchar>(0, i), expectResult[i]); |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
void CV_RadialVarianceHashTest::testPixPerLine() |
||||||
|
{ |
||||||
|
cv::Mat const pixPerLine = rvh->getPixPerLine(input); |
||||||
|
uchar const expectResult[] = |
||||||
|
{ |
||||||
|
8,8,8,0,8,15,7,5,8,8, |
||||||
|
}; |
||||||
|
bool const equal = |
||||||
|
std::equal(expectResult, expectResult + pixPerLine.total(), |
||||||
|
pixPerLine.ptr<int>(0)); |
||||||
|
if(equal == false) |
||||||
|
{ |
||||||
|
ts->printf(cvtest::TS::LOG, "Wrong pixel per line value \n"); |
||||||
|
ts->set_failed_test_info(cvtest::TS::FAIL_INVALID_TEST_DATA); |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
void CV_RadialVarianceHashTest::testProjection() |
||||||
|
{ |
||||||
|
cv::Mat const proj = rvh->getProjection(); |
||||||
|
uchar const expectResult[] = |
||||||
|
{ |
||||||
|
32, 33, 34, 35, 36, 37, 38, 39, |
||||||
|
16, 17, 18, 27, 36, 37, 46, 47, |
||||||
|
0, 9, 18, 19, 36, 45, 46, 55, |
||||||
|
0, 0, 0, 0, 0, 0, 0, 0, |
||||||
|
2, 10, 18, 27, 36, 44, 53, 61, |
||||||
|
4, 59, 51, 44, 36, 29, 22, 14, |
||||||
|
0, 58, 51, 43, 36, 30, 22, 15, |
||||||
|
0, 0, 58, 43, 36, 21, 6, 0, |
||||||
|
56, 49, 42, 43, 36, 21, 22, 15, |
||||||
|
40, 41, 42, 35, 36, 29, 22, 23 |
||||||
|
}; |
||||||
|
bool const equal = |
||||||
|
std::equal(expectResult, expectResult + proj.total(), |
||||||
|
proj.ptr<uchar>(0)); |
||||||
|
if(equal == false) |
||||||
|
{ |
||||||
|
ts->printf(cvtest::TS::LOG, "Wrong projection value \n"); |
||||||
|
ts->set_failed_test_info(cvtest::TS::FAIL_INVALID_TEST_DATA); |
||||||
|
} |
||||||
|
} |
||||||
|
|
||||||
|
void CV_RadialVarianceHashTest::run(int) |
||||||
|
{ |
||||||
|
testPixPerLine(); |
||||||
|
testProjection(); |
||||||
|
testFeatures(); |
||||||
|
testComputeHash(); |
||||||
|
} |
||||||
|
|
||||||
|
TEST(radial_variance_hash_test, accuracy) { CV_RadialVarianceHashTest test; test.safe_run(); } |
||||||
Loading…
Reference in new issue