2022-05-03 10:25:52 +00:00
|
|
|
|
#include "HGImgProc.h"
|
2022-05-12 03:11:22 +00:00
|
|
|
|
#include "./ImageProcess/ImageApplyAdjustColors.h"
|
|
|
|
|
#include "./ImageProcess/ImageApplyAutoCrop.h"
|
|
|
|
|
#include "./ImageProcess/ImageApplyDiscardBlank.h"
|
2022-06-18 02:32:32 +00:00
|
|
|
|
#include "./ImageProcess/ImageApplyBWBinaray.h"
|
2022-06-18 07:05:04 +00:00
|
|
|
|
#include "./ImageProcess/ImageApplyChannel.h"
|
|
|
|
|
#include "./ImageProcess/ImageApplyColorRecognition.h"
|
2022-06-18 09:59:25 +00:00
|
|
|
|
#include "./ImageProcess/ImageApplyDispersion.h"
|
|
|
|
|
#include "./ImageProcess/ImageApplyFadeBackGroundColor.h"
|
|
|
|
|
#include "./ImageProcess/ImageApplyFilter.h"
|
2022-06-20 03:06:18 +00:00
|
|
|
|
#include "./ImageProcess/ImageApplyOutHole.h"
|
2022-06-20 06:18:21 +00:00
|
|
|
|
#include "./ImageProcess/ImageApplyHSVCorrect.h"
|
2022-06-13 11:56:43 +00:00
|
|
|
|
#include "CvxText.hpp"
|
2022-05-03 10:25:52 +00:00
|
|
|
|
#include "../base/HGInc.h"
|
2022-06-13 11:56:43 +00:00
|
|
|
|
#include "../base/HGUtility.h"
|
2022-05-03 10:25:52 +00:00
|
|
|
|
|
|
|
|
|
HGResult HGAPI HGImgProc_ResizeImage(HGImage image, HGImage destImage, HGUInt interp)
|
|
|
|
|
{
|
|
|
|
|
if (NULL == image || NULL == destImage || image == destImage)
|
|
|
|
|
{
|
|
|
|
|
return HGBASE_ERR_INVALIDARG;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (HGIMGPROC_INTERPOTYPE_NN != interp && HGIMGPROC_INTERPOTYPE_LINEAR != interp)
|
|
|
|
|
{
|
|
|
|
|
return HGBASE_ERR_INVALIDARG;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
HGImageInfo imgInfo;
|
|
|
|
|
HGBase_GetImageInfo(image, &imgInfo);
|
|
|
|
|
HGImageInfo destImgInfo;
|
|
|
|
|
HGBase_GetImageInfo(destImage, &destImgInfo);
|
|
|
|
|
|
|
|
|
|
uint32_t type = imgInfo.type;
|
|
|
|
|
uint32_t destType = destImgInfo.type;
|
|
|
|
|
if (type != destType)
|
|
|
|
|
{
|
|
|
|
|
return HGBASE_ERR_INVALIDDATA;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
HGByte* data = NULL;
|
|
|
|
|
HGBase_GetImageData(image, &data);
|
|
|
|
|
HGByte* destData = NULL;
|
|
|
|
|
HGBase_GetImageData(destImage, &destData);
|
|
|
|
|
|
|
|
|
|
HGImageRoi roi;
|
|
|
|
|
HGBase_GetImageROI(image, &roi);
|
|
|
|
|
HGImageRoi destRoi;
|
|
|
|
|
HGBase_GetImageROI(destImage, &destRoi);
|
|
|
|
|
|
|
|
|
|
HGUInt roiWidth = roi.right - roi.left;
|
|
|
|
|
HGUInt roiHeight = roi.bottom - roi.top;
|
|
|
|
|
HGUInt destRoiWidth = destRoi.right - destRoi.left;
|
|
|
|
|
HGUInt destRoiHeight = destRoi.bottom - destRoi.top;
|
|
|
|
|
|
|
|
|
|
if (roiWidth == destRoiWidth && roiHeight == destRoiHeight)
|
|
|
|
|
{
|
|
|
|
|
return HGBase_CopyImage(image, destImage);
|
|
|
|
|
}
|
|
|
|
|
|
2022-05-26 11:01:38 +00:00
|
|
|
|
if (HGBASE_IMGTYPE_BINARY == type)
|
|
|
|
|
{
|
|
|
|
|
HGImage imageTmp1 = NULL;
|
|
|
|
|
HGResult ret = HGBase_CloneImage(image, HGBASE_IMGTYPE_GRAY, 0, &imageTmp1);
|
|
|
|
|
if (HGBASE_ERR_OK == ret)
|
|
|
|
|
{
|
|
|
|
|
HGImage imageTmp2 = NULL;
|
|
|
|
|
ret = HGBase_CreateImage(destRoiWidth, destRoiHeight, HGBASE_IMGTYPE_GRAY, imgInfo.origin, &imageTmp2);
|
|
|
|
|
if (HGBASE_ERR_OK == ret)
|
|
|
|
|
{
|
|
|
|
|
ret = HGImgProc_ResizeImage(imageTmp1, imageTmp2, interp);
|
|
|
|
|
if (HGBASE_ERR_OK == ret)
|
|
|
|
|
{
|
|
|
|
|
ret = HGBase_CopyImage(imageTmp2, destImage);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
HGBase_DestroyImage(imageTmp2);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
HGBase_DestroyImage(imageTmp1);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
2022-05-03 10:25:52 +00:00
|
|
|
|
uint32_t channels = 1;
|
|
|
|
|
if (HGBASE_IMGTYPE_BGR == type || HGBASE_IMGTYPE_RGB == type)
|
|
|
|
|
channels = 3;
|
|
|
|
|
else if (HGBASE_IMGTYPE_BGRA == type || HGBASE_IMGTYPE_RGBA == type)
|
|
|
|
|
channels = 4;
|
|
|
|
|
|
|
|
|
|
uint8_t* p = data + roi.top * imgInfo.widthStep + roi.left * channels;
|
2022-06-14 09:06:19 +00:00
|
|
|
|
if (HGBASE_IMGORIGIN_BOTTOM == imgInfo.origin)
|
|
|
|
|
p = data + (imgInfo.height - roi.bottom) * imgInfo.widthStep + roi.left * channels;
|
|
|
|
|
|
2022-05-03 10:25:52 +00:00
|
|
|
|
uint8_t* pDest = destData + destRoi.top * destImgInfo.widthStep + destRoi.left * channels;
|
2022-06-14 09:06:19 +00:00
|
|
|
|
if (HGBASE_IMGORIGIN_BOTTOM == destImgInfo.origin)
|
|
|
|
|
pDest = destData + (destImgInfo.height - destRoi.bottom) * destImgInfo.widthStep + destRoi.left * channels;
|
2022-05-03 10:25:52 +00:00
|
|
|
|
|
|
|
|
|
IplImage* pImg = cvCreateImageHeader(cvSize(roiWidth, roiHeight), IPL_DEPTH_8U, channels);
|
|
|
|
|
IplImage* pImgDest = cvCreateImageHeader(cvSize(destRoiWidth, destRoiHeight), IPL_DEPTH_8U, channels);
|
|
|
|
|
cvSetData(pImg, p, imgInfo.widthStep);
|
|
|
|
|
cvSetData(pImgDest, pDest, destImgInfo.widthStep);
|
|
|
|
|
int interpolation = (HGIMGPROC_INTERPOTYPE_NN == interp) ? CV_INTER_NN : CV_INTER_LINEAR;
|
|
|
|
|
cvResize(pImg, pImgDest, interpolation);
|
|
|
|
|
cvReleaseImageHeader(&pImgDest);
|
|
|
|
|
cvReleaseImageHeader(&pImg);
|
|
|
|
|
|
|
|
|
|
if (imgInfo.origin != destImgInfo.origin)
|
|
|
|
|
{
|
|
|
|
|
HGBase_ImageFlip(destImage, destImage);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return HGBASE_ERR_OK;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
HGResult HGAPI HGImgProc_ImageAdjustColors(HGImage image, HGImage destImage,
|
|
|
|
|
HGInt brightness, HGInt contrast, HGFloat gamma)
|
|
|
|
|
{
|
|
|
|
|
if (NULL == image)
|
|
|
|
|
{
|
|
|
|
|
return HGBASE_ERR_INVALIDARG;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
HGImageInfo imgInfo;
|
|
|
|
|
HGBase_GetImageInfo(image, &imgInfo);
|
2022-05-26 03:16:59 +00:00
|
|
|
|
HGUInt type = imgInfo.type;
|
2022-05-26 11:01:38 +00:00
|
|
|
|
|
2022-05-03 10:25:52 +00:00
|
|
|
|
HGByte* data = NULL;
|
|
|
|
|
HGBase_GetImageData(image, &data);
|
|
|
|
|
|
|
|
|
|
HGImageRoi roi;
|
|
|
|
|
HGBase_GetImageROI(image, &roi);
|
|
|
|
|
HGUInt roiWidth = roi.right - roi.left;
|
|
|
|
|
HGUInt roiHeight = roi.bottom - roi.top;
|
|
|
|
|
|
|
|
|
|
uint32_t channels = 1;
|
|
|
|
|
if (HGBASE_IMGTYPE_BGR == type || HGBASE_IMGTYPE_RGB == type)
|
|
|
|
|
channels = 3;
|
|
|
|
|
else if (HGBASE_IMGTYPE_BGRA == type || HGBASE_IMGTYPE_RGBA == type)
|
|
|
|
|
channels = 4;
|
|
|
|
|
|
|
|
|
|
if (NULL == destImage || image == destImage)
|
|
|
|
|
{
|
2022-05-26 11:01:38 +00:00
|
|
|
|
if (HGBASE_IMGTYPE_BINARY == type)
|
|
|
|
|
{
|
|
|
|
|
HGImage imageTmp = NULL;
|
|
|
|
|
HGResult ret = HGBase_CloneImage(image, HGBASE_IMGTYPE_GRAY, 0, &imageTmp);
|
|
|
|
|
if (HGBASE_ERR_OK == ret)
|
|
|
|
|
{
|
|
|
|
|
ret = HGImgProc_ImageAdjustColors(imageTmp, imageTmp, brightness, contrast, gamma);
|
|
|
|
|
if (HGBASE_ERR_OK == ret)
|
|
|
|
|
{
|
|
|
|
|
ret = HGBase_CopyImage(imageTmp, image);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
HGBase_DestroyImage(imageTmp);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
2022-05-27 01:40:25 +00:00
|
|
|
|
uint8_t* p = data + roi.top * imgInfo.widthStep + roi.left * channels;
|
2022-06-14 09:06:19 +00:00
|
|
|
|
if (HGBASE_IMGORIGIN_BOTTOM == imgInfo.origin)
|
|
|
|
|
p = data + (imgInfo.height - roi.bottom) * imgInfo.widthStep + roi.left * channels;
|
2022-05-27 01:40:25 +00:00
|
|
|
|
|
2022-06-14 09:06:19 +00:00
|
|
|
|
cv::Mat img(roiHeight, roiWidth, CV_8UC(channels), p, imgInfo.widthStep);
|
2022-05-12 03:11:22 +00:00
|
|
|
|
CImageApplyAdjustColors imgApply(brightness, contrast, gamma);
|
|
|
|
|
imgApply.apply(img, 0);
|
2022-06-18 02:32:32 +00:00
|
|
|
|
assert(img.data == p);
|
2022-05-03 10:25:52 +00:00
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
HGImageInfo destImgInfo;
|
|
|
|
|
HGBase_GetImageInfo(destImage, &destImgInfo);
|
|
|
|
|
HGUInt destType = destImgInfo.type;
|
|
|
|
|
if (type != destType)
|
|
|
|
|
{
|
|
|
|
|
return HGBASE_ERR_INVALIDDATA;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
HGByte* destData = NULL;
|
|
|
|
|
HGBase_GetImageData(destImage, &destData);
|
|
|
|
|
|
|
|
|
|
HGImageRoi destRoi;
|
|
|
|
|
HGBase_GetImageROI(destImage, &destRoi);
|
|
|
|
|
HGUInt destRoiWidth = destRoi.right - destRoi.left;
|
|
|
|
|
HGUInt destRoiHeight = destRoi.bottom - destRoi.top;
|
|
|
|
|
|
|
|
|
|
if (roiWidth != destRoiWidth || roiHeight != destRoiHeight)
|
|
|
|
|
{
|
|
|
|
|
return HGBASE_ERR_INVALIDDATA;
|
|
|
|
|
}
|
|
|
|
|
|
2022-05-26 11:01:38 +00:00
|
|
|
|
if (HGBASE_IMGTYPE_BINARY == type)
|
|
|
|
|
{
|
|
|
|
|
HGImage imageTmp = NULL;
|
|
|
|
|
HGResult ret = HGBase_CloneImage(image, HGBASE_IMGTYPE_GRAY, 0, &imageTmp);
|
|
|
|
|
if (HGBASE_ERR_OK == ret)
|
|
|
|
|
{
|
|
|
|
|
ret = HGImgProc_ImageAdjustColors(imageTmp, imageTmp, brightness, contrast, gamma);
|
|
|
|
|
if (HGBASE_ERR_OK == ret)
|
|
|
|
|
{
|
|
|
|
|
ret = HGBase_CopyImage(imageTmp, destImage);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
HGBase_DestroyImage(imageTmp);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
2022-05-12 03:11:22 +00:00
|
|
|
|
HGBase_CopyImage(image, destImage);
|
|
|
|
|
|
2022-05-03 10:25:52 +00:00
|
|
|
|
uint8_t* pDest = destData + destRoi.top * destImgInfo.widthStep + destRoi.left * channels;
|
2022-06-14 09:06:19 +00:00
|
|
|
|
if (HGBASE_IMGORIGIN_BOTTOM == destImgInfo.origin)
|
|
|
|
|
pDest = destData + (destImgInfo.height - destRoi.bottom) * destImgInfo.widthStep + destRoi.left * channels;
|
2022-05-03 10:25:52 +00:00
|
|
|
|
|
2022-06-14 09:06:19 +00:00
|
|
|
|
cv::Mat destImg(destRoiHeight, destRoiWidth, CV_8UC(channels), pDest, destImgInfo.widthStep);
|
2022-05-12 03:11:22 +00:00
|
|
|
|
CImageApplyAdjustColors imgApply(brightness, contrast, gamma);
|
|
|
|
|
imgApply.apply(destImg, 0);
|
2022-06-18 02:32:32 +00:00
|
|
|
|
assert(destImg.data == pDest);
|
2022-05-03 10:25:52 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return HGBASE_ERR_OK;
|
|
|
|
|
}
|
|
|
|
|
|
2022-05-12 03:11:22 +00:00
|
|
|
|
HGResult HGAPI HGImgProc_ImageAutoCrop(HGImage image, HGBool autoCrop, HGBool deskew, HGBool fillBlank, const HGImgAutoCropParam* param,
|
2022-05-03 10:25:52 +00:00
|
|
|
|
HGUInt destWidth, HGUInt destHeight, HGUInt destType, HGUInt destOrigin, HGImage* destImage)
|
|
|
|
|
{
|
|
|
|
|
if (NULL == image || NULL == destImage)
|
|
|
|
|
{
|
|
|
|
|
return HGBASE_ERR_INVALIDARG;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
HGImageInfo imgInfo;
|
|
|
|
|
HGBase_GetImageInfo(image, &imgInfo);
|
2022-06-18 02:32:32 +00:00
|
|
|
|
if (HGBASE_IMGTYPE_BINARY == imgInfo.type || HGBASE_IMGTYPE_RGB == imgInfo.type
|
|
|
|
|
|| HGBASE_IMGTYPE_RGBA == imgInfo.type || HGBASE_IMGTYPE_BGRA == imgInfo.type)
|
2022-05-03 10:25:52 +00:00
|
|
|
|
{
|
2022-05-26 11:01:38 +00:00
|
|
|
|
HGImage imageTmp = NULL;
|
2022-06-18 02:32:32 +00:00
|
|
|
|
HGResult ret = HGBase_CloneImage(image, HGBASE_IMGTYPE_BGR, 0, &imageTmp);
|
2022-05-26 11:01:38 +00:00
|
|
|
|
if (HGBASE_ERR_OK == ret)
|
|
|
|
|
{
|
|
|
|
|
if (0 == destType)
|
|
|
|
|
destType = imgInfo.type;
|
|
|
|
|
if (0 == destOrigin)
|
|
|
|
|
destOrigin = imgInfo.origin;
|
|
|
|
|
|
2022-06-14 07:05:22 +00:00
|
|
|
|
ret = HGImgProc_ImageAutoCrop(imageTmp, autoCrop, deskew, fillBlank, param,
|
2022-05-26 11:01:38 +00:00
|
|
|
|
destWidth, destHeight, destType, destOrigin, destImage);
|
|
|
|
|
HGBase_DestroyImage(imageTmp);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return ret;
|
2022-05-03 10:25:52 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
bool convex = true;
|
2022-05-12 03:11:22 +00:00
|
|
|
|
bool fillColor = false;
|
2022-05-03 10:25:52 +00:00
|
|
|
|
double threshold = 40.0;
|
|
|
|
|
int noise = 8;
|
|
|
|
|
int indent = 5;
|
2022-05-12 03:11:22 +00:00
|
|
|
|
bool normalCrop = false;
|
|
|
|
|
bool dispersion = true;
|
2022-05-03 10:25:52 +00:00
|
|
|
|
|
|
|
|
|
if (NULL != param)
|
|
|
|
|
{
|
2022-05-12 03:11:22 +00:00
|
|
|
|
convex = (bool)param->convex;
|
|
|
|
|
fillColor = (bool)param->fillColor;
|
|
|
|
|
threshold = param->threshold;
|
|
|
|
|
noise = param->noise;
|
|
|
|
|
indent = param->indent;
|
|
|
|
|
normalCrop = (bool)param->normalCrop;
|
|
|
|
|
dispersion = (bool)param->dispersion;
|
2022-05-03 10:25:52 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
HGByte* data = NULL;
|
|
|
|
|
HGBase_GetImageData(image, &data);
|
|
|
|
|
|
|
|
|
|
HGImageRoi roi;
|
|
|
|
|
HGBase_GetImageROI(image, &roi);
|
|
|
|
|
HGUInt roiWidth = roi.right - roi.left;
|
|
|
|
|
HGUInt roiHeight = roi.bottom - roi.top;
|
|
|
|
|
|
|
|
|
|
uint32_t channels = 1;
|
2022-06-18 02:32:32 +00:00
|
|
|
|
if (HGBASE_IMGTYPE_BGR == imgInfo.type)
|
2022-05-03 10:25:52 +00:00
|
|
|
|
channels = 3;
|
|
|
|
|
|
|
|
|
|
uint8_t* p = data + roi.top * imgInfo.widthStep + roi.left * channels;
|
2022-06-14 09:06:19 +00:00
|
|
|
|
if (HGBASE_IMGORIGIN_BOTTOM == imgInfo.origin)
|
|
|
|
|
p = data + (imgInfo.height - roi.bottom) * imgInfo.widthStep + roi.left * channels;
|
|
|
|
|
|
2022-05-12 03:11:22 +00:00
|
|
|
|
cv::Mat img(roiHeight, roiWidth, CV_8UC(channels), p, imgInfo.widthStep);
|
|
|
|
|
|
|
|
|
|
cv::Mat destImg;
|
|
|
|
|
autoCrop_desaskew_fillBlank(img, destImg, autoCrop, deskew, fillBlank, destWidth, destHeight,
|
|
|
|
|
convex, fillColor, threshold, noise, indent, normalCrop, dispersion);
|
2022-05-03 10:25:52 +00:00
|
|
|
|
if (destImg.empty())
|
|
|
|
|
{
|
|
|
|
|
return HGIMGPROC_ERR_FAIL;
|
|
|
|
|
}
|
|
|
|
|
|
2022-05-12 03:11:22 +00:00
|
|
|
|
HGImageInfo newImgInfo;
|
|
|
|
|
newImgInfo.width = (HGUInt)destImg.cols;
|
|
|
|
|
newImgInfo.height = (HGUInt)destImg.rows;
|
|
|
|
|
newImgInfo.type = imgInfo.type;
|
|
|
|
|
newImgInfo.widthStep = (HGUInt)destImg.step;
|
|
|
|
|
newImgInfo.origin = imgInfo.origin;
|
2022-05-26 11:01:38 +00:00
|
|
|
|
|
|
|
|
|
if (0 == destType)
|
|
|
|
|
destType = imgInfo.type;
|
|
|
|
|
if (0 == destOrigin)
|
|
|
|
|
destOrigin = imgInfo.origin;
|
|
|
|
|
|
2022-05-12 03:11:22 +00:00
|
|
|
|
return HGBase_CreateImageFromData(destImg.data, &newImgInfo, NULL, destType, destOrigin, destImage);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
HGResult HGAPI HGImgProc_ImageBlankCheck(HGImage image, const HGImgBlankCheckParam* param, HGBool* blank)
|
|
|
|
|
{
|
|
|
|
|
if (NULL == image || NULL == blank)
|
2022-05-03 10:25:52 +00:00
|
|
|
|
{
|
2022-05-12 03:11:22 +00:00
|
|
|
|
return HGBASE_ERR_INVALIDARG;
|
2022-05-03 10:25:52 +00:00
|
|
|
|
}
|
|
|
|
|
|
2022-05-12 03:11:22 +00:00
|
|
|
|
HGImageInfo imgInfo;
|
|
|
|
|
HGBase_GetImageInfo(image, &imgInfo);
|
2022-06-18 02:32:32 +00:00
|
|
|
|
if (HGBASE_IMGTYPE_BINARY == imgInfo.type || HGBASE_IMGTYPE_RGB == imgInfo.type
|
|
|
|
|
|| HGBASE_IMGTYPE_RGBA == imgInfo.type || HGBASE_IMGTYPE_BGRA == imgInfo.type)
|
2022-05-03 10:25:52 +00:00
|
|
|
|
{
|
2022-05-26 11:01:38 +00:00
|
|
|
|
HGImage imageTmp = NULL;
|
2022-06-18 02:32:32 +00:00
|
|
|
|
HGResult ret = HGBase_CloneImage(image, HGBASE_IMGTYPE_BGR, 0, &imageTmp);
|
2022-05-26 11:01:38 +00:00
|
|
|
|
if (HGBASE_ERR_OK == ret)
|
|
|
|
|
{
|
|
|
|
|
ret = HGImgProc_ImageBlankCheck(imageTmp, param, blank);
|
|
|
|
|
HGBase_DestroyImage(imageTmp);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return ret;
|
2022-05-03 10:25:52 +00:00
|
|
|
|
}
|
|
|
|
|
|
2022-05-12 03:11:22 +00:00
|
|
|
|
HGDouble threshold = 40.0;
|
|
|
|
|
HGInt edge = 150;
|
|
|
|
|
HGInt blockSize = 10;
|
|
|
|
|
HGDouble devTh = 50.0;
|
|
|
|
|
HGDouble meanTh = 200.0;
|
|
|
|
|
|
|
|
|
|
if (NULL != param)
|
|
|
|
|
{
|
|
|
|
|
threshold = param->threshold;
|
|
|
|
|
edge = param->edge;
|
|
|
|
|
blockSize = param->blockSize;
|
|
|
|
|
devTh = param->devTh;
|
|
|
|
|
meanTh = param->meanTh;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
HGByte* data = NULL;
|
|
|
|
|
HGBase_GetImageData(image, &data);
|
|
|
|
|
|
|
|
|
|
HGImageRoi roi;
|
|
|
|
|
HGBase_GetImageROI(image, &roi);
|
|
|
|
|
HGUInt roiWidth = roi.right - roi.left;
|
|
|
|
|
HGUInt roiHeight = roi.bottom - roi.top;
|
|
|
|
|
|
|
|
|
|
uint32_t channels = 1;
|
2022-06-18 02:32:32 +00:00
|
|
|
|
if (HGBASE_IMGTYPE_BGR == imgInfo.type)
|
2022-05-12 03:11:22 +00:00
|
|
|
|
channels = 3;
|
|
|
|
|
|
|
|
|
|
uint8_t* p = data + roi.top * imgInfo.widthStep + roi.left * channels;
|
2022-06-14 09:06:19 +00:00
|
|
|
|
if (HGBASE_IMGORIGIN_BOTTOM == imgInfo.origin)
|
|
|
|
|
p = data + (imgInfo.height - roi.bottom) * imgInfo.widthStep + roi.left * channels;
|
|
|
|
|
|
2022-05-12 03:11:22 +00:00
|
|
|
|
cv::Mat img(roiHeight, roiWidth, CV_8UC(channels), p, imgInfo.widthStep);
|
|
|
|
|
|
|
|
|
|
bool ret = CImageApplyDiscardBlank::apply(img, threshold, edge, blockSize, devTh, meanTh);
|
|
|
|
|
*blank = ret ? HGTRUE : HGFALSE;
|
|
|
|
|
return HGBASE_ERR_OK;
|
2022-06-13 11:56:43 +00:00
|
|
|
|
}
|
|
|
|
|
|
2022-06-15 01:50:21 +00:00
|
|
|
|
HGResult HGAPI HGImgProc_ImageDrawLine(HGImage image, HGInt x1, HGInt y1, HGInt x2, HGInt y2,
|
|
|
|
|
HGColor color, HGUInt width, HGUInt type)
|
2022-06-13 11:56:43 +00:00
|
|
|
|
{
|
2022-06-15 01:50:21 +00:00
|
|
|
|
if (NULL == image || 0 == width || type < HGIMGPROC_LINETYPE_SOLID || type > HGIMGPROC_LINETYPE_DASH)
|
2022-06-14 09:06:19 +00:00
|
|
|
|
{
|
|
|
|
|
return HGBASE_ERR_INVALIDARG;
|
|
|
|
|
}
|
2022-06-13 11:56:43 +00:00
|
|
|
|
|
2022-06-14 09:06:19 +00:00
|
|
|
|
HGImageInfo imgInfo;
|
|
|
|
|
HGBase_GetImageInfo(image, &imgInfo);
|
2022-06-15 01:50:21 +00:00
|
|
|
|
if (HGBASE_IMGTYPE_BINARY == imgInfo.type || HGBASE_IMGTYPE_GRAY == imgInfo.type)
|
2022-06-13 11:56:43 +00:00
|
|
|
|
{
|
2022-06-14 09:06:19 +00:00
|
|
|
|
HGImage imageTmp = NULL;
|
2022-06-18 02:32:32 +00:00
|
|
|
|
HGResult ret = HGBase_CloneImage(image, HGBASE_IMGTYPE_BGR, 0, &imageTmp);
|
2022-06-14 09:06:19 +00:00
|
|
|
|
if (HGBASE_ERR_OK == ret)
|
|
|
|
|
{
|
2022-06-15 01:50:21 +00:00
|
|
|
|
ret = HGImgProc_ImageDrawLine(imageTmp, x1, y1, x2, y2, color, width, type);
|
2022-06-14 09:06:19 +00:00
|
|
|
|
if (HGBASE_ERR_OK == ret)
|
|
|
|
|
{
|
|
|
|
|
ret = HGBase_CopyImage(imageTmp, image);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
HGBase_DestroyImage(imageTmp);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return ret;
|
2022-06-13 11:56:43 +00:00
|
|
|
|
}
|
|
|
|
|
|
2022-06-15 01:50:21 +00:00
|
|
|
|
HGByte* data = NULL;
|
|
|
|
|
HGBase_GetImageData(image, &data);
|
|
|
|
|
|
|
|
|
|
HGImageRoi roi;
|
|
|
|
|
HGBase_GetImageROI(image, &roi);
|
|
|
|
|
HGUInt roiWidth = roi.right - roi.left;
|
|
|
|
|
HGUInt roiHeight = roi.bottom - roi.top;
|
|
|
|
|
|
2022-06-14 09:06:19 +00:00
|
|
|
|
uint32_t channels = 3;
|
2022-06-15 01:50:21 +00:00
|
|
|
|
if (HGBASE_IMGTYPE_BGRA == imgInfo.type || HGBASE_IMGTYPE_RGBA == imgInfo.type)
|
2022-06-14 09:06:19 +00:00
|
|
|
|
channels = 4;
|
2022-06-13 11:56:43 +00:00
|
|
|
|
|
2022-06-14 09:06:19 +00:00
|
|
|
|
uint8_t* p = data + roi.top * imgInfo.widthStep + roi.left * channels;
|
|
|
|
|
if (HGBASE_IMGORIGIN_BOTTOM == imgInfo.origin)
|
|
|
|
|
p = data + (imgInfo.height - roi.bottom) * imgInfo.widthStep + roi.left * channels;
|
|
|
|
|
|
|
|
|
|
IplImage* pImg = cvCreateImageHeader(cvSize(roiWidth, roiHeight), IPL_DEPTH_8U, channels);
|
|
|
|
|
cvSetData(pImg, p, imgInfo.widthStep);
|
|
|
|
|
|
|
|
|
|
if (HGBASE_IMGORIGIN_BOTTOM == imgInfo.origin)
|
|
|
|
|
{
|
|
|
|
|
y1 = roiHeight - y1 - 1;
|
|
|
|
|
y2 = roiHeight - y2 - 1;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
HGUInt r = HG_GETCOLOR_R(color);
|
|
|
|
|
HGUInt g = HG_GETCOLOR_G(color);
|
|
|
|
|
HGUInt b = HG_GETCOLOR_B(color);
|
2022-06-18 02:32:32 +00:00
|
|
|
|
if (HGBASE_IMGTYPE_RGB == imgInfo.type || HGBASE_IMGTYPE_RGBA == imgInfo.type)
|
2022-06-13 11:56:43 +00:00
|
|
|
|
{
|
2022-06-14 09:06:19 +00:00
|
|
|
|
r = HG_GETCOLOR_B(color);
|
|
|
|
|
g = HG_GETCOLOR_G(color);
|
|
|
|
|
b = HG_GETCOLOR_R(color);
|
2022-06-13 11:56:43 +00:00
|
|
|
|
}
|
|
|
|
|
|
2022-06-18 02:32:32 +00:00
|
|
|
|
cvLine(pImg, cvPoint(x1, y1), cvPoint(x2, y2), cvScalar(b, g, r), width);
|
2022-06-14 09:06:19 +00:00
|
|
|
|
cvReleaseImageHeader(&pImg);
|
|
|
|
|
return HGBASE_ERR_OK;
|
2022-06-13 11:56:43 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
HGResult HGAPI HGImgProc_AddImageWatermark(HGImage image, const HGChar* text, HGColor color, HGUInt posType,
|
|
|
|
|
HGInt locationX, HGInt locationY, const HGImgWatermarkFontParam *fontParam)
|
|
|
|
|
{
|
|
|
|
|
if (NULL == image || NULL == text || '\0' == *text || posType < HGIMGPROC_WMPOSTYPE_LEFT
|
|
|
|
|
|| posType > HGIMGPROC_WMPOSTYPE_LOCATION)
|
|
|
|
|
{
|
|
|
|
|
return HGBASE_ERR_INVALIDARG;
|
|
|
|
|
}
|
|
|
|
|
|
2022-06-14 09:06:19 +00:00
|
|
|
|
std::string fontName = "宋体";
|
|
|
|
|
HGUInt fontSize = 20;
|
|
|
|
|
HGBool bold = HGFALSE;
|
|
|
|
|
HGBool underline = HGFALSE;
|
|
|
|
|
HGBool italic = HGFALSE;
|
|
|
|
|
HGBool strikeout = HGFALSE;
|
2022-06-13 11:56:43 +00:00
|
|
|
|
|
2022-06-14 09:06:19 +00:00
|
|
|
|
if (NULL != fontParam)
|
2022-06-13 11:56:43 +00:00
|
|
|
|
{
|
2022-06-14 09:06:19 +00:00
|
|
|
|
if (0 == fontParam->fontSize)
|
2022-06-13 11:56:43 +00:00
|
|
|
|
{
|
2022-06-14 09:06:19 +00:00
|
|
|
|
return HGBASE_ERR_INVALIDARG;
|
2022-06-13 11:56:43 +00:00
|
|
|
|
}
|
|
|
|
|
|
2022-06-14 09:06:19 +00:00
|
|
|
|
fontName = fontParam->foneName;
|
|
|
|
|
fontSize = fontParam->fontSize;
|
|
|
|
|
bold = fontParam->bold;
|
|
|
|
|
underline = fontParam->underline;
|
|
|
|
|
italic = fontParam->italic;
|
|
|
|
|
strikeout = fontParam->strikeout;
|
2022-06-13 11:56:43 +00:00
|
|
|
|
}
|
|
|
|
|
|
2022-06-14 09:06:19 +00:00
|
|
|
|
HGChar moduleName[256];
|
|
|
|
|
HGBase_GetModuleName((void *)HGImgProc_AddImageWatermark, moduleName, 256);
|
|
|
|
|
HGChar modulePath[256];
|
|
|
|
|
HGBase_GetFilePath(moduleName, modulePath, 256);
|
|
|
|
|
HGChar fontPath[256];
|
|
|
|
|
sprintf(fontPath, "%s%s.ttf", modulePath, fontName.c_str());
|
2022-06-13 11:56:43 +00:00
|
|
|
|
|
2022-06-14 09:06:19 +00:00
|
|
|
|
CvxText cvxText;
|
|
|
|
|
HGResult ret = cvxText.Create(fontPath);
|
|
|
|
|
if (HGBASE_ERR_OK != ret)
|
2022-06-13 11:56:43 +00:00
|
|
|
|
{
|
2022-06-14 09:06:19 +00:00
|
|
|
|
return ret;
|
2022-06-13 11:56:43 +00:00
|
|
|
|
}
|
|
|
|
|
|
2022-06-14 09:06:19 +00:00
|
|
|
|
ret = cvxText.DrawString(image, text, color, posType, locationX, locationY, fontSize, bold, underline, italic, strikeout);
|
|
|
|
|
return ret;
|
2022-06-14 07:05:22 +00:00
|
|
|
|
}
|
2022-06-18 02:32:32 +00:00
|
|
|
|
|
2022-06-30 01:28:30 +00:00
|
|
|
|
#if 0
|
2022-06-18 02:32:32 +00:00
|
|
|
|
HGResult HGAPI HGImgProc_ImageBinarization(HGImage image, HGImage destImage, HGUInt thresholdType,
|
|
|
|
|
HGInt threshold, HGInt blockSize, HGInt constant)
|
|
|
|
|
{
|
|
|
|
|
if (NULL == image || thresholdType < HGIMGPROC_THRESHTYPE_BINARY || thresholdType > HGIMGPROC_THRESHTYPE_ERROR_DIFFUSION)
|
|
|
|
|
{
|
|
|
|
|
return HGBASE_ERR_INVALIDARG;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
CImageApplyBWBinaray::ThresholdType thresholdType2 = CImageApplyBWBinaray::ThresholdType::THRESH_BINARY;
|
|
|
|
|
if (HGIMGPROC_THRESHTYPE_OTSU == thresholdType)
|
|
|
|
|
thresholdType2 = CImageApplyBWBinaray::ThresholdType::THRESH_OTSU;
|
|
|
|
|
else if (HGIMGPROC_THRESHTYPE_ADAPTIVE_GAUSSIAN == thresholdType)
|
|
|
|
|
thresholdType2 = CImageApplyBWBinaray::ThresholdType::ADAPTIVE_GAUSSIAN;
|
|
|
|
|
else if (HGIMGPROC_THRESHTYPE_ADAPTIVE_MEAN == thresholdType)
|
|
|
|
|
thresholdType2 = CImageApplyBWBinaray::ThresholdType::ADAPTIVE_MEAN;
|
|
|
|
|
else if (HGIMGPROC_THRESHTYPE_ERROR_DIFFUSION == thresholdType)
|
|
|
|
|
thresholdType2 = CImageApplyBWBinaray::ThresholdType::ERROR_DIFFUSION;
|
|
|
|
|
|
|
|
|
|
HGImageInfo imgInfo;
|
|
|
|
|
HGBase_GetImageInfo(image, &imgInfo);
|
|
|
|
|
|
|
|
|
|
HGByte* data = NULL;
|
|
|
|
|
HGBase_GetImageData(image, &data);
|
|
|
|
|
|
|
|
|
|
HGImageRoi roi;
|
|
|
|
|
HGBase_GetImageROI(image, &roi);
|
|
|
|
|
HGUInt roiWidth = roi.right - roi.left;
|
|
|
|
|
HGUInt roiHeight = roi.bottom - roi.top;
|
|
|
|
|
|
|
|
|
|
if (NULL == destImage || image == destImage)
|
|
|
|
|
{
|
2022-06-18 07:05:04 +00:00
|
|
|
|
if (HGBASE_IMGTYPE_BINARY == imgInfo.type)
|
|
|
|
|
{
|
|
|
|
|
return HGBASE_ERR_OK;
|
|
|
|
|
}
|
|
|
|
|
else if (HGBASE_IMGTYPE_GRAY != imgInfo.type)
|
2022-06-18 02:32:32 +00:00
|
|
|
|
{
|
|
|
|
|
HGImage imageTmp = NULL;
|
|
|
|
|
HGResult ret = HGBase_CloneImage(image, HGBASE_IMGTYPE_GRAY, 0, &imageTmp);
|
|
|
|
|
if (HGBASE_ERR_OK == ret)
|
|
|
|
|
{
|
|
|
|
|
ret = HGImgProc_ImageBinarization(imageTmp, imageTmp, thresholdType, threshold, blockSize, constant);
|
|
|
|
|
if (HGBASE_ERR_OK == ret)
|
|
|
|
|
{
|
|
|
|
|
ret = HGBase_CopyImage(imageTmp, image);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
HGBase_DestroyImage(imageTmp);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
uint8_t* p = data + roi.top * imgInfo.widthStep + roi.left;
|
|
|
|
|
if (HGBASE_IMGORIGIN_BOTTOM == imgInfo.origin)
|
|
|
|
|
p = data + (imgInfo.height - roi.bottom) * imgInfo.widthStep + roi.left;
|
|
|
|
|
|
|
|
|
|
cv::Mat img(roiHeight, roiWidth, CV_8UC(1), p, imgInfo.widthStep);
|
|
|
|
|
CImageApplyBWBinaray imgApply(thresholdType2, threshold, blockSize, constant);
|
|
|
|
|
imgApply.apply(img, 0);
|
|
|
|
|
if (img.data != p)
|
|
|
|
|
{
|
|
|
|
|
for (HGUInt i = 0; i < roiHeight; ++i)
|
|
|
|
|
{
|
|
|
|
|
memcpy(p + i * imgInfo.widthStep, img.data + i * img.step, roiWidth);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
HGImageInfo destImgInfo;
|
|
|
|
|
HGBase_GetImageInfo(destImage, &destImgInfo);
|
|
|
|
|
if (imgInfo.type != destImgInfo.type)
|
|
|
|
|
{
|
|
|
|
|
return HGBASE_ERR_INVALIDDATA;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
HGByte* destData = NULL;
|
|
|
|
|
HGBase_GetImageData(destImage, &destData);
|
|
|
|
|
|
|
|
|
|
HGImageRoi destRoi;
|
|
|
|
|
HGBase_GetImageROI(destImage, &destRoi);
|
|
|
|
|
HGUInt destRoiWidth = destRoi.right - destRoi.left;
|
|
|
|
|
HGUInt destRoiHeight = destRoi.bottom - destRoi.top;
|
|
|
|
|
|
|
|
|
|
if (roiWidth != destRoiWidth || roiHeight != destRoiHeight)
|
|
|
|
|
{
|
|
|
|
|
return HGBASE_ERR_INVALIDDATA;
|
|
|
|
|
}
|
|
|
|
|
|
2022-06-18 07:05:04 +00:00
|
|
|
|
if (HGBASE_IMGTYPE_BINARY == imgInfo.type)
|
|
|
|
|
{
|
|
|
|
|
return HGBase_CopyImage(image, destImage);
|
|
|
|
|
}
|
|
|
|
|
else if (HGBASE_IMGTYPE_GRAY != imgInfo.type)
|
2022-06-18 02:32:32 +00:00
|
|
|
|
{
|
|
|
|
|
HGImage imageTmp = NULL;
|
|
|
|
|
HGResult ret = HGBase_CloneImage(image, HGBASE_IMGTYPE_GRAY, 0, &imageTmp);
|
|
|
|
|
if (HGBASE_ERR_OK == ret)
|
|
|
|
|
{
|
|
|
|
|
ret = HGImgProc_ImageBinarization(imageTmp, imageTmp, thresholdType, threshold, blockSize, constant);
|
|
|
|
|
if (HGBASE_ERR_OK == ret)
|
|
|
|
|
{
|
|
|
|
|
ret = HGBase_CopyImage(imageTmp, destImage);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
HGBase_DestroyImage(imageTmp);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
HGBase_CopyImage(image, destImage);
|
|
|
|
|
|
|
|
|
|
uint8_t* pDest = destData + destRoi.top * destImgInfo.widthStep + destRoi.left;
|
|
|
|
|
if (HGBASE_IMGORIGIN_BOTTOM == destImgInfo.origin)
|
|
|
|
|
pDest = destData + (destImgInfo.height - destRoi.bottom) * destImgInfo.widthStep + destRoi.left;
|
|
|
|
|
|
|
|
|
|
cv::Mat destImg(destRoiHeight, destRoiWidth, CV_8UC(1), pDest, destImgInfo.widthStep);
|
|
|
|
|
CImageApplyBWBinaray imgApply(thresholdType2, threshold, blockSize, constant);
|
|
|
|
|
imgApply.apply(destImg, 0);
|
|
|
|
|
if (destImg.data != pDest)
|
|
|
|
|
{
|
|
|
|
|
for (HGUInt i = 0; i < destRoiHeight; ++i)
|
|
|
|
|
{
|
|
|
|
|
memcpy(pDest + i * destImgInfo.widthStep, destImg.data + i * destImg.step, destRoiWidth);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return HGBASE_ERR_OK;
|
|
|
|
|
}
|
2022-06-18 07:05:04 +00:00
|
|
|
|
|
|
|
|
|
HGResult HGAPI HGImgProc_ImageExtractChannel(HGImage image, HGImage destImage, HGUInt channelType)
|
|
|
|
|
{
|
|
|
|
|
if (NULL == image || channelType < HGIMGPROC_CHANNELTYPE_RED || channelType > HGIMGPROC_CHANNELTYPE_EXCEPT_BLUE)
|
|
|
|
|
{
|
|
|
|
|
return HGBASE_ERR_INVALIDARG;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
CImageApplyChannel::Channel channelType2 = CImageApplyChannel::Red;
|
|
|
|
|
if (HGIMGPROC_CHANNELTYPE_GREEN == channelType)
|
|
|
|
|
channelType2 = CImageApplyChannel::Green;
|
|
|
|
|
else if (HGIMGPROC_CHANNELTYPE_BLUE == channelType)
|
|
|
|
|
channelType2 = CImageApplyChannel::Blue;
|
|
|
|
|
else if (HGIMGPROC_CHANNELTYPE_ALL == channelType)
|
|
|
|
|
channelType2 = CImageApplyChannel::All;
|
|
|
|
|
else if (HGIMGPROC_CHANNELTYPE_INVALID == channelType)
|
|
|
|
|
channelType2 = CImageApplyChannel::Invalid;
|
|
|
|
|
else if (HGIMGPROC_CHANNELTYPE_EXCEPT_RED == channelType)
|
|
|
|
|
channelType2 = CImageApplyChannel::Except_Red;
|
|
|
|
|
else if (HGIMGPROC_CHANNELTYPE_EXCEPT_GREEN == channelType)
|
|
|
|
|
channelType2 = CImageApplyChannel::Except_Green;
|
|
|
|
|
else if (HGIMGPROC_CHANNELTYPE_EXCEPT_BLUE == channelType)
|
|
|
|
|
channelType2 = CImageApplyChannel::Except_Blue;
|
|
|
|
|
|
|
|
|
|
HGImageInfo imgInfo;
|
|
|
|
|
HGBase_GetImageInfo(image, &imgInfo);
|
|
|
|
|
|
|
|
|
|
HGByte* data = NULL;
|
|
|
|
|
HGBase_GetImageData(image, &data);
|
|
|
|
|
|
|
|
|
|
HGImageRoi roi;
|
|
|
|
|
HGBase_GetImageROI(image, &roi);
|
|
|
|
|
HGUInt roiWidth = roi.right - roi.left;
|
|
|
|
|
HGUInt roiHeight = roi.bottom - roi.top;
|
|
|
|
|
|
|
|
|
|
if (NULL == destImage)
|
|
|
|
|
{
|
|
|
|
|
destImage = image;
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
HGImageRoi destRoi;
|
|
|
|
|
HGBase_GetImageROI(destImage, &destRoi);
|
|
|
|
|
HGUInt destRoiWidth = destRoi.right - destRoi.left;
|
|
|
|
|
HGUInt destRoiHeight = destRoi.bottom - destRoi.top;
|
|
|
|
|
|
|
|
|
|
if (roiWidth != destRoiWidth || roiHeight != destRoiHeight)
|
|
|
|
|
{
|
|
|
|
|
return HGBASE_ERR_INVALIDDATA;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (HGBASE_IMGTYPE_BGR != imgInfo.type)
|
|
|
|
|
{
|
|
|
|
|
HGImage imageTmp = NULL;
|
|
|
|
|
HGResult ret = HGBase_CloneImage(image, HGBASE_IMGTYPE_BGR, 0, &imageTmp);
|
|
|
|
|
if (HGBASE_ERR_OK == ret)
|
|
|
|
|
{
|
|
|
|
|
ret = HGImgProc_ImageExtractChannel(imageTmp, destImage, channelType);
|
|
|
|
|
HGBase_DestroyImage(imageTmp);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
uint8_t* p = data + roi.top * imgInfo.widthStep + roi.left * 3;
|
|
|
|
|
if (HGBASE_IMGORIGIN_BOTTOM == imgInfo.origin)
|
|
|
|
|
p = data + (imgInfo.height - roi.bottom) * imgInfo.widthStep + roi.left * 3;
|
|
|
|
|
|
|
|
|
|
cv::Mat img(roiHeight, roiWidth, CV_8UC(3), p, imgInfo.widthStep);
|
|
|
|
|
CImageApplyChannel imgApply(channelType2);
|
|
|
|
|
imgApply.apply(img, 0);
|
|
|
|
|
assert(img.data != p);
|
|
|
|
|
|
|
|
|
|
HGImageInfo newImgInfo;
|
|
|
|
|
newImgInfo.width = (HGUInt)img.cols;
|
|
|
|
|
newImgInfo.height = (HGUInt)img.rows;
|
|
|
|
|
newImgInfo.type = HGBASE_IMGTYPE_GRAY;
|
|
|
|
|
newImgInfo.widthStep = (HGUInt)img.step;
|
|
|
|
|
newImgInfo.origin = imgInfo.origin;
|
|
|
|
|
|
|
|
|
|
HGImage newImg = NULL;
|
|
|
|
|
HGResult ret = HGBase_CreateImageWithData(img.data, &newImgInfo, &newImg);
|
|
|
|
|
if (NULL != newImg)
|
|
|
|
|
{
|
|
|
|
|
ret = HGBase_CopyImage(newImg, destImage);
|
|
|
|
|
HGBase_DestroyImage(newImg);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
HGResult HGAPI HGImgProc_ImageColorRecognition(HGImage image, HGUInt* colorType)
|
|
|
|
|
{
|
|
|
|
|
if (NULL == image || NULL == colorType)
|
|
|
|
|
{
|
|
|
|
|
return HGBASE_ERR_INVALIDARG;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
HGImageInfo imgInfo;
|
|
|
|
|
HGBase_GetImageInfo(image, &imgInfo);
|
|
|
|
|
if (HGBASE_IMGTYPE_BINARY == imgInfo.type)
|
|
|
|
|
{
|
|
|
|
|
*colorType = HGIMGPROC_COLORTYPE_BINARY;
|
|
|
|
|
return HGBASE_ERR_OK;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
HGByte* data = NULL;
|
|
|
|
|
HGBase_GetImageData(image, &data);
|
|
|
|
|
|
|
|
|
|
HGImageRoi roi;
|
|
|
|
|
HGBase_GetImageROI(image, &roi);
|
|
|
|
|
HGUInt roiWidth = roi.right - roi.left;
|
|
|
|
|
HGUInt roiHeight = roi.bottom - roi.top;
|
|
|
|
|
|
|
|
|
|
uint32_t channels = 1;
|
|
|
|
|
if (HGBASE_IMGTYPE_BGR == imgInfo.type || HGBASE_IMGTYPE_RGB == imgInfo.type)
|
|
|
|
|
channels = 3;
|
|
|
|
|
else if (HGBASE_IMGTYPE_BGRA == imgInfo.type || HGBASE_IMGTYPE_RGBA == imgInfo.type)
|
|
|
|
|
channels = 4;
|
|
|
|
|
|
|
|
|
|
uint8_t* p = data + roi.top * imgInfo.widthStep + roi.left * channels;
|
|
|
|
|
if (HGBASE_IMGORIGIN_BOTTOM == imgInfo.origin)
|
|
|
|
|
p = data + (imgInfo.height - roi.bottom) * imgInfo.widthStep + roi.left * channels;
|
|
|
|
|
|
|
|
|
|
if (HGBASE_IMGTYPE_GRAY == imgInfo.type)
|
|
|
|
|
{
|
|
|
|
|
*colorType = HGIMGPROC_COLORTYPE_BINARY;
|
2022-10-24 14:48:17 +00:00
|
|
|
|
|
2022-06-18 07:05:04 +00:00
|
|
|
|
for (HGUInt h = 0; h < roiHeight; ++h)
|
|
|
|
|
{
|
|
|
|
|
for (HGUInt w = 0; w < roiWidth; ++w)
|
|
|
|
|
{
|
2022-06-20 03:06:18 +00:00
|
|
|
|
uint8_t *pData = p + imgInfo.widthStep * h + w * channels;
|
2022-06-18 07:05:04 +00:00
|
|
|
|
if (0 != *pData && 255 != *pData)
|
|
|
|
|
{
|
|
|
|
|
*colorType = HGIMGPROC_COLORTYPE_GRAY;
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
if (HGBASE_IMGTYPE_BGR != imgInfo.type)
|
|
|
|
|
{
|
|
|
|
|
HGImage imageTmp = NULL;
|
|
|
|
|
HGResult ret = HGBase_CloneImage(image, HGBASE_IMGTYPE_BGR, 0, &imageTmp);
|
|
|
|
|
if (HGBASE_ERR_OK == ret)
|
|
|
|
|
{
|
|
|
|
|
ret = HGImgProc_ImageColorRecognition(imageTmp, colorType);
|
|
|
|
|
HGBase_DestroyImage(imageTmp);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
2022-06-20 03:06:18 +00:00
|
|
|
|
cv::Mat img(roiHeight, roiWidth, CV_8UC(channels), p, imgInfo.widthStep);
|
2022-06-18 07:05:04 +00:00
|
|
|
|
CImageApplyColorRecognition imgApply(CImageApplyColorRecognition::AllColor);
|
|
|
|
|
imgApply.apply(img, 0);
|
|
|
|
|
|
|
|
|
|
*colorType = HGIMGPROC_COLORTYPE_COLOR;
|
|
|
|
|
CImageApplyColorRecognition::ColorType colorType2 = imgApply.getResult();
|
|
|
|
|
if (CImageApplyColorRecognition::Gray == colorType2)
|
|
|
|
|
*colorType = HGIMGPROC_COLORTYPE_GRAY;
|
|
|
|
|
else if (CImageApplyColorRecognition::Mono == colorType2)
|
|
|
|
|
*colorType = HGIMGPROC_COLORTYPE_BINARY;
|
|
|
|
|
}
|
2022-10-24 14:48:17 +00:00
|
|
|
|
|
2022-06-18 07:05:04 +00:00
|
|
|
|
return HGBASE_ERR_OK;
|
|
|
|
|
}
|
2022-06-18 09:59:25 +00:00
|
|
|
|
|
|
|
|
|
HGResult HGAPI HGImgProc_ImageDispersion(HGImage image, HGImage destImage)
|
|
|
|
|
{
|
|
|
|
|
if (NULL == image)
|
|
|
|
|
{
|
|
|
|
|
return HGBASE_ERR_INVALIDARG;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
HGImageInfo imgInfo;
|
|
|
|
|
HGBase_GetImageInfo(image, &imgInfo);
|
|
|
|
|
HGUInt type = imgInfo.type;
|
|
|
|
|
|
|
|
|
|
HGByte* data = NULL;
|
|
|
|
|
HGBase_GetImageData(image, &data);
|
|
|
|
|
|
|
|
|
|
HGImageRoi roi;
|
|
|
|
|
HGBase_GetImageROI(image, &roi);
|
|
|
|
|
HGUInt roiWidth = roi.right - roi.left;
|
|
|
|
|
HGUInt roiHeight = roi.bottom - roi.top;
|
|
|
|
|
|
|
|
|
|
if (NULL == destImage || image == destImage)
|
|
|
|
|
{
|
|
|
|
|
if (HGBASE_IMGTYPE_BGR != type)
|
|
|
|
|
{
|
|
|
|
|
HGImage imageTmp = NULL;
|
|
|
|
|
HGResult ret = HGBase_CloneImage(image, HGBASE_IMGTYPE_BGR, 0, &imageTmp);
|
|
|
|
|
if (HGBASE_ERR_OK == ret)
|
|
|
|
|
{
|
|
|
|
|
ret = HGImgProc_ImageDispersion(imageTmp, imageTmp);
|
|
|
|
|
if (HGBASE_ERR_OK == ret)
|
|
|
|
|
{
|
|
|
|
|
ret = HGBase_CopyImage(imageTmp, image);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
HGBase_DestroyImage(imageTmp);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
uint8_t* p = data + roi.top * imgInfo.widthStep + roi.left * 3;
|
|
|
|
|
if (HGBASE_IMGORIGIN_BOTTOM == imgInfo.origin)
|
|
|
|
|
p = data + (imgInfo.height - roi.bottom) * imgInfo.widthStep + roi.left * 3;
|
|
|
|
|
|
|
|
|
|
cv::Mat img(roiHeight, roiWidth, CV_8UC(3), p, imgInfo.widthStep);
|
|
|
|
|
CImageApplyDispersion imgApply;
|
|
|
|
|
imgApply.apply(img, 0);
|
|
|
|
|
assert(img.data == p);
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
HGImageInfo destImgInfo;
|
|
|
|
|
HGBase_GetImageInfo(destImage, &destImgInfo);
|
|
|
|
|
HGUInt destType = destImgInfo.type;
|
|
|
|
|
if (type != destType)
|
|
|
|
|
{
|
|
|
|
|
return HGBASE_ERR_INVALIDDATA;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
HGByte* destData = NULL;
|
|
|
|
|
HGBase_GetImageData(destImage, &destData);
|
|
|
|
|
|
|
|
|
|
HGImageRoi destRoi;
|
|
|
|
|
HGBase_GetImageROI(destImage, &destRoi);
|
|
|
|
|
HGUInt destRoiWidth = destRoi.right - destRoi.left;
|
|
|
|
|
HGUInt destRoiHeight = destRoi.bottom - destRoi.top;
|
|
|
|
|
|
|
|
|
|
if (roiWidth != destRoiWidth || roiHeight != destRoiHeight)
|
|
|
|
|
{
|
|
|
|
|
return HGBASE_ERR_INVALIDDATA;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (HGBASE_IMGTYPE_BGR != type)
|
|
|
|
|
{
|
|
|
|
|
HGImage imageTmp = NULL;
|
|
|
|
|
HGResult ret = HGBase_CloneImage(image, HGBASE_IMGTYPE_BGR, 0, &imageTmp);
|
|
|
|
|
if (HGBASE_ERR_OK == ret)
|
|
|
|
|
{
|
|
|
|
|
ret = HGImgProc_ImageDispersion(imageTmp, imageTmp);
|
|
|
|
|
if (HGBASE_ERR_OK == ret)
|
|
|
|
|
{
|
|
|
|
|
ret = HGBase_CopyImage(imageTmp, destImage);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
HGBase_DestroyImage(imageTmp);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
HGBase_CopyImage(image, destImage);
|
|
|
|
|
|
|
|
|
|
uint8_t* pDest = destData + destRoi.top * destImgInfo.widthStep + destRoi.left * 3;
|
|
|
|
|
if (HGBASE_IMGORIGIN_BOTTOM == destImgInfo.origin)
|
|
|
|
|
pDest = destData + (destImgInfo.height - destRoi.bottom) * destImgInfo.widthStep + destRoi.left * 3;
|
|
|
|
|
|
|
|
|
|
cv::Mat destImg(destRoiHeight, destRoiWidth, CV_8UC(3), pDest, destImgInfo.widthStep);
|
|
|
|
|
CImageApplyDispersion imgApply;
|
|
|
|
|
imgApply.apply(destImg, 0);
|
|
|
|
|
assert(destImg.data == pDest);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return HGBASE_ERR_OK;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
HGResult HGAPI HGImgProc_ImageFilter(HGImage image, HGImage destImage, HGUInt filterType, HGInt kSize)
|
|
|
|
|
{
|
|
|
|
|
if (NULL == image || filterType < HGIMGPROC_FILTERTYPE_SHARPEN || filterType > HGIMGPROC_FILTERTYPE_BRIGHTSHARP)
|
|
|
|
|
{
|
|
|
|
|
return HGBASE_ERR_INVALIDARG;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
CImageApplyFilter::FilterMode filterType2 = CImageApplyFilter::Sharpen;
|
|
|
|
|
if (HGIMGPROC_FILTERTYPE_SHARPEN_MORE == filterType)
|
|
|
|
|
filterType2 = CImageApplyFilter::Sharpen_More;
|
|
|
|
|
else if (HGIMGPROC_FILTERTYPE_AVERBLUR == filterType)
|
|
|
|
|
filterType2 = CImageApplyFilter::AverBlur;
|
|
|
|
|
else if (HGIMGPROC_FILTERTYPE_AVERBLUR_MORE == filterType)
|
|
|
|
|
filterType2 = CImageApplyFilter::AverBlur_More;
|
|
|
|
|
else if (HGIMGPROC_FILTERTYPE_BILATERALFILTER == filterType)
|
|
|
|
|
filterType2 = CImageApplyFilter::BilateralFilter;
|
|
|
|
|
else if (HGIMGPROC_FILTERTYPE_GAUSSIANBLUR == filterType)
|
|
|
|
|
filterType2 = CImageApplyFilter::GaussianBlur;
|
|
|
|
|
else if (HGIMGPROC_FILTERTYPE_BRIGHTSHARP == filterType)
|
|
|
|
|
filterType2 = CImageApplyFilter::BrightSharp;
|
|
|
|
|
|
|
|
|
|
HGImageInfo imgInfo;
|
|
|
|
|
HGBase_GetImageInfo(image, &imgInfo);
|
|
|
|
|
|
|
|
|
|
HGByte* data = NULL;
|
|
|
|
|
HGBase_GetImageData(image, &data);
|
|
|
|
|
|
|
|
|
|
HGImageRoi roi;
|
|
|
|
|
HGBase_GetImageROI(image, &roi);
|
|
|
|
|
HGUInt roiWidth = roi.right - roi.left;
|
|
|
|
|
HGUInt roiHeight = roi.bottom - roi.top;
|
|
|
|
|
|
|
|
|
|
uint32_t channels = 1;
|
|
|
|
|
if (HGBASE_IMGTYPE_BGR == imgInfo.type || HGBASE_IMGTYPE_RGB == imgInfo.type)
|
|
|
|
|
channels = 3;
|
|
|
|
|
else if (HGBASE_IMGTYPE_BGRA == imgInfo.type || HGBASE_IMGTYPE_RGBA == imgInfo.type)
|
|
|
|
|
channels = 4;
|
|
|
|
|
|
|
|
|
|
if (NULL == destImage || image == destImage)
|
|
|
|
|
{
|
|
|
|
|
if (HGBASE_IMGTYPE_BINARY == imgInfo.type || HGBASE_IMGTYPE_RGBA == imgInfo.type
|
|
|
|
|
|| HGBASE_IMGTYPE_BGRA == imgInfo.type)
|
|
|
|
|
{
|
|
|
|
|
HGImage imageTmp = NULL;
|
|
|
|
|
HGResult ret = HGBase_CloneImage(image, HGBASE_IMGTYPE_BGR, 0, &imageTmp);
|
|
|
|
|
if (HGBASE_ERR_OK == ret)
|
|
|
|
|
{
|
|
|
|
|
ret = HGImgProc_ImageFilter(imageTmp, imageTmp, filterType, kSize);
|
|
|
|
|
if (HGBASE_ERR_OK == ret)
|
|
|
|
|
{
|
|
|
|
|
ret = HGBase_CopyImage(imageTmp, image);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
HGBase_DestroyImage(imageTmp);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
uint8_t* p = data + roi.top * imgInfo.widthStep + roi.left * channels;
|
|
|
|
|
if (HGBASE_IMGORIGIN_BOTTOM == imgInfo.origin)
|
|
|
|
|
p = data + (imgInfo.height - roi.bottom) * imgInfo.widthStep + roi.left * channels;
|
|
|
|
|
|
|
|
|
|
cv::Mat img(roiHeight, roiWidth, CV_8UC(channels), p, imgInfo.widthStep);
|
|
|
|
|
CImageApplyFilter imgApply(filterType2, kSize);
|
|
|
|
|
imgApply.apply(img, 0);
|
|
|
|
|
if (img.data != p)
|
|
|
|
|
{
|
|
|
|
|
for (HGUInt i = 0; i < roiHeight; ++i)
|
|
|
|
|
{
|
2022-06-20 03:06:18 +00:00
|
|
|
|
memcpy(p + i * imgInfo.widthStep, img.data + i * img.step, roiWidth * channels);
|
2022-06-18 09:59:25 +00:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
HGImageInfo destImgInfo;
|
|
|
|
|
HGBase_GetImageInfo(destImage, &destImgInfo);
|
|
|
|
|
if (imgInfo.type != destImgInfo.type)
|
|
|
|
|
{
|
|
|
|
|
return HGBASE_ERR_INVALIDDATA;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
HGByte* destData = NULL;
|
|
|
|
|
HGBase_GetImageData(destImage, &destData);
|
|
|
|
|
|
|
|
|
|
HGImageRoi destRoi;
|
|
|
|
|
HGBase_GetImageROI(destImage, &destRoi);
|
|
|
|
|
HGUInt destRoiWidth = destRoi.right - destRoi.left;
|
|
|
|
|
HGUInt destRoiHeight = destRoi.bottom - destRoi.top;
|
|
|
|
|
|
|
|
|
|
if (roiWidth != destRoiWidth || roiHeight != destRoiHeight)
|
|
|
|
|
{
|
|
|
|
|
return HGBASE_ERR_INVALIDDATA;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (HGBASE_IMGTYPE_BINARY == imgInfo.type || HGBASE_IMGTYPE_RGBA == imgInfo.type
|
|
|
|
|
|| HGBASE_IMGTYPE_BGRA == imgInfo.type)
|
|
|
|
|
{
|
|
|
|
|
HGImage imageTmp = NULL;
|
|
|
|
|
HGResult ret = HGBase_CloneImage(image, HGBASE_IMGTYPE_BGR, 0, &imageTmp);
|
|
|
|
|
if (HGBASE_ERR_OK == ret)
|
|
|
|
|
{
|
|
|
|
|
ret = HGImgProc_ImageFilter(imageTmp, imageTmp, filterType, kSize);
|
|
|
|
|
if (HGBASE_ERR_OK == ret)
|
|
|
|
|
{
|
|
|
|
|
ret = HGBase_CopyImage(imageTmp, destImage);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
HGBase_DestroyImage(imageTmp);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
HGBase_CopyImage(image, destImage);
|
|
|
|
|
|
|
|
|
|
uint8_t* pDest = destData + destRoi.top * destImgInfo.widthStep + destRoi.left * channels;
|
|
|
|
|
if (HGBASE_IMGORIGIN_BOTTOM == destImgInfo.origin)
|
|
|
|
|
pDest = destData + (destImgInfo.height - destRoi.bottom) * destImgInfo.widthStep + destRoi.left * channels;
|
|
|
|
|
|
|
|
|
|
cv::Mat destImg(destRoiHeight, destRoiWidth, CV_8UC(channels), pDest, destImgInfo.widthStep);
|
|
|
|
|
CImageApplyFilter imgApply(filterType2, kSize);
|
|
|
|
|
imgApply.apply(destImg, 0);
|
|
|
|
|
if (destImg.data != pDest)
|
|
|
|
|
{
|
|
|
|
|
for (HGUInt i = 0; i < destRoiHeight; ++i)
|
|
|
|
|
{
|
2022-06-20 03:06:18 +00:00
|
|
|
|
memcpy(pDest + i * destImgInfo.widthStep, destImg.data + i * destImg.step, destRoiWidth * channels);
|
2022-06-18 09:59:25 +00:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return HGBASE_ERR_OK;
|
|
|
|
|
}
|
2022-06-20 03:06:18 +00:00
|
|
|
|
|
|
|
|
|
HGResult HGAPI HGImgProc_ImageOutHole(HGImage image1, HGImage image2, HGFloat borderSize, HGFloat edgeScale, HGDouble threshold)
|
|
|
|
|
{
|
|
|
|
|
if (NULL == image1 || NULL == image2 || image1 == image2)
|
|
|
|
|
{
|
|
|
|
|
return HGBASE_ERR_INVALIDARG;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
HGImageInfo imgInfo1;
|
|
|
|
|
HGBase_GetImageInfo(image1, &imgInfo1);
|
|
|
|
|
HGImageInfo imgInfo2;
|
|
|
|
|
HGBase_GetImageInfo(image2, &imgInfo2);
|
|
|
|
|
if (imgInfo1.type != imgInfo2.type || imgInfo1.origin != imgInfo2.origin)
|
|
|
|
|
{
|
|
|
|
|
return HGBASE_ERR_INVALIDDATA;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
HGByte* data1 = NULL;
|
|
|
|
|
HGBase_GetImageData(image1, &data1);
|
|
|
|
|
HGByte* data2 = NULL;
|
|
|
|
|
HGBase_GetImageData(image2, &data2);
|
|
|
|
|
|
|
|
|
|
HGImageRoi roi1;
|
|
|
|
|
HGBase_GetImageROI(image1, &roi1);
|
|
|
|
|
HGUInt roiWidth1 = roi1.right - roi1.left;
|
|
|
|
|
HGUInt roiHeight1 = roi1.bottom - roi1.top;
|
|
|
|
|
HGImageRoi roi2;
|
|
|
|
|
HGBase_GetImageROI(image2, &roi2);
|
|
|
|
|
HGUInt roiWidth2 = roi2.right - roi2.left;
|
|
|
|
|
HGUInt roiHeight2 = roi2.bottom - roi2.top;
|
|
|
|
|
if (roiWidth1 != roiWidth2 || roiHeight1 != roiHeight2)
|
|
|
|
|
{
|
|
|
|
|
return HGBASE_ERR_INVALIDDATA;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (HGBASE_IMGTYPE_BINARY == imgInfo1.type || HGBASE_IMGTYPE_RGBA == imgInfo1.type
|
|
|
|
|
|| HGBASE_IMGTYPE_BGRA == imgInfo1.type || HGBASE_IMGTYPE_RGB == imgInfo1.type)
|
|
|
|
|
{
|
|
|
|
|
HGImage imageTmp1 = NULL;
|
|
|
|
|
HGResult ret = HGBase_CloneImage(image1, HGBASE_IMGTYPE_BGR, 0, &imageTmp1);
|
|
|
|
|
if (HGBASE_ERR_OK == ret)
|
|
|
|
|
{
|
|
|
|
|
HGImage imageTmp2 = NULL;
|
|
|
|
|
ret = HGBase_CloneImage(image2, HGBASE_IMGTYPE_BGR, 0, &imageTmp2);
|
|
|
|
|
if (HGBASE_ERR_OK == ret)
|
|
|
|
|
{
|
|
|
|
|
ret = HGImgProc_ImageOutHole(imageTmp1, imageTmp2, borderSize, edgeScale, threshold);
|
|
|
|
|
if (HGBASE_ERR_OK == ret)
|
|
|
|
|
{
|
|
|
|
|
HGBase_CopyImage(imageTmp1, image1);
|
|
|
|
|
HGBase_CopyImage(imageTmp2, image2);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
HGBase_DestroyImage(imageTmp2);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
HGBase_DestroyImage(imageTmp1);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
uint32_t channels = 1;
|
|
|
|
|
if (HGBASE_IMGTYPE_BGR == imgInfo1.type || HGBASE_IMGTYPE_RGB == imgInfo1.type)
|
|
|
|
|
channels = 3;
|
|
|
|
|
else if (HGBASE_IMGTYPE_BGRA == imgInfo1.type || HGBASE_IMGTYPE_RGBA == imgInfo1.type)
|
|
|
|
|
channels = 4;
|
|
|
|
|
|
|
|
|
|
uint8_t* p1 = data1 + roi1.top * imgInfo1.widthStep + roi1.left * channels;
|
|
|
|
|
if (HGBASE_IMGORIGIN_BOTTOM == imgInfo1.origin)
|
|
|
|
|
p1 = data1 + (imgInfo1.height - roi1.bottom) * imgInfo1.widthStep + roi1.left * channels;
|
|
|
|
|
cv::Mat img1(roiHeight1, roiWidth1, CV_8UC(channels), p1, imgInfo1.widthStep);
|
|
|
|
|
|
|
|
|
|
uint8_t* p2 = data2 + roi2.top * imgInfo2.widthStep + roi2.left * channels;
|
|
|
|
|
if (HGBASE_IMGORIGIN_BOTTOM == imgInfo2.origin)
|
|
|
|
|
p2 = data2 + (imgInfo2.height - roi2.bottom) * imgInfo2.widthStep + roi2.left * channels;
|
|
|
|
|
cv::Mat img2(roiHeight2, roiWidth2, CV_8UC(channels), p2, imgInfo2.widthStep);
|
|
|
|
|
|
|
|
|
|
std::vector<cv::Mat> mats;
|
|
|
|
|
mats.push_back(img1);
|
|
|
|
|
mats.push_back(img2);
|
|
|
|
|
CImageApplyOutHole imgApply(borderSize, edgeScale, threshold);
|
|
|
|
|
imgApply.apply(mats, true);
|
|
|
|
|
assert(mats[0].data == p1);
|
|
|
|
|
assert(mats[1].data == p2);
|
|
|
|
|
|
|
|
|
|
return HGBASE_ERR_OK;
|
|
|
|
|
}
|
2022-06-20 06:18:21 +00:00
|
|
|
|
|
|
|
|
|
HGResult HGAPI HGImgProc_ImageHSVCorrect(HGImage image, HGImage destImage, HGUInt correctOption, HGBool cvtGray, HGColor color)
|
|
|
|
|
{
|
|
|
|
|
if (NULL == image || correctOption < HGIMGPROC_CORRECTOPTION_DEFAULT || correctOption > HGIMGPROC_CORRECTOPTION_RED_REMOVAL)
|
|
|
|
|
{
|
|
|
|
|
return HGBASE_ERR_INVALIDARG;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
CImageApplyHSVCorrect::CorrectOption correctOption2 = CImageApplyHSVCorrect::Deafault;
|
|
|
|
|
if (HGIMGPROC_CORRECTOPTION_LOWSATURATION_REMOVAL == correctOption)
|
|
|
|
|
correctOption2 = CImageApplyHSVCorrect::LowSaturation_Removal;
|
|
|
|
|
else if (HGIMGPROC_CORRECTOPTION_RED_REMOVAL == correctOption)
|
|
|
|
|
correctOption2 = CImageApplyHSVCorrect::Red_Removal;
|
|
|
|
|
bool cvtGray2 = cvtGray ? true : false;
|
|
|
|
|
HGUInt r = HG_GETCOLOR_R(color);
|
|
|
|
|
HGUInt g = HG_GETCOLOR_G(color);
|
|
|
|
|
HGUInt b = HG_GETCOLOR_B(color);
|
|
|
|
|
uint color2 = (uint)(((HGUInt)r << 16) | ((HGUInt)g << 8) | (HGUInt)b);
|
|
|
|
|
|
|
|
|
|
HGImageInfo imgInfo;
|
|
|
|
|
HGBase_GetImageInfo(image, &imgInfo);
|
|
|
|
|
HGUInt type = imgInfo.type;
|
|
|
|
|
|
|
|
|
|
HGByte* data = NULL;
|
|
|
|
|
HGBase_GetImageData(image, &data);
|
|
|
|
|
|
|
|
|
|
HGImageRoi roi;
|
|
|
|
|
HGBase_GetImageROI(image, &roi);
|
|
|
|
|
HGUInt roiWidth = roi.right - roi.left;
|
|
|
|
|
HGUInt roiHeight = roi.bottom - roi.top;
|
|
|
|
|
|
|
|
|
|
if (NULL == destImage || image == destImage)
|
|
|
|
|
{
|
|
|
|
|
if (HGBASE_IMGTYPE_BGR != type)
|
|
|
|
|
{
|
|
|
|
|
HGImage imageTmp = NULL;
|
|
|
|
|
HGResult ret = HGBase_CloneImage(image, HGBASE_IMGTYPE_BGR, 0, &imageTmp);
|
|
|
|
|
if (HGBASE_ERR_OK == ret)
|
|
|
|
|
{
|
|
|
|
|
ret = HGImgProc_ImageHSVCorrect(imageTmp, imageTmp, correctOption, cvtGray, color);
|
|
|
|
|
if (HGBASE_ERR_OK == ret)
|
|
|
|
|
{
|
|
|
|
|
ret = HGBase_CopyImage(imageTmp, image);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
HGBase_DestroyImage(imageTmp);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
uint8_t* p = data + roi.top * imgInfo.widthStep + roi.left * 3;
|
|
|
|
|
if (HGBASE_IMGORIGIN_BOTTOM == imgInfo.origin)
|
|
|
|
|
p = data + (imgInfo.height - roi.bottom) * imgInfo.widthStep + roi.left * 3;
|
|
|
|
|
|
|
|
|
|
cv::Mat img(roiHeight, roiWidth, CV_8UC(3), p, imgInfo.widthStep);
|
|
|
|
|
CImageApplyHSVCorrect imgApply(correctOption2, cvtGray2, color2);
|
|
|
|
|
imgApply.apply(img, 0);
|
|
|
|
|
assert(img.data == p);
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
HGImageInfo destImgInfo;
|
|
|
|
|
HGBase_GetImageInfo(destImage, &destImgInfo);
|
|
|
|
|
HGUInt destType = destImgInfo.type;
|
|
|
|
|
if (type != destType)
|
|
|
|
|
{
|
|
|
|
|
return HGBASE_ERR_INVALIDDATA;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
HGByte* destData = NULL;
|
|
|
|
|
HGBase_GetImageData(destImage, &destData);
|
|
|
|
|
|
|
|
|
|
HGImageRoi destRoi;
|
|
|
|
|
HGBase_GetImageROI(destImage, &destRoi);
|
|
|
|
|
HGUInt destRoiWidth = destRoi.right - destRoi.left;
|
|
|
|
|
HGUInt destRoiHeight = destRoi.bottom - destRoi.top;
|
|
|
|
|
|
|
|
|
|
if (roiWidth != destRoiWidth || roiHeight != destRoiHeight)
|
|
|
|
|
{
|
|
|
|
|
return HGBASE_ERR_INVALIDDATA;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (HGBASE_IMGTYPE_BGR != type)
|
|
|
|
|
{
|
|
|
|
|
HGImage imageTmp = NULL;
|
|
|
|
|
HGResult ret = HGBase_CloneImage(image, HGBASE_IMGTYPE_BGR, 0, &imageTmp);
|
|
|
|
|
if (HGBASE_ERR_OK == ret)
|
|
|
|
|
{
|
|
|
|
|
ret = HGImgProc_ImageHSVCorrect(imageTmp, imageTmp, correctOption, cvtGray, color);
|
|
|
|
|
if (HGBASE_ERR_OK == ret)
|
|
|
|
|
{
|
|
|
|
|
ret = HGBase_CopyImage(imageTmp, destImage);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
HGBase_DestroyImage(imageTmp);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
HGBase_CopyImage(image, destImage);
|
|
|
|
|
|
|
|
|
|
uint8_t* pDest = destData + destRoi.top * destImgInfo.widthStep + destRoi.left * 3;
|
|
|
|
|
if (HGBASE_IMGORIGIN_BOTTOM == destImgInfo.origin)
|
|
|
|
|
pDest = destData + (destImgInfo.height - destRoi.bottom) * destImgInfo.widthStep + destRoi.left * 3;
|
|
|
|
|
|
|
|
|
|
cv::Mat destImg(destRoiHeight, destRoiWidth, CV_8UC(3), pDest, destImgInfo.widthStep);
|
|
|
|
|
CImageApplyHSVCorrect imgApply(correctOption2, cvtGray2, color2);
|
|
|
|
|
imgApply.apply(destImg, 0);
|
|
|
|
|
assert(destImg.data == pDest);
|
2022-06-30 01:28:30 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return HGBASE_ERR_OK;
|
|
|
|
|
}
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
HGResult HGAPI HGImgProc_ImageFadeBkColor(HGImage image, HGImage destImage, const HGImgFaceBkColorParam* param)
|
|
|
|
|
{
|
|
|
|
|
if (NULL == image)
|
|
|
|
|
{
|
|
|
|
|
return HGBASE_ERR_INVALIDARG;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
int threshold = 100;
|
|
|
|
|
int offset = 0;
|
|
|
|
|
int range = 40;
|
|
|
|
|
if (NULL != param)
|
|
|
|
|
{
|
|
|
|
|
threshold = param->threshold;
|
|
|
|
|
offset = param->offset;
|
|
|
|
|
range = param->range;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
HGImageInfo imgInfo;
|
|
|
|
|
HGBase_GetImageInfo(image, &imgInfo);
|
|
|
|
|
HGUInt type = imgInfo.type;
|
|
|
|
|
|
|
|
|
|
HGByte* data = NULL;
|
|
|
|
|
HGBase_GetImageData(image, &data);
|
|
|
|
|
|
|
|
|
|
HGImageRoi roi;
|
|
|
|
|
HGBase_GetImageROI(image, &roi);
|
|
|
|
|
HGUInt roiWidth = roi.right - roi.left;
|
|
|
|
|
HGUInt roiHeight = roi.bottom - roi.top;
|
|
|
|
|
|
|
|
|
|
if (NULL == destImage || image == destImage)
|
|
|
|
|
{
|
|
|
|
|
if (HGBASE_IMGTYPE_BGR != type)
|
|
|
|
|
{
|
|
|
|
|
HGImage imageTmp = NULL;
|
|
|
|
|
HGResult ret = HGBase_CloneImage(image, HGBASE_IMGTYPE_BGR, 0, &imageTmp);
|
|
|
|
|
if (HGBASE_ERR_OK == ret)
|
|
|
|
|
{
|
|
|
|
|
ret = HGImgProc_ImageFadeBkColor(imageTmp, imageTmp, param);
|
|
|
|
|
if (HGBASE_ERR_OK == ret)
|
|
|
|
|
{
|
|
|
|
|
ret = HGBase_CopyImage(imageTmp, image);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
HGBase_DestroyImage(imageTmp);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
uint8_t* p = data + roi.top * imgInfo.widthStep + roi.left * 3;
|
|
|
|
|
if (HGBASE_IMGORIGIN_BOTTOM == imgInfo.origin)
|
|
|
|
|
p = data + (imgInfo.height - roi.bottom) * imgInfo.widthStep + roi.left * 3;
|
|
|
|
|
|
|
|
|
|
cv::Mat img(roiHeight, roiWidth, CV_8UC(3), p, imgInfo.widthStep);
|
|
|
|
|
CImageApplyFadeBackGroudColor imgApply(threshold, offset, range);
|
|
|
|
|
imgApply.apply(img, 0);
|
|
|
|
|
assert(img.data == p);
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
HGImageInfo destImgInfo;
|
|
|
|
|
HGBase_GetImageInfo(destImage, &destImgInfo);
|
|
|
|
|
HGUInt destType = destImgInfo.type;
|
|
|
|
|
if (type != destType)
|
|
|
|
|
{
|
|
|
|
|
return HGBASE_ERR_INVALIDDATA;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
HGByte* destData = NULL;
|
|
|
|
|
HGBase_GetImageData(destImage, &destData);
|
|
|
|
|
|
|
|
|
|
HGImageRoi destRoi;
|
|
|
|
|
HGBase_GetImageROI(destImage, &destRoi);
|
|
|
|
|
HGUInt destRoiWidth = destRoi.right - destRoi.left;
|
|
|
|
|
HGUInt destRoiHeight = destRoi.bottom - destRoi.top;
|
|
|
|
|
|
|
|
|
|
if (roiWidth != destRoiWidth || roiHeight != destRoiHeight)
|
|
|
|
|
{
|
|
|
|
|
return HGBASE_ERR_INVALIDDATA;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (HGBASE_IMGTYPE_BGR != type)
|
|
|
|
|
{
|
|
|
|
|
HGImage imageTmp = NULL;
|
|
|
|
|
HGResult ret = HGBase_CloneImage(image, HGBASE_IMGTYPE_BGR, 0, &imageTmp);
|
|
|
|
|
if (HGBASE_ERR_OK == ret)
|
|
|
|
|
{
|
|
|
|
|
ret = HGImgProc_ImageFadeBkColor(imageTmp, imageTmp, param);
|
|
|
|
|
if (HGBASE_ERR_OK == ret)
|
|
|
|
|
{
|
|
|
|
|
ret = HGBase_CopyImage(imageTmp, destImage);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
HGBase_DestroyImage(imageTmp);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
HGBase_CopyImage(image, destImage);
|
|
|
|
|
|
|
|
|
|
uint8_t* pDest = destData + destRoi.top * destImgInfo.widthStep + destRoi.left * 3;
|
|
|
|
|
if (HGBASE_IMGORIGIN_BOTTOM == destImgInfo.origin)
|
|
|
|
|
pDest = destData + (destImgInfo.height - destRoi.bottom) * destImgInfo.widthStep + destRoi.left * 3;
|
|
|
|
|
|
|
|
|
|
cv::Mat destImg(destRoiHeight, destRoiWidth, CV_8UC(3), pDest, destImgInfo.widthStep);
|
|
|
|
|
CImageApplyFadeBackGroudColor imgApply(threshold, offset, range);
|
|
|
|
|
imgApply.apply(destImg, 0);
|
|
|
|
|
assert(destImg.data == pDest);
|
2022-06-20 06:18:21 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return HGBASE_ERR_OK;
|
|
|
|
|
}
|
2022-06-20 09:32:28 +00:00
|
|
|
|
|
|
|
|
|
HGResult HGAPI HGImgProc_ImageDecontamination(HGImage image, HGImage destImage, HGUInt decoType, HGUInt x, HGUInt y,
|
|
|
|
|
HGUInt width, HGUInt height, HGColor color)
|
|
|
|
|
{
|
|
|
|
|
if (NULL == image || decoType < HGIMGPROC_DECOTYPE_INSIDE || decoType > HGIMGPROC_DECOTYPE_OUTSIDE
|
|
|
|
|
|| 0 == width || 0 == height)
|
|
|
|
|
{
|
|
|
|
|
return HGBASE_ERR_INVALIDARG;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
HGImageInfo imgInfo;
|
|
|
|
|
HGBase_GetImageInfo(image, &imgInfo);
|
|
|
|
|
|
|
|
|
|
HGByte* data = NULL;
|
|
|
|
|
HGBase_GetImageData(image, &data);
|
|
|
|
|
|
|
|
|
|
HGImageRoi roi;
|
|
|
|
|
HGBase_GetImageROI(image, &roi);
|
|
|
|
|
HGUInt roiWidth = roi.right - roi.left;
|
|
|
|
|
HGUInt roiHeight = roi.bottom - roi.top;
|
|
|
|
|
|
|
|
|
|
if (x + width > roiWidth || y + height > roiHeight)
|
|
|
|
|
{
|
|
|
|
|
return HGBASE_ERR_INVALIDARG;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
uint32_t channels = 1;
|
|
|
|
|
if (HGBASE_IMGTYPE_BGR == imgInfo.type || HGBASE_IMGTYPE_RGB == imgInfo.type)
|
|
|
|
|
channels = 3;
|
|
|
|
|
else if (HGBASE_IMGTYPE_BGRA == imgInfo.type || HGBASE_IMGTYPE_RGBA == imgInfo.type)
|
|
|
|
|
channels = 4;
|
|
|
|
|
uint32_t dataSize = roiWidth * channels;
|
|
|
|
|
|
|
|
|
|
HGUInt r = HG_GETCOLOR_R(color);
|
|
|
|
|
HGUInt g = HG_GETCOLOR_G(color);
|
|
|
|
|
HGUInt b = HG_GETCOLOR_B(color);
|
|
|
|
|
HGUInt v = (r * 76 + g * 150 + b * 30) >> 8;
|
|
|
|
|
|
|
|
|
|
if (NULL == destImage || image == destImage)
|
|
|
|
|
{
|
|
|
|
|
if (HGBASE_IMGTYPE_BINARY == imgInfo.type)
|
|
|
|
|
{
|
|
|
|
|
HGImage imageTmp = NULL;
|
|
|
|
|
HGResult ret = HGBase_CloneImage(image, HGBASE_IMGTYPE_GRAY, 0, &imageTmp);
|
|
|
|
|
if (HGBASE_ERR_OK == ret)
|
|
|
|
|
{
|
|
|
|
|
ret = HGImgProc_ImageDecontamination(imageTmp, imageTmp, decoType, x, y, width, height, color);
|
|
|
|
|
if (HGBASE_ERR_OK == ret)
|
|
|
|
|
{
|
|
|
|
|
ret = HGBase_CopyImage(imageTmp, image);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
HGBase_DestroyImage(imageTmp);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
HGByte* p = data + (HGUSize)roi.top * (HGUSize)imgInfo.widthStep + roi.left * channels;
|
|
|
|
|
HGInt step = (HGInt)imgInfo.widthStep;
|
|
|
|
|
if (HGBASE_IMGORIGIN_BOTTOM == imgInfo.origin)
|
|
|
|
|
{
|
|
|
|
|
p = data + (HGUSize)(imgInfo.height - roi.top - 1) * (HGUSize)imgInfo.widthStep + roi.left * channels;
|
|
|
|
|
step = -(HGInt)imgInfo.widthStep;
|
|
|
|
|
}
|
2022-10-24 14:48:17 +00:00
|
|
|
|
|
2022-06-20 09:32:28 +00:00
|
|
|
|
if (HGBASE_IMGTYPE_RGB == imgInfo.type || HGBASE_IMGTYPE_RGBA == imgInfo.type
|
|
|
|
|
|| HGBASE_IMGTYPE_BGR == imgInfo.type || HGBASE_IMGTYPE_BGRA == imgInfo.type)
|
|
|
|
|
{
|
|
|
|
|
if (HGBASE_IMGTYPE_BGR == imgInfo.type || HGBASE_IMGTYPE_BGRA == imgInfo.type)
|
|
|
|
|
{
|
|
|
|
|
r = HG_GETCOLOR_B(color);
|
|
|
|
|
g = HG_GETCOLOR_G(color);
|
|
|
|
|
b = HG_GETCOLOR_R(color);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (HGIMGPROC_DECOTYPE_INSIDE == decoType)
|
|
|
|
|
{
|
|
|
|
|
//#pragma omp parallel for
|
|
|
|
|
for (int32_t i = 0; i < (int32_t)roiHeight; ++i)
|
|
|
|
|
{
|
|
|
|
|
HGByte* pEx = p + (HGSize)i * (HGSize)step;
|
|
|
|
|
for (int32_t j = 0; j < (int32_t)roiWidth; ++j)
|
|
|
|
|
{
|
|
|
|
|
HGByte* pEx2 = pEx + j * channels;
|
|
|
|
|
if ((j >= (int32_t)x && j < (int32_t)(x + width)) && (i >= (int32_t)y && i < (int32_t)(y + height)))
|
|
|
|
|
{
|
|
|
|
|
pEx2[0] = r;
|
|
|
|
|
pEx2[1] = g;
|
|
|
|
|
pEx2[2] = b;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
assert(HGIMGPROC_DECOTYPE_OUTSIDE == decoType);
|
|
|
|
|
|
|
|
|
|
//#pragma omp parallel for
|
|
|
|
|
for (int32_t i = 0; i < (int32_t)roiHeight; ++i)
|
|
|
|
|
{
|
|
|
|
|
HGByte* pEx = p + (HGSize)i * (HGSize)step;
|
|
|
|
|
for (int32_t j = 0; j < (int32_t)roiWidth; ++j)
|
|
|
|
|
{
|
|
|
|
|
HGByte* pEx2 = pEx + j * channels;
|
|
|
|
|
if ((j >= (int32_t)x && j < (int32_t)(x + width)) && (i >= (int32_t)y && i < (int32_t)(y + height)))
|
|
|
|
|
{
|
2022-10-24 14:48:17 +00:00
|
|
|
|
|
2022-06-20 09:32:28 +00:00
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
pEx2[0] = r;
|
|
|
|
|
pEx2[1] = g;
|
|
|
|
|
pEx2[2] = b;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
assert(HGBASE_IMGTYPE_GRAY == imgInfo.type);
|
|
|
|
|
|
|
|
|
|
if (HGIMGPROC_DECOTYPE_INSIDE == decoType)
|
|
|
|
|
{
|
|
|
|
|
//#pragma omp parallel for
|
|
|
|
|
for (int32_t i = 0; i < (int32_t)roiHeight; ++i)
|
|
|
|
|
{
|
|
|
|
|
HGByte* pEx = p + (HGSize)i * (HGSize)step;
|
|
|
|
|
for (int32_t j = 0; j < (int32_t)roiWidth; ++j)
|
|
|
|
|
{
|
|
|
|
|
HGByte* pEx2 = pEx + j * channels;
|
|
|
|
|
if ((j >= (int32_t)x && j < (int32_t)(x + width)) && (i >= (int32_t)y && i < (int32_t)(y + height)))
|
|
|
|
|
*pEx2 = v;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
assert(HGIMGPROC_DECOTYPE_OUTSIDE == decoType);
|
|
|
|
|
|
|
|
|
|
//#pragma omp parallel for
|
|
|
|
|
for (int32_t i = 0; i < (int32_t)roiHeight; ++i)
|
|
|
|
|
{
|
|
|
|
|
HGByte* pEx = p + (HGSize)i * (HGSize)step;
|
|
|
|
|
for (int32_t j = 0; j < (int32_t)roiWidth; ++j)
|
|
|
|
|
{
|
|
|
|
|
HGByte* pEx2 = pEx + j * channels;
|
|
|
|
|
if ((j >= (int32_t)x && j < (int32_t)(x + width)) && (i >= (int32_t)y && i < (int32_t)(y + height)))
|
|
|
|
|
{
|
|
|
|
|
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
*pEx2 = v;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
HGImageInfo destImgInfo;
|
|
|
|
|
HGBase_GetImageInfo(destImage, &destImgInfo);
|
|
|
|
|
if (imgInfo.type != destImgInfo.type)
|
|
|
|
|
{
|
|
|
|
|
return HGBASE_ERR_INVALIDDATA;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
HGByte* destData = NULL;
|
|
|
|
|
HGBase_GetImageData(destImage, &destData);
|
|
|
|
|
|
|
|
|
|
HGImageRoi destRoi;
|
|
|
|
|
HGBase_GetImageROI(destImage, &destRoi);
|
|
|
|
|
HGUInt destRoiWidth = destRoi.right - destRoi.left;
|
|
|
|
|
HGUInt destRoiHeight = destRoi.bottom - destRoi.top;
|
|
|
|
|
|
|
|
|
|
if (roiWidth != destRoiWidth || roiHeight != destRoiHeight)
|
|
|
|
|
{
|
|
|
|
|
return HGBASE_ERR_INVALIDDATA;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (HGBASE_IMGTYPE_BINARY == imgInfo.type)
|
|
|
|
|
{
|
|
|
|
|
HGImage imageTmp = NULL;
|
|
|
|
|
HGResult ret = HGBase_CloneImage(image, HGBASE_IMGTYPE_GRAY, 0, &imageTmp);
|
|
|
|
|
if (HGBASE_ERR_OK == ret)
|
|
|
|
|
{
|
|
|
|
|
ret = HGImgProc_ImageDecontamination(imageTmp, imageTmp, decoType, x, y, width, height, color);
|
|
|
|
|
if (HGBASE_ERR_OK == ret)
|
|
|
|
|
{
|
|
|
|
|
ret = HGBase_CopyImage(imageTmp, destImage);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
HGBase_DestroyImage(imageTmp);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
HGByte* src = data + (HGUSize)roi.top * (HGUSize)imgInfo.widthStep + roi.left * channels;
|
|
|
|
|
HGInt srcStep = (HGInt)imgInfo.widthStep;
|
|
|
|
|
if (HGBASE_IMGORIGIN_BOTTOM == imgInfo.origin)
|
|
|
|
|
{
|
|
|
|
|
src = data + (HGUSize)(imgInfo.height - roi.top - 1) * (HGUSize)imgInfo.widthStep + roi.left * channels;
|
|
|
|
|
srcStep = -(HGInt)imgInfo.widthStep;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
HGByte* dest = destData + (HGUSize)destRoi.top * (HGUSize)destImgInfo.widthStep + destRoi.left * channels;
|
|
|
|
|
HGInt destStep = (HGInt)destImgInfo.widthStep;
|
|
|
|
|
if (HGBASE_IMGORIGIN_BOTTOM == destImgInfo.origin)
|
|
|
|
|
{
|
|
|
|
|
dest = destData + (HGUSize)(destImgInfo.height - destRoi.top - 1) * (HGUSize)destImgInfo.widthStep + destRoi.left * channels;
|
|
|
|
|
destStep = -(HGInt)destImgInfo.widthStep;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (HGBASE_IMGTYPE_RGB == imgInfo.type || HGBASE_IMGTYPE_RGBA == imgInfo.type
|
|
|
|
|
|| HGBASE_IMGTYPE_BGR == imgInfo.type || HGBASE_IMGTYPE_BGRA == imgInfo.type)
|
|
|
|
|
{
|
|
|
|
|
if (HGBASE_IMGTYPE_BGR == imgInfo.type || HGBASE_IMGTYPE_BGRA == imgInfo.type)
|
|
|
|
|
{
|
|
|
|
|
r = HG_GETCOLOR_B(color);
|
|
|
|
|
g = HG_GETCOLOR_G(color);
|
|
|
|
|
b = HG_GETCOLOR_R(color);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (HGIMGPROC_DECOTYPE_INSIDE == decoType)
|
|
|
|
|
{
|
|
|
|
|
//#pragma omp parallel for
|
|
|
|
|
for (int32_t i = 0; i < (int32_t)roiHeight; ++i)
|
|
|
|
|
{
|
|
|
|
|
HGByte* pSrcEx = src + (HGSize)i * (HGSize)srcStep;
|
|
|
|
|
HGByte* pDestEx = dest + (HGSize)i * (HGSize)destStep;
|
|
|
|
|
for (int32_t j = 0; j < (int32_t)roiWidth; ++j)
|
|
|
|
|
{
|
|
|
|
|
HGByte* pSrcEx2 = pSrcEx + j * channels;
|
|
|
|
|
HGByte* pDestEx2 = pDestEx + j * channels;
|
|
|
|
|
if ((j >= (int32_t)x && j < (int32_t)(x + width)) && (i >= (int32_t)y && i < (int32_t)(y + height)))
|
|
|
|
|
{
|
|
|
|
|
pDestEx2[0] = r;
|
|
|
|
|
pDestEx2[1] = g;
|
|
|
|
|
pDestEx2[2] = b;
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
pDestEx2[0] = pSrcEx2[0];
|
|
|
|
|
pDestEx2[1] = pSrcEx2[1];
|
|
|
|
|
pDestEx2[2] = pSrcEx2[2];
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
assert(HGIMGPROC_DECOTYPE_OUTSIDE == decoType);
|
|
|
|
|
|
|
|
|
|
//#pragma omp parallel for
|
|
|
|
|
for (int32_t i = 0; i < (int32_t)roiHeight; ++i)
|
|
|
|
|
{
|
|
|
|
|
HGByte* pSrcEx = src + (HGSize)i * (HGSize)srcStep;
|
|
|
|
|
HGByte* pDestEx = dest + (HGSize)i * (HGSize)destStep;
|
|
|
|
|
for (int32_t j = 0; j < (int32_t)roiWidth; ++j)
|
|
|
|
|
{
|
|
|
|
|
HGByte* pSrcEx2 = pSrcEx + j * channels;
|
|
|
|
|
HGByte* pDestEx2 = pDestEx + j * channels;
|
|
|
|
|
if ((j >= (int32_t)x && j < (int32_t)(x + width)) && (i >= (int32_t)y && i < (int32_t)(y + height)))
|
|
|
|
|
{
|
|
|
|
|
pDestEx2[0] = pSrcEx2[0];
|
|
|
|
|
pDestEx2[1] = pSrcEx2[1];
|
|
|
|
|
pDestEx2[2] = pSrcEx2[2];
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
pDestEx2[0] = r;
|
|
|
|
|
pDestEx2[1] = g;
|
|
|
|
|
pDestEx2[2] = b;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
assert(HGBASE_IMGTYPE_GRAY == imgInfo.type);
|
|
|
|
|
|
|
|
|
|
if (HGIMGPROC_DECOTYPE_INSIDE == decoType)
|
|
|
|
|
{
|
|
|
|
|
//#pragma omp parallel for
|
|
|
|
|
for (int32_t i = 0; i < (int32_t)roiHeight; ++i)
|
|
|
|
|
{
|
|
|
|
|
HGByte* pSrcEx = src + (HGSize)i * (HGSize)srcStep;
|
|
|
|
|
HGByte* pDestEx = dest + (HGSize)i * (HGSize)destStep;
|
|
|
|
|
for (int32_t j = 0; j < (int32_t)roiWidth; ++j)
|
|
|
|
|
{
|
|
|
|
|
HGByte* pSrcEx2 = pSrcEx + j * channels;
|
|
|
|
|
HGByte* pDestEx2 = pDestEx + j * channels;
|
|
|
|
|
if ((j >= (int32_t)x && j < (int32_t)(x + width)) && (i >= (int32_t)y && i < (int32_t)(y + height)))
|
|
|
|
|
*pDestEx2 = v;
|
|
|
|
|
else
|
|
|
|
|
*pDestEx2 = *pSrcEx2;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
assert(HGIMGPROC_DECOTYPE_OUTSIDE == decoType);
|
|
|
|
|
|
|
|
|
|
//#pragma omp parallel for
|
|
|
|
|
for (int32_t i = 0; i < (int32_t)roiHeight; ++i)
|
|
|
|
|
{
|
|
|
|
|
HGByte* pSrcEx = src + (HGSize)i * (HGSize)srcStep;
|
|
|
|
|
HGByte* pDestEx = dest + (HGSize)i * (HGSize)destStep;
|
|
|
|
|
for (int32_t j = 0; j < (int32_t)roiWidth; ++j)
|
|
|
|
|
{
|
|
|
|
|
HGByte* pSrcEx2 = pSrcEx + j * channels;
|
|
|
|
|
HGByte* pDestEx2 = pDestEx + j * channels;
|
|
|
|
|
if ((j >= (int32_t)x && j < (int32_t)(x + width)) && (i >= (int32_t)y && i < (int32_t)(y + height)))
|
|
|
|
|
*pDestEx2 = *pSrcEx2;
|
|
|
|
|
else
|
|
|
|
|
*pDestEx2 = v;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return HGBASE_ERR_OK;
|
|
|
|
|
}
|