def video_file(file):
cap = hg.cvCreateFileCapture(file);
f = hg.cvQueryFrame(cap)
while f != None:
yield f
f = hg.cvQueryFrame(cap)
def main():
print "FaceIn! an OpenCV Python Face Recognition Program"
highgui.cvNamedWindow('Camera', highgui.CV_WINDOW_AUTOSIZE)
highgui.cvMoveWindow('Camera', 10, 10)
device = 0 #use first device found
capture = highgui.cvCreateCameraCapture(device)
frame = highgui.cvQueryFrame(capture)
frame_size = cv.cvGetSize(frame)
fps = 30
while 1:
frame = highgui.cvQueryFrame(capture)
detectFace(frame)
# display the frames to have a visual output
highgui.cvShowImage('Camera', frame)
# handle events
k = highgui.cvWaitKey(5)
if k % 0x100 == 27:
# user has press the ESC key, so exit
quit()
def contFrames(self,capture):
frame = cvQueryFrame(capture)
total_frames = 1
while frame <> None:
frame = cvQueryFrame(capture)
total_frames+=1
return total_frames
def process(self, videofile, progress):
progress(0, _("Extracting histogram"))
video = hg.cvCreateFileCapture(str(videofile).encode(sys.getfilesystemencoding()))
if not video:
raise Exception("Could not open video file")
histo = cv.cvCreateHist([256],cv.CV_HIST_ARRAY,[[0,256]], 1)
frame = hg.cvQueryFrame(video)
frame_gray = cv.cvCreateImage(cv.cvGetSize(frame), frame.depth, 1);
hists = []
nbframes = 0
fps = hg.cvGetCaptureProperty(video, hg.CV_CAP_PROP_FPS)
while frame :
if not progress(hg.cvGetCaptureProperty(video, hg.CV_CAP_PROP_POS_AVI_RATIO)):
break
hg.cvConvertImage(frame,frame_gray)
cv.cvCalcHist(frame_gray,histo,0,None)
h = [cv.cvGetReal1D(histo.bins,i) for i in range(255) ]
h = numpy.array(h,dtype='int32')
hists.append(h)
frame = hg.cvQueryFrame(video)
nbframes += 1
hists = numpy.array(hists)
return hists.reshape(nbframes, -1), fps
def contFrames(self, capture):
frame = cvQueryFrame(capture)
total_frames = 1
while frame <> None:
frame = cvQueryFrame(capture)
total_frames += 1
return total_frames
def apply_filter(self, image, _config):
highgui.cvQueryFrame(self.camera)
im = highgui.cvQueryFrame(self.camera)
pilwebcam_image = opencv.adaptors.Ipl2PIL(im)
pilwebcam_image.thumbnail(
(int((pilwebcam_image.size[0] / 100.0) * _config['width']),
int((pilwebcam_image.size[1] / 100.0) * _config['height'])))
## Border
from ImageDraw import Draw
drawing = Draw(pilwebcam_image)
# top line
drawing.line(((0, 0), (pilwebcam_image.size[0], 0)),
fill=_config['border_colour'])
# left line
drawing.line(((0, 0), (0, pilwebcam_image.size[1])),
fill=_config['border_colour'])
# right line
drawing.line(((pilwebcam_image.size[0] - 1, 0),
(pilwebcam_image.size[0] - 1, pilwebcam_image.size[1])),
fill=_config['border_colour'])
# bottow line
drawing.line(((0, pilwebcam_image.size[1] - 1),
(pilwebcam_image.size[0], pilwebcam_image.size[1] - 1)),
fill=_config['border_colour'])
image.paste(pilwebcam_image, (10, 10))
return image
def __init__(self,
processFunction=None,
title="Video Capture Player",
show=True,
**argd):
self.__dict__.update(**argd)
super(VideoCapturePlayer, self).__init__(**argd)
t_begin = time.time()
self.processFunction = processFunction
self.title = title
self.show = show
if self.show is True:
self.display = hg.cvNamedWindow(self.title)
try:
self.camera = hg.cvCreateCameraCapture(0)
except:
print("Couldn't open camera device, is it connected?")
hg.cvDestroyWindow(title)
raise SystemExit
# Take a frame to get props and use in testing
self.snapshot = cv.cvCloneMat(hg.cvQueryFrame(self.camera))
# check that we got an image, otherwise try again.
for i in xrange(100):
if self.snapshot is not None: break
self.snapshot = hg.cvQueryFrame(self.camera)
def get_image(camera):
testimage = highgui.cvQueryFrame(camera)
time.sleep(1)
im = highgui.cvQueryFrame(camera)
dir(im)
print "l'image est prise"
return opencv.adaptors.Ipl2PIL(im)
def apply_filter(self, image, _config): highgui.cvQueryFrame(self.camera) im = highgui.cvQueryFrame(self.camera) pilwebcam_image = opencv.adaptors.Ipl2PIL(im) pilwebcam_image.thumbnail( ( int((pilwebcam_image.size[0] / 100.0) * _config['width']), int((pilwebcam_image.size[1] / 100.0) * _config['height']) ) ) ## Border from ImageDraw import Draw drawing = Draw(pilwebcam_image) # top line drawing.line(((0,0), (pilwebcam_image.size[0], 0)), fill = _config['border_colour']) # left line drawing.line(((0,0), (0, pilwebcam_image.size[1])), fill = _config['border_colour']) # right line drawing.line(((pilwebcam_image.size[0]-1,0), (pilwebcam_image.size[0]-1, pilwebcam_image.size[1])), fill = _config['border_colour']) # bottow line drawing.line(((0, pilwebcam_image.size[1]-1), (pilwebcam_image.size[0], pilwebcam_image.size[1]-1)), fill = _config['border_colour']) image.paste(pilwebcam_image, (10,10)) return image
def video_file(file):
cap = hg.cvCreateFileCapture(file)
f = hg.cvQueryFrame(cap)
while f != None:
yield f
f = hg.cvQueryFrame(cap)
def main():
print "FaceIn! an OpenCV Python Face Recognition Program"
highgui.cvNamedWindow ('Camera', highgui.CV_WINDOW_AUTOSIZE)
highgui.cvMoveWindow ('Camera', 10, 10)
device = 0 #use first device found
capture = highgui.cvCreateCameraCapture (device)
frame = highgui.cvQueryFrame (capture)
frame_size = cv.cvGetSize (frame)
fps = 30
while 1:
frame = highgui.cvQueryFrame (capture)
detectFace(frame)
# display the frames to have a visual output
highgui.cvShowImage ('Camera', frame)
# handle events
k = highgui.cvWaitKey (5)
if k % 0x100 == 27:
# user has press the ESC key, so exit
quit()
def next(self):
tup = (hg.cvQueryFrame(self.left), hg.cvQueryFrame(self.right))
#frame_numb = hg.cvGetCaptureProperty(self.left, hg.CV_CAP_PROP_POS_FRAMES )
#if tup[0] == None or tup[1] == None or frame_numb >= self.total_frames:
if tup[0] == None or tup[1] == None:
raise StopIteration()
return tup
def next(self):
tup = (hg.cvQueryFrame(self.left), hg.cvQueryFrame(self.right))
#frame_numb = hg.cvGetCaptureProperty(self.left, hg.CV_CAP_PROP_POS_FRAMES )
#if tup[0] == None or tup[1] == None or frame_numb >= self.total_frames:
if tup[0] == None or tup[1] == None:
raise StopIteration()
return tup
def _get_image(self, params):
#while 1:
### HACK to work around opencv problem
for i in range(5):
highgui.cvQueryFrame(self._camera)
###
im = highgui.cvQueryFrame(self._camera)
#im = opencv.cvGetMat(im)
im = opencv.adaptors.Ipl2PIL(im)
# Figure out what is happening!
#im = copy.copy(im)
self._image = ImageOps.grayscale(im)
return self._image
def _get_image(self,params):
#while 1:
### HACK to work around opencv problem
for i in range(5):
highgui.cvQueryFrame(self._camera)
###
im = highgui.cvQueryFrame(self._camera)
#im = opencv.cvGetMat(im)
im = opencv.adaptors.Ipl2PIL(im)
# Figure out what is happening!
#im = copy.copy(im)
self._image = ImageOps.grayscale(im)
return self._image
def onCapture(self, event):
self.buffer = highgui.cvQueryFrame(self.camera)
self.im = highgui.cvQueryFrame(self.camera)
self.im = opencv.cvGetMat(self.im)
self.im = opencv.adaptors.Ipl2PIL(self.im)
filename = 'img' + str(self.image_counter) + '.jpg'
self.im.save('Photos/'+filename)
raw = wx.Image('Photos/'+filename)
# (308, 267) is the size of the picture after getting the
# size of the panel
bmp = raw.Rescale(308,267)
bmp = bmp.ConvertToBitmap()
wx.StaticBitmap(self.Photoshot_Panel, -1, bmp)
self.image_counter += 1
def main():
# Initialization
highgui.cvNamedWindow("Guardian", 1)
signal.signal(signal.SIGINT, handler)
# Stage
#robot = playerc.playerc_client(None, "localhost", 6665)
# Corobot
robot = playerc.playerc_client(None, "corobot-w.wifi.wpi.edu", 6665)
robot.connect()
p2dproxy = playerc.playerc_position2d(robot, 0)
p2dproxy.subscribe(playerc.PLAYERC_OPEN_MODE)
p2dproxy.get_geom()
robot.read()
while True:
image = highgui.cvQueryFrame(camera)
detectObject(image)
p2dproxy.set_cmd_vel(speed[0], 0, speed[1], 0)
draw_gui(image)
highgui.cvShowImage("Guardian", image)
if highgui.cvWaitKey(20) != -1:
break
highgui.cvDestroyWindow("Guardian")
p2dproxy.set_cmd_vel(0, 0, 0, 0)
def get_frame(self, face_rec = False): image = highgui.cvQueryFrame(self.device) face_matches = False if face_rec: grayscale = cv.cvCreateImage(cv.cvSize(640, 480), 8, 1) cv.cvCvtColor(image, grayscale, cv.CV_BGR2GRAY) storage = cv.cvCreateMemStorage(0) cv.cvClearMemStorage(storage) cv.cvEqualizeHist(grayscale, grayscale) for cascade in self.haarfiles: matches = cv.cvHaarDetectObjects(grayscale, cascade, storage, 1.2, 2, cv.CV_HAAR_DO_CANNY_PRUNING, cv.cvSize(100,100)) if matches: face_matches = True for i in matches: cv.cvRectangle(image, cv.cvPoint( int(i.x), int(i.y)), cv.cvPoint(int(i.x+i.width), int(i.y+i.height)), cv.CV_RGB(0,0,255), 2, 5, 0) image = cv.cvGetMat(image) return (image, face_matches)
def get_image(camera):
im = highgui.cvQueryFrame(camera)
# Add the line below if you need it (Ubuntu 8.04+)
#im = opencv.cvGetMat(im)
#convert Ipl image to PIL image
#print im
return opencv.adaptors.Ipl2PIL(im)
def init_camera(self):
# create the device
self._device = hg.cvCreateCameraCapture(self._index)
# Set preferred resolution
cv.SetCaptureProperty(self._device, cv.CV_CAP_PROP_FRAME_WIDTH,
self.resolution[0])
cv.SetCaptureProperty(self._device, cv.CV_CAP_PROP_FRAME_HEIGHT,
self.resolution[1])
# and get frame to check if it's ok
frame = hg.cvQueryFrame(self._device)
# Just set the resolution to the frame we just got, but don't use
# self.resolution for that as that would cause an infinite recursion
# with self.init_camera (but slowly as we'd have to always get a
# frame).
self._resolution = (int(frame.width), int(frame.height))
# get fps
self.fps = cv.GetCaptureProperty(self._device, cv.CV_CAP_PROP_FPS)
if self.fps <= 0:
self.fps = 1 / 30.
if not self.stopped:
self.start()
def onIdle(self, event):
"""
Event to grab and display a frame from the camera. (internal use).
"""
if self.cap == None: #Should be cvCameraCapture instance.
#unbind the idle instance, change to click.
highgui.cvReleaseCapture(self.cap) #release the old instance and
self.cap = highgui.cvCreateCameraCapture(
self.camera) #try new one.
self.displayError(self.errorBitmap, (128, 128))
raise CameraError('Unable to open camera, retrying....')
event.Skip()
try:
img = highgui.cvQueryFrame(self.cap)
except cv2.error as e:
raise CameraError('Error when querying for frame: {0}'.format(e))
self._error = 0 #worked successfully
img = opencv.cvGetMat(img)
cv.cvCvtColor(img, img, cv.CV_BGR2RGB)
if conf.as_bool(conf.config['webcam']['cropBars']):
#Draw cropping region
cv.cvRectangle(img, (80, -1), (560, 480), (205.0, 0.0, 0.0, 0.0),
2)
self.displayImage(img)
event.RequestMore()
def getData(): frame = highgui.cvQueryFrame(capture) if frame is None: return None cv.cvSplit(frame, b_img, g_img, r_img, None) cv.cvInRangeS(r_img, 150, 255, r_img) cv.cvInRangeS(g_img, 0, 100, g_img) cv.cvInRangeS(b_img, 0, 100, b_img) cv.cvAnd(r_img, g_img, laser_img) cv.cvAnd(laser_img, b_img, laser_img) cv.cvErode(laser_img,laser_img) #,0,2) cv.cvDilate(laser_img,laser_img) c_count, contours = cv.cvFindContours (laser_img, storage, cv.sizeof_CvContour, cv.CV_RETR_LIST, cv.CV_CHAIN_APPROX_NONE, cv.cvPoint (0,0)) if c_count: return returnEllipses(contours) else: return None
def main():
# Initialization
highgui.cvNamedWindow("Guardian", 1)
signal.signal(signal.SIGINT, handler)
# Stage
#robot = playerc.playerc_client(None, "localhost", 6665)
# Corobot
robot = playerc.playerc_client(None, "corobot-w.wifi.wpi.edu", 6665)
robot.connect()
p2dproxy = playerc.playerc_position2d(robot, 0)
p2dproxy.subscribe(playerc.PLAYERC_OPEN_MODE)
p2dproxy.get_geom()
robot.read()
while True:
image = highgui.cvQueryFrame(camera)
detectObject(image)
p2dproxy.set_cmd_vel(speed[0], 0, speed[1], 0)
draw_gui(image)
highgui.cvShowImage("Guardian", image)
if highgui.cvWaitKey(20) != -1:
break
highgui.cvDestroyWindow("Guardian")
p2dproxy.set_cmd_vel(0, 0, 0, 0)
def save(self):
print "Save"
img = highgui.cvQueryFrame(self.cap)
img = opencv.cvGetMat(img)
#No BGR => RGB conversion needed for PIL output.
pil = opencv.adaptors.Ipl2PIL(img) #convert to a PIL
pil.save('out.jpg')
def get_image():
img = highgui.cvQueryFrame(camera)
# Add the line below if you need it (Ubuntu 8.04+)
#im = opencv.cvGetMat(im)
#convert Ipl image to PIL image
print img
return opencv.adaptors.Ipl2PIL(img)
def get_image(self,surface=None,*argv,**argd):
"""
Since we are using opencv there are some differences here.
This function will return a cvmat by default (the quickest route from camera to your code)
Or if pygame was specified a 3dpixel array
- this can be blitted directly to a pygame surface
- or can be converted to a surface array and returned to your pygame code.
"""
if self.imageType == "pygame":
try:
surfarray.blit_array(surface,conversionUtils.cv2SurfArray(hg.cvQueryFrame(self.capture)))
return surface
except:
return surfarray.make_surface(conversionUtils.cv2SurfArray(hg.cvQueryFrame(self.capture))).convert()
return hg.cvQueryFrame(self.capture)
def init_camera(self):
# create the device
self._device = hg.cvCreateCameraCapture(self._index)
# Set preferred resolution
cv.SetCaptureProperty(self._device, cv.CV_CAP_PROP_FRAME_WIDTH,
self.resolution[0])
cv.SetCaptureProperty(self._device, cv.CV_CAP_PROP_FRAME_HEIGHT,
self.resolution[1])
# and get frame to check if it's ok
frame = hg.cvQueryFrame(self._device)
# Just set the resolution to the frame we just got, but don't use
# self.resolution for that as that would cause an infinite recursion
# with self.init_camera (but slowly as we'd have to always get a
# frame).
self._resolution = (int(frame.width), int(frame.height))
#get fps
self.fps = cv.GetCaptureProperty(self._device, cv.CV_CAP_PROP_FPS)
if self.fps <= 0:
self.fps = 1 / 30.
if not self.stopped:
self.start()
def init_camera(self):
# consts have changed locations between versions 2 and 3
if self.opencvMajorVersion in (3, 4):
PROPERTY_WIDTH = cv2.CAP_PROP_FRAME_WIDTH
PROPERTY_HEIGHT = cv2.CAP_PROP_FRAME_HEIGHT
PROPERTY_FPS = cv2.CAP_PROP_FPS
elif self.opencvMajorVersion == 2:
PROPERTY_WIDTH = cv2.cv.CV_CAP_PROP_FRAME_WIDTH
PROPERTY_HEIGHT = cv2.cv.CV_CAP_PROP_FRAME_HEIGHT
PROPERTY_FPS = cv2.cv.CV_CAP_PROP_FPS
elif self.opencvMajorVersion == 1:
PROPERTY_WIDTH = cv.CV_CAP_PROP_FRAME_WIDTH
PROPERTY_HEIGHT = cv.CV_CAP_PROP_FRAME_HEIGHT
PROPERTY_FPS = cv.CV_CAP_PROP_FPS
Logger.debug('Using opencv ver.' + str(self.opencvMajorVersion))
if self.opencvMajorVersion == 1:
# create the device
self._device = hg.cvCreateCameraCapture(self._index)
# Set preferred resolution
cv.SetCaptureProperty(self._device, cv.CV_CAP_PROP_FRAME_WIDTH,
self.resolution[0])
cv.SetCaptureProperty(self._device, cv.CV_CAP_PROP_FRAME_HEIGHT,
self.resolution[1])
# and get frame to check if it's ok
frame = hg.cvQueryFrame(self._device)
# Just set the resolution to the frame we just got, but don't use
# self.resolution for that as that would cause an infinite
# recursion with self.init_camera (but slowly as we'd have to
# always get a frame).
self._resolution = (int(frame.width), int(frame.height))
# get fps
self.fps = cv.GetCaptureProperty(self._device, cv.CV_CAP_PROP_FPS)
elif self.opencvMajorVersion in (2, 3, 4):
# create the device
self._device = cv2.VideoCapture(self._index)
# Set preferred resolution
self._device.set(PROPERTY_WIDTH,
self.resolution[0])
self._device.set(PROPERTY_HEIGHT,
self.resolution[1])
# and get frame to check if it's ok
ret, frame = self._device.read()
# source:
# http://stackoverflow.com/questions/32468371/video-capture-propid-parameters-in-opencv # noqa
self._resolution = (int(frame.shape[1]), int(frame.shape[0]))
# get fps
self.fps = self._device.get(PROPERTY_FPS)
if self.fps == 0 or self.fps == 1:
self.fps = 1.0 / 30
elif self.fps > 1:
self.fps = 1.0 / self.fps
if not self.stopped:
self.start()
def init_camera(self):
# consts have changed locations between versions 2 and 3
if self.opencvMajorVersion in (3, 4):
PROPERTY_WIDTH = cv2.CAP_PROP_FRAME_WIDTH
PROPERTY_HEIGHT = cv2.CAP_PROP_FRAME_HEIGHT
PROPERTY_FPS = cv2.CAP_PROP_FPS
elif self.opencvMajorVersion == 2:
PROPERTY_WIDTH = cv2.cv.CV_CAP_PROP_FRAME_WIDTH
PROPERTY_HEIGHT = cv2.cv.CV_CAP_PROP_FRAME_HEIGHT
PROPERTY_FPS = cv2.cv.CV_CAP_PROP_FPS
elif self.opencvMajorVersion == 1:
PROPERTY_WIDTH = cv.CV_CAP_PROP_FRAME_WIDTH
PROPERTY_HEIGHT = cv.CV_CAP_PROP_FRAME_HEIGHT
PROPERTY_FPS = cv.CV_CAP_PROP_FPS
Logger.debug('Using opencv ver.' + str(self.opencvMajorVersion))
if self.opencvMajorVersion == 1:
# create the device
self._device = hg.cvCreateCameraCapture(self._index)
# Set preferred resolution
cv.SetCaptureProperty(self._device, cv.CV_CAP_PROP_FRAME_WIDTH,
self.resolution[0])
cv.SetCaptureProperty(self._device, cv.CV_CAP_PROP_FRAME_HEIGHT,
self.resolution[1])
# and get frame to check if it's ok
frame = hg.cvQueryFrame(self._device)
# Just set the resolution to the frame we just got, but don't use
# self.resolution for that as that would cause an infinite
# recursion with self.init_camera (but slowly as we'd have to
# always get a frame).
self._resolution = (int(frame.width), int(frame.height))
# get fps
self.fps = cv.GetCaptureProperty(self._device, cv.CV_CAP_PROP_FPS)
elif self.opencvMajorVersion in (2, 3, 4):
# create the device
self._device = cv2.VideoCapture(self._index)
# Set preferred resolution
self._device.set(PROPERTY_WIDTH,
self.resolution[0])
self._device.set(PROPERTY_HEIGHT,
self.resolution[1])
# and get frame to check if it's ok
ret, frame = self._device.read()
# source:
# http://stackoverflow.com/questions/32468371/video-capture-propid-parameters-in-opencv # noqa
self._resolution = (int(frame.shape[1]), int(frame.shape[0]))
# get fps
self.fps = self._device.get(PROPERTY_FPS)
if self.fps == 0 or self.fps == 1:
self.fps = 1.0 / 30
elif self.fps > 1:
self.fps = 1.0 / self.fps
if not self.stopped:
self.start()
def getImg():
ImgOCV = highgui.cvQueryFrame(camera)
ImgPIL = adaptors.Ipl2PIL(ImgOCV)
ImgPIL = ImgPIL.filter(GAUSSIAN)
ImgRAW = ImgPIL.convert("L").tostring()
ImgArray = numpy.frombuffer(ImgRAW, dtype=numpy.uint8)
ImgArray = ImgArray.reshape(ImgPIL.size)
return ImgArray
def onNextFrame(self, evt):
frame = gui.cvQueryFrame(self.capture)
if frame:
cv.cvCvtColor(frame, frame, cv.CV_BGR2RGB)
self.bmp = wx.BitmapFromBuffer(frame.width, frame.height, frame.imageData)
self.Refresh()
evt.Skip()
def get_image():
try:
im = highgui.cvQueryFrame(camera)
return opencv.adaptors.Ipl2PIL(im)
except Exception:
print "Error: camera disconnected"
sys.exit()
raise SystemExit
def get_image(camera): """ Grabs a frame from the camera and returns it as a PIL image """ im = highgui.cvQueryFrame(camera) im = opencv.cvGetMat(im) return opencv.adaptors.Ipl2PIL(im) #convert Ipl image to PIL image
def get_image(self):
im=highgui.cvQueryFrame(self.camera)
image=opencv.adaptors.Ipl2PIL(im)
workimage=os.path.join(self.imgdir,self.workimage)
imagename=os.path.join(self.imgdir,self.imagetemplate % self.index)
image.save(os.path.join(self.imgdir,self.workimage))
os.rename(workimage,imagename)
self.index+=1
self.write_index()
def snapshot():
cam = highgui.cvCreateCameraCapture(1)
img = highgui.cvQueryFrame(cam)
pilImage = opencv.adaptors.Ipl2PIL(img)
highgui.cvReleaseCapture(cam)
return pilImage
def onNextFrame(self, evt):
frame = gui.cvQueryFrame(self.capture)
if frame:
cv.cvCvtColor(frame, frame, cv.CV_BGR2RGB)
self.bmp = wx.BitmapFromBuffer(frame.width, frame.height,
frame.imageData)
self.Refresh()
evt.Skip()
def display_picture(self): imagecapture = highgui.cvQueryFrame(self.camera) self.pilimage = opencv.adaptors.Ipl2PIL(imagecapture) miniimage = self.pilimage.resize((320,240)) self.image = ImageTk.PhotoImage(miniimage, master=self.frame) self.imagecanvas.create_image(0,0,image=self.image,anchor="nw") self.imagecanvas.update() time.sleep(0.1) self.display_picture()
def snapshot(arg):
time.sleep(1.0)
camera = highgui.cvCreateCameraCapture(0)
im = highgui.cvQueryFrame(camera)
# Add the line below if you need it (Ubuntu 8.04+)
im = opencv.cvGetMat(im)
#convert Ipl image to PIL image
im = opencv.adaptors.Ipl2PIL(im)
im.save('test.png',"PNG")
def main(argv):
# Frames per second
fps = 20
tux_pos = 5
tux_pos_min = 0.0
tux_pos_max = 9.0
try:
opts, args = getopt.getopt(argv, "fps", ["framerate=",])
except getopt.GetoptError:
sys.exit(2)
for opt, arg in opts:
if opt in ("-fps", "--framerate"):
fps = arg
camera = highgui.cvCreateCameraCapture(0)
while True:
highgui.cvNamedWindow('Camera', 1)
im = highgui.cvQueryFrame(camera)
if im is None:
break
# mirror
opencv.cv.cvFlip(im, None, 1)
# positions = face.detect(im, 'haarcascade_data/haarcascade_profileface.xml')
positions = face.detect(im, 'haarcascade_data/haarcascade_frontalface_alt2.xml')
# if not positions:
# positions = face.detect(im, 'haarcascade_data/haarcascade_frontalface_alt2.xml')
# display webcam image
highgui.cvShowImage('Camera', im)
# Division of the screen to count as "walking" motion to trigger tux
image_size = opencv.cvGetSize(im)
motion_block = image_size.width / 9
if positions:
mp = None
for position in positions:
if not mp or mp['width'] > position['width']:
mp = position
pos = (mp['x'] + (mp['width'] / 2)) / motion_block
print "tux pos: %f" % tux_pos
print "pos: %f" % pos
if pos != tux_pos:
if tux_pos > pos:
move_tux_right(tux_pos - pos)
elif tux_pos < pos:
move_tux_left(pos - tux_pos)
tux_pos = pos
if highgui.cvWaitKey(fps) >= 0:
highgui.cvDestroyWindow('Camera')
sys.exit(0)
def getFilter(frameWidht, frameHeight):
cvNamedWindow("Filtred")
cvCreateTrackbar("hmax", "Filtred", getHlsFilter('hmax'), 180, trackBarChangeHmax)
cvCreateTrackbar("hmin", "Filtred", getHlsFilter('hmin'), 180, trackBarChangeHmin)
#cvCreateTrackbar("lmax", "Filtred", hlsFilter['lmax'], 255, trackBarChangeLmax)
#cvCreateTrackbar("lmin", "Filtred", hlsFilter['lmin'], 255, trackBarChangeLmin)
cvCreateTrackbar("smax", "Filtred", getHlsFilter('smax'), 255, trackBarChangeSmax)
cvCreateTrackbar("smin", "Filtred", getHlsFilter('smin'), 255, trackBarChangeSmin)
cvSetMouseCallback("Filtred", mouseClick, None)
frame = cvCreateImage(cvSize(frameWidth, frameHeight), IPL_DEPTH_8U, 3)
hlsFrame = cvCreateImage(cvSize(frameWidth, frameHeight), IPL_DEPTH_8U, 3)
filtredFrame = cvCreateImage(cvSize(frameWidth, frameHeight), IPL_DEPTH_8U, 3)
mask = cvCreateImage(cvSize(frameWidth, frameHeight), IPL_DEPTH_8U, 1)
hFrame = cvCreateImage(cvSize(frameWidth, frameHeight), IPL_DEPTH_8U, 1)
lFrame = cvCreateImage(cvSize(frameWidth, frameHeight), IPL_DEPTH_8U, 1)
sFrame = cvCreateImage(cvSize(frameWidth, frameHeight), IPL_DEPTH_8U, 1)
ThHFrame = cvCreateImage(cvSize(frameWidth, frameHeight), IPL_DEPTH_8U, 1)
ThLFrame = cvCreateImage(cvSize(frameWidth, frameHeight), IPL_DEPTH_8U, 1)
ThSFrame = cvCreateImage(cvSize(frameWidth, frameHeight), IPL_DEPTH_8U, 1)
key = -1
while key == -1:
if not cvGrabFrame(CAM):
print "Could not grab a frame"
exit
frame = cvQueryFrame(CAM)
cvCvtColor(frame, hlsFrame, CV_BGR2HLS)
cvSplit(hlsFrame, hFrame, lFrame, sFrame, None)
pixelInRange(hFrame, getHlsFilter('hmin'), getHlsFilter('hmax'), 0, 180, ThHFrame)
#pixelInRange(lFrame, getHlsFilter('lmin'), getHlsFilter('lmax'), 0, 255, ThLFrame)
pixelInRange(sFrame, getHlsFilter('smin'), getHlsFilter('smax'), 0, 255, ThSFrame)
cvSetZero(mask)
cvAnd(ThHFrame, ThSFrame, mask)
cvSetZero(filtredFrame)
cvCopy(frame, filtredFrame, mask)
cvShowImage("Filtred", filtredFrame)
key = cvWaitKey(10)
if key == 'r':
key = -1
resetHlsFilter()
cvDestroyWindow("Filtred")
def _update(self, dt):
if self.stopped:
return
try:
frame = hg.cvQueryFrame(self._device)
self._format = 'bgr'
self._buffer = frame.imageData
self._copy_to_gpu()
except:
Logger.exception('OpenCV: Couldn\'t get image from Camera')
def onShot(self, event):
frame = gui.cvQueryFrame(self.capture)
self.playTimer.Stop()
gui.cvSaveImage("foo.png", frame)
self.hasPicture = True
self.shotbutton.Hide()
self.retrybutton.Show()
self.Layout()
event.Skip()
def CaptureVGA(self):
im = highgui.cvQueryFrame(camera)
highgui.cvWriteFrame(self.videowriter, im) # 录制视频，写入文件
# convert Ipl image to PIL image
im = opencv.adaptors.Ipl2PIL(im)
im = im.convert('RGB').tostring('jpeg', 'RGB') # 转换格式，jpeg
self.image.loadFromData(QByteArray(im)) # 格式支持QT，直接加载
# im.save('3.jpg')#opencv 返回的是Ipl 格式，QT无法直接显示。不知道如何转换格式，采用保存、读取的方式。
# pic.load('3.jpg')
self.piclabel.setPixmap(QPixmap.fromImage(self.image)) # 一帧一帧的显示
def update(self):
if self.stopped:
return
try:
frame = hg.cvQueryFrame(self._device)
self._format = GL_BGR_EXT
self._buffer = frame.imageData
self._copy_to_gpu()
except:
pymt.pymt_logger.exception('OpenCV: Couldn\'t get image from Camera')
def onShot(self, event):
frame = gui.cvQueryFrame(self.capture)
self.playTimer.Stop()
gui.cvSaveImage("foo.png", frame)
self.hasPicture = True
self.shotbutton.Hide()
self.retrybutton.Show()
self.Layout()
event.Skip()
def _detect(image):
""" Detects faces on `image`
Parameters:
@image: image file path
Returns:
[((x1, y1), (x2, y2)), ...] List of coordenates for top-left
and bottom-right corner
"""
# the OpenCV API says this function is obsolete, but we can't
# cast the output of cvLoad to a HaarClassifierCascade, so use
# this anyways the size parameter is ignored
capture = cvCreateFileCapture(image)
if not capture:
return []
frame = cvQueryFrame(capture)
if not frame:
return []
img = cvCreateImage(cvSize(frame.width, frame.height), IPL_DEPTH_8U,
frame.nChannels)
cvCopy(frame, img)
# allocate temporary images
gray = cvCreateImage((img.width, img.height), COPY_DEPTH, COPY_CHANNELS)
width, height = (cvRound(img.width / IMAGE_SCALE),
cvRound(img.height / IMAGE_SCALE))
small_img = cvCreateImage((width, height), COPY_DEPTH, COPY_CHANNELS)
# convert color input image to grayscale
cvCvtColor(img, gray, CV_BGR2GRAY)
# scale input image for faster processing
cvResize(gray, small_img, CV_INTER_LINEAR)
cvEqualizeHist(small_img, small_img)
cvClearMemStorage(STORAGE)
coords = []
for haar_file in CASCADES:
cascade = cvLoadHaarClassifierCascade(haar_file, cvSize(1, 1))
if cascade:
faces = cvHaarDetectObjects(small_img, cascade, STORAGE,
HAAR_SCALE, MIN_NEIGHBORS, HAAR_FLAGS,
MIN_SIZE) or []
for face_rect in faces:
# the input to cvHaarDetectObjects was resized, so scale the
# bounding box of each face and convert it to two CvPoints
x, y = face_rect.x, face_rect.y
pt1 = (int(x * IMAGE_SCALE), int(y * IMAGE_SCALE))
pt2 = (int((x + face_rect.width) * IMAGE_SCALE),
int((y + face_rect.height) * IMAGE_SCALE))
coords.append((pt1, pt2))
return coords
def onRetry(self, event):
frame = gui.cvQueryFrame(self.capture)
cv.cvCvtColor(frame, frame, cv.CV_BGR2RGB)
self.bmp = wx.BitmapFromBuffer(frame.width, frame.height,
frame.imageData)
self.startTimer()
self.shotbutton.Show()
self.retrybutton.Hide()
self.hasPicture = False
self.Layout()
event.Skip()
def seek_onChange(pos, capture, windowName):
'''Callback for the seek trackbar'''
print 'Seeking to frame: %d' % pos
# Set the pointer to frame pos and grab the frame
highgui.cvSetCaptureProperty(capture, highgui.CV_CAP_PROP_POS_FRAMES,
pos * 3600 - 1)
frame = highgui.cvQueryFrame(capture)
# Display the frame on the window
highgui.cvShowImage(windowName, frame)
def update(self):
if self.stopped:
return
try:
frame = hg.cvQueryFrame(self._device)
self._format = GL_BGR_EXT
self._buffer = frame.imageData
self._copy_to_gpu()
except:
pymt.pymt_logger.exception(
'OpenCV: Couldn\'t get image from Camera')
def get_image(self, surface=None, *argv, **argd):
"""
Since we are using opencv there are some differences here.
This function will return a cvmat by default (the quickest route from camera to your code)
Or if pygame was specified a 3dpixel array
- this can be blitted directly to a pygame surface
- or can be converted to a surface array and returned to your pygame code.
"""
if self.imageType == "pygame":
try:
surfarray.blit_array(
surface,
conversionUtils.cv2SurfArray(hg.cvQueryFrame(
self.capture)))
return surface
except:
return surfarray.make_surface(
conversionUtils.cv2SurfArray(hg.cvQueryFrame(
self.capture))).convert()
return hg.cvQueryFrame(self.capture)
def get_image(new_size=None, mode="L"):
''' inspired by http://www.jperla.com/blog/2007/09/26/capturing-frames-from-a-webcam-on-linux '''
ipl_im = highgui.cvQueryFrame(camera)
# Add the line below if you need it (Ubuntu 8.04+)
#ipl_im = opencv.cvGetMat(ipl_im)
#convert Ipl image to PIL image
im = opencv.adaptors.Ipl2PIL(ipl_im)
im = im.convert(mode)
if new_size:
return array(im.resize(new_size))
return array(im)
def capture_webcam():
"""
Grab a frame from the first detected webcam using OpenCV.
"""
import opencv
from opencv import highgui
camera = highgui.cvCreateCameraCapture(0)
cv_img = highgui.cvQueryFrame(camera)
img = opencv.adaptors.Ipl2PIL(cv_img)
highgui.cvReleaseCapture(camera)
return img
def __init__(self, src="", time=None, flipped=False, thresh=128, thmode=0):
self.src = src
self.time = time
self.bthresh = thresh
self.bthreshmode = thmode
if self.time:
hg.cvSetCaptureProperty(self.src, hg.CV_CAP_PROP_POS_FRAMES, self.time)
self.iplimage = hg.cvQueryFrame(self.src)
if flipped:
opencv.cvFlip(self.iplimage, None, 1)
self.width = self.iplimage.width
self.height = self.iplimage.height
def run(self):
"""
Consume images from the webcam at 25fps.
If visualize is True, show the result in the screen.
"""
if self.visualize:
highgui.cvNamedWindow('DucksboardFace')
while self.running:
self.image = highgui.cvQueryFrame(self.camera)
if self.visualize:
highgui.cvShowImage('DucksboardFace', self.image)
highgui.cvWaitKey(1000 / 25)
def save(self, record=-1):
"""
Captures, crops, and saves a webcam frame. Pass an explicit record number
otherwise writes to next in sequence. Returns zero-padded photo reference ID.
"""
img = highgui.cvQueryFrame(self.cap)
img = opencv.cvGetMat(img)
#No BGR => RGB conversion needed for PIL output.
pil = opencv.adaptors.Ipl2PIL(img) #convert to a PIL
#~ pil = pil.crop((80, 0, 560, 480))
#~ pil.show()
return self.store.savePIL(pil, record)
def init_camera(self):
# create the device
self._device = hg.cvCreateCameraCapture(self._index)
try:
# try first to set resolution
cv.hg(self._device, cv.CV_CAP_PROP_FRAME_WIDTH,
self.resolution[0])
cv.hg(self._device, cv.CV_CAP_PROP_FRAME_HEIGHT,
self.resolution[1])
# and get frame to check if it's ok
frame = hg.cvQueryFrame(self._device)
if not int(frame.width) == self.resolution[0]:
raise Exception('OpenCV: Resolution not supported')
except:
# error while setting resolution
# fallback on default one
w = int(hg.cvGetCaptureProperty(self._device,
hg.CV_CAP_PROP_FRAME_WIDTH))
h = int(hg.cvGetCaptureProperty(self._device,
hg.CV_CAP_PROP_FRAME_HEIGHT))
frame = hg.cvQueryFrame(self._device)
Logger.warning(
'OpenCV: Camera resolution %s impossible! Defaulting to %s.' %
(self.resolution, (w, h)))
# set resolution to default one
self._resolution = (w, h)
# create texture !
self._texture = Texture.create(*self._resolution)
self._texture.flip_vertical()
self.dispatch('on_load')
if not self.stopped:
self.start()
def get_image(self):
"""Return an image in PIL (Python Imaging Library) format."""
im = None
while not im:
im = highgui.cvQueryFrame(self.camera)
arr = numpy.asarray(cv.adaptors.Ipl2PIL(im)).copy()
arr[:, :, 2] = 0
if self.blur_factor:
arr = ndimage.gaussian_filter(arr, self.blur_factor)
pil = Image.fromarray(arr).convert('L')
return pil, pil.mode
