convert image 8bpp indexed into array..

public static void convertRgbImageToArray(Bitmap bm, out double[,] r, out double[,] g, out double[,] b) 
        { 
            // make an array that would be refeneccing into the function
            r = new double[bm.Width, bm.Height];
            g = new double[bm.Width, bm.Height];
            b = new double[bm.Width, bm.Height];

            // threshold for image that has a 24bppRGB
            
            // Copy RGB value from the image
            Rectangle rect = new Rectangle(0,0,bm.Width,bm.Height);
            BitmapData bmd = bm.LockBits(
                                         rect,
                                         ImageLockMode.ReadOnly,
                                         bm.PixelFormat
                                         );
            int bytes = bmd.Stride * bmd.Height; 
            byte[] bgrVal = new byte[bytes];
            IntPtr ptr = bmd.Scan0;
            System.Runtime.InteropServices.Marshal.Copy(ptr, bgrVal, 0, bytes); // Copy data value RGB from pointer ptr into array bgrVal
            bm.UnlockBits(bmd);

            // devide array value into RGB colour (Red, Green, Blue).
            for (int x = 0; x < bm.Width; x++)
            {
                for (int y = 0; y < bm.Height; y++)
                {
                    int m = x * 3 + y * bmd.Stride;
                    b[x,y] = (bgrVal[m]);
                    g[x, y] = (bgrVal[m + 1]);
                    r[x, y] = (bgrVal[m + 2]);
                }
            }

            return;
        }

public static Bitmap convertRgbArrayToImage(double[,]r,double[,]g, double[,]b)
        {
            // make image.
            Bitmap bm = new Bitmap(b.GetLength(0), b.GetLength(1), PixelFormat.Format24bppRgb);

            // make byte array that use for the image
            // Copy RGB value from image.
            Rectangle rect = new Rectangle(0, 0, bm.Width, bm.Height);
            BitmapData bmd = bm.LockBits(
                                         rect,
                                         ImageLockMode.ReadOnly,
                                         bm.PixelFormat
                                         );

            int bytes = bmd.Stride * bmd.Height;
            byte[] bgrVal = new byte[bytes];

            // Copy pixel value into byte array
            for (int x = 0; x < bm.Width; x++)
            {
                for (int y = 0; y < bm.Height; y++)
                {
                    int m = x * 3 + y * bmd.Stride;
                    double bb = (b[x, y]);
                    if (bb < 0) bb = 0;
                    if (bb > 255) bb = 255;
                    bgrVal[m] = (byte)bb;

                    double gg = (g[x, y]);
                    if (gg < 0) gg = 0;
                    if (gg > 255) gg = 255;
                    bgrVal[m + 1] = (byte)gg;

                    double rr = (r[x, y]);
                    if (rr < 0) rr = 0;
                    if (rr > 255) rr = 255;
                    bgrVal[m + 2] = (byte)rr;
                }
            }
            IntPtr ptr=bmd.Scan0;
            System.Runtime.InteropServices.Marshal.Copy(bgrVal, 0, ptr, bytes); // Copy array RGB value into pointer.
            bm.UnlockBits(bmd);
            return bm;
        }