Capturer une image de la webcam en Java?
Comment puis-je capturer en continu des images à partir d'une webcam?
Je veux expérimenter avec la reconnaissance d'objet (en utilisant peut-être un framework multimédia Java).
Je pensais créer deux fils
un fil:
- Noeud 1: capture d'une image en direct
- Noeud 2: enregistrer l'image sous "1.jpg"
- Noeud 3: attendez 5 secondes
- Noeud 4: répétez ...
autre fil:
- Nœud 1: attend que l'image soit capturée
- Noeud 2: en utilisant le "1.jpg", obtenez les couleurs De chaque pixel
- Node 3: sauvegarder les données dans les tableaux
- Noeud 4: répétez ...
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 pouvoir enregistrer les images à intervalles réguliers et effectuer le traitement souhaité.
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, ne contient pas trop de fonctionnalités, peut fonctionner de manière autonome, mais prend également en charge des pilotes de webcam supplémentaires tels que 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 l'enregistrer dans 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 sous forme de fichier Zip distinct, qui inclut toutes les dépendances requises et les fichiers JAR 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();
Cela ressemble à la réponse de gt_ebuddy avec JavaCV, mais la qualité de ma sortie vidéo est bien supérieure à celle de 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 s'assurant 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 library également . Un applet de démonstration SDK est disponible à l'adresse link .
J'ai utilisé JMF sur une application de vidéoconférence et cela fonctionnait bien sur deux ordinateurs portables: un avec webcam intégrée et un autre avec une ancienne webcam USB. JMF doit être installé et configuré à l'avance, mais une fois que vous avez terminé, vous pouvez accéder assez facilement au matériel via le code Java.
Vous pouvez essayer Framework Marvin . Il fournit une interface pour travailler avec des caméras. En outre, il fournit également un ensemble de fonctionnalités de traitement vidéo en temps réel, telles que le suivi et le filtrage d'objets.
Regarde!
Démo de traitement vidéo en temps réel:
http://www.youtube.com/watch?v=D5mBt0kRYvk
Vous pouvez utiliser la source ci-dessous. Sauvegardez simplement un cadre en utilisant MarvinImageIO.saveImage () toutes les 5 secondes.
Démo vidéo Webcam:
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();
}
}
}
J'ai utilisé Webcam Capture API ... vous pouvez télécharger à partir de ceci 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"));
}
}
}
http://grack.com/downloads/school/enel619.10/report/Java_media_framework.html
Utiliser le joueur avec Swing
Le lecteur peut également être facilement utilisé dans une application Swing. Le code suivant crée un programme de capture de télévision 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, vous aurez donc besoin d'un programme de pilote, comme le dit goldenmean. Je l'ai fait sur mon ordinateur portable en trouvant un programme en ligne de commande qui capture une image. 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 est identique.
Excepté la partie concernant la lecture des valeurs de pixels dans un tableau, il serait peut-être préférable de sauvegarder le fichier au format BMP, qui a déjà presque ce format, puis d'utiliser les bibliothèques d'images Java standard.
L'utilisation d'un programme en ligne de commande ajoute une dépendance à votre programme et le rend moins portable, mais la webcam l'était également, non?
Je crois que le logiciel d’application de la webcam fourni avec la webcam, ou votre logiciel natif de webcam pour Windows, peut être exécuté dans un script batch (script Windows/DOS) après avoir allumé la webcam (c’est-à-dire si elle nécessite une alimentation externe la fourniture). Dans le script bacth, vous pouvez ajouter le délai approprié à capturer après une certaine période. Et continuez à exécuter la commande de capture en boucle.
Je suppose que cela devrait être possible
-UN D
FMJ peut le faire, de même que la bibliothèque de support utilisée, LTI-CIVIL. Les deux sont sur sourceforge.
Recommandez l'utilisation de FMJ pour les applications multimédia relatives à Java.
Essayez d’utiliser JMyron Comment utiliser une webcam avec 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 cela m'a donné une erreur. Cela fonctionnait parfaitement sur un processeur 32 bits, cependant.
Il existe une jolie interface pour cela dans processing , qui est un peu comme un Pidgin Java conçu pour les graphiques. Il est utilisé dans certains travaux de reconnaissance d'images, tels que ce lien.
En fonction de vos besoins, vous pourrez peut-être charger la bibliothèque de vidéos utilisée en Java ou, si vous vous contentez de la jouer, vous pourrez peut-être utiliser le traitement lui-même.