Software and hardware engineering

Mon 02 August 2010 Posted by Matt Williamson in Experiments

Motion Tracking with a Webcam

I used Python and OpenCV to get a simple app together that tracks movement using a webcam. It currently averages all of the movements’ locations to determine a single point for targeting. This will not work for multiple targets, with a little modification.

Here's the code from http://github.com/mattwilliamson/Motion-Tracker/blob/master/track.py:

# Derived from http://sundararajana.blogspot.com/2007/05/motion-detection-using-opencv.html

import cv

class Target:
    def __init__(self):
        self.capture = cv.CaptureFromCAM(0)
        cv.NamedWindow("Target", 1)

    def run(self):
        # Capture first frame to get size
        frame = cv.QueryFrame(self.capture)
        frame_size = cv.GetSize(frame)
        grey_image = cv.CreateImage(cv.GetSize(frame), cv.IPL_DEPTH_8U, 1)
        moving_average = cv.CreateImage(cv.GetSize(frame), cv.IPL_DEPTH_32F, 3)
        difference = None

        while True:
            # Capture frame from webcam
            color_image = cv.QueryFrame(self.capture)

            # Smooth to get rid of false positives
            cv.Smooth(color_image, color_image, cv.CV_GAUSSIAN, 3, 0)

            if not difference:
                # Initialize
                difference = cv.CloneImage(color_image)
                temp = cv.CloneImage(color_image)
                cv.ConvertScale(color_image, moving_average, 1.0, 0.0)
            else:
                cv.RunningAvg(color_image, moving_average, 0.020, None)

            # Convert the scale of the moving average.
            cv.ConvertScale(moving_average, temp, 1.0, 0.0)

            # Minus the current frame from the moving average.
            cv.AbsDiff(color_image, temp, difference)

            # Convert the image to grayscale.
            cv.CvtColor(difference, grey_image, cv.CV_RGB2GRAY)

            # Convert the image to black and white.
            cv.Threshold(grey_image, grey_image, 70, 255, cv.CV_THRESH_BINARY)

            # Dilate and erode to get object blobs
            cv.Dilate(grey_image, grey_image, None, 18)
            cv.Erode(grey_image, grey_image, None, 10)

            # Calculate movements
            storage = cv.CreateMemStorage(0)
            contour = cv.FindContours(grey_image, storage, cv.CV_RETR_CCOMP, cv.CV_CHAIN_APPROX_SIMPLE)
            points = []

            while contour:
                # Draw rectangles
                bound_rect = cv.BoundingRect(list(contour))
                contour = contour.h_next()

                pt1 = (bound_rect[0], bound_rect[1])
                pt2 = (bound_rect[0] + bound_rect[2], bound_rect[1] + bound_rect[3])
                points.append(pt1)
                points.append(pt2)
                cv.Rectangle(color_image, pt1, pt2, cv.CV_RGB(255,0,0), 1)

            num_points = len(points)
            if num_points:
                # Draw bullseye in midpoint of all movements
                x = y = 0
                for point in points:
                    x += point[0]
                    y += point[1]
                x /= num_points
                y /= num_points
                center_point = (x, y)
                cv.Circle(color_image, center_point, 40, cv.CV_RGB(255, 255, 255), 1)
                cv.Circle(color_image, center_point, 30, cv.CV_RGB(255, 100, 0), 1)
                cv.Circle(color_image, center_point, 20, cv.CV_RGB(255, 255, 255), 1)
                cv.Circle(color_image, center_point, 10, cv.CV_RGB(255, 100, 0), 5)

            # Display frame to user
            cv.ShowImage("Target", color_image)

            # Listen for ESC or ENTER key
            c = cv.WaitKey(7) % 0x100
            if c == 27 or c == 10:
                break

if __name__=="__main__":
    t = Target()
    t.run()

Tue 18 May 2010 Posted by Matt Williamson in Experiments

Browser Based Map Reduce

What if you could offload some of your computational work onto the visitors of your site? We thought it would be pretty cool to make a quick little app to test the theory out using Google App Engine.

We opted to use the MapReduce paradigm as made famous by Google. The workflow is like this:

  1. Admin (you) create a new job
  2. Admin adds data set, a line break delimited string
  3. Admin adds a map function, written in pure javascript
  4. Admin adds a reduce function
  5. Client visits web page with javascript embedded
  6. Javascript library prompts the user to contribute CPU cycles and writes to a cookie to remember
  7. If user accepts, request a random function and data set item from all jobs that is not complete
  8. Execute job and submit result
  9. Request another job, if there is none, wait a while and check again, if there is, don’t delay and start step 8 again
  10. It works like a charm! Try it out at http://bbmapreduce.appspot.com/. You can find the sources on my GitHub project page. To allow your visitors to contribute CPU cycles, simply include the script tag at http://bbmapreduce.appspot.com/client/sample in your website.

Sample:

<script src="http://bbmapreduce.appspot.com/client/wrapper/"></script>

It should be noted that was not written with security in mind and you can never trust the data that gets sent back from your visitors, but there are ways to make it more reliable, such as executing one function on multiple clients and checking the data returned against the rest which is not currently implemented. The other issue is that the jobs being submitted on this test site is completely open and thus prone to spam alert calls.

DISCLAIMER

I am not responsible for any harm this causes you, your computer, or anyone who visits the URLs provided. This is simply for educational purposes.

Page 1 / 1

Categories

Tags

Try out Pocket Sentry, our iPhone motion-activated camera app and get emails when your pet enters the bathroom.

Matt Williamson

President, App Delegate Inc