Question

我正在创建TCP远程桌面应用程序我想只发送先前发送的帧的差异。

当我比较原始图像和第二个图像时，我放置了在ArrayList中已更改的像素的信息 ArrayList中的五个Item包含一个像素的信息第一个项目包含高度点第二个项目包含宽度点第三个项目包含RGB.red 第四项包含RGB.Green 第五项包含RGB.Blue

这是代码

    private void button1_Click(object sender, EventArgs e)
    {
        ArrayList new_pixel = Unsafe_diff_array(pictureBox2.Image, pictureBox1.Image);

        Bitmap new_bit_map = (Bitmap)pictureBox3.Image;

        for (int i = 0; i < new_pixel.Count; i+=5)
        {
            int x = (int)new_pixel[i +1];
            int y=(int)new_pixel[i];
            int red= Convert.ToInt16(new_pixel[i + 4]) ;
            int green= Convert.ToInt16(new_pixel[i + 3]) ;
            int blue=Convert.ToInt16(new_pixel[i + 2]);
            new_bit_map.SetPixel(x, y, Color.FromArgb(red , green, blue));

        }
        pictureBox3.Image = new_bit_map;

    }







    public ArrayList Unsafe_diff_array(Image OrginalImage, Image SecondImage)
    {
        Bitmap BOrginalImage = new Bitmap(OrginalImage);
        Bitmap BSecondImage = new Bitmap(SecondImage);
        BitmapData bitmapData1 = BOrginalImage.LockBits(new Rectangle(0, 0,
                                                         OrginalImage.Width, OrginalImage.Height),
                                                         ImageLockMode.ReadOnly,
                                                         PixelFormat.Format32bppArgb);
        BitmapData bitmapData2 = BSecondImage.LockBits(new Rectangle(0, 0,
                                                         SecondImage.Width, SecondImage.Height),
                                                         ImageLockMode.ReadOnly,
                                                         PixelFormat.Format32bppArgb);

        ArrayList siblings = new ArrayList();


        unsafe
        {
            byte* imagePointer1 = (byte*)bitmapData1.Scan0;
            byte* imagePointer2 = (byte*)bitmapData2.Scan0;

            for (int i = 0; i < bitmapData1.Height; i++)
            {

                for (int j = 0; j < bitmapData1.Width; j++)
                {
                    // write the logic implementation here

                    if ((imagePointer1[0] != imagePointer2[0]) || (imagePointer1[1] != imagePointer2[1]) || (imagePointer1[2] != imagePointer2[2]))
                    {
                        imagePointer2[0] = imagePointer1[0];
                        imagePointer2[1] = imagePointer1[1];
                        imagePointer2[2] = imagePointer1[2];

                        siblings.Add(i);
                        siblings.Add(j);
                        siblings.Add(imagePointer2[0]);
                        siblings.Add(imagePointer2[1]);
                        siblings.Add(imagePointer2[2]);


                    }

                    imagePointer2[3] = imagePointer1[3];
                    imagePointer1 += 4;
                    imagePointer2 += 4;


                }//end for j
                imagePointer1 += bitmapData1.Stride -
                                 (bitmapData1.Width * 4);
                imagePointer2 += bitmapData1.Stride -
                                                (bitmapData1.Width * 4);
            }//end for i
        }//end unsafe


        BOrginalImage.UnlockBits(bitmapData1);
        BSecondImage.UnlockBits(bitmapData2);

        return siblings ;
      //  return BSecondImage.GetThumbnailImage(SecondImage.Width, SecondImage.Height, null, new IntPtr()); ;
    }

问题是当我将ArrayList序列化为MemoryStream时我发现尺寸大于图像我也尝试将像素的信息改成短阵列，但也发现尺寸比图像大!!!!!？

如何制作此过程以便缩略图尺寸达到尽可能小的尺寸？

我用来序列化ArrayList的代码

private System.IO.MemoryStream SerializeBinary(object obj){
        System.Runtime.Serialization.Formatters.Binary.BinaryFormatter serializer = new System.Runtime.Serialization.Formatters.Binary.BinaryFormatter();

        System.IO.MemoryStream memStrm = new System.IO.MemoryStream();

        serializer.Serialize(memStrm, obj);

        return memStrm; 

    }

Answer 1

当然它会更大！

Bitmap具有内存结构，包括头，像素数据和有时调色板，而ArrayList的二进制格式化器序列化结果具有完全不同的格式，包括程序集元数据，类型metatdata等。

同样遗憾的是，对像素执行不安全编码的所有性能提升都会浪费在使用ArrayList的拳击上。

Answer 2

典型的32位WxH映像使用WxHx4字节的内存（对于1024x1024位图，这是4MB）。

假设您以[x] [y] [颜色]格式发送不同像素的列表，其中包含16位[x]和[y]以及32位[颜色]值，并且存在D不同的像素，差异将使用Dx8字节的内存。因此，如果超过一半的像素不同（D> WxH / 2），则差异将大于图像。

在你的情况下，你正在使用一个数组，这意味着[color]实际上表示为三个[r] [g] [b] 16位值。内存使用量变为Dx10，如果40％像素已更改（D> WxH / 2.5），则可以找到阈值。

考虑使用一点来判断您是发送差异列表还是完整图像，并发送两者中最小的一个。还要考虑RLE编码，使用单个[offset] 16位值而不是[x]和[y]，或者只是将任何未更改的值透明并将结果保存为PNG格式。

当然，运行时插入的任何其他序列化数据以及图像可以压缩的事实（例如PNG是无损的）会加剧这种情况。

两幅图像之间的差异是否大于图像？

2 个答案: