C# 如何逆转这一功能

我以前问过关于按位AND（&）的反义词，你告诉我它是不可能反转的

情况就是这样：服务器发送一个图像，用我想反转的函数进行编码，然后用zlib进行编码

以下是我从服务器获取映像的方式：

        UInt32[] image = new UInt32[200 * 64];
        int imgIndex = 0;
        byte[] imgdata = new byte[compressed];
        byte[] imgdataout = new byte[uncompressed];

        Array.Copy(data, 17, imgdata, 0, compressed);
        imgdataout = zlib.Decompress(imgdata);
        for (int h = 0; h < height; h++)
        {
            for (int w = 0; w < width; w++)
            {
                imgIndex = (int)((height - 1 - h) * width + w);
                image[imgIndex] = 0xFF000000;
                if (((1 << (Int32)(0xFF & (w & 0x80000007))) & imgdataout[((h * width + w) >> 3)]) > 0)
                {
                    image[imgIndex] = 0xFFFFFFFF;
                }
            }
        }

UInt32[]image=newuint32[200*64]；
int imgIndex=0；
字节[]imgdata=新字节[压缩]；
字节[]imgdataout=新字节[未压缩]；
复制（数据，17，imgdata，0，压缩）；
imgdataout=zlib.解压缩（imgdata）；
对于（int h=0；h3）]）>0）
{
图像[imgIndex]=0xFFFFFFFF；
}
}
}

宽度、高度、图像解压缩和图像压缩长度始终相同

完成此函数后，我将图像（UInt32[]数组）放入位图中，就得到了它

现在我想成为服务器并发送图像。我必须做两件事：

反转该函数，然后用zlib压缩它

如何反转该函数以便对图片进行编码

    for (int h = 0; h < height; h++)
    {
        for (int w = 0; w < width; w++)
        {
            imgIndex = (int)((height - 1 - h) * width + w);
            image[imgIndex] = 0xFF000000;
            if (((1 << (Int32)(0xFF & (w & 0x80000007))) & imgdataout[((h * width + w) >> 3)]) > 0)
            {
                image[imgIndex] = 0xFFFFFFFF;
            }
        }
    }

for（int h=0；h3）]）>0）
{
图像[imgIndex]=0xFFFFFFFF；
}
}
}

---

编辑：格式为32bppRGB

假设

&

运算符始终不可逆是不正确的

是的，一般来说，如果你有

c = a & b

你只知道

c

的值，那么你就不知道

a

或

b

之前有什么值了

但是，

&

通常用于从较长的值中提取某些位，这些位以前与

|

运算符组合在一起，并且每个“位字段”彼此独立。使此可逆的通用

&

或

|

运算符的根本区别在于，原始位之前都为零，字中的其他位保持不变。i、 e:

0xc0 | 0x03 = 0xc3   // combine two nybbles

0xc3 & 0xf0 = 0xc0   // extract the top nybble
0xc3 & 0x0f = 0x03   // extract the bottom nybble

在这种情况下，当前函数似乎是提取每像素1位（单色图像）并将其转换为32位RGBA

您将需要以下内容：

int source_image[];
byte dest_image[];

for (int h = 0; h < height; ++h) {
    for (int w = 0; w < width; ++w) {
        int offset = (h * width) + w;
        if (source_image[offset] == 0xffffffff) {
            int mask = w % 8; // these two lines convert from one int-per-pixel
            offset /= 8;      // offset to one-bit-per-pixel
            dest_image[offset] |= (1 << mask); // only changes _one_ bit
        }
    }
}

int-source_-image[]；
字节dest_图像[]；
对于（int h=0；hdest_image[offset]|=（1假设
&
运算符总是不可逆的，这是不正确的

是的，一般来说，如果你有

c = a & b

你只知道
c
的值，那么你就不知道
a
或
b
之前有什么值了

但是，
&
通常用于从较长的值中提取某些位，这些位以前与
|
运算符组合在一起，并且每个“位字段”彼此独立。与通用的
&
或
|
运算符的根本区别在于可逆性是指原始位事先全部为零，字中的其他位保持不变，即：

0xc0 | 0x03 = 0xc3   // combine two nybbles

0xc3 & 0xf0 = 0xc0   // extract the top nybble
0xc3 & 0x0f = 0x03   // extract the bottom nybble

在这种情况下，当前函数似乎是提取每像素1位（单色图像）并将其转换为32位RGBA

您将需要以下内容：

int source_image[];
byte dest_image[];

for (int h = 0; h < height; ++h) {
    for (int w = 0; w < width; ++w) {
        int offset = (h * width) + w;
        if (source_image[offset] == 0xffffffff) {
            int mask = w % 8; // these two lines convert from one int-per-pixel
            offset /= 8;      // offset to one-bit-per-pixel
            dest_image[offset] |= (1 << mask); // only changes _one_ bit
        }
    }
}

int-source_-image[]；
字节dest_图像[]；
对于（int h=0；hdest_image[offset]|=（1“你告诉我它是不可能反转的”…你认为这是某种博格集体吗？：）我仍然不认为你可以反转它。&即使你用一个常数-，它也不能像你说的那样反转。虽然我可能错了，也许测试一个图像[I]==0xFFFFFF意味着它满足了条件，因此您可以从中获取一些信息。该函数将字节[]转换为原始位图数据。仅此而已does@Bobby：不要反抗…抵抗是徒劳的！“你告诉我它不可能逆转”…你认为某种博格集体是这样吗？：）我仍然不认为你可以反转它。&即使你用一个常数-，也不能像你说的那样反转。虽然我可能错了，也许测试一个图像[I]==0xFFFFFF意味着它符合条件，所以你可以从中收集一些东西。该函数转换字节[]到原始位图数据。仅此而已does@Bobby：不要反抗…抵抗是徒劳的！谢谢，这个问题已经解决了。我会使用你的代码，如果遇到问题，我会再问。编辑：宽度是200，高度是64。位图bmp=新位图（200，64，800，PixelFormat.Format32bppRgb，新IntPtr（ptr））；得出了相同的结论是这样的。似乎就是这样。谢谢，这个问题已经过时了。我会使用你的代码，如果遇到问题，我会再问。编辑：宽度是200，高度是64。位图bmp=新位图（200，64，800，PixelFormat.Format32bppRgb，new IntPtr（ptr））；得出了相同的结论是这样的。似乎就是这样。