Eigene DrawImage-Funktion mit LockBits zeichnet nicht das, was sie sollte

  • C#
  • .NET (FX) 4.5–4.8

Es gibt 7 Antworten in diesem Thema. Der letzte Beitrag () ist von ichduersie.

    Eigene DrawImage-Funktion mit LockBits zeichnet nicht das, was sie sollte

    Guten Morgen.

    Ich arbeite derzeit an einer eigenen DrawImage-Funktion mit LockBits. Ich erhoffe mir von Ihr einen schnelleren Zeichenvorgang als mit Graphics.DrawImage. Um ein Bild auf ein anderes zu zeichnen übertrage Ich jedes Pixel einzeln, aber das Ergebnis ist irgendwie nicht das, was Ich mir erhofft hatte. Hier ist mal der Quellcode:

    BitmapGraphics (für die Pixeloperationen mit LockBits auf einem Bitmap)
    ​

    C#-Quellcode

    1. ​using System;
    2. using System.Drawing;
    3. using System.Drawing.Imaging;
    4. using System.Runtime.InteropServices;
    6. namespace WindowsFormsApplication1
    7. {
    8. public class BitmapGraphics
    9. {
    10. Bitmap source = null;
    11. IntPtr Iptr = IntPtr.Zero;
    12. BitmapData bitmapData = null;
    14. public byte[] Pixels { get; set; }
    15. public int Depth { get; private set; }
    16. public int Width { get; private set; }
    17. public int Height { get; private set; }
    19. public BitmapGraphics(Bitmap source)
    20. {
    21. this.source = source;
    22. }
    24. /// <summary>
    25. /// Lock bitmap data
    26. /// </summary>
    27. public void LockBits()
    28. {
    29. try
    30. {
    31. // Get width and height of bitmap
    32. Width = source.Width;
    33. Height = source.Height;
    35. // get total locked pixels count
    36. int PixelCount = Width * Height;
    38. // Create rectangle to lock
    39. Rectangle rect = new Rectangle(0, 0, Width, Height);
    41. // get source bitmap pixel format size
    42. Depth = System.Drawing.Bitmap.GetPixelFormatSize(source.PixelFormat);
    44. // Check if bpp (Bits Per Pixel) is 8, 24, or 32
    45. if (Depth != 8 && Depth != 24 && Depth != 32)
    46. {
    47. throw new ArgumentException("Only 8, 24 and 32 bpp images are supported.");
    48. }
    50. // Lock bitmap and return bitmap data
    51. bitmapData = source.LockBits(rect, ImageLockMode.ReadWrite,
    52. source.PixelFormat);
    54. // create byte array to copy pixel values
    55. int step = Depth / 8;
    56. Pixels = new byte[PixelCount * step];
    57. Iptr = bitmapData.Scan0;
    59. // Copy data from pointer to array
    60. Marshal.Copy(Iptr, Pixels, 0, Pixels.Length);
    61. }
    62. catch (Exception ex)
    63. {
    64. throw ex;
    65. }
    66. }
    68. /// <summary>
    69. /// Unlock bitmap data
    70. /// </summary>
    71. public void UnlockBits()
    72. {
    73. try
    74. {
    75. // Copy data from byte array to pointer
    76. Marshal.Copy(Pixels, 0, Iptr, Pixels.Length);
    78. // Unlock bitmap data
    79. source.UnlockBits(bitmapData);
    80. }
    81. catch (Exception ex)
    82. {
    83. throw ex;
    84. }
    85. }
    87. /// <summary>
    88. /// Get the color of the specified pixel
    89. /// </summary>
    90. /// <param name="x"></param>
    91. /// <param name="y"></param>
    92. /// <returns></returns>
    93. public Color GetPixel(int x, int y)
    94. {
    95. Color clr = Color.Empty;
    97. // Get color components count
    98. int cCount = Depth / 8;
    100. // Get start index of the specified pixel
    101. int i = ((y * Width) + x) * cCount;
    103. if (i > Pixels.Length - cCount)
    104. throw new IndexOutOfRangeException();
    106. if (Depth == 32) // For 32 bpp get Red, Green, Blue and Alpha
    107. {
    108. byte b = Pixels[i];
    109. byte g = Pixels[i + 1];
    110. byte r = Pixels[i + 2];
    111. byte a = Pixels[i + 3]; // a
    112. clr = Color.FromArgb(a, r, g, b);
    113. }
    114. if (Depth == 24) // For 24 bpp get Red, Green and Blue
    115. {
    116. byte b = Pixels[i];
    117. byte g = Pixels[i + 1];
    118. byte r = Pixels[i + 2];
    119. clr = Color.FromArgb(r, g, b);
    120. }
    121. if (Depth == 8)
    122. // For 8 bpp get color value (Red, Green and Blue values are the same)
    123. {
    124. byte c = Pixels[i];
    125. clr = Color.FromArgb(c, c, c);
    126. }
    127. return clr;
    128. }
    130. /// <summary>
    131. /// Set the color of the specified pixel
    132. /// </summary>
    133. /// <param name="x"></param>
    134. /// <param name="y"></param>
    135. /// <param name="color"></param>
    136. public void SetPixel(int x, int y, Color color)
    137. {
    138. // Get color components count
    139. int cCount = Depth / 8;
    141. // Get start index of the specified pixel
    142. int i = ((y * Width) + x) * cCount;
    144. if (Depth == 32) // For 32 bpp set Red, Green, Blue and Alpha
    145. {
    146. Pixels[i] = color.B;
    147. Pixels[i + 1] = color.G;
    148. Pixels[i + 2] = color.R;
    149. Pixels[i + 3] = color.A;
    150. }
    151. if (Depth == 24) // For 24 bpp set Red, Green and Blue
    152. {
    153. Pixels[i] = color.B;
    154. Pixels[i + 1] = color.G;
    155. Pixels[i + 2] = color.R;
    156. }
    157. if (Depth == 8)
    158. // For 8 bpp set color value (Red, Green and Blue values are the same)
    159. {
    160. Pixels[i] = color.B;
    161. }
    162. }
    163. }
    164. }
    Code von codeproject.com/Tips/240428/Wo…bitmap-faster-with-Csharp

    Die Anwendung

    C#-Quellcode

    1. ​private void Form1_Load(object sender, EventArgs e)
    2. {
    3. Bitmap bmp = new Bitmap(50, 50);
    4. using (Graphics g = Graphics.FromImage(bmp))
    5. {
    6. g.Clear(Color.Red);
    7. }
    9. Bitmap tzg = new Bitmap(100, 100);
    10. using (Graphics g = Graphics.FromImage(tzg))
    11. {
    12. g.Clear(Color.Black);
    13. }
    15. tzg = DrawImage(bmp, tzg, new Point(10, 10));
    16. pictureBox1.Image = tzg;
    18. }
    20. private Bitmap DrawImage(Bitmap sourceImage, Bitmap destinationImage, Point location)
    21. {
    22. BitmapGraphics bg = new BitmapGraphics(sourceImage);
    23. BitmapGraphics bgx = new BitmapGraphics(destinationImage);
    25. int cx = location.X;
    26. int cy = location.Y;
    28. bg.LockBits();
    29. bgx.LockBits();
    31. //Jedes Pixel auf dem sourceImage durchgehen und auf dem destinationImage an der Position cx, cy zeichnen
    32. for (int x = 0; x < sourceImage.Width; x++)
    33. {
    34. for (int y = 0; y < sourceImage.Height; y++)
    35. {
    36. if (cx >= destinationImage.Width) continue;
    37. if (cy >= destinationImage.Height) continue;
    39. bgx.SetPixel(cx, cy, bg.GetPixel(x, y));
    40. cy++;
    41. }
    42. cx++;
    43. }
    45. bg.UnlockBits();
    46. bgx.UnlockBits();
    48. return destinationImage;
    49. }



    Was eigentlich rauskommen sollte, sieht so aus:


    Was jedoch rauskam sieht so aus:


    Bin schon im Einzelschritt komplett durchgesteppt, aber finde den Fehler nicht. Könnt Ihr mir da bitte helfen?


    LG

    ~ides

    am besten als erstes die TryCatchens raus - was soll denn das: alle Fehler fangen, und dann weiter-werfen?
    Damit du ja nicht die Zeile angezeigt bekommst, wo der Fehler auftritt?

    Mehr kann ich dazu nicht sagen - da bräuchte ich ein Beispiel-projekt, um richtig debuggen zu können.

    Alternativ könntest du dich auch mit meiner PixelHelper-Klasse beschäftigen - die ermöglicht auch direktes Rumwerkeln in den Bitmap-Daten: activevb.de/cgi-bin/tippupload/show/261/Convolution_Filter
    Vorteil wäre, dasses was lauffähiges zum Downloaden ist.

    @ErfinderDesRades: Den oberen Code habe Ich nicht selbst geschrieben. Die Quelle stehe ja auch unten im Spoiler. War aber wohl ein ganz heller am Werk... ;)

    @nafets: Kenne Ich nicht. Werde Ich mir mal anschauen, Danke.

    Melde mich dann wieder.

    Wenns nur ums drawen geht, probier auch Graphics.DrawImageUnscaled(). Das ist zig-fach schneller als das normale .DrawImage. BiBlt ist nochmal 4-fach schneller (wenn ich mich recht erinnere), aber auch nur, wenn mans richtig anfasst, und es ausserdem unmanaged belassen kann (also nicht noch eine Bitmap daraus erzeugen und so Scherze).

    ichduersie schrieb:

    Was eigentlich rauskommen sollte, sieht so aus:
    Du musst cy innerhalb der x-Schleife jedes Mal neu initialisieren:
    Spoiler anzeigen

    C#-Quellcode

    1. private Bitmap DrawImage(Bitmap sourceImage, Bitmap destinationImage, Point location)
    2. {
    3. BitmapGraphics bg = new BitmapGraphics(sourceImage);
    4. BitmapGraphics bgx = new BitmapGraphics(destinationImage);
    6. int cx = location.X;
    7. //int cy = location.Y;
    9. bg.LockBits();
    10. bgx.LockBits();
    12. //Jedes Pixel auf dem sourceImage durchgehen und auf dem destinationImage an der Position cx, cy zeichnen
    13. for (int x = 0; x < sourceImage.Width; x++, cx++)
    14. {
    15. int cy = location.Y; // Dies hier
    16. if (cx >= destinationImage.Width) continue;
    17. for (int y = 0; y < sourceImage.Height; y++, cy++)
    18. {
    19. if (cy >= destinationImage.Height) continue;
    21. bgx.SetPixel(cx, cy, bg.GetPixel(x, y));
    22. }
    23. }
    25. bg.UnlockBits();
    26. bgx.UnlockBits();
    28. return destinationImage;
    29. }

    Falls Du diesen Code kopierst, achte auf die C&P-Bremse.
    Jede einzelne Zeile Deines Programms, die Du nicht explizit getestet hast, ist falsch :!:
    Ein guter .NET-Snippetkonverter (der ist verfügbar).
    Programmierfragen über PN / Konversation werden ignoriert!

    Ja klar. Meine Güte, das kommt bei raus, wenn man 5h lang ohne Pause arbeitet. Macht natürlich Sinn, dass der Y-Wert bei jedem X-Wert wieder zurückgesetzt werden muss. :facepalm:
    Danke @RodFromGermany!

    @ErfinderDesRades: Ich konnte mit ​DrawImageUnscaled keinen Unterschied zum normalen ​DrawImage feststellen.

    Werde das jetzt mal mit LockBits und dem BitBliting probieren. Wir sehen dann ja was raus kommt.

    Vorerst mal Danke für alle Antworten.

    LG

Facebook
Telefonspende