oder [C#]: Fast Gaußian Blur

  • VB.NET

Es gibt 35 Antworten in diesem Thema. Der letzte Beitrag () ist von Artentus.

    oder [C#]: Fast Gaußian Blur

    Hi Leute,

    Ich suche nach einem Filter für Bitmaps (Source, Binary oder Native mit COM-Aufruf) für einen schnellen Gaußschen Weichzeichner.
    Es ist wichtig, dass dieser Filter Bilder schnell verarbeiten kann, welche größer als 8 Megapixel groß sind.

    Bisher habe ich diverse Codes in .NET und C# probiert - auch mit LockBits und C++-Codes, welche über die GPU laufen....
    Jedoch erziele ich nicht die gewünschten Ergebnisse.

    Kennt jemand vlt. eine gute Library mit API-Aufruf oder Ähnliches? :D

    Vielen Dank und viele Grüße,
    wincrash
    (\_/) Das ist Hase.
    (O.o) Kopiere Hase in deine Signatur
    (> <) und hilf ihm so auf seinem Weg zur Weltherrschaft.

    Wincrash schrieb:

    über die GPU laufen
    Schneller gehts nicht. Eigentlich sollte die Grafikkarte das aber locker über 1000 mal in der Sekunde schaffen, das Problem liegt dann wohl eher im Übergang zischen managed und unamanaged Kontext und in der Bitmap-Klasse.

    Hm....

    was empfiehlst du mir also?
    Soll ich nochmal nach dem C++-Code kramen und den versuchen in meinem Projekt unterzubringen?

    Viele Grüße,
    wincrash
    (\_/) Das ist Hase.
    (O.o) Kopiere Hase in deine Signatur
    (> <) und hilf ihm so auf seinem Weg zur Weltherrschaft.

    Die Ultra-Workaround-Methode mit GDI+:
    Lade ein Bild, verkleinere es und zeichne es anschließend wieder in der originalen Größe. Du musst etwas mit dem Interpolation Mode und dem Skalierungsfaktor rumspielen. Ist wahrscheinlich kein "originaler" Gaußscher Weichzeichner, jedoch ist der Effekt sehr ähnlich und läuft dafür recht fix.


    Hier kannst du eventuell auch noch ein paar Infos rausziehen:
    [VB.NET] [Sammelthread] Knobel-Aufgaben, knifflige Algorithmen, elegante Lösungen (bzw hier)
    Von meinem iPhone gesendet

    @Artentus: Es geht eigentlich darum zwar nichts in Echtzeit zu verarbeiten, jedoch für bestimmte visuelle Effekte ein großes Bild unscharf werden lassen.

    Ich weiß, dass ich nach viel frage, aber der Effekt sollte nicht länger als 500ms brauchen und auch einen Radius von über 100 "blurren" können :)

    @nikeee13: Ich schaus mir mal an

    Vielen Dank und Viele Grüße,
    wincrash
    (\_/) Das ist Hase.
    (O.o) Kopiere Hase in deine Signatur
    (> <) und hilf ihm so auf seinem Weg zur Weltherrschaft.

    @nikeee13: Vielen Dank für deinen Link, aber dieser hat mir (jetzt zumindest) nicht direkt geholfen.
    Ich habe die Methode getestet, welche du mir empfohlen hast, jedoch ist mein Ergebnis nicht glatt verwischt (ich glaube, du weißt, was ich meine :D )

    Viele Grüße,
    wincrash
    (\_/) Das ist Hase.
    (O.o) Kopiere Hase in deine Signatur
    (> <) und hilf ihm so auf seinem Weg zur Weltherrschaft.

    Ich denke, dass ein Gaußscher Weichzeichner bis zu 100 so gut wie unmöglich ist. Wenn es aber um das unscharf werden lassen geht (Animation?), dann fällt mir ein möglicher Trick ein: Du erhöhst immer wieder den Radius um 1, wobei du das bisherige Ergebnis und die neu dazugekommenen Pixel wieder von neu verrechnest. Dadurch müsstest du jedes Mal nur nen kleinen Teil neu berechnen. Du musst aber dann wissen, bis wie viel du gehen willst (Radius), damit du berechnen kannst, wie stark der nächste Pixel mit einbezogen werden soll.

    Wincrash schrieb:

    Es ist wichtig, dass dieser Filter Bilder schnell verarbeiten kann, welche größer als 8 Megapixel groß sind.

    Hi,

    ich spiele gerade ein bisschen an Deinem Problem herum, weil es mich auch interessiert.
    Sehr schön wäre es, wenn Du uns einen typischen Vertreter dieser Bilder zur Verfügung stellen könntest!?

    LG,
    Bruno

    @diylab: hier ist so ein Bild oder dieses Bild :D


    @Gonger96: Hm ... bei Matrizen liegt nicht direkt meine stärke^^ - Hättest du da vlt. Tutorials oder Ähnliches, welche in die Richtung gehen? :D
    @nafets3646: Ist zwar eine gute Idee, aber leider zu langsam für meine Zwecke:/

    Viele Grüße,
    wincrash
    (\_/) Das ist Hase.
    (O.o) Kopiere Hase in deine Signatur
    (> <) und hilf ihm so auf seinem Weg zur Weltherrschaft.

    Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von „Wincrash“ ()

    @diylab: Naah - das ist nicht schlimm, wenn du's nicht schaffst :)
    Ich habe auch ewig lang rumprobiert - und es waren bei mir nie unter 4 Sekunden :P
    Dann hab' ich im Internet rumgesucht, bin aber wahnsinnig geworden, weil ich nie das richtige gefunden habe....

    Mach dir deswegen bloß keinen Stress,
    Vielen Dank, viele liebe Grüße und einen guten Abend noch,
    wincrash
    (\_/) Das ist Hase.
    (O.o) Kopiere Hase in deine Signatur
    (> <) und hilf ihm so auf seinem Weg zur Weltherrschaft.

    ~push~

    @diylab: sry dass ich drängle, aber hast du inzwischen einige (bessere) Ergebnisse erzielen können? :D

    Vielen Dank und viele Grüße,
    wincrash
    (\_/) Das ist Hase.
    (O.o) Kopiere Hase in deine Signatur
    (> <) und hilf ihm so auf seinem Weg zur Weltherrschaft.

    @Artentus: Ich bin zwar kein Fan von BoxBlur - im schlimmsten Falle ist das aber auch ok ^^
    @J-F: Das schaue ich mir mal an - ich sage dir auf jeden Fall mal später bescheid, inwieweit mir dein Link geholfen hat :D
    @Gonger96: Vielen Dank - ich werde mich mal damit auseinander setzen (auf den ersten Blick sieht das BoxBlur-Ähnlich aus:) )

    Edit:
    Ich habe mir den Link von J-F angeschaut und den Code auch in C# gefunden:
    Spoiler anzeigen

    C#-Quellcode

    1. public static Bitmap FastBlur(Bitmap SourceImage, int radius)
    2. {
    3. var rct = new Rectangle(0, 0, SourceImage.Width, SourceImage.Height);
    4. var dest = new int[rct.Width * rct.Height];
    5. var source = new int[rct.Width * rct.Height];
    6. var bits = SourceImage.LockBits(rct, ImageLockMode.ReadWrite, PixelFormat.Format32bppArgb);
    8. Marshal.Copy(bits.Scan0, source, 0, source.Length);
    10. SourceImage.UnlockBits(bits);
    12. if (radius < 1) return SourceImage;
    14. int w = rct.Width;
    15. int h = rct.Height;
    16. int wm = w - 1;
    17. int hm = h - 1;
    18. int wh = w * h;
    19. int div = radius + radius + 1;
    21. var r = new int[wh];
    22. var g = new int[wh];
    23. var b = new int[wh];
    25. int rsum, gsum, bsum, x, y, i, p1, p2, yi;
    27. var vmin = new int[max(w, h)];
    28. var vmax = new int[max(w, h)];
    30. var dv = new int[256 * div];
    32. for (i = 0; i < 256 * div; i++)
    33. {
    34. dv[i] = (i / div);
    35. }
    37. int yw = yi = 0;
    39. for (y = 0; y < h; y++)
    40. { // blur horizontal
    41. rsum = gsum = bsum = 0;
    43. for (i = -radius; i <= radius; i++)
    44. {
    45. int p = source[yi + min(wm, max(i, 0))];
    47. rsum += (p & 0xff0000) >> 16;
    48. gsum += (p & 0x00ff00) >> 8;
    49. bsum += p & 0x0000ff;
    50. }
    52. for (x = 0; x < w; x++)
    53. {
    55. r[yi] = dv[rsum];
    56. g[yi] = dv[gsum];
    57. b[yi] = dv[bsum];
    59. if (y == 0)
    60. {
    61. vmin[x] = min(x + radius + 1, wm);
    62. vmax[x] = max(x - radius, 0);
    63. }
    65. p1 = source[yw + vmin[x]];
    66. p2 = source[yw + vmax[x]];
    68. rsum += ((p1 & 0xff0000) - (p2 & 0xff0000)) >> 16;
    69. gsum += ((p1 & 0x00ff00) - (p2 & 0x00ff00)) >> 8;
    70. bsum += (p1 & 0x0000ff) - (p2 & 0x0000ff);
    72. yi++;
    73. }
    75. yw += w;
    76. }
    78. for (x = 0; x < w; x++)
    79. { // blur vertical
    80. rsum = gsum = bsum = 0;
    82. int yp = -radius * w;
    84. for (i = -radius; i <= radius; i++)
    85. {
    86. yi = max(0, yp) + x;
    88. rsum += r[yi];
    89. gsum += g[yi];
    90. bsum += b[yi];
    92. yp += w;
    93. }
    95. yi = x;
    97. for (y = 0; y < h; y++)
    98. {
    99. dest[yi] = (int)(0xff000000u | (uint)(dv[rsum] << 16) | (uint)(dv[gsum] << 8) | (uint)dv[bsum]);
    101. if (x == 0)
    102. {
    103. vmin[y] = min(y + radius + 1, hm) * w;
    104. vmax[y] = max(y - radius, 0) * w;
    105. }
    107. p1 = x + vmin[y];
    108. p2 = x + vmax[y];
    110. rsum += r[p1] - r[p2];
    111. gsum += g[p1] - g[p2];
    112. bsum += b[p1] - b[p2];
    114. yi += w;
    115. }
    116. }
    118. var bits2 = SourceImage.LockBits(rct, ImageLockMode.ReadWrite, PixelFormat.Format32bppArgb);
    120. Marshal.Copy(dest, 0, bits2.Scan0, dest.Length);
    122. SourceImage.UnlockBits(bits);
    124. return SourceImage;
    125. }
    127. private static int min(int a, int b) { return Math.Min(a, b); }
    128. private static int max(int a, int b) { return Math.Max(a, b); }

    Das Problem ist nur, dass das Bild nicht geblurred wird .... Ich geh' mal auf Fehlersuche ^^

    Vielen Dank und viele Grüße,
    wincrash
    (\_/) Das ist Hase.
    (O.o) Kopiere Hase in deine Signatur
    (> <) und hilf ihm so auf seinem Weg zur Weltherrschaft.

    Dieser Beitrag wurde bereits 2 mal editiert, zuletzt von „Wincrash“ ()

    @diylab
    @Wincrash
    Ihr habts mit .Net geschafft, solche Ergebnisse bei 100 Pixel Radius zu erreichen?
    Also ich habs mit Parallel.For und LockBits mal probiert und das dauert Minuten (und das nur für nen BoxBlur). Oo

    Spoiler anzeigen
    public static unsafe Bitmap ApplyBoxBlur(this Bitmap sourceImage, int radius)
    {
    int width = sourceImage.Width;
    int height = sourceImage.Height;

    var destinationImage = new Bitmap(width, height);

    var lockRect = new Rectangle(0, 0, width, height);
    BitmapData sourceData = sourceImage.LockBits(lockRect, ImageLockMode.ReadOnly, PixelFormat.Format32bppArgb);
    BitmapData destinationData = destinationImage.LockBits(lockRect, ImageLockMode.WriteOnly, PixelFormat.Format32bppArgb);

    Parallel.For(0, width * height, (int index) =>
    {
    int x;
    int y = Math.DivRem(index, width, out x);

    int alpha = 0;
    int red = 0;
    int green = 0;
    int blue = 0;

    int fromY = Math.Max(y - radius, 0);
    int toY = Math.Min(y + radius, height - 1);
    int fromX = Math.Max(x - radius, 0);
    int toX = Math.Min(x + radius, width - 1);
    for (int sourceY = fromY; sourceY < toY; sourceY++)
    {
    byte* color = (byte*)sourceData.Scan0 + sourceY * sourceData.Stride + fromX * 4;

    for (int sourceX = fromX; sourceX < toX; sourceX++)
    {
    alpha += color[3];
    red += color[2];
    green += color[1];
    blue += color[0];

    color += 4;
    }
    }

    int pixelCount = (toY - fromY) * (toX - fromX);
    blue /= pixelCount;
    green /= pixelCount;
    red /= pixelCount;
    alpha /= pixelCount;

    byte* destinationPointer = (byte*)destinationData.Scan0 + index * 4;
    destinationPointer[0] = (byte)blue;
    destinationPointer[1] = (byte)green;
    destinationPointer[2] = (byte)red;
    destinationPointer[3] = (byte)alpha;
    });

    sourceImage.UnlockBits(sourceData);
    destinationImage.UnlockBits(destinationData);

    return destinationImage;
    }

Facebook