Converting array of int to bitmap

Question

I am trying to convert an array of integers in to a bitmap. I have an array of integers in range [0 - 4095] and I want to display them in to a bitmap, than have the user pick an area in the bitmap make a copy of that area and then get the integers back.

I have code that works for cutting the area of the bitmap, but I am having problems with making the bitmap with values as high as 4095, and getting values back from the bitmap as high as 4095.

public Bitmap InttoBitmap(int[] array)
{
    unsafe
    {
        int[] pixels = new int[array.Length];
        for (int i = 0; i < keepWidth * keepHeight; i++)
        {
            pixels[i] = array[i] * 64;
        }
        IntPtr pixptr = Marshal.AllocHGlobal(keepWidth * keepHeight * 2);
        Marshal.Copy(pixels, 0, pixptr, keepWidth * keepHeight);
        Bitmap bitmap = new Bitmap(keepWidth, keepHeight, 2 * keepWidth, System.Drawing.Imaging.PixelFormat.Format16bppGrayScale, pixptr);

        return bitmap;
    }
}

I get a run time error at:

Marshal.Copy(pixels, 0, pixptr, keepWidth * keepHeight);

it says:

System.AccessViolationException: 'Attempted to read or write protected memory. This is often an indication that other memory is corrupt.'

update:

 double Average_intensity2(Bitmap bmp)
    {

        double[,] image;
        double answer = 0;
        image = imageToByteArray(bmp);
        double l = 0;

        for (int y = 0; y < bmp.Height; y++)
        {
            for (int x = 0; x < bmp.Width; x++)
            {
                answer = answer + image[y,x];

                l++;
            }
        }
        answer = answer / l;
        return answer;
    }

Answer 1

This answer should correct the System.AccessViolationException being thrown.

Marshal.AllocHGlobal takes the size in bytes.

Allocates memory from the unmanaged memory of the process by using the specified number of bytes.

Let's say that keepWidth = 10 and keepHeight = 10.

You would need to allocate enough space for 10 * 10 = 100 32-bit integers, which would be 10 * 10 * 4 = 400 bytes.

But, you're only allocating 10 * 10 * 2 = 200 bytes. Then, you're trying to copy 100 32-bit integers (400 bytes) into that 200 byte space.

This example will go from an int[] where each item in the array represents a single, RGB pixel in a bitmap. Then it will take the Bitmap and go back to an int[] containing the pixel data.

I'm no expert on this, not by a long shot. I used TheCodeKing's answer from this question to figure out how to get the pixel data from the Bitmap (the BitmapToInts function).

using System;
using System.Drawing;
using System.Runtime.InteropServices;

namespace Example
{
   class Program
   {
      static void Main(string[] args)
      {
         IntPtr bitmapData = IntPtr.Zero; //Declaring it here and passing it to IntsToBitmap because it needs to be freed.
         try
         {
            int[] pixels = new int[32 * 32]; //32x32 bitmap.
            for (int i = 0; i < pixels.Length; i++)
            {
               pixels[i] = 4080;
            }
            var bmp = IntsToBitmap(pixels, 32, 32, out bitmapData);
            //bmp.Save("SomefilePath") //If you want to see the bitmap.
            var bmpPixels = BitmapToInts(bmp, 0, 0, 32, 32);
            bmp.Dispose();
         }
         finally
         {
            if (bitmapData != IntPtr.Zero)
            {
               Marshal.FreeHGlobal(bitmapData);
            }
         }
      }

      static int[] BitmapToInts(Bitmap bitmap, int x, int y, int width, int height)
      {
         var bitmapData = bitmap.LockBits(
            new Rectangle(x, y, width, height), 
            System.Drawing.Imaging.ImageLockMode.ReadOnly, 
            bitmap.PixelFormat);
         var lengthInBytes = bitmapData.Stride * bitmapData.Height;

         int[] pixels = new int[lengthInBytes / 4];
         Marshal.Copy(bitmapData.Scan0, pixels, 0, pixels.Length);
         bitmap.UnlockBits(bitmapData);
         return pixels;
      }

      static Bitmap IntsToBitmap(int[] pixels, int width, int height, out IntPtr bitmapData)
      {
         bitmapData = Marshal.AllocHGlobal(width * height * 4);
         Marshal.Copy(pixels, 0, bitmapData, pixels.Length);
         return new Bitmap(width, height, 4 * width, System.Drawing.Imaging.PixelFormat.Format32bppArgb, bitmapData);
      }
   }
}