CODEWITHSUNDEEP
c++
Betai97
Betai97

Reputation: 51

How do you convert a 16 bit unsigned integer to a larger 8 bit unsigned integer?

I have a function that needs to return a 16 bit unsigned int vector, but for another from which I also call this one, I need the output in 8 bit unsigned int vector format. For example, if I start out with:

std::vector<uint16_t> myVec(640*480);

How might I convert it to the format of:

std::vector<uint8_t> myVec2(640*480*4);

UPDATE (more information): I am working with libfreenect and its getDepth() method. I have modified it to output a 16 bit unsigned integer vector so that I can retrieve the depth data in millimeters. However, I would also like to display the depth data. I am working with some example code c++ from the freenect installation, which uses glut and requires an 8 bit unsigned int vector to display the depth, however, i need the 16 bit to retrieve the depth in millimeters and log it to a text file. Therefore, i was looking to retrieve the data as a 16 bit unsigned int vector in glut's draw function, and then convert it so that I can display it with the glut function that's already written.

Upvotes: 4

Views: 2087

Answers (3)

RyanP
RyanP

Reputation: 1918

As per your update, assuming the 8-bit unsigned int is going to be displayed as a gray scale image, what you need is akin to a Brightness Transfer Function. Basically, your output function is looking to map the data to the values 0-255, but you don't necessarily want those to correspond directly to millimeters. What if all of your data was from 0-3mm? Then your image would look almost completely black. What if it was all 300-400mm? Then it'd be completely white because it was clipped to 255.

A rudimentary way to do it would be to find the minimum and maximum values, and do this:

double scale = 255.0 / (double)(maxVal - minVal);
for( int i = 0; i < std::min(myVec.size(), myVec2.size()); ++i )
{
    myVec2.at(i) = (unsigned int)((double)(myVec.at(i)-minVal) * scale);
}

depending on the distribution of your data, you might need to do something a little more complex to get the most out of your dynamic range.

Edit: This assumes your glut function is creating an image, if it is using the 8-bit value as an input to a graph then you can disregard.

Edit2: An update after your other update. If you want to fill a 640x480x4 vector, you are clearly doing an image. You need to do what I outlined above, but also the 4 dimensions that it is looking for are Red, Green, Blue, and Alpha. The Alpha channel needs to be 255 at all times (this controls how transparent it is, you don't want it to be transparent), as for the other 3... that value you got from the function above (the scaled value) if you set all 3 channels (channels being red, green, and blue) to the same value it will appear as grayscale. For example, if my data ranged from 0-25mm, for a pixel who's value is 10mm, I would set the data to 255/(25-0)* 10 = 102 and therefore the pixel would be (102, 102, 102, 255)

Edit 3: Adding wikipedia link about Brightness Transfer Functions - https://en.wikipedia.org/wiki/Color_mapping

Upvotes: 3

edmz
edmz

Reputation: 8494

Straightforward way:

std::vector<std::uint8_t> myVec2(myVec.size() * 2);
std::memcpy(myVec2.data(), myVec.data(), myVec.size());

or with the use of the standard library

std::copy( begin(myVec), end(myVec), begin(myVec2));

Upvotes: -1

Alex Lop.
Alex Lop.

Reputation: 6875

How might I convert it to the format of:

std::vector myVec2; such that myVec2.size() will be twice as big as myVec.size()?

myVec2.reserve(myVec.size() * 2);
for (auto it = begin(myVec); it!=end(myVec); ++it)
{
    uint8_t val = static_cast<uint8_t>(*it); // isolate the low 8 bits
    myVec2.push_back(val);
    val = static_cast<uint8_t>((*it) >> 8); // isolate the upper 8 bits
    myVec2.push_back(val);
}

Or you can change the order of push_back()'s if it matters which byte come first (the upper or the lower).

Upvotes: 3

Related Questions