Quotient Robotics | Hobby Robotics, Biped Robots & C# Robotics

OpenCV HaarTraining - Object Detection with a Cascade of Boosted Classifiers Based on Haar-like Features - Part II

noreply@blogger.com (David J Barnes) — Fri, 09 Apr 2010 13:10:00 +0000

Steps 1 and 2 (asset preparation and generating a .vec using createsamples.exe) of this overview were covered in part I, OpenCV HaarTraining - Object Detection with a Cascade of Boosted Classifiers Based on Haar-like Features - Part I.

Thus far we have prepared our assets and created a .vec file. In doing so, we have created a directory that contains an images folder. It has three child folder; Negatives, Positives, and TestPostives. In the root we have our index files that list all positive and negative images. The .vec file has been verified using:

C:\HaarTraining\createsamples.exe -vec C:\HaarTraining\PositivesMany.vec

3) Train the Classifier using haartraining.exe

Haartraining.exe is provided by OpenCV and can be found in: C:\Program Files\OpenCV\bin. For convenience, both haartraining.exe and createsamples.exe were moved to my "working" directory's root. Similar to createsamples.exe, we pass the necessary parameters to haartraining.exe via command line. For convenience a .bat file is created. We name it: 2_HaarTraining.bat. It's contents are:

haartraining.exe -data HaarCascade_Horse5 -vec PositivesMany.vec -bg Negatives.txt -nstages 20 -nsplits 2 -minhitrate 0.998 -maxfalsealarm 0.5 -npos 1191 -nneg 3985 -w 24 -h 24 -nonsym -mem 1024 -mode ALL

PAUSE

Depending on the number of negatives and positives collected, this process commonly takes many hours. The parameter -mem 1024 allocates memory to the systems process. To leverage a multi-core processor, additional advanced configuration is necessary. A screenshot of haartraining.exe running is displayed above. Once complete, a "completion" prompt will be displayed and an xml file will be generated. In this example a cascade named HaarCascade_Horse5.xml is placed in the working root.

4) Testing

Once training is complete and a cascade of classifiers has been generated, it is suggested that you benchmark performance using performance.exe. Run performance.exe from a command line for usage.

The results of training a classifier with fewer than 2000 positive images and less than 3000 negatives is promising. A video containing frames that were not present in either the positives or negatives is displayed below. The results are acceptable and performance can easily be boosted by providing additional images; both positive and negative.

OpenCV HaarTraining - Object Detection with a Cascade of Boosted Classifiers Based on Haar-like Features - Part I

noreply@blogger.com (David J Barnes) — Thu, 08 Apr 2010 15:28:00 +0000

OpenCV provides a way to train and create your own classifiers using Haar-like features in HaarTraining. The result of training is an xml file that contains the definitions of your classifier. Note that this experiment was produced with the following: WindowsXP Pro, 3GB RAM, OpenCV 1.0 pre, CodeBlocks, Visual Studio 2005, OpenCVSharp, OpenCV root path: C:\Program Files\OpenCV, and tons of coffee and nicotine.

Much of the work for training a classifier is "busy work." We break the process of creating a classifier into four logical steps; 1) asset preparation (acquire images/videos, tons of them), 2) create sample images and generate a .vec (using createsamples.exe) 3) train the classifier (using haartraining.exe) 4) test.

A working directory is created. This example uses C:\HaarTraining\. The directory is organized as such. Within the Images directory 3 additional folders exist: Positives, Negatives, and PositivesTest. Positives contain our positives, negatives our negatives, and PositivesTest contain positive images that were not used in the training process.

1) Asset Preparation

This phase of the process involves acquiring images or videos which contain the object to classify. We refer to these images as "positive" images. It also involves the collection of "negative" images; images that do not contain the target object. Since an abundance of video footage was readily accessible for this project, images were extracted frame by frame to produce positives.

While this is ordinarily a painful process, the aid of a simple C# Windows app (Positives Builder, ironically produces negatives too) greatly reduced the amount of time spent doing this (interns are often exceptionally great at this type of work too, think about it). Version 1 can be downloaded for free from Google Code: http://code.google.com/p/opencv-haar-cascade-positive-image-builder/downloads/list. If you'd like the source code, please contact me. According to Kuranov et. al. [1] 5000 positives is a suitable number to train with. As a proof of concept, we took 1191 positives and 2000 negatives to begin with. The results of this test reflect the relationship of the number of positive and negative images in proportion to the confidence of the object found via HaarDetection.

Positives Builder will output a text file (modified in the app.config) that contains a list of images and the objects coordinates. A samples Positives.txt files is structured like so:

C:\HaarTraining\Images\Positives\Horse_0.jpg 1 288 167 111 100

Where C:\HaarTraining\Images\Positives\Horse_0.jpg is a positive image, 1 indicates a single instance of a positve object in the image, 288 is the x position, 167 is the y position, and 111 and 100 are the respective width and height of the objects bounding area.

The Negatives.txt file is structured like so:

C:\HaarTraining\Images\Negatives\neg-0003.jpg

And so on. The use of a directory contents reader can help build a file in a snap.

Step 1 is complete once all assets are acquired, "cropped", and placed in their respective directories.

2) Create Sample Images and Generate a .vec

After all positives and negatives are segregated into their proper directories we use createsamples.exe to generate our .vec file. This is a straight-forward process that converts all positives. No work is done with negatives in step 2.

A .bat file containing the following is used:

createsamples.exe -info Positives.txt -vec PositivesMany.vec -num 1191 -w 24 -h 24
PAUSE

Where the -info parameter Positives.txt is used from step 1, -vec indicates the name of the .vec file to be produced, -num is the number of positive images to processed, and -w and -h are the width and height. We find that this is a quick process and should resolve in under a few seconds for ~1200 positives. The output of the above is PositivesMany.vec.

To verify that all images were properly processed by createsamples, we run:

C:\HaarTraining\createsamples.exe -vec C:\HaarTraining\PositivesMany.vec
PAUSE

Step 2 is short and sweet and is complete once a .vec file is compiled and validated.

-----------------------

[1] Alexander Kuranov, Rainer Lienhart, and Vadim Pisarevsky. An Empirical Analysis of Boosting Algorithms for Rapid Objects With an Extended Set of Haar-like Features. Intel Technical Report MRL-TR-July02-01, 2002.

Robot Social Experiment - How Humans and Canines Respond to Robots

noreply@blogger.com (David J Barnes) — Wed, 31 Mar 2010 23:57:00 +0000

Seldom do Chicagoans get to experience a 76 degree day in March. Given the perfect weather, I thought it was an excellent opportunity to introduce Anthony to the outdoors. With beer, cigarette, and emergency remote in hand, Anthony navigated his way through the lobby door. Like a house cat that has never seen the pavement of city streets, he crept eerily alongside the condo flowerbeds. This site was something I had been waiting many cold wintery months to see.

People from a near by pub gathered at the edge of their fenced-in patio to see what was approaching. One gentleman walked backwards down the sidewalk in an attempt to maximize his time spent viewing such an odd thing. Lady walking a stroller felt threatened enough to cross the street in the middle of traffic; only to cross back once she cleared Anthony. As I was sitting on the flowerbed watching Anthony run circles, another lady asked (in a condescending tone) if I lived here; eying Anthony. Implying that if I did not, I'd best move along. She was surprised to find out that I knew she was my neighbor.

By no means did I set out today to experiment with robot-human or robot-dog interaction, I'll save that for another day. But, I was more than surprised at the reactions I was getting. Cross the street, really? Are people ready for robots in their every day lives?

Optical Flow in OpenCV used to Track Objects in Motion

noreply@blogger.com (David J Barnes) — Fri, 26 Mar 2010 16:29:00 +0000

Optical flow is a very important concept in image processing. It is the pattern of motion of objects, surfaces, edges, etc. OpenCV has embedded many methods that utilize the Lucas-kanade algorithm. They are cvGoodFeaturesToTrack (used to find meaningful features to track), cvFindCornerSubPix (refines a set of features), and cvCalcOpticalFlowPyrLK (does the actual optical flow calculations). This application demonstrates the fundamentals of optical flow by using cvCalcOpticalFlowPyrLK to track points defined by an end users mouse click.

David Stavens at the Stanford AI Lab gives a more comprehensive overview of optical flow algorithms in OpenCV on the Stanford AI web site.

CodeBlocks & OpenCV - Configure the Compiler and Linker

noreply@blogger.com (David J Barnes) — Thu, 25 Mar 2010 19:48:00 +0000

Configuring your compiler and linker settings for OpenCV in CodeBlocks is as straight forward as it gets. There are only three basic steps involved. Configure the global variables path, set the compiler settings, and set the linker settings.

Since many struggling to find the right settings will only read the first few lines of a post that instructs them how to do so, I will flip-flop the order of these steps and start with what I consider to be the most crucial yet most often skipped step.

Enter your My Computer properties, select Advanced tab, Environment Variables. Select the Path variable from the system variables list. I like to copy this string into Notepad so I can search through it. Look for an OpenCV entry. If it is not present, add a semicolon to the end and add "C:\Program Files\OpenCV" Of course omit quotes.

Next launch CodeBlocks. It is worth mentioning I am currently running version 8.02. From the CodeBlocks start here screen, select the Settings menu, then Compiler and debugger.

Be sure the Global compiler settings icon to the left is selected. Navigate to the Linker settings tab and make the following entries into the Link libraries textbox:

C:\Program Files\OpenCV\lib\cv.lib
C:\Program Files\OpenCV\lib\cvaux.lib
C:\Program Files\OpenCV\lib\cxcore.lib
C:\Program Files\OpenCV\lib\highgui.lib

Navigate to the Search directories tab and select the Compiler sub-tab. Enter the following:

C:\Program Files\OpenCV\cv\include
C:\Program Files\OpenCV\cxcore\include
C:\Program Files\OpenCV\otherlibs\highgui
C:\Program Files\OpenCV\cvaux\include

Ok your way out of the global settings and create a new C console application. Test that you linked OpenCV correctly by including the appropriate libraries:

#include "cv.h"
#include "highgui.h"
#include
#include

RoBoard Running Ubuntu Linux on MicroSDHC

noreply@blogger.com (David J Barnes) — Sun, 21 Mar 2010 15:41:00 +0000

A different, faster approach to getting Linux Ubuntu onto a RoBoard is to install the OS directly to your MicroSDHC card from another machine. VMWear is another viable option. I used an old Asus EeePC laptop which has a card reader built in. For this installation I used a 4G micro SDHC card from Gigaware. File copy took about an hour and after the initial reboot, everything was in order.

After ensuring that your internet connection is in order, run all suggested Ubuntu updates. Since the default Ubuntu kernel installed is an i686, you'll need to load a kernel compatible with the RoBoard, something a 486 could handle. To do so, issue "sudo apt-get -y install linux-386" at a terminal prompt. Next set the new kernel as the default. You can enter the boot menu by "sudo nano -w /boot/grub/menu.lst." One of the top entries in the boot menu is default. This value corresponds with the list of system kernels listed below (note that the index value is base zero). Once the default is adjusted, a minor tweak needs to be done to the 386 kernel flag. Replace splash with "pnpbios=off acpi=off noreplace-paravirt noapic nolapic."

Keep in mind we are still not working on the RoBoard. Once the above is complete, verify your current kernel by "uname -r." Reboot. Your 386 kernel should have been selected if you set the default flag correctly. Check your current kernel again to verify 386 booted.

Assuming the 386 kernel was verified, its time to swap in he micro SDHC into the RoBoard; the moment of truth. One other tweak needed when running the 386 kernel is to install the Ndiswrapper (https://help.ubuntu.com/community/WifiDocs/Driver/Ndiswrapper). This allows you to use many Windows wifi device drivers.

Embedded Linux (Debian) RoBoard USB Flash Drive Installation

noreply@blogger.com (David J Barnes) — Sat, 13 Mar 2010 00:28:00 +0000

Though single-board computers are not a new concept but the idea of marrying an SBC with MCU functionality is; DMP Electronics is leading the way with their new RoBoard. The RoBoard offers tons of GPIO, PWM, I2C, USB, and tons of robotic-esque features via a rich C++ based library. When I saw this, I of course had to have it. $289 from Trossen Robotics gets you everything you need to get started.

The RoBoard has the ability to run a wide variety of operating systems. I chose to begin with Debian given it's tiny footprint, open source GNU-ness, and well, because Linux rocks for embedded systems. The plan is to slowly integrate the RoBoard into Anthony, unlocking the functionality of OpenCV while removing abstraction between a traditional micro-controller and a PC.

I will certainly share my experiences as I install OpenCV, the RoBoard C++libraries, and unlock the RoBoard's robust feature set.

Proportional Turning and Path Planning for Autonomous Robot with Infrared Sensors

noreply@blogger.com (David J Barnes) — Wed, 10 Mar 2010 04:54:00 +0000

This brief video shows the two basic changes to Anthony's control algorithm. When objects are present (Left, Left Mid, Right, and Right Mid sensors), the turning radius is now proportional to the distance from the object. A new method for deciding optimal direction was also added. Instead of arbitrary path planning, based upon the outputs of all sensors, the path of least resistance is selected. Variable speed control is still being tested. As readings indicate objects becoming closer rather than further away, speed will be reduced to eliminate a lack of response time.

OpenCV Image Processing Execution Pipeline in C#

noreply@blogger.com (David J Barnes) — Wed, 24 Feb 2010 04:15:00 +0000

A brief overview of building an image processing execution pipeline application in C# that uses the OpenCV library (OpenCvSharp). This demonstration shows how to stack various filters such as Canny, FloodFill, and Dilate in an execution pipeline. MatchImage is also used to match the cameras current view with a pre-selected image template; in this case a camera tripod stand.

Autonomous Robot Navigation using Infrared Sensors

noreply@blogger.com (David J Barnes) — Tue, 23 Feb 2010 03:51:00 +0000

I mounted 4 of the 6 new Sony IR sensors on Anthony tonight. This gives him much broader range of sensing and allows for much more precise autonomous control (in the future). While he is still rather clumsy, the application code still needs quite a bit more tweaking. Also, IR is meant to supplement the vision system and act only as local detection; it is not his primary means of navigation.

Object Detection and Tracking using OpenCV CvMatchTemplate

noreply@blogger.com (David J Barnes) — Sun, 21 Feb 2010 22:53:00 +0000

On my way to Florida this past weekend, I finally got a substantial chunk of free-time to dive deep into O'Reilly's Learning OpenCV (ISBN 0-596-51613-4). As a side note, if you are working with OpenCV or have a desire to learn basic image processing terms and concepts, this is a spectacular read; well worth the $50 USD.

OpenCV provides a highly robust means of image matching; CvMatchTemplate. The method takes 4 parameters with no overrides. We call it like so:

Cv.MatchTemplate(R_Source, R_Template, Results, MatchTemplateMethod.CCoeffNormed);

R_Source represents the source image to be scanned. Note that it must be a single channel image. R_Template is the image that will be scanned across the source image. Again, this image must be single channel. Results, as the name suggests, contains the results of the image scan. I declare all three IplImages as such:

IplImage R_Source = Cv.CreateImage(Cv.GetSize(SrcFrame), BitDepth.U8, 1);
IplImage R_Template = Cv.CreateImage(Cv.GetSize(Template), BitDepth.U8, 1);
IplImage Results = Cv.CreateImage(Cv.Size(SrcFrame.Width - Template.Width + 1, SrcFrame.Height - Template.Height + 1), BitDepth.F32, 1);

Then the cvSplit method is used to select out a single channel from the source and the template.

Cv.Split(SrcFrame, R_Source, null, null, null);
Cv.Split(Template, R_Template, null, null, null);

Once the channels have been split, we run cvMatchTemplate: Cv.MatchTemplate(R_Source, R_Template, Results, MatchTemplateMethod.CCoeffNormed); In this case the coefficient normalized algorithm is used. Finally cvMinMaxLoc is used to return match coordinates and a confidence interval; based on MatchTemplateMethod.CCoeffNormed.

Cv.MinMaxLoc(Results, out MinVal, out MaxVal, out MinLoc, out MaxLoc, null);

The above is a screen shot of the revised application running Image Match. A thumbnail image (to the left) was taken of the tripod handle. Next, that thumbnail was loaded into the application as the template. cvMatchTemplate() runs on each frame of the web cam returning back a positive match with a confidence interval of .61. Normalizing and making additional modifications to the image before matching is one way to increase confidence.

Autonomous Robot Test using Sony IR, A Supplement to Vision

noreply@blogger.com (David J Barnes) — Tue, 16 Feb 2010 03:46:00 +0000

This is a crude, crude autonomous test and is the very beginning to supplementing the primary vision system with tactical IR sensors. The test reveals that more sensors are clearly needed. The robot has a limited sense of its surroundings but is able to adapt and move quickly due to its tri-cycle locomotion.

After additional sensors are attached and a mounting scheme is selected, I will begin working on the feedback control of the tactical sensors into the vision platform. In addition, the current method for turning will be modified. A linear and exponential method will be used. Servo steering adjustments will be calculated as:

PctgOfDist = SensorLeft1Val / 128
TurnVal = 150 - (PctgOfDist * 50)

Where 128 is the value received by the sensor when no object is present; 150 is the center point of the servo, 50 is the width from servo center to servo full left. The result is a linear servo adjustment proportional to how close the object is to that particular sensor.

OpenCV & EmguCV using cvFloodFill and Canny Edge Detection

noreply@blogger.com (David J Barnes) — Thu, 11 Feb 2010 04:03:00 +0000

The FloodFill algorithm is an excellent way to fill in an object with a replacement color. While this sounds trivial, this is a very meaningful step in vision-based path planning. In this example I focus the camera on a small lamp head (~6m away). Using a Canny edge detector (prior example) method, I pass in a threshold and threshold linking value. This creates rough outlines of the objects in the cameras line of sight. Next, the cvFloodFill method is used to fill in neighboring pixels with an updated value. The cvFloodFill code is as follows:

Image mask = new Image(ImageColor.Width + 2, ImageColor.Height + 2);

MCvConnectedComp comp = new MCvConnectedComp();

CvInvoke.cvFloodFill(ImageColor.Ptr, new System.Drawing.Point(Convert.ToInt32(this.FrmFillPointX.Value), Convert.ToInt32(this.FrmFillPointY.Value)), new MCvScalar(Convert.ToDouble(this.FrmFillNewVal.Value)), new MCvScalar(Convert.ToDouble(this.FrmFillLowDiff.Value)), new MCvScalar(Convert.ToDouble(this.FrmFillUpDiff.Value)), out comp, Emgu.CV.CvEnum.CONNECTIVITY.FOUR_CONNECTED, Emgu.CV.CvEnum.FLOODFILL_FLAG.DEFAULT, mask);

The interface shown is an application I am working on that arranges various methods and algorithms into an execution pipeline. Doing so decreases the learning curve when tampering with various arrangements and provides immediate visual feedback. Each filter is applied one on top of the other resulting in a combination of outcomes.

Autonomous Robot Navigation using Vision Algorithms

noreply@blogger.com (David J Barnes) — Fri, 05 Feb 2010 04:10:00 +0000

I will be using a hybrid sensor approach to empower Anthony's autonomous nature. Binocular vision feedback will serve as the overarching path planning while RF and IR will provide local object detection yet have higher priority placed on its findings than that of the vision system. The purpose of this post is not to fully describe the hybrid approach nor to discuss the multiple tiers of processing. This is a quick overview of one method for using vision filters and algorithms to autonomously navigate a robot.

Each image was take from the robot's point of view. I have enlisted a series of 5 steps to defining an object free path. First apply a canny edge detector. A Gaussian blur will help eliminate any extensive noise in the image.

Next, isolate and mask in the area nearest the bottom of the image and mask in pixel by pixel until you hit an edge line. RoboRealm has a lovely SideFill filter for this allowing filling from anyone of the 4 primary angles.

Erode your result to blow out any hanging pixels or eliminate noise. Objects that have a low level of connectivity will likely disappear all together depending on the intensity applied. In addition, apply a smooth hull filter to smooth blob shapes. A 100% weight replaces the original outline with the averaged one.

Finally, use point location, X and Y variables, to visually represent the highest, most center white space of the image. This x,y pair represents the robots destination and is overwritten in the image as a pink dot.

Autonomous Robot Anthony - Quick Overview & Test Drive

noreply@blogger.com (David J Barnes) — Tue, 02 Feb 2010 03:29:00 +0000

A brief Anthony update component by component ending with a quick test drive. The two batteries are not sourced together. They are 12 vdc @ 12a. The system uses a total of 6 1/2" bearing blocks from Burden Supply, 1/8" mild steel for support, 1-1/4" aluminum square tube, epvc as a platform, 2 PICAXE micro controllers, 8 12" threaded rods, 1 Banebot gearbox motor, and 1 ServoCity gearbox. The Asus laptop is running RoboRealm but is not yet integrated into the system.

Autonomous Robot Anthony's Mechanical Structure

noreply@blogger.com (David J Barnes) — Sat, 23 Jan 2010 02:52:00 +0000

Deciding to change the drive train structure of Anthony resulted in a full-blown rebuild keeping nothing from the original machine except a single motor, a few bearing blocks, and an otherwise meaningless name. If I were ignorant to the danger of welding in a downtown Chicago residential condo, this would have been an ideal job for a TIG or MIG. As a backup to welding, I decided to work with what I consider adult Tinker Toys; a slew of 1/2" threaded rod, aluminum square tube, and epvc. One of the very nice benefits of working with these materials is the adjust-ability. Meaning chain tension, for instance, can easily be adjusted with a wrench just by modifying the height of its mounting plate. This goes for many aspects of the project. This also proved helpful when trying to perfectly position the servo's control arms with the rear wheel.

The new structure weighs roughly 50lbs without batteries, electronics, or chassis cover. It has rock solid durability and is sturdy enough to hold my weight; 180lbs. Once new shelves are threaded into place (to house electronics) I am going to begin working on the external cover crafted from fiberglass resin and nylon stretch cloth.

ServoCity High Torque Gearbox for Robotic Steering Control

noreply@blogger.com (David J Barnes) — Sat, 09 Jan 2010 03:39:00 +0000

Precision turning, accuracy, and motor encoding are always of utmost importance when designing a mobile robot. If your vehicle can't drive a straight line, precisely, you are well behind the eight ball before you face any real challenges.

With my latest robot Anthony, I strive to make this a concern of the past by developing a new mechanism that will control both forward momentum as well as turning. The solution consists of a single assembly that resembles a motor-powered unicycle. The idea is that both steering and propulsion will be controlled from the assembly which is mounted at the rear of the robot. As apposed to traditional drive trains, this vehicles locomotion only uses a single wheel. The upside to this is there are no other motors to calibrate to. The challenge then becomes steering.

Hobby servos have very limited torque. As I was searching for stepper motors that could provide me the force needed to turn the assembly, I stumbled across ServoCity's line of heavy duty pan systems. At a relatively low price point, I had to try one. I went with an SPG785A-BM. It boasts an amazing 1,315 oz-in of torque at 4.8vdc with the same precision as a standard hobby servo.

In the images show the servo mounted directly to the top of the assembly, or the headset. After some testing, this is a huge flaw and stress point for the assembly. The new plan is to relocate the servo elsewhere allowing the assembly to attach to the rear of the robot with a bearing and arm assembly. The servo will then use something like tie rods or control arms to swivel the assembly.

Programmatically Control Sony LANC Camcorder via ELM624

noreply@blogger.com (David J Barnes) — Wed, 30 Dec 2009 20:55:00 +0000

A few weeks ago I started doing some research on controlling a Sony camcorder programmatically. I was hoping to work directly with a Picaxe or AVR micro controller but stumbled upon a nice dedicated device designed specifically for interfacing RS232 circuits with the LANC protocol. The ELM624 (datasheet) is designed by Elm Electronics and is built on the PIC12C5XX chip. It abstracts all the complex micro-second timing needs of the LANC protocol and allows for easy integration into any circuit.

As the datasheet shows, connecting with a traditional RS232 interface is quite simple. For my installation, I decided to use an FT232R USB converter (connected directly to a PC C# application). One of the many nice things about this piece of hardware is its flexible EEPROM program-ability. Since the ELM624 signal needs to be inverted you would ordinarily need additional hardware (NPN transistor, resistors, etc). Simply modify the EEPROM settings in the FT232R and save yourself the extra component configuration.

Helpful Links:
Sony LANC (Control-L) Protocol Overview: http://www.boehmel.de/lanc.htm
Hardware and Software: http://www.avitresearch.com/
Elm Electronics (ELM624 and various others): http://www.elmelectronics.com/
General Overview and Sample VB Application: http://www.esac.org.uk/SonyLancControl.asp

Robot Canine Interaction

noreply@blogger.com (David J Barnes) — Mon, 21 Dec 2009 01:35:00 +0000

Anthony is my latest robot. He is an application I am working on for my PhD research proposal [On Enhanced Control and Interaction with Robots using Hybrid Vision Sensors].

Robots are always more fun once you've got a few cocktails in you. In the below video we demonstrate that fun as we chase Turi around the kitchen. I'd love to one day take Anthony out on the streets of Chicago and get footage of him interacting with pedestrians, dogs, or anything that moves.

Mechanical Toy Robot

noreply@blogger.com (David J Barnes) — Sun, 13 Dec 2009 17:02:00 +0000

December 11th was my thirtieth birthday, a day I won't soon forget. From running keg stands to mechanical toy robot gifts, nearly everything was perfect. Unfortunately I was unable to snag video of a severely intoxicated friend interacting with my latest trashcan-based robot. Thank you.

Machine Vision Robotics Platform - OpenCV & EmguCV

noreply@blogger.com (David J Barnes) — Fri, 04 Dec 2009 01:36:00 +0000

A quick overview of my current machine vision platform. The robot currently features a trash can shell, 12" mag wheels, 1/2" steel axles, 2 Banebot RS-540 motors with encoders, encoder divider boards, Sabertooth 2x10 motor controller, and a PICAXE 40x1 micro controller.

After wiring of the basic system components is complete I will begin to integrate the PC laptop which will act as the main processing unit. A USART interface between the micro controller(s) and the PC will exchange data about direction, speed, vision parameters, etc.

HaarCascade Training Resources for OpenCV and Computer Vision Algorithms

noreply@blogger.com (David J Barnes) — Thu, 19 Nov 2009 20:54:00 +0000

My interest in machine & computer vision is growing each day. Each time I crack open the web or continue development of my QRCV application, I get sucked deeper and deeper into a world of unknown terminology and bitwise operators that I am only beginning to grasp. One of the many ambitious goals I have for my current robot is understanding hand gestures, understanding the gesture then taking the appropriate action. The beginning to all of this starts with learning the human hand. There are various methods to detect a hand; color, shape, orientation, etc. I have decided to take the route of using haar training to detect my hand(s). Some quick research on haar-like features and haar training led me to the below links.

After grooming through pages of documentation on haar training, it appears I need a ton (2,000 - 10,000 optimally) of hand photos. In the name of science and good will towards men, I have decided to launch www.HandsForScience.org. A site dedicated to collecting as many unique hands as possible. Once the site fully launches, hopefully people will see past the creepiness of photographing their hand (others hands?) and upload them for science. The goal is to collect thousands then compile and train.

Some excellent resources for haar-like features and haar training:

Computer Vision in C# using OpenCV & Emgu CV

noreply@blogger.com (David J Barnes) — Fri, 13 Nov 2009 19:44:00 +0000

OpenCV is a computer vision library originally developed by Intel. Emgu CV is a cross platform .Net wrapper for OpenCV. This is a quick intro to what I call "Quotient Robotics CV"; my C# application that leverages both existing technologies and a RoboRealm-influenced flow of filters and algorithms. It is a work in progress and only features basic threshold, contour, face recognition, skin detection, and drawing filters.

Machine Vision - Emgu CV the Open CV Wrapper

noreply@blogger.com (David J Barnes) — Tue, 10 Nov 2009 21:18:00 +0000

I have spent the last few weeks working with RoboRealm, a machine vision application offering various filters including blob separation, image and shape match, thresholds, etc. Although I enjoy all of their canned filters and API access methods, I have been getting frustrated not being able to easily implement some of the algorithms I'd like to.

I have heard plenty about Open CV; a computer vision library originally developed by Intel, but never fiddled with it. It wasn't until I learned of a C# wrapper, rather a multi-language wrapper called Emgu CV that I decided to do further investigation. Emgu CV is a stable and well supported alternative to Open CV.Net, another C# wrapper for Open CV. Their documentation is well formatted and have an active community committed to the development of the platform. Unlike Open CV.net, Emgu CV supports the latest version of Open CV (2.0).

The above image is the result of a simple face detection application using the HaarCascade objects. A file stream can be captured from a camera device or an avi file. E.g.:

Capture capture = capture = new Capture(0); //Obtains default camera device 0
Capture capture = capture = new Capture("My_AVI.avi"); //Grabs the enclosed avi for processing

When deploying your application, be sure to include the following libraries found in the Emgu CV bin directory: cv200.dll, cvaux200.dll, cvextern.dll, cxcore200.dll, and highgui200.dll. The easiest way to ensure these get deployed properly is to add them to your project and set their build actions to "Content" and Copy to Output Directory to "Copy if newer."

RoboRealm Server API C# Read Variable

noreply@blogger.com (David J Barnes) — Tue, 03 Nov 2009 04:47:00 +0000

I felt like tinkering with RoboRealm tonight. Since I bought a license a few weeks ago I have spent very little time with the application. But even after a few minutes the shear power of it's capabilities are obvious.

Using RoboRealm, I use the Laser_Spot filter to detect the X,Y coordinates of a laser being projected onto the wall. Next, I connect to the remote server using the RoboRealm API (C#).