oder [C#]: Fast Gaußian Blur

  • VB.NET

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

    Artentus schrieb:

    @diylab
    Ihr habts mit .Net geschafft, solche Ergebnisse bei 100 Pixel Radius zu erreichen?


    Moin,

    ja - aber nur mit dem STACKBLUR (der Code wurde weiter oben schon einmal gepostet).
    Hier meine Klasse:

    Spoiler anzeigen

    C-Quellcode

    1. using System;
    2. using System.Diagnostics;
    3. using System.Drawing;
    4. using System.Drawing.Imaging;
    5. using System.IO;
    6. using System.Runtime.InteropServices;
    8. namespace BlurTest
    9. {
    10. public class ImageTools
    11. {
    12. /// <summary>
    13. /// Load image without leaving the file locked
    14. /// </summary>
    15. /// <param name="fileName">Source path</param>
    16. /// <returns>Image from stream</returns>
    17. public static Image LoadBitmap(string fileName)
    18. {
    19. using (FileStream stream = new FileStream(fileName, FileMode.Open, FileAccess.Read))
    20. return Image.FromStream(stream);
    21. }
    23. /// <summary>
    24. /// Save blurred bitmap
    25. /// </summary>
    26. /// <param name="SourceImage">Source bitmap</param>
    27. /// <param name="filePath">Target path</param>
    28. public static void SaveBlur(Bitmap SourceImage, string filePath)
    29. {
    30. SourceImage.Save(filePath);
    31. }
    33. /// <summary>
    34. /// Stackblur
    35. /// </summary>
    36. /// <param name="SourceImage">Source bitmap</param>
    37. /// <param name="BlurRadius">Blur radius</param>
    38. public static Bitmap FastBlur(Bitmap SourceImage, int BlurRadius)
    39. {
    40. if (BlurRadius > 0)
    41. {
    42. // Start stopwatch
    43. Stopwatch watch = Stopwatch.StartNew();
    45. var rct = new Rectangle(0, 0, SourceImage.Width, SourceImage.Height);
    46. var dest = new int[rct.Width * rct.Height];
    47. var source = new int[rct.Width * rct.Height];
    48. var bits = SourceImage.LockBits(rct, ImageLockMode.ReadWrite, PixelFormat.Format32bppArgb);
    49. Marshal.Copy(bits.Scan0, source, 0, source.Length);
    50. SourceImage.UnlockBits(bits);
    52. int w = rct.Width;
    53. int h = rct.Height;
    54. int wm = w - 1;
    55. int hm = h - 1;
    56. int wh = w * h;
    57. int div = BlurRadius + BlurRadius + 1;
    58. var r = new int[wh];
    59. var g = new int[wh];
    60. var b = new int[wh];
    61. int rsum, gsum, bsum, x, y, i, p1, p2, yi;
    62. var vmin = new int[max(w, h)];
    63. var vmax = new int[max(w, h)];
    65. var dv = new int[256 * div];
    66. for (i = 0; i < 256 * div; i++)
    67. {
    68. dv[i] = (i / div);
    69. }
    71. int yw = yi = 0;
    73. for (y = 0; y < h; y++)
    74. { // blur horizontal
    75. rsum = gsum = bsum = 0;
    76. for (i = -BlurRadius; i <= BlurRadius; i++)
    77. {
    78. int p = source[yi + min(wm, max(i, 0))];
    79. rsum += (p & 0xff0000) >> 16;
    80. gsum += (p & 0x00ff00) >> 8;
    81. bsum += p & 0x0000ff;
    82. }
    84. for (x = 0; x < w; x++)
    85. {
    87. r[yi] = dv[rsum];
    88. g[yi] = dv[gsum];
    89. b[yi] = dv[bsum];
    91. if (y == 0)
    92. {
    93. vmin[x] = min(x + BlurRadius + 1, wm);
    94. vmax[x] = max(x - BlurRadius, 0);
    95. }
    96. p1 = source[yw + vmin[x]];
    97. p2 = source[yw + vmax[x]];
    99. rsum += ((p1 & 0xff0000) - (p2 & 0xff0000)) >> 16;
    100. gsum += ((p1 & 0x00ff00) - (p2 & 0x00ff00)) >> 8;
    101. bsum += (p1 & 0x0000ff) - (p2 & 0x0000ff);
    102. yi++;
    103. }
    104. yw += w;
    105. }
    107. for (x = 0; x < w; x++)
    108. { // blur vertical
    109. rsum = gsum = bsum = 0;
    110. int yp = -BlurRadius * w;
    111. for (i = -BlurRadius; i <= BlurRadius; i++)
    112. {
    113. yi = max(0, yp) + x;
    114. rsum += r[yi];
    115. gsum += g[yi];
    116. bsum += b[yi];
    117. yp += w;
    118. }
    119. yi = x;
    121. for (y = 0; y < h; y++)
    122. {
    123. dest[yi] = (int)(0xff000000u | (uint)(dv[rsum] << 16) | (uint)(dv[gsum] << 8) | (uint)dv[bsum]);
    124. if (x == 0)
    125. {
    126. vmin[y] = min(y + BlurRadius + 1, hm) * w;
    127. vmax[y] = max(y - BlurRadius, 0) * w;
    128. }
    130. p1 = x + vmin[y];
    131. p2 = x + vmax[y];
    133. rsum += r[p1] - r[p2];
    134. gsum += g[p1] - g[p2];
    135. bsum += b[p1] - b[p2];
    137. yi += w;
    138. }
    139. }
    141. // copy back to image
    142. var bits2 = SourceImage.LockBits(rct, ImageLockMode.ReadWrite, PixelFormat.Format32bppArgb);
    143. Marshal.Copy(dest, 0, bits2.Scan0, dest.Length);
    144. SourceImage.UnlockBits(bits);
    146. // Stop stopwatch
    147. watch.Stop();
    148. Console.WriteLine(watch.ElapsedMilliseconds.ToString() + " ms");
    150. return SourceImage;
    151. }
    152. else
    153. {
    154. return null;
    155. }
    156. }
    158. private static int min(int a, int b) { return Math.Min(a, b); }
    159. private static int max(int a, int b) { return Math.Max(a, b); }
    160. }
    161. }


    Und der Aufruf:
    Spoiler anzeigen

    VB.NET-Quellcode

    1. using System;
    2. using System.Drawing;
    4. namespace BlurTest
    5. {
    6. class Program
    7. {
    8. static void Main(string[] args)
    9. {
    10. using (Bitmap bm = new Bitmap(ImageTools.LoadBitmap(@"F:\BlurTest\2.jpg")))
    11. {
    12. ImageTools.SaveBlur(ImageTools.FastBlur(bm, 130), @"F:\BlurTest\2a.jpg");
    13. }
    15. Console.ReadKey();
    16. }
    17. }
    18. }


    Da komme ich wie gesagt bei 130px Radius auf 3 Sekunden für das erste Bild und 1,7 Sekunden für zweite Bild.
    Ich habe zum Test die Stoppuhr quick and dirty einfach in die Methode geballert.

    Ich bin mir sicher, wenn Du da wieder hand anlegst und das Marshalcopy rausschmeist und die Hauptschleifen für vertikal und horizontal parallelisierst, kommen wir auf min. 1/4 der Gesamtzeit!
    Hat auch beim Sharpen echt Wunder bewirkt (danke nochmals).
    Allein kriege ich das aber nicht hin - da verknoten sich meine Synapsen :rolleyes: ..

    Aber das Resultat bei 130px ist für meine Begriffe prima.

    LG,
    Bruno

    Artentus schrieb:

    Ich hab die FastBlur-Funktion kopiert und einfach statt meiner BoxBlur-Funktion aufgerufen.
    Kannst du mir mal nen Link geben, der erklärt, wie dieser Blur funktioniert? Ich würde das dann parallelisieren und mit Pointern arbeiten.


    Original Urheber: LINK
    C# Implementierung: LINK

    Aber eine richtige Erklärung? Öhhm..
    Hatte sogar mal eine schöne Erklärung in deutsch gefunden - aber nun isse weg.
    Ich weiß nur, das erst vertikal und dann horizontal geblurt wird - das macht wohl den Speed aus.

    Hier noch die Ergebnisse mit 130px:
    Bild 1
    Bild 2

    Mit größerem Radius gehts noch matschiger :D .

    LG,
    Bruno

    Artentus schrieb:

    Jo, ich sitz gerade dran. Die beschreibung bei dem Quellcode ist nicht gerade pralle, aber das wird schon.


    Jo - aber wie Gonger schon sagte - an einen gaußscher Weichzeichner kommt der Stackblur nicht heran - da fehlt noch der Weichspüler im letzten Gang.
    Aber schnell ist der Algo.. hmm.
    Vielleicht gehts ja noch weicher..

    LG,
    Bruno

    NACHTRAG:
    mal ganz quer gedacht - vielleicht einfach eine WPF-Klasse verwenden?
    Da gibts doch einen Haufen Image-Filter..

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

    Bitteschön, das große Bild mit Radius 130 800 Millisekunden: ^^
    Spoiler anzeigen

    C-Quellcode

    1. public static unsafe Bitmap StackBlur(this Bitmap sourceImage, int radius)
    2. {
    3. int width = sourceImage.Width;
    4. int height = sourceImage.Height;
    5. int size = radius << 1;
    7. var destinationImage = new Bitmap(width, height);
    9. var lockRect = new Rectangle(0, 0, width, height);
    10. BitmapData sourceData = sourceImage.LockBits(lockRect, ImageLockMode.ReadOnly, PixelFormat.Format32bppArgb);
    11. BitmapData destinationData = destinationImage.LockBits(lockRect, ImageLockMode.WriteOnly, PixelFormat.Format32bppArgb);
    13. Parallel.For(0, height, (int y) =>
    14. {
    15. byte* sourcePointer = (byte*)sourceData.Scan0 + y * sourceData.Stride;
    16. byte* destinationPointer = (byte*)destinationData.Scan0 + y * destinationData.Stride;
    18. int alpha = 0;
    19. int red = 0;
    20. int green = 0;
    21. int blue = 0;
    23. var colors = new Queue<byte[]>(size);
    24. for (int i = 0; i < Math.Min(radius, width); i++)
    25. {
    26. var color = new byte[4];
    27. color[0] = sourcePointer[3];
    28. color[1] = sourcePointer[2];
    29. color[2] = sourcePointer[1];
    30. color[3] = sourcePointer[0];
    31. colors.Enqueue(color);
    33. alpha += color[0];
    34. red += color[1];
    35. green += color[2];
    36. blue += color[3];
    38. sourcePointer += 4;
    39. }
    41. for (int x = 0; x < width; x++)
    42. {
    43. if (colors.Count == size)
    44. {
    45. byte[] subtract = colors.Dequeue();
    46. alpha -= subtract[0];
    47. red -= subtract[1];
    48. green -= subtract[2];
    49. blue -= subtract[3];
    50. }
    51. if (x + radius < width)
    52. {
    53. var color = new byte[4];
    54. color[0] = sourcePointer[3];
    55. color[1] = sourcePointer[2];
    56. color[2] = sourcePointer[1];
    57. color[3] = sourcePointer[0];
    58. colors.Enqueue(color);
    60. alpha += color[0];
    61. red += color[1];
    62. green += color[2];
    63. blue += color[3];
    65. sourcePointer += 4;
    66. }
    68. destinationPointer[0] = (byte)(blue / colors.Count);
    69. destinationPointer[1] = (byte)(green / colors.Count);
    70. destinationPointer[2] = (byte)(red / colors.Count);
    71. destinationPointer[3] = (byte)(alpha / colors.Count);
    72. destinationPointer += 4;
    73. }
    74. });
    76. Parallel.For(0, width, (int x) =>
    77. {
    78. byte* sourcePointer = (byte*)destinationData.Scan0 + x * 4;
    79. byte* destinationPointer = (byte*)destinationData.Scan0 + x * 4;
    81. int alpha = 0;
    82. int red = 0;
    83. int green = 0;
    84. int blue = 0;
    86. var colors = new Queue<byte[]>(size);
    87. for (int i = 0; i < Math.Min(radius, height); i++)
    88. {
    89. var color = new byte[4];
    90. color[0] = sourcePointer[3];
    91. color[1] = sourcePointer[2];
    92. color[2] = sourcePointer[1];
    93. color[3] = sourcePointer[0];
    94. colors.Enqueue(color);
    96. alpha += color[0];
    97. red += color[1];
    98. green += color[2];
    99. blue += color[3];
    101. sourcePointer += destinationData.Stride;
    102. }
    104. for (int y = 0; y < height; y++)
    105. {
    106. if (colors.Count == size)
    107. {
    108. byte[] subtract = colors.Dequeue();
    109. alpha -= subtract[0];
    110. red -= subtract[1];
    111. green -= subtract[2];
    112. blue -= subtract[3];
    113. }
    114. if (y + radius < height)
    115. {
    116. var color = new byte[4];
    117. color[0] = sourcePointer[3];
    118. color[1] = sourcePointer[2];
    119. color[2] = sourcePointer[1];
    120. color[3] = sourcePointer[0];
    121. colors.Enqueue(color);
    123. alpha += color[0];
    124. red += color[1];
    125. green += color[2];
    126. blue += color[3];
    128. sourcePointer += destinationData.Stride;
    129. }
    131. destinationPointer[0] = (byte)(blue / colors.Count);
    132. destinationPointer[1] = (byte)(green / colors.Count);
    133. destinationPointer[2] = (byte)(red / colors.Count);
    134. destinationPointer[3] = (byte)(alpha / colors.Count);
    135. destinationPointer += destinationData.Stride;
    136. }
    137. });
    139. sourceImage.UnlockBits(sourceData);
    140. destinationImage.UnlockBits(destinationData);
    142. return destinationImage;
    143. }

    Ich hab übrigens nix abgeschrieben, kann also sein, dass der Code nicht 100% das wie der andere macht.

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

    Artentus schrieb:

    Bitteschön, das große Bild mit Radius 130 800 Millisekunden: ^^


    Sch*** die Wand an :D !
    Habe es gerade probiert - dieses Parallelgedöns ist wirklich irre.

    Auch wenn es vielleicht nicht den Vorstellungen des TE entspricht - ich finde es gut und kann es sicher in dieser Form gebrauchen.
    Danke für Deine Mühe!

    LG,
    Bruno

    Parallelisierung ist die Zukunft. ^^ Ist halt n' Unterschied, ob nur 3,4 GHz oder 13,6 GHz arbeiten.
    Ob man da noch mehr rausholen kann, dass man auf die gewünschten 500ms kommt, weiß ich nicht, da kann sich vielleicht jemand äußern, der mehr Verständnis von Speichermanagement hat, als ich.

    @Artentus: Ich bin begeistert!! :thumbsup: :thumbsup:
    Ich habe selbst gestern abend rumgebastelt und habs vermasselt
    Du hast das richtig gut hingekriegt - 800ms sind für mich ok :)

    Du solltest den Codeabschnitt im Tutorial bereich veröffentlichen - weil man da dann noch was über die Schnelligkeit der Parallelisierung lernen kann.

    Vielen Dank an alle und viele Grüße,
    wincrash

    ~closed~
    (\_/) Das ist Hase.
    (O.o) Kopiere Hase in deine Signatur
    (> <) und hilf ihm so auf seinem Weg zur Weltherrschaft.

    Ich kanns in den Sourcecode-Austausch stellen, nen Tutorial ists ja nicht und ich wüsste auch nicht, wie man eins draus machen könnte.
    Allerdings funktioniert der Code wirklich nur in C#, nicht in VB, von daher muss ich entweder warten, bis die Umstrukturierung erfolgt ist oder ich muss es in den Weiteren Programmiersprachen posten.

Facebook