opencv4android 3.0实现三帧差分法无法正确显示结果

我想在android上实现三帧差分法，效果同电脑上那样，但是做三帧差分运算后结果无法显示出来，请问用什么方法显示运算结果。
（1）电脑上的三帧差分程序（正确）：

// 25MotionDetetion_ThreeDiff.cpp : 定义控制台应用程序的入口点。  

//三帧差分法  

  

#include <iostream>

#include <cv.h>    

#include <cxcore.h>    

#include <highgui.h>    

//CAM定义用摄像头获得视频else文件  

//#define CAM     

 int apos=30;    

void on_trackbar(int pos)    

{    

        apos=pos;     

}      

    

int main( int argc, char** argv )    

{    

    //声明IplImage指针    

    IplImage* pFrame = NULL; //原始视频帧    

    IplImage* pFrImg = NULL; //提取的前景图像，即运动目标    

    IplImage* pBkImg = NULL; //背景图像   

    IplImage* pMiImg = NULL; //中间帧图像  

    

    CvMat* pFrameMat = NULL; //原始视频矩阵   

    CvMat* pFrMat = NULL;    //前景矩阵  第一帧  

    CvMat* pBkMat = NULL;    //背景矩阵  第三帧  

    CvMat* pMiMat = NULL;    //中间帧矩阵 第二帧  

    CvMat* pRe1Mat = NULL;   //结果1  

    CvMat* pRe2Mat = NULL;   //结果2  

    CvCapture* pCapture = NULL;    

    //帧数  

    int nFrmNum = 0;    

    

    //创建窗口    

    cvNamedWindow("video", 1);    

    cvNamedWindow("background",1);    

    cvNamedWindow("foreground",1);    

    //使窗口有序排列    

    cvMoveWindow("video", 30, 0);    

    cvMoveWindow("background", 360, 0);    

    cvMoveWindow("foreground", 690, 0);   

    // 滑动条            

    int nThreshold = 30;          

    cvCreateTrackbar("阀值", "foreground", &nThreshold, 100, on_trackbar);   

     

    if( argc == 1 || (argc == 2 && strlen(argv[1]) == 1 && isdigit(argv[1][0])))

        //打开摄像头

        pCapture = cvCaptureFromCAM( argc == 2 ? argv[1][0] - '0' : 0 );

    else if( argc == 2 )

        //打开avi

        pCapture = cvCaptureFromAVI( argv[1] ); 

 

    if( !pCapture )

    //打开视频流失败

    {

        fprintf(stderr,"Could not initialize capturing...\n");

        return -1;

    }

    //逐帧读取视频    

    while(pFrame = cvQueryFrame( pCapture ))    

    {    

        nFrmNum++;    

    

        //如果是第一帧，需要申请内存，并初始化    

        if(nFrmNum == 1)    

        {    

            pBkImg = cvCreateImage(cvSize(pFrame->width, pFrame->height),  IPL_DEPTH_8U,1);    

            pFrImg = cvCreateImage(cvSize(pFrame->width, pFrame->height),  IPL_DEPTH_8U,1);    

    

            pBkMat = cvCreateMat(pFrame->height, pFrame->width, CV_32FC1);    

            pFrMat = cvCreateMat(pFrame->height, pFrame->width, CV_32FC1);    

            pFrameMat = cvCreateMat(pFrame->height, pFrame->width, CV_32FC1);    

            pMiMat = cvCreateMat(pFrame->height, pFrame->width, CV_32FC1);  

            //转化成单通道图像再处理    

            cvCvtColor(pFrame, pBkImg, CV_BGR2GRAY); //第一帧作为背景了   

            //cvCvtColor(pFrame, pFrImg, CV_BGR2GRAY); //   

            //转换成矩阵  

            cvConvert(pBkImg, pFrameMat);  //虽然没用，相当于给矩阵赋了初值  

            cvConvert(pBkImg, pFrMat);     //虽然没用，相当于给矩阵赋了初值  

            cvConvert(pBkImg, pBkMat);    

        }  

        //如果是第er帧，需要申请内存，并初始化  

        else if(nFrmNum==2)  

        {  

            pMiImg = cvCreateImage(cvSize(pFrame->width, pFrame->height),  IPL_DEPTH_8U,1);    

            pMiMat = cvCreateMat(pFrame->height, pFrame->width, CV_32FC1);  

            pRe1Mat = cvCreateMat(pFrame->height, pFrame->width, CV_32FC1);  

            pRe2Mat = cvCreateMat(pFrame->height, pFrame->width, CV_32FC1);  

            cvCvtColor(pFrame, pMiImg, CV_BGR2GRAY);  

            cvConvert(pMiImg, pMiMat);  

        }  

        else    

        {    

            cvCvtColor(pFrame, pFrImg, CV_BGR2GRAY);    

            cvConvert(pFrImg, pFrameMat);    

            //高斯滤波先，以平滑图像    

            //cvSmooth(pFrameMat, pFrameMat, CV_GAUSSIAN, 3, 0, 0);    

    

            //当前帧跟背景图相减 计算两个数组差的绝对值   

            cvAbsDiff(pMiMat, pBkMat, pRe1Mat);  

            cvAbsDiff(pFrameMat, pMiMat, pRe2Mat);    

            cvAnd(pRe1Mat,pRe2Mat,pFrMat,NULL);   

            //二值化前景图    

            cvThreshold(pFrMat, pFrImg, apos, 255.0, CV_THRESH_BINARY);    

              

            //进行形态学滤波，去掉噪音      

            //cvErode(pFrImg, pFrImg, 0, 1);    

            //cvDilate(pFrImg, pFrImg, 0, 1);    

            /*cvDilate(pFrImg, pFrImg, 0, 1); 

            cvErode(pFrImg, pFrImg, 0, 1);  */  

            //更新背景    

            //cvRunningAvg(pFrameMat, pBkMat, 0.003, 0);    

            //将背景转化为图像格式，用以显示    

            cvConvert(pBkMat, pBkImg);   

            cvCopy(pMiMat,pBkMat,NULL);  

            cvCopy(pFrameMat,pMiMat,NULL);  

            //pBkMat=pFrameMat;  

            //显示图像    

            cvShowImage("video", pFrame);    

            cvShowImage("background", pBkImg);    

            cvShowImage("foreground", pFrImg);    

    

            //如果有按键事件，则跳出循环    

            //此等待也为cvShowImage函数提供时间完成显示    

            //等待时间可以根据CPU速度调整    

            if( cvWaitKey(20) >= 0 )    

            {    

                break;    

            }    

        }    

    }    

    cvWaitKey();    

    

    //销毁窗口    

    cvDestroyWindow("video");    

    cvDestroyWindow("background");    

    cvDestroyWindow("foreground");    

    

    //释放图像和矩阵    

    cvReleaseImage(&pFrImg);    

    cvReleaseImage(&pBkImg);    

    cvReleaseImage(&pMiImg);  

  

    cvReleaseMat(&pFrameMat);    

    cvReleaseMat(&pFrMat);    

    cvReleaseMat(&pBkMat);  

    cvReleaseMat(&pMiMat);  

    

    cvReleaseCapture(&pCapture);    

    

    return 0;    

}   

（2）仿照pc上写的android上的三帧差分程序（有问题）：

package com.jack.threediff;



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.Core;

import org.opencv.core.Mat;

import org.opencv.core.Point;

import org.opencv.core.Scalar;

import org.opencv.core.Size;

import org.opencv.imgproc.Imgproc;

import org.opencv.samples.colorblobdetect.R;



import android.app.Activity;

import android.os.Bundle;

import android.view.SurfaceView;

import android.view.WindowManager;

import android.widget.SeekBar;

import android.widget.SeekBar.OnSeekBarChangeListener;



public class DetectionActivity extends Activity implements

		CvCameraViewListener2 {



	private int nFrmNum = 0;// 帧数

	private int nThreshold = 30;// 阈值

	private SeekBar thrsh;

	private Mat mRgba, mGray;

	private Mat pFstMat, pSecMat, pThrMat;// 第一帧、第二帧、第三帧

	private Mat pResMat1, pResMat2, pResAnd, out;

	private Mat outWindow;

	private Size wsize;



	private CameraBridgeViewBase mOpenCvCameraView;



	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

	public Mat onCameraFrame(CvCameraViewFrame inputFrame) {

		nFrmNum++;

		// mRgba做为背景图

		mRgba = inputFrame.rgba();



		Size sizeRgba = mRgba.size();

		int rows = (int) sizeRgba.height;

		int cols = (int) sizeRgba.width;

		int left = cols / 8;

		int top = rows / 8;



		int width = cols * 3 / 4;

		int height = rows * 3 / 4;



		Imgproc.cvtColor(mRgba, mGray, Imgproc.COLOR_BGR2GRAY);



		if (nFrmNum == 1) {

			pFstMat = mGray;

		} else if (nFrmNum == 2) {

			pSecMat = mGray;

		} else {

			pThrMat = mGray;

			// 三帧差分

			Core.subtract(pFstMat, pSecMat, pResMat1);

			Core.subtract(pSecMat, pThrMat, pResMat2);

			Core.bitwise_and(pResMat1, pResMat2, pResAnd);

			// 二值化处理

			Imgproc.threshold(pResAnd, out, nThreshold, 255.0, 0);



			// 更新背景

			pFstMat = pSecMat;

			pSecMat = pThrMat;

		}

		if (out.size().height != 0) {

			outWindow = out.submat(top, top + height, left, left + width);

			wsize = out.size();

			Imgproc.rectangle(outWindow, new Point(1, 1), new Point(

					wsize.width - 2, wsize.height - 2), new Scalar(255, 0, 0,

					255), 20);

			// 边缘检测

			Imgproc.Canny(mRgba, outWindow, 80, 90);

			Imgproc.cvtColor(outWindow, mRgba, Imgproc.COLOR_GRAY2BGRA);

		}



		return mRgba;

	}



	@Override

	public void onCameraViewStarted(int width, int height) {

		mGray = new Mat();

		pFstMat = new Mat();

		pSecMat = new Mat();

		pThrMat = new Mat();

		pResMat1 = new Mat();

		pResMat2 = new Mat();

		pResAnd = new Mat();

		out = new Mat();

	}



	@Override

	protected void onCreate(Bundle savedInstanceState) {

		super.onCreate(savedInstanceState);

		setContentView(R.layout.color_blob_detection_surface_view);



		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);



		thrsh = (SeekBar) findViewById(R.id.threshold1);

		thrsh.setOnSeekBarChangeListener(new OnSeekBarChangeListener() {



			@Override

			public void onStopTrackingTouch(SeekBar arg0) {



			}



			@Override

			public void onStartTrackingTouch(SeekBar arg0) {



			}



			@Override

			public void onProgressChanged(SeekBar arg0, int progress,

					boolean arg2) {

				nThreshold = progress;

			}

		});



	}



	public void onResume() {

		super.onResume();

		OpenCVLoader.initAsync(OpenCVLoader.OPENCV_VERSION_2_4_3, this,

				mLoaderCallback);

	};



	@Override

	public void onCameraViewStopped() {

	}



}

布局文件：

    <org.opencv.android.JavaCameraView

        android:id="@+id/color_blob_detection_activity_surface_view"

        android:layout_width="fill_parent"

        android:layout_height="500dp" >

    </org.opencv.android.JavaCameraView>



    <LinearLayout

        android:layout_width="fill_parent"

        android:layout_height="131dp"

        android:orientation="vertical" >



        <SeekBar

            android:id="@+id/threshold1"

            android:layout_width="fill_parent"

            android:layout_height="fill_parent"

            android:max="255"

            android:progress="30" />

    </LinearLayout>