मैं लगातार एक वेब कैमरा से छवियों को कैसे पकड़ सकता हूं?
मैं ऑब्जेक्ट मान्यता के साथ प्रयोग करना चाहता हूं (शायद जावा मीडिया फ्रेमवर्क का उपयोग करके)।
मैं दो सूत्र बनाने की सोच रहा था
एक धागा:
अन्य धागा:
जवाबों:
यह जावासीवी कार्यान्वयन ठीक काम करता है।
कोड:
import org.bytedeco.javacv.*;
import org.bytedeco.opencv.opencv_core.IplImage;
import java.io.File;
import static org.bytedeco.opencv.global.opencv_core.cvFlip;
import static org.bytedeco.opencv.helper.opencv_imgcodecs.cvSaveImage;
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() {
new File("images").mkdir();
FrameGrabber grabber = new OpenCVFrameGrabber(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("images" + File.separator + (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();
}
}
JavaCV के लिए कॉन्फ़िगरेशन पर पोस्ट भी है
आप कोडों को संशोधित कर सकते हैं और नियमित अंतराल में छवियों को सहेजने में सक्षम हो सकते हैं और बाकी की प्रोसेसिंग चाहते हैं।
कुछ समय पहले मैंने जेनेरिक जावा लाइब्रेरी बनाई है जिसका उपयोग पीसी वेब कैमरा के साथ चित्र लेने के लिए किया जा सकता है। एपीआई बहुत सरल है, ओवरफिट नहीं किया गया है, स्टैंडअलोन काम कर सकता है, लेकिन अतिरिक्त वेब कैमरा ड्राइवरों जैसे ओपनिमाज, जेएमएफ, एफएमजे, एलटीआई-सिविल, आदि और कुछ आईपी कैमरों का भी समर्थन करता है।
परियोजना का लिंक https://github.com/sarxos/webcam-capture है
उदाहरण कोड (तस्वीर ले लो और test.jpg में सहेजें):
Webcam webcam = Webcam.getDefault();
webcam.open();
BufferedImage image = webcam.getImage();
ImageIO.write(image, "JPG", new File("test.jpg"));
यह मावेन सेंट्रल रिपोजिटरी में या एक अलग ज़िप के रूप में भी उपलब्ध है जिसमें सभी आवश्यक निर्भरताएं और 3 जी पार्टी जार शामिल हैं।
JMyron उपयोग के लिए बहुत सरल है। http://webcamxtra.sourceforge.net/
myron = new JMyron();
myron.start(imgw, imgh);
myron.update();
int[] img = myron.image();
इस तरह का जावासीवी का उपयोग करके gt_ebuddy के उत्तर को बंद कर दिया जाता है, लेकिन मेरा वीडियो आउटपुट बहुत उच्च गुणवत्ता पर है और फिर उसका उत्तर। मैंने कुछ अन्य यादृच्छिक सुधार भी जोड़े हैं (जैसे कि प्रोग्राम को बंद करने के दौरान ESCऔर CTRL+Cदबाए जाने पर, और प्रोग्राम को संसाधनों को ठीक से बंद करना सुनिश्चित करें)।
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;
}
}
आप जावा वेब कैमरा एसडीके लाइब्रेरी भी आज़मा सकते हैं। एसडीके डेमो एप्लेट लिंक पर उपलब्ध है ।
मैंने एक वीडियोकांफ्रेंसिंग एप्लिकेशन पर जेएमएफ का उपयोग किया है और इसने दो लैपटॉप पर अच्छा काम किया है: एक एकीकृत वेब कैमरा के साथ और दूसरा एक पुराने यूएसबी वेबकैम के साथ। इसके लिए जेएमएफ को पहले हाथ से स्थापित और कॉन्फ़िगर किया जाना आवश्यक है, लेकिन एक बार जब आप पूरा कर लेते हैं तो आप जावा कोड के माध्यम से हार्डवेयर को आसानी से एक्सेस कर सकते हैं।
आप मार्विन फ्रेमवर्क ट्राई कर सकते हैं । यह कैमरों के साथ काम करने के लिए एक इंटरफ़ेस प्रदान करता है। इसके अलावा, यह ऑब्जेक्ट ट्रैकिंग और फ़िल्टरिंग जैसी वास्तविक समय वीडियो प्रसंस्करण सुविधाओं का एक सेट भी प्रदान करता है।
जरा देखो तो!
रियल-टाइम वीडियो प्रोसेसिंग डेमो:
http://www.youtube.com/watch?v=D5mBt0kRYvk
आप नीचे दिए गए स्रोत का उपयोग कर सकते हैं। बस हर 5 सेकंड में MarvinImageIO.saveImage () का उपयोग करके एक फ़्रेम को सहेजें ।
वेब कैमरा वीडियो डेमो:
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);
}
}
उन लोगों के लिए जो केवल एक तस्वीर लेना चाहते हैं:
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
स्विंग के साथ खिलाड़ी का उपयोग करना
प्लेयर का उपयोग आसानी से एक स्विंग एप्लिकेशन में भी किया जा सकता है। निम्न कोड पूरी विंडो में प्रदर्शित वीडियो आउटपुट के साथ एक स्विंग-आधारित टीवी कैप्चर प्रोग्राम बनाता है:
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();
}
}
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"));
}
}
}
Java आमतौर पर हार्डवेयर एक्सेस करना पसंद नहीं करता है, इसलिए आपको कुछ प्रकार के ड्राइवर प्रोग्राम की आवश्यकता होगी, जैसा कि गोल्डनम ने कहा था। मैंने अपने लैपटॉप पर कमांड लाइन प्रोग्राम ढूंढकर किया है जो तस्वीर खींचता है। फिर यह वही है जो स्वर्णिम ने समझाया था; आप अपने java प्रोग्राम से टेकपिटचर () रूटीन में कमांड लाइन प्रोग्राम चलाते हैं, और आपका बाकी कोड भी यही चलता है।
किसी सरणी में पिक्सेल मान पढ़ने के बारे में भाग को छोड़कर, आपको फ़ाइल को BMP में सहेजकर बेहतर तरीके से प्रस्तुत किया जा सकता है, जो कि पहले से ही लगभग उस प्रारूप है, फिर उस पर मानक जावा छवि पुस्तकालयों का उपयोग करना।
कमांड लाइन प्रोग्राम का उपयोग करने से आपके प्रोग्राम पर निर्भरता बढ़ जाती है और यह कम पोर्टेबल हो जाता है, लेकिन क्या वेब कैमरा सही था?
मल्टीमीडिया से संबंधित जावा एप के लिए एफएमजे का उपयोग करने की सिफारिश की गई है।
मेरा मानना है कि वेब-कैम एप्लिकेशन सॉफ्टवेयर जो वेब-कैम के साथ आता है, या आप देशी विंडोज़ वेबकेम सॉफ्टवेयर को वेब कैम को चालू करने के बाद एक बैच स्क्रिप्ट (विंडोज़ / डॉस स्क्रिप्ट) में चलाया जा सकता है (अर्थात यदि इसे बाहरी शक्ति की आवश्यकता है आपूर्ति)। बैक्ट लिपि में, यू निश्चित समय अवधि के बाद कब्जा करने के लिए उपयुक्त देरी जोड़ सकता है। और लूप में कैप्चर कमांड को निष्पादित करना जारी रखें।
मुझे लगता है कि यह संभव होना चाहिए
-AD
प्रसंस्करण में इसके लिए एक बहुत अच्छा इंटरफ़ेस है , जो कि एक पिजिन की तरह है ग्राफिक्स के लिए डिज़ाइन किए गए जावा । इसका उपयोग कुछ छवि पहचान कार्य में किया जाता है, जैसे कि लिंक।
इस पर निर्भर करते हुए कि आपको इसकी क्या आवश्यकता है, आप उस वीडियो लाइब्रेरी को लोड करने में सक्षम हो सकते हैं जो वहां जावा में उपयोग की जाती है, या यदि आप बस इसके साथ खेल रहे हैं, तो आप स्वयं प्रसंस्करण का उपयोग करके प्राप्त करने में सक्षम हो सकते हैं।
FMJ यह कर सकता है, जैसा कि सहायक पुस्तकालय इसका उपयोग करता है, LTI-CIVIL। दोनों स्रोत पर हैं।
जावा का उपयोग करके वेब कैमरा का उपयोग करने के लिए JMyron का उपयोग करने का प्रयास करें । मुझे लगता है कि JMyron का उपयोग करना java का उपयोग करके वेब कैमरा एक्सेस करने का सबसे आसान तरीका है। मैंने 64-बिट प्रोसेसर के साथ इसका उपयोग करने की कोशिश की, लेकिन इसने मुझे एक त्रुटि दी। हालांकि, 32-बिट प्रोसेसर पर यह ठीक काम करता था।