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;
}