Cette implémentation JavaCV fonctionne bien.

Code:

import org.bytedeco.javacv.*;

import static org.bytedeco.javacpp.opencv_core.IplImage;
import static org.bytedeco.javacpp.opencv_core.cvFlip;
import static org.bytedeco.javacpp.opencv_imgcodecs.cvSaveImage;


/**
 * Created by gtiwari on 1/3/2017.
 */

public class Test implements Runnable {
    final int INTERVAL = 100;///you may use interval
    CanvasFrame canvas = new CanvasFrame("Web Cam");

    public Test() {
        canvas.setDefaultCloseOperation(javax.swing.JFrame.EXIT_ON_CLOSE);
    }

    public void run() {

        FrameGrabber grabber = new VideoInputFrameGrabber(0); // 1 for next camera
        OpenCVFrameConverter.ToIplImage converter = new OpenCVFrameConverter.ToIplImage();
        IplImage img;
        int i = 0;
        try {
            grabber.start();
            while (true) {
                Frame frame = grabber.grab();

                img = converter.convert(frame);

                //the grabbed frame will be flipped, re-flip to make it right
                cvFlip(img, img, 1);// l-r = 90_degrees_steps_anti_clockwise

                //save
                cvSaveImage((i++) + "-aa.jpg", img);

                canvas.showImage(converter.convert(img));

                Thread.sleep(INTERVAL);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) {
        Test gs = new Test();
        Thread th = new Thread(gs);
        th.start();
    }
}

Il y a aussi post sur la configuration pour JavaCV

Vous pouvez modifier les codes et être en mesure d'enregistrer les images à intervalle régulier et faire le reste du traitement que vous voulez.

Il y a quelque temps, j'ai créé une bibliothèque Java générique qui peut être utilisée pour prendre des photos avec une webcam PC. L'API est très simple, pas suralimentée, peut fonctionner de manière autonome, mais prend également en charge des pilotes de webcam supplémentaires comme OpenIMAJ, JMF, FMJ, LTI-CIVIL, etc., et certaines caméras IP.

Lien vers le projet est https://github.com/sarxos/webcam-capture

Exemple de code (prendre une photo et enregistrer dans le test.jpg):

Webcam webcam = Webcam.getDefault();
webcam.open();
BufferedImage image = webcam.getImage();
ImageIO.write(image, "JPG", new File("test.jpg"));

Il est également disponible dans le référentiel central Maven ou en tant que ZIP séparé qui comprend toutes les dépendances requises et les POTS tiers.

JMyron est très simple à utiliser. http://webcamxtra.sourceforge.net/

myron = new JMyron();
myron.start(imgw, imgh);
myron.update();
int[] img = myron.image();

Voici une question similaire avec des réponses - encore inacceptables -. L'un d'eux mentionne FMJ comme alternative java à JMF.

Ce genre de réponse sort de la réponse de gt_ebuddy en utilisant JavaCV, mais ma sortie vidéo est d'une qualité beaucoup plus élevée que sa réponse. J'ai également ajouté d'autres améliorations aléatoires (telles que la fermeture du programme lorsque ESC et CTRL+C sont pressés, et en veillant à fermer les ressources que le programme utilise correctement).

import java.awt.event.ActionEvent;
import java.awt.event.KeyEvent;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;
import java.awt.image.BufferedImage;

import javax.swing.AbstractAction;
import javax.swing.ActionMap;
import javax.swing.InputMap;
import javax.swing.JComponent;
import javax.swing.JFrame;
import javax.swing.KeyStroke;

import com.googlecode.javacv.CanvasFrame;
import com.googlecode.javacv.OpenCVFrameGrabber;
import com.googlecode.javacv.cpp.opencv_core.IplImage;

public class HighRes extends JComponent implements Runnable {
    private static final long serialVersionUID = 1L;

    private static CanvasFrame frame = new CanvasFrame("Web Cam");
    private static boolean running = false;
    private static int frameWidth = 800;
    private static int frameHeight = 600;
    private static OpenCVFrameGrabber grabber = new OpenCVFrameGrabber(0);
    private static BufferedImage bufImg;

    public HighRes()
    {
        // setup key bindings
        ActionMap actionMap = frame.getRootPane().getActionMap();
        InputMap inputMap = frame.getRootPane().getInputMap(JComponent.WHEN_IN_FOCUSED_WINDOW);

        for (Keys direction : Keys.values())
        {
            actionMap.put(direction.getText(), new KeyBinding(direction.getText()));
            inputMap.put(direction.getKeyStroke(), direction.getText());
        }

        frame.getRootPane().setActionMap(actionMap);
        frame.getRootPane().setInputMap(JComponent.WHEN_IN_FOCUSED_WINDOW, inputMap);

        // setup window listener for close action
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        frame.addWindowListener(new WindowAdapter()
        {
            public void windowClosing(WindowEvent e)
            {
                stop();
            }
        });
    }

    public static void main(String... args)
    {
        HighRes webcam = new HighRes();
        webcam.start();
    }

    @Override
    public void run()
    {
        try
        {

            grabber.setImageWidth(frameWidth);
            grabber.setImageHeight(frameHeight);
            grabber.start();
            while (running)
            {

                final IplImage cvimg = grabber.grab();
                if (cvimg != null)
                {

                    // cvFlip(cvimg, cvimg, 1); // mirror

                    // show image on window
                    bufImg = cvimg.getBufferedImage();
                    frame.showImage(bufImg);
                }
            }
            grabber.stop();
            grabber.release();
            frame.dispose();
        }
        catch (Exception e)
        {
            e.printStackTrace();
        }
    }

    public void start()
    {
        new Thread(this).start();
        running = true;
    }

    public void stop()
    {
        running = false;
    }

    private class KeyBinding extends AbstractAction {

        private static final long serialVersionUID = 1L;

        public KeyBinding(String text)
        {
            super(text);
            putValue(ACTION_COMMAND_KEY, text);
        }

        @Override
        public void actionPerformed(ActionEvent e)
        {
            String action = e.getActionCommand();
            if (action.equals(Keys.ESCAPE.toString()) || action.equals(Keys.CTRLC.toString())) stop();
            else System.out.println("Key Binding: " + action);
        }
    }
}

enum Keys
{
    ESCAPE("Escape", KeyStroke.getKeyStroke(KeyEvent.VK_ESCAPE, 0)),
    CTRLC("Control-C", KeyStroke.getKeyStroke(KeyEvent.VK_C, KeyEvent.CTRL_DOWN_MASK)),
    UP("Up", KeyStroke.getKeyStroke(KeyEvent.VK_UP, 0)),
    DOWN("Down", KeyStroke.getKeyStroke(KeyEvent.VK_DOWN, 0)),
    LEFT("Left", KeyStroke.getKeyStroke(KeyEvent.VK_LEFT, 0)),
    RIGHT("Right", KeyStroke.getKeyStroke(KeyEvent.VK_RIGHT, 0));

    private String text;
    private KeyStroke keyStroke;

    Keys(String text, KeyStroke keyStroke)
    {
        this.text = text;
        this.keyStroke = keyStroke;
    }

    public String getText()
    {
        return text;
    }

    public KeyStroke getKeyStroke()
    {
        return keyStroke;
    }

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

Vous pouvez également essayer la bibliothèque Java Webcam SDK. L'applet de démonstration du SDK est disponible sur link .

J'ai utilisé JMF sur une application de visioconférence et cela a bien fonctionné sur deux ordinateurs portables: un avec webcam intégrée et un autre avec une ancienne webcam USB. Il nécessite l'installation et la configuration préalable de JMF, mais une fois que vous avez terminé, vous pouvez accéder au matériel via du code Java assez facilement.

Vous pouvez essayer de Marvin Cadre. Il fournit une interface pour travailler avec des caméras. De plus, il fournit également un ensemble de fonctionnalités de traitement vidéo en temps réel, telles que le suivi et le filtrage des objets.

Jetez un oeil!

Démo de traitement Vidéo en temps réel:
http://www.youtube.com/watch?v=D5mBt0kRYvk

Vous pouvez utiliser la source ci-dessous. Enregistrez simplement un cadre en utilisant MarvinImageIO.saveImage () toutes les 5 secondes.

Vidéo de la Webcam démonstration:

public class SimpleVideoTest extends JFrame implements Runnable{

    private MarvinVideoInterface    videoAdapter;
    private MarvinImage             image;
    private MarvinImagePanel        videoPanel;

    public SimpleVideoTest(){
        super("Simple Video Test");
        videoAdapter = new MarvinJavaCVAdapter();
        videoAdapter.connect(0);
        videoPanel = new MarvinImagePanel();
        add(videoPanel);
        new Thread(this).start();
        setSize(800,600);
        setVisible(true);
    }
    @Override
    public void run() {
        while(true){
            // Request a video frame and set into the VideoPanel
            image = videoAdapter.getFrame();
            videoPanel.setImage(image);
        }
    }
    public static void main(String[] args) {
        SimpleVideoTest t = new SimpleVideoTest();
        t.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    }
}

Pour ceux qui veulent juste prendre une seule image:

WebcamPicture.java

public class WebcamPicture {
    public static void main(String[] args) {
        try{
            MarvinVideoInterface videoAdapter = new MarvinJavaCVAdapter();
            videoAdapter.connect(0);
            MarvinImage image = videoAdapter.getFrame();
            MarvinImageIO.saveImage(image, "./res/webcam_picture.jpg");
        } catch(MarvinVideoInterfaceException e){
            e.printStackTrace();
        }
    }
}

Http://grack.com/downloads/school/enel619.10/report/java_media_framework.html

Utilisation du joueur avec Swing

Le lecteur peut également être facilement utilisé dans une application Swing. Le code suivant crée un programme de capture TV basé sur Swing avec la sortie vidéo affichée dans toute la fenêtre:

import javax.media.*;
import javax.swing.*;
import java.awt.*;
import java.net.*;
import java.awt.event.*;
import javax.swing.event.*;

public class JMFTest extends JFrame {
    Player _player;
    JMFTest() {
        addWindowListener( new WindowAdapter() {
            public void windowClosing( WindowEvent e ) {
                _player.stop();
                _player.deallocate();
                _player.close();
                System.exit( 0 );
            }
        });
          setExtent( 0, 0, 320, 260 );
        JPanel panel = (JPanel)getContentPane();
        panel.setLayout( new BorderLayout() );
        String mediaFile = "vfw://1";
        try {
            MediaLocator mlr = new MediaLocator( mediaFile );
            _player = Manager.createRealizedPlayer( mlr );
            if (_player.getVisualComponent() != null)
            panel.add("Center", _player.getVisualComponent());
            if (_player.getControlPanelComponent() != null)
            panel.add("South", _player.getControlPanelComponent());
        }
        catch (Exception e) {
            System.err.println( "Got exception " + e );
        }
    }

    public static void main(String[] args) {
        JMFTest jmfTest = new JMFTest();
        jmfTest.show();
    }
}

Java n'aime généralement pas accéder au matériel, vous aurez donc besoin d'un programme de pilote, comme l'a dit goldenmean. Je l'ai fait sur mon ordinateur portable en trouvant un programme de ligne de commande qui prend une image. Ensuite, c'est la même chose que goldenmean expliqué; vous exécutez le programme de ligne de commande à partir de votre programme java dans la routine takepicture (), et le reste de votre code s'exécute de la même manière.

À l'exception de la partie sur la lecture des valeurs de pixels dans un tableau, vous pourriez être mieux servi en enregistrant le fichier à BMP, qui est déjà presque ce format, puis en utilisant les bibliothèques d'images java standard dessus.

L'utilisation d'un programme en ligne de commande ajoute une dépendance à votre programme et le rend moins portable, mais la webcam aussi, non?

J'ai utilisé l'API de capture de webcam...vous pouvez télécharger à partir de ce http://webcam-capture.sarxos.pl /

        webcam = Webcam.getDefault();
        webcam.open();

        if (webcam.isOpen()) { //if web cam open 
            BufferedImage image = webcam.getImage();
            JLabel imageLbl = new JLabel();
            imageLbl.setSize(640, 480);             //show captured image
            imageLbl.setIcon(new ImageIcon(image));

            int showConfirmDialog = JOptionPane.showConfirmDialog(null, imageLbl, "Image Viewer", JOptionPane.YES_NO_OPTION, JOptionPane.QUESTION_MESSAGE, new ImageIcon(""));

            if (showConfirmDialog == JOptionPane.YES_OPTION) {
                JFileChooser chooser = new JFileChooser();
                chooser.setDialogTitle("Save Image");
                chooser.setFileFilter(new FileNameExtensionFilter("IMAGES ONLY", "png", "jpeg", "jpg")); //this file extentions are shown
                int showSaveDialog = chooser.showSaveDialog(this);
                if (showSaveDialog == 0) {                  //if pressed 'Save' button
                    String filePath = chooser.getCurrentDirectory().toString().replace("\\", "/");
                    String fileName = chooser.getSelectedFile().getName(); //get user entered file name to save
                    ImageIO.write(image, "PNG", new File(filePath + "/" + fileName + ".png"));

                }
            }
        }

Je crois que le logiciel d'application web-cam qui vient avec la web-cam, ou votre logiciel de webcam Windows natif peut être exécuté dans un script batch(script windows/dos) après avoir allumé la web cam(c'est-à-dire s'il a besoin d'une alimentation externe). Dans le script bacth , vous pouvez ajouter un délai approprié pour capturer après une certaine période de temps. Et continuez à exécuter la commande de capture en boucle.

Je suppose que cela devrait être possible,

- AD

Il y a une jolie interface pour cela dans traitement, qui est une sorte de pidgin java conçu pour les graphiques. Il est utilisé dans certains travaux de reconnaissance d'image, tels que ce lien.

En fonction de ce dont vous avez besoin, vous pourrez peut-être charger la bibliothèque vidéo qui y est utilisée en java, ou si vous jouez simplement avec elle, vous pourrez peut-être l'obtenir en utilisant le traitement lui-même.

FMJ peut le faire, tout comme la bibliothèque de support qu'il utilise, LTI-CIVIL. Les deux sont sur sourceforge.

Recommande d'utiliser FMJ pour l'application java relative au multimédia.

Essayez d'utiliser JMyronComment Utiliser La Webcam En Utilisant Java . Je pense que l'utilisation de JMyron est le moyen le plus simple d'accéder à une webcam en utilisant java. J'ai essayé de l'utiliser avec un processeur 64 bits, mais il m'a donné une erreur. Cela a très bien fonctionné sur un processeur 32 bits, cependant.