使用OpenCV從IP攝像機流式傳輸

Question

我正在使用OpenCV處理相機圖像，但是，此刻，我正在使用連接到計算機的USB網絡攝像頭。 我想知道是否可以更改當前代碼以從IP地址流式傳輸視頻。

startCamera方法打開相機。

碼：

public class ObjRecognitionController {
// FXML camera button
@FXML
private Button cameraButton;
// the FXML area for showing the current frame
@FXML
private ImageView originalFrame;
// the FXML area for showing the mask
@FXML
private ImageView maskImage;
// the FXML area for showing the output of the morphological operations
@FXML
private ImageView morphImage;
// FXML slider for setting HSV ranges
@FXML
private Slider hueStart;
@FXML
private Slider hueStop;
@FXML
private Slider saturationStart;
@FXML
private Slider saturationStop;
@FXML
private Slider valueStart;
@FXML
private Slider valueStop;
// FXML label to show the current values set with the sliders
@FXML
private Label hsvCurrentValues;

// a timer for acquiring the video stream
private ScheduledExecutorService timer;
// the OpenCV object that performs the video capture
private VideoCapture capture = new VideoCapture();
// a flag to change the button behavior
private boolean cameraActive;

// property for object binding
private ObjectProperty<String> hsvValuesProp;

/**
 * The action triggered by pushing the button on the GUI
 */
@FXML
private void startCamera()
{
    // bind a text property with the string containing the current range of
    // HSV values for object detection
    hsvValuesProp = new SimpleObjectProperty<>();
    this.hsvCurrentValues.textProperty().bind(hsvValuesProp);

    // set a fixed width for all the image to show and preserve image ratio
    this.imageViewProperties(this.originalFrame, 400);
    this.imageViewProperties(this.maskImage, 200);
    this.imageViewProperties(this.morphImage, 200);

    if (!this.cameraActive) {
        // start the video capture
        this.capture.open(0);

        // is the video stream available?
        if (this.capture.isOpened()) {
            this.cameraActive = true;

            // grab a frame every 33 ms (30 frames/sec)
            Runnable frameGrabber = new Runnable() {

                @Override
                public void run() {
                    Image imageToShow = grabFrame();
                    originalFrame.setImage(imageToShow);
                }
            };

            this.timer = Executors.newSingleThreadScheduledExecutor();
            this.timer.scheduleAtFixedRate(frameGrabber, 0, 33, TimeUnit.MILLISECONDS);

            // update the button content
            this.cameraButton.setText("Stop Camera");
        } else {
            // log the error
            System.err.println("Failed to open the camera connection...");
        }
    } else {
        // the camera is not active at this point
        this.cameraActive = false;
        // update again the button content
        this.cameraButton.setText("Start Camera");

        // stop the timer
        try {
            this.timer.shutdown();
            this.timer.awaitTermination(33, TimeUnit.MILLISECONDS);
        } catch (InterruptedException e) {
            // log the exception
            System.err.println("Exception in stopping the frame capture, trying to release the camera now... " + e);
        }

        // release the camera
        this.capture.release();
    }
}

/**
 * Get a frame from the opened video stream (if any)
 * 
 * @return the {@link Image} to show
 */
private Image grabFrame()
{
    // init everything
    Image imageToShow = null;
    Mat frame = new Mat();

    // check if the capture is open
    if (this.capture.isOpened())
    {
        try
        {
            // read the current frame
            this.capture.read(frame);

            // if the frame is not empty, process it
            if (!frame.empty())
            {
                // init
                Mat blurredImage = new Mat();
                Mat hsvImage = new Mat();
                Mat mask = new Mat();
                Mat morphOutput = new Mat();

                // remove some noise
                Imgproc.blur(frame, blurredImage, new Size(7, 7));

                // convert the frame to HSV
                Imgproc.cvtColor(blurredImage, hsvImage, Imgproc.COLOR_BGR2HSV);

                // get thresholding values from the UI
                // remember: H ranges 0-180, S and V range 0-255
                Scalar minValues = new Scalar(this.hueStart.getValue(), this.saturationStart.getValue(),
                        this.valueStart.getValue());
                Scalar maxValues = new Scalar(this.hueStop.getValue(), this.saturationStop.getValue(),
                        this.valueStop.getValue());

                // show the current selected HSV range
                String valuesToPrint = "Hue range: " + minValues.val[0] + "-" + maxValues.val[0]
                        + "\tSaturation range: " + minValues.val[1] + "-" + maxValues.val[1] + "\tValue range: "
                        + minValues.val[2] + "-" + maxValues.val[2];
                this.onFXThread(this.hsvValuesProp, valuesToPrint);

                // threshold HSV image to select tennis balls
                Core.inRange(hsvImage, minValues, maxValues, mask);
                // show the partial output
                this.onFXThread(this.maskImage.imageProperty(), this.mat2Image(mask));

                // morphological operators
                // dilate with large element, erode with small ones
                Mat dilateElement = Imgproc.getStructuringElement(Imgproc.MORPH_RECT, new Size(24, 24));
                Mat erodeElement = Imgproc.getStructuringElement(Imgproc.MORPH_RECT, new Size(12, 12));

                Imgproc.erode(mask, morphOutput, erodeElement);
                Imgproc.erode(mask, morphOutput, erodeElement);

                Imgproc.dilate(mask, morphOutput, dilateElement);
                Imgproc.dilate(mask, morphOutput, dilateElement);

                // show the partial output
                this.onFXThread(this.morphImage.imageProperty(), this.mat2Image(morphOutput));

                // find the tennis ball(s) contours and show them
                frame = this.findAndDrawBalls(morphOutput, frame);

                // convert the Mat object (OpenCV) to Image (JavaFX)
                imageToShow = mat2Image(frame);
            }

        }
        catch (Exception e)
        {
            // log the (full) error
            System.err.print("ERROR");
            e.printStackTrace();
        }
    }

    return imageToShow;
}

/**
 * Given a binary image containing one or more closed surfaces, use it as a
 * mask to find and highlight the objects contours
 * 
 * @param maskedImage
 *            the binary image to be used as a mask
 * @param frame
 *            the original {@link Mat} image to be used for drawing the
 *            objects contours
 * @return the {@link Mat} image with the objects contours framed
 */
private Mat findAndDrawBalls(Mat maskedImage, Mat frame) {
    // init
    List<MatOfPoint> contours = new ArrayList<>();
    Mat hierarchy = new Mat();
    // find contours
    Imgproc.findContours(maskedImage, contours, hierarchy, Imgproc.RETR_CCOMP, Imgproc.CHAIN_APPROX_SIMPLE);

    // if any contour exist...
    if (hierarchy.size().height > 0 && hierarchy.size().width > 0) {
        // for each contour, display it in yellow
        for (int idx = 0; idx >= 0; idx = (int) hierarchy.get(0, idx)[0]) {
            Imgproc.drawContours(frame, contours, idx, new Scalar(0, 255, 255),2);

            Rect rect = Imgproc.boundingRect(contours.get(idx));

            if(rect.x < 25){
                System.out.println("Turn left " + rect.x);
            }else if(rect.x > 600){
                System.out.println("Turn Right: " + rect.x);
            }
            System.out.println();
        }
    }

    return frame;
}

/**
 * Set typical {@link ImageView} properties: a fixed width and the
 * information to preserve the original image ration
 * 
 * @param image
 *            the {@link ImageView} to use
 * @param dimension
 *            the width of the image to set
 */
private void imageViewProperties(ImageView image, int dimension) {
    // set a fixed width for the given ImageView
    image.setFitWidth(dimension);
    // preserve the image ratio
    image.setPreserveRatio(true);
}

/**
 * Convert a {@link Mat} object (OpenCV) in the corresponding {@link Image}
 * for JavaFX
 * 
 * @param frame
 *            the {@link Mat} representing the current frame
 * @return the {@link Image} to show
 */
private Image mat2Image(Mat frame) {
    // create a temporary buffer
    MatOfByte buffer = new MatOfByte();
    // encode the frame in the buffer, according to the PNG format
    Imgcodecs.imencode(".png", frame, buffer);
    // build and return an Image created from the image encoded in the
    // buffer
    return new Image(new ByteArrayInputStream(buffer.toArray()));
}

/**
 * Generic method for putting element running on a non-JavaFX thread on the
 * JavaFX thread, to properly update the UI
 * 
 * @param property
 *            a {@link ObjectProperty}
 * @param value
 *            the value to set for the given {@link ObjectProperty}
 */
private <T> void onFXThread(final ObjectProperty<T> property, final T value)
{
    Platform.runLater(new Runnable() {

        @Override
        public void run()
        {
            property.set(value);
        }
    });
}

}

相機說明文件

VLC Media Player VLC Media Player是一個跨平台的視頻播放器，流服務器和轉換器解決方案，位於一個軟件包中。 在這里獲取。

對於使用IP網絡攝像頭使用VLC媒體播放器，在菜單上選擇媒體⇨打開網絡流和輸入http://192.168.1.8:8080/video為視頻流或http://192.168.1.8:8080/audio.wav流媒體音頻。

您也可以使用VLC Media Player進行視頻錄制：

選擇媒體->轉換/保存。 選擇“網絡”選項卡輸入http://192.168.1.8:8080/video作為URL單擊“轉換/保存”。選擇目標文件，選擇要保存的格式， 最好使用ZoneMinder使用以下配置：

常規：信號源類型：遠程功能：監控器

源：協議：HTTP方法：簡單主機名：192.168.1.8端口：8080遠程主機路徑：/ video（僅“ video”不起作用）。

注意：如有必要，請在URL的密碼中指定用戶名，例如：username：password@192.168.1.8。

藍色虹膜照常打開“添加相機”對話框

使用IP網絡攝像頭時，必須從列表中選擇“ MJPEG流”，而不是特定的攝像機。

視頻路徑：/ video音頻路徑：/audio.wav主機名：192.168.1.8端口：8080在“ RTSP /視頻端口”框中輸入任何內容都沒有關系。

webcamXP在webcamXP主界面中，右鍵單擊視頻源，然后選擇網絡攝像機⇨連接...

將“攝像機品牌”設置為Android，將“攝像機型號”設置為IP Webcam。 選擇所需的預設（建議使用MJPEG）。 點擊下一步。

將主機名設置為192.168.1.8並將端口設置為8080。

單擊確定，您就可以使用新相機了！

高級這是IP網絡攝像頭服務URL的列表：

http://192.168.1.8:8080/video是MJPEG URL。 http://192.168.1.8:8080/shot.jpg獲取最新的幀。 http://192.168.1.8:8080/audio.wav是Wav格式的音頻流。 http://192.168.1.8:8080/audio.aac是AAC格式的音頻流（如果硬件支持）。 http://192.168.1.8:8080/audio.opus是Opus格式的音頻流。 http://192.168.1.8:8080/focus聚焦相機。 http://192.168.1.8:8080/nofocus釋放焦點。

Answer 1

您可以修改

VideoCapture camera = new VideoCapture("IPADDRESS");

要么

capture.open("IPADRESS");

Answer 2

您必須從攝像機的流網址捕獲視頻，例如

VideoCapture capture = new VideoCapture(url);

網址可以是

url = "http://IPADDRESS:PORT/?dummy=param.mjpg"
//or
url= "http://IPADDRESS:PORT/mjpeg.cgi";
//or
url = "http://IPADDRESS:PORT/mjpg/mjpeg.cgi";
//or
url ="http://IPADDRESS:PORT/video.mjpeg";

嘗試使用瀏覽器確認正確的值，希望對您有所幫助。

另外 ，如果您使用的是Android設備，則不要在OpenCV中使用IP網絡攝像頭應用程序，更好的選擇是使用droidcam應用程序和PC軟件來識別網絡攝像頭，例如

VideoCapture capture = new VideoCapture(camIndex);