2020-03-11 01:58:06 +00:00
|
|
|
#include "ImageApplyDiscardBlank.h"
|
|
|
|
#include "ImageProcess_Public.h"
|
2020-08-15 08:06:44 +00:00
|
|
|
#include "filetools.h"
|
2020-12-21 09:34:20 +00:00
|
|
|
CImageApplyDiscardBlank::CImageApplyDiscardBlank(int blockSize, int devTh)
|
|
|
|
: m_res(false)
|
|
|
|
, m_dSize(blockSize)
|
|
|
|
, m_devTh(devTh)
|
|
|
|
{
|
|
|
|
}
|
2020-08-15 08:06:44 +00:00
|
|
|
CImageApplyDiscardBlank::CImageApplyDiscardBlank()
|
2020-03-11 01:58:06 +00:00
|
|
|
: m_res(false)
|
2020-12-21 09:34:20 +00:00
|
|
|
, m_dSize(200)
|
|
|
|
, m_devTh(15, 15, 15, 15)
|
2020-03-11 01:58:06 +00:00
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
CImageApplyDiscardBlank::~CImageApplyDiscardBlank(void)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
int CImageApplyDiscardBlank::processRectR(const cv::Mat& image, cv::RotatedRect& rotatedRect, std::vector<cv::Point>& maxContour,
|
|
|
|
double scale, double thresh, int blobAreaSize)
|
|
|
|
{
|
|
|
|
cv::Mat gray;
|
|
|
|
int blockCount = 0;
|
|
|
|
if (image.channels() == 3)
|
|
|
|
if (scale != 1.0f)
|
|
|
|
{
|
|
|
|
cv::Size ResImgSiz = cv::Size(image.cols * scale, image.rows * scale);
|
|
|
|
resize(image, gray, cv::Size(), scale, scale, 0);
|
|
|
|
cvtColor(gray, gray, CV_BGR2GRAY);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
cvtColor(image, gray, CV_BGR2GRAY);
|
|
|
|
else
|
|
|
|
if (scale != 1.0f)
|
|
|
|
resize(image, gray, cv::Size(), scale, scale, 0);
|
|
|
|
else
|
|
|
|
gray = image;
|
|
|
|
|
|
|
|
cv::Mat threshold_img;
|
|
|
|
threshold(gray, threshold_img, thresh, 255.0, CV_THRESH_BINARY);
|
|
|
|
std::vector<std::vector<cv::Point>> contours;
|
|
|
|
std::vector<cv::Vec4i> h1;
|
|
|
|
hg::findContours(threshold_img, contours, h1, CV_CHAIN_APPROX_SIMPLE);
|
|
|
|
threshold_img.release();
|
|
|
|
|
|
|
|
if (contours.size() == 0)
|
|
|
|
return blockCount;
|
|
|
|
|
|
|
|
std::vector<cv::Point2f> list_com;
|
|
|
|
for (int i = 0; i < contours.size(); i++)
|
|
|
|
{
|
|
|
|
double area = cv::contourArea(contours[i]);
|
|
|
|
if (area > blobAreaSize)
|
|
|
|
{
|
|
|
|
blockCount++;
|
|
|
|
for (int j = 0; j < contours[i].size(); j++)
|
|
|
|
list_com.push_back(contours[i][j]);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (list_com.size() == 0)
|
|
|
|
return blockCount;
|
|
|
|
|
|
|
|
rotatedRect = cv::minAreaRect(list_com);
|
|
|
|
rotatedRect.center.x /= (float)scale;
|
|
|
|
rotatedRect.center.y /= (float)scale;
|
|
|
|
rotatedRect.size.width /= (float)scale;
|
|
|
|
rotatedRect.size.height /= (float)scale;
|
|
|
|
|
|
|
|
if (rotatedRect.angle < -45.0f)
|
|
|
|
{
|
|
|
|
rotatedRect.angle += 90.0f;
|
|
|
|
float l_temp = rotatedRect.size.width;
|
|
|
|
rotatedRect.size.width = rotatedRect.size.height;
|
|
|
|
rotatedRect.size.height = l_temp;
|
|
|
|
}
|
|
|
|
|
|
|
|
std::vector<int> hull(list_com.size());
|
|
|
|
cv::convexHull(list_com, hull);
|
|
|
|
|
|
|
|
for (int i = 0; i < hull.size(); i++)
|
|
|
|
{
|
|
|
|
cv::Point temp = list_com[hull[i]];
|
|
|
|
int x = (int)(temp.x / scale);
|
|
|
|
int y = (int)(temp.y / scale);
|
|
|
|
maxContour.push_back(cv::Point(x, y));
|
|
|
|
}
|
|
|
|
|
|
|
|
return blockCount;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool CImageApplyDiscardBlank::scalar_LE(const cv::Scalar& val1, const cv::Scalar& val2)
|
|
|
|
{
|
2020-08-15 08:06:44 +00:00
|
|
|
for (int i = 0; i < 3; i++)
|
|
|
|
if (val1[i] > val2[i])
|
2020-03-11 01:58:06 +00:00
|
|
|
return false;
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
void CImageApplyDiscardBlank::setIntensity(int val)
|
|
|
|
{
|
2020-12-21 09:34:20 +00:00
|
|
|
val = cv::max(cv::min(100, val), 2);
|
|
|
|
m_devTh = cv::Scalar::all(val);
|
2020-03-11 01:58:06 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
cv::Mat CImageApplyDiscardBlank::getRoiMat(const cv::Mat& image)
|
|
|
|
{
|
|
|
|
int gap = 100;
|
|
|
|
cv::RotatedRect rect;
|
|
|
|
std::vector<cv::Point> contour;
|
|
|
|
double scale = 0.25;
|
|
|
|
double thresh = 50;
|
|
|
|
int blobSize = 200;
|
|
|
|
processRectR(image, rect, contour, scale, thresh, blobSize);
|
|
|
|
cv::Rect rect2 = rect.boundingRect();
|
|
|
|
cv::Rect inRect = rect2 & cv::Rect(0, 0, image.cols, image.rows);
|
2020-12-21 09:34:20 +00:00
|
|
|
gap = cv::max(inRect.width - rect.size.width, inRect.height - rect.size.height) + 100;
|
2020-03-11 01:58:06 +00:00
|
|
|
inRect = cv::Rect(inRect.x + gap, inRect.y + gap, inRect.width - gap * 2, inRect.height - gap * 2);
|
2020-12-21 09:34:20 +00:00
|
|
|
|
|
|
|
if (inRect.width <= 0 || inRect.height <= 0)
|
|
|
|
return cv::Mat();
|
2020-03-11 01:58:06 +00:00
|
|
|
return image(inRect);
|
|
|
|
}
|
|
|
|
|
2020-08-15 08:06:44 +00:00
|
|
|
void CImageApplyDiscardBlank::apply(cv::Mat& pDib, int side)
|
2020-03-11 01:58:06 +00:00
|
|
|
{
|
|
|
|
#ifdef LOG
|
2020-11-16 10:05:04 +00:00
|
|
|
FileTools::write_log("imgprc.txt", "enter CImageApplyDiscardBlank apply");
|
2020-03-11 01:58:06 +00:00
|
|
|
#endif // LOG
|
|
|
|
|
|
|
|
if (pDib.empty())
|
|
|
|
{
|
|
|
|
#ifdef LOG
|
|
|
|
FileTools::write_log("imgprc.txt", "exit CImageApplyDiscardBlank apply");
|
|
|
|
#endif // LOG
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
cv::Scalar mean;
|
|
|
|
cv::Scalar dev;
|
|
|
|
cv::Mat image = getRoiMat(pDib);
|
|
|
|
cv::Rect rect;
|
|
|
|
cv::Rect imRect(0, 0, image.cols, image.rows);
|
2020-12-21 09:34:20 +00:00
|
|
|
for(int i = 0; i < image.cols; i+= m_dSize)
|
|
|
|
for(int j = 0; j < image.rows; j+= m_dSize)
|
2020-03-11 01:58:06 +00:00
|
|
|
{
|
2020-12-21 09:34:20 +00:00
|
|
|
rect = cv::Rect(i, j, m_dSize, m_dSize) & imRect;
|
2020-03-11 01:58:06 +00:00
|
|
|
if(rect != cv::Rect())
|
|
|
|
{
|
|
|
|
cv::meanStdDev (image(rect) , mean, dev);
|
2020-12-21 09:34:20 +00:00
|
|
|
if(!scalar_LE(dev, m_devTh))
|
2020-03-11 01:58:06 +00:00
|
|
|
{
|
|
|
|
m_res = false;
|
|
|
|
#ifdef LOG
|
2020-12-21 09:34:20 +00:00
|
|
|
FileTools::write_log("imgprc.txt", "exit CImageApplyDiscardBlank apply");
|
2020-03-11 01:58:06 +00:00
|
|
|
#endif // LOG
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
m_res = true;
|
|
|
|
if (m_res)
|
|
|
|
pDib.release();
|
|
|
|
#ifdef LOG
|
|
|
|
FileTools::write_log("imgprc.txt", "exit CImageApplyDiscardBlank apply");
|
|
|
|
#endif // LOG
|
|
|
|
}
|
|
|
|
|
|
|
|
void CImageApplyDiscardBlank::apply(std::vector<cv::Mat>& mats, bool isTwoSide)
|
|
|
|
{
|
2020-08-15 08:06:44 +00:00
|
|
|
(void)isTwoSide;
|
|
|
|
int i = 0;
|
|
|
|
for (cv::Mat& var : mats) {
|
|
|
|
if (i != 0 && isTwoSide == false)
|
|
|
|
break;
|
|
|
|
if (!var.empty())
|
|
|
|
apply(var, 0);
|
|
|
|
i++;
|
2020-03-17 13:06:21 +00:00
|
|
|
}
|
2020-08-15 08:06:44 +00:00
|
|
|
}
|
2020-12-21 09:34:20 +00:00
|
|
|
|
|
|
|
bool CImageApplyDiscardBlank::apply(const cv::Mat& pDib, int blockSize, int devTh)
|
|
|
|
{
|
|
|
|
if (pDib.empty())
|
|
|
|
return true;
|
|
|
|
|
|
|
|
cv::Scalar mean;
|
|
|
|
cv::Scalar dev;
|
|
|
|
cv::Scalar s_devTh = cv::Scalar::all(devTh);
|
|
|
|
cv::Mat image = getRoiMat(pDib);
|
|
|
|
if (image.empty())
|
|
|
|
return false;
|
|
|
|
cv::Rect rect;
|
|
|
|
cv::Rect imRect(0, 0, image.cols, image.rows);
|
|
|
|
for (int i = 0; i < image.cols; i += blockSize)
|
|
|
|
for (int j = 0; j < image.rows; j += blockSize)
|
|
|
|
{
|
|
|
|
rect = cv::Rect(i, j, blockSize, blockSize) & imRect;
|
|
|
|
if (rect != cv::Rect())
|
|
|
|
{
|
|
|
|
cv::meanStdDev(image(rect), mean, dev);
|
|
|
|
if (!scalar_LE(dev, s_devTh))
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|