How can I improve the map in my Mobile Autonomous Robot using KINECT

Question

A little background of my aim

I am in the process of building a mobile autonomous robot which must navigate around an unknown area, must avoid obstacles and receive speech input to do various tasks. It also must recognize faces, objects etc. I am using a Kinect Sensor and wheel odometry data as its sensors. I chose C# as my primary language as the official drivers and sdk are readily available. I have completed the Vision and NLP module and am working on the Navigation part.

My robot currently uses the Arduino as a module for communication and a Intel i7 x64 bit processor on a laptop as a CPU.

This is the overview of the robot and its electronics:

---

The Problem

I implemented a simple SLAM algorithm which gets robot position from the encoders and the adds whatever it sees using the kinect (as a 2D slice of the 3D point cloud) to the map.

This is what the maps of my room currently look like:

This is a rough representation of my actual room:

As you can see, they are very different and so really bad maps.

• Is this expected from using just dead reckoning?
• I am aware of particle filters that refine it and am ready to implement, but what are the ways in which I can improve this result?

---

Update

I forgot to mention my current approach (which I earlier had to but forgot). My program roughly does this: (I am using a hashtable to store the dynamic map)

• Grab point cloud from Kinect
• Wait for incoming serial odometry data
• Synchronize using a time-stamp based method
• Estimate robot pose (x,y,theta) using equations at Wikipedia and encoder data
• Obtain a "slice" of the point cloud
• My slice is basically an array of the X and Z parameters
• Then plot these points based on the robot pose and the X and Z params
• Repeat

Answer 1

Is this what would be expected: in principle yes. Although you may be able to improve your odometry model, in general it is not enough to get a good map. Without a description of your system its difficult to say how to improve it. On most systems translation estimation is better than rotation. You could add a gyro and measure the rotation. This should improve your results significantly.

Instead of implementing a particle filter yourself, you could use a SLAM implementation e.g. from openslam. This should save you a lot of time, and will most likely give better results.

Answer 2

I'd suggest that you try particle filters/ EKF.

What you currently do:

--> Dead Reckoning: You're looking at your current position without any reference.

--> Continuous Localization: You roughly know where you are in the map.

If you don't have a reference and don't know where you are on the map, regardless of what actions you take, you will find it dificult to obtain a perfect map.

For example: You're in a circular room. You keep moving forward. You know what was your last move. The map which you get will be that of a straight box like structure. This will occur unless and until you have some way to localize or to know where are you precisely on the map, continuously.

Localization can be done via EKF/Particle Filters if you have a starting reference point. However, the starting reference point is a must.

Answer 3

Because you are using dead reckoning the errors in estimating the pose of the robot accumulate in time. From my experience, after a while, dead reckoning pose estimation becomes useless. If you use extra sensors,like Gyroscope or Accelerometer the pose estimation will improve but since you have no feedback at some point it will diverge as before. As a result, even if you have good data from the Kinect, building an accurate map is difficult since your pose estimation is not valid.

You need to localize your robot at the same time as your try to build your map (SLAM!). So as the map is being created, the same map is also used to localize the robot. This ensures that your pose estimation will not diverge and your map quality should be better. Therefore I would suggest to study some SLAM algorithms (i.e. FastSLAM) and try to implement your own version.