public static Mat drawContours(List<MatOfPoint> contours, Mat mBase) { Mat mResult = Element.getNewMat(); Core.subtract(mBase, mBase, mResult); Imgproc.drawContours(mResult, contours, -1, new Scalar(255)); return mResult; }
public static List<Element> detectChanges(Mat base, Mat mChanged) { int PIXEL_DIFF_THRESHOLD = 3; int IMAGE_DIFF_THRESHOLD = 5; Mat mBaseGray = Element.getNewMat(); Mat mChangedGray = Element.getNewMat(); Mat mDiffAbs = Element.getNewMat(); Mat mDiffTresh = Element.getNewMat(); Mat mChanges = Element.getNewMat(); List<Element> rectangles = new ArrayList<>(); Imgproc.cvtColor(base, mBaseGray, toGray); Imgproc.cvtColor(mChanged, mChangedGray, toGray); Core.absdiff(mBaseGray, mChangedGray, mDiffAbs); Imgproc.threshold(mDiffAbs, mDiffTresh, PIXEL_DIFF_THRESHOLD, 0.0, Imgproc.THRESH_TOZERO); if (Core.countNonZero(mDiffTresh) > IMAGE_DIFF_THRESHOLD) { Imgproc.threshold(mDiffAbs, mDiffAbs, PIXEL_DIFF_THRESHOLD, 255, Imgproc.THRESH_BINARY); Imgproc.dilate(mDiffAbs, mDiffAbs, Element.getNewMat()); Mat se = Imgproc.getStructuringElement(Imgproc.MORPH_ELLIPSE, new Size(5, 5)); Imgproc.morphologyEx(mDiffAbs, mDiffAbs, Imgproc.MORPH_CLOSE, se); List<MatOfPoint> contours = new ArrayList<MatOfPoint>(); Mat mHierarchy = Element.getNewMat(); Imgproc.findContours(mDiffAbs, contours, mHierarchy, Imgproc.RETR_LIST, Imgproc.CHAIN_APPROX_SIMPLE); rectangles = contoursToRectangle(contours); Core.subtract(mDiffAbs, mDiffAbs, mChanges); Imgproc.drawContours(mChanges, contours, -1, new Scalar(255)); //logShow(mDiffAbs); } return rectangles; }
private Mat doFindMatch(Element target, Mat mBase, Element probe) { if (SX.isNull(probe)) { probe = target; } Mat mResult = Element.getNewMat(); Mat mProbe = probe.getContentBGR(); if (!target.isPlainColor()) { if (probe.hasMask()) { Mat mMask = matMulti(probe.getMask(), mProbe.channels()); Imgproc.matchTemplate(mBase, mProbe, mResult, Imgproc.TM_CCORR_NORMED, mMask); } else { Imgproc.matchTemplate(mBase, mProbe, mResult, Imgproc.TM_CCOEFF_NORMED); } } else { Mat mBasePlain = mBase; Mat mProbePlain = mProbe; if (target.isBlack()) { Core.bitwise_not(mBase, mBasePlain); Core.bitwise_not(mProbe, mProbePlain); } if (probe.hasMask()) { Mat mMask = matMulti(probe.getMask(), mProbe.channels()); Imgproc.matchTemplate(mBasePlain, mProbePlain, mResult, Imgproc.TM_SQDIFF_NORMED, mMask); } else { Imgproc.matchTemplate(mBasePlain, mProbePlain, mResult, Imgproc.TM_SQDIFF_NORMED); } Core.subtract(Mat.ones(mResult.size(), CvType.CV_32F), mResult, mResult); } return mResult; }
public void actionPerformed(ActionEvent arg0) { Mat gp1 = new Mat(); Imgproc.pyrDown(image, gp1); Imgproc.pyrUp(gp1, gp1); Core.subtract(image, gp1, gp1); updateView(gp1); } });
private Mat negative(Mat foregroundThresh) { Mat result = new Mat(); Mat white = foregroundThresh.clone(); white.setTo(new Scalar(255.0)); Core.subtract(white, foregroundThresh, result); return result; }
private void HitAndMiss(Mat src, Mat dst, Mat positive, Mat negative) { Imgproc.erode(src, dst, positive); Core.subtract(Mat.ones(src.size(), CvType.CV_8UC1), src, tmpMat_); Imgproc.erode(tmpMat_, tmpMat_, negative); Core.bitwise_and(tmpMat_, dst, dst); }
/** * Edge thinning, based on the awesome algorithm suggested here: * http://homepages.inf.ed.ac.uk/rbf/HIPR2/thin.htm */ private void thin(Mat image) { Mat tmp = new Mat(); int prevnz = Core.countNonZero(image); Log.v(TAG, "Starting thinning. NZ=" + prevnz); while (true) { for (int i = 0; i < 4; ++i) { HitAndMiss(image, tmp, HNM1POS, HNM1NEG); Core.subtract(image, tmp, image); HitAndMiss(image, tmp, HNM2POS, HNM2NEG); Core.subtract(image, tmp, image); rotateCCW(HNM1POS); rotateCCW(HNM1NEG); rotateCCW(HNM2POS); rotateCCW(HNM2NEG); } int nz = Core.countNonZero(image); if (nz == prevnz) break; prevnz = nz; } Log.v(TAG, "Thinning done. NZ=" + prevnz); }
private void clear() { // Resize to native resolution divided by blur factor. float scale = LINE_WIDTH_TO_IMAGE_WIDTH / blur_ / srcImage_.cols(); Imgproc.resize(srcImage_, imageResidue_, new Size(), scale, scale, Imgproc.INTER_AREA); // Negative. final Mat scalar = new Mat(1, 1, CvType.CV_64FC1).setTo(new Scalar(255)); Core.subtract(scalar, imageResidue_, imageResidue_); // Convert to S16. imageResidue_.convertTo(imageResidue_, CvType.CV_16SC1); // Full scale is now blur * GRAY_RESOLUTION. Core.multiply(imageResidue_, new Scalar(blur_ * GRAY_RESOLUTION / 255), imageResidue_); // Clear map. curves_.clear(); kernelFactory_.setDimensions(imageResidue_.width(), imageResidue_.height()); }
private void addNoise() { image = originalImage.clone(); Mat grayRnd = new Mat(image.rows(), image.cols(), image.type()); double noise = 128; grayRnd.setTo(new Scalar(noise/2, noise/2, noise/2)); Core.subtract(image, grayRnd, image); Core.randu(grayRnd, 0, noise); Core.add(image, grayRnd, image); processOperation(); updateView(); }
private Core.MinMaxLocResult doFindMatch(Mat base, Mat probe) { Mat res = new Mat(); Mat bi = new Mat(); Mat pi = new Mat(); if (!isPlainColor) { Imgproc.matchTemplate(base, probe, res, Imgproc.TM_CCOEFF_NORMED); } else { if (isBlack) { Core.bitwise_not(base, bi); Core.bitwise_not(probe, pi); } else { bi = base; pi = probe; } Imgproc.matchTemplate(bi, pi, res, Imgproc.TM_SQDIFF_NORMED); Core.subtract(Mat.ones(res.size(), CvType.CV_32F), res, res); } return Core.minMaxLoc(res); }
private KernelInstance nextKernalInstance(Mat image, int numAttempts, Object context) { Mat mask = Mat.zeros(image.size(), CvType.CV_8U); Mat bestMask = Mat.zeros(image.size(), CvType.CV_8U); KernelInstance bestInstance = null; double bestScore = Float.NEGATIVE_INFINITY; for (int i = 0; i < numAttempts; ++i) { KernelInstance instance = kernelFactory_.createKernelInstance(context); mask.setTo(new Scalar(0)); instance.shape_.renderToMat(mask, new Scalar(GRAY_RESOLUTION)); double score = Core.mean(image, mask).val[0]; if (score > bestScore) { bestScore = score; Mat t = mask; mask = bestMask; bestMask = t; bestInstance = instance; } } Core.subtract(image, bestMask, image, bestMask, image.type()); return bestInstance; }