为std :: vector赋值<user-defined>

Question

I am working with images and computing radon transform for an object. The function that computes the transform accepts vector as input:

pixel p;
vector<pixel> segObj  //segObj is the object segmneted from the image

pixel is a user-defined struct defined as:

struct pixel
{
float x, y;  //x,y coordinates of the pixel
};

Currently, I am doing an element wise assignment to the vector:

for(int ix=0; ix < element_count; ix++)
{
f.x = xCoordArray[ix];
f.y = yCoordArray[ix];
segObj.push_back(f);
//xCoordArray and yCoordArray are computed separately
}

The for loop makes it slow when dealing with large images. Is there a way to assign xCoordArray and yCoordArray directly to vector<pixel>segObj

I am not expereinced with the use of vectors so any help would be appreciated.
Also, If xCoordArray , yCoordArray can be computed as vectors, is there a way to join them so that each vector index as two values.

Answer 1

One reason of being it slow is the reallocation (and copy) done by the vector as the for loop executes. In your case, you could do this:

segObj.reserve(element_count); //DO THIS

for(int ix=0; ix < element_count; ix++)
{
  f.x = xCoordArray[ix];
  f.y = yCoordArray[ix];
  segObj.push_back(f);
}

This at least will improve the code a little bit, as there is one allocation before the loop, and no reallocation and copy is done when the for loop executes.

If your compiler supports C++11, then you could try this:

struct pixel
{
  float x,y;
  pixel(float x, float y) : x(x), y(y) {}   //add this constructor
};

segObj.reserve(element_count); //DO THIS

for(int ix=0; ix < element_count; ix++)
{
  segObj.emplace_back(xCoordArray[ix], yCoordArray[ix]);
}

Note that it calls emplace_back , not push_back . This member function is available with C++11 only; it constructs the pixel objects in-place. No copy of pixel object is made when adding to the vector:

template< class... Args >
void emplace_back( Args&&... args ); (since C++11)

Appends a new element to the end of the container. The element is constructed in-place, ie no copy or move operations are performed . The constructor of the element is called with exactly the same arguments, as supplied to the function.

Answer 2

You can create an input iterator producing pixel objects and assign those directly. You could initialize the objects directly using something along the lines of this:

pixel iterator::operator*() const {
    pixel rc = {
        xCoordArray[index],
        tCoordArray[index]
    };
    return rc;
}

That said, I somewhat doubt that this is indeed the bottleneck: did you profile your code or are you suspecting that this is the problem?