Mat getBackground(VideoCapture& cap){
// initailize the count, and the frames
int i = 1;
Mat frame, frame2, sum;
cap >> frame;
frame2 = frame;
// the main loop (termiantes when a key is pressed);
while (true) {
cap >> frame;
if (i > 1) {
frame2 = sum;
}
double beta = 1.0 / (i + 1);
double alpha = 1.0 - beta;
addWeighted(frame2, alpha, frame, beta, 0.0, sum);
imshow("background", sum);
if(waitKey(30) >= 0) break;
++i;
}
destroyWindow("background");
return sum;
}
void BlendingImages::demo(char * filename1,char * filename2, double inputAlpha){
double alpha = 0.5;
double beta;
Mat src1, src2, dst;
/// We use the alpha provided by the user if it is between 0 and 1
if( inputAlpha >= 0.0 && inputAlpha <= 1.0 )
{
alpha = inputAlpha;
}
/// Read image ( same size, same type )
src1 = imread(filename1);
src2 = imread(filename2);
if( !src1.data ) {
printf("Error loading src1 \n");
return;
}
if( !src2.data ) {
printf("Error loading src2 \n");
return;
}
/// Create Windows
namedWindow("Linear Blend", 1);
beta = ( 1.0 - alpha );
addWeighted( src1, alpha, src2, beta, 0.0, dst);
imshow( "Linear Blend", dst );
waitKey(0);
}
imageCapture::imageCapture(Mat image, int& counter, int amountOfColors, int AmountOfProjectedPointsPerColor, int totalProjectedColumns, vector<vector<Point>>& twoDPointSpace) {
colorObject redLower("redLower"), redUpper("redUpper"), green("green"), blue("blue"), white("white");
// get blue points
cvtColor(image, HSV, COLOR_BGR2HSV);
inRange(HSV, blue.getHSVmin(), blue.getHSVmax(), threshold);
morphOps(threshold);
trackFilteredObject(blue, threshold, image, counter, twoDPointSpace);
// get red points
cvtColor(image, HSV, COLOR_BGR2HSV);
inRange(HSV, redLower.getHSVmin(), redLower.getHSVmax(), lowerRedImage);
inRange(HSV, redUpper.getHSVmin(), redUpper.getHSVmax(), upperRedImage);
addWeighted(lowerRedImage, 1.0, upperRedImage, 1.0, 0.0, threshold);
morphOps(threshold);
trackFilteredObject(redUpper, threshold, image, counter, twoDPointSpace);
//get green points
cvtColor(image, HSV, COLOR_BGR2HSV);
inRange(HSV, green.getHSVmin(), green.getHSVmax(), threshold);
morphOps(threshold);
trackFilteredObject(green, threshold, image, counter, twoDPointSpace);
//get white points
cvtColor(image, HSV, COLOR_BGR2HSV);
inRange(HSV, white.getHSVmin(), white.getHSVmax(), threshold);
morphOps(threshold);
trackFilteredObject(white, threshold, image, counter, twoDPointSpace);
counter++;
}
Mat ImageAnalysis::getColoredAreas(){
if( !m_areaCol_ok ) genColoredAreas();
IplImage gray = m_depthf;
IplImage rgb = m_rgb;
cvMerge(&gray, &gray, &gray, NULL, &rgb);
addWeighted(m_rgb,0.5f,m_areaCol,0.5f,0,m_rgb);
return m_rgb;
}
void HazeRemove::gui(Mat& src, string wname)
{
namedWindow(wname);
int mode = 0;
createTrackbar("mode", wname, &mode, 1);
int alpha = 0;
createTrackbar("alpha", wname, &alpha, 100);
int hazerate = 10;
createTrackbar("hazerate", wname, &hazerate, 100);
int hazesize = 4;
createTrackbar("hazesize", wname, &hazesize, 100);
int ksize = 15;
createTrackbar("ksize", wname, &ksize, 100);
int e = 6;
createTrackbar("e", wname, &e, 255);
int key = 0;
while (key != 'q')
{
if (mode == 0)
{
Mat show;
Mat destC;
Mat destDark;
{
//CalcTime t("dehaze");
operator()(src, show, hazesize, hazerate / 100.0, ksize, e / 10.0);
}
showTransmissionMap(destC, true);
Mat a;
getAtmosphericLightImage(a);
imshow("a light", a);
addWeighted(src, alpha / 100.0, destC, 1.0 - alpha / 100.0, 0.0, destC);
imshow(wname, destC);
imshow("dehaze", show);
}
else
{
double mn, mx;
Mat srcg;
cvtColor(src, srcg, CV_RGB2YUV);
minMaxLoc(srcg, &mn, &mx);
Mat dest = src - CV_RGB(mn, mn, mn);
dest.convertTo(dest, CV_8UC3, 255 / (mx - mn));
imshow("dehaze", dest);
}
key = waitKey(33);
}
}
void MainWindow::addImage()
{
if(!activeMdiChild()) return;
CvGlWidget *actCV = activeMdiChild();
double alpha = 0.75;
double beta = ( 1.0 - alpha );
addWeighted( actCV->cvImage, alpha, actCV->inputImage, beta, 0.0, actCV->cvImage);
actCV->showImage(actCV->cvImage);
actCV->setWindowTitle("Blended");
actCV->buildHistogram();
makeHistogram();
}
int CPlateDetect::showResult(const Mat& result) {
namedWindow("EasyPR", CV_WINDOW_AUTOSIZE);
const int RESULTWIDTH = 640; // 640 930
const int RESULTHEIGHT = 540; // 540 710
Mat img_window;
img_window.create(RESULTHEIGHT, RESULTWIDTH, CV_8UC3);
int nRows = result.rows;
int nCols = result.cols;
Mat result_resize;
if (nCols <= img_window.cols && nRows <= img_window.rows) {
result_resize = result;
} else if (nCols > img_window.cols && nRows <= img_window.rows) {
float scale = float(img_window.cols) / float(nCols);
resize(result, result_resize, Size(), scale, scale, CV_INTER_AREA);
} else if (nCols <= img_window.cols && nRows > img_window.rows) {
float scale = float(img_window.rows) / float(nRows);
resize(result, result_resize, Size(), scale, scale, CV_INTER_AREA);
} else if (nCols > img_window.cols && nRows > img_window.rows) {
Mat result_middle;
float scale = float(img_window.cols) / float(nCols);
resize(result, result_middle, Size(), scale, scale, CV_INTER_AREA);
if (result_middle.rows > img_window.rows) {
float scale = float(img_window.rows) / float(result_middle.rows);
resize(result_middle, result_resize, Size(), scale, scale, CV_INTER_AREA);
} else {
result_resize = result_middle;
}
} else {
result_resize = result;
}
Mat imageRoi = img_window(Rect((RESULTWIDTH - result_resize.cols) / 2,
(RESULTHEIGHT - result_resize.rows) / 2,
result_resize.cols, result_resize.rows));
addWeighted(imageRoi, 0, result_resize, 1, 0, imageRoi);
imshow("EasyPR", img_window);
waitKey();
destroyWindow("EasyPR");
return 0;
}
//Generates Intensity Image
Mat Get_Intensity_Image(Mat inputImage)
{
#ifdef GPU_MODE
gpu::GpuMat d_src(inputImage);
Mat retImage;
gpu::GpuMat gputemp;
vector<gpu::GpuMat> d_vec;
gpu::split(d_src, d_vec);
gpu::addWeighted(d_vec[0], 1.0/3, d_vec[1], 1.0/3, 0.0, gputemp, -1);
gpu::addWeighted(gputemp, 1, d_vec[2], 1.0/3, 0.0, gputemp, -1);
gputemp.download(retImage);
asdf
#else
vector<Mat> rgb;
Mat cputemp;
Mat retImage;
split(inputImage, rgb);
addWeighted(rgb[0], 1.0/3, rgb[1], 1.0/3, 0.0, cputemp, -1);
addWeighted(cputemp, 1, rgb[2], 1.0/3, 0.0, retImage, -1);
#endif
return retImage;
}
void CTargetDetector::filterByColors(std::vector<Scalar> colorsLow, std::vector<Scalar> colorsHigh) {
Mat hsvImage;
cvtColor(bufferImg, hsvImage, COLOR_BGR2HSV);
Mat colorsFilteredImage;
Mat buffer;
for (int i = 0; i < colorsLow.size(); ++i) {
inRange(sourceImg, colorsLow[i], colorsHigh[i], buffer);
addWeighted(buffer, 1.0, colorsFilteredImage, 1.0, 0.0, colorsFilteredImage);
}
colorsFilteredImage.copyTo(bufferImg);
}
bool cameraSettings2d::mixImagesToColor(){
if(isUpdated)
{
cam->retriveDepthAndMask(nC,depths[nC],masks[nC]);
cam->retriveImage(nC,imgs[nC]);
depths[nC].convertTo(depthsT[nC],CV_8UC1,255.0/6000);
depths[nC].convertTo(depthsS[nC],CV_32FC1,1.0/6000);
cvtColor(depthsT[nC],depthsC[nC],CV_GRAY2RGB);
addWeighted( depthsC[nC], alpha, imgs[nC], 1.0-alpha, 0.0, mixs[nC]);
cvtColor(mixs[nC],mixs[nC],CV_BGR2RGB);
return true;
}
return false;
}
void COrientationFilter::filterImage(const Mat& input_img, Mat& filtered_img)
{
// Step 1: get for each image pixel the gradient for each color channel
Mat orientation_grad_resp;
Mat grad_x, grad_y;
// Blur
Mat blurred_img;
GaussianBlur(input_img, blurred_img, Size(3,3), 0, 0, BORDER_DEFAULT);
// Gradient X (right)
Sobel(blurred_img, grad_x, ddepth_, 1, 0, 3, scale_, delta_, BORDER_DEFAULT);
// Gradient Y (down)
Sobel(blurred_img, grad_y, ddepth_, 0, 1, 3, scale_, delta_, BORDER_DEFAULT);
grad_x = abs(grad_x);
grad_y = abs(grad_y);
// threshold to zero to neglect gradients in opposite directions
threshold(grad_x, grad_x, to_zero_threshold_, 0, THRESH_TOZERO);
threshold(grad_y, grad_y, to_zero_threshold_, 0, THRESH_TOZERO);
// superposition of both gradients: neglect gradients that are also strong to the perpenticular direction
switch(direction_)
{
case HORIZ:
addWeighted(grad_x, -0.707107, grad_y, 0.707107, 0, orientation_grad_resp);
break;
case VERT:
addWeighted(grad_x, 0.707107, grad_y, -0.707107, 0, orientation_grad_resp);
break;
}
//normalize(orientation_grad_resp, orientation_grad_resp, 0, 255, NORM_MINMAX);
filtered_img = Mat::zeros(orientation_grad_resp.size(), CV_8UC1);
orientation_grad_resp.convertTo(filtered_img, CV_8UC1);
}
int EdgeHandle::singleEdgeHandle( string InImgPosition , string InImageName, string OutImgPosition, string OutImgName ){
Mat src, src_gray;
Mat grad;
int scale = 1;
int delta = 0;
int ddepth = CV_16S;
int c;
/// Load an image
src = imread(InImgPosition+InImageName);
if( !src.data )
{ return -1; }
GaussianBlur( src, src, Size(3,3), 0, 0, BORDER_DEFAULT );
/// Convert it to gray
cvtColor( src, src_gray, CV_RGB2GRAY );
/// Generate grad_x and grad_y
Mat grad_x, grad_y;
Mat abs_grad_x, abs_grad_y;
//sobel
Sobel( src_gray, grad_x, ddepth, 1, 0, 3, scale, delta, BORDER_DEFAULT );
convertScaleAbs( grad_x, abs_grad_x );
Sobel( src_gray, grad_y, ddepth, 0, 1, 3, scale, delta, BORDER_DEFAULT );
convertScaleAbs( grad_y, abs_grad_y );
addWeighted( abs_grad_x, 0.5, abs_grad_y, 0.5, 0, grad );
// binary image.
//threshold(grad,grad,0,255,THRESH_BINARY);
// Apply the specified morphology operation
int morph_size = 1;
Mat element = getStructuringElement( 1, Size( 2*morph_size + 1, 2*morph_size+1 ), Point( morph_size, morph_size ) );
morphologyEx( grad, grad, 5, element );
morphologyEx( grad, grad, 5, element );
morphologyEx( grad, grad, 5, element );
// Create window
string outs = OutImgPosition + OutImgName;
imwrite(outs,grad);
return 0;
}
void *color_processing(void *pointer) {
Mat *imgPtr = (Mat *) pointer;
vector < Mat > color_map;
color_map = Normalize_color(*imgPtr, IntensityImg);
vector < Mat > RGBYMap(6);
for (int i = 0; i < 6; i++)
addWeighted(color_map[i], 0.5, color_map[i + 6], 0.5, 0, RGBYMap[i],
-1);
AggColor = aggregateMaps(RGBYMap);
normalize(AggColor, AggColor, 0, 255, NORM_MINMAX, -1);
pthread_exit (NULL);
}
void my_Sobel(cv::Mat& srcImg, cv::Mat& dstImg)
{
Mat dst_x, dst_y;
Sobel(srcImg, dst_x, srcImg.depth(), 1, 0, 3);
Sobel(srcImg, dst_y, srcImg.depth(), 0, 1, 3);
convertScaleAbs(dst_x, dst_x);
convertScaleAbs(dst_y, dst_y);
addWeighted( dst_x, 0.5, dst_y, 0.5, 0, dstImg);
if(dstImg.channels() == 3)
{
cvtColor(dstImg, dstImg, CV_BGR2GRAY);
cvtColor(dstImg, dstImg, CV_GRAY2BGR);
}
}
void harrisCornerDetection() {
cv::Mat grad_x, grad_y;
cv::Mat abs_grad_x, abs_grad_y;
cv::Mat grad;
cv::Mat R(inputImage.rows,inputImage.cols,CV_64F);
double maxR = 0;
Sobel(inputImage,grad_x,CV_16S,1,0,3,1,0,cv::BORDER_DEFAULT);
Sobel(inputImage,grad_y,CV_16S,0,1,3,1,0,cv::BORDER_DEFAULT);
convertScaleAbs(grad_x,abs_grad_x);
convertScaleAbs(grad_y,abs_grad_y);
addWeighted(abs_grad_x,0.5,abs_grad_y,0.5,0,grad);
for (int x=0;x<inputImage.cols;x++) {
for (int y=0;y<inputImage.rows;y++) {
double A = 0;
double B = 0;
double C = 0;
for (int u=-templateSize/2;u<=templateSize/2;u++) {
for (int v=-templateSize/2;v<=templateSize/2;v++) {
int columnIndex = x+u;
int rowIndex = y+v;
if (columnIndex<0 || columnIndex>=inputImage.cols) {
continue;
}
if (rowIndex<0 || rowIndex>=inputImage.rows) {
continue;
}
A += pow(abs_grad_x.at<uchar>(rowIndex,columnIndex),2);
B += abs_grad_x.at<uchar>(rowIndex,columnIndex)*abs_grad_y.at<uchar>(rowIndex,columnIndex);
C += pow(abs_grad_y.at<uchar>(rowIndex,columnIndex),2);
}
}
double cornerness = A*C-B*B-0.04*(A+C);
R.at<double>(y,x) = cornerness;
maxR = std::max(cornerness,maxR);
}
}
cv::Mat annotatedImage;
cv::cvtColor(inputImage,annotatedImage,CV_GRAY2RGB);
for (int x=0;x<inputImage.cols;x++) {
for (int y=0;y<inputImage.rows;y++) {
if (R.at<double>(y,x) >= maxR*threshold) {
circle(annotatedImage,cvPoint(x,y),2,CV_RGB(0,0,255));
}
}
}
imshow("Harris Corner Detection",annotatedImage);
}
CMat& CMat::soble(){
Mat src_gray;
pic.copyTo(src_gray);
pic.release();
int scale = 1,delta = 0,ddepth = CV_16S;
Mat grad_x, grad_y;
Mat abs_grad_x, abs_grad_y;
Sobel(src_gray, grad_x, ddepth, 1, 0, 3, scale, delta, BORDER_DEFAULT);
convertScaleAbs(grad_x, abs_grad_x );
Sobel(src_gray, grad_y, ddepth, 0, 1, 3, scale, delta, BORDER_DEFAULT);
convertScaleAbs(grad_y, abs_grad_y);
addWeighted(abs_grad_x, 0.5, abs_grad_y, 0.5, 0, pic);
src_gray.release();
grad_x.release(), grad_y.release();
abs_grad_x.release(), abs_grad_y.release();
return (*this);
}
void alpha::process(const cv::Mat &img_input, cv::Mat &img_output)
{
if(img_input.empty())
return;
img = Mat(img_input);
if(firstTime)
{
int width = img_input.size().width;
int height = img_input.size().height;
img.copyTo(background);
//background = Scalar::all(0);
}
addWeighted(background, alphaParam, img, 1-alphaParam, 0.0, background);
background.copyTo(img_output);
firstTime = false;
}
void coherenceEnhancingShockFilter(cv::InputArray src, cv::OutputArray dest_, const int sigma, const int str_sigma_, const double blend, const int iter)
{
Mat dest = src.getMat();
const int str_sigma = min(31, str_sigma_);
for (int i = 0; i < iter; i++)
{
Mat gray;
if (src.channels() == 3)cvtColor(dest, gray, CV_BGR2GRAY);
else gray = dest;
Mat eigen;
if (gray.type() == CV_8U || gray.type() == CV_32F || gray.type() == CV_64F)
cornerEigenValsAndVecs(gray, eigen, str_sigma, 3);
else
{
Mat grayf; gray.convertTo(grayf, CV_32F);
cornerEigenValsAndVecs(grayf, eigen, str_sigma, 3);
}
vector<Mat> esplit(6);
split(eigen, esplit);
Mat x = esplit[2];
Mat y = esplit[3];
Mat gxx;
Mat gyy;
Mat gxy;
Sobel(gray, gxx, CV_32F, 2, 0, sigma);
Sobel(gray, gyy, CV_32F, 0, 2, sigma);
Sobel(gray, gxy, CV_32F, 1, 1, sigma);
Mat gvv = x.mul(x).mul(gxx) + 2 * x.mul(y).mul(gxy) + y.mul(y).mul(gyy);
Mat mask;
compare(gvv, 0, mask, cv::CMP_LT);
Mat di, ero;
erode(dest, ero, Mat());
dilate(dest, di, Mat());
di.copyTo(ero, mask);
addWeighted(dest, blend, ero, 1.0 - blend, 0.0, dest);
}
dest.copyTo(dest_);
}
void caasCLR4Tx1::FindIsolatorAngle()
{
//We cut 4/5 width of isolator out
int height = 3 * (isolatorBottomEdge - isolatorTopEdge) / 2; int middle = (isolatorBottomEdge + isolatorTopEdge) / 2;
Rect rect = Rect(isolatorRightEdge - 4 * isolatorWidth / 5, middle - height / 2, 4 * isolatorWidth / 5, height);
Mat imageIsolator = imageGray(rect);
int scale = 4;
resize(imageIsolator, imageIsolator, Size(imageIsolator.cols / scale, imageIsolator.rows / scale));
#if _DEBUG
imwrite("Isolator.jpg", imageIsolator);
#endif
//sharpen the image
//Unsharping masking: Use a Gaussian smoothing filter and subtract the smoothed version from the original image (in a weighted way so the values of a constant area remain constant).
Mat imageBlurred, imageGraySharpened; double GAUSSIAN_RADIUS = 4.0;
GaussianBlur(imageIsolator, imageBlurred, Size(0, 0), GAUSSIAN_RADIUS);
addWeighted(imageIsolator, 1.5, imageBlurred, -0.5, 0, imageGraySharpened);
#if _DEBUG
//imageGraySharpened = imageGrayQuarter;
imwrite("IsolatorSharpened.jpg", imageGraySharpened);
#endif
imageGraySharpened = imageIsolator;
//Histogram Equalization
equalizeHist(imageGraySharpened, imageGraySharpened);
#if _DEBUG
imwrite("IsolatorEqualized.jpg", imageGraySharpened);
#endif
//Otsu binarization
Mat imageOtsu; threshold(imageGraySharpened, imageOtsu, 0, 255, CV_THRESH_BINARY | CV_THRESH_OTSU);
#if _DEBUG
imwrite("IsolatorOtsu.jpg", imageOtsu);
#endif
//Canny Edge Detection
int median = Median(imageGraySharpened);
Mat imageCanny; Canny(imageGraySharpened, imageCanny, 0.66 * median, 1.33 * median);
#if _DEBUG
imwrite("IsolatorCanny.jpg", imageCanny);
#endif
}
/**
* Main processing function.
* Read input image and create vector of images for each digit.
*/
void ImageProcessor::process() {
_digits.clear();
// convert to gray
cvtColor(_img, _imgGray, CV_BGR2GRAY);
fastNlMeansDenoising(_imgGray, _imgGray, 10);
cv::imshow("Denoising", _imgGray);
_imgCalque = imread("./images/calque.png");
cvtColor(_imgCalque, _imgCalqueGray, CV_BGR2GRAY);
addWeighted( _imgGray, 0.65, _imgCalqueGray, 0.35, 0.0, _imgGray);
cv::imshow("ImageProcessor1", _imgGray);
threshold(_imgGray, _imgGray, 135, 255, 3);
cv::imshow("ImageProcessor2", _imgGray);
// find and isolate counter digits
findCounterDigits();
if (_debugWindow) {
showImage();
}
}
Mat EdgeHandle::MatIllumination(Mat img){
Mat src, src_gray;
Mat grad;
int scale = 1;
int delta = 0;
int ddepth = CV_16S;
int c;
/// Load an image
src = img;
GaussianBlur( src, src, Size(3,3), 0, 0, BORDER_DEFAULT );
/// Convert it to gray
cvtColor( src, src_gray, CV_RGB2GRAY );
/// Generate grad_x and grad_y
Mat grad_x, grad_y;
Mat abs_grad_x, abs_grad_y;
//sobel
Sobel( src_gray, grad_x, ddepth, 1, 0, 3, scale, delta, BORDER_DEFAULT );
convertScaleAbs( grad_x, abs_grad_x );
Sobel( src_gray, grad_y, ddepth, 0, 1, 3, scale, delta, BORDER_DEFAULT );
convertScaleAbs( grad_y, abs_grad_y );
addWeighted( abs_grad_x, 0.5, abs_grad_y, 0.5, 0, grad );
// binary image.
//threshold(grad,grad,0,255,THRESH_BINARY);
// Apply the specified morphology operation
int morph_size = 1;
Mat element = getStructuringElement( 1, Size( 2*morph_size + 1, 2*morph_size+1 ), Point( morph_size, morph_size ) );
morphologyEx( grad, grad, 5, element );
morphologyEx( grad, grad, 5, element );
morphologyEx( grad, grad, 5, element );
return grad;
}
void FWImage::createGrad(int scale,int delta)
{
/// Generate grad_x and grad_y
Mat grad_x, grad_y;
Mat abs_grad_x, abs_grad_y;
int ddepth = CV_16S;
/// Gradient X
//Scharr( src_gray, grad_x, ddepth, 1, 0, scale, delta, BORDER_DEFAULT );
Sobel( this->iGray, grad_x, ddepth, 1, 0, 3, scale, delta, BORDER_DEFAULT );
convertScaleAbs( grad_x, abs_grad_x );
/// Gradient Y
//Scharr( src_gray, grad_y, ddepth, 0, 1, scale, delta, BORDER_DEFAULT );
Sobel( this->iGray, grad_y, ddepth, 0, 1, 3, scale, delta, BORDER_DEFAULT );
convertScaleAbs( grad_y, abs_grad_y );
/// Total Gradient (approximate)
addWeighted( abs_grad_x, 0.5, abs_grad_y, 0.5, 0, this->iGrad );
}
/**
* Efeito de pintura.
*/
void edgeDetectSobel(Mat& img) {
Mat gray, temp;
GaussianBlur(img, img, Size(3, 3), 0, 0);
cvtColor(img, gray, CV_RGB2GRAY);
//x
Sobel(gray, img, CV_16S, 1, 0, 3, 1.5, 0.3, BORDER_DEFAULT);
convertScaleAbs(img, img);
//y
Sobel(gray, temp, CV_16S, 0, 1, 3, 1.5, 0.4, BORDER_DEFAULT);
convertScaleAbs(temp, temp);
addWeighted(img, .3, temp, .3, .3, img);
erode(img, img,
getStructuringElement(MORPH_ELLIPSE,
Size(dilation_size + 1, dilation_size + 1),
Point(dilation_size, dilation_size)));
bitwise_not(img, img);
cvtColor(img, img, CV_GRAY2BGR);
}
void RoadDetection::drawRoadShape(Mat frame, vector<Point> points, Scalar color, double alpha)
{
Mat copy;
Point shapePoints[1][3];
int npt[] = { 3 };
if (points.size() <= 0)
{
return;
}
for (size_t i = 0; i < points.size(); i++)
{
shapePoints[0][i] = points[i];
}
const Point* ppt[1] = { shapePoints[0] };
frame.copyTo(copy);
fillPoly(copy, ppt, npt, 1, color, CV_AA);
addWeighted(copy, alpha, frame, 1.0 - alpha, 0.0, frame);
}
Mat gradient(Mat src) {
int scale = 1;
int delta = 0;
int ddepth = CV_16S;
Mat grad_x, grad_y;
Mat abs_grad_x, abs_grad_y, grad, gradh, gradl;
/// Gradient X
//Scharr( src_gray, grad_x, ddepth, 1, 0, scale, delta, BORDER_DEFAULT );
Sobel(src, grad_x, ddepth, 1, 0, 3, scale, delta, BORDER_DEFAULT);
convertScaleAbs(grad_x, abs_grad_x);
/// Gradient Y
//Scharr( src_gray, grad_y, ddepth, 0, 1, scale, delta, BORDER_DEFAULT );
Sobel(src, grad_y, ddepth, 0, 1, 3, scale, delta, BORDER_DEFAULT);
convertScaleAbs(grad_y, abs_grad_y);
/// Total Gradient (approximate)
addWeighted(abs_grad_x, 0.5, abs_grad_y, 0.5, 0, grad);
return grad;
}
void caasCLR4Tx1::RefineIsolator()
{
//int width = isolatorRightEdge - isolatorLeftEdge;
//int height = isolatorBottomEdge - isolatorTopEdge;
//Expand horizontally 1 time to the right; expand vertically 1/2
int left = isolatorLeftEdge;
int right = left + 2 * isolatorWidth; if (right > targetLeftEdge - 20) right = targetLeftEdge - 20;
int top = isolatorTopEdge - isolatorHeight / 4;
int bottom = top + isolatorHeight + isolatorHeight / 2;
Rect roi = Rect(left, top, right - left, bottom - top);
imageIsolatorRoi = imageGray(roi);
#if _DEBUG
imwrite("5.1.IsolatorRoi.jpg", imageIsolatorRoi);
#endif
int scale = 4;
resize(imageIsolatorRoi, imageIsolatorRoi, Size(imageIsolatorRoi.cols / scale, imageIsolatorRoi.rows / scale));
Mat imageBlurred, imageGraySharpened; double GAUSSIAN_RADIUS = 4.0;
GaussianBlur(imageIsolatorRoi, imageBlurred, Size(0, 0), GAUSSIAN_RADIUS);
addWeighted(imageIsolatorRoi, 2.5, imageBlurred, -1.5, 0, imageGraySharpened);
#if _DEBUG
imwrite("5.2.IsolatorRoiSharpened.jpg", imageGraySharpened);
#endif
int median = Median(imageGraySharpened);
Mat imageCanny; Canny(imageGraySharpened, imageCanny, 0.66 * median, 1.33 * median);
#if _DEBUG
imwrite("5.3.IsolatorRoiCanny.jpg", imageCanny);
#endif
Mat Points; findNonZero(imageCanny, Points);
Rect Min_Rect = boundingRect(Points);
isolatorRightEdge = roi.x + (Min_Rect.x + Min_Rect.width) * scale;
RotatedRect rect = minAreaRect(Points);
isolatorAngle = rect.angle;
}
Mat AntiShake::BorderDetector(Mat src, int type) {
Mat dst;
if (type == 0) {
// ----- Sobel:
Mat grad_x, grad_y, grad;
Mat abs_grad_x, abs_grad_y;
int ddepth = CV_16S;
int border = BORDER_ISOLATED;
Sobel(src, grad_x, ddepth, 1, 0, 3, 1, 1, border);
convertScaleAbs(grad_x, abs_grad_x);
Sobel(src, grad_y, ddepth, 0, 1, 3, 1, 1, border);
convertScaleAbs(grad_y, abs_grad_y);
addWeighted(abs_grad_x, 0.5, abs_grad_y, 0.5, 0, grad);
grad.copyTo(dst);
// threshold(dst, dst, 150, 255, cv::THRESH_TOZERO);
} else if (type == 1) {
// ----- Canny Corner Detector
Canny(src, dst, 200, 6000, 5, true);
} else if (type == 2) {
// ----- Laplacian:
Laplacian(src, dst, CV_8UC1, 1, 1, 1);
} else {
// ----- Magic Laplacian:
cv::Laplacian(src, dst, CV_32F, 9);
double scale = -1.0;
if (scale < 0) {
double lapmin, lapmax;
cv::minMaxLoc(dst, &lapmin, &lapmax);
scale = 255 / std::max(-lapmin, lapmax);
}
dst.convertTo(dst, CV_8U, scale, 256);
}
return dst;
}
void guiAlphaBlend(const Mat& src1, const Mat& src2)
{
Mat s1,s2;
if(src1.channels()==1)cvtColor(src1,s1,CV_GRAY2BGR);
else s1 = src1;
if(src2.channels()==1)cvtColor(src2,s2,CV_GRAY2BGR);
else s2 = src2;
namedWindow("alphaBlend");
int a = 0;
createTrackbar("a","alphaBlend",&a,100);
int key = 0;
Mat show;
while(key!='q')
{
addWeighted(s1,1.0-a/100.0,s2,a/100.0,0.0,show);
imshow("alphaBlend",show);
key = waitKey(1);
if(key=='f')
{
a = (a > 0) ? 0 : 100;
setTrackbarPos("a","alphaBlend",a);
}
}
}
// !车牌识别模块
int CPlateRecognize::plateRecognize(Mat src, std::vector<string> &licenseVec) {
// 车牌方块集合
vector<CPlate> plateVec;
// 进行深度定位，使用颜色信息与二次Sobel
int resultPD = plateDetect(src, plateVec, getPDDebug(), 0);
if (resultPD == 0) {
int num = plateVec.size();
int index = 0;
//依次识别每个车牌内的符号
for (int j = 0; j < num; j++) {
CPlate item = plateVec[j];
Mat plate = item.getPlateMat();
//获取车牌颜色
string plateType = getPlateColor(plate);
//获取车牌号
string plateIdentify = "";
int resultCR = charsRecognise(plate, plateIdentify);
if (resultCR == 0) {
string license = plateType + ":" + plateIdentify;
licenseVec.push_back(license);
}
}
//完整识别过程到此结束
//如果是Debug模式，则还需要将定位的图片显示在原图左上角
if (getPDDebug() == true) {
Mat result;
src.copyTo(result);
for (int j = 0; j < num; j++) {
CPlate item = plateVec[j];
Mat plate = item.getPlateMat();
int height = 36;
int width = 136;
if (height * index + height < result.rows) {
Mat imageRoi = result(Rect(0, 0 + height * index, width, height));
addWeighted(imageRoi, 0, plate, 1, 0, imageRoi);
}
index++;
RotatedRect minRect = item.getPlatePos();
Point2f rect_points[4];
minRect.points(rect_points);
Scalar lineColor = Scalar(255, 255, 255);
if (item.getPlateLocateType() == SOBEL) lineColor = Scalar(255, 0, 0);
if (item.getPlateLocateType() == COLOR) lineColor = Scalar(0, 255, 0);
for (int j = 0; j < 4; j++)
line(result, rect_points[j], rect_points[(j + 1) % 4], lineColor, 2,
8);
}
//显示定位框的图片
showResult(result);
}
}
return resultPD;
}
void MapsMerge::ImagesMergerStrategy::mergeImages(ImagesMatches& imgsMatches) {
addWeighted(imgsMatches.imgFeatures2.img, 0.5, imgsMatches.transformedImage, 1, 0.0, imgsMatches.mergedImages);
}
