@Override public Result process(CvPipeline pipeline) throws Exception { Mat mat = pipeline.getWorkingImage(); Mat mask = mat.clone(); Mat masked = mat.clone(); Scalar color = FluentCv.colorToScalar(Color.black); mask.setTo(color); masked.setTo(color); Core.inRange( mat, new Scalar(hueMin, saturationMin, valueMin), new Scalar(hueMax, saturationMax, valueMax), mask); Core.bitwise_not(mask, mask); mat.copyTo(masked, mask); return new Result(masked); }
/** * calculates the center of mass using <code>colorForTrackingHSV</code> and <code>colorRadius * </code> as radius (in HSV-color space) * * @param hsv the frame of which the center of mass should be calculated off * @return the center of mass as a point in pixel coordinates (i.e. integer) */ public Point calcCenterOfMass(Mat hsv) { blackWhiteMask = new Mat(); Core.inRange(hsv, lowerBound, upperBound, blackWhiteMask); dilatedMask = new Mat(); Imgproc.dilate(blackWhiteMask, dilatedMask, new Mat()); contour = new ArrayList<MatOfPoint>(); Mat mHierarchy = new Mat(); Mat tempDilatedMask = dilatedMask.clone(); Imgproc.findContours( tempDilatedMask, contour, mHierarchy, Imgproc.RETR_EXTERNAL, Imgproc.CHAIN_APPROX_SIMPLE); boundingRect = Imgproc.boundingRect(findLargestContour(contour)); int centerOfMassX = boundingRect.x + boundingRect.width / 2; int centerOfMassY = boundingRect.y + boundingRect.height / 2; Point centerOfMass = new Point(centerOfMassX, centerOfMassY); trackPath.add(centerOfMass); return centerOfMass; }
public Point findLaser(Mat inputFrame) { Mat mHsv = new Mat(); Imgproc.cvtColor(inputFrame, mHsv, Imgproc.COLOR_RGB2HSV); // Find laser center Mat center = new Mat(); Core.inRange(mHsv, new Scalar(0, 0, 250), new Scalar(180, 16, 255), center); Mat h = new Mat(); List<MatOfPoint> contours = new ArrayList<MatOfPoint>(); Imgproc.findContours(center, contours, h, Imgproc.RETR_LIST, Imgproc.CHAIN_APPROX_SIMPLE); center.release(); Mat center_mask = Mat.zeros(inputFrame.rows(), inputFrame.cols(), CvType.CV_8U); if (contours.size() > 0) { for (int i = 0; i < contours.size(); i++) { int radius = 10; // Point[] cont_pos = contours.get(i).toArray(); Moments m = Imgproc.moments(contours.get(i)); Point p = new Point(); p.x = m.get_m10() / m.get_m00(); p.y = m.get_m01() / m.get_m00(); Core.circle(center_mask, p, radius * 2, new Scalar(255), -1); } } // Find halo Mat ranged = new Mat(); Core.inRange(mHsv, new Scalar(100, 32, 225), new Scalar(150, 255, 255), ranged); mHsv.release(); // Mat f_frame =ranged.clone(); // Find halo around bright dot Core.bitwise_and(ranged, center_mask, ranged); center_mask.release(); // Find biggest resulting contour for (int i = 1; i < contours.size(); i++) { contours.get(i).release(); } contours.clear(); Imgproc.findContours(ranged, contours, h, Imgproc.RETR_LIST, Imgproc.CHAIN_APPROX_SIMPLE); h.release(); ranged.release(); if (contours.size() > 0) { MatOfPoint biggest_cont = contours.get(0); double cont_size = Imgproc.contourArea(biggest_cont); for (int i = 1; i < contours.size(); i++) { MatOfPoint cur = contours.get(i); if (Imgproc.contourArea(cur) > cont_size) { biggest_cont = cur; cont_size = Imgproc.contourArea(cur); } } Moments m = Imgproc.moments(biggest_cont); Point p = new Point(); p.x = m.get_m10() / m.get_m00(); p.y = m.get_m01() / m.get_m00(); for (int i = 1; i < contours.size(); i++) { contours.get(i).release(); } biggest_cont.release(); return p; } else { return null; } }
public void processImage(Mat imageToProcess) { try { final Mat processedImage = imageToProcess.clone(); // red final Mat redUpper = new Mat(); final Mat redLower = new Mat(); Core.inRange(processedImage, new Scalar(170, 100, 20), new Scalar(180, 255, 255), redUpper); Core.inRange(processedImage, new Scalar(0, 100, 20), new Scalar(20, 255, 255), redLower); Core.bitwise_or(redLower, redUpper, processedImage); // refining the binary image Imgproc.erode(processedImage, processedImage, new Mat(), new Point(-1, -1), 1); Imgproc.dilate(processedImage, processedImage, new Mat(), new Point(-1, -1), 0); // create a clone for the processedImage to be used in finding contours final Mat clone = processedImage.clone(); Imgproc.cvtColor(processedImage, processedImage, Imgproc.COLOR_GRAY2RGB); // finds list of contours and draw the biggest on the processedImage final Scalar color1 = new Scalar(0, 0, 255); final Scalar color2 = new Scalar(255, 255, 0); final Scalar color3 = new Scalar(255, 255, 255); final List<MatOfPoint> contours = new ArrayList<MatOfPoint>(); Imgproc.findContours( clone, contours, new Mat(), Imgproc.RETR_LIST, Imgproc.CHAIN_APPROX_NONE); final List<MatOfPoint> contour = new ArrayList<MatOfPoint>(1); double maxArea = 0.0; for (int index = 0; index < contours.size(); index++) { double area = Imgproc.contourArea(contours.get(index)); if (area > maxArea && area > 25 && Imgproc.boundingRect(contours.get(index)).y > 40) { maxArea = area; contour.add(0, contours.get(index)); } } // finds bounding Rectangle and draws contours Rect boundingRect = new Rect(); if (contour.size() > 0) { Imgproc.drawContours(processedImage, contour, -2, color1); boundingRect = Imgproc.boundingRect(contour.get(0)); final double x = boundingRect.x; final double y = boundingRect.y; final double width = boundingRect.width; final double height = boundingRect.height; Core.rectangle(processedImage, new Point(x, y), new Point(x + width, y + height), color3); } // finding bounding Circle and draws it final Point center = new Point(); final float[] radius = new float[1]; if (contour.size() > 0) { final MatOfPoint2f contour2f = new MatOfPoint2f(contour.get(0).toArray()); Imgproc.minEnclosingCircle(contour2f, center, radius); Core.circle(processedImage, center, (int) radius[0], color2); } final BallStruct redBallStruct = new BallStruct(boundingRect, center, (double) radius[0]); final BallTargeting ballTargeting = new BallTargeting(redBallStruct); synchronized (this) { distanceToRed = ballTargeting.getDistance(); angleToRedInDegrees = ballTargeting.getAngle() * (180 / Math.PI); this.processedImage = processedImage; } } catch (Exception e) { } }
public void process(Mat rgbaImage) { Mat pyrDownMat = new Mat(); Imgproc.pyrDown(rgbaImage, pyrDownMat); Imgproc.pyrDown(pyrDownMat, pyrDownMat); Mat hsvMat = new Mat(); Imgproc.cvtColor(pyrDownMat, hsvMat, Imgproc.COLOR_RGB2HSV_FULL); Mat Mask = new Mat(); Core.inRange(hsvMat, mLowerBound, mUpperBound, Mask); Mat dilatedMask = new Mat(); Imgproc.dilate(Mask, dilatedMask, new Mat()); List<MatOfPoint> contours = new ArrayList<MatOfPoint>(); Mat hierarchy = new Mat(); Imgproc.findContours( dilatedMask, contours, hierarchy, Imgproc.RETR_EXTERNAL, Imgproc.CHAIN_APPROX_SIMPLE); blobCenters[0] = new Point(); blobCenters[1] = new Point(); if (contours.size() > 0) { // Find max contour area of the two biggest double[] maxArea = new double[2]; maxArea[0] = 0; // biggest maxArea[1] = 0; // 2nd biggest Iterator<MatOfPoint> each = contours.iterator(); int[] contourIndex = new int[2]; contourIndex[0] = 0; contourIndex[1] = 0; int index = 0; while (each.hasNext()) { MatOfPoint wrapper = each.next(); double area = Imgproc.contourArea(wrapper); if (area > maxArea[0]) { // area bigger than the maximum found maxArea[1] = maxArea[0]; contourIndex[1] = contourIndex[0]; maxArea[0] = area; contourIndex[0] = index; } else if (area > maxArea[1]) { // area bigger than the second maximum found maxArea[1] = area; contourIndex[1] = index; } index++; } // // another possibility to iterate through contours // for (index = 0; index < contours.size(); index++) { // d = Imgproc.contourArea (contours.get(index)); Log.d("index0", Integer.toString(contourIndex[0])); Log.d("index1", Integer.toString(contourIndex[1])); MatOfPoint2f mMOP2f1 = new MatOfPoint2f(); float[] radius = new float[contours.size()]; // contours is a List<MatOfPoint> // so contours.get(x) is a single MatOfPoint // but to use approxPolyDP we need to pass a MatOfPoint2f // so we need to do a conversion contours.get(contourIndex[0]).convertTo(mMOP2f1, CvType.CV_32FC2); // get the center of the bigger contour found Point tempCenter = new Point(); Imgproc.minEnclosingCircle(mMOP2f1, tempCenter, radius); blobCenters[0].x = tempCenter.x; blobCenters[0].y = tempCenter.y; blobRadius[0] = radius[0]; Log.d("center0.x", Double.toString(blobCenters[0].x)); Log.d("center0.y", Double.toString(blobCenters[0].y)); Log.d("radius0", Double.toString(blobRadius[0])); contours.get(contourIndex[1]).convertTo(mMOP2f1, CvType.CV_32FC2); Imgproc.minEnclosingCircle(mMOP2f1, tempCenter, radius); blobCenters[1].x = tempCenter.x; blobCenters[1].y = tempCenter.y; blobRadius[1] = radius[0]; Log.d("center1.x", Double.toString(blobCenters[1].x)); Log.d("center1.y", Double.toString(blobCenters[1].y)); Log.d("radius1", Double.toString(blobRadius[1])); // Filter contours by area and resize to fit the original image size mContours.clear(); each = contours.iterator(); while (each.hasNext()) { MatOfPoint contour = each.next(); if (Imgproc.contourArea(contour) > mMinContourArea * maxArea[1]) { Core.multiply(contour, new Scalar(4, 4), contour); mContours.add(contour); } } } else { blobCenters[0].x = 0; blobCenters[0].y = 0; blobCenters[1].x = 0; blobCenters[1].y = 0; } }
private Mat InRangeCircles(Mat src) { Core.inRange(src, new Scalar(148, 40, 50), new Scalar(179, 255, 255), img_bw1); Core.inRange(src, new Scalar(0, 50, 50), new Scalar(10, 255, 255), img_bw2); Core.bitwise_or(img_bw1, img_bw2, temp); return temp; }