def main(): scale_amount = (200, 150) cam = Camera(0) prev = cam.get_image().resize(scale_amount[0], scale_amount[1]) time.sleep(0.5) t = 0.5 buffer = 20 count = 0 while True: current = cam.get_image() current = current.resize(scale_amount[0], scale_amount[1]) if count < buffer: count = count + 1 else: fs = current.find(Motion, prev, window=15, method="BM") length_of_fs = len(fs) if fs: dx = 0 dy = 0 for f in fs: dx = dx + f.dx dy = dy + f.dy dx = dx / length_of_fs dy = dy / length_of_fs motion_str = movement_check(dx, dy, t) current.dl().text(motion_str, (10, 10)) prev = current time.sleep(0.01) current.show()
class ColorSegmentationWindow(Window): def __init__(self): super(ColorSegmentationWindow, self).__init__('Color Segmentation Example') self.cam = Camera() self.template_img = None self.point1 = (0, 0) self.point2 = (0, 0) self.mosue_down = False def on_mouse(self, event, x, y, mouse_key, data=None): """ Callback for mouse events event - int - see cv2.EVENT_* constants x, y - int, int - position of the cursor mouse_key - int - mouse key """ if event == cv2.EVENT_LBUTTONDOWN: self.point1 = (x, y) self.point2 = (x, y) self.mosue_down = True elif event == cv2.EVENT_MOUSEMOVE: if self.mosue_down == True: self.point2 = (x, y) elif event == cv2.EVENT_LBUTTONUP: self.mosue_down = False self.point2 = (x, y) x1, y1, w, h = points_to_roi(self.point1, self.point2) if w > 0 and h > 0: self.template_img = self.cam.get_image().crop(x1, y1, w, h) print "Mode:", "Detecting features..." def on_key(self, key): if key == 32: # Space bar to select template self.template_img = None print "Mode:", "Selecting template..." def on_update(self): """ Callback for periodic update. """ img = self.cam.get_image() if self.mosue_down: img.dl().rectangle_to_pts(self.point1, self.point2, color=Color.RED) img = img.apply_layers() elif self.template_img is not None: # Detect and draw key points img = img.draw_keypoint_matches(self.template_img) img = img.apply_layers() self.show(img)
class BallTrackWindow(Window): def __init__(self): super(BallTrackWindow, self).__init__('Ball Track Example') self.cam = Camera() # initialize the camera self.normal = True # mode toggle for segment detection def on_key(self, key): if key == 32: # Space bar to switch between modes self.normal = not self.normal print "Display Mode:", "Normal" if self.normal else "Segmented" def on_update(self): """ Callback for periodic update. """ img = self.cam.get_image().flip_horizontal() # grab image from camera dist = img.color_distance(Color.BLACK).dilate(2) # try to separate colors in image segmented = dist.stretch(200, 255) # really try to push out white colors if not self.normal: img = segmented blobs = segmented.find_blobs() # search the image for blob objects if blobs: # if blobs are found circles = blobs.filter([b.is_circle(0.2) for b in blobs]) # filter out only circle shaped blobs if circles: # draw the circle on the main image img.dl().circle((circles[-1].x, circles[-1].y), circles[-1].radius(), Color.BLUE, width=3) self.show(img.apply_layers())
class Webcam(QtGui.QMainWindow): def __init__(self, parent=None): QtGui.QWidget.__init__(self,parent) self.MainWindow = Ui_Dialog() self.MainWindow.setupUi(self) self.webcam = Camera(0, {"width": 640, "height": 480}) self.timer = QtCore.QTimer() self.connect(self.timer, QtCore.SIGNAL('timeout()'), self.show_frame) self.timer.start(1) def show_frame(self): ipl_image = self.webcam.get_image() ipl_image.dl().circle((150, 75), 50, Color.RED, filled=True) data = ipl_image.tostring() image = QtGui.QImage(data, ipl_image.width, ipl_image.height, 3 * ipl_image.width, QtGui.QImage.Format_RGB888) pixmap = QtGui.QPixmap() pixmap.convertFromImage(image.rgbSwapped()) self.MainWindow.label.setPixmap(pixmap)
analog_pin_1 = board.get_pin('a:1:i') # Use pin 1 as input analog_pin_2 = board.get_pin('a:2:i') # Use pin 2 as input button_13 = board.get_pin('d:13:i') # Use pin 13 for button input it = util.Iterator(board) # Initalize the pin monitor for the Arduino it.start() # Start the pin monitor loop multiplier = 400.0 # A value to adjust the edge threshold by cam = Camera() # Initalize the camera while True: t1 = analog_pin_1.read() # Read the value from pin 1 t2 = analog_pin_2.read() # Read the value from pin 2 b13 = button_13.read() # Read if the button has been pressed. if not t1: # Set a default if no value read t1 = 50 else: t1 *= multiplier if not t2: # Set a default if no value read t2 = 100 else: t2 *= multiplier print "t1 " + str(t1) + ", t2 " + str(t2) + ", b13 " + str(b13) img = cam.get_image().flip_horizontal() edged_img = img.edges(int(t1), int(t2)).invert().smooth() edged_img.show() time.sleep(0.1)
from simplecv.api import Camera c = Camera() while True: img = c.get_image() split = img.split(2, 1) left = split[0][0] mirrorred = img.blit(left.flip_horizontal(), (left.width + 1, 0)) mirrorred.show()
#!/usr/bin/python """ This program uses a Color model to try and do segmentation based on color """ print __doc__ import time from simplecv.color_model import ColorModel from simplecv.api import Camera c = Camera() i = c.get_image() cm = ColorModel(i) i.show() t = int(time.time()) ticks = 0 while True: cm.threshold(c.get_image()).show() time.sleep(0.01) ticks = ticks + 1 if int(time.time()) > t: print str(ticks) + " fps" ticks = 0 t = int(time.time())
#!/usr/bin/python """ This program is basically the hello world in SimpleCV all it does is grab an image from the camera and display it """ print __doc__ from simplecv.api import Camera cam = Camera() while True: img = cam.get_image() img.show()
#!/usr/bin/python from simplecv.api import Camera from simplecv.stream import VideoStream import time c = Camera() vs = VideoStream("foo.avi") for i in range(0, 500): c.get_image().edges().invert().save(vs) time.sleep(0.05)
#!/usr/bin/python """ This example just takes an image, finds the edges, and draws them the threshold is used for the edge detection, if you adjust the max_threshold and threshold_step values and run the program you will see it change over time """ print __doc__ from simplecv.api import Camera, Color cam = Camera() # initialize the camera max_threshold = 255 # this is used for the edge detection threshold_step = 0.5 # this is the amount to adjust the threshold by each time the display is updated threshold = max_threshold while True: image = cam.get_image() # get image (or frame) from camera flipped_image = image.flip_horizontal() # flip it so it looks mirrored edged_image = flipped_image.edges(threshold) # get the image edges # This just automatically cycles through threshold levels if threshold <= 0: threshold = max_threshold else: threshold -= 0.5 edged_image.dl().text("Current Edge Threshold:" + str(threshold), (10, 20), color=Color.GREEN) edged_image.show()
#!/usr/bin/python """ This program does basic motion blurring. It averages the number of maxframes that are set using some basic image math """ print __doc__ from operator import add from simplecv.api import Camera cam = Camera() # initialize the camera # the number of frames maxframes = 3 frames = [] frames.append(cam.get_image()) frames[0].show() while True: frames.append(cam.get_image()) #add the next frame to the end of the set if len(frames) > maxframes: frames.pop(0) # remove the earliest frame if we're at max pic = reduce(add, [i / float(len(frames)) for i in frames]) # add the frames in the array, weighted by 1 / number of frames pic.show()
""" This program super imposes the camera onto the television in the picture """ print __doc__ from simplecv.api import Camera, Image tv_original = Image("family_watching_television_1958.jpg", sample=True) tv_coordinates = [(353, 379), (433, 380), (432, 448), (354, 446)] tv_mask = Image(tv_original.size_tuple).invert().warp(tv_coordinates) tv = tv_original - tv_mask c = Camera() while True: bwimage = c.get_image().to_gray().resize(tv.width, tv.height).to_bgr() on_tv = tv + bwimage.warp(tv_coordinates) on_tv.show()
from simplecv.api import Camera c = Camera() while True: img = c.get_image() split = img.split(2, 1) left = split[0][0] mirrorred = img.blit(left.flip_horizontal(),(left.width + 1, 0)) mirrorred.show()
from simplecv.api import Camera from simplecv.color import Color from simplecv.segmentation.mog_segmentation import MOGSegmentation mog = MOGSegmentation(history=200, mixtures=5, bg_ratio=0.3, noise_sigma=16, learning_rate=0.3) cam = Camera() while True: mog.add_image(cam.get_image()) segmented_image = mog.get_segmented_image() blobs = mog.get_segmented_blobs() for blob in blobs: segmented_image.dl().circle((blob.x, blob.y), 10, Color.RED) segmented_image.show()
#!/usr/bin/python """ This program basically simulates some kind of 80's music video. """ print __doc__ from simplecv.api import Camera, Blob cam = Camera() # settings for the project min_size = 0.1 * cam.get_property("width") * cam.get_property("height") # Change threshold thresh = 10 # frame difference threshold last_img = cam.get_image() last_img.dl().text("Move around to get the party started!", (5, 5)) last_img.show() while True: new_img = cam.get_image() track_img = new_img - last_img # difference the images blobs = track_img.find(Blob, -1, threshblocksize=99) # use adapative blob detection if blobs: blobs.draw(autocolor=True) track_img.show() last_img = new_img # update the image
right_red = right.merge_channels(r, None, None) #right_red.save("red.png", sample=True) sz = (left.width + offset[0], left.height + offset[1]) output = left_blue.embiggen(size=sz, pos=(0, 0)) output = output.blit(right_red, alpha=0.5, pos=offset) output = output.crop(offset[0], y=offset[1], w=left.width - offset[0], h=left.height - offset[1]) return output print "Taking pictures. Please move your camera slightly to its right" print "after every picture." c = Camera() time.sleep(1) images = [] for i in range(5): images.append(c.get_image()) print "Picture %d taken" % (i + 1) time.sleep(1) offset = (0, 0) for i in range(4): left = images[i] right = images[i + 1] output = threedee_me(left, right, offset) print output.save(temp=True) output.show() time.sleep(2)