spieleprogrammierer.de - Forum und Wiki zur Spieleprogrammierung und Spieleentwicklung

C#-Quelltext

((uint*)ptr)[x + y * (stride / 4)] = ((uint*)ptrOriginal)[xO + yO * (strideOriginal / 4)]; //ABGR: alles aufeinmal

C#-Quelltext

 public Bitmap quadDistort(Bitmap disortBitmap, Bitmap background, Vec2[] vectoren)
        {
            //Testen, ob ein Rechteck vorliegt, da diese mit dem BitmapDistortFast Algorithmus nicht gezeichnet werden können
            if (isRectangular(vectoren))
            {
                //Rechtecke können mit den GDI Funktionen gezeichnet werden
                using (Graphics gr = Graphics.FromImage(background))
                {
                    int x = (int)vectoren[0].x;
                    int y = (int)vectoren[0].y;
                    int imageWidth = (int)vectoren[1].x - x;
                    int imageHeight = (int)vectoren[3].y - y;

                    gr.DrawImage(disortBitmap, new Rectangle(x, y, imageWidth, imageHeight));
                }
                return background;
            }

            BitmapData dataNeu = background.LockBits(new Rectangle(0, 0, background.Width, background.Height), ImageLockMode.ReadWrite, PixelFormat.Format32bppArgb);
            int stride = dataNeu.Stride;

            BitmapData dataOriginal = disortBitmap.LockBits(new Rectangle(0, 0, disortBitmap.Width, disortBitmap.Height), ImageLockMode.ReadOnly, PixelFormat.Format32bppArgb);
            int strideOriginal = dataOriginal.Stride;

            int width = background.Width;
            int height = background.Height;

            int widthDistort = disortBitmap.Width;
            int heightDistort = disortBitmap.Height;

            Vec2 a = vectoren[0];
            Vec2 b = vectoren[1];
            Vec2 c = vectoren[2];
            Vec2 d = vectoren[3];

            unsafe
            {
                byte* ptr = (byte*)dataNeu.Scan0;
                byte* ptrOriginal = (byte*)dataOriginal.Scan0;

                //Code für Parallele Ausführung
                CancellationTokenSource cancellationSource = new CancellationTokenSource();
                ParallelOptions options = new ParallelOptions();
                options.CancellationToken = cancellationSource.Token;

                try
                {
                    ParallelLoopResult loopResult = Parallel.For(
                            0,
                            heightDistort,
                            options,
                            (y, loopState) =>
                            {
                                for (int x = 0; x < widthDistort; x++)
                                {

                                    Vec2 vecOriginalBild = invBilinear(new Vec2(x, y), a, b, c, d);
                                    vecOriginalBild.x = vecOriginalBild.x * widthDistort;
                                    vecOriginalBild.y = vecOriginalBild.y * heightDistort;
                                    if (vecOriginalBild.x >= 0 && vecOriginalBild.y >= 0 &&
                                        vecOriginalBild.x < widthDistort && vecOriginalBild.y < heightDistort)
                                    {
                                        int xO = (int)vecOriginalBild.x;
                                        int yO = (int)vecOriginalBild.y;

                                        ((uint*)ptr)[x + y * (stride / 4)] = ((uint*)ptrOriginal)[xO + yO * (strideOriginal / 4)]; //ABGR: alles aufeinmal
                                    }
                                }
                            });
                }
                catch (Exception e)
                {
                }
            }

            background.UnlockBits(dataNeu);
            disortBitmap.UnlockBits(dataOriginal);

            return background;
        }

C#-Quelltext

 byte* ptr = (byte*)dataNeu.Scan0;
 ((uint*)ptr)[x + y * (stride / 4)] = ((uint*)ptrOriginal)[xO + yO * (strideOriginal / 4)];

C#-Quelltext

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

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

C#-Quelltext

((uint*)ptrOriginal)

C#-Quelltext

(uint*)ptrOriginal