private void displayRectOnImageSegment(Mat imgMat, boolean markerFound) {
Scalar color = null;
if (markerFound) color = new Scalar(0, 255, 0, 255);
else color = new Scalar(255, 160, 36, 255);
Rect rect = calculateImageSegmentArea(imgMat);
Core.rectangle(imgMat, rect.tl(), rect.br(), color, 3, Core.LINE_AA, 0);
}
public static void main(String[] args) {
// 指定读出的图片路径和输出的文件
String inputImagePath =
identificate.class.getClassLoader().getResource("hf.jpg").getPath().substring(1);
String outputImageFile = "identificate.png";
String xmlPath =
identificate
.class
.getClassLoader()
.getResource("cascade_storage.xml")
.getPath()
.substring(1);
System.loadLibrary(Core.NATIVE_LIBRARY_NAME);
CascadeClassifier faceDetector = new CascadeClassifier(xmlPath);
Mat image = Highgui.imread(inputImagePath);
MatOfRect faceDetections = new MatOfRect();
faceDetector.detectMultiScale(image, faceDetections);
// 画出脸的位置
for (Rect rect : faceDetections.toArray()) {
Core.rectangle(
image,
new Point(rect.x, rect.y),
new Point(rect.x + rect.width, rect.y + rect.height),
new Scalar(0, 0, 255));
}
// 写入到文件
Highgui.imwrite(outputImageFile, image);
System.out.print("\nOK!");
}
@Override
public Mat onCameraFrame(CameraBridgeViewBase.CvCameraViewFrame inputFrame) {
mRgba = inputFrame.rgba();
Imgproc.cvtColor(mRgba, grayScaleImage, Imgproc.COLOR_RGBA2RGB);
MatOfRect faces = new MatOfRect();
// detect faces
if (cascadeClassifier != null) {
cascadeClassifier.detectMultiScale(
grayScaleImage,
faces,
1.1,
2,
2,
new Size(absoluteFaceSize, absoluteFaceSize),
new Size());
}
Rect[] facesArray = faces.toArray();
for (int i = 0; i < facesArray.length; i++)
Core.rectangle(mRgba, facesArray[i].tl(), facesArray[i].br(), new Scalar(0, 255, 0, 255), 3);
if (facesArray.length > 0) {
facesInASecond.add(true);
} else {
facesInASecond.add(false);
}
return mRgba;
}
public void dibujarRegiones() {
// **** Crear los cuadros de cada region (para debugging) ***
// L izquierda
Point pt1 = new Point(0, 0);
Point pt2 = new Point(mRgba.width() / 4, mRgba.height());
Core.rectangle(mRgba, pt1, pt2, WHITE);
// C centro-arriba
Point pt3 = new Point(mRgba.width() / 4, 0);
Point pt4 = new Point((mRgba.width() / 4) * 3, (mRgba.height() / 4) * 3);
Core.rectangle(mRgba, pt3, pt4, WHITE);
// N centro-abajo
Point pt5 = new Point(mRgba.width() / 4, (mRgba.height() / 4) * 3);
Point pt6 = new Point((mRgba.width() / 4) * 3, mRgba.height());
Core.rectangle(mRgba, pt5, pt6, WHITE);
// R derecha
Point pt7 = new Point((mRgba.width() / 4) * 3, 0);
Point pt8 = new Point(mRgba.width(), mRgba.height());
Core.rectangle(mRgba, pt7, pt8, WHITE);
}
private double match_eye(Rect area, Mat mTemplate, int type) {
Point matchLoc;
Mat mROI = mGray.submat(area);
int result_cols = mGray.cols() - mTemplate.cols() + 1;
int result_rows = mGray.rows() - mTemplate.rows() + 1;
if (mTemplate.cols() == 0 || mTemplate.rows() == 0) {
return 0.0;
}
mResult = new Mat(result_cols, result_rows, CvType.CV_32FC1);
switch (type) {
case TM_SQDIFF:
Imgproc.matchTemplate(mROI, mTemplate, mResult, Imgproc.TM_SQDIFF);
break;
case TM_SQDIFF_NORMED:
Imgproc.matchTemplate(mROI, mTemplate, mResult, Imgproc.TM_SQDIFF_NORMED);
break;
case TM_CCOEFF:
Imgproc.matchTemplate(mROI, mTemplate, mResult, Imgproc.TM_CCOEFF);
break;
case TM_CCOEFF_NORMED:
Imgproc.matchTemplate(mROI, mTemplate, mResult, Imgproc.TM_CCOEFF_NORMED);
break;
case TM_CCORR:
Imgproc.matchTemplate(mROI, mTemplate, mResult, Imgproc.TM_CCORR);
break;
case TM_CCORR_NORMED:
Imgproc.matchTemplate(mROI, mTemplate, mResult, Imgproc.TM_CCORR_NORMED);
break;
}
Core.MinMaxLocResult mmres = Core.minMaxLoc(mResult);
if (type == TM_SQDIFF || type == TM_SQDIFF_NORMED) {
matchLoc = mmres.minLoc;
} else {
matchLoc = mmres.maxLoc;
}
Point matchLoc_tx = new Point(matchLoc.x + area.x, matchLoc.y + area.y);
Point matchLoc_ty =
new Point(matchLoc.x + mTemplate.cols() + area.x, matchLoc.y + mTemplate.rows() + area.y);
Core.rectangle(mRgba, matchLoc_tx, matchLoc_ty, new Scalar(255, 255, 0, 255));
if (type == TM_SQDIFF || type == TM_SQDIFF_NORMED) {
return mmres.maxVal;
} else {
return mmres.minVal;
}
}
private Mat get_template(CascadeClassifier clasificator, Rect area, int size) {
Mat template = new Mat();
Mat mROI = mGray.submat(area);
MatOfRect eyes = new MatOfRect();
Point iris = new Point();
Rect eye_template = new Rect();
clasificator.detectMultiScale(
mROI,
eyes,
1.15,
2,
Objdetect.CASCADE_FIND_BIGGEST_OBJECT | Objdetect.CASCADE_SCALE_IMAGE,
new Size(30, 30),
new Size());
Rect[] eyesArray = eyes.toArray();
for (int i = 0; i < eyesArray.length; i++) {
Rect e = eyesArray[i];
e.x = area.x + e.x;
e.y = area.y + e.y;
Rect eye_only_rectangle =
new Rect(
(int) e.tl().x,
(int) (e.tl().y + e.height * 0.4),
(int) e.width,
(int) (e.height * 0.6));
mROI = mGray.submat(eye_only_rectangle);
Mat vyrez = mRgba.submat(eye_only_rectangle);
Core.MinMaxLocResult mmG = Core.minMaxLoc(mROI);
Core.circle(vyrez, mmG.minLoc, 2, new Scalar(255, 255, 255, 255), 2);
iris.x = mmG.minLoc.x + eye_only_rectangle.x;
iris.y = mmG.minLoc.y + eye_only_rectangle.y;
eye_template = new Rect((int) iris.x - size / 2, (int) iris.y - size / 2, size, size);
Core.rectangle(mRgba, eye_template.tl(), eye_template.br(), new Scalar(255, 0, 0, 255), 2);
template = (mGray.submat(eye_template)).clone();
return template;
}
return template;
}
public void templateMatching() {
System.loadLibrary(Core.NATIVE_LIBRARY_NAME);
int match_method = 5;
int max_Trackbar = 5;
Mat data = Highgui.imread("images/training_data/1" + "/data (" + 1 + ").jpg");
Mat temp = Highgui.imread("images/template.jpg");
Mat img = data.clone();
int result_cols = img.cols() - temp.cols() + 1;
int result_rows = img.rows() - temp.rows() + 1;
Mat result = new Mat(result_rows, result_cols, CvType.CV_32FC1);
Imgproc.matchTemplate(img, temp, result, match_method);
Core.normalize(result, result, 0, 1, Core.NORM_MINMAX, -1, new Mat());
double minVal;
double maxVal;
Point minLoc;
Point maxLoc;
Point matchLoc;
// minMaxLoc( result, &minVal, &maxVal, &minLoc, &maxLoc, Mat() );
Core.MinMaxLocResult res = Core.minMaxLoc(result);
if (match_method == Imgproc.TM_SQDIFF || match_method == Imgproc.TM_SQDIFF_NORMED) {
matchLoc = res.minLoc;
} else {
matchLoc = res.maxLoc;
}
// / Show me what you got
Core.rectangle(
img,
matchLoc,
new Point(matchLoc.x + temp.cols(), matchLoc.y + temp.rows()),
new Scalar(0, 255, 0));
// Save the visualized detection.
Highgui.imwrite("images/samp.jpg", img);
}
/**
* 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 (mAbsoluteFaceSize == 0) {
int height = mGray.rows();
if (Math.round(height * mRelativeFaceSize) > 0) {
mAbsoluteFaceSize = Math.round(height * mRelativeFaceSize);
}
mNativeDetector.setMinFaceSize(mAbsoluteFaceSize);
}
MatOfRect faces = new MatOfRect();
if (mDetectorType == JAVA_DETECTOR) {
if (mJavaDetector != null)
mJavaDetector.detectMultiScale(
mGray,
faces,
1.1,
2,
2, // TODO: objdetect.CV_HAAR_SCALE_IMAGE
new Size(mAbsoluteFaceSize, mAbsoluteFaceSize),
new Size());
} else if (mDetectorType == NATIVE_DETECTOR) {
if (mNativeDetector != null) mNativeDetector.detect(mGray, faces);
} else {
Log.e(TAG, "Detection method is not selected!");
}
Rect[] facesArray = faces.toArray();
for (int i = 0; i < facesArray.length; i++)
Core.rectangle(mRgba, facesArray[i].tl(), facesArray[i].br(), FACE_RECT_COLOR, 3);
return mRgba;
}
/**
* 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;
}
}
}
/** drawRectangle, dessine les rectangles sur la matrice */
public void drawRectangle() {
Core.rectangle(currentFrame, rectA.br(), rectA.tl(), new Scalar(0, 255, 255), 2);
Core.rectangle(currentFrame, rectB.br(), rectB.tl(), new Scalar(0, 255, 0), 2);
Core.rectangle(currentFrame, rectC.br(), rectC.tl(), new Scalar(255, 255, 0), 2);
Core.rectangle(currentFrame, rectD.br(), rectD.tl(), new Scalar(255, 0, 0), 2);
}
/**
* detection_contours, détecte les contours, les affiches et gères le traitement
* d'authentification
*
* @param inmat : la matrice qui arrive pour la detection de contour
* @param outmat : la matrice qui sort après les comptours
*/
public void detection_contours(Mat inmat, Mat outmat) {
Mat v = new Mat();
Mat vv = outmat.clone();
List<MatOfPoint> contours = new ArrayList(); // Tous les contours
int key; // Plus gros contours
MatOfInt hullI = new MatOfInt();
List<MatOfPoint> hullP = new ArrayList<MatOfPoint>();
Rect r; // Rectangle du plus gros contours
// Trouve tous les contours
Imgproc.findContours(vv, contours, v, Imgproc.RETR_LIST, Imgproc.CHAIN_APPROX_SIMPLE);
// Calcul l'indice du plus gros contours
key = findBiggestContour(contours);
// S'il y a au moins un contours et le
if (key != 0) {
Imgproc.drawContours(inmat, contours, key, new Scalar(0, 0, 255));
r = Imgproc.boundingRect(contours.get(key));
Core.rectangle(currentFrame, r.br(), r.tl(), new Scalar(0, 255, 0), 1);
}
// Calcul les points convexes de la main
Imgproc.convexHull(contours.get(key), hullI, false);
// S'il y a des points de convexion
if (hullI != null) {
// Reinitialise les points de convexion
hullP.clear();
// On calcule le nombres de points de convexion
for (int i = 0; contours.size() >= i; i++) hullP.add(new MatOfPoint());
int[] cId = hullI.toArray();
// On récupère dans un tableau de points, les points du contours
Point[] contourPts = contours.get(key).toArray();
// Réinitialisation des points de recherche dans les tableau
int findRectA = 0;
int findRectB = 0;
int findRectC = 0;
int findRectD = 0;
// Pour chaque point de convexion
for (int i = 0; i < cId.length; i++) {
// Dessin du point de convexion sur la matrice
Core.circle(inmat, contourPts[cId[i]], 2, new Scalar(241, 247, 45), -3);
// Si le point de convexion se trouve dans un des carrés
// on incrémente le compteur associé
if (isInRectangle(rectA, contourPts[cId[i]])) findRectA++;
else if (isInRectangle(rectB, contourPts[cId[i]])) findRectB++;
else if (isInRectangle(rectC, contourPts[cId[i]])) findRectC++;
else if (isInRectangle(rectD, contourPts[cId[i]])) findRectD++;
}
// Si on a trouvé la main dans le rectangle A
if (findRectA >= 5) {
if (cptRect == 0) {
numeroRect[cptRect] = 1;
cptRect++;
System.out.println("Haut gauche");
} else {
if (numeroRect[cptRect - 1] != 1) {
numeroRect[cptRect] = 1;
if (cptRect == 3) cptRect = 0;
else cptRect++;
System.out.println("Haut gauche");
}
}
}
// Si on a trouvé la main dans le rectangle B
if (findRectB >= 5) {
if (cptRect == 0) {
numeroRect[cptRect] = 2;
cptRect++;
System.out.println("Bas gauche");
} else {
if (numeroRect[cptRect - 1] != 2) {
numeroRect[cptRect] = 2;
if (cptRect == 3) cptRect = 0;
else cptRect++;
System.out.println("Bas gauche");
}
}
}
// Si on a trouvé la main dans le rectangle C
if (findRectC >= 5) {
if (cptRect == 0) {
numeroRect[cptRect] = 3;
if (cptRect == 3) cptRect = 0;
else cptRect++;
System.out.println("Haut droite");
} else {
if (numeroRect[cptRect - 1] != 3) {
numeroRect[cptRect] = 3;
if (cptRect == 3) cptRect = 0;
else cptRect++;
System.out.println("Haut droite");
}
}
}
// Si on a trouvé la main dans le rectangle D
if (findRectD >= 5) {
if (cptRect == 0) {
numeroRect[cptRect] = 4;
cptRect++;
System.out.println("Bas droite");
} else {
if (numeroRect[cptRect - 1] != 4) {
numeroRect[cptRect] = 4;
if (cptRect == 3) cptRect = 0;
else cptRect++;
System.out.println("Bas droite");
}
}
}
// Si on a sélectionné 3 fenètres et que cela correspond au mot de passe
// MOT DE PASSE : Haut Gauche - Bas Droite - Bas Gauche
if (cptRect == 3) {
if ((numeroRect[0] == 1) && (numeroRect[1] == 4) && (numeroRect[2] == 2))
this.jTextField2.setText("Authenticated");
// Réinitilisation du compteur
cptRect = 0;
}
}
}
public void processImage(Mat imageToProcess) {
try {
final Mat processedImage = imageToProcess.clone();
// red
final Mat redUpper = new Mat();
final Mat redLower = new Mat();
Core.inRange(processedImage, new Scalar(170, 100, 20), new Scalar(180, 255, 255), redUpper);
Core.inRange(processedImage, new Scalar(0, 100, 20), new Scalar(20, 255, 255), redLower);
Core.bitwise_or(redLower, redUpper, processedImage);
// refining the binary image
Imgproc.erode(processedImage, processedImage, new Mat(), new Point(-1, -1), 1);
Imgproc.dilate(processedImage, processedImage, new Mat(), new Point(-1, -1), 0);
// create a clone for the processedImage to be used in finding contours
final Mat clone = processedImage.clone();
Imgproc.cvtColor(processedImage, processedImage, Imgproc.COLOR_GRAY2RGB);
// finds list of contours and draw the biggest on the processedImage
final Scalar color1 = new Scalar(0, 0, 255);
final Scalar color2 = new Scalar(255, 255, 0);
final Scalar color3 = new Scalar(255, 255, 255);
final List<MatOfPoint> contours = new ArrayList<MatOfPoint>();
Imgproc.findContours(
clone, contours, new Mat(), Imgproc.RETR_LIST, Imgproc.CHAIN_APPROX_NONE);
final List<MatOfPoint> contour = new ArrayList<MatOfPoint>(1);
double maxArea = 0.0;
for (int index = 0; index < contours.size(); index++) {
double area = Imgproc.contourArea(contours.get(index));
if (area > maxArea && area > 25 && Imgproc.boundingRect(contours.get(index)).y > 40) {
maxArea = area;
contour.add(0, contours.get(index));
}
}
// finds bounding Rectangle and draws contours
Rect boundingRect = new Rect();
if (contour.size() > 0) {
Imgproc.drawContours(processedImage, contour, -2, color1);
boundingRect = Imgproc.boundingRect(contour.get(0));
final double x = boundingRect.x;
final double y = boundingRect.y;
final double width = boundingRect.width;
final double height = boundingRect.height;
Core.rectangle(processedImage, new Point(x, y), new Point(x + width, y + height), color3);
}
// finding bounding Circle and draws it
final Point center = new Point();
final float[] radius = new float[1];
if (contour.size() > 0) {
final MatOfPoint2f contour2f = new MatOfPoint2f(contour.get(0).toArray());
Imgproc.minEnclosingCircle(contour2f, center, radius);
Core.circle(processedImage, center, (int) radius[0], color2);
}
final BallStruct redBallStruct = new BallStruct(boundingRect, center, (double) radius[0]);
final BallTargeting ballTargeting = new BallTargeting(redBallStruct);
synchronized (this) {
distanceToRed = ballTargeting.getDistance();
angleToRedInDegrees = ballTargeting.getAngle() * (180 / Math.PI);
this.processedImage = processedImage;
}
} catch (Exception e) {
}
}
public 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;
}
@Override
protected Bitmap processFrame(VideoCapture capture) {
capture.retrieve(mRgba, Highgui.CV_CAP_ANDROID_COLOR_FRAME_RGBA);
capture.retrieve(mGray, Highgui.CV_CAP_ANDROID_GREY_FRAME);
if (mAbsoluteFaceSize == 0) {
int height = mGray.rows();
if (Math.round(height * mRelativeFaceSize) > 0) ;
{
mAbsoluteFaceSize = Math.round(height * mRelativeFaceSize);
}
mNativeDetector.setMinFaceSize(mAbsoluteFaceSize);
}
MatOfRect faces = new MatOfRect();
if (mDetectorType == JAVA_DETECTOR) {
if (mJavaDetector != null)
mJavaDetector.detectMultiScale(
mGray,
faces,
1.1,
2,
2 // TODO: objdetect.CV_HAAR_SCALE_IMAGE
,
new Size(mAbsoluteFaceSize, mAbsoluteFaceSize),
new Size());
if (mZoomCorner == null || mZoomWindow == null) CreateAuxiliaryMats();
Rect[] facesArray = faces.toArray();
for (int i = 0; i < facesArray.length; i++) {
Rect r = facesArray[i];
Core.rectangle(mGray, r.tl(), r.br(), new Scalar(0, 255, 0, 255), 3);
Core.rectangle(mRgba, r.tl(), r.br(), new Scalar(0, 255, 0, 255), 3);
eyearea =
new Rect(
r.x + r.width / 8,
(int) (r.y + (r.height / 4.5)),
r.width - 2 * r.width / 8,
(int) (r.height / 3.0));
Core.rectangle(mRgba, eyearea.tl(), eyearea.br(), new Scalar(255, 0, 0, 255), 2);
Rect eyearea_right =
new Rect(
r.x + r.width / 16,
(int) (r.y + (r.height / 4.5)),
(r.width - 2 * r.width / 16) / 2,
(int) (r.height / 3.0));
Rect eyearea_left =
new Rect(
r.x + r.width / 16 + (r.width - 2 * r.width / 16) / 2,
(int) (r.y + (r.height / 4.5)),
(r.width - 2 * r.width / 16) / 2,
(int) (r.height / 3.0));
Core.rectangle(mRgba, eyearea_left.tl(), eyearea_left.br(), new Scalar(255, 0, 0, 255), 2);
Core.rectangle(
mRgba, eyearea_right.tl(), eyearea_right.br(), new Scalar(255, 0, 0, 255), 2);
if (learn_frames < 5) {
teplateR = get_template(mCascadeER, eyearea_right, 24);
teplateL = get_template(mCascadeEL, eyearea_left, 24);
learn_frames++;
} else {
match_value = match_eye(eyearea_right, teplateR, FdActivity.method);
match_value = match_eye(eyearea_left, teplateL, FdActivity.method);
;
}
Imgproc.resize(mRgba.submat(eyearea_left), mZoomWindow2, mZoomWindow2.size());
Imgproc.resize(mRgba.submat(eyearea_right), mZoomWindow, mZoomWindow.size());
}
} else if (mDetectorType == NATIVE_DETECTOR) {
if (mNativeDetector != null) mNativeDetector.detect(mGray, faces);
} else {
Log.e(TAG, "Detection method is not selected!");
}
Rect[] facesArray = faces.toArray();
for (int i = 0; i < facesArray.length; i++)
Core.rectangle(mRgba, facesArray[i].tl(), facesArray[i].br(), FACE_RECT_COLOR, 3);
Bitmap bmp = Bitmap.createBitmap(mRgba.cols(), mRgba.rows(), Bitmap.Config.ARGB_8888);
try {
Utils.matToBitmap(mRgba, bmp);
} catch (Exception e) {
Log.e(TAG, "Utils.matToBitmap() throws an exception: " + e.getMessage());
bmp.recycle();
bmp = null;
}
return bmp;
}
/**
* Determines where captured pieces are
*
* @param in Mat image of the board
*/
public void findCaptured(Mat in) {
int vsegment = in.rows() / 8; // only accounts 8 playable
int hsegment = in.cols() / 12; // 8 playable, 2 capture, 2 extra
int offset; // offset for playable board
int capSquares = 12; // number of capture squares
int rowNum = 1; // starting row number for capture squares
int rightdx = 48;
int leftdx = 0;
offset = hsegment;
int count = 0;
// keep track of captured squares
// left: end user, right: system
for (int i = 0; i < capSquares; i++) {
// 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);
char color;
// frame only includes rectangle
Mat roi = new Mat(in, bound);
// get the color
color = identifyColor(roi);
switch (color) {
case COLOR_BLUE:
// Imgproc.rectangle(in, p1, p2, new Scalar(255, 0, 0), 3);
Core.rectangle(in, p1, p2, new Scalar(255, 0, 0), 2);
captured[i] = 1;
break;
case COLOR_ORANGE:
// Imgproc.rectangle(in, p1, p2, new Scalar(0, 128, 255), 3);
Core.rectangle(in, p1, p2, new Scalar(0, 128, 255), 2);
captured[i] = 1;
break;
case COLOR_WHITE:
// Imgproc.rectangle(in, p1, p2, new Scalar(255, 255, 255), 3);
Core.rectangle(in, p1, p2, new Scalar(255, 255, 255), 2);
captured[i] = 0;
break;
case COLOR_BLACK:
// Imgproc.rectangle(in, p1, p2, new Scalar(0, 0, 0), 3);
Core.rectangle(in, p1, p2, new Scalar(255, 255, 255), 2);
captured[i] = 0;
break;
}
count++;
if (count == 1) {
offset = hsegment * 10 - rightdx;
} else if (count == 2) {
count = 0;
rightdx -= 6;
leftdx += 6;
offset = hsegment - leftdx;
rowNum++;
}
}
}
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;
}
}
}
private Mat drawLines(Mat inputFrame) {
int row = inputFrame.rows();
int col = inputFrame.cols();
if (mIsFound) {
// Core.line(inputFrame, new Point(10,10), new Point(10,row-10), new Scalar(0, 255, 0, 255),
// 3);
// Core.line(inputFrame, new Point(10,10), new Point(col-10,10), new Scalar(0, 255, 0, 255),
// 3);
// Core.line(inputFrame, new Point(10,row-10), new Point(col-10,row-10), new Scalar(0, 255, 0,
// 255), 3);
// Core.line(inputFrame, new Point(col-10,10), new Point(col-10,row-10), new Scalar(0, 255, 0,
// 255), 3);
/*
if(mCheckIcon == null){
mCheckIcon = new Mat();
Bitmap input2 = MatchImageUtil.scaleAndTrun(BitmapFactory.decodeResource(getResources(), R.drawable.check_icon));
Utils.bitmapToMat(input2, mCheckIcon);
}
mCheckIcon.copyTo(inputFrame);
*/
int radius = (row > col ? col : row) / 2 - (row > col ? col : row) / 2 / 3;
Core.circle(inputFrame, new Point(col / 2, row / 2), radius, new Scalar(0, 255, 0, 255), 15);
}
int baseSize = (row > col ? col : row) / 2 - (row > col ? col : row) / 2 / 5;
Core.rectangle(
inputFrame,
new Point(col / 2 - baseSize, row / 2 - baseSize),
new Point(col / 2 + baseSize, row / 2 + baseSize),
new Scalar(255, 255, 255, 255),
1);
Core.line(
inputFrame,
new Point(col / 2 - 5, row / 2),
new Point(col / 2 + 5, row / 2),
new Scalar(255, 255, 255, 255),
1);
Core.line(
inputFrame,
new Point(col / 2, row / 2 - 5),
new Point(col / 2, row / 2 + 5),
new Scalar(255, 255, 255, 255),
1);
if (mIsBarDraw) {
if (mBarReverse) {
mBarCount -= 2;
} else {
mBarCount += 2;
}
if (!mBarReverse && mBarCount > row - 2 * MARGIN) {
mBarReverse = true;
}
if (mBarReverse && mBarCount < MARGIN) {
mBarReverse = false;
}
int curBarPosition = MARGIN + mBarCount;
Core.line(
inputFrame,
new Point(0, curBarPosition),
new Point(col, curBarPosition),
new Scalar(0, 255, 255, 255),
2);
}
return inputFrame;
}
