无法在opencv android（Java）中应用掩码

我尝试在圆或点上应用遮罩。我在嘴唇上方画了一个圆圈来涂胡子。但我无法用胡子的形象来代替它。我没有使用本机。请帮帮我。

这是我完整的图像蒙版代码，请参考。这里可能会使用黄色、绿色和棕色的遮罩框

public class MainActivity extends AppCompatActivity {

    private static final String TAG = "MainActivity";
    protected CameraBridgeViewBase cameraView;
    protected TextView tvDistance;
    private Mat mRgba;
    private Mat mHSV;

    private Mat red;
    private Mat blue;
    private Mat yellow;
    private Mat green;
    private Mat brown;
    private Mat mask;

    private MatOfPoint matOfPoint;
    private Mat pts;
    private Handler handler;

    int height;
    int width;

    int camera_height;
    int camera_width;

    ArrayList<Float> averageList;
    static int AVERAGE_FACTOR = 3;

    private MenuItem mItemPreviewFeatures;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        requestWindowFeature(Window.FEATURE_NO_TITLE);
        getWindow().setFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN, WindowManager.LayoutParams.FLAG_FULLSCREEN);
        getWindow().addFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON);
        setContentView(R.layout.activity_main);
        initView();

        averageList = new ArrayList<>();

        DisplayMetrics displaymetrics = new DisplayMetrics();
        getWindowManager().getDefaultDisplay().getMetrics(displaymetrics);
        height = displaymetrics.heightPixels;
        width = displaymetrics.widthPixels;

        handler = new Handler(Looper.getMainLooper());

        cameraView.post(new Runnable() {
            @Override
            public void run() {
                camera_height = cameraView.getHeight();
                camera_width = cameraView.getWidth();
            }
        });

        cameraView.setVisibility(SurfaceView.VISIBLE);
        cameraView.setCvCameraViewListener(new CameraBridgeViewBase.CvCameraViewListener2() {
            @Override
            public void onCameraViewStarted(int width, int height) {
                mRgba = new Mat(height, width, CvType.CV_8UC4);
                mHSV = new Mat(height, width, CvType.CV_8UC4);
                mask = new Mat(height, width, CvType.CV_8UC4);

                pts = new Mat(height, width, CvType.CV_8UC1);
                yellow = new Mat(height, width, CvType.CV_8UC1);
                green = new Mat(height, width, CvType.CV_8UC1);
                brown = new Mat(height, width, CvType.CV_8UC1);
                blue = new Mat(height, width, CvType.CV_8UC1);
                red = new Mat(height, width, CvType.CV_8UC1);
            }

            @Override
            public void onCameraViewStopped() {
                mRgba.release();
                mHSV.release();
                mask.release();
                pts.release();

                blue.release();
                yellow.release();
                green.release();
                brown.release();
                red.release();
            }

            @Override
            public Mat onCameraFrame(CameraBridgeViewBase.CvCameraViewFrame inputFrame) {
                mRgba = inputFrame.rgba();

                Imgproc.cvtColor(mRgba, mHSV, Imgproc.COLOR_BGR2HSV, 4);

                //red
                //Core.inRange(mHSV, new Scalar(234, 240, 199), new Scalar(234, 240, 104), red);
                //blue
                //Core.inRange(mHSV, new Scalar(110, 50, 50), new Scalar(130, 255, 255), blue);
                //Yellow
                Core.inRange(mHSV, new Scalar(25, 80, 80), new Scalar(36, 255, 255), yellow);
                //Green
                Core.inRange(mHSV, new Scalar(37, 80, 80), new Scalar(70, 255, 255), green);
                //Brown
                Core.inRange(mHSV, new Scalar(10, 80, 80), new Scalar(30, 200, 200), brown);

                // logical OR mask
                //Core.bitwise_or(red, blue, blue);
                //Core.bitwise_or(blue, yellow, yellow);
                Core.bitwise_or(yellow, green, green);
                Core.bitwise_or(green, brown, mask);

                //Imgproc.dilate(mask, mask, new Mat());

                // Find non zero pixels
                pts = Mat.zeros(mask.size(), mask.type());
                Core.findNonZero(mask, pts);

                // Compute bounding box
                matOfPoint = new MatOfPoint(pts);

                try {
                    if (matOfPoint.cols() > 0 && matOfPoint.rows() > 0) {
                        final Rect box = Imgproc.boundingRect(matOfPoint);
                        //Log.d(TAG, "Height : " + box.height + " :: Width : " + box.width);

                        handler.post(new Runnable() {
                            @Override
                            public void run() {

                                float focalLength = Util.getFocalLength(box.width, 1, 1);
                                float distance = Util.getDistance_2(focalLength / 3, camera_height, box.height);

                                if (averageList.size() > AVERAGE_FACTOR) {
                                    float d = 0.0f;
                                    for (int i = 0; i < AVERAGE_FACTOR; i++) {
                                        d += averageList.get(i);
                                    }
                                    tvDistance.setText(String.valueOf(String.format(Locale.ENGLISH, "%.2f", (Math.abs(d / AVERAGE_FACTOR) / 304.8)) + " ft"));
                                    averageList.clear();
                                } else {
                                    averageList.add(distance);
                                }
                            }
                        });

                        //Core.rectangle(mask, box.tl(), box.br(), new Scalar(255, 0, 0), 5);
                    }

                    Core.rectangle(mRgba, new Point(350, 350), new Point(camera_width - 350, camera_height - 350), new Scalar(255, 0, 0), 2);

                } catch (Exception e) {
                    e.printStackTrace();
                }

                return mRgba;
            }
        });
    }

    private void initView() {
        cameraView = (JavaCameraView) findViewById(R.id.cameraView);
        tvDistance = (TextView) findViewById(R.id.tvDistance);
    }

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

    @Override
    public boolean onCreateOptionsMenu(Menu menu) {
        Log.i(TAG, "called onCreateOptionsMenu");
        mItemPreviewFeatures = menu.add("Tracking");
        return true;
    }

    @Override
    public boolean onOptionsItemSelected(MenuItem item) {
        if (item == mItemPreviewFeatures) {
            Toast.makeText(this, "Selected", Toast.LENGTH_SHORT).show();
        }
        return true;
    }

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

    @Override
    protected void onResume() {
        super.onResume();
        if (OpenCVLoader.initDebug()) {
            Log.d(TAG, "OpenCV loaded");
            mLoaderCallback.onManagerConnected(LoaderCallbackInterface.SUCCESS);
        } else {
            Log.d(TAG, "OpenCV not loaded");
            OpenCVLoader.initAsync(OpenCVLoader.OPENCV_VERSION_2_4_9, this, mLoaderCallback);
        }
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        if (cameraView != null)
            cameraView.disableView();
    }
}

public类MainActivity扩展了AppCompatActivity{
私有静态最终字符串TAG=“MainActivity”；
受保护的CameraBridgeViewBase cameraView；
受保护的文本视图距离；
私人Mat mRgba；
私人Mat mHSV；
私人席红；
私人地毯蓝；
私人席黄；
私人地毯绿；
私人席布朗；
私人垫面罩；
私人马托福分公司马托福分公司；
私人Mat pts；
私人经办人；
内部高度；
整数宽度；
int摄像机高度；
int摄像机的宽度；
ArrayList平均值列表；
静态整数平均因数=3；
私人MenuItem mItemPreviewFeatures；
@凌驾
创建时受保护的void（Bundle savedInstanceState）{
super.onCreate（savedInstanceState）；
requestWindowFeature（窗口。功能\u无\u标题）；
getWindow（）.setFlags（WindowManager.LayoutParams.FLAG_全屏，WindowManager.LayoutParams.FLAG_全屏）；
getWindow（）.addFlags（WindowManager.LayoutParams.FLAG\u保持屏幕打开）；
setContentView（R.layout.activity_main）；
initView（）；
averageList=新的ArrayList（）；
DisplayMetrics DisplayMetrics=新的DisplayMetrics（）；
getWindowManager（）.getDefaultDisplay（）.getMetrics（displaymetrics）；
高度=displaymetrics.heightPixels；
宽度=displaymetrics.widthPixels；
handler=新处理程序（Looper.getMainLooper（））；
cameraView.post（新的Runnable（）{
@凌驾
公开募捐{
camera_height=cameraView.getHeight（）；
camera_width=cameraView.getWidth（）；
}
});
cameraView.setVisibility（SurfaceView.VISIBLE）；
setCvCameraViewListener（新的CameraBridgeViewBase.CvCameraViewListener2（）{
@凌驾
开始时的公共空隙（整数宽度、整数高度）{
mRgba=新垫（高度、宽度、CvType.CV_8UC4）；
mHSV=新垫（高度、宽度、CvType.CV_8UC4）；
面罩=新垫（高度、宽度、CvType.CV_8UC4）；
pts=新垫（高度、宽度、CvType.CV_8UC1）；
黄色=新垫（高度、宽度、CvType.CV_8UC1）；
绿色=新垫（高度、宽度、CvType.CV_8UC1）；
棕色=新垫（高度、宽度、CvType.CV_8UC1）；
蓝色=新垫（高度、宽度、CvType.CV_8UC1）；
红色=新垫（高度、宽度、CvType.CV_8UC1）；
}
@凌驾
CAMERAVIEWSTOPPED（）上的公共空白{
mRgba.release（）；
mHSV.release（）；
面具。释放（）；
pts.release（）；
蓝色。释放（）；
黄色。释放（）；
绿色。释放（）；
brown.release（）；
红色。释放（）；
}
@凌驾
CameraFrame上的公用Mat（CameraBridgeViewBase.CvCameraViewFrame inputFrame）{
mRgba=inputFrame.rgba（）；
Imgproc.CVT颜色（mRgba、mHSV、Imgproc.COLOR_BGR2HSV，4）；
//红色的
//在范围内（mHSV，新标量（234，240，199），新标量（234，240，104），红色）；
//蓝色的
//Core.inRange（mHSV，新标量（110,50,50），新标量（130,255,255），蓝色）；
//黄色的
Core.inRange（mHSV，新标量（25,80,80），新标量（36,255,255），黄色）；
//绿色的
在范围内（mHSV，新标量（37,80,80），新标量（70,255,255），绿色）；
//棕色的
核心。在范围内（mHSV，新标量（10，80，80），新标量（30，200，200），棕色）；
//逻辑或掩码
//核心。按位_或（红色、蓝色、蓝色）；
//核心。按位_或（蓝色、黄色、黄色）；
核心。按位_或（黄色、绿色、绿色）；
核心。按位_或（绿色、棕色、遮罩）；
//Imgproc.扩张（面罩，面罩，新垫（））；
//查找非零像素
pts=Mat.zero（mask.size（），mask.type（））；
Core.findNonZero（掩码，pts）；
//计算边界框
matOfPoint=新的matOfPoint（pts）；
试一试{
if（matOfPoint.cols（）>0&&matOfPoint.rows（）>0）{
最终矩形框=Imgproc.boundingRect（matOfPoint）；
//Log.d（标记“高度：+box.Height+”：：宽度：+box.Width）；
handler.post（新的Runnable（）{
@凌驾
公开募捐{
float focalLength=Util.getFocalLength（box.width，1,1）；
浮动距离=Util.getDistance_2（焦距长度/3，摄像机高度，框高度）；
if（averageList.size（）>平均_因子）{
浮动d=0.0f；
对于（int i=0；i