BallTracker

package cobramosch.trackingserver;

import android.content.pm.ActivityInfo;
import android.hardware.Camera;
import android.os.Bundle;
import android.support.v7.app.AppCompatActivity;
import android.text.Editable;
import android.text.TextWatcher;
import android.util.Log;
import android.view.Menu;
import android.view.MenuInflater;
import android.view.SurfaceView;
import android.view.WindowManager;
import android.widget.EditText;
import android.widget.Switch;
import android.widget.TextView;

import com.appyvet.rangebar.RangeBar;

import org.opencv.android.BaseLoaderCallback;
import org.opencv.android.CameraBridgeViewBase;
import org.opencv.android.LoaderCallbackInterface;
import org.opencv.android.OpenCVLoader;
import org.opencv.core.Core;
import org.opencv.core.CvType;
import org.opencv.core.Mat;
import org.opencv.core.MatOfPoint;
import org.opencv.core.MatOfPoint2f;
import org.opencv.core.Point;
import org.opencv.core.Scalar;
import org.opencv.imgproc.Imgproc;

import java.util.ArrayList;
import java.util.List;


public class MainActivity extends AppCompatActivity implements CameraBridgeViewBase.CvCameraViewListener2 {

    /* OpenCV stuff */
    CameraBridgeViewBase mOpenCvCameraView;
    Scalar mLowerBound = new Scalar(0), mUpperBound = new Scalar(0);
    List<MatOfPoint> contours;
    Point[] points;
    Mat mRgba, mRgbaF, smHsv, mMask, mHistory;

    /* UI stuff */
    Switch hsvSwitch;
    TextView angle;
    EditText ipEditText, portEditText, fEditText;
    SyncUDPServer server;
    RangeBar hRangeBar, sRangeBar, vRangeBar;

    private float lastDistance = 0.0f;
    private float amplitude    = 10.0f;

    private BaseLoaderCallback mLoaderCallback = new BaseLoaderCallback(this){
        @Override
        public void onManagerConnected(int status) {
            switch (status) {
                case LoaderCallbackInterface.SUCCESS:
                    mOpenCvCameraView.enableView();
                    break;
                default:
                    super.onManagerConnected(status);
                    break;
            }
        }
    };

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_REVERSE_LANDSCAPE);
        getWindow().addFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON);

        mOpenCvCameraView = (CameraBridgeViewBase) findViewById(R.id.color_blob_detection_activity_surface_view);
        mOpenCvCameraView.setVisibility(SurfaceView.VISIBLE);
        mOpenCvCameraView.setCvCameraViewListener(this);
        mOpenCvCameraView.setMaxFrameSize(848, 480);

        hsvSwitch = (Switch) findViewById(R.id.maskSwitch);
        angle = (TextView) findViewById(R.id.angleTextView);

        ipEditText = (EditText) findViewById(R.id.ipEditText);
        ipEditText.setText(DataStorage.getUDPConnectionIP());

        ipEditText.addTextChangedListener(new TextWatcher() {
            @Override
            public void beforeTextChanged(CharSequence charSequence, int i, int i1, int i2) {}

            @Override
            public void onTextChanged(CharSequence charSequence, int i, int i1, int i2) {}

            @Override
            public void afterTextChanged(Editable editable) {
                DataStorage.setUDPConnectionIP(editable.toString());
            }
        });

        portEditText = (EditText) findViewById(R.id.portEditText);
        portEditText.setText(String.valueOf(DataStorage.getUDPPort()));

        portEditText.addTextChangedListener(new TextWatcher() {
            @Override
            public void beforeTextChanged(CharSequence charSequence, int i, int i1, int i2) {}

            @Override
            public void onTextChanged(CharSequence charSequence, int i, int i1, int i2) {}

            @Override
            public void afterTextChanged(Editable editable) {
                DataStorage.setUDPPort(Integer.valueOf(editable.toString()));
            }
        });

        fEditText = (EditText) findViewById(R.id.fEditText);
        fEditText.setText(String.valueOf(DataStorage.getF()));

        fEditText.addTextChangedListener(new TextWatcher() {
            @Override
            public void beforeTextChanged(CharSequence charSequence, int i, int i1, int i2) {

            }

            @Override
            public void onTextChanged(CharSequence charSequence, int i, int i1, int i2) {

            }

            @Override
            public void afterTextChanged(Editable editable) {
                DataStorage.setF(editable.toString().equals("") ? 0 : Float.valueOf(editable.toString()));
            }
        });


        hRangeBar = (RangeBar) findViewById(R.id.hRangeBar);
        hRangeBar.setOnRangeBarChangeListener(new RangeBar.OnRangeBarChangeListener() {
            @Override
            public void onRangeChangeListener(RangeBar rangeBar, int leftPinIndex,
                                              int rightPinIndex,
                                              String leftPinValue, String rightPinValue) {

                mLowerBound.val[0] = Double.valueOf(leftPinValue);
                mUpperBound.val[0] = Double.valueOf(rightPinValue);

            }
        });

        sRangeBar = (RangeBar) findViewById(R.id.sRangeBar);
        sRangeBar.setOnRangeBarChangeListener(new RangeBar.OnRangeBarChangeListener() {
            @Override
            public void onRangeChangeListener(RangeBar rangeBar, int leftPinIndex,
                                              int rightPinIndex,
                                              String leftPinValue, String rightPinValue) {

                mLowerBound.val[1] = Double.valueOf(leftPinValue);
                mUpperBound.val[1] = Double.valueOf(rightPinValue);

            }
        });

        vRangeBar = (RangeBar) findViewById(R.id.vRangeBar);
        vRangeBar.setOnRangeBarChangeListener(new RangeBar.OnRangeBarChangeListener() {
            @Override
            public void onRangeChangeListener(RangeBar rangeBar, int leftPinIndex,
                                              int rightPinIndex,
                                              String leftPinValue, String rightPinValue) {

                mLowerBound.val[2] = Double.valueOf(leftPinValue);
                mUpperBound.val[2] = Double.valueOf(rightPinValue);

            }
        });

        server = new SyncUDPServer();
        server.execute();

    }

    @Override
    public void onCameraViewStarted(int width, int height) {
        assignUpperLower();

        this.mRgba = new Mat(height, width, CvType.CV_8UC4);
        this.mRgbaF = new Mat(height, width, CvType.CV_8UC4);
        this.mHistory = new Mat();
        this.smHsv = new Mat();
        this.mMask = new Mat();

        contours = new ArrayList<>();

        Camera camera = ((MyCameraView) findViewById(R.id.color_blob_detection_activity_surface_view)).getCamera();
        if (camera != null) {
            Camera.Parameters params = camera.getParameters();
            params.setAutoWhiteBalanceLock(false);
            params.setFocusMode(Camera.Parameters.FOCUS_MODE_FIXED);
            params.setVideoStabilization(false);
            params.setFlashMode(Camera.Parameters.FLASH_MODE_ON);
            camera.setParameters(params);

            double vertAngle = params.getVerticalViewAngle();
            double horAngle = params.getHorizontalViewAngle();
            angle.setText((int)vertAngle + "::" + (int)horAngle);
        }
    }

    @Override
    public void onCameraViewStopped() {

    }

    @Override
    public Mat onCameraFrame(CameraBridgeViewBase.CvCameraViewFrame inputFrame) {
        mRgba = inputFrame.rgba();
        Imgproc.resize(mRgba, mRgbaF, mRgbaF.size(), 0, 0, 0);
        Core.flip(mRgbaF, mRgba, -1);

        if(mRgba.channels()>1)
            Imgproc.cvtColor(mRgba, smHsv, Imgproc.COLOR_RGB2HSV_FULL);
        else smHsv = mRgba;

        Core.inRange(smHsv, mLowerBound, mUpperBound, mMask);

        contours.clear();
        Imgproc.findContours(mMask.clone(), contours, mHistory, Imgproc.RETR_EXTERNAL, Imgproc.CHAIN_APPROX_SIMPLE);

        if(contours.size() > 0){
            MatOfPoint largestContour = new MatOfPoint();
            double max = 0;
            for(MatOfPoint m: contours){
                double tmp = Imgproc.contourArea(m);
                if(tmp > max) {
                    max = tmp;
                    largestContour = m;
                }
            }

            points = largestContour.toArray();

            Point center = new Point();
            float[] radius = new float[1];
            if(!largestContour.empty()) {
                Imgproc.minEnclosingCircle(new MatOfPoint2f(points), center, radius);
            }

            if(radius[0] > 10){
                Imgproc.circle(mRgba, center, (int)radius[0], new Scalar(0, 255, 255), 2);
            }

            /* Calculate the distance to the object */
            float F, P, D, W, distance;
            W = 93;
            P = radius[0];
            F = DataStorage.getF();

            distance = (W * F) / P;
            Log.d("radius", "" + radius[0]);
            Log.d("distance", "" + distance);

            server.distance = distance > (lastDistance + amplitude) || distance < (lastDistance - amplitude) ? distance : lastDistance;

            lastDistance = distance;

        }

        if(hsvSwitch.isChecked()) {

            return mMask;
        }
        else{

            return mRgba;
        }

    }

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

    @Override
    public void onDestroy(){
        super.onDestroy();
        if(mOpenCvCameraView != null){
            mOpenCvCameraView.disableView();
        }
        server.STOP_FLAG = true;
    }

    @Override
    public void onResume(){
        super.onResume();
        if(!OpenCVLoader.initDebug()){
            OpenCVLoader.initAsync(OpenCVLoader.OPENCV_VERSION_3_1_0, this, mLoaderCallback);
        }else{
            mLoaderCallback.onManagerConnected(LoaderCallbackInterface.SUCCESS);
        }
        server.STOP_FLAG = false;
    }

    private void assignUpperLower(){
        /* Get values from range bar: h-value */
        mLowerBound.val[0] = Double.valueOf(hRangeBar.getLeftPinValue());
        mUpperBound.val[0] = Double.valueOf(hRangeBar.getRightPinValue());

        /* Get values from range bar: s-value */
        mLowerBound.val[1] = Double.valueOf(sRangeBar.getLeftPinValue());
        mUpperBound.val[1] = Double.valueOf(sRangeBar.getRightPinValue());

        /* Get values from range bar: v-value */
        mLowerBound.val[2] = Double.valueOf(vRangeBar.getLeftPinValue());
        mUpperBound.val[2] = Double.valueOf(vRangeBar.getRightPinValue());


    }

    @Override
    public boolean onCreateOptionsMenu(Menu menu) {
        MenuInflater inflater = getMenuInflater();
        inflater.inflate(R.menu.menu_main, menu);
        return true;
    }
}