Bitmap Image Repetition with Memory Stream

Question

Bitmap Image Multiplication I Found this Memory stream option to merge the files with given no of repeats. All the things are working file but in the End, the generated BMP file is not as per enter repetition. Need help. Commented lines in code is another way which I tried. enter code here public partial class Form1 : Form { FileStream bitmapfileload; Bitmap bmp; int NoOfRepeats; public Form1() { InitializeComponent(); }

    private void btnOpenFile_Click(object sender, EventArgs e)
    {
        DoubleBuffered = true;
        OpenFileDialog openFileDialog1 = new OpenFileDialog
        {
            InitialDirectory = @"D:\",
            Title = "Browse Design Files",
            CheckFileExists = true,
            CheckPathExists = true,
            DefaultExt = "tif",
            Filter = "Images (*.BMP;*.TIF)|*.BMP;*.TIF|" + "All files (*.*)|*.*",
            FilterIndex = 1,
            RestoreDirectory = true,
            Multiselect = false,
            ReadOnlyChecked = false,
            ShowReadOnly = true
        };

        if (openFileDialog1.ShowDialog() == DialogResult.OK)
        {
            byte[] ba = null;
            foreach (String file in openFileDialog1.FileNames)
            {
                Image temp = new Bitmap(file);
                LblSourceWidth.Text = Convert.ToString(temp.Width);
                LblSourHeight.Text = Convert.ToString(temp.Height);
                temp.Dispose();
                bitmapfileload = new FileStream(file,FileMode.Open,FileAccess.Read,FileShare.ReadWrite);
                ba = streamToByteArray(bitmapfileload);
            }
            NoOfRepeats = int.Parse(ltbRepeat.Text); // Text box will give no of repeat for writing proceedure
            // List <byte[]> ListBa = new List<byte[]>();
            MemoryStream MergeFile = new MemoryStream();
            using (MemoryStream allFrameStream = new MemoryStream())
            {
                for (int i = 0; i < NoOfRepeats; i++)
                {
                    allFrameStream.Write(ba, 0, ba.Length);
                    allFrameStream.Position = ba.Length * i;
                    //ListBa.Add(allFrameStream.ToArray());
                    //ListBa.Add(ba);
                }
                MergeFile = allFrameStream;
                bmp = new Bitmap(MergeFile);
            }
            //byte[] finaleba = Combine(ListBa.ToArray());
            //byte[] finaleba = ListBa.Cast<byte[]>().SelectMany(a => a).ToArray();
            //LblListCount.Text = Convert.ToString(finaleba.Length); // List Count = no of repeats for FOR-LOOP
            //Stream Finalfile = new MemoryStream(MergeFile);
            //richTextBox1.Text = Convert.ToString(Finalfile);
          
           
            LblDestiWidth.Text = Convert.ToString(bmp.Width); // no change here
            LblDestiHeight.Text = Convert.ToString(bmp.Height); // no change here
            pictureBox1.Image = bmp;
            pictureBox1.SizeMode = PictureBoxSizeMode.Zoom;
        }
    }
    private static byte[] Combine(byte[][] arrays)
    {
        byte[] bytes = new byte[arrays.Sum(a => a.Length)];
        int offset = 0;

        foreach (byte[] array in arrays)
        {
            Buffer.BlockCopy(array, 0, bytes, offset, array.Length);
            offset += array.Length;
        }

        return bytes;
    }
    public static byte[] streamToByteArray(Stream input)
    {
        MemoryStream ms = new MemoryStream();
        input.CopyTo(ms);
        return ms.ToArray();
    }

Answer 1

The example is not very obvious. I would assume the end goal is to produce a larger image, with multiple copies of the source image stacked on top of each other.

It looks like you are trying to do this by concatenating the streams for an image. This will not work since images have headers. This will cause only the first image to be decoded.

The correct approach would be to create a new, larger, bitmap, and copy all the pixel-values to this bitmap. For example:

    public static unsafe Bitmap Repeat(Bitmap source, int count)
    {
        var targetHeight = source.Height * count;
        var target = new Bitmap(source.Width, targetHeight, source.PixelFormat);
        var sourceData = source.LockBits(new Rectangle(0,0, source.Width, source.Height), ImageLockMode.ReadOnly, source.PixelFormat);
        var targetData = target.LockBits(new Rectangle(0, 0, target.Width, target.Height), ImageLockMode.ReadOnly,
            target.PixelFormat);
        try
        {
            var frameLength = sourceData.Stride * sourceData.Height;
            for (int i = 0; i < count; i++)
            {
                var targetPtr = targetData.Scan0 + i * frameLength;
                Buffer.MemoryCopy(sourceData.Scan0.ToPointer(), targetPtr.ToPointer(), frameLength * count, frameLength);
            }
        }
        finally
        {
            source.UnlockBits(sourceData);
            target.UnlockBits(targetData);
        }
        return target;
    }

This could be adopted to merge images of different size, but it would require copying the image row by row instead, and some more math regarding height, indices etc. Note that this code is untested, use at own risk.

Another approach would be to use the Graphics api with FromImage and DrawImageUnscaled. This would perhaps be easier if you have multiple images.