Image to Binary Image

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

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

    Image to Binary Image

    Im Spoiler die original Frage.
    Spoiler anzeigen

    Hallo Leute,

    ich versuche momentan Bilder in "binär" umzuwandeln.
    Versteht mich hier bitte nicht falsch, aus einem jpeg o. png eine Textdatei zu erstellen die aus 1 und 0 besteht ist kein Problem.

    1 und 0 sind in meinem Fall Bitmaps (8x8 Pixel).
    Bilder im Anhang als bin0.png und bin1.png.
    Ein einzelner Pixel wird also in eine 8x8 große Bitmap übersetzt.

    An und für sich funktioniert das auch... nur ist das Resultat ist schräg und versetzt (siehe Anhänge).
    Ich komme hier momentan nicht weiter. Ich sehe den Wald vor lauter Bäumen nicht...

    Code für das konvertieren von Pixel in 1 und 0 Bitmap
    Spoiler anzeigen

    C#-Quellcode

    1. private static Bitmap CreateBinaryImage(Bitmap zero, Bitmap one, Bitmap source)
    2. {
    3. // store all results and their location here
    4. var imageList = new List<KeyValuePair<Point, Bitmap>>();
    5. // new width and height
    6. int w = source.Width * zero.Width;
    7. int h = source.Height * zero.Height;
    8. // width and height of binary image
    9. int hbin = zero.Height;
    10. int wbin = zero.Width;
    11. // image position indexer
    12. int posX = 0;
    13. int posY = 0;
    15. // bitmap to draw on
    16. var canvas = new Bitmap(w, h, source.PixelFormat);
    17. using (var g = Graphics.FromImage(canvas))
    18. {
    19. // set background
    20. g.FillRectangle(Brushes.Black, 0, 0, canvas.Width, canvas.Height);
    21. unsafe
    22. {
    23. BitmapData lockBits = source.LockBits(
    24. new Rectangle(0, 0, source.Width, source.Height),
    25. ImageLockMode.ReadWrite,
    26. source.PixelFormat);
    28. try
    29. {
    30. // bits per pixel
    31. int bpp = Bitmap.GetPixelFormatSize(source.PixelFormat) / 8;
    32. int hip = lockBits.Height;
    33. int wib = lockBits.Width;
    34. // pointer to first pixel
    35. byte* ptrPx = (byte*)lockBits.Scan0;
    36. // length of stride
    37. int bytes = Math.Abs(lockBits.Stride);
    38. for (int y = 0; y < hip; y++)
    39. {
    40. // get pointer to current scanline
    41. byte* scanLine = ptrPx + (y * lockBits.Stride);
    42. // iterate through pixels
    43. for (int x = 0; x < bytes; x+=bpp)
    44. {
    45. // calculate average to determine wether pixel will be 1 or 0
    46. float avg = ((scanLine[x + 2] & 0xff) / 255f +
    47. (scanLine[x + 1] & 0xff) / 255f +
    48. (scanLine[x] & 0xff) / 255f) / 3;
    49. avg = Math.Min(1f, .35f + .65f * avg);
    51. // set location and bitmap which will later be drawn
    52. imageList.Add(new KeyValuePair<Point, Bitmap>(
    53. new Point(posX, posY),
    54. avg < 0.5f ? one : zero));
    56. // increment or decrement the binary image location variables
    57. posX = posX >= w ? 0 : posX + wbin;
    58. posY = posX >= w ? posY + hbin : posY;
    59. }
    60. }
    62. // draw images on canvas bitmap
    63. for (int i=0; i<imageList.Count; i++) {
    64. g.DrawImage(imageList[i].Value, imageList[i].Key);
    65. }
    67. }
    68. finally
    69. {
    70. // release locked bitmap bits
    71. if (source != null) {
    72. source.UnlockBits(lockBits);
    73. }
    74. }
    75. return canvas;
    76. }
    77. }
    78. }



    Aufruf von CreateBinaryImage:
    Spoiler anzeigen

    C#-Quellcode

    1. static void Main(string[] args)
    2. {
    3. var source = (Bitmap)Load.FromFile(@"C:\Users\...\Pictures\240px-C_Sharp_wordmark.svg.png");
    4. var zero = (Bitmap)Load.FromFile("c:\\users\\...\\desktop\\bin0.jpeg");
    5. var one = (Bitmap)Load.FromFile("c:\\users\\...\\desktop\\bin1.jpeg");
    7. var binaryImage = CreateBinaryImage(zero, one, source);
    8. binaryImage.Save("c:\\users\\...\\desktop\\binaryImage_test.jpeg");
    10. Console.Write("Done... Press any key to exit");
    11. Console.ReadKey();
    12. }


    @RodFromGermany
    @Morrison
    @exc-jdbi
    @Mircosofter2206

    Problem war lediglich die Indizierung der zu setzenden Bilder.

    Weiter unten der neue Code der Funktioniert.
    An alle die vielleicht sagen "Warum nicht einfach GetPixel() und SetPixel() verwenden?": Weil es unfassbar langsam ist!

    ImageData Class:
    Spoiler anzeigen

    C#-Quellcode

    1. using System;
    2. using System.Drawing;
    3. using System.Drawing.Imaging;
    5. namespace ImageConverter
    6. {
    7. public unsafe class ImageData : IDisposable
    8. {
    9. public Bitmap Bitmap { get; }
    10. public BitmapData Bits { get; }
    11. /// <summary>
    12. /// Width in Pixel
    13. /// </summary>
    14. public int Wip { get; }
    15. /// <summary>
    16. /// Height in Pixel
    17. /// </summary>
    18. public int Hip { get; }
    19. /// <summary>
    20. /// Byte per Pixel
    21. /// </summary>
    22. public int Bpp { get; }
    23. /// <summary>
    24. /// Pointer to first pixel of Image
    25. /// </summary>
    26. public unsafe byte* FirstPixel { get; }
    27. /// <summary>
    28. /// Stride of Image
    29. /// </summary>
    30. public int Stride { get; }
    31. /// <summary>
    32. /// Amount of Bytes per Pixel row (Math.Abs(Stride))
    33. /// </summary>
    34. public int Bytes { get; }
    36. public ImageData(Bitmap bitmap, ImageLockMode lockMode)
    37. {
    38. Bitmap = bitmap;
    39. Bits = bitmap.LockBits(
    40. new Rectangle(0, 0, bitmap.Width, bitmap.Height),
    41. lockMode,
    42. bitmap.PixelFormat);
    43. Bpp = Bitmap.GetPixelFormatSize(bitmap.PixelFormat) / 8;
    44. Hip = Bits.Height;
    45. Wip = Bits.Width;
    46. FirstPixel = (byte*)Bits.Scan0;
    47. Stride = Bits.Stride;
    48. Bytes = Math.Abs(Stride);
    49. }
    51. public Color GetPixel(int x, int y)
    52. {
    53. int px = Bpp * x + Stride * y;
    54. if (Bpp % 3 == 0)
    55. {
    56. return Color.FromArgb(
    57. FirstPixel[px + 2],
    58. FirstPixel[px + 1],
    59. FirstPixel[px + 0]);
    60. }
    61. else if (Bpp % 4 == 0)
    62. {
    63. return Color.FromArgb(
    64. FirstPixel[px + 3],
    65. FirstPixel[px + 2],
    66. FirstPixel[px + 1],
    67. FirstPixel[px + 0]);
    68. }
    69. return Color.Empty;
    70. }
    72. public void SetPixel(int x, int y, Color c)
    73. {
    74. int px = Bpp * x + Stride * y;
    75. if (Bpp % 3 == 0)
    76. {
    77. FirstPixel[px + 0] = c.B;
    78. FirstPixel[px + 1] = c.G;
    79. FirstPixel[px + 2] = c.R;
    80. }
    81. else if (Bpp % 4 == 0)
    82. {
    83. FirstPixel[px + 0] = c.B;
    84. FirstPixel[px + 1] = c.G;
    85. FirstPixel[px + 2] = c.R;
    86. FirstPixel[px + 3] = c.A;
    87. }
    88. }
    90. ~ImageData() { Dispose(false); }
    91. public void Dispose() { Dispose(true); }
    92. private void Dispose(bool disposing)
    93. {
    94. if (disposing)
    95. {
    96. GC.SuppressFinalize(this);
    97. }
    98. try { Bitmap.UnlockBits(Bits); }
    99. catch { }
    100. }
    101. }
    102. }




    Test Class mit CreateBinaryImage() Implementation (Methode zum erstellen eines "Binär" Bildes)
    Spoiler anzeigen

    C#-Quellcode

    1. using System;
    2. using System.Collections.Generic;
    4. using System.Drawing;
    5. using System.Drawing.Imaging;
    7. namespace ImageConverter
    8. {
    9. class Program
    10. {
    11. static void Main(string[] args)
    12. {
    13. Bitmap source = (Bitmap)Image.FromFile(@"C:\data\resources\images\image.jpg");
    14. Bitmap zero = (Bitmap)Image.FromFile(@"c:\data\resources\images\bin_0_1024px_w.png");
    15. Bitmap one = (Bitmap)Image.FromFile(@"c:\data\resources\images\bin_1_1024px_w.png");
    17. zero = Resize(zero, 16, 16);
    18. one = Resize(one, 16, 16);
    20. var img = CreateBinaryImage(source, zero, one);
    21. img.Save("C:\\users\\[user]\\desktop\\test.png");
    23. Console.Write("Done... Press any key to exit");
    24. Console.ReadKey();
    25. }
    27. private static Bitmap Resize(Image source, int width, int height)
    28. {
    29. var destRect = new Rectangle(0, 0, width, height);
    30. var destImage = new Bitmap(width, height, source.PixelFormat);
    32. destImage.SetResolution(source.HorizontalResolution, source.VerticalResolution);
    34. using (var g = Graphics.FromImage(destImage))
    35. {
    36. g.CompositingMode = System.Drawing.Drawing2D.CompositingMode.SourceCopy;
    37. g.CompositingQuality = System.Drawing.Drawing2D.CompositingQuality.HighQuality;
    38. g.InterpolationMode = System.Drawing.Drawing2D.InterpolationMode.HighQualityBicubic;
    39. g.SmoothingMode = System.Drawing.Drawing2D.SmoothingMode.HighQuality;
    40. g.PixelOffsetMode = System.Drawing.Drawing2D.PixelOffsetMode.HighQuality;
    42. using (var wrap = new ImageAttributes()) {
    43. wrap.SetWrapMode(System.Drawing.Drawing2D.WrapMode.TileFlipXY);
    44. g.DrawImage(source, destRect, 0, 0, source.Width, source.Height, GraphicsUnit.Pixel, wrap);
    45. }
    46. }
    47. return destImage;
    48. }
    50. private static Bitmap CreateBinaryImage(Bitmap source, Bitmap zero, Bitmap one, float threshold = 0.53f)
    51. {
    52. var canvas = new Bitmap(
    53. source.Width * zero.Width,
    54. source.Height * zero.Height,
    55. PixelFormat.Format24bppRgb);
    57. unsafe
    58. {
    59. var srcData = new ImageData(source, ImageLockMode.ReadOnly);
    60. var zData = new ImageData(zero, ImageLockMode.ReadOnly);
    61. var oData = new ImageData(one, ImageLockMode.ReadOnly);
    62. var cnvData = new ImageData(canvas, ImageLockMode.ReadWrite);
    64. try
    65. {
    66. /* Create lists of color arrays of the replacement images.
    67. ** Use the bpp property for incrementation to step through the individual pixel values.
    68. ** Stores each pixels RGB values as bytes. */
    69. var zPixel = new List<Color[]>();
    70. var oPixel = new List<Color[]>();
    72. for (int y=0; y<zData.Hip; y++)
    73. {
    74. /* Pointer to the desired row of pixels */
    75. byte* zScan = zData.FirstPixel + y * zData.Bytes;
    76. byte* oScan = oData.FirstPixel + y * oData.Bytes;
    78. /* We only want to store the Pixels color which is why we need to devide by Byte per pixel */
    79. Color[] z = new Color[zData.Bytes / zData.Bpp];
    80. Color[] o = new Color[oData.Bytes / oData.Bpp];
    82. int index = 0;
    83. for (int x=0; x<zData.Bytes; x+=zData.Bpp)
    84. {
    85. z[index] = Color.FromArgb(zScan[x + 2], zScan[x + 1], zScan[x + 0]);
    86. o[index] = Color.FromArgb(oScan[x + 2], oScan[x + 1], oScan[x + 0]);
    87. index++;
    88. }
    89. zPixel.Add(z);
    90. oPixel.Add(o);
    91. }
    93. int cx = 0; /* X-position on canvas */
    94. int cy = 0; /* Y-position on canvas */
    95. for (int y0=0; y0<srcData.Hip; y0++)
    96. {
    97. byte* srcScan = srcData.FirstPixel + y0 * srcData.Bytes;
    98. for (int x0=0; x0<srcData.Bytes; x0+=srcData.Bpp)
    99. {
    100. // calculate average to determine if pixel will be 1 or 0
    101. float avg = ((srcScan[x0 + 2] & 0xff) / 255f +
    102. (srcScan[x0 + 1] & 0xff) / 255f +
    103. (srcScan[x0 + 0] & 0xff) / 255f) / 3;
    104. avg = Math.Min(1f, .35f + .65f * avg);
    106. /* Determine which colors/pixels to use to reduce length of code */
    107. List<Color[]> pixels = avg < threshold ? oPixel : zPixel;
    109. /* Calculate start indizes on canvas */
    110. cx = (x0 / srcData.Bpp) * pixels[0].Length;
    111. cy = y0 * pixels.Count;
    112. int y1 = 0;
    113. while (y1 < pixels.Count && cy < canvas.Height)
    114. {
    115. int x1 = 0;
    116. while (x1 + zData.Bpp < pixels[y1].Length && cx < canvas.Width)
    117. {
    118. /* Increment the start indizes of the canvas with the current
    119. ** Pixel position of the replacement image. */
    120. cnvData.SetPixel(cx + x1, cy + y1, pixels[y1][x1]);
    121. x1++;
    122. }
    123. y1++;
    124. }
    125. }
    126. }
    127. }
    128. finally
    129. {
    130. srcData.Dispose();
    131. zData.Dispose();
    132. oData.Dispose();
    133. cnvData.Dispose();
    134. }
    135. return canvas;
    136. }
    137. }
    140. }
    141. }



    Hier ein Code, der das Prinzip des vorherigen Codes, etwas simpler darstellt und für manche evtl etwas einfacher zu verstehen ist:
    Spoiler anzeigen

    C#-Quellcode

    1. using System;
    2. using System.Collections.Generic;
    4. using System.Drawing;
    5. using System.Drawing.Imaging;
    7. namespace ImageConverter
    8. {
    10. class Program
    11. {
    12. static void Main(string[] args)
    13. {
    14. Bitmap source = (Bitmap)Image.FromFile(@"C:\data\resources\images\image.jpg");
    15. Bitmap zero = (Bitmap)Image.FromFile(@"c:\data\resources\images\bin_0_1024px_w.png");
    16. Bitmap one = (Bitmap)Image.FromFile(@"c:\data\resources\images\bin_1_1024px_w.png");
    18. zero = Resize(zero, 16, 16);
    19. one = Resize(one, 16, 16);
    21. var sourceMap = GetBinaryMap(source, .625f);
    22. var testImage = GetParsedMap(sourceMap, zero, one);
    23. testImage.Save("c:\\users\\[user]\\desktop\\test.png");
    25. Console.Write("Done... Press any key to exit");
    26. Console.ReadKey();
    27. }
    29. private static Bitmap Resize(Image source, int width, int height)
    30. {
    31. var destRect = new Rectangle(0, 0, width, height);
    32. var destImage = new Bitmap(width, height, source.PixelFormat);
    34. destImage.SetResolution(source.HorizontalResolution, source.VerticalResolution);
    36. using (var g = Graphics.FromImage(destImage))
    37. {
    38. g.CompositingMode = System.Drawing.Drawing2D.CompositingMode.SourceCopy;
    39. g.CompositingQuality = System.Drawing.Drawing2D.CompositingQuality.HighQuality;
    40. g.InterpolationMode = System.Drawing.Drawing2D.InterpolationMode.HighQualityBicubic;
    41. g.SmoothingMode = System.Drawing.Drawing2D.SmoothingMode.HighQuality;
    42. g.PixelOffsetMode = System.Drawing.Drawing2D.PixelOffsetMode.HighQuality;
    44. using (var wrap = new ImageAttributes())
    45. {
    46. wrap.SetWrapMode(System.Drawing.Drawing2D.WrapMode.TileFlipXY);
    47. g.DrawImage(source, destRect, 0, 0, source.Width, source.Height, GraphicsUnit.Pixel, wrap);
    48. }
    49. }
    50. return destImage;
    51. }
    53. private static Bitmap GetParsedMap(int[,] map, Bitmap z, Bitmap o)
    54. {
    55. var zMap = GetImageMap(z);
    56. var oMap = GetImageMap(o);
    58. Bitmap canvas = new Bitmap(map.GetLength(0) * z.Width, map.GetLength(1) * z.Width);
    59. int cx = 0;
    60. int cy = 0;
    61. for (int y0 = 0; y0 < map.GetLength(0); y0++)
    62. {
    63. for (int x0 = 0; x0 < map.GetLength(1); x0++)
    64. {
    65. List<Color[]> cMap = map[y0, x0] == 0 ? zMap : oMap;
    66. cx = x0 * cMap[0].Length;
    67. cy = y0 * cMap.Count;
    68. int y1 = 0;
    69. while (y1 < cMap.Count && cy < canvas.Height)
    70. {
    71. int x1 = 0;
    72. while (x1 < cMap[y1].Length && cx < canvas.Width)
    73. {
    74. canvas.SetPixel(cx + x1, cy + y1, cMap[y1][x1]);
    75. x1++;
    76. }
    77. y1++;
    78. }
    79. }
    80. }
    81. return canvas;
    82. }
    84. private static List<Color[]> GetImageMap(Bitmap map)
    85. {
    86. var bList = new List<Color[]>();
    87. unsafe
    88. {
    89. BitmapData lockBits = map.LockBits(
    90. new Rectangle(0, 0, map.Width, map.Height),
    91. ImageLockMode.ReadOnly,
    92. map.PixelFormat);
    94. try
    95. {
    96. int bpp = Bitmap.GetPixelFormatSize(map.PixelFormat) / 8;
    97. int hip = lockBits.Height;
    98. int wib = lockBits.Width;
    99. byte* ptrPx = (byte*)lockBits.Scan0;
    100. int bytes = Math.Abs(lockBits.Stride);
    101. for (int y = 0; y < hip; y++)
    102. {
    103. byte* scanLine = ptrPx + y * bytes;
    104. Color[] rowColors = new Color[bytes / bpp];
    105. int index = 0;
    106. for (int x = 0; x < bytes; x += bpp)
    107. {
    108. Color px = Color.FromArgb(
    109. scanLine[x + 2],
    110. scanLine[x + 1],
    111. scanLine[x]);
    112. rowColors[index] = px;
    113. index++;
    114. }
    115. bList.Add(rowColors);
    116. }
    117. return bList;
    118. }
    119. finally
    120. {
    121. map.UnlockBits(lockBits);
    122. }
    123. }
    124. }
    126. private static int[,] GetBinaryMap(Bitmap source, float threshold = 0.53f)
    127. {
    128. int[,] map;
    129. unsafe
    130. {
    131. BitmapData lockBits = source.LockBits(
    132. new Rectangle(0, 0, source.Width, source.Height),
    133. ImageLockMode.ReadWrite,
    134. source.PixelFormat);
    136. try
    137. {
    138. // byte per pixel
    139. int bpp = Bitmap.GetPixelFormatSize(source.PixelFormat) / 8;
    140. int hip = lockBits.Height;
    141. int wib = lockBits.Width;
    142. // pointer to first pixel
    143. byte* ptrPx = (byte*)lockBits.Scan0;
    144. // length of stride
    145. int bytes = Math.Abs(lockBits.Stride);
    146. map = new int[hip + 1, wib + 1];
    147. for (int y = 0; y < hip; y++)
    148. {
    149. int x0 = 0;
    150. // get pointer to current scanline
    151. byte* scanLine = ptrPx + y * bytes;
    152. // iterate through pixels
    153. for (int x = 0; x < bytes; x += bpp)
    154. {
    155. // calculate average to determine wether pixel will be 1 or 0
    156. float avg = ((scanLine[x + 2] & 0xff) / 255f +
    157. (scanLine[x + 1] & 0xff) / 255f +
    158. (scanLine[x] & 0xff) / 255f) / 3;
    159. avg = Math.Min(1f, .35f + .65f * avg);
    160. map[y, x0] = avg < threshold ? 0 : 1;
    161. x0++;
    162. }
    163. }
    165. }
    166. finally
    167. {
    168. // release locked bitmap bits
    169. if (source != null)
    170. {
    171. source.UnlockBits(lockBits);
    172. }
    173. }
    174. return map;
    175. }
    176. }

    Bilder

    • binary_image_warp0.png

      1,03 MB, 1.612×620, 205 mal angesehen

    • bin_0_1024px_w.png

      28,33 kB, 1.024×1.024, 128 mal angesehen

    • bin_1_1024px_w.png

      15,21 kB, 1.024×1.024, 123 mal angesehen

    • image.jpg

      49,28 kB, 970×575, 124 mal angesehen
    Dateien

    • test.png

      (17,31 MB, 231 mal heruntergeladen, zuletzt: )

    Dieser Beitrag wurde bereits 3 mal editiert, zuletzt von „Petersilie“ ()

    Petersilie schrieb:

    schräg und versetzt
    sieht aus, als ob die Zeilenlänge nicht stimmt.
    Mach die mal Mod 4 = 0.
    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!

    @RodFromGermany Hi, Danke für deine Antwort.

    Das ist leider nicht das Problem.
    Das erste Bild hat eine Abmessung von 1920x1080 und das zweite 240x240.
    Beides also ein vielfaches von 4.
    Die Abmessung der Bitmap 'canvas' ist ebenfalls ein vielfaches von 4 da die original Abmessung mit 8 multipliziert wurde.


    Ich glaube es hat etwas mit Graphics.DrawImage() zutun.
    Ändert man die Größe der 8x8 Bitmaps auf 1x1 ab, erhält man eine perfekte schwarz weiß Kopie des Bildes.
    Ändert man den Code um, so dass keine Bitmaps gesetzt werden, sondern einfach nur die einzelnen Pixel in schwarz oder weiß
    abgeändert werden, erhält man ebenfalls eine perfekte schwarz weiß Kopie.

    Dieser Beitrag wurde bereits 3 mal editiert, zuletzt von „Petersilie“ ()

    Morrison schrieb:

    der berücksichtigt werden muss!
    Macht er doch:

    Petersilie schrieb:

    C#-Quellcode

    1. int bpp = Bitmap.GetPixelFormatSize(source.PixelFormat) / 8;
    2. // ...
    3. // iterate through pixels
    4. for (int x = 0; x < bytes; x += bpp) { ... }
    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!

    Guten Morgen

    In Zeilen 57 und 58 ist der Code doch NULL-basieren, aber du gehst bis auf posX >= w.
    Ist das nicht einmal zu viel?

    Zeilen 57 und 58

    C#-Quellcode

    1. posX = posX + wbin >= w ? 0 : posX + wbin;
    2. posY = posX + wbin >= w ? posY + hbin : posY;


    ODER

    so sein lassen und
    zwischen Zeile 58 und 59

    C#-Quellcode

    1. if (posX == w) posX = 0;



    Freundliche Grüsse

    exc-jdbi

    Dieser Beitrag wurde bereits 5 mal editiert, zuletzt von „exc-jdbi“ ()

    @RodFromGermany
    @Morrison
    @exc-jdbi
    @Mircosofter2206

    Hallo Leute,
    erstmal vielen Dank für eure Antworten!

    Da ich momentan mit einem anderen Projekt vollkommen ausgelastet bin und das ganze hier nur ein privates Projekt ist,
    kann ich gerade leider nicht ernsthaft daran weiterarbeiten (besser gesagt fehlt mir gerade die Lust nach 10 bis 12 Stunden noch weiter zu hacken).

    Ich melde mich wenn ich wieder etwas mehr Luft haben!