Capturing Image From Webcam In Java

1. Overview

Usually, Java doesn't provide easy access to the computer hardware. That's why we might find it tough to access the webcam using Java.

In this tutorial, we’ll explore a few Java libraries that allow us to capture images by accessing the webcam.

2. JavaCV

First, we'll examine the javacv library. This is Bytedeco‘s Java implementation of the OpenCV computer vision library.

Let's add the latest javacv-platform Maven dependency to our pom.xml:

<dependency>
    <groupId>org.bytedeco</groupId>
    <artifactId>javacv-platform</artifactId>
    <version>1.5.5</version>
</dependency>

Similarly, when using Gradle, we can add the javacv-platform dependency in the build.gradle file:

compile group: 'org.bytedeco', name: 'javacv-platform', version: '1.5.5'

Now that we're ready with the setup, let's use the OpenCVFrameGrabber class to access the webcam and capture a frame:

FrameGrabber grabber = new OpenCVFrameGrabber(0);
grabber.start();
Frame frame = grabber.grab();

Here, we've passed the device number as 0, pointing to the default webcam of the system. However, if we have more than one camera available, then the second camera is accessible at 1, the third one at 2, and so on.

Then, we can use the OpenCVFrameConverter to convert the captured frame into an image. Also, we'll save the image using the cvSaveImage method of the opencv_imgcodecs class:

OpenCVFrameConverter.ToIplImage converter = new OpenCVFrameConverter.ToIplImage();
IplImage img = converter.convert(frame);
opencv_imgcodecs.cvSaveImage("selfie.jpg", img);

Last, we can use the CanvasFrame class to display the captured frame:

CanvasFrame canvas = new CanvasFrame("Web Cam");
canvas.showImage(frame);

Let's examine a full solution that accesses the webcam, captures an image, displays the image in a frame, and closes the frame automatically after two seconds:

CanvasFrame canvas = new CanvasFrame("Web Cam");
canvas.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
FrameGrabber grabber = new OpenCVFrameGrabber(0);
OpenCVFrameConverter.ToIplImage converter = new OpenCVFrameConverter.ToIplImage();
grabber.start();
Frame frame = grabber.grab();
IplImage img = converter.convert(frame);
cvSaveImage("selfie.jpg", img);
canvas.showImage(frame);
Thread.sleep(2000);
canvas.dispatchEvent(new WindowEvent(canvas, WindowEvent.WINDOW_CLOSING));

3. webcam-capture

Next, we'll examine the webcam-capture library that allows using the webcam by supporting multiple capturing frameworks.

First, let's add the latest webcam-capture Maven dependency to our pom.xml:

<dependency>
    <groupId>com.github.sarxos</groupId>
    <artifactId>webcam-capture</artifactId>
    <version>0.3.12</version>
</dependency>

Or, we can add the webcam-capture in the build.gradle for a Gradle project:

compile group: 'com.github.sarxos', name: 'webcam-capture', version: '0.3.12'

Then, let's write a simple example to capture an image using the Webcam class:

Webcam webcam = Webcam.getDefault();
webcam.open();
BufferedImage image = webcam.getImage();
ImageIO.write(image, ImageUtils.FORMAT_JPG, new File("selfie.jpg"));

Here, we accessed the default webcam to capture the image, and then we saved the image to a file.

Alternatively, we can use the WebcamUtils class to capture an image:

WebcamUtils.capture(webcam, "selfie.jpg");

Also, we can use the WebcamPanel class to display a captured image in a frame:

Webcam webcam = Webcam.getDefault();
webcam.setViewSize(WebcamResolution.VGA.getSize());
WebcamPanel panel = new WebcamPanel(webcam);
panel.setImageSizeDisplayed(true);
JFrame window = new JFrame("Webcam");
window.add(panel);
window.setResizable(true);
window.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
window.pack();
window.setVisible(true);

Here, we set VGA as the view size of the webcam, created the JFrame object, and added the WebcamPanel component to the frame.

4. Marvin Framework

At last, we'll explore the Marvin framework to access the webcam and capturing an image.

As usual, we'll add the latest marvin dependency to our pom.xml:

<dependency>
    <groupId>com.github.downgoon</groupId>
    <artifactId>marvin</artifactId>
    <version>1.5.5</version>
</dependency>

Or, for a Gradle project, we'll add the marvin dependency in the build.gradle file:

compile group: 'com.github.downgoon', name: 'marvin', version: '1.5.5'

Now that setup is ready, let's use the MarvinJavaCVAdapter class to connect to the default webcam by providing 0 for the device number:

MarvinVideoInterface videoAdapter = new MarvinJavaCVAdapter();
videoAdapter.connect(0);

Next, we can use the getFrame method to capture the frame, and then we'll save the image using the saveImage method of the MarvinImageIO class:

MarvinImage image = videoAdapter.getFrame();
MarvinImageIO.saveImage(image, "selfie.jpg");

Also, we can use the MarvinImagePanel class to display an image in a frame:

MarvinImagePanel imagePanel = new MarvinImagePanel();
imagePanel.setImage(image);
imagePanel.setSize(800, 600);
imagePanel.setVisible(true);

5. Conclusion

In this short article, we examined a few Java libraries that provide easy access to the webcam.

First, we explored the javacv-platform library that provides a Java implementation of the OpenCV project. Then, we saw the example implementation of the webcam-capture library to capture images using a webcam. Last, we took a look at the simple examples to capture the images using the Marvin framework.

As usual, all the code implementations are available over on GitHub.