I am thinking of creating a robot that can navigate using a map. It is controlled from a PC. An 8-bit controller performs low level tasks and the PC is doing the image processing. I plan to implement it in a single room where the robot is placed and the robot and environment are tracked by a camera from a height or from the ceiling of the room. First, the robot needs to be mapped, like this http://www.societyofrobots.com/programming_wavefront.shtml
To do:
Track the robot from some height using camera Following the wavefont algorithim to locate robot and obstacles.
Procedure:(just my idea)
The camera will give image of the robot surrounded by obstacles in
the random places. using some opencv technique draw some grind over
the image.
Locating the grid which contain robot(by having some colored symbol
over the robot) and locating the grids containing the obstacle.
Now the grids with obstacle is thought as wall and the remaining is
the free space for the robot to navigate.
robot is going to get the goal place which should be reached is given
from the pc(may be like point the place to reach in the image by
mouse click).
firstly finding the obstacle from the video stream is to be done for that iam going to catch a image of the robot which is in the room now the image is edit by manually in M.S paint by filling the grid with stationary obstacle by some color say red.
now the edited image is going to be the reference and it is compared with video stream to tell the free space available to robot.
each grid is given some value using that place value of the robot should be determined
now i should be able to give some grid value in the free space to make it as goal for the robot
now the Pc should calculate and tell the robot which grid should be traveled to reach the goal. the only thing the robot need to figure out itself is dynamic obstacle avoidance like cat walking across the robot
comparing the area of the room with the image of some dimension to find how far the robot moved and how far to go
is it possible to do? can anybody help me to do this?
\thanks in advance
Not sure if this will help you, but I did some work related to your post. Though I'd share.
http://letsmakerobots.com/node/38208
Related
I'm a relative newbie when it concerns image analysis. My PhD advisor introduced a question regarding calculating the surface area of the forearm of pain patients who cannot stand even the lightest touch on their skin.
Therefore, I'd like to find out is whether or not the following is feasible:
My idea is mounting a small video camera unto a pod which is placed on a circular rail (like that of a toy train) far enough from the forearm so it can capture its whole length.
The participant will then place their forearm in the middle of this "capturing circle", and the camera will be circled to capture a 360 view of the forearm.
The video will be then fed into ImageJ/Fiji for pre-processing, eventually to be rendered as a 3D-object which surface and volume can be calculated and further used for analysis.
I'd appreciate your expert opinions on this, and any help/recommendation will be welcome.
Thanks for your attention.
So I'm working in this app and got many things done, i can track the ball perfectly on my current videos ( just a small part of the lane currently ). The Idea is to be able to track a bowling ball down the whole lane to calculate all sorts of things ( like speed and position ). My problem is that lanes are 60 foot ( 18m ) long and like 4 ( 1.1m ) wide. I figured the best way to do it was putting the Cameras on the ceiling, because background extraction worked flawlessly so my first test was a USB webcams. My first problems were to discover that ceilings are almost 10 foot ( 3m ) from the floor so i would need a lot of webcams, when i got 1 more i realized 2 things, webcams are not the way because:
a) It doesn't support the bandwidth of streaming the video of many cameras at the time at high res.
b) I would need a lot of webcams because of fixed lens sizes.
c) Unless you use powered cables USB doesn't get very far before losing singal
So i discovered what it seemed to be the solution that is something like 1 or 2 PointGrey cameras (Butterfly or other model) with maybe a 4mm or 8 mm lens would work. At this point my financing is very low and I'm trying to have the least amount of possible errors as is my own startup and as an Argentinean is not as easy to do stuff like being in the US.
My question is what kind of approach would you guys take to be able to capture the whole lane? maybe change camera positions and use other way instead of background extraction? You guys think I'm going on the right track? with the USB cam, at least i was able to capture and follow frame by frame the ball in a very limited space of lane, but i realized i can do everything i want and the project is possible, but USB is not the way.
Hoping to hear some advice as I'm no expert in computer vision or cameras. and i want to do a cost efficient project. I'm currently working on C# using emgu.
Thanks to anyone took the time to read this :)
These approaches came to my mind:
1- I seems that with one camera on the ceiling your system works well but you do not cover the whole lane. Then you can calculate the speed and position in the portion you cover and make an estimation for when the ball goes of the field of view.
2- Another approach is to use a camera with a wider angle on the ceiling.
3- Instead of on the ceiling, you can mount the camera somewhere else (for example on the sides) that covers the whole lane. Since you exactly know the location of your camera you can calculate speed and position based on the location of the ball on the screen (taking into account prespective,etc). The problem with this approach would be that you have to mount the camera always in one point for all customers and the system won't work if camera moved later.
4- The most robust approach to me is stereo vision. You use two cameras with a certain distance to each other, calibrate them. Then you can mount them anywhere that covers the whole lane. Distance, speed, position, etc are all feasible and easy to extract when you have the matrices of two cameras.
put a camera at an angle where it can see the whole lane. For example, you can mount it on a ceiling looking down and forward. Background subtraction should just work fine while the distance can be calibrated based on the initial and final position of the ball. The mapping between the image and the physical world (lane surface) will be given by Homography which requires 4 point correspondences to calculate.
I'm playing around with motion detection through a webcam connected to RaspberryPi using OpenCV and cvBlob in C++. I want to kick it up a notch and make a robot that detects and tracks movement driving towards it and turning left/ring to keep the moving object in the center of view.
But I quickly hit a roadblock - I cannot find any materials about motion tracking with an active, moving camera that are more on an amateur level. I found only academic papers e.g. on optical flow. Sure, I can try to get through one of them, if I knew that's the algorithm that suits my needs, but going through all the papers and choosing the one among them is beyond my level of understanding.
So I would be grateful, If someone could point me to the simplest possible method (after all, RaspberryPi has quite limited resources) that would allow me to determine if the selected blob (I plan to track the movement of the biggest blob exceeding a set size) moves on the horizontal axis, compared to the movement of the background caused by the movement of the robot on which the camera is mounted The movement in the vertical axis is irrelevant in this application.
If you use the the left and right x co-ordinates of the blob you should be able to determine if the object is moving by measuring the distance from the left and right image borders to the objects left and right x co-ordinates. If the robot is moving left or right, the object would have stopped if the distance of the measurement starts to decrees.
My goal to for an autonomous robot to navigate a walled mazed using a camera. The camera is fixed atop the robot and facing down to be able to view the walls and the robot from above.
The approach I took that seemed most straightforward from my experience was to
Threshold the image to extract the red walls
Perform Canny edge detection
Use the Hough transform the detect the strong lines from the edges
as seen below after some parameter tweaking
I want to have the robot move forward and avoid "hitting" the red walls. The problem is that there are multiple lines detected per wall edge from the hough transform. One idea I had was to perform k-means clustering to cluster the lines and find the centers (means) of each cluster, but I do not know the number of wall edges (and therefore number of clusters to input to the k-means algorithm) I will have at any time in navigating the maze (walls ahead, behind, multiple turn intersections, etc.).
Any help in finding a good way to have a consistent wall location to compare the robot's location (which is always fixed in every image frame) to at any time in navigating the maze would be greatly appreciated. I'm also open to any other approach to this problem.
Run a skeletonization algorithm before extracting the HoughLines.
I'm trying to track the position of a robot from an overhead webcam. However, as I don't have much access to the robot or the environment, so I have been working with snapshots from the webcam.
The robot has 5 bright LEDs positioned strategically which are a different enough color from the robot and the environment so as to easily isolate.
I have been able to do just that using EmguCV, resulting in a binary image like the one below. My question is now, how to I get the positions of the five blobs and use those positions to determine the position and orientation of the robot?
I have been experimenting with the Emgu.CV.VideoSurveillance.BlobTrackerAuto class, but it stubbornly refuses to detect the blobs in the above image. Being a bit of a newbie when it comes to any of this, I'm not sure what I could be doing wrong.
So what would be the best method of obtaining the positions of the blobs in the above image?
I can't tell you how to do it with emgucv in particular, you'd need to translate the calls from opencv to emgucv. You'd use cv::findContours to get the blobs and cv::moments to get the position of the blobs (the formula to get the middle points of the blobs is in the documentation of cv::moments). Then you'd use cv::estimateRigidTransform to get the position and orientation of the robot.
I use cvBlob library to work blobs. Yesterday i worked with it to detect small blobs and works fine.
I wrote a python module to do this very thing.
http://letsmakerobots.com/node/38883#comments