java - 有人可以逐步解释此代码吗？

Question

我有点理解它在做什么，但是下面提供的代码中的步骤背后的逻辑是什么？这是在 LWJGL 中加载纹理的一种方式。但是 for 循环中发生了什么？你不会只是将 x 和 y 相乘来得到一个像素的位置吗？对从 for 循环到代码末尾发生的任何事情的任何解释都会有所帮助，因为当它到达 for 循环时，注释会变得含糊不清。将像素信息放入缓冲区时，我不明白奇怪的符号。

public class TextureLoader { 
private static final int BYTES_PER_PIXEL = 4;//3 for RGB, 4 for RGBA 
   public static int loadTexture(BufferedImage image){ 

      int[] pixels = new int[image.getWidth() * image.getHeight()]; 
        image.getRGB(0, 0, image.getWidth(), image.getHeight(), pixels, 0, image.getWidth()); 

        ByteBuffer buffer = BufferUtils.createByteBuffer(image.getWidth() * image.getHeight() * BYTES_PER_PIXEL); //4 for RGBA, 3 for RGB 

        for(int y = 0; y < image.getHeight(); y++){ 
            for(int x = 0; x < image.getWidth(); x++){ 
                int pixel = pixels[y * image.getWidth() + x]; 
                buffer.put((byte) ((pixel >> 16) & 0xFF));     // Red component 
                buffer.put((byte) ((pixel >> 8) & 0xFF));      // Green component 
                buffer.put((byte) (pixel & 0xFF));               // Blue component 
                buffer.put((byte) ((pixel >> 24) & 0xFF));    // Alpha component. Only for RGBA 
            } 
        } 

        buffer.flip(); //FOR THE LOVE OF GOD DO NOT FORGET THIS 

        // You now have a ByteBuffer filled with the color data of each pixel. 
        // Now just create a texture ID and bind it. Then you can load it using  
        // whatever OpenGL method you want, for example: 

      int textureID = glGenTextures(); //Generate texture ID 
        glBindTexture(GL_TEXTURE_2D, textureID); //Bind texture ID 

        //Setup wrap mode 
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL12.GL_CLAMP_TO_EDGE); 
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL12.GL_CLAMP_TO_EDGE); 

        //Setup texture scaling filtering 
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); 
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); 

        //Send texel data to OpenGL 
        glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, image.getWidth(), image.getHeight(), 0, GL_RGBA, GL_UNSIGNED_BYTE, buffer); 

        //Return the texture ID so we can bind it later again 
      return textureID; 
   } 

   public static BufferedImage loadImage(String loc) 
   { 
        try { 
           return ImageIO.read(DefenseStep.class.getResource(loc)); 
        } catch (IOException e) { 
            //Error Handling Here 
        } 
       return null; 
   }

}

score 2 · Accepted Answer

它所做的只是将图像中的颜色逐个像素地加载到缓冲区中。

此代码使用 Java 中的按位运算符执行此操作。请参阅此Java 线索。

当您看到时>>，这意味着“将该数字的二进制向右移动”，当您看到时num >> n，这意味着“将num的值n位的二进制向右移动。例如：

System.out.println(4 >> 2); // Prints "1"

打印出来1是因为二进制中的 4 是0100，并且当右移 2 位时，你会得到0001，它是十进制的 1。

现在，话虽如此，图像中的颜色使用 ARGB 表示。这意味着图像中的每 32 位都有 8 位专用于 A、R、G 和 B（alpha、红色、绿色和蓝色），因此其十六进制形式如下所示：

0xAARRGGBB

其中每个字母都是十六进制数字。

您发布的代码使用二进制逻辑来检索每组AA,RR等。每组恰好是一个字节或 8 位，所以这就是 8、16 和 24 的来源。&对这两个数字进行按位逻辑AND运算，其中只有两个数字中为 1 的位位置保持 1，每隔一个位置变为 0。

举个具体的例子，让我们RR从 ARGB 中的紫色中检索字节。

在 ARGB 中，黄色是A=255、R=127、G=0和B=127，所以我们的十六进制版本是：

0xAARRGGBB
0xFF7F007F

查看十六进制值，我们看到它RR是倒数第三个字节。要获取RRARGB 值何时在变量中，让我们首先将其放入int pixel：

int pixel = 0xFF7F007F;

请注意与您的代码的相似之处。int像素矩阵中的每一个都是 ARGB 颜色。

接下来，我们将数字右移 2 个RR字节，最低字节也是如此，这给了我们：

0x0000AARR
0x0000FF7F

这是通过以下代码完成的：

int intermediate = pixel >> 16;

这里16的原因是我们要右移 2 个字节，每个字节包含 8 位。>>运算符需要位，所以我们必须给它 16 而不是 2 。

接下来，我们想摆脱AA，但保留RR。为此，我们使用所谓的位掩码和&运算符。位掩码用于挑选出二进制数的特定位。在这里，我们想要0xFF. 这恰好是二进制中的八个 1。（每个F十六进制都是1111二进制。）

忍受我，因为这看起来很难看。当我们这样做int red = intermediate & 0xFF时，它在做什么（二进制）是：

  0000 0000 0000 0000 1111 1111 0111 1111 (0x00007F7F)
& 0000 0000 0000 0000 0000 0000 1111 1111 (0x000000FF)
= 0000 0000 0000 0000 0000 0000 0111 1111 (0x0000007F)

请记住，这&意味着如果两个输入位均为 1，则结果位仅为 1。

所以我们得到了red = 0x7For red = 127，这正是我们上面所得到的。

编辑：

y为什么他从, then开始遍历图像的像素x，而不是xthen y？当他创建变量时pixel，为什么要乘以y宽度并添加x？不应该只是x * y为了获取像素吗？

让我们使用一个简单的 3x3 图像来演示。在 3x3 图像中，您有 9 个像素，这意味着该pixels数组有 9 个元素。这些元素是按getRGB相对于图像的逐行顺序创建的，因此像素/索引关系如下所示：

0 1 2
3 4 5
6 7 8

这些位置对应于用于获取该像素的索引。因此，为了获得图像的左上角像素(0, 0)，我使用pixel[0]. 为了获得中心像素(1, 1)，我使用pixel[4]. 为了得到中心像素下的像素(1, 2)，我使用pixel[7].

请注意，这会生成图像坐标到索引的 1:1 映射，如下所示：

Coord. -> Index
---------------
(0, 0) -> 0
(1, 0) -> 1
(2, 0) -> 2
(0, 1) -> 3
(1, 1) -> 4
(2, 1) -> 5
(0, 2) -> 6
(1, 2) -> 7
(2, 2) -> 8

坐标是(x, y)对的，所以我们需要找出一种数学方法将 x 和 y 对转换为索引。

我可以学习一些有趣的数学，但为了简单起见，我不会这样做。让我们从您的提案开始，x * y用于获取索引。如果我们这样做，我们会得到：

Coord. -> Index
-------------------
(0, 0) -> 0 * 0 = 0
(1, 0) -> 1 * 0 = 0
(2, 0) -> 2 * 0 = 0
(0, 1) -> 0 * 1 = 0
(1, 1) -> 1 * 1 = 1
(2, 1) -> 2 * 1 = 2
(0, 2) -> 0 * 2 = 0
(1, 2) -> 1 * 2 = 2
(2, 2) -> 2 * 2 = 4

这不是我们上面的映射，所以 usingx * y不起作用。由于我们不能改变getRGB像素的顺序，我们需要它来匹配上面的映射。

让我们试试他的解决方案。他的方程是x = y * w，其中w是宽度，在这种情况下为 3：

Coord. -> Index
-----------------------
(0, 0) -> 0 + 0 * 3 = 0
(1, 0) -> 1 + 0 * 3 = 1
(2, 0) -> 2 + 0 * 3 = 2
(0, 1) -> 0 + 1 * 3 = 3
(1, 1) -> 1 + 1 * 3 = 4
(2, 1) -> 2 + 1 * 3 = 5
(0, 2) -> 0 + 2 * 3 = 6
(1, 2) -> 1 + 2 * 3 = 7
(2, 2) -> 2 + 2 * 3 = 8

看看映射如何与上面的映射对齐？这就是我们想要的。基本上y * w这里所做的是跳过数组中的第一个像素，这与跳过像素行y * w完全相同。y然后通过迭代x，我们正在迭代当前行的每个像素。

如果从上面的解释中不清楚，我们迭代y then x因为像素是按水平 ( ) 顺序逐行添加到数组中的x，所以内部循环应该迭代该x值，这样我们就不会跳来跳去. 如果我们使用相同的y * w + x，那么迭代xtheny将导致迭代进行0, 3, 6, 1, 4, 7, 2, 5, 8, 这是不可取的，因为我们需要以与像素数组相同的顺序将颜色添加到字节缓冲区。

score 0 · Accepted Answer

每个像素由一个 32 位整数表示。该整数的最左边八位是它的 alpha 分量，然后是红色，然后是绿色，最后是蓝色。

(pixel >> 16) & 0xFF将整数向右移动 16 位，因此其中最右边的 8 位现在是红色分量。然后它使用位掩码将所有其他位设置为零，因此您只剩下红色组件。相同的逻辑适用于其他组件。

进一步阅读。

score 0 · Accepted Answer

您所指的奇怪符号是移位运算符，我认为是按位与运算符。

>> n右移 n 位

&& 0xFF意味着你取给定二进制值的最低 8 位

简而言之：for 循环将pixel变量分解为 4 个不同的 8 位部分：最高 8 位是alpha，第二个是red，第三个是green，最后一个是blue

所以这是 32 位的映射：

AAAAAAAARRRRRRRRGGGGGGGGBBBBBBBBB

在哪里：

答：阿尔法
R：红色
G：绿色
B：蓝色

score 0 · Accepted Answer

RGBA 的每个分量（红色、绿色、蓝色、alpha）都有 256 = 2^8（= 1 个字节）不同的值。连接每个组件产生一个 32 位二进制字符串，for 循环将其按字节加载到缓冲区中。

java - 有人可以逐步解释此代码吗？

4 回答 4

Related

Reference