Question

My question can be asked in two different aspects: one is from data structure perspective, and the other is from image processing perspective. Let’s begin with the data structure perspective: suppose now I have a component composed of several small items as the following class shows:

class Component
{
public:
  struct Point
  { 
     float x_;
     float y_;
  };
  Point center;
  Point bottom;
  Point top;
}

In the above example, the Component class is composed of member variables such as center, bottom and top (small items).

Now I have a stack of components (the number of components is between 1000 and 10000), and each component in the stack has been assigned different values, which means there are no duplicate components in the stack. Then, if one small item in the component, for example, ‘center’ in the illustrated class is known, we can find the unique component in the stack. After that, we can retrieve other properties in the component. Then my question is, how to build a right container data structure to make the searching easier? Now I am considering to use vector and find algorithm in STL(Pseudocode）:

vector<Component> comArray;
comArray.push_back( component1);
.....
comArray.push_back(componentn);
find(comArray.begin(), comArray.end(), center);

I was wondering whether there are more efficient containers to solve this problem.

I can also explain my question from image processing perspective. In image processing, connect component analysis is a very important step for object recognition. Now for my application I can obtain all the connect components in the image, and I also find interesting objects should fulfill the following requirement: their connect component centers should be in a specific range. Therefore, given this constraint, I can eliminate many connected components and then work on the candidate ones. The key step in the above procedure is to how to search for candidate connected components if the central coordinate constraint is given. Any idea will be appreciated.

Answer 1

If you need to be able to get them rather fast, here’s a little strange solution for you.

Note that it is a bad solution general-speaking, but it may suit you.

You could make an ordinary vector< component >. Or that can even be a simple array. Then make three maps:

map< Point, Component *>center
map< Point, Component *>bottom
map< Point, Component *>top

Fill them with all the available values of center, bottom and top as keys, and provide pointers to the corresponding Components as values (you could also use just indexes in a vector, so it would be map< Point, int >).

After that, you just use center[Key], bottom[Key] or top[Key], and get either your value (if you store pointers), or the index of your value in the array (if you store indexes).

I wouldn’t use such an approach often, but it could work if the values will not change (so you can fill the index maps once), and the data amount is rather big (so searching through an unsorted vector is slow), and you will need to search often.