You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1650 lines
43 KiB
C++
1650 lines
43 KiB
C++
/*! \file ImageCompareModel.cpp
|
|
|
|
Copyright (C) 2014 Hangzhou Leaper.
|
|
|
|
Created by bang.jin at 2017/02/04.
|
|
|
|
*/
|
|
|
|
#include "ImageCompareModel.h"
|
|
#include "CVUtils.h"
|
|
#include "MultiScaleImageCompareModel.h"
|
|
#include <iostream>
|
|
|
|
//#define DEBUG_VIEW_PLOT
|
|
// #define DEBUG_VIEW_PLOT
|
|
|
|
|
|
#define IMGCMP_STR_NAME "name"
|
|
#define IMGCMP_STR_IMAGE_COMPARE_MODEL "imageCompareModel"
|
|
#define IMGCMP_STR_ALIGN_BASE_IMAGE "alignBaseImage"
|
|
#define IMGCMP_STR_COMPARE_BASE_IMAGE "compareBaseImage"
|
|
#define IMGCMP_STR_WEIGHT_MAT "weightMat"
|
|
#define IMGCMP_STR_MATCH_VAL_SCALE "matchValScale"
|
|
#define IMGCMP_STR_TARGET_MEAN_VAL "targetMeanVal"
|
|
#define IMGCMP_STR_TARGET_STDDEV_VAL "targetStddevVal"
|
|
#define IMGCMP_STR_REPEAT_NUM "repeatNum"
|
|
#define IMGCMP_STR_TRUE_SAMPLE_DIS_MEAN "trueSampleDisMean"
|
|
#define IMGCMP_STR_TRUE_SAMPLE_DIS_STDDEV "trueSampleDisStddev"
|
|
#define IMGCMP_STR_TRUE_SAMPLE_DIS_MIN "trueSampleDisMin"
|
|
#define IMGCMP_STR_TRUE_SAMPLE_DIS_MAX "trueSampleDisMax"
|
|
#define IMGCMP_STR_DIS_THRE "disThre"
|
|
#define IMGCMP_STR_FALSE_SAMPLE_MIN_DIS "falseSampleMinDis"
|
|
#define IMGCMP_STR_TRAIN_DIS "trainDis"
|
|
#define IMGCMP_STR_SMALLEST_MATCH_DIS "falseMinDis"
|
|
#define IMGCMP_STR_AVER_DIAMETER "averageDiameter"
|
|
|
|
#define IMGCMP_CACHE_MAX_SIZE 100
|
|
using namespace std;
|
|
|
|
|
|
// void meanvarnorm(Mat& src, Mat &dst, double avg, double var, Mat mask = Mat())
|
|
// {
|
|
// Scalar m, v;
|
|
// cv::meanStdDev(src, m, v, mask);
|
|
// // (I - m)*var/v + avg = I*var/v - m*var/v + avg
|
|
// double s = var / v.val[0];
|
|
// double t = avg - m.val[0] * var / v.val[0];
|
|
// dst = src * s + t;
|
|
// }
|
|
|
|
float angleNorm(float angle)
|
|
{
|
|
angle = angle - (int)(angle / 360.0) * 360;
|
|
if (angle < 0)
|
|
{
|
|
angle += 360.0;
|
|
}
|
|
return angle;
|
|
}
|
|
float angleDis(float angle0, float angle1)
|
|
{
|
|
angle0 = angleNorm(angle0);
|
|
angle1 = angleNorm(angle1);
|
|
float dis = angle0 - angle1;
|
|
float ldis = dis;
|
|
if (dis < 0)
|
|
{
|
|
ldis = dis + 360;
|
|
}
|
|
else if (dis > 0)
|
|
{
|
|
ldis = dis - 360;
|
|
}
|
|
if (abs(ldis) < abs(dis))
|
|
{
|
|
dis = ldis;
|
|
}
|
|
return dis;
|
|
}
|
|
|
|
cv::Point2f ImageCompareModel::refineCircleCen(const Mat& img, Point2f cen)
|
|
{
|
|
int r = 2;
|
|
vector<double> vec;
|
|
double minDiff = DBL_MAX;
|
|
Point2f bestCenter;
|
|
vector<float> bestDftVec;
|
|
for (float y = cen.y - r; y <= cen.y + r; y += 0.5)
|
|
{
|
|
for (float x = cen.x - r; x <= cen.x + r; x += 0.5)
|
|
{
|
|
std::cout << "newCenter: " << x << "-" << y << ", ";
|
|
|
|
Point2f newCenter(x, y);
|
|
|
|
vector<float> vec;
|
|
selfRotationSimilarityFeature(img, vec, newCenter);
|
|
|
|
vector<float> dftVec;
|
|
dft(vec, dftVec);
|
|
|
|
// CvPlot::plot<float>("refineCenter", &(vec[0]), vec.size());
|
|
|
|
float diffVal = sum<float>(vec.begin(), vec.end());
|
|
|
|
// CvPlot::clear("dft");
|
|
// CvPlot::plot<float>("dft", &(dftVec[0]), 25);
|
|
//
|
|
// float diffVal = dftVec[9];
|
|
|
|
vec.push_back(diffVal);
|
|
|
|
if (minDiff > diffVal)
|
|
{
|
|
minDiff = diffVal;
|
|
bestCenter = newCenter;
|
|
bestDftVec = dftVec;
|
|
}
|
|
|
|
// CvPlot::clear("bestDft");
|
|
// CvPlot::plot<float>("bestDft", &(bestDftVec[0]), 25);
|
|
|
|
std::cout << "diff: " << diffVal << ", "
|
|
" minDiff: " << minDiff << ", "
|
|
" bestCenter: " << bestCenter.x << "-" << bestCenter.y <<
|
|
std::endl;
|
|
}
|
|
}
|
|
|
|
return bestCenter;
|
|
}
|
|
|
|
cv::Mat ImageCompareModel::genWeightImage(const Mat& img, Point2f center,
|
|
float innerR /*= -1*/, float outterR /*= -1*/)
|
|
{
|
|
if (innerR == -1)
|
|
{
|
|
// default is 30
|
|
innerR = img.rows*0.175;
|
|
}
|
|
if (outterR == -1)
|
|
{
|
|
// default is max radius - 10
|
|
outterR = img.rows*0.475;
|
|
}
|
|
|
|
Mat weightImg;
|
|
weightImg.create(img.size(), CV_32FC1);
|
|
weightImg.setTo(0);
|
|
|
|
uchar* pData = weightImg.data;
|
|
for (int y = 0; y < weightImg.rows; y++)
|
|
{
|
|
float* pFData = (float*)weightImg.row(y).data;
|
|
for (int x = 0; x < weightImg.cols; x++)
|
|
{
|
|
float& val = pFData[x];
|
|
float dx = center.x - x;
|
|
float dy = center.y - y;
|
|
float r = sqrt(dx*dx + dy*dy);
|
|
if (r > outterR || r < innerR)
|
|
{
|
|
val = 0;
|
|
}
|
|
else
|
|
{
|
|
val = min(outterR - r, r - innerR);
|
|
}
|
|
}
|
|
}
|
|
|
|
return weightImg;
|
|
}
|
|
|
|
void ImageCompareModel::selfRotationSimilarityFeature(
|
|
const Mat& img, vector<float>& vec, Point2f center /*= Point2f(-1, -1)*/)
|
|
{
|
|
float angleStep = 1.0;
|
|
if (center.x < 0 || center.y < 0)
|
|
{
|
|
center = Point2f(img.cols / 2.0, img.rows / 2.0);
|
|
}
|
|
|
|
double bestVal = DBL_MAX;
|
|
Mat bestRImg;
|
|
Mat fImg;
|
|
img.convertTo(fImg, CV_32FC1);
|
|
|
|
Mat weightImg = genWeightImage(img, center);
|
|
fImg = fImg.mul(weightImg);
|
|
|
|
double sumVal = sum(weightImg).val[0];
|
|
|
|
Mat baseImg;
|
|
{
|
|
Mat t = getRotationMatrix2D(center, 1.0, 1.0);
|
|
Mat rImg;
|
|
warpAffine(fImg, rImg, t, fImg.size(), CV_INTER_CUBIC);
|
|
t = getRotationMatrix2D(center, -1.0, 1.0);
|
|
warpAffine(rImg, baseImg, t, rImg.size(), CV_INTER_CUBIC);
|
|
}
|
|
|
|
#ifdef DEBUG_VIEW_INTERNAL_MAT
|
|
Mat viewBaseImg = baseImg / 255.0/25.0;
|
|
Mat viewfImg = fImg / 255.0/25.0;
|
|
#endif
|
|
|
|
for (float a = 0; a <= 360.0; a += angleStep)
|
|
{
|
|
Mat t = getRotationMatrix2D(center, a, 1.0);
|
|
Mat rImg;
|
|
warpAffine(fImg, rImg, t, fImg.size(), CV_INTER_CUBIC);
|
|
|
|
Mat diffImg = baseImg - rImg;
|
|
//diffImg = diffImg.mul(weightImg);
|
|
double diffVal = norm(diffImg)/sumVal;
|
|
vec.push_back(diffVal);
|
|
}
|
|
}
|
|
|
|
cv::Mat ImageCompareModel::genMask(const Mat& img, Point2f center,
|
|
float innerR /*= -1*/, float outterR /*= -1*/, int type /*= CV_32FC1*/)
|
|
{
|
|
Mat mask(img.size(), CV_8UC1);
|
|
mask.setTo(0);
|
|
if (innerR == -1)
|
|
{
|
|
// default is 30
|
|
innerR = img.rows*0.178;
|
|
}
|
|
if (outterR == -1)
|
|
{
|
|
// default is max radius - 10
|
|
outterR = img.rows*0.425;
|
|
}
|
|
circle(mask, center, outterR, Scalar(255), -1);
|
|
circle(mask, center, innerR, Scalar(0), -1);
|
|
if (type != CV_8UC1)
|
|
{
|
|
converToType(mask, type);
|
|
mask /= 255;
|
|
}
|
|
return mask;
|
|
}
|
|
|
|
void ImageCompareModel::genMask()
|
|
{
|
|
m32fMaskImg = genMask(mAlignBaseImg, Point2f(mAlignBaseImg.cols / 2.0, mAlignBaseImg.rows / 2.0));
|
|
m8uMaskImg = genMask(mAlignBaseImg, Point2f(mAlignBaseImg.cols / 2.0, mAlignBaseImg.rows / 2.0),
|
|
-1.0, -1.0, CV_8UC1);
|
|
}
|
|
|
|
void ImageCompareModel::printInfo()
|
|
{
|
|
std::cout << IMGCMP_STR_IMAGE_COMPARE_MODEL << ": ";
|
|
std::cout << std::endl;
|
|
|
|
printProperty(1, IMGCMP_STR_NAME, mName);
|
|
|
|
printIndent(1);
|
|
std::cout << IMGCMP_STR_ALIGN_BASE_IMAGE << ": ";
|
|
std::cout << std::endl;
|
|
printMatInfo(mAlignBaseImg, 2);
|
|
std::cout << std::endl;
|
|
|
|
printIndent(1);
|
|
std::cout << IMGCMP_STR_WEIGHT_MAT << ": ";
|
|
std::cout << std::endl;
|
|
printMatInfo(mWeightMat, 2);
|
|
std::cout << std::endl;
|
|
|
|
printProperty(1, IMGCMP_STR_MATCH_VAL_SCALE, mMatchValScale);
|
|
printProperty(1, IMGCMP_STR_TARGET_MEAN_VAL, mTargetMeanVal);
|
|
printProperty(1, IMGCMP_STR_TARGET_STDDEV_VAL, mTargetStddevVal);
|
|
printProperty(1, IMGCMP_STR_REPEAT_NUM, mRepeatNum);
|
|
printProperty(1, IMGCMP_STR_DIS_THRE, mDisThre);
|
|
printProperty(1, IMGCMP_STR_TRUE_SAMPLE_DIS_STDDEV, mTrueSampleDisStddev);
|
|
printProperty(1, IMGCMP_STR_TRUE_SAMPLE_DIS_MEAN, mTrueSampleDisMean);
|
|
printProperty(1, IMGCMP_STR_TRUE_SAMPLE_DIS_MAX, mTrueSampleDisMax);
|
|
printProperty(1, IMGCMP_STR_TRUE_SAMPLE_DIS_MIN, mTrueSampleDisMin);
|
|
|
|
printProperty(1, "filePath", mFilePath);
|
|
printProperty(1, "isEnableCache", mIsEnableCache);
|
|
}
|
|
|
|
void ImageCompareModel::saveImages(string dirPath)
|
|
{
|
|
imwrite(dirPath + "/base.png", mAlignBaseImg);
|
|
imwrite(dirPath + "/weight.png", mWeightMat);
|
|
}
|
|
|
|
bool ImageCompareModel::save2file(string filePath)
|
|
{
|
|
FileStorage fs(filePath, FileStorage::WRITE);
|
|
if (!fs.isOpened())
|
|
{
|
|
return false;
|
|
}
|
|
|
|
fs << IMGCMP_STR_NAME << mName <<
|
|
IMGCMP_STR_ALIGN_BASE_IMAGE << mAlignBaseImg <<
|
|
IMGCMP_STR_COMPARE_BASE_IMAGE << mCompareBaseImg <<
|
|
IMGCMP_STR_WEIGHT_MAT << mWeightMat <<
|
|
IMGCMP_STR_MATCH_VAL_SCALE << mMatchValScale <<
|
|
IMGCMP_STR_TARGET_MEAN_VAL << mTargetMeanVal <<
|
|
IMGCMP_STR_TARGET_STDDEV_VAL << mTargetStddevVal <<
|
|
IMGCMP_STR_REPEAT_NUM << mRepeatNum <<
|
|
IMGCMP_STR_TRUE_SAMPLE_DIS_MEAN << mTrueSampleDisMean <<
|
|
IMGCMP_STR_TRUE_SAMPLE_DIS_STDDEV << mTrueSampleDisStddev <<
|
|
IMGCMP_STR_TRUE_SAMPLE_DIS_MIN << mTrueSampleDisMin <<
|
|
IMGCMP_STR_TRUE_SAMPLE_DIS_MAX << mTrueSampleDisMax <<
|
|
IMGCMP_STR_FALSE_SAMPLE_MIN_DIS << getFalseSampleMinDis() <<
|
|
IMGCMP_STR_DIS_THRE << mDisThre <<
|
|
IMGCMP_STR_TRAIN_DIS <<mDisMat <<
|
|
IMGCMP_STR_AVER_DIAMETER << meanDiameter;
|
|
|
|
setFilePath(filePath);
|
|
|
|
return true;
|
|
}
|
|
|
|
bool ImageCompareModel::readFromFile(string filePath)
|
|
{
|
|
FileStorage fs(filePath, FileStorage::READ);
|
|
if (!fs.isOpened())
|
|
{
|
|
return false;
|
|
}
|
|
|
|
fs[IMGCMP_STR_ALIGN_BASE_IMAGE] >> mAlignBaseImg;
|
|
fs[IMGCMP_STR_COMPARE_BASE_IMAGE] >> mCompareBaseImg;
|
|
fs[IMGCMP_STR_WEIGHT_MAT] >> mWeightMat;
|
|
mMatchValScale = (double)fs[IMGCMP_STR_MATCH_VAL_SCALE];
|
|
|
|
FileNode fn = fs[IMGCMP_STR_TARGET_MEAN_VAL];
|
|
if (!fn.empty())
|
|
{
|
|
mTargetMeanVal = (int)fn;
|
|
}
|
|
|
|
fn = fs[IMGCMP_STR_TARGET_STDDEV_VAL];
|
|
if (!fn.empty())
|
|
{
|
|
mTargetStddevVal = (int)fn;
|
|
}
|
|
|
|
fn = fs[IMGCMP_STR_REPEAT_NUM];
|
|
if (!fn.empty())
|
|
{
|
|
mRepeatNum = (int)fn;
|
|
}
|
|
else
|
|
{
|
|
//mRepeatNum = computeRepeatNum();
|
|
}
|
|
|
|
fn = fs[IMGCMP_STR_NAME];
|
|
if (!fn.empty())
|
|
{
|
|
mName = (string)fn;
|
|
}
|
|
|
|
fn = fs[IMGCMP_STR_TRUE_SAMPLE_DIS_MEAN];
|
|
if (!fn.empty())
|
|
{
|
|
mTrueSampleDisMean = (double)fn;
|
|
}
|
|
fn = fs[IMGCMP_STR_TRUE_SAMPLE_DIS_STDDEV];
|
|
if (!fn.empty())
|
|
{
|
|
mTrueSampleDisStddev = (double)fn;
|
|
}
|
|
fn = fs[IMGCMP_STR_TRUE_SAMPLE_DIS_MIN];
|
|
if (!fn.empty())
|
|
{
|
|
mTrueSampleDisMin = (double)fn;
|
|
}
|
|
fn = fs[IMGCMP_STR_TRUE_SAMPLE_DIS_MAX];
|
|
if (!fn.empty())
|
|
{
|
|
mTrueSampleDisMax = (double)fn;
|
|
}
|
|
fn = fs[IMGCMP_STR_FALSE_SAMPLE_MIN_DIS];
|
|
if (!fn.empty())
|
|
{
|
|
setFalseSampleMinDis((double)fn);
|
|
}
|
|
fn = fs[IMGCMP_STR_DIS_THRE];
|
|
if (!fn.empty())
|
|
{
|
|
mDisThre = (double)fn;
|
|
}
|
|
|
|
fn = fs[IMGCMP_STR_AVER_DIAMETER];
|
|
if (!fn.empty())
|
|
{
|
|
meanDiameter = (int)fn;
|
|
}
|
|
|
|
|
|
setFilePath(filePath);
|
|
|
|
genMask();
|
|
|
|
return true;
|
|
}
|
|
|
|
void ImageCompareModel::preProcessImage(Mat& img) const
|
|
{
|
|
preProcessImage(img, m8uMaskImg, mTargetMeanVal, mTargetStddevVal, mHighlightsThreshold);
|
|
}
|
|
|
|
void ImageCompareModel::preProcessImage(Mat& img, const Mat& mask, double tarMean,
|
|
double tarStddev, int highlightsThreshold) const
|
|
{
|
|
if (img.channels() > 1)
|
|
{
|
|
img = getFirstChannel(img);
|
|
}
|
|
if (img.type() != CV_32FC1)
|
|
{
|
|
converToType(img, CV_32FC1);
|
|
}
|
|
|
|
Mat gaussImg;
|
|
GaussianBlur(img, gaussImg, Size(3, 3), 5.0);
|
|
img = gaussImg;
|
|
|
|
Mat dilatedMask;
|
|
dilate(mask, dilatedMask, Mat::ones(Size(3, 3), CV_32FC1));
|
|
|
|
Mat hightlightsMask = img < highlightsThreshold;
|
|
Mat imgMask = hightlightsMask & dilatedMask;
|
|
|
|
Scalar meanScalar, stddevScalar;
|
|
meanStdDev(img, meanScalar, stddevScalar, imgMask);
|
|
img = (img - meanScalar.val[0]) * tarStddev / stddevScalar.val[0] + tarMean;
|
|
|
|
converToType(imgMask, CV_32FC1);
|
|
imgMask /= 255.0;
|
|
Mat imgNorm = cocentricNorm(img, Point2f(img.cols / 2.0, img.rows / 2.0),
|
|
imgMask, 125);
|
|
#ifdef DEBUG_VIEW_INTERNAL_MAT
|
|
Mat vImgNorm = imgNorm / 255.0;
|
|
#endif
|
|
img = imgNorm;
|
|
}
|
|
|
|
void ImageCompareModel::preProcessImage(Mat& img, const Mat& mask,
|
|
const Mat& weightMat, double dstMean, double dstStddev, int highlightsThreshold) const
|
|
{
|
|
if (img.channels() > 1)
|
|
{
|
|
img = getFirstChannel(img);
|
|
}
|
|
if (img.type() != CV_32FC1)
|
|
{
|
|
converToType(img, CV_32FC1);
|
|
}
|
|
|
|
Mat gaussImg;
|
|
GaussianBlur(img, gaussImg, Size(3, 3), 5.0);
|
|
img = gaussImg;
|
|
|
|
Mat hightlightsMask = img < highlightsThreshold;
|
|
Mat imgMask = hightlightsMask & mask & (weightMat > 0);
|
|
|
|
Scalar meanScalar, stddevScalar;
|
|
meanStdDev(img, meanScalar, stddevScalar, imgMask);
|
|
img = (img - meanScalar.val[0]) * dstMean / stddevScalar.val[0] + dstMean;
|
|
|
|
converToType(hightlightsMask, CV_32FC1);
|
|
|
|
Mat imgNorm = cocentricNorm(img, Point2f(img.cols / 2.0, img.rows / 2.0),
|
|
weightMat.mul(hightlightsMask), 125);
|
|
#ifdef DEBUG_VIEW_INTERNAL_MAT
|
|
Mat vImgNorm = imgNorm / 255.0;
|
|
#endif
|
|
img = imgNorm;
|
|
}
|
|
|
|
void ImageCompareModel::preProcessImage0(Mat& img) const
|
|
{
|
|
|
|
}
|
|
|
|
double ImageCompareModel::compare(Mat img0, Mat img1, Mat* pRImg0, Mat* pRImg1)
|
|
{
|
|
if (img0.size() != img1.size() && img0.size() != mAlignBaseImg.size())
|
|
{
|
|
return -1;
|
|
}
|
|
|
|
double bestMatchVal = DBL_MAX;
|
|
int bestAngle = -1;
|
|
Mat bestImg1;
|
|
double bestDD = 0;
|
|
|
|
double w = 0;
|
|
|
|
Point2f center((float)img1.cols / 2.0, (float)img1.rows / 2.0);
|
|
Mat rImg0 = rotateMatch(img0).mBestRImg;
|
|
Mat rImg1 = rotateMatch(img1).mBestRImg;
|
|
Mat dMat = rImg0 - rImg1;
|
|
converToType(dMat, CV_32FC1);
|
|
dMat = dMat.mul(mWeightMat);
|
|
|
|
if (pRImg0)
|
|
{
|
|
*pRImg0 = rImg0;
|
|
}
|
|
if (pRImg1)
|
|
{
|
|
*pRImg1 = rImg1;
|
|
}
|
|
|
|
return genMatchValue(dMat);
|
|
}
|
|
|
|
double ImageCompareModel::compare(Mat img, Mat* pRImg /*= NULL*/, int levelNum /*= 1*/,
|
|
bool isFilterSize /*= true*/, int flag, double md_diameter, double md_height)
|
|
{
|
|
if (mIsEnableCache)
|
|
{
|
|
auto cacheIter = mDisCache.find(img.data);
|
|
if (cacheIter != mDisCache.end())
|
|
{
|
|
return cacheIter->second;
|
|
}
|
|
}
|
|
Mat rawImg = img.clone();
|
|
int nRadiusDiff = 15;
|
|
if (mAlignBaseImg.size() != img.size())
|
|
{
|
|
if (isFilterSize && abs(mAlignBaseImg.size().width- img.size().width) > nRadiusDiff)
|
|
{
|
|
return DBL_MAX;
|
|
}
|
|
resize(img, img, mAlignBaseImg.size());
|
|
}
|
|
|
|
Mat matchImg = img.clone();
|
|
preProcessImage(matchImg);
|
|
|
|
if (!mpMultiScaleModel)
|
|
{
|
|
initMultiScaleModel();
|
|
}
|
|
RotateMatchResult rmr = rotateMatch(matchImg, levelNum);
|
|
Mat rImg = rmr.mBestRImg;
|
|
|
|
if (rImg.empty())
|
|
{
|
|
return DBL_MAX;
|
|
}
|
|
|
|
#ifdef DEBUG_VIEW_INTERNAL_MAT
|
|
Mat vRImg = rImg / 255.0;
|
|
#endif
|
|
|
|
double bestAngle = rmr.mBestAngle;
|
|
Mat cmpImg = rotateImage(img, Point2f(img.cols / 2.0, img.rows / 2.0),
|
|
bestAngle);
|
|
|
|
// remove highlights
|
|
Mat hightlightsMask = cmpImg < mHighlightsThreshold;
|
|
converToType(hightlightsMask, CV_32FC1);
|
|
hightlightsMask /= 255.0;
|
|
|
|
Mat unifiedMask = m32fMaskImg.mul(hightlightsMask).mul(mWeightMat);
|
|
|
|
preProcessImage(cmpImg, m8uMaskImg, mWeightMat, mTargetMeanVal,
|
|
mTargetStddevVal, mHighlightsThreshold);
|
|
|
|
cmpImg.setTo(0, cmpImg < 0);
|
|
converToType(cmpImg, CV_32FC1);
|
|
normSectors_tarImg(cmpImg, unifiedMask, imgCen(cmpImg), 1,
|
|
mCompareBaseImg);
|
|
|
|
#ifdef DEBUG_VIEW_INTERNAL_MAT
|
|
Mat vRotatedImg0 = cmpImg / 255.0;
|
|
#endif
|
|
|
|
#ifdef DEBUG_VIEW_INTERNAL_MAT
|
|
Mat vRotatedImg1 = cmpImg / 255.0;
|
|
#endif
|
|
|
|
cmpImg.setTo(0, cmpImg < 10);
|
|
if (pRImg)
|
|
{
|
|
*pRImg = cmpImg;
|
|
}
|
|
|
|
double ret = genMatchValue(cmpImg, mCompareBaseImg, unifiedMask, flag, rawImg.rows, md_diameter, md_height);
|
|
|
|
/*if (flag == 1)
|
|
{
|
|
double matchedVal = ret;
|
|
ret = penltyCoeff(matchedVal, meanDiameter, rawImg.rows);
|
|
printf("the matched value %f", ret);
|
|
}*/
|
|
|
|
if (mIsEnableCache)
|
|
{
|
|
mDisCache[img.data] = ret;
|
|
if (mDisCache.size() > IMGCMP_CACHE_MAX_SIZE)
|
|
{
|
|
mDisCache.clear();
|
|
}
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
|
|
|
|
void ImageCompareModel::train(const vector<Mat>& imgVec)
|
|
{
|
|
#ifdef _DEBUG
|
|
cout << getName() << endl;
|
|
#endif _DEBUG
|
|
if (0 == imgVec.size()) {
|
|
return;
|
|
}
|
|
mAlignBaseImg = imgVec.front();
|
|
genMask();
|
|
preProcessImage(mAlignBaseImg);
|
|
Mat sumMat = Mat::zeros(mAlignBaseImg.size(), CV_32FC1);
|
|
Mat minMat(mAlignBaseImg.size(), mAlignBaseImg.type());
|
|
minMat.setTo(FLT_MAX);
|
|
vector<Mat> rImgVec;
|
|
vector<RotateMatchResult> rmrVec;
|
|
vector<Mat> resizedImgVec;
|
|
vector<int> diametersVec;
|
|
for (int i = 0; i < imgVec.size(); ++i)
|
|
{
|
|
diametersVec.push_back(imgVec[i].rows);
|
|
Mat img = imgVec[i].clone();
|
|
if (img.size() != mAlignBaseImg.size())
|
|
{
|
|
Mat resizedImg;
|
|
resize(img, resizedImg, mAlignBaseImg.size());
|
|
img = resizedImg;
|
|
}
|
|
resizedImgVec.push_back(img);
|
|
preProcessImage(img);
|
|
|
|
RotateMatchResult rmr = rotateMatch(img);
|
|
rmrVec.push_back(rmr);
|
|
|
|
Mat rImg = rmr.mBestRImg;
|
|
rImgVec.push_back(rImg);
|
|
minMat = min(minMat, rImg);
|
|
sumMat += rImg;
|
|
|
|
#ifdef DEBUG_VIEW_INTERNAL_MAT
|
|
Mat viewRImg = rImg / 255.0;
|
|
Mat viewMinMat = minMat / 255.0;
|
|
#endif
|
|
}
|
|
meanDiameter = mean(diametersVec)[0];
|
|
|
|
Mat avgMat = sumMat / imgVec.size();
|
|
mAlignBaseImg = avgMat;
|
|
#ifdef DEBUG_VIEW_INTERNAL_MAT
|
|
Mat vAvgMat = avgMat / 255.0;
|
|
#endif
|
|
mWeightMat = minMat;
|
|
|
|
mWeightMat /= 255.0;
|
|
/*luffy_base::luffy_imageProc::*/meanvarnorm(mWeightMat, mWeightMat,
|
|
mTargetMeanVal, 150, m8uMaskImg);
|
|
mWeightMat.setTo(0, mWeightMat < 10);
|
|
{
|
|
if(mRepeatNum <= 0)
|
|
{
|
|
mRepeatNum = computeRepeatNum();
|
|
}
|
|
selfRotateMin(mWeightMat, mWeightMat, mRepeatNum);
|
|
}
|
|
|
|
#ifdef DEBUG_VIEW_INTERNAL_MAT
|
|
Mat vWeightMat = mWeightMat / 255.0;
|
|
Mat vBaseMat = mAlignBaseImg / 255.0;
|
|
Mat vMinMat = minMat / 255.0;
|
|
#endif
|
|
|
|
sumMat.setTo(0);
|
|
for (int i = 0; i < rmrVec.size(); ++i)
|
|
{
|
|
double bestAngle = rmrVec[i].mBestAngle;
|
|
Mat img = resizedImgVec[i];
|
|
Mat rotatedImg = rotateImage(img, Point2f(img.cols/2.0, img.rows/2.0),
|
|
bestAngle);
|
|
preProcessImage(rotatedImg, m8uMaskImg, mWeightMat, mTargetMeanVal,
|
|
mTargetStddevVal, mHighlightsThreshold);
|
|
|
|
sumMat += rotatedImg;
|
|
}
|
|
mCompareBaseImg = sumMat / resizedImgVec.size();
|
|
|
|
#ifdef DEBUG_VIEW_INTERNAL_MAT
|
|
Mat vCompareBaseImg = mCompareBaseImg / 255.0;
|
|
vWeightMat = mWeightMat / 255.0;
|
|
#endif
|
|
|
|
trueSampleWeightRecon(resizedImgVec, rmrVec);
|
|
mWeightMat = falseReConMat.clone();
|
|
}
|
|
|
|
void ImageCompareModel::trueSampleWeightRecon(const vector<Mat>& resizedVec, vector<RotateMatchResult> rmrVec)
|
|
{
|
|
falseReConMat = mWeightMat.clone();
|
|
for (int i = 0; i < resizedVec.size(); i++)
|
|
{
|
|
const Mat &img = resizedVec[i];
|
|
double bestAngle = rmrVec[i].mBestAngle;
|
|
Mat processedImg = img.clone();
|
|
preProcessImage(processedImg);
|
|
Mat rotatedImg = rotateImage(processedImg, Point2f(img.cols / 2.0, img.rows / 2.0),
|
|
bestAngle);
|
|
|
|
Mat hightlightsMask = rotatedImg < mHighlightsThreshold;
|
|
converToType(hightlightsMask, CV_32FC1);
|
|
hightlightsMask /= 255.0;
|
|
|
|
Mat unifiedMask = m32fMaskImg.mul(hightlightsMask).mul(mWeightMat);
|
|
|
|
preProcessImage(rotatedImg, m8uMaskImg, mWeightMat, mTargetMeanVal,
|
|
mTargetStddevVal, mHighlightsThreshold);
|
|
|
|
rotatedImg.setTo(0, rotatedImg < 0);
|
|
converToType(rotatedImg, CV_32FC1);
|
|
normSectors_tarImg(rotatedImg, unifiedMask, imgCen(rotatedImg), 1,
|
|
mCompareBaseImg);
|
|
|
|
Mat vRotatedImg0 = rotatedImg / 255.0;
|
|
|
|
#ifdef DEBUG_VIEW_INTERNAL_MAT
|
|
Mat vRotatedImg1 = rotatedImg / 255.0;
|
|
#endif
|
|
|
|
rotatedImg.setTo(0, rotatedImg < 10);
|
|
trueWeightRecon(rotatedImg, mCompareBaseImg);
|
|
}
|
|
}
|
|
|
|
void ImageCompareModel::trueWeightRecon(const Mat& rImg, const Mat& baseImg)
|
|
{
|
|
Mat dMat = abs(rImg - baseImg);
|
|
//Mat norImg = Mat::ones(dMat.size(), dMat.type()) * 255;
|
|
//dMat = max(dMat, 254);
|
|
Mat mData;
|
|
dMat.copyTo(mData, dMat > 1000);
|
|
mData = minMaxNorm(mData, 0, 255);
|
|
//mData.copyTo(mData, mData > 0.9);
|
|
double minVal, maxVal;
|
|
minMaxIdx(mData, &minVal, &maxVal);
|
|
weightMapping(mData, maxVal);
|
|
}
|
|
|
|
void ImageCompareModel::weightMapping(const Mat& mData, double maxVal)
|
|
{
|
|
for (int i = 0; i < mData.rows; i++)
|
|
{
|
|
float* pData = (float*)mData.row(i).data;
|
|
float*pWeight = (float*)falseReConMat.row(i).data;
|
|
for (int j = 0; j < mData.cols; j++)
|
|
{
|
|
double pixVal = pData[j];
|
|
|
|
if (pixVal != 0)
|
|
{
|
|
double affineCoeff = descendFunction(pixVal, maxVal);
|
|
pWeight[j] *= affineCoeff;
|
|
}
|
|
|
|
}
|
|
}
|
|
}
|
|
double ImageCompareModel::descendFunction(double pixVal, double maxVal)
|
|
{
|
|
return (-1.0 / maxVal)*pixVal + 1.0;
|
|
//return -1 * pow(pixVal, 2) + 1;
|
|
}
|
|
|
|
|
|
void ImageCompareModel::calculateAllParams(const vector<Mat>& imgVec)
|
|
{
|
|
mDisThre = DBL_MAX;
|
|
Mat disMat(1, imgVec.size(), CV_64FC1);
|
|
for (int i = 0; i < imgVec.size(); ++i)
|
|
{
|
|
const Mat& img = imgVec[i];
|
|
double dis = compare(img, NULL, 1, false, 0);
|
|
disMat.at<double>(i) = dis;
|
|
//disMat.copyTo(mDisMat);
|
|
}
|
|
|
|
if (disMat.cols == 1)
|
|
{
|
|
mTrueSampleDisStddev = 0;
|
|
mTrueSampleDisMean = disMat.at<double>(0);
|
|
}
|
|
else
|
|
{
|
|
Scalar m, s;
|
|
meanStdDev(disMat, m, s);
|
|
mTrueSampleDisStddev = s.val[0];
|
|
mTrueSampleDisMean = m.val[0];
|
|
}
|
|
disMat.copyTo(mDisMat);
|
|
minMaxIdx(disMat, &mTrueSampleDisMin, &mTrueSampleDisMax);
|
|
}
|
|
|
|
void ImageCompareModel::computeDisThre(const vector<Mat>& imgVec, double* pMinDis, double md_diameter, double md_height)
|
|
{
|
|
if (imgVec.empty())
|
|
{
|
|
return;
|
|
}
|
|
mDisThre = DBL_MAX;
|
|
vector<double> disVec;
|
|
for_each(imgVec.begin(), imgVec.end(), [&](Mat img)
|
|
{
|
|
double dis = compare(img, NULL, 3, false, 1, md_diameter, md_height);
|
|
disVec.push_back(dis);
|
|
});
|
|
double minDis = *(min_element(disVec.begin(), disVec.end()));
|
|
setFalseSampleMinDis(minDis);
|
|
|
|
if (pMinDis)
|
|
{
|
|
*pMinDis = minDis;
|
|
}
|
|
if (minDis > mTrueSampleDisMax)
|
|
{
|
|
mDisThre = mTrueSampleDisMax*0.2 + minDis*0.8;
|
|
//mDisThre = mTrueSampleDisMax*0.15 + minDis*0.85 + mTrueSampleDisStddev;
|
|
//mDisThre = minDis;
|
|
if (mDisThre > mTrueSampleDisMax*1.8)
|
|
{
|
|
mDisThre = mTrueSampleDisMax*1.8;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
mDisThre = DBL_MAX;
|
|
std::cout << "max distance in training > min distance in testing" << std::endl;
|
|
}
|
|
}
|
|
|
|
void ImageCompareModel::genUniformSepIdx(int num, int startIdx, int endIdx, vector<int>& cenVec)
|
|
{
|
|
float step = (endIdx - startIdx) / (num);
|
|
for (int i = 0; i < num; i++)
|
|
{
|
|
cenVec.push_back(floorf(step*i + startIdx));
|
|
}
|
|
}
|
|
|
|
void ImageCompareModel::genAngleRanges(vector<int> cenVec, vector<Range>& rangeVec, int localRange)
|
|
{
|
|
rangeVec.clear();
|
|
for_each(cenVec.begin(), cenVec.end(), [&](int cen)
|
|
{
|
|
Range r;
|
|
r.start = cen - localRange;
|
|
r.end = cen + localRange + 1;
|
|
rangeVec.push_back(r);
|
|
});
|
|
}
|
|
|
|
void ImageCompareModel::genCandidateAngleRanges(vector<float> disVec,
|
|
float angleStep, vector<Range>& rangeVec)
|
|
{
|
|
auto minDisIter = min_element(disVec.begin(), disVec.end());
|
|
int startIdx = minDisIter - disVec.begin();
|
|
|
|
rotate(disVec.begin(), minDisIter, disVec.end());
|
|
|
|
Mat disVecMat(1, disVec.size(), CV_32FC1, &(disVec[0]));
|
|
Mat normDisVecMat;
|
|
/*luffy_base::luffy_imageProc::*/meanvarnorm(disVecMat, normDisVecMat, 0, 1.0);
|
|
|
|
set<unsigned int> canNums;
|
|
genCandidateRepeatNums(canNums);
|
|
vector<int> cenVec;
|
|
int repeatNum = recognizeLowerExtremes(normDisVecMat, canNums, 5, &cenVec);
|
|
#ifdef _TEST
|
|
if (repeatNum <= 0)
|
|
{
|
|
std::cout << "repeatNum < 0" << std::endl;
|
|
//waitKey();
|
|
}
|
|
#endif
|
|
if (repeatNum < 0)
|
|
{
|
|
rangeVec.clear();
|
|
return;
|
|
cenVec.clear();
|
|
cenVec.push_back(disVec.size() / 2);
|
|
genAngleRanges(cenVec, rangeVec, disVec.size() / 2);
|
|
}
|
|
else
|
|
{
|
|
if (cenVec.size() >= 2 && angleDis(cenVec.front(), cenVec.back()) < 2)
|
|
{
|
|
cenVec.pop_back();
|
|
}
|
|
|
|
for_each(cenVec.begin(), cenVec.end(), [&](int& cen)
|
|
{
|
|
cen += startIdx;
|
|
cen *= angleStep;
|
|
cen = angleNorm(cen);
|
|
});
|
|
for (auto i = cenVec.begin(); i != cenVec.end(); ++i)
|
|
{
|
|
if (*i < startIdx*angleStep)
|
|
{
|
|
rotate(cenVec.begin(), i, cenVec.end());
|
|
break;
|
|
}
|
|
}
|
|
#ifdef _TEST
|
|
for (int i = 0; i < cenVec.size() - 1; ++i)
|
|
{
|
|
float curVal = cenVec[i];
|
|
float nxtVal = cenVec[i + 1];
|
|
if (nxtVal <= curVal)
|
|
{
|
|
std::cout << "assert nxtVal <= curVal failed" << std::endl;
|
|
waitKey();
|
|
}
|
|
}
|
|
#endif
|
|
genAngleRanges(cenVec, rangeVec, 10);
|
|
}
|
|
|
|
}
|
|
|
|
void ImageCompareModel::genCandidateAngleRanges(const Mat& disMat,
|
|
float angleStep, vector<Range>& rangeVec, float rangeScale /*= 1*/)
|
|
{
|
|
for (int i = 0; i < disMat.rows; ++i)
|
|
{
|
|
Mat disVec = disMat.row(i);
|
|
double minVal, maxVal;
|
|
Point minPt, maxPt;
|
|
minMaxLoc(disVec, &minVal, &maxVal, &minPt, &maxPt);
|
|
Range &r = rangeVec[i];
|
|
float cenAngle = r.start + angleStep*minPt.x;
|
|
float angleRangeWidth = r.end - r.start;
|
|
|
|
r.start = floorf(cenAngle - angleRangeWidth * 0.5 * rangeScale);
|
|
r.end = floorf(cenAngle + angleRangeWidth * 0.5 * rangeScale);
|
|
}
|
|
}
|
|
|
|
void ImageCompareModel::selfRotateMin(const Mat& img, Mat& weightMat, int repeatNum)
|
|
{
|
|
Point2f cen(img.cols / 2.0, img.rows / 2.0);
|
|
float angleStep = 360.0 / repeatNum;
|
|
Mat dSumMat = Mat::ones(img.size(), img.type())*255;
|
|
for (int i = 1; i < repeatNum; ++i)
|
|
{
|
|
Mat rotatedImg = rotateImage(img, cen, i*angleStep);
|
|
Mat dilatedImg;
|
|
dilate(rotatedImg, dilatedImg, Mat::ones(3, 3, CV_32FC1));
|
|
dSumMat = min(dSumMat, dilatedImg);
|
|
}
|
|
weightMat = dSumMat;
|
|
}
|
|
|
|
double ImageCompareModel::genMatchValue(const Mat& dMat) const
|
|
{
|
|
double v = norm(dMat, NORM_L2);
|
|
|
|
double ret = scaleMatchValue(v);
|
|
|
|
return ret;
|
|
}
|
|
|
|
double ImageCompareModel::genMatchValue(const Mat& rImg, const Mat& baseImg,
|
|
const Mat& maskImg, int flag, int diameter, double md_diameter, double md_height) const
|
|
{
|
|
Mat dMat = rImg - baseImg;
|
|
dMat = abs(dMat.mul(maskImg));
|
|
|
|
#ifdef DEBUG_VIEW_INTERNAL_MAT
|
|
Mat vRImg = rImg / 255.0;
|
|
Mat vDMat0 = abs(dMat) / 255.0;
|
|
Mat vBase = baseImg / 255.0;
|
|
Mat vDMat = abs(dMat) / 255.0 / 255.0;
|
|
Mat vMask = maskImg / 255.0;
|
|
#endif
|
|
|
|
Mat minmaxScaleMat = minMaxNorm(dMat, 0, 255, m8uMaskImg);
|
|
converToType(minmaxScaleMat, CV_8UC1);
|
|
Mat mMask = lowerMajorityMask(minmaxScaleMat, m8uMaskImg, 0.97);
|
|
converToType(mMask, CV_32FC1);
|
|
mMask /= 255.0;
|
|
|
|
dMat = dMat.mul(mMask);
|
|
|
|
#ifdef DEBUG_VIEW_INTERNAL_MAT
|
|
Mat vDMat1 = abs(dMat) / 255.0 / 255.0;
|
|
#endif
|
|
|
|
double s = sum(mMask.mul(maskImg)).val[0];
|
|
|
|
double ret = genMatchValue(dMat) / s;
|
|
|
|
if (flag == 1)
|
|
{
|
|
double matchedVal = ret;
|
|
ret = penltyCoeff(matchedVal, meanDiameter, diameter, md_diameter, md_height);
|
|
printf("the matched value %f", ret);
|
|
}
|
|
|
|
if (ret > mDisThre)
|
|
{
|
|
return DBL_MAX;
|
|
}
|
|
else
|
|
{
|
|
return ret;
|
|
}
|
|
}
|
|
|
|
double ImageCompareModel::scaleMatchValue(double val) const
|
|
{
|
|
return val*mMatchValScale;
|
|
}
|
|
|
|
|
|
ImageCompareModel* ImageCompareModel::scale(float s)
|
|
{
|
|
Mat baseImage;
|
|
resize(mAlignBaseImg, baseImage, Size(), s, s, INTER_CUBIC);
|
|
Mat weightMat;
|
|
resize(mWeightMat, weightMat, Size(), s, s, INTER_CUBIC);
|
|
|
|
ImageCompareModel* pRet = new ImageCompareModel;
|
|
*pRet = *this;
|
|
pRet->setBaseImg(baseImage);
|
|
pRet->setWeightMat(weightMat);
|
|
|
|
pRet->genMask();
|
|
|
|
// Mat mask8uImg;
|
|
// resize(m8uMaskImg, mask8uImg, Size(), s, s, INTER_NEAREST);
|
|
// Mat mask32fImg;
|
|
// resize(m32fMaskImg, mask32fImg, Size(), s, s, INTER_NEAREST);
|
|
//
|
|
// pRet->set8uMaskImg(mask8uImg);
|
|
// pRet->set32fMaskImg(mask32fImg);
|
|
|
|
return pRet;
|
|
}
|
|
|
|
ImageCompareModel::RotateMatchResult ImageCompareModel::rotateMatch(const Mat& img, int levelNum /*= 1*/, float angleStep /*= 1.0*/,
|
|
float startAngle /*= 0*/, float endAngle /*= 360*/) const
|
|
{
|
|
#ifdef _TEST
|
|
static int idx = 0;
|
|
std::cout << idx << " ";
|
|
#endif
|
|
RotateData* pData = new RotateData;
|
|
vector<Range> angleRangeVec;
|
|
if (levelNum > 1)
|
|
{
|
|
MultiScaleImage msi;
|
|
msi.setLevelNum(3);
|
|
msi.setBaseLevel(img);
|
|
msi.genMultiScale();
|
|
ImageCompareData imgCmpData(&msi);
|
|
imgCmpData.setStartAngle(startAngle);
|
|
imgCmpData.setEndAngle(endAngle);
|
|
|
|
mpMultiScaleModel->proc(&imgCmpData);
|
|
|
|
*pData = *imgCmpData.getRotateData();
|
|
}
|
|
else
|
|
{
|
|
rotateMatchData(img, pData, angleStep, startAngle, endAngle);
|
|
}
|
|
|
|
#ifdef _TEST
|
|
if(1)
|
|
{
|
|
//if (idx == 15)
|
|
{
|
|
RotateData* pTestData = new RotateData;
|
|
rotateMatchData(img, pTestData, angleStep, startAngle, endAngle);
|
|
|
|
stringstream ss;
|
|
ss << "multi_scale_comp_plot";
|
|
CvPlot::clear(ss.str());
|
|
CvPlot::plot<float>(ss.str(), &(pTestData->mDisValVec[0]),
|
|
pTestData->mDisValVec.size());
|
|
|
|
float baseAngle = pTestData->bestAngle();
|
|
float curAngle = pData->bestAngle();
|
|
std::cout << baseAngle << " " << curAngle << " " << baseAngle - curAngle << std::endl;
|
|
delete pTestData;
|
|
if (abs(angleDis(baseAngle, curAngle)) > 1)
|
|
{
|
|
waitKey();
|
|
}
|
|
}
|
|
idx++;
|
|
}
|
|
#endif
|
|
|
|
RotateMatchResult rmr;
|
|
|
|
if (pData->mDisValVec.empty())
|
|
{
|
|
delete pData;
|
|
return rmr;
|
|
}
|
|
else
|
|
{
|
|
size_t bestIndex = min_element(pData->mDisValVec.begin(), pData->mDisValVec.end()) - pData->mDisValVec.begin();
|
|
|
|
Mat ret = pData->mRImgVec[bestIndex];
|
|
rmr.mBestRImg = ret;
|
|
rmr.mBestAngle = pData->bestAngle();
|
|
|
|
delete pData;
|
|
|
|
return rmr;
|
|
}
|
|
}
|
|
|
|
void ImageCompareModel::rotateMatchData(const Mat& _img, RotateData* pData,
|
|
float angleStep /*= 1.0*/, float startAngle /*= 0*/, float endAngle /*= 360*/) const
|
|
{
|
|
Mat img = _img.clone();
|
|
Point2f center(img.cols / 2.0, img.rows / 2.0);
|
|
int nNum = (endAngle - startAngle) / angleStep;
|
|
RotateData& data = *pData;
|
|
data.init(_img, center, angleStep, nNum);
|
|
data.mStartAngle = startAngle;
|
|
data.mEndAngle = endAngle;
|
|
|
|
parallel_for_(Range(0, nNum), ImageCompareModelInvoker(this, pData));
|
|
}
|
|
|
|
void ImageCompareModel::rotateMatchData(const Mat& img, RotateData* pData,
|
|
float angleStep /*= 1.0*/, const vector<Range>& angleRangeVec) const
|
|
{
|
|
float minDis = FLT_MAX;
|
|
RotateData bestData;
|
|
for_each(angleRangeVec.begin(), angleRangeVec.end(), [&](const Range& r)
|
|
{
|
|
float startAngle = r.start;
|
|
float endAngle = r.end;
|
|
rotateMatchData(img, pData, angleStep, startAngle, endAngle);
|
|
float localMinDis = *min_element(pData->mDisValVec.begin(), pData->mDisValVec.end());
|
|
if (localMinDis < minDis)
|
|
{
|
|
minDis = localMinDis;
|
|
bestData = *pData;
|
|
}
|
|
});
|
|
*pData = bestData;
|
|
}
|
|
|
|
void ImageCompareModel::rotateMatchData(const Mat& img, RotateData* pData,
|
|
const vector<Range>& angleRangeVec, float angleStep, Mat& disMat) const
|
|
{
|
|
if (angleRangeVec.empty())
|
|
{
|
|
return;
|
|
}
|
|
disMat.create(angleRangeVec.size(), angleRangeVec.front().size(), CV_32FC1);
|
|
pData->mRImgVec.resize(angleRangeVec.size());
|
|
pData->mDisValVec.resize(angleRangeVec.size(), FLT_MAX);
|
|
double minDis = DBL_MAX;
|
|
for (int i = 0; i < angleRangeVec.size(); ++i)
|
|
{
|
|
Range r = angleRangeVec[i];
|
|
Mat disVec = disMat.row(i);
|
|
RotateData rotateData;
|
|
float startAngle = r.start;
|
|
float endAngle = r.end;
|
|
rotateMatchData(img, &rotateData, angleStep, startAngle, endAngle);
|
|
std::copy(rotateData.mDisValVec.begin(), rotateData.mDisValVec.end(),
|
|
(float*)disVec.data);
|
|
double localMinDis, localMaxDis;
|
|
Point minPt, maxPt;
|
|
minMaxLoc(disVec, &localMinDis, &localMaxDis, &minPt, &maxPt);
|
|
if (localMinDis < minDis)
|
|
{
|
|
minDis = localMinDis;
|
|
*pData = rotateData;
|
|
}
|
|
}
|
|
}
|
|
|
|
void ImageCompareModel::genCandidateRepeatNums(set<unsigned int>& canNums)
|
|
{
|
|
canNums.clear();
|
|
|
|
for (int i = 4; i < 25; ++i)
|
|
{
|
|
canNums.insert(i);
|
|
}
|
|
}
|
|
|
|
bool isValidExtremas(const Mat& vec, const vector<int>& lessExtremaIdxVec,
|
|
const vector<int>& moreExtremaIdxVec)
|
|
{
|
|
float* pVec = (float*)vec.data;
|
|
auto lessIdxIter = lessExtremaIdxVec.begin();
|
|
auto moreIdxIter = moreExtremaIdxVec.begin();
|
|
while (lessIdxIter != lessExtremaIdxVec.end())
|
|
{
|
|
auto leftLessIdxIter = lessIdxIter;
|
|
auto leftMoreIdxIter = moreIdxIter;
|
|
auto rightLessIdxIter = lessIdxIter;
|
|
rightLessIdxIter++;
|
|
if (rightLessIdxIter == lessExtremaIdxVec.end())
|
|
{
|
|
break;
|
|
}
|
|
auto rightMoreIdxIter = leftMoreIdxIter;
|
|
while (*rightLessIdxIter > *rightMoreIdxIter)
|
|
{
|
|
rightMoreIdxIter++;
|
|
}
|
|
|
|
float leftLessExtrema = pVec[*leftLessIdxIter];
|
|
float rightLessExtrema = pVec[*rightLessIdxIter];
|
|
float localMaxVal = *max_element(pVec + *leftLessIdxIter,
|
|
pVec + *rightLessIdxIter + 1);
|
|
float valRange = localMaxVal - min(leftLessExtrema, rightLessExtrema);
|
|
float valTor = valRange*0.05;
|
|
float slope = (rightLessExtrema - leftLessExtrema) / (*rightLessIdxIter - *leftLessIdxIter);
|
|
|
|
leftMoreIdxIter++;
|
|
while (leftMoreIdxIter != rightMoreIdxIter)
|
|
{
|
|
float interVal = leftLessExtrema + slope*(*leftMoreIdxIter - *leftLessIdxIter);
|
|
float curExtremaVal = pVec[*leftMoreIdxIter];
|
|
if (curExtremaVal < interVal + valTor)
|
|
{
|
|
return false;
|
|
}
|
|
leftMoreIdxIter++;
|
|
}
|
|
|
|
lessIdxIter++;
|
|
moreIdxIter = rightMoreIdxIter;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
int ImageCompareModel::recognizeLowerExtremes(const Mat& vec,
|
|
set<unsigned int> canNums, int extremeRefineRange /*= 5*/, vector<int> *pExtremaIdxVec /*= 0*/)
|
|
{
|
|
unsigned int size = vec.cols;
|
|
set<unsigned int> validNs;
|
|
float* pVec = (float*)vec.data;
|
|
|
|
double vecMinVal, vecMaxVal;
|
|
minMaxIdx(vec, &vecMinVal, &vecMaxVal);
|
|
|
|
#ifdef DEBUG_VIEW_PLOT
|
|
CvPlot::clear("recognizeLowerExtreams");
|
|
CvPlot::plot<float>("recognizeLowerExtreams", (float*)vec.data, vec.cols);
|
|
#endif
|
|
|
|
map<int, vector<int> > repeatNumLocalExtremaIdxMap;
|
|
map<int, Mat> repeatNumLocalExtremaValMap;
|
|
for (auto iter = canNums.rbegin(); iter != canNums.rend(); ++iter)
|
|
{
|
|
unsigned int n = *iter;
|
|
|
|
Mat extremaValVec;
|
|
vector<int> extremaIdxVec;
|
|
uniformLocalMinExtremas(vec, extremaValVec, extremaIdxVec,
|
|
n, extremeRefineRange);
|
|
|
|
float* pExtremaVecVec = (float*)extremaValVec.data;
|
|
|
|
float curVal, nxtVal;
|
|
bool isValid = true;
|
|
|
|
Mat preLocalVec;
|
|
|
|
for (unsigned int i = 0; i < extremaIdxVec.size() - 1; ++i)
|
|
{
|
|
unsigned int curIdx = extremaIdxVec[i];
|
|
unsigned int nxtIdx = extremaIdxVec[i + 1];
|
|
curVal = pVec[curIdx];
|
|
nxtVal = pVec[nxtIdx];
|
|
|
|
// no smaller value between two neighbor extremes
|
|
if (anyInRange(pVec + curIdx + 1, pVec + nxtIdx,
|
|
-FLT_MAX, min(curVal, nxtVal)))
|
|
{
|
|
isValid = false;
|
|
break;
|
|
}
|
|
|
|
if (!preLocalVec.empty())
|
|
{
|
|
Mat curLocalVec = vec.colRange(curIdx, nxtIdx + 1);
|
|
if (curLocalVec.size() != preLocalVec.size())
|
|
{
|
|
resize(curLocalVec, curLocalVec, preLocalVec.size());
|
|
}
|
|
float sim = compareHist(curLocalVec, preLocalVec, CV_COMP_CORREL);
|
|
if (sim < 0)
|
|
{
|
|
isValid = false;
|
|
break;
|
|
}
|
|
}
|
|
|
|
preLocalVec = vec.colRange(curIdx, nxtIdx + 1);
|
|
}
|
|
if (!isValid)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
set<int> nToBeErased;
|
|
for_each(validNs.begin(), validNs.end(), [&](int preN)
|
|
{
|
|
if (preN % n != 0 || !isValid)
|
|
{
|
|
return;
|
|
}
|
|
vector<int> preExtremaIdxVec = repeatNumLocalExtremaIdxMap[preN];
|
|
if (isValidExtremas(vec, extremaIdxVec, preExtremaIdxVec))
|
|
{
|
|
nToBeErased.insert(preN);
|
|
}
|
|
else
|
|
{
|
|
isValid = false;
|
|
}
|
|
});
|
|
if (!isValid)
|
|
{
|
|
continue;
|
|
}
|
|
if (nToBeErased.size() == validNs.size())
|
|
{
|
|
validNs.clear();
|
|
}
|
|
else
|
|
{
|
|
for_each(nToBeErased.begin(), nToBeErased.end(), [&](int toBeErasedN)
|
|
{
|
|
validNs.erase(toBeErasedN);
|
|
});
|
|
}
|
|
|
|
validNs.insert(n);
|
|
repeatNumLocalExtremaIdxMap[n] = extremaIdxVec;
|
|
repeatNumLocalExtremaValMap[n] = extremaValVec;
|
|
if (pExtremaIdxVec)
|
|
{
|
|
*pExtremaIdxVec = extremaIdxVec;
|
|
}
|
|
}
|
|
if (validNs.size() == 0)
|
|
{
|
|
return -1;
|
|
}
|
|
if (validNs.size() > 1)
|
|
{
|
|
return -2;
|
|
}
|
|
|
|
return *(validNs.begin());
|
|
}
|
|
|
|
int ImageCompareModel::recognizeRepeatedLocalExtremas(const Mat& vec,
|
|
const set<unsigned int>& canNums, int refineRange /*= 5*/,
|
|
vector<int> *pIdxVec /*= 0*/)
|
|
{
|
|
assert(vec.type() == CV_32FC1);
|
|
float* pVecData = (float*)vec.data;
|
|
|
|
for_each(canNums.begin(), canNums.end(), [&](int n)
|
|
{
|
|
Mat localMinExtremaValVec;
|
|
vector<int> localMinExtremaIdxVec;
|
|
uniformLocalMinExtremas(vec, localMinExtremaValVec, localMinExtremaIdxVec,
|
|
n, refineRange);
|
|
|
|
float* pExtremaVecVec = (float*)localMinExtremaValVec.data;
|
|
|
|
// get locally top 10% values
|
|
|
|
});
|
|
|
|
return -1;
|
|
}
|
|
|
|
int ImageCompareModel::computeRepeatNum(const Mat& _img)
|
|
{
|
|
Mat img;
|
|
cv::GaussianBlur(_img, img, Size(3, 3), 5.0);
|
|
vector<float> vec;
|
|
selfRotationSimilarityFeature(img, vec, Point2f(img.cols / 2.0, img.rows / 2.0));
|
|
|
|
#ifdef DEBUG_VIEW_INTERNAL_MAT
|
|
Mat viewImg = img / 255.0 /255.0;
|
|
Mat view_Img = _img / 255.0 /255.0;
|
|
#endif
|
|
|
|
vector<float> normVec(vec);
|
|
Mat vecMat(1, vec.size(), CV_32FC1, &(vec[0]));
|
|
Mat normVecMat(1, normVec.size(), CV_32FC1, &(normVec[0]));
|
|
/*luffy_base::luffy_imageProc::*/meanvarnorm(vecMat, normVecMat, 0, 1.0);
|
|
|
|
#ifdef DEBUG_VIEW_PLOT
|
|
Mat dftVec;
|
|
dft(normVec, dftVec);
|
|
dftVec = abs(dftVec);
|
|
|
|
Mat dVecMat = normVecMat.clone();
|
|
genSobelImage(dVecMat);
|
|
Mat dDftVec;
|
|
dft(dVecMat, dDftVec);
|
|
|
|
Mat ddVecMat = dVecMat.clone();
|
|
genSobelImage(ddVecMat);
|
|
Mat ddDftVec;
|
|
dft(ddVecMat, ddDftVec);
|
|
|
|
CvPlot::plot<float>("normVec", (float*)&(normVec[0]), normVec.size());
|
|
CvPlot::plot<float>("dVec", (float*)dVecMat.data, dVecMat.cols);
|
|
CvPlot::plot<float>("ddVec", (float*)ddVecMat.data, ddVecMat.cols);
|
|
CvPlot::plot<float>("ddft", (float*)dDftVec.data, 50);
|
|
CvPlot::plot<float>("dft", (float*)dftVec.data, 50);
|
|
CvPlot::plot<float>("dddft", (float*)ddDftVec.data, 50);
|
|
|
|
waitKey();
|
|
#endif
|
|
|
|
set<unsigned int> canNums;
|
|
genCandidateRepeatNums(canNums);
|
|
return recognizeLowerExtremes(normVecMat, canNums);
|
|
}
|
|
|
|
int ImageCompareModel::computeRepeatNum()
|
|
{
|
|
if (mWeightMat.empty() || mAlignBaseImg.empty())
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
Mat img = mAlignBaseImg.mul(mWeightMat);
|
|
|
|
#ifdef DEBUG_VIEW_INTERNAL_MAT
|
|
Mat viewImg = img / 255.0 / 255.0;
|
|
#endif
|
|
|
|
return computeRepeatNum(img);
|
|
}
|
|
|
|
void ImageCompareModel::initMultiScaleModel()
|
|
{
|
|
if (mpMultiScaleModel)
|
|
{
|
|
delete mpMultiScaleModel;
|
|
}
|
|
mpMultiScaleModel = new MultiScaleImageCompareModel;
|
|
mpMultiScaleModel->setLevelNum(3);
|
|
mpMultiScaleModel->setBaseLevel(this);
|
|
mpMultiScaleModel->genMultiScale();
|
|
}
|
|
|
|
void ImageCompareModelInvoker::operator()(const cv::Range& range) const
|
|
{
|
|
int i0 = range.start;
|
|
int i1 = range.end;
|
|
//assert(abs(i1 - i0) == 1);
|
|
m_pModel->parallelDetect(i0, m_pData);
|
|
}
|
|
|
|
void ImageCompareModel::parallelDetect(int index, void *p) const
|
|
{
|
|
RotateData *pData = (RotateData *)p;
|
|
Mat t = getRotationMatrix2D(pData->mCenter, pData->angle(index), 1.0);
|
|
Mat rImg;
|
|
warpAffine(pData->mImgSrc, rImg, t, pData->mImgSrc.size());
|
|
if (rImg.size() != mAlignBaseImg.size())
|
|
{
|
|
resize(rImg, rImg, mAlignBaseImg.size());
|
|
}
|
|
|
|
Mat imgRes = rImg - mAlignBaseImg;
|
|
|
|
#ifdef DEBUG_VIEW_INTERNAL_MAT
|
|
Mat vRImg, vBaseImg;
|
|
vRImg = rImg / 255.0;
|
|
vBaseImg = mAlignBaseImg / 255.0;
|
|
Mat vImgRes = imgRes / 255.0;
|
|
Mat vWeightMat = mWeightMat / 255.0;
|
|
#endif
|
|
|
|
imgRes = imgRes.mul(m32fMaskImg);
|
|
|
|
if (!mWeightMat.empty())
|
|
{
|
|
imgRes.mul(mWeightMat);
|
|
}
|
|
double val = norm(imgRes);
|
|
|
|
#ifdef DEBUG_VIEW_INTERNAL_MAT
|
|
vImgRes = imgRes / 255.0;
|
|
#endif
|
|
pData->mDisValVec[index] = val;
|
|
pData->mRImgVec[index] = rImg;
|
|
}
|
|
double ImageCompareModel::filterTrainImage(const Mat&img)
|
|
{
|
|
if (img.empty())
|
|
{
|
|
return DBL_MAX;
|
|
}
|
|
mDisThre = DBL_MAX;
|
|
double dis = compare(img, NULL, 3, false);
|
|
/*if (dis < mTrueSampleDisMax)
|
|
{
|
|
dis = mTrueSampleDisMax;
|
|
}
|
|
double absDiff = abs(dis - mTrueSampleDisMax);*/
|
|
return dis;
|
|
}
|
|
void ImageCompareModel::weightOptimization(const vector<Mat>& falseSamples)
|
|
{
|
|
reConMat = mWeightMat.clone();
|
|
for (int i = 0; i < falseSamples.size(); i++)
|
|
{
|
|
Mat falseSample = falseSamples[i].clone();
|
|
preWeightReconstruction(falseSample, reConMat);
|
|
}
|
|
mWeightMat = reConMat;
|
|
}
|
|
|
|
void ImageCompareModel::preWeightReconstruction(Mat img, Mat &reConImg)
|
|
{
|
|
|
|
if (mAlignBaseImg.size() != img.size())
|
|
{
|
|
resize(img, img, mAlignBaseImg.size());
|
|
}
|
|
|
|
Mat matchImg = img.clone();
|
|
preProcessImage(matchImg);
|
|
|
|
if (!mpMultiScaleModel)
|
|
{
|
|
initMultiScaleModel();
|
|
}
|
|
RotateMatchResult rmr = rotateMatch(matchImg, 1);
|
|
Mat rImg = rmr.mBestRImg;
|
|
|
|
#ifdef DEBUG_VIEW_INTERNAL_MAT
|
|
Mat vRImg = rImg / 255.0;
|
|
#endif
|
|
|
|
double bestAngle = rmr.mBestAngle;
|
|
Mat cmpImg = rotateImage(img, Point2f(img.cols / 2.0, img.rows / 2.0),
|
|
bestAngle);
|
|
|
|
// remove highlights
|
|
Mat hightlightsMask = cmpImg < mHighlightsThreshold;
|
|
converToType(hightlightsMask, CV_32FC1);
|
|
hightlightsMask /= 255.0;
|
|
|
|
Mat unifiedMask = m32fMaskImg.mul(hightlightsMask).mul(mWeightMat);
|
|
|
|
preProcessImage(cmpImg, m8uMaskImg, mWeightMat, mTargetMeanVal,
|
|
mTargetStddevVal, mHighlightsThreshold);
|
|
|
|
cmpImg.setTo(0, cmpImg < 0);
|
|
converToType(cmpImg, CV_32FC1);
|
|
normSectors_tarImg(cmpImg, unifiedMask, imgCen(cmpImg), 1,
|
|
mCompareBaseImg);
|
|
|
|
#ifdef DEBUG_VIEW_INTERNAL_MAT
|
|
Mat vRotatedImg0 = cmpImg / 255.0;
|
|
#endif
|
|
|
|
#ifdef DEBUG_VIEW_INTERNAL_MAT
|
|
Mat vRotatedImg1 = cmpImg / 255.0;
|
|
#endif
|
|
|
|
cmpImg.setTo(0, cmpImg < 10);
|
|
|
|
weightReconstruction(cmpImg, mCompareBaseImg, unifiedMask, reConImg);
|
|
|
|
}
|
|
|
|
void ImageCompareModel::weightReconstruction(const Mat& rImg, const Mat& baseImg, const Mat& maskImg, Mat &reConImg)
|
|
{
|
|
Mat dMat = abs(rImg - baseImg);
|
|
Mat norImg = Mat::ones(dMat.size(), dMat.type()) * 255;
|
|
dMat = min(dMat, norImg);
|
|
Mat w;
|
|
dMat.copyTo(w, dMat < 0.5);
|
|
|
|
w = minMaxNorm(w, 0, 1.0);
|
|
for (int i = 0; i < reConImg.rows; i++)
|
|
{
|
|
float* pData = (float*)reConImg.row(i).data;
|
|
float* pWeight = (float*)w.row(i).data;
|
|
for (int j = 0; j < reConImg.cols; j++)
|
|
{
|
|
if (pWeight[j]!=0)
|
|
{
|
|
//pData[j] *= pWeight[j];
|
|
pWeight[j] = -1 * pow(pWeight[j] - 1, 2) + 1;
|
|
pData[j] *= pWeight[j];
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
double ImageCompareModel::penltyCoeff(double matchedVal, int diameterMean, int targetDiameter, double modelDiamter, double modelHeight) const
|
|
{
|
|
int diff = abs(diameterMean - targetDiameter);
|
|
double modelDiameterDiff = abs(modelDiamter - realWidth);
|
|
double modelHeightDiff = abs(modelHeight - realHeight);
|
|
|
|
if (diff >=10)
|
|
{
|
|
return matchedVal*(diff / 100.0 + 1) * (modelHeightDiff / 100.0 + 1) * (modelDiameterDiff / 100.0 + 1);
|
|
}
|
|
else
|
|
{
|
|
return matchedVal;
|
|
}
|
|
|
|
|
|
} |