Webcam Capture with OpenCV's Python Interface cv2 and with its C++ interface

.gitignore

video
*.pyc

Readme.md

More interesting example code for OpenCV:

• video_dmtx.cpp
• video_homography.cpp

Makefile

all: video

UNAME := $(shell uname)

O_CFLAGS := $(shell pkg-config --cflags opencv)
O_LDFLAGS := $(shell pkg-config --libs opencv)
CC = g++

# Not really needed right now but might be useful:
ifeq ($(UNAME), Linux)
  ## On Ubuntu / Debian
endif
ifeq ($(UNAME), Darwin)
  ## On Mac OS X
endif

video: video.cpp
	$(CC) -o video video.cpp $(O_CFLAGS) $(O_LDFLAGS)

clean:
	-rm video
.PHONY: clean

mathtools.py

# -*- coding: utf-8 -*-

""" A collection of useful mathematical tools and functions. """

import numpy as np

def scoreatpercentile(a, per, limit=()):
    """
    Calculate the score at the given percentile_ `per` of the sequence `a`.

    Largely the same as http://docs.scipy.org/doc/scipy/reference/generated/scipy.stats.scoreatpercentile.html .

    .. _percentile: http://en.wikipedia.org/wiki/Percentile"""
    values = np.sort(a, axis=0)
    if limit:
        values = values[(limit[0] <= values) & (values <= limit[1])]
    idx = per /100. * (values.shape[0] - 1)
    if (idx % 1 == 0):
        score = values[idx]
    else:
        score = values[int(idx)] + (idx % 1) * (values[int(idx) + 1] - values[int(idx)])
    return score

pg-video.py

#!/usr/bin/env python

# http://johnroach.info/2011/03/02/image-capturing-from-webcam-using-opencv-and-pygame-in-python/

import pygame
import Image
from pygame.locals import *
import sys

import cv2

import numpy

cap = cv2.VideoCapture(0)
i=0
def get_image():
    ret, im = cap.read()
    #convert numpy array to PIL image
    im = numpy.array(im)
    return Image.fromarray(im)

fps = 25.0
pygame.init()
window = pygame.display.set_mode((1280,720))
pygame.display.set_caption("WebCAM Demo")
screen = pygame.display.get_surface()

while True:
    events = pygame.event.get()
    for event in events:
        if event.type == QUIT or event.type == KEYDOWN:
            sys.exit(0)
    im = get_image()
    if i>100:
	    #allowing the camera to focus auto focus is really annoying
        im.save("image_"+str(i)+"", "JPEG")
    i=i+1
    pg_img = pygame.image.frombuffer(im.tostring(), im.size, im.mode)

    screen.blit(pg_img, (0,0))
    pygame.display.flip()
    pygame.time.delay(int(1000 * 1.0/fps))

video.cpp

/*
 * starter_video.cpp
 *
 *  Created on: Nov 23, 2010
 *      Author: Ethan Rublee
 *
 * A starter sample for using opencv, get a video stream and display the images
 * easy as CV_PI right?
 *
 *
 * Also check http://laconsigna.wordpress.com/2011/04/29/1d-histogram-on-opencv/
 *
 */
#include "opencv2/highgui/highgui.hpp"
#include <opencv2/objdetect/objdetect.hpp>
#include <opencv2/imgproc/imgproc.hpp>
#include <iostream>
#include <vector>
#include <stdio.h>

using namespace cv;
using namespace std;

//hide the local functions in an anon namespace
namespace
{
    void help(char** av)
    {
        cout << "\nThis program justs gets you started reading images from video\n"
        "Usage:\n./" << av[0] << " <video device number>\n" << "q,Q,esc -- quit\n"
        << "space   -- save frame\n\n"
        << "\tThis is a starter sample, to get you up and going in a copy pasta fashion\n"
        << "\tThe program captures frames from a camera connected to your computer.\n"
        << "\tTo find the video device number, try ls /dev/video* \n"
        << "\tYou may also pass a video file, like my_vide.avi instead of a device number"
        << endl;
    }

    int process(VideoCapture& capture)
    {

        int n = 0;
        char filename[200];
        string window_name = "video | q or esc to quit";
        cout << "press space to save a picture. q or esc to quit" << endl;
        namedWindow(window_name, CV_WINDOW_KEEPRATIO); //resizable window;
        // namedWindow( "H-S Histogram", 1 );
        namedWindow("Histogram", CV_WINDOW_AUTOSIZE );
        Mat histImage;
        Mat frame;
        int COMPUTE_EVERY = 1; //20;
        for (int j = 0; j != -1; j++)
        {
            capture >> frame;
            if (frame.empty())
                break;

            if (j % COMPUTE_EVERY == 0)
            {
                /// Example from http://opencv.willowgarage.com/documentation/cpp/histograms.html
                //Mat hsv;
                //cvtColor(frame, hsv, CV_BGR2HSV);

                //// let's quantize the hue to 30 levels
                //// and the saturation to 32 levels
                //int hbins = 30, sbins = 32;
                //int histSize[] = {hbins, sbins};
                //// hue varies from 0 to 179, see cvtColor
                //float hranges[] = { 0, 180 };
                //// saturation varies from 0 (black-gray-white) to
                //// 255 (pure spectrum color)
                //float sranges[] = { 0, 256 };
                //const float* ranges[] = { hranges, sranges };
                //MatND hist;
                //// we compute the histogram from the 0-th and 1-st channels
                //int channels[] = {0, 1};

                //calcHist( &hsv, 1, channels, Mat(), // do not use mask
                //    hist, 2, histSize, ranges,
                //    true, // the histogram is uniform
                //    false );
                //double maxVal=0;
                //minMaxLoc(hist, 0, &maxVal, 0, 0);

                //int scale = 10;
                //Mat histImg = Mat::zeros(sbins*scale, hbins*10, CV_8UC3);

                //for( int h = 0; h < hbins; h++ )
                //    for( int s = 0; s < sbins; s++ )
                //    {
                //        float binVal = hist.at<float>(h, s);
                //        int intensity = cvRound(binVal*255/maxVal);
                //        rectangle( histImg, Rect(Point(h*scale, s*scale),
                //                     Point( (h+1)*scale - 1, (s+1)*scale - 1)),
                //                     Scalar::all(intensity),
                //                     CV_FILLED );
                //    }

                /// Example from http://docs.opencv.org/2.4.2/doc/tutorials/imgproc/histograms/histogram_calculation/histogram_calculation.html
                /// Separate the image in 3 places ( B, G and R )
                vector<Mat> bgr_planes;
                split( frame, bgr_planes );

                /// Establish the number of bins
                int histSize = 64; //256;

                /// Set the ranges ( for B,G,R) )
                float range[] = { 0, 256} ;
                const float* histRange = { range };

                bool uniform = true; bool accumulate = false;

                Mat b_hist, g_hist, r_hist;

                /// Compute the histograms:
                calcHist( &bgr_planes[0], 1, 0, Mat(), b_hist, 1, &histSize, &histRange, uniform, accumulate );
                calcHist( &bgr_planes[1], 1, 0, Mat(), g_hist, 1, &histSize, &histRange, uniform, accumulate );
                calcHist( &bgr_planes[2], 1, 0, Mat(), r_hist, 1, &histSize, &histRange, uniform, accumulate );

                // Draw the histograms for B, G and R
                //int hist_w = 512; int hist_h = 400;
                //int hist_w = 1024; int hist_h = 400;
                int hist_w = 1152; int hist_h = 400;
                int bin_w = cvRound( (double) hist_w/(histSize+1) );

                histImage = Mat( hist_h, hist_w, CV_8UC3, Scalar( 0,0,0) );

                /// Normalize the result to [ 0, histImage.rows ]
                normalize(b_hist, b_hist, 0, histImage.rows, NORM_MINMAX, -1, Mat() );
                normalize(g_hist, g_hist, 0, histImage.rows, NORM_MINMAX, -1, Mat() );
                normalize(r_hist, r_hist, 0, histImage.rows, NORM_MINMAX, -1, Mat() );

                /// Draw for each channel
                for( int i = 0; i < histSize; i++ )
                {
                    //cout << "[" << i << "] b: " << b_hist.at<float>(i-1) << "  g: " << g_hist.at<float>(i-1) << "  r: " << r_hist.at<float>(i-1) << endl;
                    rectangle( histImage, Point( bin_w*(i)+1, hist_h - cvRound(b_hist.at<float>(i)) ) ,
                                     Point( bin_w*(i)+3, hist_h ),
                                     Scalar( 255, 0, 0), 2, 8, 0  );
                    rectangle( histImage, Point( bin_w*(i)+5, hist_h - cvRound(g_hist.at<float>(i)) ) ,
                                     Point( bin_w*(i)+7, hist_h ),
                                     Scalar( 0, 255, 0), 2, 8, 0  );
                    rectangle( histImage, Point( bin_w*(i)+9, hist_h - cvRound(r_hist.at<float>(i)) ) ,
                                     Point( bin_w*(i)+11, hist_h ),
                                     Scalar( 0, 0, 255), 2, 8, 0  );
                    //line( histImage, Point( bin_w*(i-1), hist_h - cvRound(b_hist.at<float>(i-1)) ) ,
                    //                 Point( bin_w*(i), hist_h - cvRound(b_hist.at<float>(i)) ),
                    //                 Scalar( 255, 0, 0), 2, 8, 0  );
                    //line( histImage, Point( bin_w*(i-1), hist_h - cvRound(g_hist.at<float>(i-1)) ) ,
                    //                 Point( bin_w*(i), hist_h - cvRound(g_hist.at<float>(i)) ),
                    //                 Scalar( 0, 255, 0), 2, 8, 0  );
                    //line( histImage, Point( bin_w*(i-1), hist_h - cvRound(r_hist.at<float>(i-1)) ) ,
                    //                 Point( bin_w*(i), hist_h - cvRound(r_hist.at<float>(i)) ),
                    //                 Scalar( 0, 0, 255), 2, 8, 0  );
                }
            }

            Mat gray;
            cvtColor(frame,gray,CV_RGB2GRAY);
            vector<string> codes;
            Mat corners;
            imshow(window_name, frame);
            /// Show sum of image
            Scalar ch_img_sum = sum(frame);
            double img_sum = ch_img_sum[0] + ch_img_sum[1] + ch_img_sum[2];
            if (j % 4 == 0) cout << "Sum of values: " << scientific << img_sum << endl;
            if (j % COMPUTE_EVERY == 0)
            {
                /// Display
                imshow("Histogram", histImage );
                //imshow( "H-S Histogram", histImg );
            }
            char key = (char) waitKey(5); //delay N millis, usually long enough to display and capture input
            switch (key)
            {
                case 'q':
                case 'Q':
                case 27: //escape key
                    return 0;
                case ' ': //Save an image
                    sprintf(filename, "filename%.3d.jpg", n++);
                    imwrite(filename, frame);
                    cout << "Saved " << filename << endl;
                    break;
                default:
                    break;
            }
        }
        return 0;
    }

}

int main(int ac, char** av)
{

    if (ac != 2)
    {
        help(av);
        return 1;
    }
    std::string arg = av[1];
    VideoCapture capture(arg); //try to open string, this will attempt to open it as a video file
    if (!capture.isOpened()) //if this fails, try to open as a video camera, through the use of an integer param
        capture.open(atoi(arg.c_str()));
    if (!capture.isOpened())
    {
        cerr << "Failed to open a video device or video file!\n" << endl;
        help(av);
        return 1;
    }
    return process(capture);
}

video.py

#!/usr/bin/env python
# -*- encoding: UTF8 -*-

'''
Capturing live video (from a webcam) using OpenCV.
In version control on <https://gist.github.com/3773505>.

Stripped-down version of the one found on
<http://code.opencv.org/projects/opencv/repository/revisions/master/entry/samples/python2/video.py>.

Modified by Philipp Klaus, philipp.l.klaus AT web.de

Usage:
    video.py [--shotdir <shot path>] [source]

    source is an integer number for camera capture (or a movie file).

Keys:
    ESC    - exit
    SPACE  - save current frame to <shot path> directory

'''

import cv2

properties = {
        'CV_CAP_PROP_POS_MSEC' : cv2.cv.CV_CAP_PROP_POS_MSEC,
        'CV_CAP_PROP_POS_FRAMES' : cv2.cv.CV_CAP_PROP_POS_FRAMES,
        'CV_CAP_PROP_POS_AVI_RATIO' : cv2.cv.CV_CAP_PROP_POS_AVI_RATIO,
        'CV_CAP_PROP_FRAME_WIDTH' : cv2.cv.CV_CAP_PROP_FRAME_WIDTH,
        'CV_CAP_PROP_FRAME_HEIGHT' : cv2.cv.CV_CAP_PROP_FRAME_HEIGHT,
        'CV_CAP_PROP_FPS' : cv2.cv.CV_CAP_PROP_FPS,
        'CV_CAP_PROP_FOURCC' : cv2.cv.CV_CAP_PROP_FOURCC,
        'CV_CAP_PROP_FRAME_COUNT' : cv2.cv.CV_CAP_PROP_FRAME_COUNT,
        'CV_CAP_PROP_FORMAT' : cv2.cv.CV_CAP_PROP_FORMAT,
        'CV_CAP_PROP_MODE' : cv2.cv.CV_CAP_PROP_MODE,
        'CV_CAP_PROP_BRIGHTNESS' : cv2.cv.CV_CAP_PROP_BRIGHTNESS,
        'CV_CAP_PROP_CONTRAST' : cv2.cv.CV_CAP_PROP_CONTRAST,
        'CV_CAP_PROP_SATURATION' : cv2.cv.CV_CAP_PROP_SATURATION,
        'CV_CAP_PROP_HUE' : cv2.cv.CV_CAP_PROP_HUE,
        'CV_CAP_PROP_GAIN' : cv2.cv.CV_CAP_PROP_GAIN,
        'CV_CAP_PROP_EXPOSURE' : cv2.cv.CV_CAP_PROP_EXPOSURE,
        'CV_CAP_PROP_CONVERT_RGB' : cv2.cv.CV_CAP_PROP_CONVERT_RGB,
        #'CV_CAP_PROP_WHITE_BALANCE' : cv2.cv.CV_CAP_PROP_WHITE_BALANCE,
        'CV_CAP_PROP_RECTIFICATION' : cv2.cv.CV_CAP_PROP_RECTIFICATION,
        }

def create_capture(source = 0):
    '''source: <int> or '<int>|<filename>|synth [:<param_name>=<value> [:...]]'
    '''
    source = str(source).strip()
    chunks = source.split(':')
    # handle drive letter ('c:', ...)
    if len(chunks) > 1 and len(chunks[0]) == 1 and chunks[0].isalpha():
        chunks[1] = chunks[0] + ':' + chunks[1]
        del chunks[0]

    source = chunks[0]
    try: source = int(source)
    except ValueError: pass
    params = dict( s.split('=') for s in chunks[1:] )

    cap = cv2.VideoCapture(source)
    if 'size' in params:
        w, h = map(int, params['size'].split('x'))
        cap.set(cv2.cv.CV_CAP_PROP_FRAME_WIDTH, w)
        cap.set(cv2.cv.CV_CAP_PROP_FRAME_HEIGHT, h)
    if cap is None or not cap.isOpened():
        print 'Warning: unable to open video source: ', source
    for name, value in properties.items():
        print "%s: %s" % (name, cap.get(value) )
    return cap

if __name__ == '__main__':
    import sys
    import getopt

    print __doc__

    args, sources = getopt.getopt(sys.argv[1:], '', 'shotdir=')
    args = dict(args)
    shotdir = args.get('--shotdir', '.')
    if len(sources) == 0:
        sources = [ 0 ]

    cv2.namedWindow("capture 0", cv2.WINDOW_NORMAL) # instead of cv2.WINDOW_AUTOSIZE
    #cv2.namedWindow("capture 0", )
    #cv2.setWindowProperty("capture 0", cv2.CV_WND_PROP_FULLSCREEN, cv2.CV_WINDOW_FULLSCREEN)
    ### the above doesn't work but the following does ( values from
    ###  http://pyopencv.googlecode.com/svn-history/r842/trunk/src_gen/highgui_h.py ) :
    cv2.setWindowProperty("capture 0", 0, 1)
    caps = map(create_capture, sources)
    shot_idx = 0

    # Image analysis
    i = 0
    from mathtools import scoreatpercentile

    while True:
        imgs = []
        for i, cap in enumerate(caps):
            ret, img = cap.read()
            imgs.append(img)
            ### Possible image modifications:
            #img = cv2.flip(img, 1)
            #img = img/2
            if i%7 == 0:
                print("Sum over all pixels: %E  95 percentile value: %E" % (img.sum(), scoreatpercentile(img.sum(axis=2).flatten(),95) ) )
            cv2.imshow('capture %d' % i, img)
        ch = 0xFF & cv2.waitKey(1)
        if ch == 27 or ch == ord('q'):
            break
        if ch == ord(' '):
            for i, img in enumerate(imgs):
                fn = '%s/shot_%d_%03d.bmp' % (shotdir, i, shot_idx)
                cv2.imwrite(fn, img)
                print fn, 'saved'
            shot_idx += 1
    cv2.destroyAllWindows() 			

view.py

#!/usr/bin/env python
# -*- encoding: UTF8 -*-

'''
Capturing live video (from a webcam) using OpenCV's old Python interface.
Better use the more up to date Python interface cv2 like here:
<https://gist.github.com/3773505#file_video.py>

This is a stripped-down version of the one found on
<http://www.developerstation.org/2010/08/reading-data-from-webcam-on-python.html>

Modified by Philipp Klaus, philipp.l.klaus AT web.de
'''

import cv

dims = (1280, 720) # webcam dimensions

camcapture = cv.CreateCameraCapture(0)
cv.SetCaptureProperty(camcapture,cv.CV_CAP_PROP_FRAME_WIDTH, dims[0])
cv.SetCaptureProperty(camcapture,cv.CV_CAP_PROP_FRAME_HEIGHT, dims[1]);

if not camcapture:
        print "Error opening WebCAM"
        sys.exit(1)

while 1:
    frame = cv.QueryFrame(camcapture)
    if frame is None:
        break
    cv.ShowImage('Camera Image', frame)
    if 0xFF & cv.WaitKey(1) == 27:
        break