Diffusion en continu à partir d'une caméra IP utilisant OpenCV

Question

J'utilise OpenCV pour traiter une image de caméra, cependant, au moment où j'utilise une webcam USB connectée à mon ordinateur. Je me demandais s'il est possible d'apporter des modifications à mon code actuel pour diffuser une vidéo à partir d'une adresse IP.

startCamera La méthode ouvre la caméra.

code:

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

}

Documentation Caméra

VLC Media Player VLC Media Player est un lecteur vidéo multi-plateforme, serveur de streaming et d'une solution convertisseur dans un paquet unique. Obtenez-le ici. Pour utiliser IP Webcam avec le lecteur multimédia VLC, sélectionnez Media ⇨ Open Network Stream dans le menu et entrez http://192.168.1.8:8080/video pour le streaming vidéo ou http://192.168.1.8:8080/audio.wav pour le streaming audio.

Vous pouvez également utiliser le lecteur VLC Media pour l'enregistrement vidéo:

Select Media -> Convertir/Enregistrer. Sélectionnez l'onglet Réseau Entrez http://192.168.1.8:8080/video comme URL Cliquez convert/enregistrer Sélectionnez le fichier de destination, format dans lequel vous voulez enregistrer et vous êtes bon pour aller zoneminder Utilisez cette configuration:

général: Source Type: télécommande Fonction: Moniteur

Source: Protocole: HTTP Méthode: simple nom d'hôte: 192.168.1.8 Port: 8080 Chemin de l'hôte distant:/vidéo (juste "vidéo" ne fonctionne pas).

Remarque: Si nécessaire, spécifiez votre nom d'utilisateur dans mot de passe dans URL, comme ceci: nom d'utilisateur: password@192.168.1.8.

Blue Iris Ouvrir « Ajouter la caméra » dialogue comme d'habitude

Lorsque vous utilisez IP Webcam, vous devez choisir « MJPEG Stream » dans la liste à la place d'une caméra spécifique.

chemin de la vidéo:/vidéo chemin Audio: /audio.wav Nom d'hôte: 192.168.1.8 Port: 8080 Peu importe ce que vous entrez dans la boîte "port RTSP/vidéo".

webcamXP Dans l'interface principale webcamXP, faites un clic droit sur la source vidéo et sélectionnez Se connecter ...

Set Marque Appareil photo pour Android et modèle de caméra de caméras réseau IP Webcam. Sélectionnez le préréglage souhaité (MJPEG recommandé). Cliquez sur Suivant.

Définissez le nom d'hôte sur 192.168.1.8 et le port sur 8080.

Cliquez sur OK, et vous êtes prêt à utiliser votre nouvel appareil photo!

avancée Voici la liste des URL de service Webcam IP:

http://192.168.1.8:8080/video est l'URL MJPEG. http://192.168.1.8:8080/shot.jpg récupère la dernière image. http://192.168.1.8:8080/audio.wav est le flux audio au format Wav. http://192.168.1.8:8080/audio.aac est le flux audio au format AAC (si pris en charge par le matériel). http://192.168.1.8:8080/audio.opus est le flux audio au format Opus. http://192.168.1.8:8080/focus fait la mise au point de la caméra. http://192.168.1.8:8080/nofocus libère le focus.

Answer 1

Vous pouvez simplement modifier

VideoCapture camera = new VideoCapture("IPADDRESS"); 

ou

capture.open("IPADRESS"); 

Answer 2

Vous devez capturer la vidéo à partir de l'URL du flux de la caméra comme

VideoCapture capture = new VideoCapture(url); 

L'URL peut être

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

Essayez de confirmer les valeurs appropriées en utilisant votre navigateur, Hope that helps.

également au lieu d'utiliser webcam IP App avec OpenCV Incase vous utilisez un appareil Android, Une meilleure alternative est d'utiliser l'application de DroidCam et logiciel PC pour reconnaître la webcam comme

VideoCapture capture = new VideoCapture(camIndex);