Kann man einen GraphicsPath anklicken, um fehlerhafte Linien zu entfernen?

  • VB.NET
  • .NET (FX) 4.5–4.8

Es gibt 30 Antworten in diesem Thema. Der letzte Beitrag () ist von Bartosz.

    @RodFromGermany
    Wenn Du die Länge einer Diagonale berechnest, solltest Du die Komponenten unter der Wurzel nicht vorher auf Short casten.

    Habe ich auch schon gesehen, danke dir trotzdem ! Ich hatte das erst gemacht, weil doch tatsächlich f(y + 1, x)) - f(y - 1, x) einen Überlauf verursacht hat – der hintere war größer als der vordere, sodass etwas Negatives herauskommt, was in Byte nicht geht. Jetzt ist eh alles in Double. (und asynchron und heller)

    VB.NET-Quellcode

    1. Private Async Sub Button_Kantenerkennung_professionell_Click(sender As Object, e As EventArgs) Handles Button_Kantenerkennung_professionell.Click
    2. Await Task.Run(Sub() Kantenerkennung_professionell())
    3. End Sub
    5. Private Sub Kantenerkennung_professionell()
    6. 'Das Originalbild wird in ein Graustufenbild umgewandelt. Ich nutze die Emgu.CV-Sachen, da ich das am einfachsten finde und ich dann keine selbstgeschriebenen Matrizen hernehmen muss.
    8. Using bgr_img As Emgu.CV.Image(Of Emgu.CV.Structure.Bgr, Byte) = Picture1.ToImage(Of Emgu.CV.Structure.Bgr, Byte)
    9. Using imgGray As Emgu.CV.Image(Of Emgu.CV.Structure.Gray, Byte) = bgr_img.Convert(Of Emgu.CV.Structure.Gray, Byte)()
    11. If PictureBox1.Image IsNot Nothing Then
    12. Me.Invoke(Sub() PictureBox1.Image = Nothing)
    13. End If
    14. Me.Invoke(Sub() PictureBox1.Image = imgGray.ToBitmap())
    16. 'in ein 2D-Array kopieren
    18. Dim f(imgGray.Height - 1, imgGray.Width - 1) As Byte
    20. For y As Integer = 0 To imgGray.Height - 1 Step 1
    21. For x As Integer = 0 To imgGray.Width - 1 Step 1
    22. f(y, x) = imgGray.Data(y, x, 0)
    23. Next
    24. Next
    25. 'Höhe an der Stelle x, y soll der Farbwert an der Stelle x, y sein.
    26. 'Es erstreckt sich ein Gebirge zwischen 0 und 255.
    27. 'Das Graustufenbild wird also dreidimensional.
    28. '„Kanten“ sind die Übergänge – Stellen, an denen der Anstieg möglichst groß ist.
    29. 'Es wird nun der Gradient berechnet:
    31. 'Dim Gradient_x(imgGray.Data.Length - 1) As Double
    32. 'Dim Gradient_y(imgGray.Data.Length - 1) As Double
    33. Dim Betrag_des_Gradienten(imgGray.Data.Length - 1) As Double
    34. Dim i As Integer = 0
    36. For y As Integer = 1 To imgGray.Height - 2 Step 1
    37. For x As Integer = 1 To imgGray.Width - 2 Step 1
    38. 'Gradient_x(i) = (CDbl(f(y, x + 1)) - CDbl(f(y, x - 1))) / 2.0
    39. 'Gradient_y(i) = (CDbl(f(y + 1, x)) - CDbl(f(y - 1, x))) / 2.0
    40. 'Pythagoras
    41. Betrag_des_Gradienten(i) = Math.Sqrt(Math.Pow((CDbl(f(y, x + 1)) - CDbl(f(y, x - 1))) / 2.0, 2) + Math.Pow((CDbl(f(y + 1, x)) - CDbl(f(y - 1, x))) / 2.0, 2))
    42. i += 1
    43. Next
    44. Next
    45. i = 0
    47. Dim Kantenbild As New Bitmap(imgGray.Width, imgGray.Height, Imaging.PixelFormat.Format32bppArgb)
    48. Dim _Graphics As Graphics = Graphics.FromImage(Kantenbild)
    49. Dim Max As Double = 0.0
    50. For a As Integer = 0 To Betrag_des_Gradienten.Length - 1 Step 1 'maximalen Wert aller Werte finden.
    51. If Betrag_des_Gradienten(a) > Max Then
    52. Max = Betrag_des_Gradienten(a)
    53. End If
    54. Next
    56. Dim Faktor As Double = 255.0 / Max
    58. For y As Integer = 0 To imgGray.Height - 2 Step 1
    59. For x As Integer = 1 To imgGray.Width - 2 Step 1
    60. Kantenbild.SetPixel(x, y, Color.FromArgb(CInt(Math.Round(Betrag_des_Gradienten(i) * Faktor, 0)), CInt(Math.Round(Betrag_des_Gradienten(i) * Faktor, 0)), CInt(Math.Round(Betrag_des_Gradienten(i) * Faktor, 0))))
    61. i += 1
    62. Next
    63. Next
    65. Me.Invoke(Sub() PictureBox1.Image = Kantenbild)
    66. Kantenbild0 = Kantenbild
    67. End Using
    68. End Using
    69. End Sub

    Grundsätzlich kannst du diese Operationen ganzzahlig ausführen. Ist meines Erachtens nicht so gut zwischen double und int hin -und her zu casten. Du kannst statt pow(x, 2), einfach x * x schreiben (und nicht wie ich erwähnt hatte << 1, das wäre tatsächlich * 2), Wurzel brauchst du da sowieso nicht, weil die Wurzelfunktion stetig im Definitionsbereich ist und damit Ordnungen beibehält, dass heißt wenn x^2 kleiner ist als y^2, dann ist betragsmäßig x auch kleiner als y. Dein Kantenbild wird sich also nicht verändern, du brauchst nur halt einen zusätzlichen Proportionalitätsfaktor um den Wert in einen gewünschten Bereich zu drücken - oder du arbeitest von vornherein mit Farbwerten die jeweils zwischen 0 und 1 liegen - aber ob diese ganzen Optimierungen jetzt was grundlegend ändert.. wenn's funktioniert ist es erstmal ja gut.
    Und Gott alleine weiß alles am allerbesten und besser.

    Ich muss mich nochmal an euch wenden. Ich möchte, wie in Post1 beschrieben, einen Bereich auswählen; und die Erkennung soll in dem Rechteck suchen und einen Körper umranden. Aufgrund der Kantenerkennung funktioniert das besser, aber nicht 100%ig perfekt. Ich habe mir 2 Hilfen eingebaut. Einmal eine Schwarzweißschwelle („Wie starkes Weiß (0 bis 255) muss ich sehen?“), und eine Einstellung, wie lang eine Strecke zwischen 2 Punkten maximal sein darf. Je nach Foto sind natürlich die Einstellungen leicht verschieden. Man kann jedoch immer sagen: Zu streng ist Mist, zu locker ist Mist. Irgendwo dazwischen ist das Optimum, jedoch muss das Wort Optimum nicht ‘gut’ heißen. Das Ergebnis-Bild ist im Anhang.

    Was kann man noch machen? Am liebsten wäre mir, und daher der Titelname, dass ich den GraphicsPath manuell korrigieren kann. Aber ich finde nichts Gescheites bei sta**********. Ich habe bisher nur gefunden, wie man komplett selbst zeichnet und dann habe ich dort einen Löschvorgang eingebaut. Das habe ich mal hochgeladen. Allerdings bekomme ich es nicht hin, beides zu tun. Any help is appreciated
    Spoiler anzeigen

    C#-Quellcode

    1. using System;
    2. using System.Collections.Generic;
    3. using System.ComponentModel;
    4. using System.Data;
    5. using System.Drawing;
    6. using System.Drawing.Drawing2D;
    7. using System.Linq;
    8. using System.Text;
    9. using System.Threading.Tasks;
    10. using System.Windows.Forms;
    12. namespace selbst_zeichnen
    13. {
    14. public partial class Form1 : Form
    15. {
    16. private GraphicsPath _drawingPath = new GraphicsPath();
    17. private Point lastMouseLocation;
    18. private bool drawing = false;
    19. public Form1()
    20. {
    21. InitializeComponent();
    22. }
    24. private void Form1_Load(object sender, EventArgs e)
    25. {
    26. }
    28. private void Form1_MouseDown(object sender, MouseEventArgs e)
    29. {
    30. if (e.Button == MouseButtons.Right)
    31. {
    32. _drawingPath = new GraphicsPath();
    33. Invalidate();
    34. }
    35. }
    37. private void Form1_MouseMove(object sender, MouseEventArgs e)
    38. {
    39. if (e.Button == MouseButtons.Left)
    40. {
    41. drawing = true;
    42. _drawingPath.AddLine(lastMouseLocation, e.Location);
    43. Invalidate();
    44. }
    46. if (e.Button == MouseButtons.None && drawing)
    47. {
    48. drawing = false;
    49. _drawingPath.StartFigure();
    50. }
    51. lastMouseLocation = e.Location;
    52. }
    54. private void Form1_Paint(object sender, PaintEventArgs e)
    55. {
    56. e.Graphics.InterpolationMode = InterpolationMode.HighQualityBilinear;
    57. e.Graphics.CompositingQuality = CompositingQuality.HighQuality;
    58. e.Graphics.PixelOffsetMode = PixelOffsetMode.HighQuality;
    59. e.Graphics.SmoothingMode = SmoothingMode.AntiAlias;
    61. using (SolidBrush b = new SolidBrush(Color.Blue))
    62. using (Pen p = new Pen(b, 51))
    63. {
    65. e.Graphics.DrawPath(p, _drawingPath);
    66. }
    68. using (SolidBrush b = new SolidBrush(Color.LightGreen))
    69. using (Pen p = new Pen(b, 50))
    70. {
    72. e.Graphics.DrawPath(p, _drawingPath);
    73. }
    74. }
    76. }
    77. }
    Bilder

    • Screenshot 2021-01-15 210349 - Kopie.png

      1,16 MB, 1.615×858, 71 mal angesehen

    @φConst Ja, gerne. Ich sage es vorsichtshalber: es geht mir nicht um Elektronik, sondern ich brauchte einfach irgendein Bild, wo größere und kleinere geschlossene Teile drin sind – das Holstentor kann man schlecht umrahmen; ist auch nicht das Ziel.
    Du kannst allerdings jedes beliebige Foto hernehmen. :)
    Bilder

    • 20210111_141648 - Kopie.jpg

      5,45 MB, 4.032×3.024, 71 mal angesehen

    Exemplarische Vorgehensweise:
    Image-Segmentation anwenden, ich habe mal eine Segmentierung basierend auf sogenannte Graph-Cuts gewählt (in MatLab geladen, und dann entsprechend Vorder -und Hintergrund markiert), Resultat:


    Nun kann ich einen Treshold festlegen - alles gelb-markierte wird betont, alles andere auf 0 gesetzt, Resultat:


    Darauf die Kantendetektion anwenden, und dann einfach mit dem Urbild addieren - schon hast du eine präzise, MODIFIZIERBARE, Kantendetektion implementiert.
    Dein Beispiel wäre:


    Näheres:
    Spoiler anzeigen


    Was du per se vorhast, ist nicht zu unterschätzen. Das geht tief in die Materie, wenn du das präziser haben willst, und individuell die Kurven setzen ist auch kein Kompromiss, weil du dadurch Akkuratesse und Präzision verlieren könntest.
    Und Gott alleine weiß alles am allerbesten und besser.

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

    Danke für die Idee. Das Video schaue ich mir morgen an.

    individuell die Kurven setzen ist auch kein Kompromiss, weil du dadurch Akkuratesse und Präzision verlieren könntest.
    Ja, ich überlege seit 2 Tagen hin und her zwischen
    1) „Programm soll möglichst gut erkennen, damit ich keine anderen Programme brauche und weil ich sonst Präzision verliere.“
    2) „Das ist schwer zu implementieren, ich muss individuell Kurven setzen.“

    Daher finde ich deine Vorgehensweise geeignet.

    Bartosz schrieb:

    „Wie starkes Weiß (0 bis 255) muss ich sehen?“
    Diskretisiere das Graubild, alle Werte kleiner als x auf 0, alle anderen auf 255.
    Dann finde Deine Kanten,mit dem oben beschriebenen Filter.
    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!

    Zum Abschluss möchte ich das, was innerhalb des GraphicsPaths ist, auf ein neues Bild übertragen, siehe Schema. Ich habe bisher keine Möglichkeit gefunden, dies in ein neues Bild zu übertragen; daher dachte ich mir, ich schreibe mir eine Funktion, welche prüft, ob das derzeitige x, y innerhalb oder außerhalb des Paths liegt. Wenn außerhalb: transparent, sonst wie im Originalbild. Wie kann in nun diese Liste durchgehen, wenn es mehrere gleiche y oder x gibt?
    Ich habe schon mal den Code für „ein neues Bild basierend auf dem Rechteck erstellen“.

    Spoiler anzeigen

    VB.NET-Quellcode

    1. Using Extracted As Bitmap = New Bitmap(rect.Width, rect.Height, Imaging.PixelFormat.Format32bppArgb)
    2. Using Grp As Graphics = Graphics.FromImage(Extracted)
    3. Grp.DrawImage(Form1.Picture1, 0, 0, rect, GraphicsUnit.Pixel)
    4. End Using
    5. If System.IO.Directory.Exists("C:\Users\xy\Desktop") Then
    6. Extracted.Save("C:\Users\xy\Desktop\1.png", Imaging.ImageFormat.Png)
    7. End If
    8. End Using
    Bilder

    • IMG_20210118_0001 2 - Kopie.jpg

      516,4 kB, 3.508×1.660, 62 mal angesehen

Facebook
Telefonspende