Beaglebone: Video Capture and Image Processing on Embedded Linux using OpenCV

In this video I look at how you can get started with video capture and image processing on the Beaglebone. It is an introductory video that should give people who are new to this topic a starting point to work from. I look at three different distinct challenges:
- How do you capture video from a USB webcam under Linux
- How do you capture image frames from a USB webcam under Linux
- How do you use OpenCV to capture and image process frames so that you can build computer vision applications under Linux on the Beaglebone.

In this video I use a Logitech C920 and the Beaglebone Black. I would highly recommend both of these devices because of the processing power of the Beaglebone black and the high resolution capability of the C920. However, you should be able to adapt the code to any specific camera.

If you use this code or the content of the associated video in your research, please cite:

Molloy, D. [DerekMolloyDCU]. (2013, May, 25). Beaglebone: Video Capture and Image Processing on Embedded Linux using OpenCV [Video file]. Retrieved from http://www.youtube.com/watch?v=8QouvY...

Further information on the videos on this channel can be found at the website http://www.derekmolloy.ie/ including update blogs, source code, text guides and structured instruction. More detail on this specific video is available at:

http://derekmolloy.ie/beaglebone/beag...

---

Closed Caption:

In this video I am going to look at how you
can get started with video capture and image
processing on the Beaglebone. It is an introductory
video that should give people who are new
to this topic a starting point to work from.
I will look at three different distinct challenges:
How do you capture video from a USB webcam
under Linux
How do you capture image frames from a USB
webcam under Linux
How do you use OpenCV to capture and image
process frames so that you can build computer
vision applications under Linux on the Beaglebone.
I�m using a specific webcam from Logitech
that I would highly recommend because of its
high resolution capability, but you should
be able to adapt the code to your specific
camera.
The good news is that once you have the source
code examples it�s not too difficult. The
latest Angstrom distributions come with almost
everything you need, particularly pre-built
Video4Linux and OpenCV libraries and support.
What I have done here is aggregated the code
that you need and customised it for the camera
that I am using.
If you are building Angstrom, bitbaking Custom
Angstrom distributions to include these packages
or you are building FFMPEG from source you
might be interested in my new personal site:
derekmolloy.ie where I have separate posts
on each of these topics. Go to blog Beaglebone
for all my posts. The site is only new, so
I will be adding more content as I am working
on projects.
Okay, so for this video I am using the Beaglebone
Black, which is the latest Beaglebone that
is available. It is very powerful with a 1GHz
ARM A8 processor with 512MB of DDR3 RAM - a
great improvement for doing any type of image
processing, which is very resource intensive.
The other improvements over the Beaglebone
white are the on-board HDMI output and a 2GB
eMMC, which means that you get boot times
of around 10 seconds � you can still use
the sd slot for additional storage. The best
thing has to be the price � at $45 it is
significantly cheaper than any other device
out there for the specification and is very
good value for money.
For the camera I am using a Logitech C920,
which is a top of the range USB webcam. At
about $80 it�s not cheap, but it is a high
quality camera that has features that could
be really useful in embedded applications.
The big advantage of this device is that it
is capable of recording full-hd 1080p and
encoding it in real-time using the H264 compression
format. It has a very good quality Carl Zeiss
lens that has a 20 step autofocus. There is
good Linux support for this camera and I have
found it to be a straightforward device to
interface to. It is a USB 2.0 device and comes
with 6 feet of cable.
It has a high quality feel to the surround.
It�s not small, but I suppose it needs space
to store the video encoding circuitry. It
has a really useful socket that is formed
in metal on the bottom that would be great
for mounting the camera securely in robotics
applications. Overall, it feels like a solid
piece of equipment that would be capable of
taking some accidental abuse.
I have adapted and written some code for all
of the examples that are presented here in
this video. It is available at my github site:
github.com/derekmolloy/ and the repository
for the project is boneCV (with the CV meaning
computer vision). In this repository you will
find the C and C++ files for the projects
and scripts for building the code and for
using ffmpeg to enclose raw streamed H264
video in a H264 container.
In my setup you will notice I am powering
the camera using the barrel jack and a 5V
1Amp supply. I was getting I/O communication
errors at one stage with this camera and it
came down purely to the fact that powering
the Beaglebone black and camera through the
usb hub on my monitor was not providing enough
current. I tried it on my laptop and it worked
fine � so, just be careful that you are
getting enough power to the devices. As I
said the problem didn�t appear as a brownout
problem it just resulted in an IO error between
the camera and Beaglebone when I tried to
capture video.
Okay so first I am going to check that the
camera is working and download
the source code:
Uname �a
Lsusb
Cd /dev
Should see video0
Video4Linux or V4L is a video capture application
programming interface for Linux, supporting
many USB webcams, TV tuners, and other devices.
Video4Linux is closely integrated with the
Linux kernel and is very stable. We need to
check that Video for linux 2 is working with
our camera:
v4l2-ctl �h gives all of the options
v4l2-ctl �list-devices
To get all available information about our
camera we can use:
V4l2-ctl --all
Right the first point is capturing raw video
from the camera. This would be perfect if
you had a project that captured video when
a sensor is triggered. For example you could
connect a PIR (passive infra red) or an ultrasonic
sensor to one of the GPIOs and when motion
is detected the camera could be triggered
to record video. In this case I am recording
the video to the file system; however, it
would be possible with some coding to stream
the data to a socket where it could be transferred
over the Internet to a host computer that
was decoding the data stream.
The really nice thing about this program is
that I am going to use the H264 format that
is provided by the camera � this means that
the camera is doing almost all of the work
and that the load on the Beaglebone is very
light (well compared to software encoding
a video stream). The Beaglebone is effectively
responsible for taking the data from the USB
input and storing it in a file.
This program is called capture.c
and while I have modified it, it is not my
code. It is provided with the
video for linux 2 API and
you can get further information about it
at
the linuxtv.org website. I�ll just briefly
explain the minor changes that I have
made
for
this camera.