Home

Photography

Silver

Computers

Contact

Barry Thomas

Java Source Code

These snippets of code are from my demo Android app for machine vision, using OpenCV v2.4.4. The snippets on this site are intended to help you see how easy it is to use many of the features of OpenCV. I assume you have installed the OpenCV v2.4.4 library and the samples which accompany it. These snippets should drop reasonably neatly into the sample apps' code from the OpenCV 2.4.4 sdk.

Feel free to use this code for any purpose. I don't guarantee it works. The code isn't written for speed or efficiency, just so it works and you can see what is going on. Feel free to improve it.

Other advice: Get a copy of "Learning OpenCV". Read it. Read it again because you probably skipped a lot of it first time through. It does get easier the more you do. Find lots of snippets of test code here. Use StackOverflow. Read Marcos Nieto's blog.

Canny Edge Detection

case VIEW_MODE_CANNY:
        	
    Imgproc.cvtColor(mRgba, mGray, Imgproc.COLOR_RGBA2GRAY);

    // doing a gaussian blur prevents getting a lot of false hits
    Imgproc.GaussianBlur(mGray, mGray, new Size(5, 5), 2, 2);
  
    iCannyLowerThreshold = 35;
    iCannyUpperThreshold = 75;
                
    Imgproc.Canny(mGray, mIntermediateMat, iCannyLowerThreshold, iCannyUpperThreshold);

    Imgproc.cvtColor(mIntermediateMat, mRgba, Imgproc.COLOR_GRAY2BGRA, 4);

    if (bDisplayTitle)
        ShowTitle ("Canny Edges", 1);

    break;

Hough Circles

case VIEW_MODE_HOUGH_CIRCLES:

    // the lower this figure the more spurious circles you get
    // 50 looks good in CANNY, but 100 is better when converting that into Hough circles
    iCannyUpperThreshold = 100;
            	
    Imgproc.HoughCircles(mGray, mIntermediateMat, Imgproc.CV_HOUGH_GRADIENT, 2.0, mGray.rows() / 8, 
                iCannyUpperThreshold, iAccumulator, iMinRadius, iMaxRadius);
                
    if (mIntermediateMat.cols() > 0)
        for (int x = 0; x < Math.min(mIntermediateMat.cols(), 10); x++) 
            {
            double vCircle[] = mIntermediateMat.get(0,x);

            if (vCircle == null)
                break;

            pt = new Point(Math.round(vCircle[0]), Math.round(vCircle[1]));
            radius = (int)Math.round(vCircle[2]);
            // draw the found circle
            Core.circle(mRgba, pt, radius, colorRed, iLineThickness);
                        
            // draw a cross on the centre of the circle
            DrawCross (mRgba, pt);
            }
                
        if (bDisplayTitle)
            ShowTitle ("Hough Circles", 1);
        	
    break;

Hough Lines

I limit the results to 50 lines, otherwise on very busy textured surfaces you can get a LOT of spurious results.

case VIEW_MODE_HOUGH_LINES:

    // the lower this figure the more spurious circles you get
    // 50 upper looks good in CANNY, but 75 is better when converting that into Hough circles
    iCannyLowerThreshold = 45;
    iCannyUpperThreshold = 75;
                
    Imgproc.Canny(mGray, mGray, iCannyLowerThreshold, iCannyUpperThreshold);

    Imgproc.HoughLinesP(mGray, lines, 1, Math.PI/180, iHoughLinesThreshold, iHoughLinesMinLineSize, iHoughLinesGap);
                
    for (int x = 0; x < Math.min(lines.cols(), 50); x++) 
        {
        double[] vec = lines.get(0, x);
                    
        if (vec == null)
            break;
                    
        double x1 = vec[0], y1 = vec[1], x2 = vec[2], y2 = vec[3];
        Point start = new Point(x1, y1);
        Point end = new Point(x2, y2);

        Core.line(mRgba, start, end, colorRed, 3);
        }
     
    if (bDisplayTitle)
        ShowTitle ("Hough Lines", 1);

    break;        

Colour Searching, with Bounding Contour

Convert to HSV, get the colours in range (here I'm looking for a nice bright yellow), erode the result a little to simplify it and reduce the resulting data set, get the contour, draw the contour (polygon).

    case VIEW_MODE_COLCONTOUR:
        	
    // Convert the image into an HSV image
        	
    Imgproc.cvtColor(mRgba, mHSVMat, Imgproc.COLOR_RGB2HSV, 3);
            
    Core.inRange(mHSVMat, new Scalar(byteColourTrackCentreHue[0] - 10, 100, 100), 
        		     new Scalar(byteColourTrackCentreHue[0] + 10, 255, 255), mHSVMat);
            
    // Here i'm only using the external contours and by
    // eroding we make the draw a teeny bit faster and the result a lot smoother
    // on the rough edges where the colour fades out of range by losing a lot
    // of the little spiky corners.

    Imgproc.erode(mHSVMat, mHSVMat, mErodeKernel);
    contours.clear();

    Imgproc.findContours(mHSVMat, contours, mContours, Imgproc.RETR_EXTERNAL, Imgproc.CHAIN_APPROX_SIMPLE);

    for (x = 0; x < contours.size(); x++) {
         	d = Imgproc.contourArea (contours.get(x));

    // get an approximation of the contour (last but one param is the min required
    // distance between the real points and the new approximation (in pixels)
    		
    // contours is a List
    // so contours.get(x) is a single MatOfPoint
    // but to use approxPolyDP we need to pass a MatOfPoint2f
    // so we need to do a conversion 
    		
    contours.get(x).convertTo(mMOP2f1, CvType.CV_32FC2);
        		
    if (d > iContourAreaMin) {

        Imgproc.approxPolyDP(mMOP2f1, mMOP2f2, 2, true);
                    
        // convert back to MatOfPoint and put it back in the list
        mMOP2f2.convertTo(contours.get(x), CvType.CV_32S);
            		
        // draw the contour itself
        Imgproc.drawContours(mRgba, contours, x, colorRed, iLineThickness);
        }
    }

    if (bDisplayTitle)
       	ShowTitle ("In-range + Contours", 1);

    break;

Colour Searching, with Quadrilateral

As above, except we simplify the boundary of the contour by allowing a much bigger gap between the actual edge of the block of colour and the bounding contour (15 pixels). If after that the resulting polygon has four corners we know we have a quadrilateral. In addition to drawing the contour, we draw in the diagonals of the quad.

case VIEW_MODE_YELLOW_QUAD_DETECT:

    // Convert the image into an HSV image

    Imgproc.cvtColor(mRgba, mHSVMat, Imgproc.COLOR_RGB2HSV, 3);
            
    Core.inRange(mHSVMat, new Scalar(byteColourTrackCentreHue[0] - 12, 100, 100), 
        		     new Scalar(byteColourTrackCentreHue[0] + 12, 255, 255), mHSVMat);

    contours.clear();
            
    Imgproc.findContours(mHSVMat, contours, mContours, Imgproc.RETR_EXTERNAL, Imgproc.CHAIN_APPROX_SIMPLE);
            
    for (x = 0; x < contours.size(); x++) {
        d = Imgproc.contourArea (contours.get(x));

        if (d > iContourAreaMin) {
            // get an approximation of the contour (last but one param is the min required
            // distance between the real points and the new approximation (in pixels)
            		
            contours.get(x).convertTo(mMOP2f1, CvType.CV_32FC2);
            		
            Imgproc.approxPolyDP(mMOP2f1, mMOP2f2, 15, true);
                    
            // convert back to MatOfPoint and put it back in the list
            mMOP2f2.convertTo(contours.get(x), CvType.CV_32S);
            		
            if (contours.get(x).rows() == 4) {
                        
            Converters.Mat_to_vector_Point2f(contours.get(x), pts);
            			
            Imgproc.drawContours(mRgba, contours, x, colorRed, iLineThickness);

            Core.line(mRgba, pts.get(0), pts.get(2), colorRed, iLineThickness);
            Core.line(mRgba, pts.get(1), pts.get(3), colorRed, iLineThickness);
            }
        }
    }

    if (bDisplayTitle)
        ShowTitle ("Colour quadrilateral", 1);

    break;

Face Detection

This section uses some code from the OpenCV sample "face-detection" and uses the LBP cascade file

try {
    // DO FACE CASCADE SETUP
                    	
    Context context = getApplicationContext();
    InputStream is3 = context.getResources().openRawResource(R.raw.lbpcascade_frontalface);
    File cascadeDir = context.getDir("cascade", Context.MODE_PRIVATE);
    File cascadeFile = new File(cascadeDir, "lbpcascade_frontalface.xml");

    FileOutputStream os = new FileOutputStream(cascadeFile);

    byte[] buffer = new byte[4096];
    int bytesRead;
                    
    while ((bytesRead = is3.read(buffer)) != -1) {
        os.write(buffer, 0, bytesRead);
        }
                    
    is3.close();
    os.close();

    mCascade = new CascadeClassifier(cascadeFile.getAbsolutePath());
                                    
    if (mCascade.empty()) {
        Log.d("OpenCV", "Failed to load cascade classifier");
        mCascade = null;
        }  

    cascadeFile.delete();
    cascadeDir.delete();

    } 
catch (IOException e) {
    e.printStackTrace();
    Log.d("OpenCV", "Failed to load cascade. Exception thrown: " + e);
    }

I first draw a rectangle around each face, and check to see if the current face is larger than the rest so far. I then copy the largest face to the top left of the screen. This just shows how, having found a face, you can take just that part of the image and do something else with it.

case VIEW_MODE_FACEDETECT:

    // Convert the image into a gray image

    Imgproc.cvtColor(mRgba, mGray, Imgproc.COLOR_RGBA2GRAY);
            
    if (mCascade != null) {
        int height = mGray.rows();
        int faceSize = Math.round(height * 0.2f);
                
        mCascade.detectMultiScale(mGray, faces, 1.1, 2, 2, new Size(faceSize, faceSize), new Size());

        for (Rect r : faces.toArray()) {
                    
            // draw the rectangle itself
            Core.rectangle(mRgba, r.tl(), r.br(), colorRed, 3);
            if (iMaxFaceHeight < r.height) {
                iMaxFaceHeight = r.height;
                iMaxFaceHeightIndex++;
                }
            }

        if (iMaxFaceHeight > 0) {
            // we have at least one face
            Rect[] facesArray = faces.toArray();
                    
            rect = facesArray[iMaxFaceHeightIndex];

            // get the submat of the rect containing the face
            mROIMat = mRgba.submat(rect);
            // resize it to the dest rect size (100x100)
            Imgproc.resize(mROIMat, mFaceResized, sSize);
            // copy it to dest rect in main image
                    
            mFaceResized.copyTo(mFaceDest);
            mROIMat.release();
            }
        }
    }

if (bDisplayTitle)
    ShowTitle ("Face Detection", 1);
            
break;

Good Features to Track

This is the first stage of the process of tracking objects - first find good (ie strong) features to track and then track existing objects through subsequent frames.

case VIEW_MODE_GFTT:
    // DON'T do a gaussian blur here, it makes the results poorer and
    // takes 0.5 off the fps rate
    // Imgproc.GaussianBlur(mGray, mGray, new Size(5, 5), 2, 2);

    Imgproc.goodFeaturesToTrack(mGray, MOPcorners, 50, 0.01, 30);
            
    y = MOPcorners.rows();
        	
    corners = MOPcorners.toList();
        	
    for (int x = 0; x < y; x++) 
        // Core.circle(mRgba, corners.get(x), 8, colorRed, iLineThickness - 1);
        DrawCross (mRgba, corners.get(x));

    if (bDisplayTitle)
        ShowTitle ("Track Features", 1);
        	
    break;

Optical Flow

Compares "good features to track" from one frame to the next. Currently limited to 40 features or fewer (poor quality features are ignored). Read more here.

case VIEW_MODE_OPFLOW:

    if (mMOP2fptsPrev.rows() == 0) {
        // first time through the loop so we need prev and this mats
        // plus prev points
        // get this mat
        Imgproc.cvtColor(mRgba, matOpFlowThis, Imgproc.COLOR_RGBA2GRAY);

        // copy that to prev mat
        matOpFlowThis.copyTo(matOpFlowPrev);
        		
        // get prev corners
        Imgproc.goodFeaturesToTrack(matOpFlowPrev, MOPcorners, iGFFTMax, 0.01, 20);
        mMOP2fptsPrev.fromArray(MOPcorners.toArray());
        		
        // get safe copy of this corners
        mMOP2fptsPrev.copyTo(mMOP2fptsSafe);
        }
    else
        {
        // we've been through before so
        // this mat is valid. Copy it to prev mat
        matOpFlowThis.copyTo(matOpFlowPrev);

        // get this mat
        Imgproc.cvtColor(mRgba, matOpFlowThis, Imgproc.COLOR_RGBA2GRAY);
        		
        // get the corners for this mat
        Imgproc.goodFeaturesToTrack(matOpFlowThis, MOPcorners, iGFFTMax, 0.01, 20);
        mMOP2fptsThis.fromArray(MOPcorners.toArray());
        		
        // retrieve the corners from the prev mat
        // (saves calculating them again)
        mMOP2fptsSafe.copyTo(mMOP2fptsPrev);
        		
        // and save this corners for next time through
        		
        mMOP2fptsThis.copyTo(mMOP2fptsSafe);
        }
        	
    Video.calcOpticalFlowPyrLK(matOpFlowPrev, matOpFlowThis, mMOP2fptsPrev, mMOP2fptsThis, mMOBStatus, mMOFerr);

    cornersPrev = mMOP2fptsPrev.toList();
    cornersThis = mMOP2fptsThis.toList();
    byteStatus = mMOBStatus.toList();
            
    for (x = 0; x < byteStatus.size() - 1; x++) {
        if (byteStatus.get(x) == 1) {
        pt = cornersThis.get(x);
        pt2 = cornersPrev.get(x);
                    
        Core.circle(mRgba, pt, 5, colorRed, iLineThickness - 1);
        Core.line(mRgba, pt, pt2, colorRed, iLineThickness);
        }
    }
            
            if (bDisplayTitle)
            	ShowTitle ("Optical Flow", 1, colorGreen);

            break;