public unsafe class FastImage
    {
        private int width;
        public int getWidth() { return width; }

        private int height;
        public int getHeight() { return height; }

        private Bitmap bitmap;
        private BitmapData bitmapData;
        private int stride;
        private byte* ptr;

        public static System.Drawing.Imaging.PixelFormat PIXEL_FORMAT = System.Drawing.Imaging.PixelFormat.Format32bppArgb;

        //Wenn ein neues Image erstellt werden soll
        public FastImage(int width, int height)
        {
            this.width = width;
            this.height = height;

            //Ein neues, leeres Bitmap generieren
            bitmap = new Bitmap(width, height, PIXEL_FORMAT);

            bitmapData = bitmap.LockBits(new Rectangle(0, 0, width, height), ImageLockMode.ReadWrite, PIXEL_FORMAT);
            stride = bitmapData.Stride;
        }

        //Wenn ein vorhandenes Bitmap verwendet werden soll
        public FastImage(Bitmap bitmapNeu)
        {
            width = bitmapNeu.Width;
            height = bitmapNeu.Height;

            //Das bitmapNeu kopieren, damit es das richtige PixelFormat besitzt
            bitmap = new Bitmap(width, height, PIXEL_FORMAT);
            using (Graphics gr = Graphics.FromImage(bitmap))
            {
                gr.DrawImage(bitmapNeu, new Rectangle(0, 0, width, height));
            }

            //Das bitmapNeu kann jetzt freigegeben werden
            bitmapNeu.Dispose();

            bitmapData = bitmap.LockBits(new Rectangle(0, 0, width, height), ImageLockMode.ReadWrite, PIXEL_FORMAT);
            stride = bitmapData.Stride;
            ptr = (byte*)bitmapData.Scan0;
        }

        //Destructor
        ~FastImage()
        {
            bitmap.UnlockBits(bitmapData);
            bitmap.Dispose();
        }

        public uint* getPixelPointer(int x, int y)
        {
            return (uint*)ptr[x + y * (stride / 4)];
        }

        public void setPixelPointer(int x, int y, uint* pointer)
        {
            ptr[x + y * (stride / 4)] = (byte)pointer;
        }

        public void setPixel(int x, int y, Color color)
        {
            ptr[(x * 3) + y * stride] = color.A;
            ptr[(x * 3) + y * stride + 1] = color.B;
            ptr[(x * 3) + y * stride + 2] = color.G;
            ptr[(x * 3) + y * stride + 3] = color.R;
        }

        public Color getPixel(int x, int y)
        {
            Byte a = ptr[(x * 3) + y * stride];
            Byte b = ptr[(x * 3) + y * stride + 1];
            Byte g = ptr[(x * 3) + y * stride + 2];
            Byte r = ptr[(x * 3) + y * stride + 3];

            Color color = Color.FromArgb(a, r, g, b);
            return color;
        }

        public Bitmap getBitmap()
        {
            //Das bitmap vorrübergehend freistellen
            bitmap.UnlockBits(bitmapData);

            Bitmap bitmapNeu = new Bitmap(width, height, PIXEL_FORMAT);
            using (Graphics gr = Graphics.FromImage(bitmapNeu))
            {
                gr.DrawImage(bitmap, new Rectangle(0, 0, width, height));
            }

            //Das bitmap wieder laden
            bitmapData = bitmap.LockBits(new Rectangle(0, 0, width, height), ImageLockMode.ReadWrite, PIXEL_FORMAT);
            ptr = (byte*)bitmapData.Scan0;


            //Das kopierte neue Bitmap kann jetzt zurückgegeben werden
            return bitmapNeu;
        }