Finding image pixel coordinates (integers) from UV values (floats) of obj file

Question

I am parsing an obj file which contains the texture coordinates (vt) values. From what I understand, vt values are a mapping into the texture image corresponding to this obj.

Assume, I have image im = 400x300 pixels

and I have a vt value

vt .33345 .8998

The mapping says, in the image, go the coordinate :

imageWidth x .3345 , imageHeight x .8998 and use the value there.

I have loaded the image values in a 2-d array.

The problem is, these mapping coordinates are floating values, how am I suppose to map them to the integer values of the pixel coordinates ? I can always truncate the decimal part, round off etc. But does the standard defines which one of the option is to be done ?

Answer 1

UV coordinates to Pixel coordinates :

pix.x = (uv.x * texture.width) -0.5
pix.y = ((1-uv.y) * texture.height) -0.5

The y axis of uv coordinates is opposite to the Pixel coordinates on an image.

For nearest neighbor interpolation, just round off the pixel coordinates.

For bilinear interpolation, calculate the participation percentage from the four neighbouring pixels and do a weighed average.

When UV coordinates go outside of range, there is a choice on how to handle the "texture wrapping":

Here's some java code for bilinear interpolation with "repeat" texture wrapping:

private static int billinearInterpolation(Point2D uv, BufferedImage texture) {
    uv.x = uv.x>0 ? uv.x%1 : 1+(uv.x%1);
    uv.y = uv.y>0 ? uv.y%1 : 1+(uv.y%1);
    double pixelXCoordinate = uv.x * texture.getWidth() - 0.5;
    double pixelYCoordinate = (1-uv.y) * texture.getHeight() - 0.5;

    pixelXCoordinate = pixelXCoordinate<0?texture.getWidth()-pixelXCoordinate: pixelXCoordinate;
    pixelYCoordinate = pixelYCoordinate<0?texture.getHeight()-pixelYCoordinate : pixelYCoordinate;

    int x = (int) Math.floor(pixelXCoordinate);
    int y = (int) Math.floor(pixelYCoordinate);

    double pX = pixelXCoordinate - x;
    double pY = pixelYCoordinate - y;

    float[] px = new float[]{(float) (1 - pX), (float) pX};
    float[] py = new float[]{(float) (1 - pY), (float) pY};

    float red = 0;
    float green = 0;
    float blue = 0;
    float alpha = 0;
    for (int i = 0; i < px.length; i++) {
        for (int j = 0; j < py.length; j++) {
            float p = px[i] * py[j];
            if (p != 0) {
                int rgb = texture.getRGB((x + i)%texture.getWidth(), (y + j)%texture.getHeight());
                alpha += (float) ((rgb >> 24) & 0xFF) * p;
                red += (float) ((rgb >> 16) & 0xFF) * p;
                green += (float) ((rgb >> 8) & 0xFF) * p;
                blue += (float) ((rgb >> 0) & 0xFF) * p;
            }
        }
    }
    return (((int) alpha & 0xFF) << 24) |
            (((int) red & 0xFF) << 16) |
            (((int) green & 0xFF) << 8) |
            (((int) blue & 0xFF) << 0);
}