private void displayMarkerImage(Mat srcImgMat, Mat destImageMat) { // find location of image segment to be replaced in the destination image. Rect rect = calculateImageSegmentArea(destImageMat); Mat destSubmat = destImageMat.submat(rect.y, rect.y + rect.height, rect.x, rect.x + rect.width); // copy image. srcImgMat.copyTo(destSubmat); }
/** * Process the given Mat, finding, classifying and displaying all resistors present. * * @param originalImg The image to parse */ private void parseImage(Mat originalImg) { Mat workingCopy = new Mat(); originalImg.copyTo(workingCopy); // blur the original image to form resistor blobs. should remove white/silver/grey bands which // would otherwise // get picked up as part of the background, leads or shadows. Mat blurred = new Mat(); // Imgproc.medianBlur(workingCopy, blurred, 29); Imgproc.blur(workingCopy, blurred, new Size(20, 20)); // faster // get a mask off the background Mat resistorMask = new Mat(); generateResistorMask(blurred, Imgproc.THRESH_BINARY).copyTo(resistorMask); // find countours in mask List<MatOfPoint> contours = getContours(resistorMask, originalImg, true); // extract resistors in input image List<Resistor> resistors = extractResistorsFromContours(contours, originalImg, true); // segment and extract colour bands for each resistor extractColourBandsAndClassify(resistors, true); // calculate and display resistance value for each resistor based on classified colour bands calculateAndDisplayResistanceValues(resistors); }
public static void cvt_YUVtoGRAY(Mat src, Mat dst) { /** convert YUV image to RGB then GRAY colorspace */ mSrc = new Mat(); src.copyTo(mSrc); Imgproc.cvtColor(mSrc, dst, Imgproc.COLOR_YUV420sp2RGB); Imgproc.cvtColor(dst, dst, Imgproc.COLOR_RGB2GRAY); }
public Mat onCameraFrame(Mat inputFrame) { inputFrame.copyTo(mRgba); Point center = new Point(mRgba.width() / 2, mRgba.height() / 2); double angle = -90; double scale = 1.0; Mat mapMatrix = Imgproc.getRotationMatrix2D(center, angle, scale); Imgproc.warpAffine(mRgba, mGrayMat, mapMatrix, mRgba.size(), Imgproc.INTER_LINEAR); return mGrayMat; }
private void copyThresholdedImageToRgbImgMat(Mat thresholdedImgMat, Mat dest) { // convert thresholded image segment to RGB. Mat smallRegionImg = new Mat(); Imgproc.cvtColor(thresholdedImgMat, smallRegionImg, Imgproc.COLOR_GRAY2BGRA, 4); // find location of image segment to be replaced in the destination image. Rect rect = calculateImageSegmentArea(dest); Mat destSubmat = dest.submat(rect.y, rect.y + rect.height, rect.x, rect.x + rect.width); // copy image. smallRegionImg.copyTo(destSubmat); smallRegionImg.release(); }
/** * Creates Resistor objects for all resistors extracted from given contours. Optionally, also * displays a bounding rectangle for all contours in the top left frame of the GUI. * * @param contours The contours defining the resistors * @param image The image from which the contours were extracted * @param showBoundingRect If true draws a bounding rectange for each contour * @return A list of Resistor objects */ private List<Resistor> extractResistorsFromContours( List<MatOfPoint> contours, Mat image, boolean showBoundingRect) { List<Mat> extractedResistors = new ArrayList<Mat>(); List<Rect> boundingRect = new ArrayList<Rect>(); List<Resistor> resistors = new ArrayList<Resistor>(); for (int i = 0; i < contours.size(); i++) { // bounding rectangle boundingRect.add(Imgproc.boundingRect(contours.get(i))); Mat mask = Mat.zeros(image.size(), CvType.CV_8U); Imgproc.drawContours(mask, contours, i, new Scalar(255), Core.FILLED); Mat contourRegion; Mat imageROI = new Mat(); image.copyTo(imageROI, mask); contourRegion = new Mat(imageROI, boundingRect.get(i)); extractedResistors.add(contourRegion); // the center of the resistor as a point within the original captured image Point resistorCenterPoint = findCenter(contours.get(i)); // create a new resistor entry Resistor r = new Resistor(resistorCenterPoint, contourRegion); resistors.add(r); } if (showBoundingRect) { Mat drawing = new Mat(); image.copyTo(drawing); for (int i = 0; i < contours.size(); i++) { Core.rectangle( drawing, boundingRect.get(i).tl(), boundingRect.get(i).br(), new Scalar(0, 0, 255), 2); } paintTL(drawing); } return resistors; }
public Mat onCameraFrame(CvCameraViewFrame inputFrame) { mRgba = inputFrame.rgba(); mGray = inputFrame.gray(); if (!detectionInProgress) { Mat image = new Mat(mGray.rows(), mGray.cols(), mGray.type()); mGray.copyTo(image); detectFaceOnFrame(image); } return mRgba; }
private ArrayList<Double> applyThresholdOnImage(Mat srcImgMat, Mat outputImgMat) { double localThreshold; int startRow; int endRow; int startCol; int endCol; ArrayList<Double> localThresholds = new ArrayList<Double>(); int numberOfTiles = mPreference.getNumberOfTiles(); int tileWidth = (int) srcImgMat.size().height / numberOfTiles; int tileHeight = (int) srcImgMat.size().width / numberOfTiles; // Split image into tiles and apply threshold on each image tile separately. // process image tiles other than the last one. for (int tileRowCount = 0; tileRowCount < numberOfTiles; tileRowCount++) { startRow = tileRowCount * tileWidth; if (tileRowCount < numberOfTiles - 1) endRow = (tileRowCount + 1) * tileWidth; else endRow = (int) srcImgMat.size().height; for (int tileColCount = 0; tileColCount < numberOfTiles; tileColCount++) { startCol = tileColCount * tileHeight; if (tileColCount < numberOfTiles - 1) endCol = (tileColCount + 1) * tileHeight; else endCol = (int) srcImgMat.size().width; Mat tileThreshold = new Mat(); Mat tileMat = srcImgMat.submat(startRow, endRow, startCol, endCol); // localThreshold = Imgproc.threshold(tileMat, tileThreshold, 0, 255, Imgproc.THRESH_BINARY // | Imgproc.THRESH_OTSU); // RNM: Adaptive threshold rules! localThreshold = 0x80; Imgproc.adaptiveThreshold( tileMat, tileThreshold, 255, Imgproc.ADAPTIVE_THRESH_GAUSSIAN_C, Imgproc.THRESH_BINARY, 91, 2); Mat copyMat = outputImgMat.submat(startRow, endRow, startCol, endCol); tileThreshold.copyTo(copyMat); tileThreshold.release(); localThresholds.add(localThreshold); } } return localThresholds; }
/* (non-Javadoc) * @see java.lang.Runnable#run() */ @Override public void run() { if (MODE.equals("VIDEO")) { Mat capturedImage = new Mat(); VideoCapture vc = new VideoCapture(DEVICE); if (!vc.isOpened()) { System.out.println("Capture Failed!"); return; } System.out.println("Device " + DEVICE + " opened"); // set captured resolution vc.set(Highgui.CV_CAP_PROP_FRAME_WIDTH, 640); vc.set(Highgui.CV_CAP_PROP_FRAME_HEIGHT, 480); // Manually set exposure vc.set(15, -11); while (true) { vc.read(capturedImage); if (capturedImage != null) { // flip the image to compensate for camera orientation Core.flip(capturedImage, capturedImage, -1); capturedImage.copyTo(finalDisplayImg); parseImage(capturedImage); } } } else { // STILL IMAGE Mat capturedImage = Highgui.imread(IMAGE_FILEPATH); while (true) { if (needUpdate) { capturedImage.copyTo(finalDisplayImg); parseImage(capturedImage); needUpdate = false; } } } }
@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); }
public Mat onCameraFrame(CvCameraViewFrame inputFrame) { mRgba = inputFrame.rgba(); if (mIsColorSelected) { abc = mDetector.process(mRgba); // hehe.setText(abc.toString()); List<MatOfPoint> contours = mDetector.getContours(); Log.e(TAG, "Contours count: " + contours.size()); Imgproc.drawContours(mRgba, contours, -1, CONTOUR_COLOR); Mat colorLabel = mRgba.submat(4, 68, 4, 68); colorLabel.setTo(mBlobColorRgba); Mat spectrumLabel = mRgba.submat(4, 4 + mSpectrum.rows(), 70, 70 + mSpectrum.cols()); mSpectrum.copyTo(spectrumLabel); } return mRgba; }
public static Mat Histogram(Mat im) { Mat img = im; Mat equ = new Mat(); img.copyTo(equ); // Imgproc.blur(equ, equ, new Size(3, 3)); Imgproc.cvtColor(equ, equ, Imgproc.COLOR_BGR2YCrCb); List<Mat> channels = new ArrayList<Mat>(); Core.split(equ, channels); Imgproc.equalizeHist(channels.get(0), channels.get(0)); Core.merge(channels, equ); Imgproc.cvtColor(equ, equ, Imgproc.COLOR_YCrCb2BGR); Mat gray = new Mat(); Imgproc.cvtColor(equ, gray, Imgproc.COLOR_BGR2GRAY); Mat grayOrig = new Mat(); Imgproc.cvtColor(img, grayOrig, Imgproc.COLOR_BGR2GRAY); System.out.println("Histogram work ///"); return grayOrig; }
/** * @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); } } } }
public static void Circle(List<MatOfPoint> contours, int index) { int i = index; Mat mRGBA = new Mat(); Utils.bitmapToMat(image, mRGBA); // cyklus s podmienkou na konci do { int buff[] = new int[4]; hierarchy.get(0, i, buff); // Get contour form list Mat contour = contours.get(i); // id kont�ry int id = i; // dostaneme �a��ie id kont�ry i = buff[0]; // zis�ujeme �i m�me dostato�ne ve�k� kont�ru aby sme sa �ou v�bec zaoberali if (Imgproc.contourArea(contour) > 500) { List<Point> points = new ArrayList<Point>(); // dostaneme celkov� po�et kont�r int num = (int) contour.total(); // vytvor�me si pole o dvojn�sobnej ve�kosti samotnej kontury int temp[] = new int[num * 2]; // na��tame si kont�ru do do�asnej premennej contour.get(0, 0, temp); // konvertujeme List<Point> do MatOfPoint2f pre pou�itie fitEllipse for (int j = 0; j < num * 2; j = j + 2) { points.add(new Point(temp[j], temp[j + 1])); } MatOfPoint2f specialPointMtx = new MatOfPoint2f(points.toArray(new Point[0])); // do premennej bound uklad�me dokonal� elipsu RotatedRect bound = Imgproc.fitEllipse(specialPointMtx); // Vypo��ta sa hodnota pi double pi = Imgproc.contourArea(contour) / ((bound.size.height / 2) * (bound.size.width / 2)); // zis�ujeme toleranciu pi - zaoplenie if (Math.abs(pi - 3.14) > 0.03) { int k = buff[2]; // zis�ujeme �i existuje nejak� rodi� kont�ry if (k != -1) { Circle(contours, k); } continue; } // konvertujeme MatOfPoint2f do MatOfPoint pre funckiu fitEllipse - rozdie� je len v 32-bit // float a 32-bit int MatOfPoint NewMtx = new MatOfPoint(specialPointMtx.toArray()); // dostaneme s�radnice najmen�ieho mo�n�ho �tvorca Rect box = Imgproc.boundingRect(NewMtx); // nacita obrazok znova Mat mat_for_count = new Mat(); Utils.bitmapToMat(image, mat_for_count); // vytvori sa klon stvorca - dobry kandidat pre vyhladanie Mat candidate = ((mat_for_count).submat(box)).clone(); // napln maticu binarnou ciernou Mat mask = new Mat(box.size(), candidate.type(), new Scalar(0, 0, 0)); // naplni ciernu plochu bielimi konturami Imgproc.drawContours( mask, contours, id, new Scalar(255, 255, 255), -1, 8, hierarchy, 0, new Point(-box.x, -box.y)); // ulozi sa kandidat Mat roi = new Mat(candidate.size(), candidate.type(), new Scalar(255, 255, 255)); // ulozia sa len informacie o kandidatovi candidate.copyTo(roi, mask); double longAxis; double shortAxis; // ziska dve osy elipsy if (bound.size.height < bound.size.width) { shortAxis = bound.size.height / 2; longAxis = bound.size.width / 2; } else { shortAxis = bound.size.width / 2; longAxis = bound.size.height / 2; } // zastavi sa vyhladavanie pokial je elipsa prilis ovalna if ((longAxis / shortAxis) < 2.0) { signList.add(roi); boxList.add(box); } } // zis�uje sa �i je tam e�te �al�� kandid�t } while (i != -1); }
public void processWithContours(Mat in, Mat out) { int playSquares = 32; // number of playable game board squares // keep track of starting row square int parity = 0; // 0 is even, 1 is odd, tied to row number int count = 0; // row square int rowNum = 0; // row number, starting at 0 int vsegment = in.rows() / 8; // only accounts 8 playable int hsegment = in.cols() / 10; // 8 playable, 2 capture int hOffset = hsegment * 2; // offset for playable board int vOffset = vsegment + 40; // For angle of camera int dx = 80; int ddx = 0; hsegment -= 16; int dy = 20; vsegment -= 24; int ddy = 0; // Go through all playable squares for (int i = 0; i < playSquares; i++) { // change offset depending on the row if (parity == 0) // playable squares start on 2nd square from left { if (rowNum >= 5) dx -= 3; hOffset = hsegment * 2 + dx; } else // playable squares start on immediate left { if (rowNum >= 5) dx -= 3; hOffset = hsegment + dx; } if (rowNum == 0) ddy = 5; if (rowNum == 4) if (count == 6) ddx = 10; if (rowNum == 5) { if (count == 0) ddx = -6; else if (count == 2) ddx = 6; else if (count == 4) ddx = 12; else if (count == 6) ddx = 20; } if (rowNum == 6) { if (count == 0) ddx = 0; else if (count == 2) ddx = 16; else if (count == 4) ddx = 32; else if (count == 6) ddx = 40; } if (rowNum == 7) { if (count == 0) ddx = 6; else if (count == 2) ddx = 24; else if (count == 4) ddx = 40; else ddx = 52; } // find where roi should be // System.out.println("" + vOffset); Point p1 = new Point( hOffset + count * hsegment + ddx + 5, vOffset + rowNum * vsegment - dy - 5 - ddy); // top left point of rectangle (x,y) Point p2 = new Point( hOffset + (count + 1) * hsegment + ddx - 5, vOffset + (rowNum + 1) * vsegment - dy - 5 - ddy); // bottom right point of rectangle (x,y) // create rectangle that is board square Rect bound = new Rect(p1, p2); Mat roi; char color; if (i == 0) { // frame only includes rectangle roi = new Mat(in, bound); // get the color color = identifyColor(roi); // copy input image to output image in.copyTo(out); } else { // frame only includes rectangle roi = new Mat(out, bound); // get the color color = identifyColor(roi); } Imgproc.cvtColor(roi, roi, Imgproc.COLOR_BGR2GRAY); // change to single color Mat canny = new Mat(); Imgproc.Canny(roi, canny, 20, 40); // make image a canny image that is only edges; 2,4 // lower threshold values find more edges List<MatOfPoint> contours = new ArrayList<MatOfPoint>(); Mat hierarchy = new Mat(); // holds nested contour information Imgproc.findContours( canny, contours, hierarchy, Imgproc.RETR_LIST, Imgproc.CHAIN_APPROX_SIMPLE); // Imgproc.RETR_LIST, TREE System.out.println(++test + "\t" + contours.size()); if (contours.size() > 3) // or error value for color is below 1 { switch (color) { case COLOR_BLUE: // Imgproc.rectangle(out, p1, p2, new Scalar(255, 0, 0), 2); Core.rectangle(out, p1, p2, new Scalar(255, 0, 0), 2); board[i] = CheckersBoard.BLACK; // end user's piece break; case COLOR_ORANGE: // Imgproc.rectangle(out, p1, p2, new Scalar(0, 128, 255), 2); Core.rectangle(out, p1, p2, new Scalar(0, 128, 255), 2); board[i] = CheckersBoard.WHITE; // system's piece break; case COLOR_WHITE: // Imgproc.rectangle(out, p1, p2, new Scalar(255, 255, 255), 2); Core.rectangle(out, p1, p2, new Scalar(255, 255, 255), 2); board[i] = CheckersBoard.EMPTY; break; case COLOR_BLACK: // this is black // Imgproc.rectangle(out, p1, p2, new Scalar(0, 0, 0), 2); Core.rectangle( out, p1, p2, new Scalar(0, 0, 0), 2); // maybe add 8, 0 as line type and fractional bits board[i] = CheckersBoard.EMPTY; break; } } System.out.println("in color switch " + board[i]); count += 2; if (count == 8) { parity = ++parity % 2; // change odd or even count = 0; rowNum++; hsegment += 2; dx -= 10; dy += 10; vsegment += 3; ddy = 0; } } }
/** * Determines which pieces are kings * * @param in Mat image of board */ public void determineKings(Mat in) { int playSquares = 32; Mat dst = new Mat(in.rows(), in.cols(), in.type()); in.copyTo(dst); Imgproc.cvtColor(dst, dst, Imgproc.COLOR_BGR2GRAY); // change to single color Mat canny = new Mat(); Imgproc.Canny(dst, canny, 100, 200); // make image a canny image that is only edges; 2,4 // lower threshold values find more edges List<MatOfPoint> contours = new ArrayList<MatOfPoint>(); Mat hierarchy = new Mat(); // holds nested contour information Imgproc.findContours( canny, contours, hierarchy, Imgproc.RETR_LIST, Imgproc.CHAIN_APPROX_SIMPLE); // Imgproc.RETR_LIST, TREE // draw contour image Mat mask = new Mat(); mask = Mat.zeros(dst.size(), dst.type()); Imgproc.drawContours( mask, contours, -1, new Scalar(255, 255, 255), 1, 8, hierarchy, 2, new Point()); Highgui.imwrite("contours.jpg", mask); ArrayList occupied = new ArrayList<Integer>(); for (int i = 0; i < playSquares; i++) { if (board[i] != 0) occupied.add(i); } for (int i = 0; i < contours.size(); i++) // assuming only contours are checker pieces { // determine if it should be a king // use Rect r = Imgproc.boundingRect then find height of it by r.height // Get bounding rect of contour Rect bound = Imgproc.boundingRect(contours.get(i)); if (bound.height > in.rows() / 8) { // board[(int) occupied.get(0)]++; // make it a king // occupied.remove(0); } } // or apply to each region of interest /* // keep track of starting row square int parity = 0; // 0 is even, 1 is odd, tied to row number int count = 0; // row square int rowNum = 0; // row number, starting at 0 int vsegment = in.rows() / 8; // only accounts 8 playable int hsegment = in.cols() / 12; // 8 playable, 2 capture, 2 extra int offset = hsegment * 2; // offset for playable board // For angle of camera int dx = 48; hsegment -= 8; // Go through all playable squares for (int i = 0; i < playSquares; i++) { // change offset depending on the row if (parity == 0) // playable squares start on immediate left offset = hsegment * 3 + dx; else // playable squares start on 2nd square from left offset = hsegment * 2 + dx; // find where roi should be Point p1 = new Point(offset + count * hsegment, rowNum * vsegment); // top left point of rectangle (x,y) Point p2 = new Point(offset + (count + 1) * hsegment, (rowNum + 1) * vsegment); // bottom right point of rectangle (x,y) // create rectangle that is board square Rect bound = new Rect(p1, p2); // frame only includes rectangle Mat roi = new Mat(in, bound); Imgproc.cvtColor(roi, roi, Imgproc.COLOR_BGR2GRAY); // change to single color Mat canny = new Mat(); Imgproc.Canny(roi, canny, 2, 4); // make image a canny image that is only edges; 2,4 // lower threshold values find more edges List<MatOfPoint> contours = new ArrayList<MatOfPoint>(); Mat hierarchy = new Mat(); // holds nested contour information Imgproc.findContours(canny, contours, hierarchy, Imgproc.RETR_EXTERNAL, Imgproc.CHAIN_APPROX_SIMPLE); // Imgproc.RETR_LIST, TREE // Get bounding rect of contour Rect rect = Imgproc.boundingRect(contours.get(0)); if (rect.height > in.rows() / 8) { board[i]++; // make it a king } count += 2; if (count == 8) { parity = ++parity % 2; // change odd or even count = 0; rowNum++; hsegment += 1; dx -= 6; } }*/ }
/** * Processes the board image * * @param in image captured of board * @param out processed image of board */ public void processFrame(Mat in, Mat out) { // multiple regions of interest int playSquares = 32; // number of playable game board squares // keep track of starting row square int parity = 0; // 0 is even, 1 is odd, tied to row number int count = 0; // row square int rowNum = 0; // row number, starting at 0 int vsegment = in.rows() / 8; // only accounts 8 playable int hsegment = in.cols() / 10; // 8 playable, 2 capture int hOffset = hsegment * 2; // offset for playable board int vOffset = vsegment + 40; // For angle of camera int dx = 80; int ddx = 0; hsegment -= 16; int dy = 20; vsegment -= 24; // Go through all playable squares for (int i = 0; i < playSquares; i++) { // change offset depending on the row if (parity == 0) // playable squares start on 2nd square from left { if (rowNum >= 5) dx -= 3; hOffset = hsegment * 2 + dx; } else // playable squares start on immediate left { if (rowNum >= 5) dx -= 3; hOffset = hsegment + dx; } if (rowNum == 4) if (count == 6) ddx = 10; if (rowNum == 5) { if (count == 0) ddx = -6; else if (count == 2) ddx = 6; else if (count == 4) ddx = 12; else if (count == 6) ddx = 20; } if (rowNum == 6) { if (count == 0) ddx = 0; else if (count == 2) ddx = 16; else if (count == 4) ddx = 32; else if (count == 6) ddx = 40; } if (rowNum == 7) { if (count == 0) ddx = 0; else if (count == 2) ddx = 24; else if (count == 4) ddx = 40; else ddx = 52; } // find where roi should be // System.out.println("" + vOffset); Point p1 = new Point( hOffset + count * hsegment + ddx, vOffset + rowNum * vsegment - dy); // top left point of rectangle (x,y) Point p2 = new Point( hOffset + (count + 1) * hsegment + ddx, vOffset + (rowNum + 1) * vsegment - dy); // bottom right point of rectangle (x,y) // create rectangle that is board square Rect bound = new Rect(p1, p2); char color; if (i == 0) { // frame only includes rectangle Mat roi = new Mat(in, bound); // get the color color = identifyColor(roi); // copy input image to output image in.copyTo(out); } else { // frame only includes rectangle Mat roi = new Mat(out, bound); // get the color color = identifyColor(roi); } // annotate the output image // scalar values as (blue, green, red) switch (color) { case COLOR_BLUE: // Imgproc.rectangle(out, p1, p2, new Scalar(255, 0, 0), 2); Core.rectangle(out, p1, p2, new Scalar(255, 0, 0), 2); board[i] = CheckersBoard.BLACK; // end user's piece break; case COLOR_ORANGE: // Imgproc.rectangle(out, p1, p2, new Scalar(0, 128, 255), 2); Core.rectangle(out, p1, p2, new Scalar(0, 128, 255), 2); board[i] = CheckersBoard.WHITE; // system's piece break; case COLOR_WHITE: // Imgproc.rectangle(out, p1, p2, new Scalar(255, 255, 255), 2); Core.rectangle(out, p1, p2, new Scalar(255, 255, 255), 2); board[i] = CheckersBoard.EMPTY; break; case COLOR_BLACK: // this is black // Imgproc.rectangle(out, p1, p2, new Scalar(0, 0, 0), 2); Core.rectangle( out, p1, p2, new Scalar(0, 0, 0), 2); // maybe add 8, 0 as line type and fractional bits board[i] = CheckersBoard.EMPTY; break; } count += 2; if (count == 8) { parity = ++parity % 2; // change odd or even count = 0; rowNum++; hsegment += 2; dx -= 10; dy += 10; vsegment += 3; } } }
public void hpFind(Mat mRgba, Mat mGray, WorkingHeadPose hp, Rect[] facesArray) // public void hpFind(Mat mRgba,Mat mGray,HeadPose hp) { int i; Log.i("HeadPose", "hpFind:Total Faces Found" + facesArray.length); if (hp.hpstatus == HeadPoseStatus.NONE) { if (facesArray.length < 1) return; TempFace = facesArray.clone(); hp.cornerCount = hp.maxCorners; Rect roi = new Rect( (int) facesArray[0].tl().x, (int) (facesArray[0].tl().y), facesArray[0].width, (int) (facesArray[0].height)); // imran Mat cropped = new Mat(); Mat GrayClone = new Mat(); GrayClone = mGray.clone(); cropped = GrayClone.submat(roi); hpFindCorners(cropped, hp); // mGray is untouched // ******** working fine upto here // Map face points to model if (hp.cornerCount < 4) return; Vector<Point3> points = new Vector<Point3>(); if (hp.corners.total() > 0) // adding to make sure, copying is done perfectly.imran,was getting exception { Log.i("hpFind+", "hp.corners.total()" + hp.corners.total()); Log.i("hpFind+", "hp.cornerCount" + hp.cornerCount); // Point3 temp1;//=new Point3(); for (i = 0; i < hp.cornerCount; i++) { if (i == hp.corners.total()) break; // Log.i("hpFind+","Itertion"+i); points.add( new Point3( (hp.corners.toList().get(i).x / facesArray[0].width) - 0.5, -(hp.corners.toList().get(i).y / facesArray[0].height) + 0.5, 0.5 * Math.sin(PI * (hp.corners.toList().get(i).x / facesArray[0].width)))); // modelPoints.toList().set(i, // hpmodel(hp.corners.toList().get(i).x/facesArray[0].width,hp.corners.toList().get(i).x/facesArray[0].height)); // temp1=new Point3((hp.corners.toList().get(i).x/facesArray[0].width) - // 0.5,-(hp.corners.toList().get(i).y/facesArray[0].height) + 0.5, 0.5 * Math.sin(PI // *(hp.corners.toList().get(i).x/facesArray[0].width))); // modelPoints. .p .toList().set .set(i,temp1); } modelPoints.fromList(points); } // imran example from marker.java , search for Point3f // Traslate corners from face coordinated to image coordinates for (i = 0; i < hp.cornerCount; i++) { if (i == hp.corners.total()) break; hp.corners.toList().get(i).x += facesArray[0].tl().x; hp.corners.toList().get(i).y += facesArray[0].br().y; // hp.corners.toList().set(i, hp.corners.toList().get(i)+facesArray[0].tl().x); } hp.corners.copyTo(hp.tempcorners); // .clone(); // Change status hp.hpstatus = HeadPoseStatus.KEYFRAME; } else { if (facesArray.length > 1) TempFace = facesArray.clone(); // imran assigning here also,to better measure MatOfPoint2f corners2f = new MatOfPoint2f(); hp.corners.convertTo(corners2f, CvType.CV_32FC2); hp.previousCorners = corners2f; corners2f.convertTo(hp.corners, CvType.CV_32S); hpTrack(mRgba, hp, facesArray); Point center = new Point(); if (hp.cornerCount < 4) { hp.hpstatus = HeadPoseStatus.NONE; return; } hp.hpstatus = HeadPoseStatus.TRACKING; } if (hp.previousFrame == null) // imran { // hp.previousFrame =new Mat(mRgba.width(),mRgba.height(),CvType); hp.previousFrame = new Mat(mRgba.size(), CvType.CV_8UC4); } mRgba.copyTo(hp.previousFrame); // cvCopy(frame, headPose->previousFrame, NULL); }
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 Mat onCameraFrame(Mat inputFrame) { inputFrame.copyTo(mRgba); switch (ImageManipulationsActivity.viewMode) { case ImageManipulationsActivity.VIEW_MODE_RGBA: break; case ImageManipulationsActivity.VIEW_MODE_HIST: if ((mSizeRgba == null) || (mRgba.cols() != mSizeRgba.width) || (mRgba.height() != mSizeRgba.height)) CreateAuxiliaryMats(); int thikness = (int) (mSizeRgba.width / (mHistSizeNum + 10) / 5); if (thikness > 5) thikness = 5; int offset = (int) ((mSizeRgba.width - (5 * mHistSizeNum + 4 * 10) * thikness) / 2); // RGB for (int c = 0; c < 3; c++) { Imgproc.calcHist(Arrays.asList(mRgba), mChannels[c], mMat0, mHist, mHistSize, mRanges); Core.normalize(mHist, mHist, mSizeRgba.height / 2, 0, Core.NORM_INF); mHist.get(0, 0, mBuff); for (int h = 0; h < mHistSizeNum; h++) { mP1.x = mP2.x = offset + (c * (mHistSizeNum + 10) + h) * thikness; mP1.y = mSizeRgba.height - 1; mP2.y = mP1.y - 2 - (int) mBuff[h]; Core.line(mRgba, mP1, mP2, mColorsRGB[c], thikness); } } // Value and Hue Imgproc.cvtColor(mRgba, mIntermediateMat, Imgproc.COLOR_RGB2HSV_FULL); // Value Imgproc.calcHist( Arrays.asList(mIntermediateMat), mChannels[2], mMat0, mHist, mHistSize, mRanges); Core.normalize(mHist, mHist, mSizeRgba.height / 2, 0, Core.NORM_INF); mHist.get(0, 0, mBuff); for (int h = 0; h < mHistSizeNum; h++) { mP1.x = mP2.x = offset + (3 * (mHistSizeNum + 10) + h) * thikness; mP1.y = mSizeRgba.height - 1; mP2.y = mP1.y - 2 - (int) mBuff[h]; Core.line(mRgba, mP1, mP2, mWhilte, thikness); } // Hue Imgproc.calcHist( Arrays.asList(mIntermediateMat), mChannels[0], mMat0, mHist, mHistSize, mRanges); Core.normalize(mHist, mHist, mSizeRgba.height / 2, 0, Core.NORM_INF); mHist.get(0, 0, mBuff); for (int h = 0; h < mHistSizeNum; h++) { mP1.x = mP2.x = offset + (4 * (mHistSizeNum + 10) + h) * thikness; mP1.y = mSizeRgba.height - 1; mP2.y = mP1.y - 2 - (int) mBuff[h]; Core.line(mRgba, mP1, mP2, mColorsHue[h], thikness); } break; case ImageManipulationsActivity.VIEW_MODE_CANNY: if ((mRgbaInnerWindow == null) || (mGrayInnerWindow == null) || (mRgba.cols() != mSizeRgba.width) || (mRgba.height() != mSizeRgba.height)) CreateAuxiliaryMats(); Imgproc.Canny(mRgbaInnerWindow, mIntermediateMat, 80, 90); Imgproc.cvtColor(mIntermediateMat, mRgbaInnerWindow, Imgproc.COLOR_GRAY2BGRA, 4); break; case ImageManipulationsActivity.VIEW_MODE_SOBEL: Imgproc.cvtColor(mRgba, mGray, Imgproc.COLOR_RGBA2GRAY); if ((mRgbaInnerWindow == null) || (mGrayInnerWindow == null) || (mRgba.cols() != mSizeRgba.width) || (mRgba.height() != mSizeRgba.height)) CreateAuxiliaryMats(); Imgproc.Sobel(mGrayInnerWindow, mIntermediateMat, CvType.CV_8U, 1, 1); Core.convertScaleAbs(mIntermediateMat, mIntermediateMat, 10, 0); Imgproc.cvtColor(mIntermediateMat, mRgbaInnerWindow, Imgproc.COLOR_GRAY2BGRA, 4); break; case ImageManipulationsActivity.VIEW_MODE_SEPIA: Core.transform(mRgba, mRgba, mSepiaKernel); break; case ImageManipulationsActivity.VIEW_MODE_ZOOM: if ((mZoomCorner == null) || (mZoomWindow == null) || (mRgba.cols() != mSizeRgba.width) || (mRgba.height() != mSizeRgba.height)) CreateAuxiliaryMats(); Imgproc.resize(mZoomWindow, mZoomCorner, mZoomCorner.size()); Size wsize = mZoomWindow.size(); Core.rectangle( mZoomWindow, new Point(1, 1), new Point(wsize.width - 2, wsize.height - 2), new Scalar(255, 0, 0, 255), 2); break; case ImageManipulationsActivity.VIEW_MODE_PIXELIZE: if ((mRgbaInnerWindow == null) || (mRgba.cols() != mSizeRgba.width) || (mRgba.height() != mSizeRgba.height)) CreateAuxiliaryMats(); Imgproc.resize(mRgbaInnerWindow, mIntermediateMat, mSize0, 0.1, 0.1, Imgproc.INTER_NEAREST); Imgproc.resize( mIntermediateMat, mRgbaInnerWindow, mSizeRgbaInner, 0., 0., Imgproc.INTER_NEAREST); break; case ImageManipulationsActivity.VIEW_MODE_POSTERIZE: if ((mRgbaInnerWindow == null) || (mRgba.cols() != mSizeRgba.width) || (mRgba.height() != mSizeRgba.height)) CreateAuxiliaryMats(); /* Imgproc.cvtColor(mRgbaInnerWindow, mIntermediateMat, Imgproc.COLOR_RGBA2RGB); Imgproc.pyrMeanShiftFiltering(mIntermediateMat, mIntermediateMat, 5, 50); Imgproc.cvtColor(mIntermediateMat, mRgbaInnerWindow, Imgproc.COLOR_RGB2RGBA); */ Imgproc.Canny(mRgbaInnerWindow, mIntermediateMat, 80, 90); mRgbaInnerWindow.setTo(new Scalar(0, 0, 0, 255), mIntermediateMat); Core.convertScaleAbs(mRgbaInnerWindow, mIntermediateMat, 1. / 16, 0); Core.convertScaleAbs(mIntermediateMat, mRgbaInnerWindow, 16, 0); break; } return mRgba; }