在javafx中检测运动

我需要帮助检测JavaFX中的运动。仅在检测到运动时开始录制，在一段时间内未检测到运动时停止录制。 一切正常，但运动检测部分工作不好

我使用了sarxos库：

有什么建议吗？

这是javafx控制器类

public class MonitorController implements Initializable {

    private static double v;
    @FXML
    private VBox monitor;
    @FXML
    JFXButton btnStartCamera, btnStopCamera;
    @FXML
    JFXComboBox<WebCamInfo> cbCameraOptions;
    @FXML
    BorderPane bpWebCamPaneHolder;
    @FXML
    FlowPane fpBottomPane;
    @FXML
    ImageView imgWebCamCapturedImage;
    int i = 0;
    @FXML
    private JFXSlider jfxSlider;
    private BufferedImage grabbedImage, grabbedImage2;
    private boolean stopCamera = false, stopCamera2 = false;
    private Webcam selWebCam = null;
    private ObjectProperty<Image> imageProperty = new SimpleObjectProperty<Image>();
    private IMediaWriter writer, writer2;
    private String cameraListPromptText = "Choose Camera";
    private File file = null, file2 = null;
    private SimpleDateFormat dateFormat = new SimpleDateFormat("dd-MMM-yyyy hh-mm-ss aa");

    @Override
    public void initialize(URL arg0, ResourceBundle arg1) {
        fpBottomPane.setDisable(true);
        ObservableList<WebCamInfo> options = FXCollections.observableArrayList();
        int webCamCounter = 0;
        for (Webcam webcam : Webcam.getWebcams()) {
            WebCamInfo webCamInfo = new WebCamInfo();
            webCamInfo.setWebCamIndex(webCamCounter);
            webCamInfo.setWebCamName(webcam.getName());
            options.add(webCamInfo);
            webCamCounter++;
        }
        cbCameraOptions.setItems(options);
        cbCameraOptions.setPromptText(cameraListPromptText);
        cbCameraOptions.getSelectionModel().selectedItemProperty().addListener((arg01, arg11, arg2) -> {
            if (arg2 != null) {
                System.out.println("WebCam Index: " + arg2.getWebCamIndex() + ": WebCam Name:" + arg2.getWebCamName());
                initializeWebCam(arg2.getWebCamIndex());
            }
        });
    }

    protected void setImageViewSize() {

        double height = bpWebCamPaneHolder.getHeight();
        double width = bpWebCamPaneHolder.getWidth();
        imgWebCamCapturedImage.setFitHeight(height);
        imgWebCamCapturedImage.setFitWidth(width);
        imgWebCamCapturedImage.setSmooth(true);
        imgWebCamCapturedImage.setPreserveRatio(false);
    }

    private void initializeWebCam(final int webCamIndex) {

        Task<Void> webCamIntilizer = new Task<Void>() {

            @Override
            protected Void call() throws Exception {
                if (selWebCam == null) {
                    selWebCam = Webcam.getWebcams().get(webCamIndex);
                    selWebCam.open();
                } else {
                    closeCamera();
                    selWebCam = Webcam.getWebcams().get(webCamIndex);
                    selWebCam.open();
                }
                startWebCamStream();
                return null;
            }

        };

        new Thread(webCamIntilizer).start();
        fpBottomPane.setDisable(false);
        btnStartCamera.setDisable(true);
    }

    //main method that will record the videos
    private synchronized void startWebCamStream() {
        stopCamera = false;
        stopCamera2 = false;
        Date date = new Date();
        File folder = new File("VideoRecordings");

        //without motion detection video
        Task<Void> task = new Task<Void>() {
            @Override
            protected Void call() throws Exception {
                file = new File(folder,"NormalVideo("+dateFormat.format(date.getTime())+").mp4");
                writer = ToolFactory.makeWriter(file.getName());
                Dimension size = WebcamResolution.QVGA.getSize();
                writer.addVideoStream(0, 0, ICodec.ID.CODEC_ID_H264, size.width, size.height);
                long start = System.currentTimeMillis();
                try {
                    while (!stopCamera) {
                        if ((grabbedImage = selWebCam.getImage()) != null) {
                            Platform.runLater(() -> {
                                final Image mainiamge = SwingFXUtils.toFXImage(grabbedImage, null);
                                imageProperty.set(mainiamge);
                            });
                            BufferedImage image = ConverterFactory.convertToType(grabbedImage, BufferedImage.TYPE_3BYTE_BGR);
                            IConverter converter = ConverterFactory.createConverter(image, IPixelFormat.Type.YUV420P);
                            IVideoPicture frame = converter.toPicture(image, ((System.currentTimeMillis() - start) * 1000));
                            frame.setKeyFrame(true);
                            frame.setQuality(0);
                            writer.encodeVideo(0,frame);
                        }
//                        grabbedImage.flush();
                    }
                } catch (Exception e) {
                } finally {
                }
                return null;
            }
        };
        //display video and pictures
        imgWebCamCapturedImage.imageProperty().bind(imageProperty);

        //with motion detection video
        Task<Void> task1 = new Task<Void>() {
            @Override
            protected Void call() throws Exception {
                WebcamMotionDetector detector = new WebcamMotionDetector(selWebCam);
                detector.setInterval(100); 

                jfxSlider.valueProperty().addListener((observable, oldValue, newValue) -> {
                    v = (double) newValue;
                    detector.setPixelThreshold((int) v);
                    });
                detector.start();

                file2 = new File(folder,"motionDetected("+dateFormat.format(date.getTime())+").mp4");
                writer2 = ToolFactory.makeWriter(file2.getName());
                Dimension size = WebcamResolution.QVGA.getSize();
                writer2.addVideoStream(0, 0, ICodec.ID.CODEC_ID_H264, size.width, size.height);


                long start = System.currentTimeMillis();
                while (!stopCamera2) {
                    if ((grabbedImage2 = selWebCam.getImage()) != null) {
                        if(detector.isMotion()){
                            while (detector.isMotion()) {
                                BufferedImage image = ConverterFactory.convertToType(grabbedImage2, BufferedImage.TYPE_3BYTE_BGR);
                                IConverter converter = ConverterFactory.createConverter(image, IPixelFormat.Type.YUV420P);
                                IVideoPicture frame = converter.toPicture(image, ((System.currentTimeMillis() - start) * 1000));
                                frame.setKeyFrame(true);
                                frame.setQuality(0);
                                writer2.encodeVideo(0, frame);
                            }
                            grabbedImage2.flush();
//                            writer2.close();
                        }
                    }
                }
                return null;
            }
        };


        Thread th = new Thread(task);
        Thread th2 = new Thread(task1);
        th.setDaemon(true);
        th.start();
        th2.setDaemon(true);
        th2.start();

    }

    private void closeCamera() {
        if (selWebCam != null) {
            selWebCam.close();
        }
    }

    @FXML
    private void stopCamera(ActionEvent event) {
        stopCameraAndRecording();
        btnStopCamera.setDisable(true);
        btnStartCamera.setDisable(false);
    }

    @FXML
    private void startCamera(ActionEvent event) {
        if(selWebCam.close()){
        }else{
            startWebCamStream();
            btnStopCamera.setDisable(false);
            btnStartCamera.setDisable(true);
        }
    }

    class WebCamInfo {
        private String webCamName;
        private int webCamIndex;

        public String getWebCamName() {
            return webCamName;
        }

        public void setWebCamName(String webCamName) {
            this.webCamName = webCamName;
        }

        public int getWebCamIndex() {
            return webCamIndex;
        }

        public void setWebCamIndex(int webCamIndex) {
            this.webCamIndex = webCamIndex;
        }

        @Override
        public String toString() {
            return webCamName;
        }

    }

    private void stopCameraAndRecording(){
        stopCamera = true;
        stopCamera2 = true;
        if (writer2!=null && writer2.isOpen()) {
            writer2.close();
        }
        if (writer!=null && writer.isOpen()) {
            writer.close();
        }
        closeCamera();
        Webcam.shutdown();
    }

}

公共类MonitorController实现可初始化{
专用静态双v；
@FXML
专用VBox监视器；
@FXML
JFX按钮btnStartCamera，btnStopCamera；
@FXML
JFXComboBox cbCameraOptions；
@FXML
网络摄像机支架；
@FXML
流窗格和底部窗格；
@FXML
ImageView ImgWebCamCaptureDiImage；
int i=0；
@FXML
专用JFXSlider JFXSlider；
私有缓冲区图像抓取图像，抓取图像2；
私有布尔stopCamera=false，stopCamera2=false；
私人网络摄像头selWebCam=null；
private ObjectProperty imageProperty=新的SimpleObject属性（）；
私人作家，作家2；
私有字符串cameralistpromptext=“选择相机”；
私有文件File=null，file2=null；
私有SimpleDataFormat dateFormat=新SimpleDataFormat（“dd-MMM-yyy-hh-mm-ss-aa”）；
@凌驾
公共void初始化（URL arg0，ResourceBundle arg1）{
fpBottomPane.setDisable（true）；
ObservableList options=FXCollections.observableArrayList（）；
int网络摄像机计数器=0；
用于（网络摄像头网络摄像头：Webcam.getwebcam（））{
WebCamInfo WebCamInfo=新的WebCamInfo（）；
webCamInfo.setWebCamIndex（网络摄像机计数器）；
setWebCamName（webcam.getName（））；
选项。添加（网络视频）；
webCamCounter++；
}
cbCameraOptions.setItems（选项）；
CbcCameraOptions.setPrompText（CameralistPrompText）；
cbCameraOptions.getSelectionModel（）.SelectEditeProperty（）.addListener（（arg01、arg11、arg2）->{
如果（arg2！=null）{
System.out.println（“网络摄像头索引：+arg2.getWebCamIndex（）+”：网络摄像头名称：+arg2.getWebCamName（））；
初始化WebCam（arg2.getWebCamIndex（））；
}
});
}
受保护的void setImageViewSize（）{
double height=bpWebCamPaneHolder.getHeight（）；
double width=bpWebCamPaneHolder.getWidth（）；
imgWebCamCapturedImage.setFitHeight（高度）；
imgWebCamCapturedImage.setFitWidth（宽度）；
imgWebCamCapturedImage.setSmooth（真）；
imgWebCamCapturedImage.setPreserveRatio（假）；
}
私有无效初始化WebCam（最终int网络摄像机）{
任务WebCaminilizer=新任务（）{
@凌驾
受保护的Void调用（）引发异常{
如果（selWebCam==null）{
selWebCam=Webcam.getWebcams（）.get（webCamIndex）；
selvebcam.open（）；
}否则{
关闭摄像头（）；
selWebCam=Webcam.getWebcams（）.get（webCamIndex）；
selvebcam.open（）；
}
startWebCamStream（）；
返回null；
}
};
新线程（WebCaminizer.start（）；
fpBottomPane.setDisable（false）；
btnStartCamera.setDisable（true）；
}
//录制视频的主要方法
私有同步的void startWebCamStream（）{
stopCamera=假；
stopCamera2=假；
日期=新日期（）；
文件夹=新文件（“录像”）；
//无运动检测视频
任务=新任务（）{
@凌驾
受保护的Void调用（）引发异常{
file=新文件（文件夹“NormalVideo”（+dateFormat.format（date.getTime（））+”.mp4））；
writer=ToolFactory.makeWriter（file.getName（））；
维度大小=WebcamResolution.QVGA.getSize（）；
writer.addVideoStream（0,0，ICodec.ID.CODEC_ID_H264，size.width，size.height）；
长启动=System.currentTimeMillis（）；
试一试{
而（！相机）{
if（（grabbedImage=selWebCam.getImage（））！=null）{
Platform.runLater（（）->{
最终图像mainiamge=SwingFXUtils.toFXImage（grabbedImage，null）；
imageProperty.set（mainiamge）；
});
BuffereImage=ConverterFactory.convertToType（grabbedImage，BuffereImage.TYPE_3BYTE_BGR）；
IConverter converter=ConverterFactory.createConverter（image，IPixelFormat.Type.YUV420P）；
IVideoPicture frame=converter.toPicture（图像，（（System.currentTimeMillis（）-start）*1000））；
frame.setKeyFrame（true）；
帧质量（0）；
编写器。编码视频（0，帧）；
}
//grabbedImage.flush（）；
}
}捕获（例外e）{
}最后{
}
返回null；
}
};
//显示视频和图片
imgWebCamCapturedImage.imageProperty（）.bind（imageProperty）；
//与运动检测视频
任务task1=新任务（）{
@凌驾
受保护的Void调用（）引发异常{
网络摄像机检测器=新的网络摄像机检测器（selWebCam）；
检测器设置间隔（100）；
jfxSlider.valueProperty（）.addListener（（可观察、旧值、新值）->{
v=（双）新值；
检测器。设置像素阈值（（int）v）；
});
检测器。启动（）；
file2=新文件（文件夹“motionDetected”（+dateFormat.format（date.getTime（））+”）.mp4）；
writer2=ToolFactory.makeWriter（文件