cette implémentation JavaCV fonctionne très 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 de sauvegarder les images dans l'intervalle régulier et ne 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, non surfeatured, peut fonctionner seul, mais prend également en charge des pilotes webcam supplémentaires comme OpenIMAJ, JMF, FMJ, LTI-CIVIL, etc, et certaines caméras IP.

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

exemple de code (prendre une photo et enregistrer en 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 Maven Central Repository ou dans un ZIP séparé qui inclut toutes les dépendances requises et les jarres de tiers.

JMyron est très simple d'utilisation. http://webcamxtra.sourceforge.net /

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

ici est une question similaire avec quelques réponses - mais non acceptées. L'un d'eux mentionne FMJ comme alternative java à JMF.

ce genre de réponse de gt_ebuddy est désactivée en utilisant JavaCV, mais ma sortie vidéo est d'une qualité beaucoup plus élevée que sa réponse. J'ai aussi ajouté quelques autres améliorations aléatoires (comme fermer le programme lorsque ESC et CTRL+C sont pressés, et s'assurer de 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 essayer Java Webcam SDK bibliothèque aussi. L'applet de démonstration SDK est disponible à link .

j'ai utilisé JMF sur une application de vidéoconférence et il a bien fonctionné sur deux ordinateurs portables: l'un avec webcam intégrée et l'autre avec une vieille webcam USB. Il exige que JMF soit installé et configuré avant main, mais une fois que vous avez terminé, vous pouvez accéder au matériel via le code Java assez facilement.

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

regardez!

démo de traitement vidéo en temps réel:

http://www.youtube.com/watch?v=D5mBt0kRYvk

Vous pouvez utiliser la source ci-dessous. Il suffit de sauvegarder un cadre utilisant MarvinImageIO.saveImage () toutes les 5 secondes.

Webcam vidéo de 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 photo:

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

utiliser le Joueur avec Swing

le Joueur peut être facilement utilisé dans une application de Swing aussi bien. Le code suivant crée un programme de capture TV basé sur Swing avec la sortie vidéo affichée dans la fenêtre entière:

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, donc vous aurez besoin d'un programme pilote d'une sorte, comme goldenmean dit. J'ai fait ça sur mon ordinateur portable en trouvant un programme de ligne de commande qui prend une photo. Alors c'est la même chose que goldenmean a expliqué; vous exécutez le programme en ligne de commande à partir de votre programme java dans la routine takepicture (), et le reste de votre code fonctionne de la même manière.

sauf pour la partie sur la lecture des valeurs de pixel dans un tableau, vous pourriez être mieux servi en enregistrant le fichier au format BMP, qui est à peu près ce format déjà, puis en utilisant le standard de java bibliothèques d'images.

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

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 Windows webcam natif peut être exécuté dans un script batch(Windows/DOS script) après avoir allumé la web-cam(i.e. si elle a besoin d'une alimentation externe). Dans le script bacth , u peut ajouter le délai approprié pour la capture après une certaine période de temps. Et continuez d'exécuter la commande de capture en boucle.

je suppose que cela devrait être possible

- AD

Il ya une interface assez agréable pour cela dans traitement , qui est une sorte de pidgin java conçu pour les graphiques. Il est utilisé dans certains de reconnaissance d'images de travail, comme ce lien.

selon ce dont vous avez besoin, vous pourriez être en mesure de charger la bibliothèque vidéo qui est utilisée en java, ou si vous êtes juste en train de jouer avec elle, vous pourriez être en mesure d'obtenir en utilisant le traitement lui-même.

FMJ pouvez faire cela, comme le soutien de la bibliothèque utilise, LTI-CIVIL. Les deux sont sur sourceforge.

Recommander à l'aide de FMJ pour le multimédia relatived application java.

essayez D'utiliser JMyron comment utiliser Webcam en utilisant Java . Je pense que l'utilisation de JMyron est la façon la plus facile 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. Mais ça marchait très bien sur un processeur 32 bits.