Difference between revisions of "Team R2D2"

Revision as of 23:44, 23 April 2012

To Do

• Connect to iRobot & Send Command with MatLab (with laptop) - Cyrus
• Decide on Camera - Leland & Corey
• Subgroup Make Outline

Imaging

Summary

• Camera will be attached and set - to move the camera left or right we will move the robot
  • We will have to decide if we want to create a contraption to raise/lower the camera
• We need to get a camera that we can also connect to via bluetooth... at first this could be a wired, but we need direct usb connection in final version
• Good Link

Matlab Imaging

• Image Acquisition Toolbox - I think this costs money
• Matlab toolbox to control cannon cameras

OpenCV

• Has some nice functions that could be used to detect opjects
• OpenCV (Open Source Computer Vision) is a library of programming functions for real time computer vision.
  • "applications of the OpenCV library are Human-Computer Interaction (HCI); Object Identification, Segmentation and Recognition; Face Recognition; Gesture Recognition; Motion Tracking, Ego Motion, Motion Understanding; Structure From Motion (SFM); Stereo and Multi-Camera Calibration and Depth Computation; Mobile Robotics."
• OpenCV Documentation
  • Python Interface
  • C++ Interface
• List of compatible cameras
  • Camera used in FLAIL project: Logitech Webcam Pro 9000
    • This camera will work with openCV and matlab camera control features (see here)

Below is python code taken from FLAIL v2

##################
# Camera Control #
##################
class FlailCam:
  """
  Controls a USB webcam. Uses OpenCV to control the camera, and should
  therefore work with any V4L2-compatible camera (in linux) or just about
  anything (in Mac OS). Webcam support being what it is in Linux, though, it
  may not work at all.
 
  If you find yourself in the it-doesn't-even-begin-to-work boat, take a look
  at flailcam.py from FLAIL 1.0. It has a (terrible, kludgy, slow) workaround
  that sometimes worked better.
 
  The important method (get_image) returns a Python Imaging Library (or PIL)
  object; these are well-documented on the PIL website, at
  <http://www.pythonware.com/library/pil/handbook/image.htm>. You're probably
  most interested in the getpixel, putpixel, and save methods. 
 
  FLAIL 1.0 had a FlailImage class, which wrapped the same PIL image class
  used here; if you'd like an extremely simplified interface, take a look at
  that code.
   
  If you'd prefer an OpenCV object, just take a look at the get_image source
  code, and you'll see what to do.
  """
  def __init__(self, index = 0):
    """
    Connect to a camera. OpenCV (which we use for camera control) numbers
    these starting from 0; the index parameter tells which camera to use. In
    Linux, an index of X implies the device /dev/videoX.
    """
    self.cap = opencv.highgui.cvCreateCameraCapture(index)
 
  def get_image(self):
    """
    Take a picture. Return it as a PIL image. 
    """
    return opencv.adaptors.Ipl2PIL(opencv.highgui.cvQueryFrame(self.cap))

Issues

• How do we connect to the camera wirelessly?
  • http://www.youtube.com/watch?v=LG8zX68lxI0

• New leads:
  • http://bitshift.bi.funpic.de/en/dslr-remote/manual/bluetooth.php
  • http://www.informationweek.com/news/cloud-computing/software/228800042
  • Pros: we can use almost any dslr camera.
  • Cons: A lot of (potentially very difficult) coding. And we still need how to send the photo back to our laptop.

• MATLAB approach:
  • http://www.mathworks.com/matlabcentral/newsreader/view_thread/154601
  • Pros: it's been done before, though maybe not without the acquisition toolbox. It looks very straightforward.
  • Cons: Acquisition toolbox is a lot of money. Couldn't find anything about using newer versions of MATLAB to do this. Have to use low res webcam.

Possible Cameras

• Something
• BT-1 - 640x480

Navigation

Notes

Jack and Duke met on 4/20 to discuss navigation. The consensus was that our first goal is to figure out how to design a virtual map of a space and write commands to get the robot to go to a target location in the space. Once we do that, we will work on mapping out chambers, hopefully using the robot to gather data of the shape of our chambers floor (which one are we going to do?) and turn that data into a map. We also discussed the possibility of using traveling salesman problem model to get the robot to our target locations as quickly as possible.