public boolean hasChanges(Mat current) { int PIXEL_DIFF_THRESHOLD = 5; int IMAGE_DIFF_THRESHOLD = 5; Mat bg = new Mat(); Mat cg = new Mat(); Mat diff = new Mat(); Mat tdiff = new Mat(); Imgproc.cvtColor(base, bg, Imgproc.COLOR_BGR2GRAY); Imgproc.cvtColor(current, cg, Imgproc.COLOR_BGR2GRAY); Core.absdiff(bg, cg, diff); Imgproc.threshold(diff, tdiff, PIXEL_DIFF_THRESHOLD, 0.0, Imgproc.THRESH_TOZERO); if (Core.countNonZero(tdiff) <= IMAGE_DIFF_THRESHOLD) { return false; } Imgproc.threshold(diff, diff, PIXEL_DIFF_THRESHOLD, 255, Imgproc.THRESH_BINARY); Imgproc.dilate(diff, diff, new Mat()); Mat se = Imgproc.getStructuringElement(Imgproc.MORPH_ELLIPSE, new Size(5, 5)); Imgproc.morphologyEx(diff, diff, Imgproc.MORPH_CLOSE, se); List<MatOfPoint> points = new ArrayList<MatOfPoint>(); Mat contours = new Mat(); Imgproc.findContours(diff, points, contours, Imgproc.RETR_LIST, Imgproc.CHAIN_APPROX_SIMPLE); int n = 0; for (Mat pm : points) { log(lvl, "(%d) %s", n++, pm); printMatI(pm); } log(lvl, "contours: %s", contours); printMatI(contours); return true; }
public Mat convertImageToBlackWhite(Mat imageMat, boolean applyGaussBlur) { Mat imageCloneMat = imageMat.clone(); if (applyGaussBlur) { Imgproc.GaussianBlur(imageCloneMat, imageCloneMat, new Size(3, 3), 0, 0); } double thresh = Imgproc.threshold( imageCloneMat, imageCloneMat, 0, 255, Imgproc.THRESH_BINARY | Imgproc.THRESH_OTSU); Imgproc.threshold(imageCloneMat, imageCloneMat, thresh, 255, Imgproc.THRESH_BINARY_INV); return (imageCloneMat); }
public static Mat warp(Mat inputMat, Mat startM, int factor) { int resultWidth = 400 * factor; int resultHeight = 240 * factor; Mat outputMat = new Mat(resultWidth, resultHeight, CvType.CV_8UC4); Point ocvPOut1 = new Point(0, 0); Point ocvPOut2 = new Point(0, resultHeight); Point ocvPOut3 = new Point(resultWidth, resultHeight); Point ocvPOut4 = new Point(resultWidth, 0); List<Point> dest = new ArrayList<Point>(); dest.add(ocvPOut1); dest.add(ocvPOut2); dest.add(ocvPOut3); dest.add(ocvPOut4); Mat endM = Converters.vector_Point2f_to_Mat(dest); Mat perspectiveTransform = Imgproc.getPerspectiveTransform(startM, endM); Imgproc.warpPerspective( inputMat, outputMat, perspectiveTransform, new Size(resultWidth, resultHeight), Imgproc.INTER_AREA); Imgproc.GaussianBlur(outputMat, outputMat, new org.opencv.core.Size(5, 5), 5); Imgproc.resize(outputMat, outputMat, new Size(resultWidth / factor, resultHeight / factor)); Imgproc.threshold(outputMat, outputMat, 127, 255, Imgproc.THRESH_TOZERO); return outputMat; }
/** * Generates a mask of all resistors present in the given Mat. Also displays this mask in the * Bottom Left frame of the GUI. * * @param imgCap The Mat image to generate the mask for * @param type The threshold operation type * @return The mask as a Mat */ private Mat generateResistorMask(Mat imgCap, int type) { Mat imgHSV = new Mat(); Mat satImg = new Mat(); // convert the input image from BGR to HSV Imgproc.cvtColor(imgCap, imgHSV, Imgproc.COLOR_BGR2HSV); ArrayList<Mat> channels = new ArrayList<Mat>(); Core.split(imgHSV, channels); // extract the saturation channel satImg = channels.get(1); // remove the background and the resistor leads (combined with previous blurring) // thresh ~86 Imgproc.threshold(satImg, satImg, RESISTOR_MASK_THRESHOLD, 255, type); paintBL(satImg); return satImg; }
/** * @param inputImg * @param minValue * @param maxValue * @return Mat */ public static Mat thresholding(Mat inputImg, Integer minValue, Integer maxValue) { Mat frame = inputImg; // яскравість // frame.convertTo(frame , -1, 10d * 33 / 100, 0); // Imgproc.medianBlur(frame,frame, 17); // Core.bitwise_not(frame,frame ); // Mat frame = new Mat(image.rows(), image.cols(), image.type()); // frame.convertTo(frame, -1, 10d * 20 / 100, 0); Mat hsvImg = new Mat(); List<Mat> hsvPlanes = new ArrayList<>(); Mat thresholdImg = new Mat(); int thresh_type = Imgproc.THRESH_BINARY_INV; // if (this.inverse.isSelected()) // thresh_type = Imgproc.THRESH_BINARY; // threshold the image with the average hue value // System.out.println("size " +frame.size()); hsvImg.create(frame.size(), CvType.CV_8U); // Imgproc.cvtColor(frame, hsvImg, Imgproc.COLOR_BGR2HSV); Core.split(hsvImg, hsvPlanes); // get the average hue value of the image // double threshValue = PreProcessingOperation.getHistAverage(hsvImg, hsvPlanes.get(0)); // System.out.println(threshValue); /* if(threshValue > 40){ maxValue = 160; }else{ maxValue = 40; }*/ // Imgproc.threshold(hsvPlanes.get(1), thresholdImg, minValue , maxValue , thresh_type); Imgproc.blur(thresholdImg, thresholdImg, new Size(27, 27)); // dilate to fill gaps, erode to smooth edges Imgproc.dilate(thresholdImg, thresholdImg, new Mat(), new Point(-1, -1), 1); Imgproc.erode(thresholdImg, thresholdImg, new Mat(), new Point(-1, -1), 1); Imgproc.threshold(thresholdImg, thresholdImg, minValue, maxValue, Imgproc.THRESH_BINARY); // create the new image Mat foreground = new Mat(frame.size(), CvType.CV_8UC3, new Scalar(255, 255, 255)); Core.bitwise_not(thresholdImg, foreground); frame.copyTo(foreground, thresholdImg); /////////////////////////////////////////////////////////////////////////////////////// /// //// return foreground; /*Mat hsvImg = new Mat(); List<Mat> hsvPlanes = new ArrayList<>(); Mat thresholdImg = new Mat(); int thresh_type = Imgproc.THRESH_BINARY_INV; // threshold the image with the average hue value hsvImg.create(inputImg.size(), CvType.CV_8U); Imgproc.cvtColor(inputImg, hsvImg, Imgproc.COLOR_BGR2HSV); Core.split(hsvImg, hsvPlanes); // get the average hue value of the image double threshValue = PreProcessingOperation.getHistAverage(hsvImg, hsvPlanes.get(0)); Imgproc.threshold(hsvPlanes.get(0), thresholdImg, minValue, maxValue, thresh_type); Imgproc.blur(thresholdImg, thresholdImg, new Size(3, 3)); // dilate to fill gaps, erode to smooth edges Imgproc.dilate(thresholdImg, thresholdImg, new Mat(), new Point(-1, -1), 3); Imgproc.erode(thresholdImg, thresholdImg, new Mat(), new Point(-1, -1), 1); Imgproc.threshold(thresholdImg, thresholdImg, minValue, maxValue, Imgproc.THRESH_BINARY); // create the new image Mat foreground = new Mat(inputImg.size(), CvType.CV_8UC3, new Scalar(255, 255, 255)); inputImg.copyTo(foreground, thresholdImg); Core.bitwise_not(foreground,foreground); return foreground;*/ }
/** * @param inputImg * @return Mat */ public static Mat kmeans(Mat inputImg) { Mat rgba = inputImg; Mat tempMat = inputImg; rgba = new Mat(inputImg.cols(), inputImg.rows(), CvType.CV_8UC3); inputImg.copyTo(rgba); List<Mat> hsv_planes_temp = new ArrayList<Mat>(3); Core.split(tempMat, hsv_planes_temp); double threshValue1 = PreProcessingOperation.getHistAverage(inputImg, hsv_planes_temp.get(0)); sample.util.Estimate.setFirstHistAverageValue(threshValue1); System.out.println("Defore eqau " + threshValue1); System.out.println( Estimate.getBlueAverage() + " ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"); if (threshValue1 > 140) { if (Estimate.getBlueAverage() > 110) { rgba.convertTo(rgba, -1, 10d * 31 / 100, 0); System.out.println("11"); } else { rgba.convertTo(rgba, -1, 10d * 40 / 100, 0); System.out.println("12"); } } else if (threshValue1 > 135) { rgba.convertTo(rgba, -1, 10d * 32 / 100, 0); System.out.println("21"); } else if (threshValue1 > 125) { if (Estimate.getBlueAverage() > 110) { rgba.convertTo(rgba, -1, 10d * 30 / 100, 0); rgba = PreProcessing.Dilate(rgba, 5); System.out.println("31"); } else { rgba.convertTo(rgba, -1, 10d * 37 / 100, 0); System.out.println("32"); } } else if (threshValue1 > 120) { rgba.convertTo(rgba, -1, 10d * 35 / 100, 0); System.out.println("41"); } else if (threshValue1 > 110) { if (Estimate.getBlueAverage() > 110) { rgba.convertTo(rgba, -1, 10d * 35 / 100, 0); rgba = PreProcessing.Dilate(rgba, 5); System.out.println("51"); } } else if (threshValue1 > 100) { if (Estimate.getBlueAverage() > 107) { rgba.convertTo(rgba, -1, 10d * 24 / 100, 0); rgba = PreProcessing.Dilate(rgba, 5); System.out.println("61"); } else if (Estimate.getBlueAverage() > 90) { rgba.convertTo(rgba, -1, 10d * 30 / 100, 0); rgba = PreProcessing.Dilate(rgba, 5); System.out.println("62"); } } else if (threshValue1 > 50) { if (Estimate.getBlueAverage() > 160) { rgba.convertTo(rgba, -1, 10d * 30 / 100, 0); rgba = PreProcessing.Dilate(rgba, 3); System.out.println("81"); } else if (Estimate.getBlueAverage() > 160) { rgba.convertTo(rgba, -1, 10d * 27 / 100, 0); rgba = PreProcessing.Dilate(rgba, 9); System.out.println("82"); } else if (Estimate.getBlueAverage() > 130) { rgba.convertTo(rgba, -1, 10d * 30 / 100, 0); rgba = PreProcessing.Dilate(rgba, 9); System.out.println("83"); } else if (Estimate.getBlueAverage() > 70) { rgba.convertTo(rgba, -1, 10d * 29 / 100, 0); rgba = PreProcessing.Dilate(rgba, 9); System.out.println("84"); } } else if (threshValue1 > 30) { if (Estimate.getBlueAverage() > 190) { rgba.convertTo(rgba, -1, 10d * 25 / 100, 0); System.out.println("91"); } else if (Estimate.getBlueAverage() > 160) { rgba.convertTo(rgba, -1, 10d * 35 / 100, 0); System.out.println("92"); } } else { if (Estimate.getBlueAverage() > 240) { rgba.convertTo(rgba, -1, 10d * 24 / 100, 0); System.out.println("7"); } else { rgba.convertTo(rgba, -1, 10d * 17 / 100, 0); System.out.println("7"); } } tempMat.release(); Mat mHSV = new Mat(); Imgproc.cvtColor(rgba, mHSV, Imgproc.COLOR_RGBA2RGB, 3); Imgproc.cvtColor(rgba, mHSV, Imgproc.COLOR_RGB2HSV, 3); List<Mat> hsv_planes = new ArrayList<Mat>(3); Core.split(mHSV, hsv_planes); Mat channel = hsv_planes.get(0); channel = Mat.zeros(mHSV.rows(), mHSV.cols(), CvType.CV_8UC1); hsv_planes.set(2, channel); Core.merge(hsv_planes, mHSV); mHSV.convertTo(mHSV, CvType.CV_8UC1); mHSV = Histogram(mHSV); /* Mat clusteredHSV = new Mat(); mHSV.convertTo(mHSV, CvType.CV_32FC3); TermCriteria criteria = new TermCriteria(TermCriteria.EPS + TermCriteria.MAX_ITER,100,0.1); Core.kmeans(mHSV, 1, clusteredHSV, criteria, 20, Core.KMEANS_PP_CENTERS); Mat hsvImg = new Mat(); List<Mat> hsvPlanes = new ArrayList<>(); Mat thresholdImg = new Mat(); int thresh_type = Imgproc.THRESH_BINARY_INV; hsvImg.create(mHSV.size(), CvType.CV_8U); Imgproc.cvtColor(mHSV, hsvImg, Imgproc.COLOR_BGR2HSV); Core.split(hsvImg, hsvPlanes); Imgproc.threshold(hsvPlanes.get(1), thresholdImg, 0 , 200 , thresh_type); double threshValue = PreProcessingOperation.getHistAverage(hsvImg, hsvPlanes.get(0)); Estimate.setSecondHistAverageValue(threshValue); System.out.println("After equa " + Estimate.getSecondHistAverageValue());*/ Imgproc.threshold(mHSV, mHSV, 0, 150, Imgproc.THRESH_BINARY_INV); // mHSV.convertTo(mHSV, CvType.CV_8UC1); return mHSV; }
/** * Extracts and classifies colour bands for each Resistor. Each ColourBand object is instantiated * and linked to their parent Resistor object. * * @param resistorList A list of Resistor objects from which to extract the colour bands * @param paintDebugInfo If ture, the extracted colour band ROIs are displayed on the GUI */ private void extractColourBandsAndClassify(List<Resistor> resistorList, boolean paintDebugInfo) { if (resistorList.size() > 0) { for (int r = 0; r < resistorList.size(); r++) { Mat resImg = resistorList.get(r).resistorMat; Mat imgHSV = new Mat(); Mat satImg = new Mat(); Mat hueImg = new Mat(); // convert to HSV Imgproc.cvtColor(resImg, imgHSV, Imgproc.COLOR_BGR2HSV); ArrayList<Mat> channels = new ArrayList<Mat>(); Core.split(imgHSV, channels); // extract channels satImg = channels.get(1); // saturation hueImg = channels.get(0); // hue // threshold saturation channel Mat threshedROISatBands = new Mat(); // ~130 sat thresh val Imgproc.threshold(satImg, threshedROISatBands, SAT_BAND_THRESH, 255, Imgproc.THRESH_BINARY); // threshold hue channel Mat threshedROIHueBands = new Mat(); // ~50 hue thresh val Imgproc.threshold(hueImg, threshedROIHueBands, HUE_BAND_THRESH, 255, Imgproc.THRESH_BINARY); // combine the thresholded binary images Mat bandROI = new Mat(); Core.bitwise_or(threshedROIHueBands, threshedROISatBands, bandROI); // find contours in binary ROI image ArrayList<MatOfPoint> contours = new ArrayList<MatOfPoint>(); Mat hierarchy = new Mat(); Imgproc.findContours( bandROI, contours, hierarchy, Imgproc.RETR_EXTERNAL, Imgproc.CHAIN_APPROX_SIMPLE, new Point(0, 0)); // remove any remaining noise by only keeping contours which area > threshold for (int i = 0; i < contours.size(); i++) { double area = Imgproc.contourArea(contours.get(i)); if (area < MIN_BAND_AREA) { contours.remove(i); i--; } } // create a ColourBand object for each detected band // storing its center, the contour and the bandROI for (int i = 0; i < contours.size(); i++) { MatOfPoint contour = contours.get(i); // extract this colour band and store in a Mat Rect boundingRect = Imgproc.boundingRect(contour); Mat mask = Mat.zeros(bandROI.size(), CvType.CV_8U); Imgproc.drawContours(mask, contours, i, new Scalar(255), Core.FILLED); Mat imageROI = new Mat(); resImg.copyTo(imageROI, mask); Mat colourBandROI = new Mat(imageROI, boundingRect); // instantiate new ColourBand object ColourBand cb = new ColourBand(findCenter(contour), contour, colourBandROI); // cluster the band colour cb.clusterBandColour(BAND_COLOUR_K_MEANS); // classify using the Lab colourspace as feature vector Mat sampleMat = new Mat(1, 3, CvType.CV_32FC1); // create a Mat contacting the clustered band colour sampleMat.put(0, 0, cb.clusteredColourLAB[0]); sampleMat.put(0, 1, cb.clusteredColourLAB[1]); sampleMat.put(0, 2, cb.clusteredColourLAB[2]); Mat classifiedValue = new Mat(1, 1, CvType.CV_32FC1); Mat neighborResponses = new Mat(); // dont actually use this Mat dists = new Mat(); // dont actually use this // classify knn.find_nearest(sampleMat, 3, classifiedValue, neighborResponses, dists); // cast classified value into Colour enum and store cb.classifiedColour = ColourEnumVals[(int) classifiedValue.get(0, 0)[0]]; // add the band to the parent resistor resistorList.get(r).bands.add(cb); } // paint the extracted band ROIs if (paintDebugInfo) { Mat finalBandROIMask = Mat.zeros(bandROI.size(), CvType.CV_8U); for (int i = 0; i < contours.size(); i++) { Scalar color = new Scalar(255, 255, 255); Imgproc.drawContours( finalBandROIMask, contours, i, color, -1, 4, hierarchy, 0, new Point()); } Mat colourROI = new Mat(); resImg.copyTo(colourROI, finalBandROIMask); paintResistorSubRegion(colourROI, r); } } } }
@Override public void run() { // Initialisation cptRect = 0; initialiseRectangle(); if (video.isOpened()) { while (begin == true) { // On récupère l'image de la CaptureVideo video.retrieve(frameaux); // On modifie les dimensions de la frame Imgproc.resize(frameaux, frame, frame.size()); // On copie frame.copyTo(currentFrame); if (jCheckBoxMotionDetection.isSelected()) { if (firstFrame) { frame.copyTo(lastFrame); firstFrame = false; continue; } // Soustraction de currentFrame par rapport à la dernière Core.subtract(currentFrame, lastFrame, processedFrame); // Filtre en niveau de gris Imgproc.cvtColor(processedFrame, processedFrame, Imgproc.COLOR_RGB2GRAY); // Filtre threshold + récupération du Jslider int threshold = jSliderThreshold.getValue(); Imgproc.threshold( processedFrame, processedFrame, threshold, 255, Imgproc.THRESH_BINARY); // Detecte les contours et check dans les detection_contours(currentFrame, processedFrame); } // Dessine les rectangles d'authentifications drawRectangle(); currentFrame.copyTo(processedFrame); // Encodage de la frame en MatOfByte Highgui.imencode(".jpg", processedFrame, matOfByte); byte[] byteArray = matOfByte.toArray(); // Affichage de l'image try { in = new ByteArrayInputStream(byteArray); bufImage = ImageIO.read(in); image.updateImage(bufImage); } catch (Exception ex) { ex.printStackTrace(); } try { Thread.sleep(50); } catch (Exception ex) { ex.printStackTrace(); } } } }
/** new algo */ public static String findTips(Mat image) { Mat binary = new Mat(); // Convert to B&W image Imgproc.threshold(image, binary, 0, 255, Imgproc.THRESH_BINARY); // Convert to binary image, 1 channel Imgproc.cvtColor(binary, binary, Imgproc.COLOR_RGB2GRAY); boolean flag_bg = false; boolean handInQuarterOfImg = false; int count_finger = 0; int start = -1; int end = -1; int tester = 0; // test variable CAN BE REMOVED double startPercent = 0, endPercent = 0; int leftHeight = -1; int firstHandPixel = -1; int lastHandPixel = -1; int KV_midFinger = -1; int KV_indxFinger = -1; double pixel[]; for (int i = 0; i < binary.cols(); i++) { pixel = binary.get((int) (binary.rows() * 0.23), i); if (pixel[0] != 0.0) { if (firstHandPixel == -1) firstHandPixel = i; if (i < image.cols() / 4) handInQuarterOfImg = true; lastHandPixel = i; leftHeight = i; } if (pixel[0] != 0.0) { if (flag_bg == false) { // flag_bg is false count_finger++; flag_bg = true; start = i; } end = i; } else { if (count_finger == 1) KV_midFinger = end; else if (count_finger == 2) KV_indxFinger = start; flag_bg = false; if (tester != count_finger) { // remove this line -- just for // testing startPercent = ((double) start / (double) binary.cols()) * 100; endPercent = ((double) end / (double) binary.cols()) * 100; } tester = count_finger; // remove this line -- just for testing } } if (count_finger == 3) { if (endPercent > 80.0) { return "W"; } else { return "F"; } } else if (count_finger == 4) { return "B"; } else if (count_finger == 1) { if (endPercent > 70.0) if (handInQuarterOfImg) return "B"; else { int result = identify_R_U(binary); switch (result) { case 1: return "R"; case 2: return "U"; default: return " "; // return "RU"; } } else { if ((float) (lastHandPixel - firstHandPixel) / image.cols() > 0.35) return "F"; else { image = Filter.furtherClean(image); Mat binary2 = new Mat(); // Convert to B&W image Imgproc.threshold(image, binary2, 0, 255, Imgproc.THRESH_BINARY); // Convert to binary image, 1 channel Imgproc.cvtColor(binary2, binary2, Imgproc.COLOR_RGB2GRAY); flag_bg = false; int countHandArea = 0; for (int i = 0; i < binary2.rows(); i++) { pixel = binary2.get(i, (int) (binary2.cols() * 0.70)); if (pixel[0] != 0.0) { if (!flag_bg) { flag_bg = true; countHandArea++; } } else flag_bg = false; } if (countHandArea == 1) { if (checkAngleL(binary)) return "L"; else { int result = identify_R_U(binary); switch (result) { case 1: return "R"; case 2: return "U"; default: return " "; } } } else if (countHandArea == 2) return "D"; else return " "; } } } else if (count_finger == 2) { // int result = identify_K_V(rgb, binary, new Point(KV_midFinger, // (int) (binary.rows() * 0.23)), new Point(KV_indxFinger, // (int) (binary.rows() * 0.23))); int startX = (int) KV_midFinger; int startY = (int) (binary.rows() * 0.23); int lastDir = 1; // 0 up; 1 down int currDir = 1; int ctr = 1; Point KV_PtsArray[] = new Point[3]; KV_PtsArray[0] = new Point(startX, startY); // Core.circle(rgb, // new Point(UL.x + startX, UL.y + startY), 5, // new Scalar(0, 0, 255)); // double pixel[]; Log.i("START", "" + startX); Log.i("END", "" + startY); for (int i = startX; i < KV_indxFinger; i++) { for (int k = (int) (binary.rows() * 0.23); k < binary.rows(); k++) { pixel = binary.get(k, i + 1); Log.i("CHECK1", "" + binary.rows()); Log.i("CHECK2", "" + binary.rows() * 0.23); Log.i("CHECK3", "" + (int) (binary.rows() * 0.23)); Log.i("CHECK4", "" + pixel[0]); if (pixel[0] != 0.0) { // Plots the edges from hullPoint[0] to hullPoint[1] // Core.circle(rgb, new Point(UL.x + startX + 1, // UL.y // + k), 5, new Scalar(0, 255, 0)); if (k > startY) currDir = 1; else if (k < startY) currDir = 0; if (currDir != lastDir && ctr < 3) { // Plots 3 significant pts in K and V // Core.circle(rgb, // new Point(UL.x + i + 1, UL.y + k), 5, // new Scalar(0, 0, 255)); KV_PtsArray[ctr] = new Point(i + 1, k); ctr++; } lastDir = currDir; // startX = startX + 1; startY = k; break; } } if (ctr < 3 && i + 1 == (int) KV_indxFinger) { // Core.circle(rgb, new Point(UL.x + startX, UL.y + startY), // 5, // new Scalar(0, 0, 255)); KV_PtsArray[ctr] = new Point(i, startY); ctr++; } if (ctr == 3) break; } if (ctr == 3) { if (KV_PtsArray[0].y == KV_PtsArray[2].y) return "V"; // V else return "K"; // K } else return " "; } return Integer.toString(count_finger); }
public static void main(String[] args) { System.loadLibrary(Core.NATIVE_LIBRARY_NAME); // Mat mat = Mat.eye( 3, 3, CvType.CV_8UC1 ); // System.out.println( "mat = " + mat.dump() ); Sample n = new Sample(); // n.templateMatching(); // put text in image // Mat data= Highgui.imread("images/erosion.jpg"); // Core.putText(data, "Sample", new Point(50,80), Core.FONT_HERSHEY_SIMPLEX, 1, new // Scalar(0,0,0),2); // // Highgui.imwrite("images/erosion2.jpg", data); // getting dct of an image String path = "images/croppedfeature/go (20).jpg"; path = "images/wordseg/img1.png"; Mat image = Highgui.imread(path, Highgui.IMREAD_GRAYSCALE); ArrayList<MatOfPoint> contours = new ArrayList<MatOfPoint>(); Imgproc.threshold(image, image, 0, 255, Imgproc.THRESH_OTSU); Imgproc.threshold(image, image, 220, 128, Imgproc.THRESH_BINARY_INV); Mat newImg = new Mat(45, 100, image.type()); newImg.setTo(new Scalar(0)); n.copyMat(image, newImg); int vgap = 25; int hgap = 45 / 3; Moments m = Imgproc.moments(image, false); Mat hu = new Mat(); Imgproc.HuMoments(m, hu); System.out.println(hu.dump()); // //divide the mat into 12 parts then get the features of each part // int count=1; // for(int j=0; j<45; j+=hgap){ // for(int i=0;i<100;i+=vgap){ // Mat result = newImg.submat(j, j+hgap, i, i+vgap); // // // Moments m= Imgproc.moments(result, false); // double m01= m.get_m01(); // double m00= m.get_m00(); // double m10 = m.get_m10(); // int x= m00!=0? (int)(m10/m00):0; // int y= m00!=0? (int)(m01/m00):0; // Mat hu= new Mat(); // Imgproc.HuMoments(m, hu); // System.out.println(hu.dump()); // System.out.println(count+" :"+x+" and "+y); // Imgproc.threshold(result, result, 0,254, Imgproc.THRESH_BINARY_INV); // Highgui.imwrite("images/submat/"+count+".jpg", result); // count++; // // } // } // // for(int i=vgap;i<100;i+=vgap){ // Point pt1= new Point(i, 0); // Point pt2= new Point(i, 99); // Core.line(newImg, pt1, pt2, new Scalar(0,0,0)); // } // for(int i=hgap;i<45;i+=hgap){ // Point pt1= new Point(0, i); // Point pt2= new Point(99, i); // Core.line(newImg, pt1, pt2, new Scalar(0,0,0)); // } // Highgui.imwrite("images/submat/copyto.jpg", newImg); }
public Mat onCameraFrame(CvCameraViewFrame inputFrame) { mRgba = inputFrame.rgba(); // convert to Gray scale Imgproc.cvtColor(mRgba, img_gray, Imgproc.COLOR_BGR2GRAY); // make it binary with threshold=100 Imgproc.threshold(img_gray, erd, 100, 255, Imgproc.THRESH_OTSU); // remove pixel noise by "erode" with structuring element of 9X9 Mat erode = Imgproc.getStructuringElement(Imgproc.MORPH_ERODE, new Size(9, 9)); Imgproc.erode(erd, tgt, erode); // apply "dilation" to enlarge object Mat dilate = Imgproc.getStructuringElement(Imgproc.MORPH_DILATE, new Size(9, 9)); Imgproc.dilate(tgt, erd, dilate); // take a window Size s = erd.size(); int W = (int) s.width; int H = (int) s.height; Rect r = new Rect(0, H / 2 - 100, W, 200); Mat mask = new Mat(s, CvType.CV_8UC1, new Scalar(0, 0, 0)); rectangle(mask, r.tl(), r.br(), new Scalar(255, 255, 255), -1); erd.copyTo(window, mask); // find the contours Imgproc.findContours(window, contours, dest, 0, 2); // find largest contour int maxContour = -1; double area = 0; for (int i = 0; i < contours.size(); i++) { double contArea = Imgproc.contourArea(contours.get(i)); if (contArea > area) { area = contArea; maxContour = i; } } // form bounding rectangle for largest contour Rect rect = null; if (maxContour > -1) rect = Imgproc.boundingRect(contours.get(maxContour)); // position to center while (!train) { if (rect != null) { Imgproc.rectangle(mRgba, rect.tl(), rect.br(), new Scalar(255, 255, 255), 5); if ((rect.x + rect.width / 2) > W / 2 - 20 && (rect.x + rect.width / 2) < W / 2 + 20) { runOnUiThread( new Runnable() { @Override public void run() { Toast.makeText(getApplicationContext(), "OK", Toast.LENGTH_SHORT).show(); } }); train = true; } } if (contours != null) contours.clear(); return mRgba; } if (train) { if (rect != null) { Imgproc.rectangle(mRgba, rect.tl(), rect.br(), new Scalar(255, 255, 255), 5); // direction of movement int thr = 100; if ((rect.x + rect.width / 2) < (W / 2 - thr)) { // move to the RIGHT uHandler.obtainMessage(MainActivity.LEFT).sendToTarget(); } else { if ((rect.x + rect.width / 2) > (W / 2 + thr)) { uHandler.obtainMessage(MainActivity.RIGHT).sendToTarget(); } else { uHandler.obtainMessage(MainActivity.FORWARD).sendToTarget(); } } } else { // stop moving uHandler.obtainMessage(MainActivity.STOP).sendToTarget(); } } if (contours != null) contours.clear(); return mRgba; }
public void run() { ArrayList<Geometry.Quad> squares; Mat image = new Mat(); Utils.bitmapToMat(source, image); Mat bwimage = new Mat(); cvtColor(image, bwimage, COLOR_RGB2GRAY); Mat blurred = new Mat(); medianBlur(image, blurred, 9); int width = blurred.width(); int height = blurred.height(); int depth = blurred.depth(); Mat gray0 = new Mat(width, height, depth); blurred.copyTo(gray0); squares = new ArrayList<Geometry.Quad>(); // find squares in every color plane of the image for (int c = 0; c < 3; c++) { Core.mixChannels( Arrays.asList(blurred), Arrays.asList(new Mat[] {gray0}), new MatOfInt(c, 0)); // try several threshold levels int thresholdLevel = 8; for (int l = 0; l < thresholdLevel; l++) { // use canny instead of 0 threshold level // canny helps catch squares with gradient shading Mat gray = new Mat(); if (l == 0) { Canny(gray0, gray, 10.0, 20.0, 3, false); Mat kernel = new Mat(11, 11, CvType.CV_8UC1, new Scalar(1)); dilate(gray, gray, kernel); } else { Mat thresh = new Mat(gray0.rows(), gray0.cols(), gray0.type()); threshold(gray0, thresh, ((double) l) / thresholdLevel * 255, 128, THRESH_BINARY_INV); cvtColor(thresh, gray, COLOR_BGR2GRAY); } // find contours and store them in a list List<MatOfPoint> contours = new ArrayList<MatOfPoint>(); findContours(gray, contours, new Mat(), RETR_LIST, CHAIN_APPROX_SIMPLE); // test contours for (MatOfPoint contour : contours) { // approximate contour with accuracy proportional to the contour perimeter MatOfPoint2f thisContour = new MatOfPoint2f(contour.toArray()); double arclength = 0.02 * arcLength(thisContour, true); MatOfPoint2f approx = new MatOfPoint2f(); approxPolyDP(thisContour, approx, arclength, true); double area = contourArea(approx); boolean isConvex = isContourConvex(new MatOfPoint(approx.toArray())); if (approx.rows() == 4 && Math.abs(area) > SQUARE_SIZE && isConvex) { double maxCosine = 0; Point[] approxArray = approx.toArray(); for (int j = 2; j < 5; j++) { double cosine = Math.abs(angle(approxArray[j % 4], approxArray[j - 2], approxArray[j - 1])); maxCosine = Math.max(maxCosine, cosine); } if (maxCosine > THRESHOLD_COS) { squares.add(new Geometry.Quad(approxArray)); Log.d(TAG, "area = " + area); } } } } } result = new Bundle(); result.putParcelableArrayList("squares", squares); Log.d(TAG, "result created"); finish(); }
public MatOfPoint getContourOfBestMatch() { if (matches == null) return null; Mat threshold = new Mat(imgGray.size(), imgGray.type()); Imgproc.threshold(imgGray, threshold, 70, 255, Imgproc.THRESH_TOZERO); List<MatOfPoint> contours = new ArrayList<MatOfPoint>(); Imgproc.findContours( threshold, contours, new Mat(), Imgproc.RETR_CCOMP, Imgproc.CHAIN_APPROX_NONE); // HashMap<Integer,MatOfPoint> coordinates = computeCoord(contours,) if (contours.size() == 0) return null; List<DMatch> matchList = matches.toList(); List<KeyPoint> keyPointList = keyPointImg.toList(); HashMap<Integer, Double> contourDensityMap = new HashMap<Integer, Double>(); Log.i("getContourBestMatch::", "contour size::" + contours.size()); for (int idx = 0; idx < contours.size(); idx++) { MatOfPoint2f ctr2f = new MatOfPoint2f(contours.get(idx).toArray()); // double contourarea = Imgproc.contourArea(contours.get(idx)); double contourarea = contours.get(idx).rows(); if (contourarea < 50) continue; Rect r = Imgproc.boundingRect(contours.get(idx)); double count = 0; // Log.i("contour area","contour area is::"+contourarea); for (DMatch match : matchList) { Point q = keyPointList.get(match.queryIdx).pt; if (q.x >= r.x && q.x <= (r.x + r.width) && q.y >= r.y && q.y <= (r.y + r.height)) count++; // // if(Imgproc.pointPolygonTest(ctr2f,keyPointList.get(match.queryIdx).pt,true)>0){ // if(null ==contourDensityMap.get(idx)) // contourDensityMap.put(idx,1.0); // // else{ // contourDensityMap.put(idx,((Double)contourDensityMap.get(idx))+1); // } // // } } // if(contourDensityMap.containsKey(idx)) { // // Log.i("contourPoint","idx::"+idx+"count::"+contourDensityMap.get(idx)+"contour // area::"+contourarea); // contourDensityMap.put(idx, contourDensityMap.get(idx) / contourarea); // } if (count != 0) { contourDensityMap.put(idx, count / contourarea); } } Log.i("MarkerTracker", "contour density size::" + contourDensityMap.size()); Map.Entry<Integer, Double> maxEntry = null; for (Map.Entry<Integer, Double> entry : contourDensityMap.entrySet()) { Log.i("contourDensityMap", "Entry value::" + entry.getValue()); if (maxEntry == null || entry.getValue().compareTo(maxEntry.getValue()) > 0) { maxEntry = entry; } } Log.i("maxEntry::", "" + (maxEntry == null ? null : maxEntry.getKey())); // return contours; return contours.get(maxEntry != null ? maxEntry.getKey() : 0); }