The module brings implementations of different image hashing algorithms.#
Detailed Description#
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” [352]
“Looks Like It” lookslikeit
Code Example#
#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;
}
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 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 Speed up image hashing of opencv(img_hash) and introduce color moment hash
Contributors#
Tham Ngap Wei, thamngapwei@gmail.com
Classes#
Name |
Description |
|---|---|
Computes average hash value of the input image. View details |
|
Image hash based on block mean. View details |
|
Image hash based on color moments. View details |
|
The base class for image hash algorithms. View details |
|
Marr-Hildreth Operator Based Hash, slowest but more discriminative. View details |
|
|
pHash View details |
Image hash based on Radon transform. View details |
Enumerations#
Enumeration Type Documentation#
BlockMeanHashMode#
enum cv::img_hash::BlockMeanHashMode
#include <opencv2/img_hash/block_mean_hash.hpp>
Enumerator:
|
use fewer block and generate 16*16/8 uchar hash value |
|
use block blocks(step sizes/2), generate 31*31/8 + 1 uchar hash value |
Function Documentation#
averageHash()#
void cv::img_hash::averageHash(
cv::InputArray inputArr,
cv::OutputArray outputArr )
#include <opencv2/img_hash/average_hash.hpp>
Python:
cv.img_hash.averageHash(inputArr[, outputArr]) -> outputArr
Calculates img_hash::AverageHash in one call.
Parameters
inputArr— input image want to compute hash value, type should be CV_8UC4, CV_8UC3 or CV_8UC1.outputArr— Hash value of input, it will contain 16 hex decimal number, return type is CV_8U
blockMeanHash()#
void cv::img_hash::blockMeanHash(
cv::InputArray inputArr,
cv::OutputArray outputArr,
int mode = BLOCK_MEAN_HASH_MODE_0 )
#include <opencv2/img_hash/block_mean_hash.hpp>
Python:
cv.img_hash.blockMeanHash(inputArr[, outputArr[, mode]]) -> outputArr
Computes block mean hash of the input image.
Parameters
inputArr— input image want to compute hash value, type should be CV_8UC4, CV_8UC3 or CV_8UC1.outputArr— Hash value of input, it will contain 16 hex decimal number, return type is CV_8Umode— the mode
colorMomentHash()#
void cv::img_hash::colorMomentHash(
cv::InputArray inputArr,
cv::OutputArray outputArr )
#include <opencv2/img_hash/color_moment_hash.hpp>
Python:
cv.img_hash.colorMomentHash(inputArr[, outputArr]) -> outputArr
Computes color moment hash of the input, the algorithm is come from the paper “Perceptual Hashing for Color Images Using Invariant Moments”.
Parameters
inputArr— input image want to compute hash value, type should be CV_8UC4, CV_8UC3 or CV_8UC1.outputArr— 42 hash values with type CV_64F(double)
marrHildrethHash()#
void cv::img_hash::marrHildrethHash(
cv::InputArray inputArr,
cv::OutputArray outputArr,
float alpha = 2.0f,
float scale = 1.0f )
#include <opencv2/img_hash/marr_hildreth_hash.hpp>
Python:
cv.img_hash.marrHildrethHash(inputArr[, outputArr[, alpha[, scale]]]) -> outputArr
Computes average hash value of the input image.
Parameters
inputArr— input image want to compute hash value, type should be CV_8UC4, CV_8UC3, CV_8UC1.outputArr— Hash value of input, it will contain 16 hex decimal number, return type is CV_8Ualpha— int scale factor for marr wavelet (default=2).scale— int level of scale factor (default = 1)
pHash()#
void cv::img_hash::pHash(
cv::InputArray inputArr,
cv::OutputArray outputArr )
#include <opencv2/img_hash/phash.hpp>
Python:
cv.img_hash.pHash(inputArr[, outputArr]) -> outputArr
Computes pHash value of the input image.
Parameters
inputArr— input image want to compute hash value, type should be CV_8UC4, CV_8UC3, CV_8UC1.outputArr— Hash value of input, it will contain 8 uchar value
radialVarianceHash()#
void cv::img_hash::radialVarianceHash(
cv::InputArray inputArr,
cv::OutputArray outputArr,
double sigma = 1,
int numOfAngleLine = 180 )
#include <opencv2/img_hash/radial_variance_hash.hpp>
Python:
cv.img_hash.radialVarianceHash(inputArr[, outputArr[, sigma[, numOfAngleLine]]]) -> outputArr
Computes radial variance hash of the input image.
Parameters
inputArr— input image want to compute hash value, type should be CV_8UC4, CV_8UC3, CV_8UC1.outputArr— Hash value of inputsigma— Gaussian kernel standard deviationnumOfAngleLine— The number of angles to consider