Android eye detection and tracking with OpenCV
ANDROID / OPENCV
28 LED, 2013
140
This tutorial is for older samples, if you are starting with the new ones (2.4.6) please
look at this updated tutorial. Method and principles of matching are the same for both.
Finally I found some time to write promised tutorial of eye detection and template
matching on Android. Since OpenCV for Android is getting better and better, some code
snippets can be old and not the best possible way to solve the problem. If you found
some improvements, please comment or contact me, I will edit this post and share it to
others.
We take standard OpenCV example for face detections and extends it a little.
Android OpenCV SDK can be found here
If you arentn familiar with Eclipse and OpenCV yet, please read basic setup of
opencv4android first.
Import Face detection sample to Eclipse and clean/build the project to be sure is
correctly imported and working.
As you can se on the video, there are some differences in GUI against the pure sample.
There is a slider to easily change the matching method and button to recreate the eye
template.
So at first we add those elements to the GUI.
1.
Open FdActivity.java and change content of LoaderCallbackInterface method
with snippet below. Code is pretty straightforward instead of putting instance
FdView as content view, we programmatically create new layout, add button and
verticalseekbar (this class is included in downloadable project at the end of page) to
layout and pass the whole layout as content view.
// Create and set View
mView = new FdView(mAppContext);
mView.setDetectorType(mDetectorType);
mView.setMinFaceSize(0.2f);
VerticalSeekBar VerticalseekBar = new VerticalSeekBar(
getApplicationContext());
VerticalseekBar.setMax(5);
VerticalseekBar.setPadding(20, 20, 20, 20);
RelativeLayout.LayoutParams vsek = new RelativeLayout.LayoutParams(
RelativeLayout.LayoutParams.WRAP_CONTENT, 400);
vsek.addRule(RelativeLayout.ALIGN_PARENT_RIGHT);
// Dont forget to set the id, or aligment will not work
VerticalseekBar.setId(1);
VerticalseekBar
.setOnSeekBarChangeListener(new
OnSeekBarChangeListener() {
public void onProgressChanged(SeekBar
seekBar,
int progress,
boolean fromUser) {
method = progress;
switch (method) {
case 0:
matching_method.setText("TM_SQDIFF");
break;
case 1:
matching_method.setText("TM_SQDIFF_NORMED");
break;
case 2:
matching_method.setText("TM_CCOEFF");
break;
case 3:
matching_method.setText("TM_CCOEFF_NORMED");
break;
case 4:
matching_method.setText("TM_CCORR");
break;
case 5:
matching_method.setText("TM_CCORR_NORMED");
break;
public void
onStartTrackingTouch(SeekBar seekBar) {
public void
onStopTrackingTouch(SeekBar seekBar) {
});
matching_method = new TextView(getApplicationContext());
matching_method.setText("TM_SQDIFF");
matching_method.setTextColor(Color.YELLOW);
RelativeLayout.LayoutParams matching_method_param = new
RelativeLayout.LayoutParams(
RelativeLayout.LayoutParams.WRAP_CONTENT,
RelativeLayout.LayoutParams.WRAP_CONTENT);
matching_method_param
.addRule(RelativeLayout.ALIGN_PARENT_RIGHT);
matching_method_param.addRule(RelativeLayout.BELOW,
VerticalseekBar.getId());
Button btn = new Button(getApplicationContext());
btn.setText("Create template");
RelativeLayout.LayoutParams btnp = new RelativeLayout.LayoutParams(
RelativeLayout.LayoutParams.WRAP_CONTENT,
RelativeLayout.LayoutParams.WRAP_CONTENT);
btnp.addRule(RelativeLayout.ALIGN_PARENT_LEFT);
btn.setId(2);
// Listen for click
btn.setOnClickListener(new OnClickListener() {
public void onClick(View v) {
mView.resetLearFramesCount();
});
RelativeLayout frameLayout = new RelativeLayout(
getApplicationContext());
frameLayout.addView(mView, 0);
frameLayout.addView(btn, btnp);
frameLayout.addView(VerticalseekBar, vsek);
frameLayout.addView(matching_method, matching_method_param);
setContentView(frameLayout);
2.
For testing purposes, edit SampleCvViewBase.java line 35 as shown below.
This will change video source to the front camera
mCamera = new VideoCapture(Highgui.CV_CAP_ANDROID+1);
3.
Now we are ready to do the main part. Open FdView.java
Add some Mats variables for zooming, templates and computations, Classificators for
right and left eye
class FdView extends SampleCvViewBase {
private static final String
TAG = "Sample::FdView";
private Mat
mRgba;
private Mat
mGray;
// Mats for zoom
private Mat
mZoomCorner;
private Mat
mZoomWindow;
private Mat
mZoomWindow2;
// Helper Mat
private Mat
mResult;
// Mat for templates
private Mat
teplateR;
private Mat
teplateL;
private File
mCascadeFile;
private CascadeClassifier
mJavaDetector;
// Classifiers for left-right eyes
private CascadeClassifier
mCascadeER;
private CascadeClassifier
mCascadeEL;
private DetectionBasedTracker mNativeDetector;
private static final Scalar
FACE_RECT_COLOR = new Scalar(0, 255, 0, 255);
public static final int
JAVA_DETECTOR
= 0;
public static final int
NATIVE_DETECTOR
= 1;
// Matching methods
private static final int TM_SQDIFF
= 0;
private static final int TM_SQDIFF_NORMED
= 1;
private static final int TM_CCOEFF
= 2;
private static final int TM_CCOEFF_NORMED
= 3;
private static final int TM_CCORR
= 4;
private static final int TM_CCORR_NORMED
= 5;
private int
mDetectorType
= JAVA_DETECTOR;
private float
mRelativeFaceSize = 0;
private int
mAbsoluteFaceSize = 0;
// counter of learning frames
private int
learn_frames = 0;
// match value
private double
match_value;
// rectangle used to extract eye region - ROI
private Rect
eyearea = new Rect();
Now we need to load cascade classifier files for left and right eye
haarcascade_lefteye_2splits.xml distributed with OpenCV package (data folder) I
used the same classifier for both eyes, because for right eye,
haarcascade_lefteye_2splits.xml gives me better results, than
haarcascade_righteye_2splits.xml . But you can try it with both simply rewrite the
filename.
Dont forget to copy haarcascade_lefteye_2splits.xml to /raw directory in your
Android project (if is not present, simply create it)
public FdView(Context context) {
super(context);
try {
InputStream is = context.getResources().openRawResource(R.raw.lbpcascade_frontalface);
File cascadeDir = context.getDir("cascade", Context.MODE_PRIVATE);
mCascadeFile = new File(cascadeDir, "lbpcascade_frontalface.xml");
FileOutputStream os = new FileOutputStream(mCascadeFile);
byte[] buffer = new byte[4096];
int bytesRead;
while ((bytesRead = is.read(buffer)) != -1) {
os.write(buffer, 0, bytesRead);
is.close();
os.close();
// --------------------------------- load left eye classificator -----------------------------------
InputStream iser = context.getResources().openRawResource(R.raw.haarcascade_lefteye_2splits);
File cascadeDirER = context.getDir("cascadeER", Context.MODE_PRIVATE);
File cascadeFileER = new File(cascadeDirER, "haarcascade_eye_right.xml");
FileOutputStream oser = new FileOutputStream(cascadeFileER);
byte[] bufferER = new byte[4096];
int bytesReadER;
while ((bytesReadER = iser.read(bufferER)) != -1) {
oser.write(bufferER, 0, bytesReadER);
iser.close();
oser.close();
//----------------------------------------------------------------------------------------------------
// --------------------------------- load right eye classificator ------------------------------------
InputStream isel = context.getResources().openRawResource(R.raw.haarcascade_lefteye_2splits);
File cascadeDirEL = context.getDir("cascadeEL", Context.MODE_PRIVATE);
File cascadeFileEL = new File(cascadeDirEL, "haarcascade_eye_left.xml");
FileOutputStream osel = new FileOutputStream(cascadeFileEL);
byte[] bufferEL = new byte[4096];
int bytesReadEL;
while ((bytesReadEL = isel.read(bufferEL)) != -1) {
osel.write(bufferEL, 0, bytesReadEL);
isel.close();
osel.close();
// ------------------------------------------------------------------------------------------------------
mJavaDetector = new CascadeClassifier(mCascadeFile.getAbsolutePath());
mCascadeER = new CascadeClassifier(cascadeFileER.getAbsolutePath());
mCascadeEL = new CascadeClassifier(cascadeFileER.getAbsolutePath());
if (mJavaDetector.empty()|| mCascadeER.empty() || mCascadeEL.empty()) {
Log.e(TAG, "Failed to load cascade classifier");
mJavaDetector = null;
mCascadeER=null;
mCascadeEL=null;
} else
Log.i(TAG, "Loaded cascade classifier from " + mCascadeFile.getAbsolutePath());
mNativeDetector = new DetectionBasedTracker(mCascadeFile.getAbsolutePath(), 0);
cascadeDir.delete();
cascadeFileER.delete();
cascadeDirER.delete();
cascadeFileEL.delete();
cascadeDirEL.delete();
} catch (IOException e) {
e.printStackTrace();
Log.e(TAG, "Failed to load cascade. Exception thrown: " + e);
Now edit the image processing:
@Override
protected Bitmap processFrame(VideoCapture capture) {
...
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());
// Prepare zoom mats
if (mZoomCorner == null || mZoomWindow == null)
CreateAuxiliaryMats();
Rect[] facesArray = faces.toArray();
// Iterate through all detected faces
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); // Draw rectangle around the face Core.rectangle(mRgba, r.tl(), r.br(), new Scalar(0,
255, 0, 255), 3);
Now we detect face, right, nothing new, its face detection sample:) What about
eyes? As face is found, it reduces our ROI (region of interest where we will finding
eyes) to face rectangle only. From face anatomy we can exclude the bottom part of
face with mouth and some top part with forehead and hair. I could be computed
relatively to the face size. See picture below original image -> detected face -> eye
area -> area splitted area for right, left eye. It saves computing power.
// compute the eye area
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));
// split it
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));
// draw the area - mGray is working grayscale mat, if you want to see area in rgb preview, change mGray to mRgba
Core.rectangle(mGray,eyearea_left.tl(),eyearea_left.br() , new Scalar(255,0, 0, 255), 2);
Core.rectangle(mGray,eyearea_right.tl(),eyearea_right.br() , new Scalar(255, 0, 0, 255), 2);
Count 5 first frames for learning get_template function get classifier, area to
detect, and desired size of new template.
if(learn_frames<5){
teplateR = get_template(mCascadeER,eyearea_right,24);
teplateL = get_template(mCascadeEL,eyearea_left,24);
learn_frames++;
}else{
// Learning finished, use the new templates for template matching
match_value = match_eye(eyearea_right,teplateR,FdActivity.method); //Or hardcode method you needs eg
TM_SQDIFF_NORMED
match_value = match_eye(eyearea_left,teplateL,FdActivity.method); //Or hardcode method you needs eg
TM_SQDIFF_NORMED
// cut eye areas and put them to zoom windows
Imgproc.resize(mRgba.submat(eyearea_left), mZoomWindow2, mZoomWindow2.size());
Imgproc.resize(mRgba.submat(eyearea_right), mZoomWindow, mZoomWindow.size());
...
Zoom method:
private void CreateAuxiliaryMats() {
if (mGray.empty())
return;
int rows = mGray.rows();
int cols = mGray.cols();
if (mZoomWindow == null){
mZoomWindow = mRgba.submat(rows / 2 + rows / 10 ,rows , cols / 2 + cols / 10, cols );
mZoomWindow2 = mRgba.submat(0, rows / 2 - rows / 10 , cols / 2 + cols / 10, cols );
Matching the template
area region of interest
mTemplate template of eye, created by get_template
type type of matching method
returns matching score of template and desired area
private double
match_eye(Rect area, Mat mTemplate,int type){
Point matchLoc;
Mat mROI = mGray.submat(area);
int result_cols =
mROI.cols() - mTemplate.cols() + 1;
int result_rows = mROI.rows() - mTemplate.rows() + 1;
//Check for bad template size
if(mTemplate.cols()==0 ||mTemplate.rows()==0){
return 0.0;
mResult = new Mat(result_cols, result_rows, CvType.CV_8U);
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);
// there is difference in matching methods - best match is max/min value
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; }
On following picture you can see all ROI areas and matching in progress yellow
rectangles.
Get template find eye in desired roi by haar classifier, if eye is found, reduce roi
to the eye only and search for the darkness point pupil. Create rectangle of desired
size, centered in pupil our new eye template.
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));
// reduce ROI
mROI = mGray.submat(eye_only_rectangle);
Mat vyrez = mRgba.submat(eye_only_rectangle);
// find the darkness point
Core.MinMaxLocResult mmG = Core.minMaxLoc(mROI);
// draw point to visualise pupil
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);
// copy area to template
template = (mGray.submat(eye_template)).clone();
return template;
return template;
Red rectangles are templates and white dots are pupils.
