eLinux.org - User contributions [en]

ECE497 Project Set Playing Beagle

2011-05-17T03:29:38Z

Mayhewsw:

Team members: [[user:allensj | Samuel Allen]], [[user:mayhewsw | Stephen Mayhew]], [[user:J.ametsitsi | Julian Ametsitsi]]

== Executive Summary ==

The game Set uses a 3 x 4 grid of 12 cards that have different symbols on them. These symbols differ in shape, fill, and number. The goal is to find a set of three cards. See [http://www.setgame.com/set/rules_set.htm here] for Set game instructions.

Using the BeagleBoard, we have developed a system that uses a webcam to take a picture of the cards in play and uses OpenCV and Python to find the sets from the picture.

Our system correctly identifies all of the sets in the hand that the image recognition provides.

It can run completely on the Beagleboard and processes aproximately 1 frame per second.

Currently, the image recognition is the downfall to our success. The image recognition does not find the correct symbols on the cards, and so the rest of the system does not find the correct sets.

The sets that are found are correct for the found cards, but not the actual cards in play.

Our system is almost functional, but there are still some problems that need to be overcome.
The image recognition is the biggest hurdle that we need to overcome and after that is completed, the system will work correctly.

== Installation Instructions ==
* First clone our github repository: git@github.com:mayhewsw/BeagleSetGame.git
<pre>git clone git@github.com:mayhewsw/BeagleSetGame.git </pre>
* The SPEd image comes with OpenCV already installed, but if you do not have it, you will need it.
<pre> $ opkg install opencv </pre>
* Install python-opencv, and espeak
<pre> $ opkg install python-opencv </pre>
<pre> $ opkg install espeak </pre>
* You will also need a webcam and a way to mount it. We used a Sony Playstation Eye, but any webcam with at least 640x480 resolution should work. Our mount held the camera about 7 inches above the playing surface, and had it pointing straight down.

== User Instructions ==

Once everything is installed, how do you use the program? Give details here, so if you have a long user manual, link to it here.

* First, run the autogain executable. If you are using the SPEd2 Angstrom image, then this executable is found the root directory.

* Next, run trackbartest.py. When this runs, it opens up 2 images. One of the images is streaming live from the webcam, and it has slider bars that set the properties for the camera. The other image is a reference image. Slide the bars until the live image looks like the reference image.
<pre> $ python trackbartest.py </pre>
Once you have found a configuration you like, press enter. This will save those values to a file called cameraConfig.cfg, which is read later. Exit the window by pressing Escape.
* Now you can run the actual program, runner.py.
<pre> $ python runner.py </pre>
This will open up 2 windows. One window is an image of what the camera sees, the other window is the same image, but with the results of the processing overlaid onto it. Because of the current state of the image recognition, these results are often very wrong, but they are also affected by how close the camera configuration is.

When the program finds a set in the recognized cards, it will print out the result to the console, and wait for a keypress to continue. Make sure one of the images has focus, and press any key.

You can quit the program either by pressing Enter while the program is in the ordinary recognizing loop, or by doing Ctrl-C in the terminal.

== Highlights ==

The interest of our project is in how it demonstrates the use of OpenCV on the Beagleboard. It shows that OpenCV functionality on the Beagleboard is very similar to what one would find on any other computer, if a little slower.

== Theory of Operation ==

=== Program Flow ===
There are 2 steps to running the project: configuration and running.

In the configuration step, it simply creates trackbars that set camera configuration options as they change position. When the user presses enter, it saves the 3 values (brightness, contrast, and hue) to a file, cameraConfig.cfg.

In the running step, there is a file called runner.py that contains the main loop. Before it enters the main loop, it opens and reads cameraConfig.cfg and sets the camera properties accordingly. Inside the main loop, it runs three separate functions (all found in processCards.py) to recognize the cards. The first function, extractCards, finds symbols in the image, and groups them by location, and returns those groups. Each group is made up of rectangles which represent the bounding boxes of the symbols on any given card. Thus, each group is of size one, two, or three. The next function, getMeaningFromCards, takes the cards and classifies each of them, and returns a list of Card objects (defined in processCards). Next, this list of Card objects is passed to the SolveGame function, which finds sets.

=== Image Recognition ===
* To find fill: the program examines the center line of the symbol, and a line of the same length on the white part of the card, just to the left of the symbol, and compares their intensities. In order to set intensity thresholds correctly, there is a preprocessing loop at the beginning of the extractMeaningFromCards function.
* To find color: the program sets a mask around the image, and colors the background to black. Then it converts the image to HSV, increases the saturation by some amount, and converts back to BGR. It splits this image into channels and gets the sum of the entire channel. The max value of the sum decides on the color.
* To find shape: the program finds the contour of the symbol subimage, and divides the bounding box of the symbol by the perimeter of the symbol. This ratio is naively used as the decider.

== Work Breakdown ==

Finished:
{| border="1"
|-
|Sam Allen || Did some work on getting the camera values set correctly so that the image was more usable. Espeak integration.
|-
|Julian Ametsitsi || Tested using TI Pico Projector to project indication of set of card. Developed algorithm with Stephen to identify individual cards in a single image.
|-
|Stephen Mayhew || Tweaking and customization of image recognition code. Software integration with hardware.
|}

To be finished:
{| border="1"
|-
| Better image classification || Stephen - if it gets done, it will be done during 10th week
|-
| Faster camera refresh rates || Sam, Stephen - if it gets done, it will be done during 10th week
|}

== Conclusions ==
We were pleased with how well the Beagleboard runs OpenCV. It was not at all difficult to install and run. While it is noticeably slower than on larger machines, it is not prohibitively so.

Originally, it was in the scope to have a projector project indication of sets back onto the actual cards. We had planned to use a DLP Pico projector for this, but we found early on that the Pico projector projects at a very small resolution, and we would have had to mount it significantly higher than the camera if it was to cover the whole playing area. We experimented with putting lenses in front of the projector to magnify it, but this turned out to be much more difficult than we imagined, so we focused our efforts on the image recognition, and on making the system coherent and smooth.

Another facet of the original idea was to have the computer actually playing against humans. This would involve the computer accepting input when a human found a set. Since the computer turned out to be so bad at actually playing the game, it was never worth putting this sort of functionality into it. If the recognition ever becomes reliable, this would be interesting to implement.

There is a trade-off between camera quality and image recognition success. In the first stages of our image recognition process, we worked with images of much higher resolution, and found that we had much better success. On the other hand, we could have used higher powered classifiers (Support Vector Machines, for example) to classify the images, instead of our rather fragile manual tweaked approach.

=== Thanks To ===
* Mark Crosby and Gary Meyer for making us a camera mount.
* Dr. Rob Bunch for providing advice and lenses for the projector
* Dr. Zach Dodd at Harvey Mudd University for providing starting image recognition code.

[[Category:ECE497]]

ECE497 Project Set Playing Beagle

2011-05-17T03:28:53Z

Mayhewsw:

Team members: [[user:allensj | Samuel Allen]], [[user:mayhewsw | Stephen Mayhew]], [[user:J.ametsitsi | Julian Ametsitsi]]

== Executive Summary ==

The game Set uses a 3 x 4 grid of 12 cards that have different symbols on them. These symbols differ in shape, fill, and number. The goal is to find a set of three cards. See [http://www.setgame.com/set/rules_set.htm here] for Set game instructions.

Using the BeagleBoard, we have developed a system that uses a webcam to take a picture of the cards in play and uses OpenCV and Python to find the sets from the picture.

Our system correctly identifies all of the sets in the hand that the image recognition provides.

It can run completely on the Beagleboard and processes aproximately 1 frame per second.

Currently, the image recognition is the downfall to our success. The image recognition does not find the correct symbols on the cards, and so the rest of the system does not find the correct sets.

The sets that are found are correct for the found cards, but not the actual cards in play.

Our system is almost functional, but there are still some problems that need to be overcome.
The image recognition is the biggest hurdle that we need to overcome and after that is completed, the system will work correctly.

== Installation Instructions ==
* First clone our github repository: git@github.com:mayhewsw/BeagleSetGame.git
<pre>git clone git@github.com:mayhewsw/BeagleSetGame.git </pre>
* The SPEd image comes with OpenCV already installed, but if you do not have it, you will need it.
<pre> $ opkg install opencv </pre>
* Install python-opencv
<pre> $ opkg install python-opencv </pre>
* You will also need a webcam and a way to mount it. We used a Sony Playstation Eye, but any webcam with at least 640x480 resolution should work. Our mount held the camera about 7 inches above the playing surface, and had it pointing straight down.

== User Instructions ==

Once everything is installed, how do you use the program? Give details here, so if you have a long user manual, link to it here.

* First, run the autogain executable. If you are using the SPEd2 Angstrom image, then this executable is found the root directory.

* Next, run trackbartest.py. When this runs, it opens up 2 images. One of the images is streaming live from the webcam, and it has slider bars that set the properties for the camera. The other image is a reference image. Slide the bars until the live image looks like the reference image.
<pre> $ python trackbartest.py </pre>
Once you have found a configuration you like, press enter. This will save those values to a file called cameraConfig.cfg, which is read later. Exit the window by pressing Escape.
* Now you can run the actual program, runner.py.
<pre> $ python runner.py </pre>
This will open up 2 windows. One window is an image of what the camera sees, the other window is the same image, but with the results of the processing overlaid onto it. Because of the current state of the image recognition, these results are often very wrong, but they are also affected by how close the camera configuration is.

When the program finds a set in the recognized cards, it will print out the result to the console, and wait for a keypress to continue. Make sure one of the images has focus, and press any key.

You can quit the program either by pressing Enter while the program is in the ordinary recognizing loop, or by doing Ctrl-C in the terminal.

== Highlights ==

The interest of our project is in how it demonstrates the use of OpenCV on the Beagleboard. It shows that OpenCV functionality on the Beagleboard is very similar to what one would find on any other computer, if a little slower.

== Theory of Operation ==

=== Program Flow ===
There are 2 steps to running the project: configuration and running.

In the configuration step, it simply creates trackbars that set camera configuration options as they change position. When the user presses enter, it saves the 3 values (brightness, contrast, and hue) to a file, cameraConfig.cfg.

In the running step, there is a file called runner.py that contains the main loop. Before it enters the main loop, it opens and reads cameraConfig.cfg and sets the camera properties accordingly. Inside the main loop, it runs three separate functions (all found in processCards.py) to recognize the cards. The first function, extractCards, finds symbols in the image, and groups them by location, and returns those groups. Each group is made up of rectangles which represent the bounding boxes of the symbols on any given card. Thus, each group is of size one, two, or three. The next function, getMeaningFromCards, takes the cards and classifies each of them, and returns a list of Card objects (defined in processCards). Next, this list of Card objects is passed to the SolveGame function, which finds sets.

=== Image Recognition ===
* To find fill: the program examines the center line of the symbol, and a line of the same length on the white part of the card, just to the left of the symbol, and compares their intensities. In order to set intensity thresholds correctly, there is a preprocessing loop at the beginning of the extractMeaningFromCards function.
* To find color: the program sets a mask around the image, and colors the background to black. Then it converts the image to HSV, increases the saturation by some amount, and converts back to BGR. It splits this image into channels and gets the sum of the entire channel. The max value of the sum decides on the color.
* To find shape: the program finds the contour of the symbol subimage, and divides the bounding box of the symbol by the perimeter of the symbol. This ratio is naively used as the decider.

== Work Breakdown ==

Finished:
{| border="1"
|-
|Sam Allen || Did some work on getting the camera values set correctly so that the image was more usable.
|-
|Julian Ametsitsi || Tested using TI Pico Projector to project indication of set of card. Developed algorithm with Stephen to identify individual cards in a single image.
|-
|Stephen Mayhew || Tweaking and customization of image recognition code. Software integration with hardware.
|}

To be finished:
{| border="1"
|-
| Better image classification || Stephen - if it gets done, it will be done during 10th week
|-
| Faster camera refresh rates || Sam, Stephen - if it gets done, it will be done during 10th week
|}

== Conclusions ==
We were pleased with how well the Beagleboard runs OpenCV. It was not at all difficult to install and run. While it is noticeably slower than on larger machines, it is not prohibitively so.

Originally, it was in the scope to have a projector project indication of sets back onto the actual cards. We had planned to use a DLP Pico projector for this, but we found early on that the Pico projector projects at a very small resolution, and we would have had to mount it significantly higher than the camera if it was to cover the whole playing area. We experimented with putting lenses in front of the projector to magnify it, but this turned out to be much more difficult than we imagined, so we focused our efforts on the image recognition, and on making the system coherent and smooth.

Another facet of the original idea was to have the computer actually playing against humans. This would involve the computer accepting input when a human found a set. Since the computer turned out to be so bad at actually playing the game, it was never worth putting this sort of functionality into it. If the recognition ever becomes reliable, this would be interesting to implement.

There is a trade-off between camera quality and image recognition success. In the first stages of our image recognition process, we worked with images of much higher resolution, and found that we had much better success. On the other hand, we could have used higher powered classifiers (Support Vector Machines, for example) to classify the images, instead of our rather fragile manual tweaked approach.

=== Thanks To ===
* Mark Crosby and Gary Meyer for making us a camera mount.
* Dr. Rob Bunch for providing advice and lenses for the projector
* Dr. Zach Dodd at Harvey Mudd University for providing starting image recognition code.

[[Category:ECE497]]

ECE497 Project Set Playing Beagle

2011-05-17T02:56:51Z

Mayhewsw:

Team members: [[user:allensj | Samuel Allen]], [[user:mayhewsw | Stephen Mayhew]], [[user:J.ametsitsi | Julian Ametsitsi]]

== Executive Summary ==

The game Set uses a 3 x 4 grid of 12 cards that have different symbols on them. These symbols differ in shape, fill, and number. The goal is to find a set of three cards. See [http://www.setgame.com/set/rules_set.htm here] for Set game instructions.

Using the BeagleBoard, we have developed a system that uses a webcam to take a picture of the cards in play and uses OpenCV and Python to find the sets from the picture.

Our system correctly identifies all of the sets in the hand that the image recognition provides.

It can run completely on the Beagleboard and processes aproximately 1 frame per second.

Currently, the image recognition is the downfall to our success. The image recognition does not find the correct symbols on the cards, and so the rest of the system does not find the correct sets.

The sets that are found are correct for the found cards, but not the actual cards in play.

Our system is almost functional, but there are still some problems that need to be overcome.
The image recognition is the biggest hurdle that we need to overcome and after that is completed, the system will work correctly.

== Installation Instructions ==
* First clone our github repository: git@github.com:mayhewsw/BeagleSetGame.git
<pre>git clone git@github.com:mayhewsw/BeagleSetGame.git </pre>
* The SPEd image comes with OpenCV already installed, but if you do not have it, you will need it.
<pre> $ opkg install opencv </pre>
* Install python-opencv
<pre> $ opkg install python-opencv </pre>
* You will also need a webcam and a way to mount it. We used a Sony Playstation Eye, but any webcam with at least 640x480 resolution should work. Our mount held the camera about 7 inches above the playing surface, and had it pointing straight down.

== User Instructions ==

Once everything is installed, how do you use the program? Give details here, so if you have a long user manual, link to it here.

* First, run the autogain executable. If you are using the SPEd2 Angstrom image, then this executable is found the root directory.

* Next, run trackbartest.py. When this runs, it opens up 2 images. One of the images is streaming live from the webcam, and it has slider bars that set the properties for the camera. The other image is a reference image. Slide the bars until the live image looks like the reference image.
<pre> $ python trackbartest.py </pre>
Once you have found a configuration you like, press enter. This will save those values to a file called cameraConfig.cfg, which is read later. Exit the window by pressing Escape.
* Now you can run the actual program, runner.py.
<pre> $ python runner.py </pre>
This will open up 2 windows. One window is an image of what the camera sees, the other window is the same image, but with the results of the processing overlaid onto it. Because of the current state of the image recognition, these results are often very wrong, but they are also affected by how close the camera configuration is.

When the program finds a set in the recognized cards, it will print out the result to the console, and wait for a keypress to continue. Make sure one of the images has focus, and press any key.

You can quit the program either by pressing Enter while the program is in the ordinary recognizing loop, or by doing Ctrl-C in the terminal.

== Highlights ==

The interest of our project is in how it demonstrates the use of OpenCV on the Beagleboard. It shows that OpenCV functionality on the Beagleboard is very similar to what one would find on any other computer, if a little slower.

== Theory of Operation ==

=== Program Flow ===
There are 2 steps to running the project: configuration and running.

In the configuration step, it simply creates trackbars that set camera configuration options as they change position. When the user presses enter, it saves the 3 values (brightness, contrast, and hue) to a file, cameraConfig.cfg.

In the running step, there is a file called runner.py that contains the main loop. Before it enters the main loop, it opens and reads cameraConfig.cfg and sets the camera properties accordingly. Inside the main loop, it runs three separate functions (all found in processCards.py) to recognize the cards. The first function, extractCards, finds symbols in the image, and groups them by location, and returns those groups. Each group is made up of rectangles which represent the bounding boxes of the symbols on any given card. Thus, each group is of size one, two, or three. The next function, getMeaningFromCards, takes the cards and classifies each of them, and returns a list of Card objects (defined in processCards). Next, this list of Card objects is passed to the SolveGame function, which finds sets.

=== Image Recognition ===
* To find fill: the program examines the center line of the symbol, and a line of the same length on the white part of the card, just to the left of the symbol, and compares their intensities. In order to set intensity thresholds correctly, there is a preprocessing loop at the beginning of the extractMeaningFromCards function.
* To find color: the program sets a mask around the image, and colors the background to black. Then it converts the image to HSV, increases the saturation by some amount, and converts back to BGR. It splits this image into channels and gets the sum of the entire channel. The max value of the sum decides on the color.
* To find shape: the program finds the contour of the symbol subimage, and divides the bounding box of the symbol by the perimeter of the symbol. This ratio is naively used as the decider.

== Work Breakdown ==

Finished:
{| border="1"
|-
|Sam Allen || Did some work on getting the camera values set correctly so that the image was more usable.
|-
|Julian Ametsitsi || Tested using TI Pico Projector to project indication of set of card. Developed algorithm with Stephen to identify individual cards in a single image.
|-
|Stephen Mayhew || Tweaking and customization of image recognition code. Software integration with hardware.
|}

To be finished:
{| border="1"
|-
| Better image classification || Stephen - if it gets done, it will be done during 10th week
|-
| Espeak integration || Sam - if it gets done, it will be done during 10th week
|}

== Conclusions ==
We were pleased with how well the Beagleboard runs OpenCV. It was not at all difficult to install and run. While it is noticeably slower than on larger machines, it is not prohibitively so.

Originally, it was in the scope to have a projector project indication of sets back onto the actual cards. We had planned to use a DLP Pico projector for this, but we found early on that the Pico projector projects at a very small resolution, and we would have had to mount it significantly higher than the camera if it was to cover the whole playing area. We experimented with putting lenses in front of the projector to magnify it, but this turned out to be much more difficult than we imagined, so we focused our efforts on the image recognition, and on making the system coherent and smooth.

Another facet of the original idea was to have the computer actually playing against humans. This would involve the computer accepting input when a human found a set. Since the computer turned out to be so bad at actually playing the game, it was never worth putting this sort of functionality into it. If the recognition ever becomes reliable, this would be interesting to implement.

There is a trade-off between camera quality and image recognition success. In the first stages of our image recognition process, we worked with images of much higher resolution, and found that we had much better success. On the other hand, we could have used higher powered classifiers (Support Vector Machines, for example) to classify the images, instead of our rather fragile manual tweaked approach.

=== Thanks To ===
* Mark Crosby and Gary Meyer for making us a camera mount.
* Dr. Rob Bunch for providing advice and lenses for the projector
* Dr. Zach Dodd at Harvey Mudd University for providing starting image recognition code.

[[Category:ECE497]]

ECE497 Project Set Playing Beagle

2011-05-17T02:56:26Z

Mayhewsw:

Team members: [[user:allensj | Samuel Allen]], [[user:mayhewsw | Stephen Mayhew]], [[user:J.ametsitsi | Julian Ametsitsi]]

== Executive Summary ==

The game Set uses a 3 x 4 grid of 12 cards that have different symbols on them. These symbols differ in shape, fill, and number. The goal is to find a set of three cards. See [http://www.setgame.com/set/rules_set.htm here] for Set game instructions.

Using the BeagleBoard, we have developed a system that uses a webcam to take a picture of the cards in play and uses OpenCV and Python to find the sets from the picture.

Our system correctly identifies all of the sets in the hand that the image recognition provides.

It can run completely on the Beagleboard and processes aproximately 1 frame per second.

Currently, the image recognition is the downfall to our success. The image recognition does not find the correct symbols on the cards, and so the rest of the system does not find the correct sets.

The sets that are found are correct for the found cards, but not the actual cards in play.

Our system is almost functional, but there are still some problems that need to be overcome.
The image recognition is the biggest hurdle that we need to overcome and after that is completed, the system will work correctly.

== Installation Instructions ==
* First clone our github repository: git@github.com:mayhewsw/BeagleSetGame.git
<pre>git clone git@github.com:mayhewsw/BeagleSetGame.git </pre>
* The SPEd image comes with OpenCV already installed, but if you do not have it, you will need it.
<pre> $ opkg install opencv </pre>
* Install python-opencv
<pre> $ opkg install python-opencv </pre>
* You will also need a webcam and a way to mount it. We used a Sony Playstation Eye, but any webcam with at least 640x480 resolution should work. Our mount held the camera about 7 inches above the playing surface, and had it pointing straight down.

== User Instructions ==

Once everything is installed, how do you use the program? Give details here, so if you have a long user manual, link to it here.

* First, run the autogain executable. If you are using the SPEd2 Angstrom image, then this executable is found the root directory.

* Next, run trackbartest.py. When this runs, it opens up 2 images. One of the images is streaming live from the webcam, and it has slider bars that set the properties for the camera. The other image is a reference image. Slide the bars until the live image looks like the reference image.
<pre> $ python trackbartest.py </pre>
Once you have found a configuration you like, press enter. This will save those values to a file called cameraConfig.cfg, which is read later. Exit the window by pressing Escape.
* Now you can run the actual program, runner.py.
<pre> $ python runner.py </pre>
This will open up 2 windows. One window is an image of what the camera sees, the other window is the same image, but with the results of the processing overlaid onto it. Because of the current state of the image recognition, these results are often very wrong, but they are also affected by how close the camera configuration is.

When the program finds a set in the recognized cards, it will print out the result to the console, and wait for a keypress to continue. Make sure one of the images has focus, and press any key.

You can quit the program either by pressing Enter while the program is in the ordinary recognizing loop, or by doing Ctrl-C in the terminal.

== Highlights ==

The interest of our project is in how it demonstrates the use of OpenCV on the Beagleboard. It shows that OpenCV functionality on the Beagleboard is very similar to what one would find on any other computer, if a little slower.

== Theory of Operation ==

=== Program Flow ===
There are 2 steps to running the project: configuration and running.

In the configuration step, it simply creates trackbars that set camera configuration options as they change position. When the user presses enter, it saves the 3 values (brightness, contrast, and hue) to a file, cameraConfig.cfg.

In the running step, there is a file called runner.py that contains the main loop. Before it enters the main loop, it opens and reads cameraConfig.cfg and sets the camera properties accordingly. Inside the main loop, it runs three separate functions (all found in processCards.py) to recognize the cards. The first function, extractCards, finds symbols in the image, and groups them by location, and returns those groups. Each group is made up of rectangles which represent the bounding boxes of the symbols on any given card. Thus, each group is of size one, two, or three. The next function, getMeaningFromCards, takes the cards and classifies each of them, and returns a list of Card objects (defined in processCards). Next, this list of Card objects is passed to the SolveGame function, which finds sets.

=== Image Recognition ===
* To find fill: the program examines the center line of the symbol, and a line of the same length on the white part of the card, just to the left of the symbol, and compares their intensities. In order to set intensity thresholds correctly, there is a preprocessing loop at the beginning of the extractMeaningFromCards function.
* To find color: the program sets a mask around the image, and colors the background to black. Then it converts the image to HSV, increases the saturation by some amount, and converts back to BGR. It splits this image into channels and gets the sum of the entire channel. The max value of the sum decides on the color.
* To find shape: the program finds the contour of the symbol subimage, and divides the bounding box of the symbol by the perimeter of the symbol. This ratio is naively used as the decider.

== Work Breakdown ==

Finished:
{| border="1"
|-
|Sam Allen || Did some work on getting the camera values set correctly so that the image was more usable.
|-
|Julian Ametsitsi || Tested using TI Pico Projector to project indication of set of card. Developed algorithm with Stephen to identify individual cards in a single image.
|-
|Stephen Mayhew || Tweaking and customization of image recognition code. Software integration with hardware.
|}

To be finished:
{| border="1"
|-
| Better image classification || Stephen - if it gets done, it will be done during 10th week
|-
| Espeak integration || Sam - if it gets done, it will be done during 10th week
|}

== Conclusions ==
We were pleased with how well the Beagleboard runs OpenCV. It was not at all difficult to install and run. While it is noticeably slower than on larger machines, it is not prohibitively so.

Originally, it was in the scope to have a projector project indication of sets back onto the actual cards. We had planned to use a DLP Pico projector for this, but we found early on that the Pico projector projects at a very small resolution, and we would have had to mount it significantly higher than the camera if it was to cover the whole playing area. We experimented with putting lenses in front of the projector to magnify it, but this turned out to be much more difficult than we imagined, so we focused our efforts on the image recognition, and on making the system coherent and smooth.

Another facet of the original idea was to have the computer actually playing against humans. This would involve the computer accepting input when a human found a set. Since the computer turned out to be so bad at actually playing the game, it was never worth putting this sort of functionality into it. If the recognition ever becomes reliable, this would be interesting to implement.

There is a trade-off between camera quality and image recognition success. In the first stages of our image recognition process, we worked with images of much higher resolution, and found that we had much better success. On the other hand, we could have used higher powered classifiers (Support Vector Machines, for example) to classify the images, instead of our rather fragile manual tweaked approach.

=== Thanks ===
Thanks to
* Mark Crosby and Gary Meyer for making us a camera mount.
* Dr. Rob Bunch for providing advice and lenses for the projector
* Dr. Zach Dodd at Harvey Mudd University for providing starting image recognition code.

[[Category:ECE497]]

ECE497 Project Set Playing Beagle

2011-05-17T02:54:23Z

Mayhewsw:

Team members: [[user:allensj | Samuel Allen]], [[user:mayhewsw | Stephen Mayhew]], [[user:J.ametsitsi | Julian Ametsitsi]]

== Executive Summary ==

The game Set uses a 3 x 4 grid of 12 cards that have different symbols on them. These symbols differ in shape, fill, and number. The goal is to find a set of three cards. See [http://www.setgame.com/set/rules_set.htm here] for Set game instructions.

Using the BeagleBoard, we have developed a system that uses a webcam to take a picture of the cards in play and uses OpenCV and Python to find the sets from the picture.

Our system correctly identifies all of the sets in the hand that the image recognition provides.

It can run completely on the Beagleboard and processes aproximately 1 frame per second.

Currently, the image recognition is the downfall to our success. The image recognition does not find the correct symbols on the cards, and so the rest of the system does not find the correct sets.

The sets that are found are correct for the found cards, but not the actual cards in play.

Our system is almost functional, but there are still some problems that need to be overcome.
The image recognition is the biggest hurdle that we need to overcome and after that is completed, the system will work correctly.

== Installation Instructions ==
* First clone our github repository: git@github.com:mayhewsw/BeagleSetGame.git
<pre>git clone git@github.com:mayhewsw/BeagleSetGame.git </pre>
* The SPEd image comes with OpenCV already installed, but if you do not have it, you will need it.
<pre> $ opkg install opencv </pre>
* Install python-opencv
<pre> $ opkg install python-opencv </pre>
* You will also need a webcam and a way to mount it. We used a Sony Playstation Eye, but any webcam with at least 640x480 resolution should work. Our mount held the camera about 7 inches above the playing surface, and had it pointing straight down.

== User Instructions ==

Once everything is installed, how do you use the program? Give details here, so if you have a long user manual, link to it here.

* First, run the autogain executable. If you are using the SPEd2 Angstrom image, then this executable is found the root directory.

* Next, run trackbartest.py. When this runs, it opens up 2 images. One of the images is streaming live from the webcam, and it has slider bars that set the properties for the camera. The other image is a reference image. Slide the bars until the live image looks like the reference image.
<pre> $ python trackbartest.py </pre>
Once you have found a configuration you like, press enter. This will save those values to a file called cameraConfig.cfg, which is read later. Exit the window by pressing Escape.
* Now you can run the actual program, runner.py.
<pre> $ python runner.py </pre>
This will open up 2 windows. One window is an image of what the camera sees, the other window is the same image, but with the results of the processing overlaid onto it. Because of the current state of the image recognition, these results are often very wrong, but they are also affected by how close the camera configuration is.

When the program finds a set in the recognized cards, it will print out the result to the console, and wait for a keypress to continue. Make sure one of the images has focus, and press any key.

You can quit the program either by pressing Enter while the program is in the ordinary recognizing loop, or by doing Ctrl-C in the terminal.

== Highlights ==

The interest of our project is in how it demonstrates the use of OpenCV on the Beagleboard. It shows that OpenCV functionality on the Beagleboard is very similar to what one would find on any other computer, if a little slower.

== Theory of Operation ==

=== Program Flow ===
There are 2 steps to running the project: configuration and running.

In the configuration step, it simply creates trackbars that set camera configuration options as they change position. When the user presses enter, it saves the 3 values (brightness, contrast, and hue) to a file, cameraConfig.cfg.

In the running step, there is a file called runner.py that contains the main loop. Before it enters the main loop, it opens and reads cameraConfig.cfg and sets the camera properties accordingly. Inside the main loop, it runs three separate functions (all found in processCards.py) to recognize the cards. The first function, extractCards, finds symbols in the image, and groups them by location, and returns those groups. Each group is made up of rectangles which represent the bounding boxes of the symbols on any given card. Thus, each group is of size one, two, or three. The next function, getMeaningFromCards, takes the cards and classifies each of them, and returns a list of Card objects (defined in processCards). Next, this list of Card objects is passed to the SolveGame function, which finds sets.

=== Image Recognition ===
* To find fill: the program examines the center line of the symbol, and a line of the same length on the white part of the card, just to the left of the symbol, and compares their intensities. In order to set intensity thresholds correctly, there is a preprocessing loop at the beginning of the extractMeaningFromCards function.
* To find color: the program sets a mask around the image, and colors the background to black. Then it converts the image to HSV, increases the saturation by some amount, and converts back to BGR. It splits this image into channels and gets the sum of the entire channel. The max value of the sum decides on the color.
* To find shape: the program finds the contour of the symbol subimage, and divides the bounding box of the symbol by the perimeter of the symbol. This ratio is naively used as the decider.

== Work Breakdown ==

Finished:
{| border="1"
|-
|Sam Allen || Did some work on getting the camera values set correctly so that the image was more usable.
|-
|Julian Ametsitsi || Tested using TI Pico Projector to project indication of set of card. Developed algorithm with Stephen to identify individual cards in a single image.
|-
|Stephen Mayhew ||
|}

To be finished:
{| border="1"
|-
| Better image classification || Stephen - if it gets done, it will be done during 10th week
|-
| Espeak integration || Sam - if it gets done, it will be done during 10th week
|}

== Conclusions ==
We were pleased with how well the Beagleboard runs OpenCV. It was not at all difficult to install and run. While it is noticeably slower than on larger machines, it is not prohibitively so.

Originally, it was in the scope to have a projector project indication of sets back onto the actual cards. We had planned to use a DLP Pico projector for this, but we found early on that the Pico projector projects at a very small resolution, and we would have had to mount it significantly higher than the camera if it was to cover the whole playing area. We experimented with putting lenses in front of the projector to magnify it, but this turned out to be much more difficult than we imagined, so we focused our efforts on the image recognition, and on making the system coherent and smooth.

Another facet of the original idea was to have the computer actually playing against humans. This would involve the computer accepting input when a human found a set. Since the computer turned out to be so bad at actually playing the game, it was never worth putting this sort of functionality into it. If the recognition ever becomes reliable, this would be interesting to implement.

There is a trade-off between camera quality and image recognition success. In the first stages of our image recognition process, we worked with images of much higher resolution, and found that we had much better success. On the other hand, we could have used higher powered classifiers (Support Vector Machines, for example) to classify the images, instead of our rather fragile manual tweaked approach.

=== Thanks ===
Thanks to
* Mark Crosby and Gary Meyer for making us a camera mount.
* Dr. Rob Bunch for providing advice and lenses for the projector
* Dr. Zach Dodd at Harvey Mudd University for providing starting image recognition code.

[[Category:ECE497]]

ECE497 Project Set Playing Beagle

2011-05-17T02:53:48Z

Mayhewsw:

Team members: [[user:allensj | Samuel Allen]], [[user:mayhewsw | Stephen Mayhew]], [[user:J.ametsitsi | Julian Ametsitsi]]

== Executive Summary ==

The game Set uses a 3 x 4 grid of 12 cards that have different symbols on them. These symbols differ in shape, fill, and number. The goal is to find a set of three cards. See [http://www.setgame.com/set/rules_set.htm here] for Set game instructions.

Using the BeagleBoard, we have developed a system that uses a webcam to take a picture of the cards in play and uses OpenCV and Python to find the sets from the picture.

Our system correctly identifies all of the sets in the hand that the image recognition provides.

It can run completely on the Beagleboard and processes aproximately 1 frame per second.

Currently, the image recognition is the downfall to our success. The image recognition does not find the correct symbols on the cards, and so the rest of the system does not find the correct sets.

The sets that are found are correct for the found cards, but not the actual cards in play.

Our system is almost functional, but there are still some problems that need to be overcome.
The image recognition is the biggest hurdle that we need to overcome and after that is completed, the system will work correctly.

== Installation Instructions ==
* First clone our github repository: git@github.com:mayhewsw/BeagleSetGame.git
<pre>git clone git@github.com:mayhewsw/BeagleSetGame.git </pre>
* The SPEd image comes with OpenCV already installed, but if you do not have it, you will need it.
<pre> $ opkg install opencv </pre>
* Install python-opencv
<pre> $ opkg install python-opencv </pre>
* You will also need a webcam and a way to mount it. We used a Sony Playstation Eye, but any webcam with at least 640x480 resolution should work. Our mount held the camera about 7 inches above the playing surface, and had it pointing straight down.

== User Instructions ==

Once everything is installed, how do you use the program? Give details here, so if you have a long user manual, link to it here.

* First, run the autogain executable. If you are using the SPEd2 Angstrom image, then this executable is found the root directory.

* Next, run trackbartest.py. When this runs, it opens up 2 images. One of the images is streaming live from the webcam, and it has slider bars that set the properties for the camera. The other image is a reference image. Slide the bars until the live image looks like the reference image.
<pre> $ python trackbartest.py </pre>
Once you have found a configuration you like, press enter. This will save those values to a file called cameraConfig.cfg, which is read later. Exit the window by pressing Escape.
* Now you can run the actual program, runner.py.
<pre> $ python runner.py </pre>
This will open up 2 windows. One window is an image of what the camera sees, the other window is the same image, but with the results of the processing overlaid onto it. Because of the current state of the image recognition, these results are often very wrong, but they are also affected by how close the camera configuration is.

When the program finds a set in the recognized cards, it will print out the result to the console, and wait for a keypress to continue. Make sure one of the images has focus, and press any key.

You can quit the program either by pressing Enter while the program is in the ordinary recognizing loop, or by doing Ctrl-C in the terminal.

== Highlights ==

The interest of our project is in how it demonstrates the use of OpenCV on the Beagleboard. It shows that OpenCV functionality on the Beagleboard is very similar to what one would find on any other computer, if a little slower.

== Theory of Operation ==

=== Program Flow ===
There are 2 steps to running the project: configuration and running.

In the configuration step, it simply creates trackbars that set camera configuration options as they change position. When the user presses enter, it saves the 3 values (brightness, contrast, and hue) to a file, cameraConfig.cfg.

In the running step, there is a file called runner.py that contains the main loop. Before it enters the main loop, it opens and reads cameraConfig.cfg and sets the camera properties accordingly. Inside the main loop, it runs three separate functions (all found in processCards.py) to recognize the cards. The first function, extractCards, finds symbols in the image, and groups them by location, and returns those groups. Each group is made up of rectangles which represent the bounding boxes of the symbols on any given card. Thus, each group is of size one, two, or three. The next function, getMeaningFromCards, takes the cards and classifies each of them, and returns a list of Card objects (defined in processCards). Next, this list of Card objects is passed to the SolveGame function, which finds sets.

=== Image Recognition ===
* To find fill: the program examines the center line of the symbol, and a line of the same length on the white part of the card, just to the left of the symbol, and compares their intensities. In order to set intensity thresholds correctly, there is a preprocessing loop at the beginning of the extractMeaningFromCards function.
* To find color: the program sets a mask around the image, and colors the background to black. Then it converts the image to HSV, increases the saturation by some amount, and converts back to BGR. It splits this image into channels and gets the sum of the entire channel. The max value of the sum decides on the color.
* To find shape: the program finds the contour of the symbol subimage, and divides the bounding box of the symbol by the perimeter of the symbol. This ratio is naively used as the decider.

== Work Breakdown ==

Finished:
{| border="1"
|-
|Sam Allen || Did some work on getting the camera values set correctly so that the image was more usable.
|-
|Julian Ametsitsi || Tested using TI Pico Projector to project indication of set of card. Developed algorithm with Stephen to identify individual cards in a single image.
|-
|Stephen Mayhew ||
|}

To be finished:
{| border="1"
|-
| Better image classification || Stephen - if it gets done, it will be done during 10th week
|-
| Espeak integration || Sam - if it gets done, it will be done during 10th week
|}

== Conclusions ==
We were pleased with how well the Beagleboard runs OpenCV. It was not at all difficult to install and run. While it is noticeably slower than on larger machines, it is not prohibitively so.

Originally, it was in the scope to have a projector project indication of sets back onto the actual cards. We had planned to use a DLP Pico projector for this, but we found early on that the Pico projector projects at a very small resolution, and we would have had to mount it significantly higher than the camera if it was to cover the whole playing area. We experimented with putting lenses in front of the projector to magnify it, but this turned out to be much more difficult than we imagined, so we focused our efforts on the image recognition, and on making the system coherent and smooth.

Another facet of the original idea was to have the computer actually playing against humans. This would involve the computer accepting input when a human found a set. Since the computer turned out to be so bad at actually playing the game, it was never worth putting this sort of functionality into it. If the recognition ever becomes reliable, this would be interesting to implement.

There is a trade-off between camera quality and image recognition success. In the first stages of our image recognition process, we worked with images of much higher resolution, and found that we had much better success. On the other hand, we could have used higher powered classifiers (Support Vector Machines, for example) to classify the images, instead of our rather fragile manual tweaked approach.

=== Thanks ===
Thanks to
* Mark Crosby and Gary Meyer for making us a camera mount.
* Dr. Rob Bunch for providing advice and lenses for the projector
* Dr. Zach Dodd at Harvey Mudd University for providing starting image recognition code.

[[Category:ECE497]]

ECE497 Project Set Playing Beagle

2011-05-17T02:53:18Z

Mayhewsw:

Team members: [[user:allensj | Samuel Allen]], [[user:mayhewsw | Stephen Mayhew]], [[user:J.ametsitsi | Julian Ametsitsi]]

== Executive Summary ==

The game Set uses a 3 x 4 grid of 12 cards that have different symbols on them. These symbols differ in shape, fill, and number. The goal is to find a set of three cards. See [http://www.setgame.com/set/rules_set.htm here] for Set game instructions.

Using the BeagleBoard, we have developed a system that uses a webcam to take a picture of the cards in play and uses OpenCV and Python to find the sets from the picture.

Our system correctly identifies all of the sets in the hand that the image recognition provides.

It can run completely on the Beagleboard and processes aproximately 1 frame per second.

Currently, the image recognition is the downfall to our success. The image recognition does not find the correct symbols on the cards, and so the rest of the system does not find the correct sets.

The sets that are found are correct for the found cards, but not the actual cards in play.

Our system is almost functional, but there are still some problems that need to be overcome.
The image recognition is the biggest hurdle that we need to overcome and after that is completed, the system will work correctly.

== Installation Instructions ==
* First clone our github repository: git@github.com:mayhewsw/BeagleSetGame.git
<pre>git clone git@github.com:mayhewsw/BeagleSetGame.git </pre>
* The SPEd image comes with OpenCV already installed, but if you do not have it, you will need it.
<pre> $ opkg install opencv </pre>
* Install python-opencv
<pre> $ opkg install python-opencv </pre>
* You will also need a webcam and a way to mount it. We used a Sony Playstation Eye, but any webcam with at least 640x480 resolution should work. Our mount held the camera about 7 inches above the playing surface, and had it pointing straight down.

== User Instructions ==

Once everything is installed, how do you use the program? Give details here, so if you have a long user manual, link to it here.

* First, run the autogain executable. If you are using the SPEd2 Angstrom image, then this executable is found the root directory.

* Next, run trackbartest.py. When this runs, it opens up 2 images. One of the images is streaming live from the webcam, and it has slider bars that set the properties for the camera. The other image is a reference image. Slide the bars until the live image looks like the reference image.
<pre> $ python trackbartest.py </pre>
Once you have found a configuration you like, press enter. This will save those values to a file called cameraConfig.cfg, which is read later. Exit the window by pressing Escape.
* Now you can run the actual program, runner.py.
<pre> $ python runner.py </pre>
This will open up 2 windows. One window is an image of what the camera sees, the other window is the same image, but with the results of the processing overlaid onto it. Because of the current state of the image recognition, these results are often very wrong, but they are also affected by how close the camera configuration is.

When the program finds a set in the recognized cards, it will print out the result to the console, and wait for a keypress to continue. Make sure one of the images has focus, and press any key.

You can quit the program either by pressing Enter while the program is in the ordinary recognizing loop, or by doing Ctrl-C in the terminal.

== Highlights ==

The interest of our project is in how it demonstrates the use of OpenCV on the Beagleboard. It shows that OpenCV functionality on the Beagleboard is very similar to what one would find on any other computer, if a little slower.

== Theory of Operation ==

=== Program Flow ===
There are 2 steps to running the project: configuration and running.

In the configuration step, it simply creates trackbars that set camera configuration options as they change position. When the user presses enter, it saves the 3 values (brightness, contrast, and hue) to a file, cameraConfig.cfg.

In the running step, there is a file called runner.py that contains the main loop. Before it enters the main loop, it opens and reads cameraConfig.cfg and sets the camera properties accordingly. Inside the main loop, it runs three separate functions (all found in processCards.py) to recognize the cards. The first function, extractCards, finds symbols in the image, and groups them by location, and returns those groups. Each group is made up of rectangles which represent the bounding boxes of the symbols on any given card. Thus, each group is of size one, two, or three. The next function, getMeaningFromCards, takes the cards and classifies each of them, and returns a list of Card objects (defined in processCards). Next, this list of Card objects is passed to the SolveGame function, which finds sets.

=== Image Recognition ===
* To find fill: the program examines the center line of the symbol, and a line of the same length on the white part of the card, just to the left of the symbol, and compares their intensities. In order to set intensity thresholds correctly, there is a preprocessing loop at the beginning of the extractMeaningFromCards function.
* To find color: the program sets a mask around the image, and colors the background to black. Then it converts the image to HSV, increases the saturation by some amount, and converts back to BGR. It splits this image into channels and gets the sum of the entire channel. The max value of the sum decides on the color.
* To find shape: the program finds the contour of the symbol subimage, and divides the bounding box of the symbol by the perimeter of the symbol. This ratio is naively used as the decider.

== Work Breakdown ==

Finished:
{| border="1"
|-
|Sam Allen || Did some work on getting the camera values set correctly so that the image was more usable.
|-
|Julian Ametsitsi || Tested using TI Pico Projector to project indication of set of card. Developed algorithm with Stephen to identify individual cards in a single image.
|-
|Stephen Mayhew ||
|}

To be finished:
{| border="1"
|-
| Better image classification || Stephen - if it gets done, it will be done during 10th week
|-
| Espeak integration || Sam - if it gets done, it will be done during 10th week
|}

Also list here what doesn't work yet and when you think it will be finished and who is finishing it.

== Conclusions ==
We were pleased with how well the Beagleboard runs OpenCV. It was not at all difficult to install and run. While it is noticeably slower than on larger machines, it is not prohibitively so.

Originally, it was in the scope to have a projector project indication of sets back onto the actual cards. We had planned to use a DLP Pico projector for this, but we found early on that the Pico projector projects at a very small resolution, and we would have had to mount it significantly higher than the camera if it was to cover the whole playing area. We experimented with putting lenses in front of the projector to magnify it, but this turned out to be much more difficult than we imagined, so we focused our efforts on the image recognition, and on making the system coherent and smooth.

Another facet of the original idea was to have the computer actually playing against humans. This would involve the computer accepting input when a human found a set. Since the computer turned out to be so bad at actually playing the game, it was never worth putting this sort of functionality into it. If the recognition ever becomes reliable, this would be interesting to implement.

There is a trade-off between camera quality and image recognition success. In the first stages of our image recognition process, we worked with images of much higher resolution, and found that we had much better success. On the other hand, we could have used higher powered classifiers (Support Vector Machines, for example) to classify the images, instead of our rather fragile manual tweaked approach.

=== Thanks ===
Thanks to
* Mark Crosby and Gary Meyer for making us a camera mount.
* Dr. Rob Bunch for providing advice and lenses for the projector
* Dr. Zach Dodd at Harvey Mudd University for providing starting image recognition code.

[[Category:ECE497]]

ECE497 Project Set Playing Beagle

2011-05-17T02:43:22Z

Mayhewsw:

Team members: [[user:allensj | Samuel Allen]], [[user:mayhewsw | Stephen Mayhew]], [[user:J.ametsitsi | Julian Ametsitsi]]

== Executive Summary ==

The game Set uses a 3 x 4 grid of 12 cards that have different symbols on them. These symbols differ in shape, fill, and number. The goal is to find a set of three cards. See [http://www.setgame.com/set/rules_set.htm here] for Set game instructions.

Using the BeagleBoard, we have developed a system that uses a webcam to take a picture of the cards in play and uses OpenCV and Python to find the sets from the picture.

Our system correctly identifies all of the sets in the hand that the image recognition provides.

It can run completely on the Beagleboard and processes aproximately 1 frame per second.

Currently, the image recognition is the downfall to our success. The image recognition does not find the correct symbols on the cards, and so the rest of the system does not find the correct sets.

The sets that are found are correct for the found cards, but not the actual cards in play.

Our system is almost functional, but there are still some problems that need to be overcome.
The image recognition is the biggest hurdle that we need to overcome and after that is completed, the system will work correctly.

== Installation Instructions ==
* First clone our github repository: git@github.com:mayhewsw/BeagleSetGame.git
<pre>git clone git@github.com:mayhewsw/BeagleSetGame.git </pre>
* The SPEd image comes with OpenCV already installed, but if you do not have it, you will need it.
<pre> $ opkg install opencv </pre>
* Install python-opencv
<pre> $ opkg install python-opencv </pre>
* You will also need a webcam and a way to mount it. We used a Sony Playstation Eye, but any webcam with at least 640x480 resolution should work. Our mount held the camera about 7 inches above the playing surface, and had it pointing straight down.

== User Instructions ==

Once everything is installed, how do you use the program? Give details here, so if you have a long user manual, link to it here.

* First, run the autogain executable. If you are using the SPEd2 Angstrom image, then this executable is found the root directory.

* Next, run trackbartest.py. When this runs, it opens up 2 images. One of the images is streaming live from the webcam, and it has slider bars that set the properties for the camera. The other image is a reference image. Slide the bars until the live image looks like the reference image.
<pre> $ python trackbartest.py </pre>
Once you have found a configuration you like, press enter. This will save those values to a file called cameraConfig.cfg, which is read later. Exit the window by pressing Escape.
* Now you can run the actual program, runner.py.
<pre> $ python runner.py </pre>
This will open up 2 windows. One window is an image of what the camera sees, the other window is the same image, but with the results of the processing overlaid onto it. Because of the current state of the image recognition, these results are often very wrong, but they are also affected by how close the camera configuration is.

When the program finds a set in the recognized cards, it will print out the result to the console, and wait for a keypress to continue. Make sure one of the images has focus, and press any key.

You can quit the program either by pressing Enter while the program is in the ordinary recognizing loop, or by doing Ctrl-C in the terminal.

== Highlights ==

The interest of our project is in how it demonstrates the use of OpenCV on the Beagleboard. It shows that OpenCV functionality on the Beagleboard is very similar to what one would find on any other computer, if a little slower.

== Theory of Operation ==

=== Program Flow ===
There are 2 steps to running the project: configuration and running.

In the configuration step, it simply creates trackbars that set camera configuration options as they change position. When the user presses enter, it saves the 3 values (brightness, contrast, and hue) to a file, cameraConfig.cfg.

In the running step, there is a file called runner.py that contains the main loop. Before it enters the main loop, it opens and reads cameraConfig.cfg and sets the camera properties accordingly. Inside the main loop, it runs three separate functions (all found in processCards.py) to recognize the cards. The first function, extractCards, finds symbols in the image, and groups them by location, and returns those groups. Each group is made up of rectangles which represent the bounding boxes of the symbols on any given card. Thus, each group is of size one, two, or three. The next function, getMeaningFromCards, takes the cards and classifies each of them, and returns a list of Card objects (defined in processCards). Next, this list of Card objects is passed to the SolveGame function, which finds sets.

=== Image Recognition ===
* To find fill: the program examines the center line of the symbol, and a line of the same length on the white part of the card, just to the left of the symbol, and compares their intensities. In order to set intensity thresholds correctly, there is a preprocessing loop at the beginning of the extractMeaningFromCards function.
* To find color: the program sets a mask around the image, and colors the background to black. Then it converts the image to HSV, increases the saturation by some amount, and converts back to BGR. It splits this image into channels and gets the sum of the entire channel. The max value of the sum decides on the color.
* To find shape: the program finds the contour of the symbol subimage, and divides the bounding box of the symbol by the perimeter of the symbol. This ratio is naively used as the decider.

== Work Breakdown ==

{| border="1"
|-
|Sam Allen || Did some work on getting the camera values set correctly so that the image was more usable.
|-
|Julian Ametsitsi || Tested using TI Pico Projector to project indication of set of card. Developed algorithm with Stephen to identify individual cards in a single image.
|-
|Stephen Mayhew ||
|}

List the major tasks in your project and who did what.

Also list here what doesn't work yet and when you think it will be finished and who is finishing it.

== Conclusions ==
We were pleased with how well the Beagleboard runs OpenCV. It was not at all difficult to install and run. While it is noticeably slower than on larger machines, it is not prohibitively so.

Originally, it was in the scope to have a projector project indication of sets back onto the actual cards. We had planned to use a DLP Pico projector for this, but we found early on that the Pico projector projects at a very small resolution, and we would have had to mount it significantly higher than the camera if it was to cover the whole playing area. We experimented with putting lenses in front of the projector to magnify it, but this turned out to be much more difficult than we imagined, so we focused our efforts on the image recognition, and on making the system coherent and smooth.

Another facet of the original idea was to have the computer actually playing against humans. This would involve the computer accepting input when a human found a set. Since the computer turned out to be so bad at actually playing the game, it was never worth putting this sort of functionality into it. If the recognition ever becomes reliable, this would be interesting to implement.

There is a trade-off between camera quality and image recognition success. In the first stages of our image recognition process, we worked with images of much higher resolution, and found that we had much better success. On the other hand, we could have used higher powered classifiers (Support Vector Machines, for example) to classify the images, instead of our rather fragile manual tweaked approach.

=== Thanks ===
Thanks to
* Mark Crosby and Gary Meyer for making us a camera mount.
* Dr. Rob Bunch for providing advice and lenses for the projector
* Dr. Zach Dodd at Harvey Mudd University for providing starting image recognition code.

[[Category:ECE497]]

ECE497 Project Set Playing Beagle

2011-05-17T02:38:44Z

Mayhewsw:

Team members: [[user:allensj | Samuel Allen]], [[user:mayhewsw | Stephen Mayhew]], [[user:J.ametsitsi | Julian Ametsitsi]]

== Executive Summary ==

The game Set uses a 3 x 4 grid of 12 cards that have different symbols on them. These symbols differ in shape, fill, and number. The goal is to find a set of three cards. See [http://www.setgame.com/set/rules_set.htm here] for Set game instructions.

Using the BeagleBoard, we have developed a system that uses a webcam to take a picture of the cards in play and uses OpenCV and Python to find the sets from the picture.

Our system correctly identifies all of the sets in the hand that the image recognition provides.

It can run completely on the Beagleboard and processes aproximately 1 frame per second.

Currently, the image recognition is the downfall to our success. The image recognition does not find the correct symbols on the cards, and so the rest of the system does not find the correct sets.

The sets that are found are correct for the found cards, but not the actual cards in play.

Our system is almost functional, but there are still some problems that need to be overcome.
The image recognition is the biggest hurdle that we need to overcome and after that is completed, the system will work correctly.

== Installation Instructions ==
* First clone our github repository: git@github.com:mayhewsw/BeagleSetGame.git
<pre>git clone git@github.com:mayhewsw/BeagleSetGame.git </pre>
* The SPEd image comes with OpenCV already installed, but if you do not have it, you will need it.
<pre> $ opkg install opencv </pre>
* Install python-opencv
<pre> $ opkg install python-opencv </pre>
* You will also need a webcam and a way to mount it. We used a Sony Playstation Eye, but any webcam with at least 640x480 resolution should work. Our mount held the camera about 7 inches above the playing surface, and had it pointing straight down.

== User Instructions ==

Once everything is installed, how do you use the program? Give details here, so if you have a long user manual, link to it here.

* First, run the autogain executable. If you are using the SPEd2 Angstrom image, then this executable is found the root directory.

* Next, run trackbartest.py. When this runs, it opens up 2 images. One of the images is streaming live from the webcam, and it has slider bars that set the properties for the camera. The other image is a reference image. Slide the bars until the live image looks like the reference image.
<pre> $ python trackbartest.py </pre>
Once you have found a configuration you like, press enter. This will save those values to a file called cameraConfig.cfg, which is read later. Exit the window by pressing Escape.
* Now you can run the actual program, runner.py.
<pre> $ python runner.py </pre>
This will open up 2 windows. One window is an image of what the camera sees, the other window is the same image, but with the results of the processing overlaid onto it. Because of the current state of the image recognition, these results are often very wrong, but they are also affected by how close the camera configuration is.

When the program finds a set in the recognized cards, it will print out the result to the console, and wait for a keypress to continue. Make sure one of the images has focus, and press any key.

You can quit the program either by pressing Enter while the program is in the ordinary recognizing loop, or by doing Ctrl-C in the terminal.

== Highlights ==

The interest of our project is in how it demonstrates the use of OpenCV on the Beagleboard. It shows that OpenCV functionality on the Beagleboard is very similar to what one would find on any other computer, if a little slower.

== Theory of Operation ==

=== Program Flow ===
There are 2 steps to running the project: configuration and running.

In the configuration step, it simply creates trackbars that set camera configuration options as they change position. When the user presses enter, it saves the 3 values (brightness, contrast, and hue) to a file, cameraConfig.cfg.

In the running step, there is a file called runner.py that contains the main loop. Before it enters the main loop, it opens and reads cameraConfig.cfg and sets the camera properties accordingly. Inside the main loop, it runs three separate functions (all found in processCards.py) to recognize the cards. The first function, extractCards, finds symbols in the image, and groups them by location, and returns those groups. Each group is made up of rectangles which represent the bounding boxes of the symbols on any given card. Thus, each group is of size one, two, or three. The next function, getMeaningFromCards, takes the cards and classifies each of them, and returns a list of Card objects (defined in processCards). Next, this list of Card objects is passed to the SolveGame function, which finds sets.

=== Image Recognition ===
* To find fill: the program examines the center line of the symbol, and a line of the same length on the white part of the card, just to the left of the symbol, and compares their intensities. In order to set intensity thresholds correctly, there is a preprocessing loop at the beginning of the extractMeaningFromCards function.
* To find color: the program sets a mask around the image, and colors the background to black. Then it converts the image to HSV, increases the saturation by some amount, and converts back to BGR. It splits this image into channels and gets the sum of the entire channel. The max value of the sum decides on the color.
* To find shape: the program finds the contour of the symbol subimage, and divides the bounding box of the symbol by the perimeter of the symbol. This ratio is naively used as the decider.

== Work Breakdown ==

{| border="1"
|-
|Sam Allen || Did some work on getting the camera values set correctly so that the image was more usable.
|-
|Julian Ametsitsi || Tested using TI Pico Projector to project indication of set of card. Developed algorithm with Stephen to identify individual cards in a single image.
|-
|Stephen Mayhew ||
|}

List the major tasks in your project and who did what.

Also list here what doesn't work yet and when you think it will be finished and who is finishing it.

== Conclusions ==
We were pleased with how well the Beagleboard runs OpenCV.

Originally, it was in the scope to have a projector project indication of sets back onto the actual cards. We had planned to use a DLP Pico projector for this, but we found early on that the Pico projector projects at a very small resolution, and we would have had to mount it significantly higher than the camera if it was to cover the whole playing area. We experimented with putting lenses in front of the projector to magnify it, but this turned out to be much more difficult than we imagined, so we focused our efforts on the image recognition, and on making the system coherent and smooth.

Another facet of the original idea was to have the computer actually playing against humans. This would involve the computer accepting input when a human found a set. Since the computer turned out to be so bad at actually playing the game, it was never worth putting this sort of functionality into it. If the recognition ever becomes reliable, this would be interesting to implement.

There is a trade-off between camera quality and image recognition success. In the first stages of our image recognition process, we worked with images of much higher resolution, and found that we had much better success. On the other hand, we could have used higher powered classifiers (Support Vector Machines, for example) to classify the images, instead of our rather fragile manual tweaked approach.

=== Thanks ===
Thanks to
* Mark Crosby and Gary Meyer for making us a camera mount.
* Dr. Rob Bunch for providing advice and lenses for the projector
* Dr. Zach Dodd at Harvey Mudd University for providing starting image recognition code.

[[Category:ECE497]]

ECE497 Project Set Playing Beagle

2011-05-17T02:37:27Z

Mayhewsw:

Team members: [[user:allensj | Samuel Allen]], [[user:mayhewsw | Stephen Mayhew]], [[user:J.ametsitsi | Julian Ametsitsi]]

== Executive Summary ==

The game Set uses a 3 x 4 grid of 12 cards that have different symbols on them. These symbols differ in shape, fill, and number. The goal is to find a set of three cards. See [http://www.setgame.com/set/rules_set.htm here] for Set game instructions.

Using the BeagleBoard, we have developed a system that uses a webcam to take a picture of the cards in play and uses OpenCV and Python to find the sets from the picture.

Our system correctly identifies all of the sets in the hand that the image recognition provides.

It can run completely on the Beagleboard and processes aproximately 1 frame per second.

Currently, the image recognition is the downfall to our success. The image recognition does not find the correct symbols on the cards, and so the rest of the system does not find the correct sets.

The sets that are found are correct for the found cards, but not the actual cards in play.

Our system is almost functional, but there are still some problems that need to be overcome.
The image recognition is the biggest hurdle that we need to overcome and after that is completed, the system will work correctly.

== Installation Instructions ==
* First clone our github repository: git@github.com:mayhewsw/BeagleSetGame.git
<pre>git clone git@github.com:mayhewsw/BeagleSetGame.git </pre>
* The SPEd image comes with OpenCV already installed, but if you do not have it, you will need it.
<pre> $ opkg install opencv </pre>
* Install python-opencv
<pre> $ opkg install python-opencv </pre>
* You will also need a webcam and a way to mount it. We used a Sony Playstation Eye, but any webcam with at least 640x480 resolution should work. Our mount held the camera about 7 inches above the playing surface, and had it pointing straight down.

== User Instructions ==

Once everything is installed, how do you use the program? Give details here, so if you have a long user manual, link to it here.

* First, run the autogain executable. If you are using the SPEd2 Angstrom image, then this executable is found the root directory.

* Next, run trackbartest.py. When this runs, it opens up 2 images. One of the images is streaming live from the webcam, and it has slider bars that set the properties for the camera. The other image is a reference image. Slide the bars until the live image looks like the reference image.
<pre> $ python trackbartest.py </pre>
Once you have found a configuration you like, press enter. This will save those values to a file called cameraConfig.cfg, which is read later. Exit the window by pressing Escape.
* Now you can run the actual program, runner.py.
<pre> $ python runner.py </pre>
This will open up 2 windows. One window is an image of what the camera sees, the other window is the same image, but with the results of the processing overlaid onto it. Because of the current state of the image recognition, these results are often very wrong, but they are also affected by how close the camera configuration is.

When the program finds a set in the recognized cards, it will print out the result to the console, and wait for a keypress to continue. Make sure one of the images has focus, and press any key.

You can quit the program either by pressing Enter while the program is in the ordinary recognizing loop, or by doing Ctrl-C in the terminal.

== Highlights ==

The interest of our project is in how it demonstrates the use of OpenCV on the Beagleboard. It shows that OpenCV functionality on the Beagleboard is very similar to what one would find on any other computer, if a little slower.

== Theory of Operation ==

=== Program Flow ===
There are 2 steps to running the project: configuration and running.

In the configuration step, it simply creates trackbars that set camera configuration options as they change position. When the user presses enter, it saves the 3 values (brightness, contrast, and hue) to a file, cameraConfig.cfg.

In the running step, there is a file called runner.py that contains the main loop. Before it enters the main loop, it opens and reads cameraConfig.cfg and sets the camera properties accordingly. Inside the main loop, it runs three separate functions (all found in processCards.py) to recognize the cards. The first function, extractCards, finds symbols in the image, and groups them by location, and returns those groups. Each group is made up of rectangles which represent the bounding boxes of the symbols on any given card. Thus, each group is of size one, two, or three. The next function, getMeaningFromCards, takes the cards and classifies each of them, and returns a list of Card objects (defined in processCards). Next, this list of Card objects is passed to the SolveGame function, which finds sets.

=== Image Recognition ===
* To find fill: the program examines the center line of the symbol, and a line of the same length on the white part of the card, just to the left of the symbol, and compares their intensities. In order to set intensity thresholds correctly, there is a preprocessing loop at the beginning of the extractMeaningFromCards function.
* To find color: the program sets a mask around the image, and colors the background to black. Then it converts the image to HSV, increases the saturation by some amount, and converts back to BGR. It splits this image into channels and gets the sum of the entire channel. The max value of the sum decides on the color.
* To find shape: the program finds the contour of the symbol subimage, and divides the bounding box of the symbol by the perimeter of the symbol. This ratio is naively used as the decider.

== Work Breakdown ==

{| border="1"
|-
|Sam Allen || Did some work on getting the camera values set correctly so that the image was more usable.
|-
|Julian Ametsitsi || Tested using TI Pico Projector to project indication of set of card. Developed algorithm with Stephen to identify individual cards in a single image.
|-
|Stephen Mayhew ||
|}

List the major tasks in your project and who did what.

Also list here what doesn't work yet and when you think it will be finished and who is finishing it.

== Conclusions ==

Give some concluding thoughts about the project. Suggest some future additions that could make it even more interesting.

Originally, it was in the scope to have a projector project indication of sets back onto the actual cards. We had planned to use a DLP Pico projector for this, but we found early on that the Pico projector projects at a very small resolution, and we would have had to mount it significantly higher than the camera if it was to cover the whole playing area. We experimented with putting lenses in front of the projector to magnify it, but this turned out to be much more difficult than we imagined, so we focused our efforts on the image recognition, and on making the system coherent and smooth.

Another facet of the original idea was to have the computer actually playing against humans. This would involve the computer accepting input when a human found a set. Since the computer turned out to be so bad at actually playing the game, it was never worth putting this sort of functionality into it. If the recognition ever becomes reliable, this would be interesting to implement.

There is a trade-off between camera quality and image recognition success. In the first stages of our image recognition process, we worked with images of much higher resolution, and found that we had much better success. On the other hand, we could have used higher powered classifiers (Support Vector Machines, for example) to classify the images, instead of our rather fragile manual tweaked approach.

Thanks to:
* Mark Crosby and Gary Meyer for making us a camera mount.
* Dr. Rob Bunch for providing advice and lenses for the projector
* Dr. Zach Dodd at Harvey Mudd University for providing starting image recognition code.

[[Category:ECE497]]

ECE497 Project Set Playing Beagle

2011-05-17T02:34:46Z

Mayhewsw:

Team members: [[user:allensj | Samuel Allen]], [[user:mayhewsw | Stephen Mayhew]], [[user:J.ametsitsi | Julian Ametsitsi]]

== Executive Summary ==

The game Set uses a 3 x 4 grid of 12 cards that have different symbols on them. These symbols differ in shape, fill, and number. The goal is to find a set of three cards. See [http://www.setgame.com/set/rules_set.htm here] for Set game instructions.

Using the BeagleBoard, we have developed a system that uses a webcam to take a picture of the cards in play and uses OpenCV and Python to find the sets from the picture.

Our system correctly identifies all of the sets in the hand that the image recognition provides.

It can run completely on the Beagleboard and processes aproximately 1 frame per second.

Currently, the image recognition is the downfall to our success. The image recognition does not find the correct symbols on the cards, and so the rest of the system does not find the correct sets.

The sets that are found are correct for the found cards, but not the actual cards in play.

Our system is almost functional, but there are still some problems that need to be overcome.
The image recognition is the biggest hurdle that we need to overcome and after that is completed, the system will work correctly.

== Installation Instructions ==
* First clone our github repository: git@github.com:mayhewsw/BeagleSetGame.git
<pre>git clone git@github.com:mayhewsw/BeagleSetGame.git </pre>
* The SPEd image comes with OpenCV already installed, but if you do not have it, you will need it.
<pre> $ opkg install opencv </pre>
* Install python-opencv
<pre> $ opkg install python-opencv </pre>
* You will also need a webcam and a way to mount it. We used a Sony Playstation Eye, but any webcam with at least 640x480 resolution should work. Our mount held the camera about 7 inches above the playing surface, and had it pointing straight down.

== User Instructions ==

Once everything is installed, how do you use the program? Give details here, so if you have a long user manual, link to it here.

* First, run the autogain executable. If you are using the SPEd2 Angstrom image, then this executable is found the root directory.

* Next, run trackbartest.py. When this runs, it opens up 2 images. One of the images is streaming live from the webcam, and it has slider bars that set the properties for the camera. The other image is a reference image. Slide the bars until the live image looks like the reference image.
<pre> $ python trackbartest.py </pre>
Once you have found a configuration you like, press enter. This will save those values to a file called cameraConfig.cfg, which is read later. Exit the window by pressing Escape.
* Now you can run the actual program, runner.py.
<pre> $ python runner.py </pre>
This will open up 2 windows. One window is an image of what the camera sees, the other window is the same image, but with the results of the processing overlaid onto it. Because of the current state of the image recognition, these results are often very wrong, but they are also affected by how close the camera configuration is.

When the program finds a set in the recognized cards, it will print out the result to the console, and wait for a keypress to continue. Make sure one of the images has focus, and press any key.

You can quit the program either by pressing Enter while the program is in the ordinary recognizing loop, or by doing Ctrl-C in the terminal.

== Highlights ==

The interest of our project is in how it demonstrates the use of OpenCV on the Beagleboard. It shows that OpenCV functionality on the Beagleboard is very similar to what one would find on any other computer, if a little slower.

== Theory of Operation ==

=== Program Flow ===
There are 2 steps to running the project: configuration and running.

In the configuration step, it simply creates trackbars that set camera configuration options as they change position. When the user presses enter, it saves the 3 values (brightness, contrast, and hue) to a file, cameraConfig.cfg.

In the running step, there is a file called runner.py that contains the main loop. Before it enters the main loop, it opens and reads cameraConfig.cfg and sets the camera properties accordingly. Inside the main loop, it runs three separate functions (all found in processCards.py) to recognize the cards. The first function, extractCards, finds symbols in the image, and groups them by location, and returns those groups. Each group is made up of rectangles which represent the bounding boxes of the symbols on any given card. Thus, each group is of size one, two, or three. The next function, getMeaningFromCards, takes the cards and classifies each of them, and returns a list of Card objects (defined in processCards). Next, this list of Card objects is passed to the SolveGame function, which finds sets.

=== Image Recognition ===
* To find fill: the program examines the center line of the symbol, and a line of the same length on the white part of the card, just to the left of the symbol, and compares their intensities. In order to set intensity thresholds correctly, there is a preprocessing loop at the beginning of the extractMeaningFromCards function.
* To find color: the program sets a mask around the image, and colors the background to black. Then it converts the image to HSV, increases the saturation by some amount, and converts back to BGR. It splits this image into channels and gets the sum of the entire channel. The max value of the sum decides on the color.
* To find shape: the program finds the contour of the symbol subimage, and divides the bounding box of the symbol by the perimeter of the symbol. This ratio is naively used as the decider.

== Work Breakdown ==

{| border="1"
|-
|Sam Allen || Did some work on getting the camera values set correctly so that the image was more usable.
|-
|Julian Ametsitsi || Tested using TI Pico Projector to project indication of set of card. Developed algorithm with Stephen to identify individual cards in a single image.
|-
|Stephen Mayhew ||
|}

List the major tasks in your project and who did what.

Also list here what doesn't work yet and when you think it will be finished and who is finishing it.

== Conclusions ==

Give some concluding thoughts about the project. Suggest some future additions that could make it even more interesting.

Originally, it was in the scope to have a projector project indication of sets back onto the actual cards. We had planned to use a DLP Pico projector for this, but we found early on that the Pico projector projects at a very small resolution, and we would have had to mount it significantly higher than the camera if it was to cover the whole playing area. We experimented with putting lenses in front of the projector to magnify it, but this turned out to be much more difficult than we imagined, so we focused our efforts on the image recognition, and on making the system coherent and smooth.

There is a trade-off between camera quality and image recognition success. In the first stages of our image recognition process, we worked with images of much higher resolution, and found that we had much better success. On the other hand, we could have used higher powered classifiers (Support Vector Machines, for example) to classify the images, instead of our rather fragile manual tweaked approach.

Thanks to:
* Mark Crosby and Gary Meyer for making us a camera mount.
* Dr. Rob Bunch for providing advice and lenses for the projector
* Dr. Zach Dodd at Harvey Mudd University for providing starting image recognition code.

[[Category:ECE497]]

ECE497 Project Set Playing Beagle

2011-05-17T02:33:43Z

Mayhewsw:

Team members: [[user:allensj | Samuel Allen]], [[user:mayhewsw | Stephen Mayhew]], [[user:J.ametsitsi | Julian Ametsitsi]]

== Executive Summary ==

The game Set uses a 3 x 4 grid of 12 cards that have different symbols on them. These symbols differ in shape, fill, and number. The goal is to find a set of three cards. See [http://www.setgame.com/set/rules_set.htm here] for Set game instructions.

Using the BeagleBoard, we have developed a system that uses a webcam to take a picture of the cards in play and uses OpenCV and Python to find the sets from the picture.

Our system correctly identifies all of the sets in the hand that the image recognition provides.

It can run completely on the Beagleboard and processes aproximately 1 frame per second.

Currently, the image recognition is the downfall to our success. The image recognition does not find the correct symbols on the cards, and so the rest of the system does not find the correct sets.

The sets that are found are correct for the found cards, but not the actual cards in play.

Our system is almost functional, but there are still some problems that need to be overcome.
The image recognition is the biggest hurdle that we need to overcome and after that is completed, the system will work correctly.

== Installation Instructions ==
* First clone our github repository: git@github.com:mayhewsw/BeagleSetGame.git
<pre>git clone git@github.com:mayhewsw/BeagleSetGame.git </pre>
* The SPEd image comes with OpenCV already installed, but if you do not have it, you will need it.
<pre> $ opkg install opencv </pre>
* Install python-opencv
<pre> $ opkg install python-opencv </pre>
* You will also need a webcam and a way to mount it. We used a Sony Playstation Eye, but any webcam with at least 640x480 resolution should work. Our mount held the camera about 7 inches above the playing surface, and had it pointing straight down.

== User Instructions ==

Once everything is installed, how do you use the program? Give details here, so if you have a long user manual, link to it here.

* First, run the autogain executable. If you are using the SPEd2 Angstrom image, then this executable is found the root directory.

* Next, run trackbartest.py. When this runs, it opens up 2 images. One of the images is streaming live from the webcam, and it has slider bars that set the properties for the camera. The other image is a reference image. Slide the bars until the live image looks like the reference image.
<pre> $ python trackbartest.py </pre>
Once you have found a configuration you like, press enter. This will save those values to a file called cameraConfig.cfg, which is read later. Exit the window by pressing Escape.
* Now you can run the actual program, runner.py.
<pre> $ python runner.py </pre>
This will open up 2 windows. One window is an image of what the camera sees, the other window is the same image, but with the results of the processing overlaid onto it. Because of the current state of the image recognition, these results are often very wrong, but they are also affected by how close the camera configuration is.

When the program finds a set in the recognized cards, it will print out the result to the console, and wait for a keypress to continue. Make sure one of the images has focus, and press any key.

You can quit the program either by pressing Enter while the program is in the ordinary recognizing loop, or by doing Ctrl-C in the terminal.

== Highlights ==

The interest of our project is in how it demonstrates the use of OpenCV on the Beagleboard. It shows that OpenCV functionality on the Beagleboard is very similar to what one would find on any other computer, if a little slower.

== Theory of Operation ==

=== Program Flow ===
There are 2 steps to running the project: configuration and running.

In the configuration step, it simply creates trackbars that set camera configuration options as they change position. When the user presses enter, it saves the 3 values (brightness, contrast, and hue) to a file, cameraConfig.cfg.

In the running step, there is a file called runner.py that contains the main loop. Before it enters the main loop, it opens and reads cameraConfig.cfg and sets the camera properties accordingly. Inside the main loop, it runs three separate functions (all found in processCards.py) to recognize the cards. The first function, extractCards, finds symbols in the image, and groups them by location, and returns those groups. Each group is made up of rectangles which represent the bounding boxes of the symbols on any given card. Thus, each group is of size one, two, or three. The next function, getMeaningFromCards, takes the cards and classifies each of them, and returns a list of Card objects (defined in processCards). Next, this list of Card objects is passed to the SolveGame function, which finds sets.

=== Image Recognition ===
* To find fill: the program examines the center line of the symbol, and a line of the same length on the white part of the card, just to the left of the symbol, and compares their intensities. In order to set intensity thresholds correctly, there is a preprocessing loop at the beginning of the extractMeaningFromCards function.
* To find color: the program sets a mask around the image, and colors the background to black. Then it converts the image to HSV, increases the saturation by some amount, and converts back to BGR. It splits this image into channels and gets the sum of the entire channel. The max value of the sum decides on the color.
* To find shape: the program finds the contour of the symbol subimage, and divides the bounding box of the symbol by the perimeter of the symbol. This ratio is naively used as the decider.

== Work Breakdown ==

{| border="1"
|-
|Sam Allen || Did some work on getting the camera values set correctly so that the image was more usable.
|-
|Julian Ametsitsi || Tested using TI Pico Projector to project indication of set of card. Developed algorithm with Stephen to identify individual cards in a single image.
|-
|Stephen Mayhew ||
|}

List the major tasks in your project and who did what.

Also list here what doesn't work yet and when you think it will be finished and who is finishing it.

== Conclusions ==

Give some concluding thoughts about the project. Suggest some future additions that could make it even more interesting.

Originally, it was in the scope to have a projector project indication of sets back onto the actual cards. We had planned to use a DLP Pico projector for this, but we found early on that the Pico projector projects at a very small resolution, and we would have had to mount it significantly higher than the camera if it was to cover the whole playing area. We experimented with putting lenses in front of the projector to magnify it, but

There is a trade-off between camera quality and image recognition success. In the first stages of our image recognition process, we worked with images of much higher resolution, and found that we had much better success. On the other hand, we could have used higher powered classifiers (Support Vector Machines, for example) to classify the images, instead of our rather fragile manual tweaked approach.

Thanks to:
* Mark Crosby and Gary Meyer for making us a camera mount.
* Dr. Rob Bunch for providing advice and lenses for the projector
* Dr. Zach Dodd at Harvey Mudd University for providing starting image recognition code.

[[Category:ECE497]]

ECE497 Project Set Playing Beagle

2011-05-17T02:29:41Z

Mayhewsw:

Team members: [[user:allensj | Samuel Allen]], [[user:mayhewsw | Stephen Mayhew]], [[user:J.ametsitsi | Julian Ametsitsi]]

== Executive Summary ==

The game Set uses a 3 x 4 grid of 12 cards that have different symbols on them. These symbols differ in shape, fill, and number. The goal is to find a set of three cards. See [http://www.setgame.com/set/rules_set.htm here] for Set game instructions.

Using the BeagleBoard, we have developed a system that uses a webcam to take a picture of the cards in play and uses OpenCV and Python to find the sets from the picture.

Our system correctly identifies all of the sets in the hand that the image recognition provides.

It can run completely on the Beagleboard and processes aproximately 1 frame per second.

Currently, the image recognition is the downfall to our success. The image recognition does not find the correct symbols on the cards, and so the rest of the system does not find the correct sets.

The sets that are found are correct for the found cards, but not the actual cards in play.

Our system is almost functional, but there are still some problems that need to be overcome.
The image recognition is the biggest hurdle that we need to overcome and after that is completed, the system will work correctly.

== Installation Instructions ==
* First clone our github repository: git@github.com:mayhewsw/BeagleSetGame.git
<pre>git clone git@github.com:mayhewsw/BeagleSetGame.git </pre>
* The SPEd image comes with OpenCV already installed, but if you do not have it, you will need it.
<pre> $ opkg install opencv </pre>
* Install python-opencv
<pre> $ opkg install python-opencv </pre>
* You will also need a webcam and a way to mount it. We used a Sony Playstation Eye, but any webcam with at least 640x480 resolution should work. Our mount held the camera about 7 inches above the playing surface, and had it pointing straight down.

== User Instructions ==

Once everything is installed, how do you use the program? Give details here, so if you have a long user manual, link to it here.

* First, run the autogain executable. If you are using the SPEd2 Angstrom image, then this executable is found the root directory.

* Next, run trackbartest.py. When this runs, it opens up 2 images. One of the images is streaming live from the webcam, and it has slider bars that set the properties for the camera. The other image is a reference image. Slide the bars until the live image looks like the reference image.
<pre> $ python trackbartest.py </pre>
Once you have found a configuration you like, press enter. This will save those values to a file called cameraConfig.cfg, which is read later. Exit the window by pressing Escape.
* Now you can run the actual program, runner.py.
<pre> $ python runner.py </pre>
This will open up 2 windows. One window is an image of what the camera sees, the other window is the same image, but with the results of the processing overlaid onto it. Because of the current state of the image recognition, these results are often very wrong, but they are also affected by how close the camera configuration is.

When the program finds a set in the recognized cards, it will print out the result to the console, and wait for a keypress to continue. Make sure one of the images has focus, and press any key.

You can quit the program either by pressing Enter while the program is in the ordinary recognizing loop, or by doing Ctrl-C in the terminal.

== Highlights ==

The interest of our project is in how it demonstrates the use of OpenCV on the Beagleboard. It shows that OpenCV functionality on the Beagleboard is very similar to what one would find on any other computer, if a little slower.

== Theory of Operation ==

=== Program Flow ===
There are 2 steps to running the project: configuration and running.

In the configuration step, it simply creates trackbars that set camera configuration options as they change position. When the user presses enter, it saves the 3 values (brightness, contrast, and hue) to a file, cameraConfig.cfg.

In the running step, there is a file called runner.py that contains the main loop. Before it enters the main loop, it opens and reads cameraConfig.cfg and sets the camera properties accordingly. Inside the main loop, it runs three separate functions (all found in processCards.py) to recognize the cards. The first function, extractCards, finds symbols in the image, and groups them by location, and returns those groups. Each group is made up of rectangles which represent the bounding boxes of the symbols on any given card. Thus, each group is of size one, two, or three. The next function, getMeaningFromCards, takes the cards and classifies each of them, and returns a list of Card objects (defined in processCards). Next, this list of Card objects is passed to the SolveGame function, which finds sets.

=== Image Recognition ===
* To find fill: the program examines the center line of the symbol, and a line of the same length on the white part of the card, just to the left of the symbol, and compares their intensities. In order to set intensity thresholds correctly, there is a preprocessing loop at the beginning of the extractMeaningFromCards function.
* To find color: the program sets a mask around the image, and colors the background to black. Then it converts the image to HSV, increases the saturation by some amount, and converts back to BGR. It splits this image into channels and gets the sum of the entire channel. The max value of the sum decides on the color.
* To find shape: the program finds the contour of the symbol subimage, and divides the bounding box of the symbol by the perimeter of the symbol. This ratio is naively used as the decider.

== Work Breakdown ==

{| border="1"
|-
|Sam Allen || Did some work on getting the camera values set correctly so that the image was more usable.
|-
|Julian Ametsitsi || Tested using TI Pico Projector to project indication of set of card. Developed algorithm with Stephen to identify individual cards in a single image.
|-
|Stephen Mayhew ||
|}

List the major tasks in your project and who did what.

Also list here what doesn't work yet and when you think it will be finished and who is finishing it.

== Conclusions ==

Give some concluding thoughts about the project. Suggest some future additions that could make it even more interesting.

Originally, it was in the scope to have a projector.

There is a trade-off between camera quality and image recognition success. In the first stages of our image recognition process, we worked with images of much higher resolution, and found that we had much better success. On the other hand, we could have used higher powered classifiers (Support Vector Machines, for example) to classify the images, instead of our rather fragile manual tweaked approach.

[[Category:ECE497]]

ECE497 Project Set Playing Beagle

2011-05-17T02:23:14Z

Mayhewsw:

Team members: [[user:allensj | Samuel Allen]], [[user:mayhewsw | Stephen Mayhew]], [[user:J.ametsitsi | Julian Ametsitsi]]

== Executive Summary ==

The game Set uses a 3 x 4 grid of 12 cards that have different symbols on them. These symbols differ in shape, fill, and number. The goal is to find a set of three cards. See [http://www.setgame.com/set/rules_set.htm here] for Set game instructions.

Using the BeagleBoard, we have developed a system that uses a webcam to take a picture of the cards in play and uses OpenCV and Python to find the sets from the picture.

Our system correctly identifies all of the sets in the hand that the image recognition provides.

It can run completely on the Beagleboard and processes aproximately 1 frame per second.

Currently, the image recognition is the downfall to our success. The image recognition does not find the correct symbols on the cards, and so the rest of the system does not find the correct sets.

The sets that are found are correct for the found cards, but not the actual cards in play.

Our system is almost functional, but there are still some problems that need to be overcome.
The image recognition is the biggest hurdle that we need to overcome and after that is completed, the system will work correctly.

== Installation Instructions ==
* First clone our github repository: git@github.com:mayhewsw/BeagleSetGame.git
<pre>git clone git@github.com:mayhewsw/BeagleSetGame.git </pre>
* The SPEd image comes with OpenCV already installed, but if you do not have it, you will need it.
<pre> $ opkg install opencv </pre>
* Install python-opencv
<pre> $ opkg install python-opencv </pre>
* You will also need a webcam and a way to mount it. We used a Sony Playstation Eye, but any webcam with at least 640x480 resolution should work. Our mount held the camera about 7 inches above the playing surface, and had it pointing straight down.

== User Instructions ==

Once everything is installed, how do you use the program? Give details here, so if you have a long user manual, link to it here.

* First, run the autogain executable. If you are using the SPEd2 Angstrom image, then this executable is found the root directory.

* Next, run trackbartest.py. When this runs, it opens up 2 images. One of the images is streaming live from the webcam, and it has slider bars that set the properties for the camera. The other image is a reference image. Slide the bars until the live image looks like the reference image.
<pre> $ python trackbartest.py </pre>
Once you have found a configuration you like, press enter. This will save those values to a file called cameraConfig.cfg, which is read later. Exit the window by pressing Escape.
* Now you can run the actual program, runner.py.
<pre> $ python runner.py </pre>
This will open up 2 windows. One window is an image of what the camera sees, the other window is the same image, but with the results of the processing overlaid onto it. Because of the current state of the image recognition, these results are often very wrong, but they are also affected by how close the camera configuration is.

When the program finds a set in the recognized cards, it will print out the result to the console, and wait for a keypress to continue. Make sure one of the images has focus, and press any key.

You can quit the program either by pressing Enter while the program is in the ordinary recognizing loop, or by doing Ctrl-C in the terminal.

== Highlights ==

The interest of our project is in how it demonstrates the use of OpenCV on the Beagleboard. It shows that OpenCV functionality on the Beagleboard is very similar to what one would find on any other computer, if a little slower.

== Theory of Operation ==

=== Program Flow ===
There are 2 steps to running the project: configuration and running.

In the configuration step, it simply creates trackbars that set camera configuration options as they change position. When the user presses enter, it saves the 3 values (brightness, contrast, and hue) to a file, cameraConfig.cfg.

In the running step, there is a file called runner.py that contains the main loop. Before it enters the main loop, it opens and reads cameraConfig.cfg and sets the camera properties accordingly. Inside the main loop, it runs three separate functions (all found in processCards.py) to recognize the cards. The first function, extractCards, finds symbols in the image, and groups them by location, and returns those groups. Each group is made up of rectangles which represent the bounding boxes of the symbols on any given card. Thus, each group is of size one, two, or three. The next function, getMeaningFromCards, takes the cards and classifies each of them, and returns a list of Card objects (defined in processCards). Next, this list of Card objects is passed to the SolveGame function, which finds sets.

=== Image Recognition ===
* To find fill: the program examines the center line of the symbol, and a line of the same length on the white part of the card, just to the left of the symbol, and compares their intensities. In order to set intensity thresholds correctly, there is a preprocessing loop at the beginning of the extractMeaningFromCards function.
* To find color: the program sets a mask around the image, and colors the background to black. Then it converts the image to HSV, increases the saturation by some amount, and converts back to BGR. It splits this image into channels and gets the sum of the entire channel. The max value of the sum decides on the color.
* To find shape: the program finds the contour of the symbol subimage, and divides the bounding box of the symbol by the perimeter of the symbol. This ratio is naively used as the decider.

== Work Breakdown ==

{| border="1"
|-
|Sam Allen ||
|-
|Julian Ametsitsi || Tested using TI Pico Projector to project indication of set of card. Developed algorithm with Stephen to identify individual cards in a single image.
|-
|Stephen Mayhew ||
|}

List the major tasks in your project and who did what.

Also list here what doesn't work yet and when you think it will be finished and who is finishing it.

== Conclusions ==

Give some concluding thoughts about the project. Suggest some future additions that could make it even more interesting.

[[Category:ECE497]]

ECE497 Project Set Playing Beagle

2011-05-17T02:22:24Z

Mayhewsw:

Team members: [[user:allensj | Samuel Allen]], [[user:mayhewsw | Stephen Mayhew]], [[user:J.ametsitsi | Julian Ametsitsi]]

== Executive Summary ==

The game Set uses a 3 x 4 grid of 12 cards that have different symbols on them. These symbols differ in shape, fill, and number. The goal is to find a set of three cards. See [http://www.setgame.com/set/rules_set.htm here] for Set game instructions.

Using the BeagleBoard, we have developed a system that uses a webcam to take a picture of the cards in play and uses OpenCV and Python to find the sets from the picture.

Our system correctly identifies all of the sets in the hand that the image recognition provides.

It can run completely on the Beagleboard and processes aproximately 1 frame per second.

Currently, the image recognition is the downfall to our success. The image recognition does not find the correct symbols on the cards, and so the rest of the system does not find the correct sets.

The sets that are found are correct for the found cards, but not the actual cards in play.

Our system is almost functional, but there are still some problems that need to be overcome.
The image recognition is the biggest hurdle that we need to overcome and after that is completed, the system will work correctly.

== Installation Instructions ==
* First clone our github repository: git@github.com:mayhewsw/BeagleSetGame.git
<pre>git clone git@github.com:mayhewsw/BeagleSetGame.git </pre>
* The SPEd image comes with OpenCV already installed, but if you do not have it, you will need it.
<pre> $ opkg install opencv </pre>
* Install python-opencv
<pre> $ opkg install python-opencv </pre>
* You will also need a webcam and a way to mount it. We used a Sony Playstation Eye, but any webcam with at least 640x480 resolution should work. Our mount held the camera about 7 inches above the playing surface, and had it pointing straight down.

== User Instructions ==

Once everything is installed, how do you use the program? Give details here, so if you have a long user manual, link to it here.

* First, run the autogain executable. If you are using the SPEd2 Angstrom image, then this executable is found the root directory.

* Next, run trackbartest.py. When this runs, it opens up 2 images. One of the images is streaming live from the webcam, and it has slider bars that set the properties for the camera. The other image is a reference image. Slide the bars until the live image looks like the reference image.
<pre> $ python trackbartest.py </pre>
Once you have found a configuration you like, press enter. This will save those values to a file called cameraConfig.cfg, which is read later. Exit the window by pressing Escape.
* Now you can run the actual program, runner.py.
<pre> $ python runner.py </pre>
This will open up 2 windows. One window is an image of what the camera sees, the other window is the same image, but with the results of the processing overlaid onto it. Because of the current state of the image recognition, these results are often very wrong, but they are also affected by how close the camera configuration is.

When the program finds a set in the recognized cards, it will print out the result to the console, and wait for a keypress to continue. Make sure one of the images has focus, and press any key.

You can quit the program either by pressing Enter while the program is in the ordinary recognizing loop, or by doing Ctrl-C in the terminal.

== Highlights ==

The interest of our project is in how it demonstrates the use of OpenCV on the Beagleboard. It shows that OpenCV functionality on the Beagleboard is very similar to what one would find on any other computer, if a little slower.

== Theory of Operation ==

There are 2 steps to running the project: configuration and running.

In the configuration step, it simply creates trackbars that set camera configuration options as they change position. When the user presses enter, it saves the 3 values (brightness, contrast, and hue) to a file, cameraConfig.cfg.

In the running step, there is a file called runner.py that contains the main loop. Before it enters the main loop, it opens and reads cameraConfig.cfg and sets the camera properties accordingly. Inside the main loop, it runs three separate functions (all found in processCards.py) to recognize the cards. The first function, extractCards, finds symbols in the image, and groups them by location, and returns those groups. Each group is made up of rectangles which represent the bounding boxes of the symbols on any given card. Thus, each group is of size one, two, or three. The next function, getMeaningFromCards, takes the cards and classifies each of them, and returns a list of Card objects (defined in processCards). Next, this list of Card objects is passed to the SolveGame function, which finds sets.

Notes on the image recognition:
* To find fill: the program examines the center line of the symbol, and a line of the same length on the white part of the card, just to the left of the symbol, and compares their intensities. In order to set intensity thresholds correctly, there is a preprocessing loop at the beginning of the extractMeaningFromCards function.
* To find color: the program sets a mask around the image, and colors the background to black. Then it converts the image to HSV, increases the saturation by some amount, and converts back to BGR. It splits this image into channels and gets the sum of the entire channel. The max value of the sum decides on the color.
* To find shape: the program finds the contour of the symbol subimage, and divides the bounding box of the symbol by the perimeter of the symbol. This ratio is naively used as the decider.

== Work Breakdown ==

{| border="1"
|-
|Sam Allen ||
|-
|Julian Ametsitsi || Tested using TI Pico Projector to project indication of set of card. Developed algorithm with Stephen to identify individual cards in a single image.
|-
|Stephen Mayhew ||
|}

List the major tasks in your project and who did what.

Also list here what doesn't work yet and when you think it will be finished and who is finishing it.

== Conclusions ==

Give some concluding thoughts about the project. Suggest some future additions that could make it even more interesting.

[[Category:ECE497]]

ECE497 Project Set Playing Beagle

2011-05-17T02:08:12Z

Mayhewsw:

ECE497 Project Set Playing Beagle

2011-05-17T02:05:39Z

Mayhewsw:

ECE497 Project Set Playing Beagle

2011-05-17T02:03:18Z

Mayhewsw:

ECE497 Project Set Playing Beagle

2011-05-17T01:58:12Z

Mayhewsw:

ECE497 Project Set Playing Beagle

2011-05-17T01:55:29Z

Mayhewsw:

ECE497 Project Set Playing Beagle

2011-05-17T01:53:11Z

Mayhewsw:

ECE497 Project Set Playing Beagle

2011-05-17T01:29:47Z

Mayhewsw:

Team members: [[user:allensj | Samuel Allen]], [[user:mayhewsw | Stephen Mayhew]], [[user:J.ametsitsi | Julian Ametsitsi]]

== Executive Summary ==

Give two sentence intro to the project.

Give two sentences telling what works.
The system

Give two sentences telling what isn't working.

End with a two sentence conclusion.

The sentence count is approximate and only to give an idea of the expected length.

== Installation Instructions ==
Give step by step instructions on how to install your project on the SPEd2 image.

* First clone our github repository: git@github.com:mayhewsw/BeagleSetGame.git
<pre>git clone git@github.com:mayhewsw/BeagleSetGame.git </pre>
* Install python-opencv
<pre> $ opkg install python-opencv </pre>
* You will also need a webcam and a way to mount it. We used a Sony Playstation Eye, but any webcam with at least 640x480 resolution should work. Our mount held the camera about 7 inches above the playing surface, and had it pointing straight down.

== User Instructions ==

Once everything is installed, how do you use the program? Give details here, so if you have a long user manual, link to it here.

== Highlights ==

Here is where you brag about what your project can do.

Consider including a [http://www.youtube.com/ YouTube] demo.

== Theory of Operation ==

Give a high level overview of the structure of your software. Are you using GStreamer? Show a diagram of the pipeline. Are you running multiple tasks? Show what they do and how they interact.

== Work Breakdown ==

List the major tasks in your project and who did what.

Also list here what doesn't work yet and when you think it will be finished and who is finishing it.

== Conclusions ==

Give some concluding thoughts about the project. Suggest some future additions that could make it even more interesting.

[[Category:ECE497]]

ECE497 Project Set Playing Beagle

2011-05-17T01:25:50Z

Mayhewsw:

Team members: [[user:allensj | Samuel Allen]], [[user:mayhewsw | Stephen Mayhew]], [[user:J.ametsitsi | Julian Ametsitsi]]

== Executive Summary ==

Give two sentence intro to the project.

Give two sentences telling what works.
The system

Give two sentences telling what isn't working.

End with a two sentence conclusion.

The sentence count is approximate and only to give an idea of the expected length.

== Installation Instructions ==
Give step by step instructions on how to install your project on the SPEd2 image.

* First clone our github repository: [git@github.com:mayhewsw/BeagleSetGame.git git@github.com:mayhewsw/BeagleSetGame.git]
<pre>git clone git@github.com:mayhewsw/BeagleSetGame.git </pre>
* Install python-opencv
<pre> $ opkg install python-opencv </pre>
* You will also need a webcam and a way to mount it. We used a Sony Playstation Eye, but any webcam with at least 640x480 resolution should work. Our mount held the camera about 7 inches above the playing surface, and had it pointing straight down.

== User Instructions ==

Once everything is installed, how do you use the program? Give details here, so if you have a long user manual, link to it here.

== Highlights ==

Here is where you brag about what your project can do.

Consider including a [http://www.youtube.com/ YouTube] demo.

== Theory of Operation ==

Give a high level overview of the structure of your software. Are you using GStreamer? Show a diagram of the pipeline. Are you running multiple tasks? Show what they do and how they interact.

== Work Breakdown ==

List the major tasks in your project and who did what.

Also list here what doesn't work yet and when you think it will be finished and who is finishing it.

== Conclusions ==

Give some concluding thoughts about the project. Suggest some future additions that could make it even more interesting.

[[Category:ECE497]]

ECE497 Project Set Playing Beagle

2011-05-17T01:23:30Z

Mayhewsw:

Team members: [[user:allensj | Samuel Allen]], [[user:mayhewsw | Stephen Mayhew]], [[user:J.ametsitsi | Julian Ametsitsi]]

== Executive Summary ==

Give two sentence intro to the project.

Give two sentences telling what works.
The system

Give two sentences telling what isn't working.

End with a two sentence conclusion.

The sentence count is approximate and only to give an idea of the expected length.

== Installation Instructions ==
Give step by step instructions on how to install your project on the SPEd2 image.

* First clone our github repository: [https://github.com/mayhewsw/BeagleSetGame https://github.com/mayhewsw/BeagleSetGame]
* Install python-opencv
<pre> $ opkg install python-opencv </pre>
* You will also need a webcam and a way to mount it. We used a Sony Playstation Eye, but any webcam with at least 640x480 resolution should work. Our mount held the camera about 7 inches above the playing surface, and had it pointing straight down.

== User Instructions ==

Once everything is installed, how do you use the program? Give details here, so if you have a long user manual, link to it here.

== Highlights ==

Here is where you brag about what your project can do.

Consider including a [http://www.youtube.com/ YouTube] demo.

== Theory of Operation ==

Give a high level overview of the structure of your software. Are you using GStreamer? Show a diagram of the pipeline. Are you running multiple tasks? Show what they do and how they interact.

== Work Breakdown ==

List the major tasks in your project and who did what.

Also list here what doesn't work yet and when you think it will be finished and who is finishing it.

== Conclusions ==

Give some concluding thoughts about the project. Suggest some future additions that could make it even more interesting.

[[Category:ECE497]]

ECE497 Project Set Playing Beagle

2011-05-17T01:23:02Z

Mayhewsw:

Team members: [[user:allensj | Samuel Allen], [[user:mayhewsw | Stephen Mayhew]], [[user:J.ametsitsi | Julian Ametsitsi]]

== Executive Summary ==

Give two sentence intro to the project.

Give two sentences telling what works.
The system

Give two sentences telling what isn't working.

End with a two sentence conclusion.

The sentence count is approximate and only to give an idea of the expected length.

== Installation Instructions ==
Give step by step instructions on how to install your project on the SPEd2 image.

* First clone our github repository: [https://github.com/mayhewsw/BeagleSetGame https://github.com/mayhewsw/BeagleSetGame]
* Install python-opencv
<pre> $ opkg install python-opencv </pre>
* You will also need a webcam and a way to mount it. We used a Sony Playstation Eye, but any webcam with at least 640x480 resolution should work. Our mount held the camera about 7 inches above the playing surface, and had it pointing straight down.

== User Instructions ==

Once everything is installed, how do you use the program? Give details here, so if you have a long user manual, link to it here.

== Highlights ==

Here is where you brag about what your project can do.

Consider including a [http://www.youtube.com/ YouTube] demo.

== Theory of Operation ==

Give a high level overview of the structure of your software. Are you using GStreamer? Show a diagram of the pipeline. Are you running multiple tasks? Show what they do and how they interact.

== Work Breakdown ==

List the major tasks in your project and who did what.

Also list here what doesn't work yet and when you think it will be finished and who is finishing it.

== Conclusions ==

Give some concluding thoughts about the project. Suggest some future additions that could make it even more interesting.

[[Category:ECE497]]

ECE497 Project Set Playing Beagle

2011-05-17T00:38:34Z

Mayhewsw:

Team members: [[user:allensj | Samuel Allen], [[user:mayhewsw | Stephen Mayhew]], [[user:J.ametsitsi | Julian Ametsitsi]]

== Executive Summary ==

Give two sentence intro to the project.
This project

Give two sentences telling what works.
The system

Give two sentences telling what isn't working.

End with a two sentence conclusion.

The sentence count is approximate and only to give an idea of the expected length.

== Installation Instructions ==

Give step by step instructions on how to install your project on the SPEd2 image.

* Our github repository: [https://github.com/mayhewsw/BeagleSetGame https://github.com/mayhewsw/BeagleSetGame]
* Additional packages (install with '''opkg'''):
**python-opencv
* Webcam. We used a Sony Playstation Eye, but any webcam with at least 640x480 resolution should work.

== User Instructions ==

Once everything is installed, how do you use the program? Give details here, so if you have a long user manual, link to it here.

== Highlights ==

Here is where you brag about what your project can do.

Consider including a [http://www.youtube.com/ YouTube] demo.

== Theory of Operation ==

Give a high level overview of the structure of your software. Are you using GStreamer? Show a diagram of the pipeline. Are you running multiple tasks? Show what they do and how they interact.

== Work Breakdown ==

List the major tasks in your project and who did what.

Also list here what doesn't work yet and when you think it will be finished and who is finishing it.

== Conclusions ==

Give some concluding thoughts about the project. Suggest some future additions that could make it even more interesting.

[[Category:ECE497]]

ECE497 Project Set Playing Beagle

2011-05-17T00:38:01Z

Mayhewsw:

Team members: [[user:allensj] Samuel Allen], [[user:mayhewsw] Stephen Mayhew], [[user:J.ametsitsi] Julian Ametsitsi]

== Executive Summary ==

Give two sentence intro to the project.
This project

Give two sentences telling what works.
The system

Give two sentences telling what isn't working.

End with a two sentence conclusion.

The sentence count is approximate and only to give an idea of the expected length.

== Installation Instructions ==

Give step by step instructions on how to install your project on the SPEd2 image.

* Our github repository: [https://github.com/mayhewsw/BeagleSetGame https://github.com/mayhewsw/BeagleSetGame]
* Additional packages (install with '''opkg'''):
**python-opencv
* Webcam. We used a Sony Playstation Eye, but any webcam with at least 640x480 resolution should work.

== User Instructions ==

Once everything is installed, how do you use the program? Give details here, so if you have a long user manual, link to it here.

== Highlights ==

Here is where you brag about what your project can do.

Consider including a [http://www.youtube.com/ YouTube] demo.

== Theory of Operation ==

Give a high level overview of the structure of your software. Are you using GStreamer? Show a diagram of the pipeline. Are you running multiple tasks? Show what they do and how they interact.

== Work Breakdown ==

List the major tasks in your project and who did what.

Also list here what doesn't work yet and when you think it will be finished and who is finishing it.

== Conclusions ==

Give some concluding thoughts about the project. Suggest some future additions that could make it even more interesting.

[[Category:ECE497]]

ECE497 Project Set Playing Beagle

2011-05-17T00:37:00Z

Mayhewsw:

ECE497 Project Set Playing Beagle

2011-05-17T00:35:12Z

Mayhewsw:

ECE497 Project Set Playing Beagle

2011-05-09T10:59:07Z

Mayhewsw:

Team members: Stephen Mayhew, Samuel Allen, Julian Ametsitsi

== Description ==
Using a webcam, a projector, and possibly a microphone, this system will allow the computer to play Set. Set is a card game which involves finding patterns among a 12-card layout. The instructor at [http://modelai.gettysburg.edu/2010/set/gettingSetWithOpenCV.html this website] makes the interesting point that for humans, it is easy to gather information about the cards, but hard to find sets. For computers, it is the opposite: even with a brute force algorithm, it is a trivial matter to find all sets in a layout, but it is difficult to read the cards.

Our github page is:

[https://github.com/mayhewsw/BeagleSetGame https://github.com/mayhewsw/BeagleSetGame]

== Game Play ==
It will be a command line application, written in Python using the OpenCV Python bindings.

Basic Flow:
* Start the program
* Set out the cards
* When there are 12 cards, the program will start to recognize cards and find sets
* When the computer finds a set, it will project the locations of the cards onto the playing surface
* If the computer can't find a set, then project red X, or speech synthesis "No set", or print to console

If there is time:
* If a human finds a set - user input: click, speech recognition - and computer stops looking
* Speech synthesis - ask for confirmation on sets (could also be command line - much easier)

== Tasks ==
* Decide on final functionality
* Come up with the hardware setup, frame to hold the camera and projector
* Learn how to stream video input using OpenCV (or PyGame) - Sam
* Finish the Set card recognizer - Stephen
* Bring the system together - Everybody
* Test the DLPpico projector, get it to communicate with the camera - Julian

Completed tasks:
* OpenCV is installed on my Beagle - Stephen
* OpenCV program tested on the Beagle - Stephen
* Game logic has been acquired - Stephen
* Install emacs on the Beagle so I don't have to deal with vi - Stephen
* Preliminary Set card recognizer created - Stephen

[[Category:ECE497]]

ECE497 Lab11 Using the Open Sound System (OSS)

2011-05-07T21:36:33Z

Mayhewsw:

[[Category:ECE497]]

Be sure you have done Lab 10 before this lab so all your software is set up.

== Lab 11/6 - Using the OSS Driver ==

Lab 11 is Lab 6 is on pages 171-186 of '''DaVinci-OMAP_Workshop_v2.0.pdf'''. In doing this lab you will get audio from the line-in jack on the Beagle and sent it out the speaker jack.
* Go to the class dfs site and get:
** setpaths.mak
** setpaths.sh

* Move the '''setpaths''' files in the workshop directory to another location.
<pre>
host $ cd workshop
host $ mv setpaths.sh setpaths.sh.orig
host $ mv setpaths.mak setpaths.mak.orig
</pre>
* Copy the setpaths files you got from DFS into the workshop directory. In Lab 11/6 you will edit these files so they are correct.

You will still need the symbolic link from part 5, and make sure to update the file paths.

== Problems and Solutions ==

=== Killing pulseaudio ===

I find that running
<pre>
cat /dev/dsp > /dev/dsp
</pre>

gave me this error:
<pre>
-sh: can't create /dev/dsp: Device or resource busy
</pre>

This did not seem to cause problems until part b of the lab. I found [http://linux.dsplabs.com.au/lsof-grep-snd-how-to-free-a-linux-sound-device-p25/ this website] to solve my problem. Apparently, the problem is that pulseaudio is using /dev/dsp, and refuses to give it up. When I killed pulseaudio (the rude way, not the graceful way), then running cat /dev/dsp > /dev/dsp worked, and my executable worked. I don't know what killing pulseaudio does to the system, I haven't noticed any ill-effects yet...

=== Testing the audio chain with GStreamer ===

Here is a simple way to test to see if you mic and speakers are working. Do this on your Beagle:

<pre>
# opkg update
# opkg install esc-gst
# cd /usr/share/esc-gst/
# ls
README a2 a4 a6 d2 d4 d6 g2 g4 g6 g8 n1 n3 p1 v1 v3
a1 a3 a5 d1 d3 d5 g1 g3 g5 g7 g9 n2 n4 s v2 v4
# less README
# less s
# ./s
# ./a1
# ./a6
</pre>

These are files for demonstrating GStreamer. The README tells what each file does. Before the first time you run anything you have to run <code>s</code>. Here’s what <code>s</code> does:

<pre>
#! /bin/sh
set -x
export DISPLAY=:0.0
export PATH=$PATH:/usr/share/esc-gst
cd /usr/share/esc-gst
killall -9 pulseaudio
set +x
</pre>

Notice you have to kill off pulseaudio as was suggested above! <code>a1</code> plays a simple tone, <code>a6</code> takes the input from the mic and sends it to the speakers. This works for me and is a good way to test your whole audio chain.

=== Some notes on ALSA ===

I've gotten [http://www.suse.de/~mana/alsa090_howto.html#sect02 this] example working. I'm also looking [http://www.equalarea.com/paul/alsa-audio.html#playex here].

On the Beagle you need to:
<pre>
# opkg install alsa-dev
</pre>

On the host:
<pre>
$ sudo apt-get install libasound2-dev
</pre>
Go to the class dfs site and get <code>alsaWrite.c</code>. Compile it with
<pre>
# gcc -lasound alsaWrite.c
# ./a.out
</pre>
It runs on the Beagle and desktop and produces a sound.

It's shouldn't be hard to convert <code>alsaWrite.c</code> to <code>alsaRead.c</code>. See the sites above for hints.

ECE497 Lab11 Using the Open Sound System (OSS)

2011-05-07T21:36:19Z

Mayhewsw:

[[Category:ECE497]]

Be sure you have done Lab 10 before this lab so all your software is set up.

== Lab 11/6 - Using the OSS Driver ==

Lab 11 is Lab 6 is on pages 171-186 of '''DaVinci-OMAP_Workshop_v2.0.pdf'''. In doing this lab you will get audio from the line-in jack on the Beagle and sent it out the speaker jack.
* Go to the class dfs site and get:
** setpaths.mak
** setpaths.sh

* Move the '''setpaths''' files in the workshop directory to another location.
<pre>
host $ cd workshop
host $ mv setpaths.sh setpaths.sh.orig
host $ mv setpaths.mak setpaths.mak.orig
</pre>
* Copy the setpaths files you got from DFS into the workshop directory. In Lab 11/6 you will edit these files so they are correct.

You will still need the symbolic link from part 5, and make sure to update the file paths.

== Problems and Solutions ==

=== Killing pulseaudio ===

I find that running
<pre>
cat /dev/dsp > /dev/dsp
</pre>

gave me this error:
<pre>
-sh: can't create /dev/dsp: Device or resource busy
</pre>

This did not seem to cause problems until part b of the lab. I found [http://linux.dsplabs.com.au/lsof-grep-snd-how-to-free-a-linux-sound-device-p25/ this website] to solve my problem. Apparently, the problem is that pulseaudio is using /dev/dsp, and refuses to give it up. When I killed pulseaudio (the rude way, not the graceful way), then running cat /dev/dsp > /dev/dsp worked, and my executable worked. I don't know what killing pulseaudio does to the system, I haven't noticed any ill-effects yet...

=== Testing the audio chain with GStreamer ===

Here is a simple way to test to see if you mic and speakers are working. Do this on your Beagle:

<pre>
# opkg update
# opkg install esc-gst
# cd /usr/share/esc-gst/
# ls
README a2 a4 a6 d2 d4 d6 g2 g4 g6 g8 n1 n3 p1 v1 v3
a1 a3 a5 d1 d3 d5 g1 g3 g5 g7 g9 n2 n4 s v2 v4
# less README
# less s
# ./s
# ./a1
# ./a6
</pre>

These are files for demonstrating GStreamer. The README tells what each file does. Before the first time you run anything you have to run <code>s</code>. Here’s what <code>s</code> does:

<pre>
#! /bin/sh
set -x
export DISPLAY=:0.0
export PATH=$PATH:/usr/share/esc-gst
cd /usr/share/esc-gst
killall -9 pulseaudio
set +x
</pre>

Notice you have to kill off pulseaudio as was suggested above! <code>a1</code> plays a simple tone, <code>a6</code> takes the input from the mic and sends it to the speakers. This works for me and is a good way to test your whole audio chain.

=== Some notes on ALSA ===

I've gotten [http://www.suse.de/~mana/alsa090_howto.html#sect02 this] example working. I'm also looking [http://www.equalarea.com/paul/alsa-audio.html#playex here].

On the Beagle you need to:
<pre>
# opkg install alsa-dev
</pre>

On the host:
<pre>
$ sudo apt-get install libasound2-dev
</pre>
Go to the class dfs site and get <code>alsaWrite.c</code>. Compile it with
<pre>
# gcc -lasound alsaWrite.c
# ./a.out
</pre>
It runs on the Beagle aad desktop and produces a sound.

It's shouldn't be hard to convert <code>alsaWrite.c</code> to <code>alsaRead.c</code>. See the sites above for hints.

ECE497 Project Set Playing Beagle

2011-05-04T01:56:30Z

Mayhewsw:

Team members: Stephen Mayhew, Samuel Allen, Julian Ametsitsi, (Mike Lester)

== Description ==
Using a webcam, a projector, and possibly a microphone, this system will allow the computer to play Set. Set is a card game which involves finding patterns among a 12-card layout. The instructor at [http://modelai.gettysburg.edu/2010/set/gettingSetWithOpenCV.html this website] makes the interesting point that for humans, it is easy to gather information about the cards, but hard to find sets. For computers, it is the opposite: even with a brute force algorithm, it is a trivial matter to find all sets in a layout, but it is difficult to read the cards.

Our github page is:

[https://github.com/mayhewsw/BeagleSetGame https://github.com/mayhewsw/BeagleSetGame]

== Game Play ==
It will be a command line application, written in Python using the OpenCV Python bindings.

Basic Flow:
* Start the program
* Set out the cards
* When there are 12 cards, the program will start to recognize cards and find sets
* When the computer finds a set, it will project the locations of the cards onto the playing surface
* If the computer can't find a set, then project red X, or speech synthesis "No set", or print to console

If there is time:
* If a human finds a set - user input: click, speech recognition - and computer stops looking
* Speech synthesis - ask for confirmation on sets (could also be command line - much easier)

== Tasks ==
* Decide on final functionality
* Come up with the hardware setup, frame to hold the camera and projector
* Learn how to stream video input using OpenCV (or PyGame) - Sam
* Finish the Set card recognizer - Stephen
* Bring the system together - Everybody
* Test the DLPpico projector, get it to communicate with the camera - Julian

Completed tasks:
* OpenCV is installed on my Beagle - Stephen
* OpenCV program tested on the Beagle - Stephen
* Game logic has been acquired - Stephen
* Install emacs on the Beagle so I don't have to deal with vi - Stephen
* Preliminary Set card recognizer created - Stephen

[[Category:ECE497]]

ECE497 Project Set Playing Beagle

2011-05-04T01:54:57Z

Mayhewsw:

ECE497 Project Set Playing Beagle

2011-05-04T01:54:38Z

Mayhewsw:

ECE497 Project Set Playing Beagle

2011-05-04T00:47:27Z

Mayhewsw:

Team members: Stephen Mayhew, Samuel Allen, Julian Ametsitsi

== Description ==
Using a webcam, a projector, and possibly a microphone, this system will allow the computer to play Set. Set is a card game which involves finding patterns among a 12-card layout. The instructor at [http://modelai.gettysburg.edu/2010/set/gettingSetWithOpenCV.html this website] makes the interesting point that for humans, it is easy to gather information about the cards, but hard to find sets. For computers, it is the opposite: even with a brute force algorithm, it is a trivial matter to find all sets in a layout, but it is difficult to read the cards.

Our github page is:

[https://github.com/mayhewsw/BeagleSetGame https://github.com/mayhewsw/BeagleSetGame]

== Game Play ==
It will be a command line application, written in Python using the OpenCV Python bindings.

Basic Flow:
* Start the program
* Set out the cards
* When there are 12 cards, the program will start to recognize cards and find sets
* When the computer finds a set, it will project the locations of the cards onto the playing surface
* If the computer can't find a set, then project red X, or speech synthesis "No set", or print to console

If there is time:
* If a human finds a set - user input: click, speech recognition - and computer stops looking
* Speech synthesis - ask for confirmation on sets (could also be command line - much easier)

== Tasks ==
* Decide on final functionality
* Come up with the hardware setup, frame to hold the camera and projector
* Test OpenCV on the Beagle - Stephen
* Learn how to stream video input using OpenCV (or PyGame) - Sam
* Finish the Set card recognizer - Stephen
* Bring the system together - Everybody
* Test the DLPpico projector, get it to communicate with the camera - Julian
* Install emacs on the Beagle so we don't have to deal with vi - Stephen

Completed tasks:
* OpenCV is installed on my Beagle - Stephen
* Game logic has been acquired - Stephen

[[Category:ECE497]]

ECE497 Project Set Playing Beagle

2011-05-04T00:17:53Z

Mayhewsw:

Team members: Stephen Mayhew, Samuel Allen, Julian Ametsitsi

== Description ==
Using a webcam, a projector, and possibly a microphone, this system will allow the computer to play Set. Set is a card game which involves finding patterns among a 12-card layout. The instructor at [http://modelai.gettysburg.edu/2010/set/gettingSetWithOpenCV.html this website] makes the interesting point that for humans, it is easy to gather information about the cards, but hard to find sets. For computers, it is the opposite: even with a brute force algorithm, it is a trivial matter to find all sets in a layout, but it is difficult to read the cards.

Our github page is:

[https://github.com/mayhewsw/BeagleSetGame https://github.com/mayhewsw/BeagleSetGame]

== Game Play ==
It will be a command line application, written in Python using the OpenCV Python bindings.

Basic Flow:
* Start the program
* Set out the cards
* When there are 12 cards, the program will start to recognize cards and find sets
* When the computer finds a set, it will project the locations of the cards onto the playing surface
* If the computer can't find a set, then project red X, or speech synthesis "No set", or print to console

If there is time:
* If a human finds a set - user input: click, speech recognition - and computer stops looking
* Speech synthesis - ask for confirmation on sets (could also be command line - much easier)

== Tasks ==
* Decide on final functionality
* Come up with the hardware setup, frame to hold the camera and projector
* Test OpenCV on the Beagle - Stephen
* Learn how to stream video input using OpenCV (or PyGame) - Sam
* Finish the Set card recognizer - Stephen
* Bring the system together - Everybody
* Test the DLPpico projector, get it to communicate with the camera - Julian

Completed tasks:
* OpenCV is installed on my Beagle - Stephen
* Game logic has been acquired - Stephen

[[Category:ECE497]]

ECE497 Project Set Playing Beagle

2011-05-04T00:17:34Z

Mayhewsw:

Team members: Stephen Mayhew, Samuel Allen, Julian Ametsitsi

== Description ==
Using a webcam, a projector, and possibly a microphone, this system will allow the computer to play Set. Set is a card game which involves finding patterns among a 12-card layout. The instructor at [http://modelai.gettysburg.edu/2010/set/gettingSetWithOpenCV.html this website] makes the interesting point that for humans, it is easy to gather information about the cards, but hard to find sets. For computers, it is the opposite: even with a brute force algorithm, it is a trivial matter to find all sets in a layout, but it is difficult to read the cards.

Our github page is:

[https://github.com/mayhewsw/BeagleSetGame https://github.com/mayhewsw/BeagleSetGame]

== Game Play ==
It will be a command line application, written in Python using the OpenCV Python bindings.

Basic Flow:
* Start the program
* Set out the cards
* When there are 12 cards, the program will start to recognize cards and find sets
* When the computer finds a set, it will project the locations of the cards onto the playing surface
* If the computer can't find a set, then project red X, or speech synthesis "No set", or print to console

If there is time:
* If a human finds a set - user input: click, speech recognition - and computer stops looking
* Speech synthesis - ask for confirmation on sets (could also be command line - much easier)

== Tasks ==
* Decide on final functionality
* Come up with the hardware setup, frame to hold the camera and projector
* Test OpenCV on the Beagle - Stephen
* Learn how to stream video input using OpenCV (or PyGame) - Sam
* Finish the Set card recognizer - Stephen
* Bring the system together - Everybody
* Test the DLPpico projector, get it to communicate with the camera - Julian

Completed tasks:
* OpenCV is installed on my Beagle - Stephen
* Game logic has been acquired - Stephen

[[Category:ECE497]]

ECE497 Project Set Playing Beagle

2011-05-04T00:17:23Z

Mayhewsw:

Team members: Stephen Mayhew, Samuel Allen, Julian Ametsitsi

== Description ==
Using a webcam, a projector, and possibly a microphone, this system will allow the computer to play Set. Set is a card game which involves finding patterns among a 12-card layout. The instructor at [http://modelai.gettysburg.edu/2010/set/gettingSetWithOpenCV.html this website] makes the interesting point that for humans, it is easy to gather information about the cards, but hard to find sets. For computers, it is the opposite: even with a brute force algorithm, it is a trivial matter to find all sets in a layout, but it is difficult to read the cards.

Our github page is:

[https://github.com/mayhewsw/BeagleSetGame https://github.com/mayhewsw/BeagleSetGame]

== Game Play ==
It will be a command line application, written in Python using the OpenCV Python bindings.

Basic Flow:
* Start the program
* Set out the cards
* When there are 12 cards, the program will start to recognize cards and find sets
* When the computer finds a set, it will project the locations of the cards onto the playing surface
* If the computer can't find a set, then project red X, or speech synthesis "No set", or print to console

If there is time:
* If a human finds a set - user input: click, speech recognition - and computer stops looking
* Speech synthesis - ask for confirmation on sets (could also be command line - much easier)

== Tasks ==
* Decide on final functionality
* Come up with the hardware setup, frame to hold the camera and projector
* Test OpenCV on the Beagle - Stephen
* Learn how to stream video input using OpenCV (or PyGame) - Sam
* Finish the Set card recognizer - Stephen
* Bring the system together - Everybody
* Test the DLPpico projector, get it to communicate with the camera - Julian

Completed tasks:
* OpenCV is installed on my Beagle - Stephen
* Game logic has been acquired - Stephen

[[Category:ECE497]]

ECE497 Project Set Playing Beagle

2011-05-04T00:15:43Z

Mayhewsw:

Team members: Stephen Mayhew, Samuel Allen, Julian Ametsitsi

== Description ==
Using a webcam, a projector, and possibly a microphone, this system will allow the computer to play Set. Set is a card game which involves finding patterns among a 12-card layout. The instructor at [http://modelai.gettysburg.edu/2010/set/gettingSetWithOpenCV.html this website] makes the interesting point that for humans, it is easy to gather information about the cards, but hard to find sets. For computers, it is the opposite: even with a brute force algorithm, it is a trivial matter to find all sets in a layout, but it is difficult to read the cards.

Our github page is:

[https://github.com/mayhewsw/BeagleSetGame https://github.com/mayhewsw/BeagleSetGame]

== Game Play ==
It will be a command line application, written in Python using the OpenCV Python bindings.

Basic Flow:
* Start the program
* Set out the cards
* When there are 12 cards, the program will start to recognize cards and find sets
* When the computer finds a set, it will project the locations of the cards onto the playing surface
* If the computer can't find a set, then project red X, or speech synthesis "No set", or print to console

If there is time:
* If a human finds a set - user input: click, speech recognition - and computer stops looking
* Speech synthesis - ask for confirmation on sets (could also be command line - much easier)

== Tasks ==
* Decide on final functionality
* Come up with the hardware setup, frame to hold the camera and projector
* Set up a git repository for the project - Stephen
* Install and test OpenCV on the Beagle - Stephen
* Learn how to stream video input using OpenCV (or PyGame) - Sam
* Finish the Set card recognizer - Stephen
* Write the game logic - Stephen
* Bring the system together - Everybody
* Test the DLPpico projector, get it to communicate with the camera - Julian

[[Category:ECE497]]

ECE497 Project Set Playing Beagle

2011-05-04T00:15:27Z

Mayhewsw:

Team members: Stephen Mayhew, Samuel Allen, Julian Ametsitsi

== Description ==
Using a webcam, a projector, and possibly a microphone, this system will allow the computer to play Set. Set is a card game which involves finding patterns among a 12-card layout. The instructor at [http://modelai.gettysburg.edu/2010/set/gettingSetWithOpenCV.html this website] makes the interesting point that for humans, it is easy to gather information about the cards, but hard to find sets. For computers, it is the opposite: even with a brute force algorithm, it is a trivial matter to find all sets in a layout, but it is difficult to read the cards.

Our github page is:

[https://github.com/mayhewsw/BeagleSetGame]

== Game Play ==
It will be a command line application, written in Python using the OpenCV Python bindings.

Basic Flow:
* Start the program
* Set out the cards
* When there are 12 cards, the program will start to recognize cards and find sets
* When the computer finds a set, it will project the locations of the cards onto the playing surface
* If the computer can't find a set, then project red X, or speech synthesis "No set", or print to console

If there is time:
* If a human finds a set - user input: click, speech recognition - and computer stops looking
* Speech synthesis - ask for confirmation on sets (could also be command line - much easier)

== Tasks ==
* Decide on final functionality
* Come up with the hardware setup, frame to hold the camera and projector
* Set up a git repository for the project - Stephen
* Install and test OpenCV on the Beagle - Stephen
* Learn how to stream video input using OpenCV (or PyGame) - Sam
* Finish the Set card recognizer - Stephen
* Write the game logic - Stephen
* Bring the system together - Everybody
* Test the DLPpico projector, get it to communicate with the camera - Julian

[[Category:ECE497]]

ECE497 Project Set Playing Beagle

2011-05-02T12:33:41Z

Mayhewsw:

Team members: Stephen Mayhew, Samuel Allen, Julian Ametsitsi

== Description ==
Using a webcam, a projector, and possibly a microphone, this system will allow the computer to play Set. Set is a card game which involves finding patterns among a 12-card layout. The instructor at [http://modelai.gettysburg.edu/2010/set/gettingSetWithOpenCV.html this website] makes the interesting point that for humans, it is easy to gather information about the cards, but hard to find sets. For computers, it is the opposite: even with a brute force algorithm, it is a trivial matter to find all sets in a layout, but it is difficult to read the cards.

== Game Play ==
It will be a command line application, written in Python using the OpenCV Python bindings.

Basic Flow:
* Start the program
* Set out the cards
* When there are 12 cards, the program will start to recognize cards and find sets
* When the computer finds a set, it will project the locations of the cards onto the playing surface
* If the computer can't find a set, then project red X, or speech synthesis "No set", or print to console

If there is time:
* If a human finds a set - user input: click, speech recognition - and computer stops looking
* Speech synthesis - ask for confirmation on sets (could also be command line - much easier)

== Tasks ==
* Decide on final functionality
* Come up with the hardware setup, frame to hold the camera and projector
* Set up a git repository for the project - Stephen
* Install and test OpenCV on the Beagle - Stephen
* Learn how to stream video input using OpenCV (or PyGame) - Sam
* Finish the Set card recognizer - Stephen
* Write the game logic - Stephen
* Bring the system together - Everybody
* Test the DLPpico projector, get it to communicate with the camera - Julian

[[Category:ECE497]]

ECE497 Project Set Playing Beagle

2011-05-02T12:22:36Z

Mayhewsw:

ECE497 Project Set Playing Beagle

2011-05-02T12:13:43Z

Mayhewsw: moved ECE497: Set Player project to ECE497 Project Set Playing Beagle

ECE497: Set Player project

2011-05-02T12:13:43Z

Mayhewsw: moved ECE497: Set Player project to ECE497 Project Set Playing Beagle

#REDIRECT [[ECE497 Project Set Playing Beagle]]

ECE497 Project Set Playing Beagle

2011-04-28T13:27:40Z

Mayhewsw:

ECE497 Lab11 Using the Open Sound System (OSS)

2011-04-27T20:47:25Z

Mayhewsw:

ECE497 Project Set Playing Beagle

2011-04-27T02:10:42Z

Mayhewsw:

Team members: Stephen Mayhew, Samuel Allen

== Description ==
Using a webcam, a projector, and possibly a microphone, this system will allow the computer to play Set. Set is a card game which involves finding patterns among a 12-card layout. The instructor at [http://modelai.gettysburg.edu/2010/set/gettingSetWithOpenCV.html this website] makes the interesting point that for humans, it is easy to gather information about the cards, but hard to find sets. For computers, it is the opposite: even with a brute force algorithm, it is a trivial matter to find all sets in a layout, but it is difficult to read the cards.

== Tasks ==
* Decide on final functionality
* Set up a git repository for the project
* Install and test OpenCV on the Beagle
* Learn how to stream video input using OpenCV (or PyGame)
* Finish the Set card recognizer
* Write the game logic
* Bring the system together
* Test the DLPpico projector, get it to communicate with the camera

[[Category:ECE497]]

ECE497 Project Set Playing Beagle

2011-04-27T02:06:15Z

Mayhewsw:

Team members: Stephen Mayhew, Samuel Allen

== Description ==
pass

== Tasks ==
* Decide on final functionality
* Set up a git repository for the project
* Install and test OpenCV on the Beagle
* Learn how to stream video input using OpenCV (or PyGame)
* Finish the Set card recognizer
* Write the game logic
* Bring the system together
* Test the DLPpico projector, get it to communicate with the camera

[[Category:ECE497]]

ECE497 Project Set Playing Beagle

2011-04-27T02:04:21Z

Mayhewsw: Created page with "Team members: Stephen Mayhew, Samuel Allen == Description == pass == Tasks == * Decide on final functionality * Set up a git repository for the project * Install and test Open..."

User:Mayhewsw

2011-04-27T02:01:14Z

Mayhewsw:

Stephen Mayhew

Computer Science Major, Class of 2012.

== Projects ==
Project topics I'm interested in:
* Speech Recognition - probably using TIESR, or Pocket Sphinx
* Image Recognition - using OpenCV. I did some work with OpenCV in the image recognition class last quarter, and I have a very simple framework for playing card recognition made already. Perhaps something to do with playing cards and virtual reality, although the [[ECE597_Project_Auto_HUD | road sign project from last year]] also looks very interesting.
* Natural Language Processing - I'm not sure if this is very doable on an embedded system, but it is one of my interests.

I will be working on the [[ECE497: Set Player project]] as my final project.

== Mini-projects ==

* I tried to get the Kinect running on the beagle. I did not have much success.
* I tried out 2 different Ubuntu installs, both were successful.
* I attempted to compile the kernel without bitbake. I was successful in compiling it, but not in running it.

== How To ==
* [[ECE497: How to install Ubuntu on the Beagleboard]]

* [[ECE497: How to edit the Matrix GUI]]

== Lab05d Workaround ==
For Lab05 Part d, I had to edit makefile_profile.mak and app.c.

I put both my files on pastebin:<br />
app.c: [http://pastebin.com/r6vsMVTU]<br />
makefile_profile.mak: [http://pastebin.com/gP0yKfN6]

[[Category:ECE497]]