Algorithm and data structure to find and store superpixels' neighborhood in C++

Question

I have an image, holding results of segmentation, like this one.

I need to build a graph of neighborhood of patches, colored in different colors. As a result I'd like a structure, representing the following

Here numbers represent separate patches, and lines represent patches' neighborhood. Currently I cannot figure out where to start, which keywords to google.

Could anyone suggest anything useful?

Image is stored in OpenCV's cv::Mat class, as for graph, I plan to use Boost.Graph library.

So, please, give me some links to code samples and algorithms, or keywords.

Thanks.

Update. After a coffee-break and some discussions, the following has come to my mind.

1. Build a large lattice graph, where each node corresponds to each image pixel, and links connect 8 or 4 neighbors.
2. Label each graph node with a corresponding pixel value.
3. Try to merge somehow nodes with the same label.

My another problem is that I'm not familiar with the BGL (but the book is on the way :)).

So, what do you think about this solution?

Update2 Probably, this link can help.

However, the solution is still not found.

Answer 1

You could solve it like that:

1. Define regions (your numbers in the graph)

   • make a 2D array which stores the region number
   • start at (0/0) and set it to 1 (region number)
   • set the whole region as 1 using floodfill algorithm or something.
   • during floodfill you probably encounter coordinates which have different color. store those inside a queue. start filling from those coordinates and increment region number if your previous fill is done.

   .

2. Make links between regions

   • iterate through your 2D array.
   • if you have neighbouring numbers, store the number pair (probably in a sorted manner, you also have to check whether the pair already exists or not). You only have to check the element below, right and the one diagonal to the right, if you advance from left to right.

Though I have to admit I don't know a thing about this topic.. just my simple idea..

Answer 2

You could use BFS to mark regions.

To expose cv::Mat to BGL you should write a lot of code. I think writeing your own bfs is much more simplier.

Than you for every two negbours write their marks to std::set<std::pair<mark_t, mark_t>>. And than build graph from that.

Answer 3

I think that if your color patches are that random, you will probably need a brute force algorithm to do what you want. An idea could be:

• Do a first brute force pass. This has to identify all the patches. For example, make a matrix A of the same size as the image, and initialize it to 0. For each pixel which is still zero, start from it and mark it as a new patch, and try a brute force approach to find the whole extent of the patch. Each matrix cell will then have a value equal to the number of the patch it is in it.
• The patch numbers have to be 2^N, for example 1, 2, 4, 8, ...
• Make another matrix B of the size of the image, but each cell holds two values. This will represent the connection between pixels. For each cell of matrix B, the first value will be the absolute difference between the patch number in the pixel and the patch number of an adjacent pixel. First value is difference with the pixel below, second with the pixel to the left.
• Pick all unique values in matrix B, you have all the connections possible.

This works because each difference between patches number is unique. For example, if in B you end up with numbers 3, 6, 7 it will mean that there are contacts between patches (4,1), (8,2) and (8,1). Value 0 of course means that there are two pixels in the same patch next to each other, so you just ignore them.