Angepinnt [Sammelthread] Knobel-Aufgaben, knifflige Algorithmen, elegante Lösungen

    • VB.NET

    Es gibt 178 Antworten in diesem Thema. Der letzte Beitrag () ist von Thunderbolt.

      Wobei es vollkommen egal ist, ob es eine andere Möglichkeit gibt, denn die Aufgabenstellung ist eindeutig - und genau das ist der Sinn hinter diesen Aufgaben.

      Hier noch eine Variante, die relativ sauber und elegant gelöst ist:
      C#

      C-Quellcode

      1. private struct File
      2. {
      3. FileInfo fileInfo;
      4. string extension, name;
      5. int number;
      6. bool valid;
      7. public FileInfo FileInfo { get { return fileInfo; } }
      8. public string Extension { get { return extension; } }
      9. public string Name { get { return name; } }
      10. public int Number { get { return number; } }
      11. public bool Valid { get { return valid; } }
      13. public File(FileInfo file)
      14. {
      15. fileInfo = file;
      16. extension = file.Extension;
      17. name = file.Name.Replace(extension, "");
      18. valid = int.TryParse(name.Split('_').Last(), out number);
      19. }
      20. }
      22. public static string AppendName(FileInfo sourceFile, DirectoryInfo destFolder)
      23. {
      24. File source = new File(sourceFile);
      25. var allFiles = destFolder.EnumerateFiles();
      26. var customStruct = allFiles.Select(item => new File(item));
      27. var customStructFiltered = customStruct.Where(item => item.Valid);
      28. var customStructOrdered = customStructFiltered.OrderByDescending(item => item.Number);
      29. File lastFile = customStructOrdered.FirstOrDefault();
      30. return Path.Combine(destFolder.FullName, source.Name + "_" + (lastFile.Number + 1).ToString("000")) + source.Extension;
      31. }

      VB

      VB.NET-Quellcode

      1. Private Structure File
      2. Private m_fileInfo As FileInfo
      3. Private m_extension As String, m_name As String
      4. Private m_number As Integer
      5. Private m_valid As Boolean
      6. Public ReadOnly Property FileInfo() As FileInfo
      7. Get
      8. Return m_fileInfo
      9. End Get
      10. End Property
      11. Public ReadOnly Property Extension() As String
      12. Get
      13. Return m_extension
      14. End Get
      15. End Property
      16. Public ReadOnly Property Name() As String
      17. Get
      18. Return m_name
      19. End Get
      20. End Property
      21. Public ReadOnly Property Number() As Integer
      22. Get
      23. Return m_number
      24. End Get
      25. End Property
      26. Public ReadOnly Property Valid() As Boolean
      27. Get
      28. Return m_valid
      29. End Get
      30. End Property
      32. Public Sub New(file__1 As FileInfo)
      33. m_fileInfo = file__1
      34. m_extension = file__1.Extension
      35. m_name = file__1.Name.Replace(m_extension, "")
      36. m_valid = Integer.TryParse(m_name.Split("_"C).Last(), m_number)
      37. End Sub
      38. End Structure
      40. Public Function AppendName(sourceFile As FileInfo, destFolder As DirectoryInfo) As String
      41. Dim source As New File(sourceFile)
      42. Dim allFiles = destFolder.EnumerateFiles()
      43. Dim customStruct = allFiles.[Select](Function(item) New File(item))
      44. Dim customStructFiltered = customStruct.Where(Function(item) item.Valid)
      45. Dim customStructOrdered = customStructFiltered.OrderByDescending(Function(item) item.Number)
      46. Dim lastFile As File = customStructOrdered.FirstOrDefault()
      47. Return Path.Combine(destFolder.FullName, source.Name & "_" & (lastFile.Number + 1).ToString("000")) & source.Extension
      48. End Function

      VB Code nicht getestet, nur durch einen Konverter gejagt, sollte allerdings funktionieren.

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

      Image Convolution

      Hey,
      falls die vorherige Knobelei gelöst wurde, hätt' ich etwas das wohl in knifflige Algorithmen passen würde.
      Es geht darum mithilfe einer 3x3 Matrix ein Image zu verändern. Um so schöne Effekte wie Blur, Pixelation und Co zu bekommen. Hierzu bekommt man nun ein float-Array mit 9 Membern (die Matrix) und die Bitmap. Man hohlt sich die Bits per Bitmap.LockBits() im Format 32bppPARGB und soll sie mit der Matrix multiplizieren. Dieses wird hier sehr schön dargestellt
      Spoiler anzeigen
      . Das wird mit jedem R, G und B Wert gemacht und mit jedem Pixel. Soweit ists also vorgegeben

      C-Quellcode

      1. public unsafe void ProcessImage(float[] matrix3x3, Bitmap bmp)
      2. {
      3. BitmapData data = bmp.LockBits(new Rectangle(0, 0, bmp.Width, bmp.Height), System.Drawing.Imaging.ImageLockMode.ReadWrite, System.Drawing.Imaging.PixelFormat.Format32bppPArgb);
      4. // Bitmap ändern
      5. bmp.UnlockBits(data);
      6. }


      Das eigentliche Problem sind die Ränder und die Ecken, da hier die Pixel erweitern werden sollen
      Spoiler anzeigen

      um auch diese Pixel verarbeiten zu können. Die Möglichkeit die Bitmap um einen Pixel an jedem Rand zu erweitern steht nicht zur Auswahl. Desweiteren gibts kein Linq, es soll möglichst simpel und performant ablaufen. Die Bitmap darf aber gern kopiert werden (oder muss), da die Bitmap nicht geändert werden darf während es noch nicht abgearbeitete Pixel gibt.

      Grüße :thumbup:

      Braucht man garnicht, du nimmst die kopierte Bitmap zum Lesen und die orginale zum Schreiben, so wie im Bild. Klar kann man da schnell ne Klasse drum schreiben (hatte gedacht grade das würde verwirren :rolleyes: ). Die Reihenfolge wäre ganz normal also so
      11 12 13
      21 22 23
      31 32 33

      Wobei im Array dann 11 - 0 wäre, 12 -1, 13- 3, 21 - 4 bis 33 - 8. Die Elemente werden mit den entsprechenden Pixeln (gucke Bild) multipliziert und die Summe bildet den neuen Pixel in der Mitte.

      Es erscheint mir nur sinnvoller, nicht das Ausgangsbild zu verändern. Und mit ner Klasse (bzw. ich würds als Struct designen) wärs schon einfacher.
      Ich mach das einfach mal so und leg dir nen Wrapper drumrum, damit die Anforderungen erfüllt sind aber trotzdem ne ordentliche Variante existiert. ;)

      Die Lösung für die Ränder steht doch in dem Wikipedia Artikel:

      Edge Handling
      Kernel convolution usually requires values from pixels outside of the image boundaries. There are a variety of methods for handling image edges.

      Extend
      The nearest border pixels are conceptually extended as far as necessary to provide values for the convolution. Corner pixels are extended in 90° wedges. Other edge pixels are extended in lines.
      Wrap
      The image is conceptually wrapped (or tiled) and values are taken from the opposite edge or corner.
      Crop
      Any pixel in the output image which would require values from beyond the edge is skipped. This method can result in the output image being slightly smaller, with the edges having been cropped.

      Endlich hab ichs geschafft (Vorsicht, langer Code):
      Spoiler anzeigen

      C-Quellcode

      1. public static class BitmapExtensions
      2. {
      3. /// <summary>
      4. /// Gets the pixel at the specified coordinates for this BitmapData object.
      5. /// </summary>
      6. public static unsafe Color GetPixel(this BitmapData data, int x, int y)
      7. {
      8. byte* dataPointer = (byte*)data.Scan0;
      9. dataPointer += y * data.Stride + x * 4;
      10. return Color.FromArgb(dataPointer[3], dataPointer[2], dataPointer[1], dataPointer[0]);
      11. }
      13. private static int Clamp(int value, int min, int max)
      14. {
      15. if (min > value) return min;
      16. if (max < value) return max;
      17. return value;
      18. }
      20. private static float Clamp(float value, float min, float max)
      21. {
      22. if (min > value) return min;
      23. if (max < value) return max;
      24. return value;
      25. }
      27. /// <summary>
      28. /// Applies a kernel to a bitmap.
      29. /// </summary>
      30. public static unsafe Bitmap Process(this Bitmap sourceImage, ProcessingKernel kernel)
      31. {
      32. int width = sourceImage.Width;
      33. int height = sourceImage.Height;
      35. var destinationImage = new Bitmap(width, height);
      37. var lockRect = new Rectangle(0, 0, width, height);
      38. BitmapData sourceData = sourceImage.LockBits(lockRect, ImageLockMode.ReadOnly, PixelFormat.Format32bppArgb);
      39. BitmapData destinationData = destinationImage.LockBits(lockRect, ImageLockMode.WriteOnly, PixelFormat.Format32bppArgb);
      41. Parallel.For(0, width * height, i =>
      42. {
      43. int x;
      44. int y = Math.DivRem(i, width, out x);
      46. float alpha = 0;
      47. float red = 0;
      48. float green = 0;
      49. float blue = 0;
      50. for (int kernelX = 0, sourceX = x - 1; kernelX < 3; kernelX++, sourceX++)
      51. {
      52. for (int kernelY = 0, sourceY = y - 1; kernelY < 3; kernelY++, sourceY++)
      53. {
      54. Color color = sourceData.GetPixel(Clamp(sourceX, 0, width - 1), Clamp(sourceY, 0, height - 1));
      55. float factor = kernel[kernelY, kernelX];
      56. alpha += (float)color.A / byte.MaxValue * factor;
      57. red += (float)color.R / byte.MaxValue * factor;
      58. green += (float)color.G / byte.MaxValue * factor;
      59. blue += (float)color.B / byte.MaxValue * factor;
      60. }
      61. }
      63. byte* destinationPointer = (byte*)destinationData.Scan0 + i * 4;
      64. destinationPointer[0] = (byte)(Clamp(blue, 0, 1) * byte.MaxValue);
      65. destinationPointer[1] = (byte)(Clamp(green, 0, 1) * byte.MaxValue);
      66. destinationPointer[2] = (byte)(Clamp(red, 0, 1) * byte.MaxValue);
      67. destinationPointer[3] = (byte)(Clamp(alpha, 0, 1) * byte.MaxValue);
      68. });
      70. sourceImage.UnlockBits(sourceData);
      71. destinationImage.UnlockBits(destinationData);
      73. return destinationImage;
      74. }
      75. }
      77. /// <summary>
      78. /// Represents a kernel for image processing.
      79. /// </summary>
      80. public unsafe struct ProcessingKernel : IEnumerable<float>
      81. {
      82. fixed float matrix[9];
      84. /// <summary>
      85. /// A kernel don't applying any changes to the image.
      86. /// </summary>
      87. public static readonly ProcessingKernel Default;
      89. static ProcessingKernel()
      90. {
      91. Default = default(ProcessingKernel);
      92. Default[4] = 1;
      93. }
      95. /// <summary>
      96. /// Gets or sets the value at a specific index.
      97. /// </summary>
      98. public float this[int index]
      99. {
      100. get { fixed (float* matrix = this.matrix) return matrix[index]; }
      101. set { fixed (float* matrix = this.matrix) matrix[index] = value; }
      102. }
      104. /// <summary>
      105. /// Gets or sets the value at a specific row an column.
      106. /// </summary>
      107. public float this[int row, int column]
      108. {
      109. get
      110. {
      111. if (row < 0 || row > 2)
      112. throw new ArgumentOutOfRangeException("row");
      113. if (column < 0 || column > 2)
      114. throw new ArgumentOutOfRangeException("column");
      116. fixed (float* matrix = this.matrix)
      117. return matrix[row * 3 + column];
      118. }
      119. set
      120. {
      121. if (row < 0 || row > 2)
      122. throw new ArgumentOutOfRangeException("row");
      123. if (column < 0 || column > 2)
      124. throw new ArgumentOutOfRangeException("column");
      126. fixed (float* matrix = this.matrix)
      127. matrix[row * 3 + column] = value;
      128. }
      129. }
      131. /// <summary>
      132. /// Creates a new image processing kernel.
      133. /// </summary>
      134. /// <param name="values">A one-dimensional array holding the values for this kernel.</param>
      135. public ProcessingKernel(float[] values)
      136. {
      137. fixed (float* matrix = this.matrix)
      138. Marshal.Copy(values, 0, (IntPtr)matrix, 9);
      139. }
      141. /// <summary>
      142. /// Creates a new image processing kernel.
      143. /// </summary>
      144. /// <param name="values">A two-dimensional array holding the values for this kernel.</param>
      145. public ProcessingKernel(float[,] values)
      146. {
      147. if (values.GetUpperBound(0) < 2 || values.GetUpperBound(1) < 2)
      148. throw new ArgumentException("values");
      150. fixed (float* matrix = this.matrix)
      151. for (int row = 0; row < 3; row++)
      152. for (int column = 0; column < 3; column++)
      153. matrix[row * 3 + column] = values[row, column];
      154. }
      156. public IEnumerator<float> GetEnumerator()
      157. {
      158. var result = new float[9];
      159. fixed (float* matrix = this.matrix) Marshal.Copy((IntPtr)matrix, result, 0, 9);
      160. return result.AsEnumerable().GetEnumerator();
      161. }
      163. System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
      164. {
      165. var result = new float[9];
      166. fixed (float* matrix = this.matrix) Marshal.Copy((IntPtr)matrix, result, 0, 9);
      167. return result.GetEnumerator();
      168. }
      169. }

      @ErfinderDesRades
      Ja, kann ich, aber sei gewarnt, dass ist mein Testprojekt für alles nur erdenklich. :D

      @~blaze~
      Ich fands mit der Color-Strukt halt einfacher, sonst hätte ich vier out-Parameter gebraucht. Es steht dir natürlich frei, das nach deinen Wünschen anzupassen. ;)
      Dateien

      @artentus:

      Ich hab dein Teil nochmal bisserl gehübscht. Und von mir füge ich ein älteres Werk an - mit Dataset natürlich.
      Das ist auf meinem 2-Kernel immer noch ca. 1,5 mal schneller als deine (total interessante :thumbup: ) Parallel.For - Übung.

      Bei meim optimierte ich v.a. 2 Sachen:
      • Randpunkte werden gesondert verarbeitet. Das vereinfacht die Schleife für 99,5% der Pixel erheblich.
      • ich mach nix mit Colors, sondern orgel auf rohen Bytes herum
      Dateien

      So ich hab @Artentus: Code mal überarbeitet und Offset + Faktor hinzugefügt. Hab das ganze Colorzeugg rausgenommn, jetzt ists schon um einiges schneller.
      Dateien

    Facebook