OpenCv Android Optic Flow

package com.mukcay.cvtest;

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.List;
import java.util.PriorityQueue;

import org.opencv.android.BaseLoaderCallback;
import org.opencv.android.CameraBridgeViewBase;
import org.opencv.android.CameraBridgeViewBase.CvCameraViewFrame;
import org.opencv.android.CameraBridgeViewBase.CvCameraViewListener2;
import org.opencv.android.LoaderCallbackInterface;
import org.opencv.android.OpenCVLoader;
import org.opencv.core.CvType;
import org.opencv.core.Mat;
import org.opencv.core.MatOfByte;
import org.opencv.core.MatOfFloat;
import org.opencv.core.MatOfPoint;
import org.opencv.core.MatOfPoint2f;
import org.opencv.core.Point;
import org.opencv.core.Size;
import org.opencv.imgproc.Imgproc;
import org.opencv.objdetect.CascadeClassifier;
import org.opencv.video.Video;

import android.app.Activity;
import android.content.Context;
import android.os.Bundle;
import android.util.Log;
import android.view.SurfaceView;
import android.view.WindowManager;

public class MainActivity extends Activity implements CvCameraViewListener2 {

    private String TAG = "MUKCAY";
    private CameraBridgeViewBase mOpenCvCameraView;
    private CascadeClassifier mCascade;
    private PriorityQueue<Direction> pq;

    private List<Byte> byteStatus;
    private List<Point> cornersThis;
    private List<Point> cornersPrev;

    private MatOfPoint2f mMOP2fptsPrev;
    private MatOfPoint2f mMOP2fptsThis;
    private MatOfPoint2f mMOP2fptsSafe;

    private MatOfPoint MOPcorners;

    private MatOfFloat mMOFerr;

    private MatOfByte mMOBStatus;

    private Mat mRgba;
    private Mat matOpFlowPrev;
    private Mat matOpFlowThis;

    private Point pt0;
    private Point pt1;
    private Point pt2;

    private Size sMatSize;
    private String string;

    private Direction up = new Direction("up",0);
    private Direction down = new Direction("down",0);
    private Direction left = new Direction("left",0);
    private Direction right = new Direction("right",0);
    private Direction r1;
    private Direction r2;
    private Direction r3;

    private int iGFFTMax = 40;
    private int x;
    private int y;
    private double NOISE = 3;

    private BaseLoaderCallback mLoaderCallback = new BaseLoaderCallback(this) {
        @Override
        public void onManagerConnected(int status) {
            switch (status) {
            case LoaderCallbackInterface.SUCCESS: {
                Log.i(TAG, "OpenCV loaded successfully");
                mOpenCvCameraView.enableView();

                try {
                    Context context = getApplicationContext();
                    InputStream is = context.getResources().openRawResource(
                            R.raw.haarcascade_frontalface_default);
                    File cascadeDir = context.getDir("cascade",
                            Context.MODE_PRIVATE);
                    File cascadeFile = new File(cascadeDir,
                            "haarcascade_frontalface_default.xml");
                    FileOutputStream os = new FileOutputStream(cascadeFile);
                    byte[] buffer = new byte[4096];
                    int bytesRead;

                    while ((bytesRead = is.read(buffer)) != -1) {
                        os.write(buffer, 0, bytesRead);
                    }

                    is.close();
                    os.close();
                    mCascade = new CascadeClassifier(
                            cascadeFile.getAbsolutePath());

                    if (mCascade.empty()) {
                        mCascade = null;
                    }

                    cascadeFile.delete();
                    cascadeDir.delete();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
                break;

            default: {
                super.onManagerConnected(status);
            }
                break;
            }
        }
    };

    @Override
    public void onResume() {
        super.onResume();
        OpenCVLoader.initAsync(OpenCVLoader.OPENCV_VERSION_2_4_9, this,
                mLoaderCallback);
    }

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        Log.i(TAG, "called onCreate");
        super.onCreate(savedInstanceState);
        pq = new PriorityQueue<Direction>();
        getWindow().addFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON);
        setContentView(R.layout.activity_main);
        mOpenCvCameraView = (CameraBridgeViewBase) findViewById(R.id.CVTest);
        mOpenCvCameraView.setVisibility(SurfaceView.VISIBLE);
        mOpenCvCameraView.setCvCameraViewListener(this);

        //OpenCVLoader.initAsync(OpenCVLoader.OPENCV_VERSION_2_4_9, this, mLoaderCallback);
    }

    @Override
    public void onPause() {
        super.onPause();
        if (mOpenCvCameraView != null) {
            mOpenCvCameraView.disableView();
        }
    }

    public void onDestroy() {
        super.onDestroy();
        if (mOpenCvCameraView != null)
            mOpenCvCameraView.disableView();
    }

    public void onCameraViewStarted(int width, int height) {
        byteStatus = new ArrayList<Byte>();
        cornersThis = new ArrayList<Point>();
        cornersPrev = new ArrayList<Point>();
        mMOP2fptsPrev = new MatOfPoint2f();
        mMOP2fptsThis = new MatOfPoint2f();
        mMOP2fptsSafe = new MatOfPoint2f();
        mMOFerr = new MatOfFloat();
        mMOBStatus = new MatOfByte();
        MOPcorners = new MatOfPoint();
        mRgba = new Mat();
        matOpFlowThis = new Mat();
        matOpFlowPrev = new Mat();
        pt0 = new Point(0, 0);
        pt1 = new Point(0, 0);
        pt2 = new Point(0, 0);
        sMatSize = new Size();
        string = "";
        mRgba = new Mat(height, width, CvType.CV_8UC4);
    }

    public void onCameraViewStopped() {
    }

    public Mat onCameraFrame(CvCameraViewFrame inputFrame) {
        up.value = 0;
        down.value = 0;
        left.value = 0;
        right.value = 0;
        pq.clear();
        mRgba = inputFrame.rgba();
        //inputFrame.copyTo(mRgba);
        sMatSize.width = mRgba.width();
        sMatSize.height = mRgba.height();

        if (mMOP2fptsPrev.rows() == 0) {
            Imgproc.cvtColor(mRgba, matOpFlowThis, Imgproc.COLOR_RGBA2GRAY);
            matOpFlowThis.copyTo(matOpFlowPrev);
            Imgproc.goodFeaturesToTrack(matOpFlowPrev, MOPcorners, iGFFTMax, 0.05, 20);
            mMOP2fptsPrev.fromArray(MOPcorners.toArray());
            mMOP2fptsPrev.copyTo(mMOP2fptsSafe);
        } else {
            matOpFlowThis.copyTo(matOpFlowPrev);
            Imgproc.cvtColor(mRgba, matOpFlowThis, Imgproc.COLOR_RGBA2GRAY);
            Imgproc.goodFeaturesToTrack(matOpFlowThis, MOPcorners, iGFFTMax, 0.05, 20);
            mMOP2fptsThis.fromArray(MOPcorners.toArray());
            mMOP2fptsSafe.copyTo(mMOP2fptsPrev);
            mMOP2fptsThis.copyTo(mMOP2fptsSafe);
        }

        Video.calcOpticalFlowPyrLK(matOpFlowPrev, matOpFlowThis, mMOP2fptsPrev, mMOP2fptsThis, mMOBStatus, mMOFerr);

        cornersPrev = mMOP2fptsPrev.toList();
        cornersThis = mMOP2fptsThis.toList();
        byteStatus = mMOBStatus.toList();

        y = byteStatus.size() - 1;

        for (x = 0; x < y; x++) {
            if (byteStatus.get(x) == 1) {
                pt0 = cornersThis.get(x);
                pt2 = cornersPrev.get(x);
                double m = Math.abs(pt2.y - pt0.y ) / Math.abs(pt2.x - pt0.x);
                double distance= Math.sqrt(Math.pow((pt0.x - pt2.x),2) + Math.pow((pt0.y - pt2.y),2));

                if(distance < NOISE)
                    continue;

                if (pt0.x < pt2.x && pt2.y < pt0.y)
                    if (m > 1)
                        up.value++;
                    else
                        right.value++;
                else if (pt0.x < pt2.x && pt2.y == pt0.y)
                    right.value++;
                else if (pt0.x < pt2.x && pt2.y > pt0.y)
                    if (m > 1)
                        down.value++;
                    else
                        right.value++;
                else if (pt0.x == pt2.x && pt2.y > pt0.y)
                    down.value++;
                else if (pt0.x > pt2.x && pt2.y > pt0.y)
                    if (m > 1)
                        down.value++;
                    else
                        left.value++;
                else if (pt0.x > pt2.x && pt2.y == pt0.y)
                    left.value++;
                else if (pt0.x > pt2.x && pt2.y < pt0.y)
                    if (m > 1)
                        up.value++;
                    else
                        left.value++;
                else if (pt0.x == pt2.x && pt2.y < pt0.y)
                    up.value++;
            }
        }//end of for


        if(up.value == 0 && left.value == 0 && right.value == 0 && down.value == 0) {
            string = String.format("Direction: ---");

//          runOnUiThread(new Runnable() {
//              @Override
//              public void run() {
//                  updateDirection(string);
//              }
//          });

        }else{
            if (left.value < right.value) {
                r1 = right;
            } else r1 = left;

            if (up.value < down.value) {
                r2 = down;
            } else r2 = up;

            if (r1.value < r2.value) {
                r3 = r2;
            } else r3 = r1;

            string = String.format("Direction: %s", r3.name);

//          runOnUiThread(new Runnable() {
//              @Override
//              public void run() {
//                  updateDirection(string);
//              }
//          });
        }

        return mRgba;
    }
}