More interesting example code for OpenCV:
Webcam Capture with OpenCV's Python Interface cv2 and with its C++ interface
video | |
*.pyc |
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 |
# -*- 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 |
#!/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)) |
/* | |
* 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); | |
} |
#!/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() |
#!/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 |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment