public static partial class MyConverter

    {

        /// <summary>

        /// Create complex image from grayscale bitmap.

        /// </summary>

        /// 

        /// <param name="image">Source grayscale bitmap (8 bpp indexed).</param>

        /// 

        /// <returns>Returns an instance of complex image.</returns>

        /// 

        /// <exception cref="UnsupportedImageFormatException">The source image has incorrect pixel format.</exception>

        /// <exception cref="InvalidImagePropertiesException">Image width and height should be power of 2.</exception>

        /// 

        public static Complex[,] BitmapToComplex2D(Bitmap image)

        {

            // check image format

            if (image.PixelFormat != PixelFormat.Format8bppIndexed)

            {

                throw new Exception("Source image must be grayscale (8bpp indexed) only.");

            }

​

            // lock source bitmap data

            BitmapData imageData = image.LockBits(

                new Rectangle(0, 0, image.Width, image.Height),

                ImageLockMode.ReadOnly, PixelFormat.Format8bppIndexed);

​

            Complex[,] complexImage;

​

            try

            {

                complexImage = FromBitmapData(imageData);

            }

            finally

            {

                // unlock source images

                image.UnlockBits(imageData);

            }

​

            return complexImage;

        }

​

        /// <summary>

        /// Create complex image from grayscale bitmap.

        /// </summary>

        /// 

        /// <param name="bitmapData">Source image data (8 bpp indexed).</param>

        /// 

        /// <returns>Returns an instance of complex image.</returns>

        /// 

        /// <exception cref="UnsupportedImageFormatException">The source image has incorrect pixel format.</exception>

        /// <exception cref="InvalidImagePropertiesException">Image width and height should be power of 2.</exception>

        /// 

        private static Complex[,] FromBitmapData(BitmapData bitmapData)

        {

            // check image format

            if (bitmapData.PixelFormat != PixelFormat.Format8bppIndexed)

            {

                throw new Exception("Source image can be graysclae (8bpp indexed) image only.");

            }

​

            // get source image size

            int width = bitmapData.Width;

            int height = bitmapData.Height;

            int offset = bitmapData.Stride - width;

​

            // check image size

            if ((!Utils.IsPowerOf2(width)) || (!Utils.IsPowerOf2(height)))

            {

                throw new Exception("Image width and height should be power of 2.");

            }

​

            // create new complexImage object

            //ComplexImage temp = new ComplexImage(width, height);

​

            Complex[,] data = new Complex[width, height];

​

            // do the job

            unsafe

            {

                byte* src = (byte*)bitmapData.Scan0.ToPointer();

​

                // for each line

                for (int y = 0; y < height; y++)

                {

                    // for each pixel

                    for (int x = 0; x < width; x++, src++)

                    {

                        data[y, x] = new Complex((float)*src / 255, 

                                                    data[y, x].Imaginary);

                    }

​

                    src += offset;

                }

            }

​

            return data;

        }

​

        /// <summary>

        /// Convert complex image to bitmap.

        /// </summary>

        /// 

        /// <returns>Returns grayscale bitmap.</returns>

        /// 

        public static Bitmap Complex2DToBitmap(Complex[,] twoDimComplexArray, bool fourierTransformed)

        {

            int width = twoDimComplexArray.GetLength(0);

            int height = twoDimComplexArray.GetLength(1);

​

            // create new image

            Bitmap dstImage = Utils.CreateGrayscaleImage(width, height);

​

            // lock destination bitmap data

            BitmapData dstData = dstImage.LockBits(

                new Rectangle(0, 0, width, height),

                ImageLockMode.ReadWrite, PixelFormat.Format8bppIndexed);

​

            int offset = dstData.Stride - width;

            double scale = (fourierTransformed) ? Math.Sqrt(width * height) : 1;

​

            // do the job

            unsafe

            {

                byte* dst = (byte*)dstData.Scan0.ToPointer();

​

                for (int y = 0; y < height; y++)

                {

                    for (int x = 0; x < width; x++, dst++)

                    {

                        *dst = (byte)System.Math.Max(0, System.Math.Min(255, 

                            twoDimComplexArray[y, x].Magnitude * scale * 255));

                    }

                    dst += offset;

                }

            }

            // unlock destination images

            dstImage.UnlockBits(dstData);

​

            return dstImage;

        }

    }