Whats the simplest way to do object recognition? - object-recognition

Given that I have harris corner detection and canny edge detection working, what is the simplest way to determine whether two images have corresponding edges or shape? The use case intended would be to classify really simple shapes and objects like a banana or a bottle.


Shape ellipse like detection with varying edge intensity

I need some help, I'm struggling to detect a shape ellipse like.
I want to make it by C++ or python.
At first glance it's clear there is a boundary of the shape though the edges are not homogeneous. I tried many algorithms like blob detection opencv or findcontours but with out any luck.
Clearly, because of non homogeneous edges the detection algorithm should be local and not global.
Here is an example of what I'm trying to do:
Input and desired output in red:

Detect ball/circle in OpenCV (C++)

I am trying to detect a ball in an filtered image.
In this image I've already removed the stuff that can't be part of the object.
Of course I tried the HoughCircle function, but I did not get the expected output.
Either it didn't find the ball or there were too many circles detected.
The problem is that the ball isn't completly round.
I had the idea that it could work, if I identify single objects, calculate their center and check whether the radius is about the same in different directions.
But it would be nice if it detect the ball also if he isn't completely visible.
And with that method I can't detect semi-circles or something like that.
EDIT: These images are from a video stream (real time).
What other method could I try?
Looks like you've used difference imaging or something similar to obtain the images you have..? Instead of looking for circles, look for a more generic loop. Suggestions:
Separate all connected components.
For every connected component -
Walk around the contour and collect all contour pixels in a list
Suggestion 1: Use least squares to fit an ellipse to the contour points
Suggestion 2: Study the curvature of every contour pixel and check if it fits a circle or ellipse. This check may be done by computing a histogram of edge orientations for the contour pixels, or by checking the gradients of orienations from contour pixel to contour pixel. In the second case, for a circle or ellipse, the gradients should be almost uniform (ask me if this isn't very clear).
Apply constraints on perimeter, area, lengths of major and minor axes, etc. of the ellipse or loop. Collect these properties as features.
You can either use hard-coded heuristics/thresholds to classify a set of features as ball/non-ball, or use a machine learning algorithm. I would first keep it simple and simply use thresholds obtained after studying some images.
Hope this helps.

2D Shape recognition and resolving algorithm

I'm looking for an algorithm for detecting simple shapes as rectangles, triangles, squares and circles, from a given set of (x,y) points. I'm also looking for a way of, once detected, transform the path to a more clean shape.
I've scrambled the internet but haven't found any "simple" approaches. Almost all of them are way to advanced for my simple implementation.
Thanks in advance.
On detection:
There are most likely no simple general approaches for classifying any set of points into a shape. However, there are a few basic functions that you could probably build that will be useful for classifying many of the shapes. For instance:
Whether or not the points form a straight line
Whether or not the points form a convex/concave polygon (useful for disqualifying points from matching certain shapes)
Finding center of points and finding distance to center from each point
Whether or not two points share a common axis
With the above functions, you should be able to write some basic logic for classifying several of the shapes.

Border between terrain areas in 3D strategy game

I want to make dynamically generated border between opponent areas on the plain terrain with some points ("bases") (e.g. alien and human bases) in the 3d strategy game. Each base has its own "land of influence" so the border should go on the appropriate distance between conflicting bases. If you have played Settlers I,II etc, you should to understand what I actually mean.
So I have an array of base coords and want to get array of polylines, describing these borders.
Please, can you suggest me any solution for it (may be some algorithms or even ready packages).
Example of desired border:
It sounds like you want a Voronoi diagram. Below is a 2D diagram, but the same algorithm also works in 3D.
I think you might want to look into a suitably weighted Voronoi diagram. In standard VDs, only the distance to the nearest control point matters to determine cells, but from your example it looks like you want control points to have an influence even when they are not the closest point.
For example, there is a region to the left of your highest blue point which is in the red area despite the closest control point being blue:
I assume this is because the NW-most red point exerts an influence, as shown by the arrow.
The 'review' linked from that wikipedia page, and the Google image search results for weighted Voronoi diagram, suggest that this kind of influence, resulting in rounder boundaries, is achievable, though obviously further research awaits you.

Detecting curves in OpenCV

I am just starting to use OpenCV to detect specific curves in an image. First, I want to verify if there is a curve, and next, I would like to identify the type of curve according to vertical or horizontal convex or concave curve. Is there an available function in OpenCV? If not, can you give me some ideas about how can I possibly write such a function? Thanks! By the way, I'm using C++.
Template matching is not a robust way to solve this problem (its like looking at an object from a small pinhole) and edge detectors don't necessarily return you the true edges in the image; false edges such as those due to shadows are returned too. Further, you have to deal with the problem of incomplete edges and other problems that scales up with the complexity of the scene in your image.
The problem you posed, in general, is a very challenging one and, except for toy examples, there are no good solutions.
A rough attempt could be to first try to detect plausible edges using an edge detector (e.g. the canny edge detector suggested). Next, use RANSAC to try to fit a subset of the points in the detected edges to your curve model.
For e.g. let's say you are trying to detect a curve of the following form f(x) = ax^2 + bx + c. RANSAC will basically try to find from among the points in the detected edges, a subset of them that would best fit this curve model. To detect different curves, change f(x) accordingly and run RANSAC for each of them. You can then try to determine if the curve represented by f(x) really exists in your image using some heuristic applied to from the points that were assigned to it by RANSAC (e.g. if too few points were fitted to the model it is likely that the curve is not there. But how to determine a good threshold for the number of points?). You model will get more complex when you have to account for allowable transformation such as rotation etc.
The problem with this approach is you are basically trying fit what you think should be in the image to the points and sometimes, even if what you are looking for is not there, it will return you the "best possible" fit. For e.g. you have a whole bunch of points detected from a concentric circle. If you try to detect straight lines from these points, RANSAC will return you the best fit line! In fact, it could give you many different lines from different runs depending on which points it selected during its random initialization stage.
For more details on how to use RANSAC on this sort of problem, have a look at RANSAC for Dummies by Marco Zuliani. He also has a nice MATLAB toolbox to accompany this tech report, which you can probably port to the language of your choice.
Unless you know what you background looks like, or if you are in control of it e.g. by forcing a clean background, this is a very difficult problem to solve.