Boundary Tracing

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

Es gibt 38 Antworten in diesem Thema. Der letzte Beitrag () ist von xd-franky-5.

    Boundary Tracing

    Hallo Leute,
    ich arbeite gerade an einer Texterkennungssoftware, welche mit Kontur-Analyse funktioniert. Dazu habe ich ein Liste an Punkten, welche ich logisch verbinden muss. Aber ich weiß nicht wie der Algorithmus erkennen soll, ob die Punkte-Gruppen unabhängig sind oder zusammen gehören und verbunden werden müssen. Aus den Verbindungen sollen dann Vektoren entstehen, die je Gruppe gespeichert werden. Man kann sich das so vorstellen:
    Punkte-Feld:


    Verbindungen: (Vektoren)


    Wisst ihr, wie man das realisieren könnte ?

    mfG Frank

    Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von „xd-franky-5“ ()

    @xd-franky-5 Sind die Punkte so löchrig oder liegen die dicht?
    Suche, bis Du einen gefunden hast.
    Wenn sie dicht liegen, teste die 8 Nachbarn, wenn sie nicht dicht liegen, suche in den 24 (5x5) oder den 48 (7x7) (ggf. MINUS Eckpunkte) Nachbarn den nächsten Punkt.
    Es gibt nun mehrere Möglichkeiten.
    - Wenn alle Ur-Punkte schwarz auf weiß (0 auf 255) sind, gib jedem gefundenen die Farbe 1 als Kennung gefunden und zum Feststellen, dass alle Punkte eines Kurvenzugs gefunden wurden (Vollzähligkeit).
    - Übertrage die zusammengehörigen Punkte in eine List(Of Points), für jedes geschlossene Zeichen eine Instanz, unter Beachtung, dass Du bei "hohlen" Buchstaben ("o") eine innere und eine äußere Kurve hast.
    Und dann tue was Du tuen willst.
    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!

    Das Traveling Salesman Problem (TSP) könnte eventuell auch ein Ansatz sein.
    Wobei ich habe es nicht getestet, und weiss darum auch nicht wie die Ressourcenauslastungen während der Laufzeit sind.
    Ich denke jedoch das sollte kein Problem sein bei dir, da du nicht viele Punkte hast, und alle Punkte logisch sehr nahe aneinander liegen. Das wird sicher fix erledigt.

    - Hier gäbe es noch eine allgemeine Variante online.
    - Problem des Handlungsreisenden


    Freundliche Grüsse

    exc-jdbi

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

    Wie kriegst du denn diese Punkte? Konturen als Punkte zu bekommen ist meines Wissens nach sehr unüblich - normalerweise kriegt man sie von Bibliotheken wie OpenCV direkt als gruppierte Polygone, bei welchen man sowas nicht machen muss.

    Also mein Vorhaben ist das:
    Vektoren generieren:
    1. Bild in Schwarz Weiß und niedrigere Auflösung
    2. Kontur als Punkte extrahieren (jeder Schwarze Punkt der um sich herum mindestens einen weißen hat)
    3. Punkte aufteilen in einzelne Mashs
    4. Mashs in Vektoren mit komplexen Zahlen umwandeln

    Vektoren vergleichen:
    (Skalarprodukt aus Vektor1 und Vektor2^m)/(Skalarprodukt aus normierter Vektor1 und normierter Vektor2) wobei m = 0, ..., Dimensionen von Vektor2 - 1

    Ich habe gerade einen einfachen Plan und versuche das mal kurz umzusetzen, ich sage dann später, ob es so funktioniert hat.

    xd-franky-5 schrieb:

    Dazu habe ich ein Liste an Punkten, welche ich logisch verbinden muss. Aber ich weiß nicht wie der Algorithmus erkennen soll, ob die Punkte-Gruppen unabhängig sind oder zusammen gehören und verbunden werden müssen.
    Mein Ansatz dazu wäre folgender:
    Spoiler anzeigen

    VB.NET-Quellcode

    1. 'Folgende Points sind ein H (durchgemischt)
    2. Dim listSource As New List(Of Point) From {New Point(6, 1), New Point(0, 3), New Point(0, 4), New Point(0, 5), New Point(0, 6), New Point(1, 0), New Point(0, 0), New Point(0, 1),
    3. New Point(4, 0), New Point(6, 0), New Point(1, 6), New Point(2, 6), New Point(4, 6), New Point(5, 6), New Point(5, 0), New Point(2, 4),
    4. New Point(6, 6), New Point(6, 4), New Point(6, 3), New Point(2, 5), New Point(6, 5), New Point(6, 2), New Point(2, 0), New Point(0, 2),
    5. New Point(2, 2), New Point(2, 1), New Point(4, 5), New Point(4, 4), New Point(4, 2), New Point(4, 1), New Point(3, 4), New Point(3, 2)}
    7. Public listEdge As New List(Of Point) 'gereihte Liste der verlaufenden Punkte des H
    8. Private Function scanLetter(source As List(Of Point)) As Boolean
    9. Dim p = source.First
    10. Dim x = p.X
    11. Dim y = p.Y
    12. Dim scan As Action(Of Integer, Integer) = Sub()
    13. listEdge.Add(New Point(x, y))
    14. Debug.WriteLine(String.Format("{0}:{1}", x, y))
    15. Dim found As Boolean
    16. Do
    17. y += 1 : If isNotOK(x, y) Then y -= 1 Else found = True : scan(x, y) 'OBEN
    18. x += 1 : If isNotOK(x, y) Then x -= 1 Else found = True : scan(x, y) 'RECHTS
    19. y -= 1 : If isNotOK(x, y) Then y += 1 Else found = True : scan(x, y) 'UNTEN
    20. x -= 1 : If isNotOK(x, y) Then x += 1 Else found = True : scan(x, y) 'LINKS
    21. y += 1 : x += 1 : If isNotOK(x, y) Then y -= 1 : x -= 1 Else found = True : scan(x, y) 'OBEN RECHTS
    22. x += 1 : y -= 1 : If isNotOK(x, y) Then x -= 1 : y += 1 Else found = True : scan(x, y) 'UNTEN RECHTS
    23. y -= 1 : x -= 1 : If isNotOK(x, y) Then y += 1 : x += 1 Else found = True : scan(x, y) 'UNTEN LINKS
    24. x -= 1 : y += 1 : If isNotOK(x, y) Then x += 1 : y -= 1 Else found = True : scan(x, y) 'OBEN LINKS
    25. If found Then found = False Else Return
    26. Loop
    27. End Sub
    29. scan(x, y)
    30. Return (source.Count = listEdge.Count)
    31. End Function
    32. Private Function isNotOK(x As Integer, y As Integer) As Boolean
    33. If Not (x >= 0 AndAlso x <= 6) AndAlso (y >= 0 AndAlso y <= 6) Then Return True
    34. If listEdge.Contains(New Point(x, y)) Then Return True
    35. Return Not listSource.Contains(New Point(x, y))
    36. End Function

    Aufruf erfolgt mit Dim ok = scanLetter(listSource) 'erfolgreich?

    listEdge ist dann eine gereihte Liste der verlaufenden Punkte des H

    Wobei ich aber sagen muss, dass das beim H ein Außenrahmen ist und es bei einem O dann einen Außen und einen Innenrahmen geben muss...

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

    xd-franky-5 schrieb:

    Also mein Vorhaben ist das:
    Das wäre eigentlich ein zu diesem Thread vorgelagertes Thema.
    Wie genau lautet die Aufgabenstellung?
    @VB1963 Das halte ich etwas über das Ziel hinaus geschossen.
    Üblicherweise hat man nach einer Vorverarbeitung schwarze und weiße Pixel in einem Bitmap. Da holt man sich das Pixel-Array und los gehts.
    Da gibt es sehr viele Möglichkeiten, schnellen Code zu machen. Die erste wäre unsafe Code in C#.
    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!

    das nächste Problem was ich sehe, ist die Regel die du erstellen willst, um eine hierarchische Zuordnung von den Punkten zu erstellen.

    Bspw. bei deinem Buchstaben "H" woher weiß jeder Punkt mit welchen 2 anderen Punkten er sich verbinden soll? Wenn du nur die 2 nächsten Punkte hierfür verwendest, frag ich mit was ist, wenn sie der Abstand zwischen zwei zugehörigen Punkten vergrößert und deshalb die Linie zwischen zwei nicht zueinander gehörigen Punkten gezogen wird.

    So ganz klar komm ich damit noch nicht :S
    Wenn das Leben wirklich nur aus Nullen und Einsen besteht, dann laufen sicherlich genügen Nullen frei herum. :D
    Signature-Move 8o
    kein Problem mit privaten Konversationen zu Thema XY :thumbup:

    Hi
    meine Idee zu einer Lösung wäre, rekursiv:
    - Beginne mit der Menge der Punkte, wobei jeder Punkt als eigenständige Zusammenhangskomponente (Eine Zusammenhangskomponente ist ein zusammenhängender Teilgraph, wobei ein Teilgraph ein "Graph in einem Graphen" ist, d.h. quasi eine Art Unterteilung) betrachtet wird
    - Verbinde immer zwei benachbarte Zusammenhangskomponenten (d.h. Komponenten mit geringstem minimalen Abstand), sofern der Abstand unterhalb eines Schwellwerts liegt, bis keine solche Verbindung mehr erstellt werden kann
    Das Abbruchkriterium des Schwellwerts ist in diesem Fall ggf. nicht optimal. Ggf. kannst du den Schwellwert in einem vorhergehenden Schritt auswerten. Es wäre vermutlich eine Heuristik anzuwendne, wie bspw. der durchschnittliche Abstand aller Nachbarn.

    Es ist ggf. zusätzlich sinnvoll, Spatial Hashing, ein Grid oder einen Quadtree zu benutzen, um die Zusammenhangskomponenten bestimmten Bereichen zuzuordnen - je nachdem, wie hoch die Zahl der Punkte ist.

    Viele Grüße
    ~blaze~

    Ich denke mal, @xd-franky-5 sollte sich auf Fälle beschränken, wo die Pixel dicht liegen.
    Wenn ein Text gescannt wird, setzt OCR dies voraus.
    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!

    Das ist ja das, was ich gemeint hab'. Der Schwellwert gibt die maximale Distanz zweier Nachbarn an.

    Übrigens: Obiges kann man noch vereinfachen, indem man abschließend die Nachbarn der Zusammenhangskomponente in Steigungen gruppiert und diese vereinfacht, sofern ein gewisser Winkel (bzw. Cosinus, d.h. Skalarprodukt, da wesentlich effizienter) nicht überschritten wird.

    Viele Grüße
    ~blaze~

    Danke für eure Rückmeldungen, ich versuche mal mein Vorhaben zu verdeutlichen, denn so ganz verstehe ich eure Pläne leider nicht :-/
    Also ich habe das Schwarz-Weiß-Bild der Konturen bereits in Punkte(nur schwarze) umgewandelt. Ich habe bereits einen Algorithmus versucht, den ich mir in der Schule überlegt habe, der sieht so aus:
    Spoiler anzeigen

    VB.NET-Quellcode

    1. Public Function FilterContour(ByVal pts As List(Of Point)) As List(Of Mash)
    2. Dim points As New List(Of Point)
    3. points.AddRange(pts.ToArray)
    4. Dim mashs As New List(Of Mash)
    5. For start = 0 To points.Count - 1
    6. If Not points(start) = Nothing Then
    7. Dim now As Integer = start
    8. Dim last As Integer = 0
    9. Dim mash As New Mash
    10. Do
    11. mash.Add(points(now))
    12. now = GetNearestPoint(now, points)
    13. points(last) = Nothing
    14. If start = now Or now = 0 Then Exit Do
    15. last = now
    16. Loop
    17. mashs.Add(mash)
    18. End If
    19. Next
    21. Dim asize As Integer = 0
    22. For Each mash In mashs
    23. asize += mash.Count
    24. Next
    25. asize = CInt(asize / mashs.Count)
    27. For m = mashs.Count - 1 To 0 Step -1
    28. If mashs(m).Count < asize Then mashs.RemoveAt(m)
    29. Next
    30. Return mashs
    31. End Function
    33. Public Function GetNearestPoint(ByVal index As Integer, ByVal points As List(Of Point)) As Integer
    34. Dim point As Point = points(index)
    35. For Each cp As Point In {New Point(0, -1), New Point(1, -1), New Point(1, 0), New Point(1, 1), New Point(0, 1), New Point(-1, 1), New Point(-1, 0), New Point(-1, -1)}.ToList
    36. Dim p As New Point(point.X + cp.X, point.Y + cp.Y)
    37. If points.Contains(p) Then Return points.IndexOf(p)
    38. Next
    39. Return Nothing
    40. End Function



    Das funktioniert tatsächlich auch, aber nicht zuverlässig, manchmal findet die Funktion GetNearestPoint() keinen benachbarten Punkt mehr obwohl das nicht sein kann, denn jede Kontur ist ein, in sicher geschlossener Kreis quasi. Das passiert nur wenn der Kreis geschlossen ist, also alle bereits passierten Punkte gelöscht sind. Das alles visualisiert sieht so aus:


    Links: Der Algorithmus funktioniert
    Rechts: Funktioniert nicht ??!?

    mfG Frank

    EDIT: Ich habe meinen Bild-Abtast-Algorithmus nochmal überarbeitet und nun funktioniert alles soweit.

    Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von „xd-franky-5“ ()

    ~blaze~ schrieb:

    Hi
    meine Idee zu einer Lösung wäre, rekursiv:
    - Beginne mit der Menge der Punkte, wobei jeder Punkt als eigenständige Zusammenhangskomponente (Eine Zusammenhangskomponente ist ein zusammenhängender Teilgraph, wobei ein Teilgraph ein "Graph in einem Graphen" ist, d.h. quasi eine Art Unterteilung) betrachtet wird
    - Verbinde immer zwei benachbarte Zusammenhangskomponenten (d.h. Komponenten mit geringstem minimalen Abstand), sofern der Abstand unterhalb eines Schwellwerts liegt, bis keine solche Verbindung mehr erstellt werden kann
    Das Abbruchkriterium des Schwellwerts ist in diesem Fall ggf. nicht optimal. Ggf. kannst du den Schwellwert in einem vorhergehenden Schritt auswerten. Es wäre vermutlich eine Heuristik anzuwendne, wie bspw. der durchschnittliche Abstand aller Nachbarn.

    Es ist ggf. zusätzlich sinnvoll, Spatial Hashing, ein Grid oder einen Quadtree zu benutzen, um die Zusammenhangskomponenten bestimmten Bereichen zuzuordnen - je nachdem, wie hoch die Zahl der Punkte ist.

    Viele Grüße
    ~blaze~


    Hallo nochmal, mein Algorithmus hat sich doch nicht so gut erwiesen, da er an solchen Stellen nicht funktioniert:

    Der Algorithmus sucht immer am neuen Punkt erst nach oben, dann rechts, unten und links nach einem neuen Punkt. Hat er ihn gefunden geht er zu diesem. Es kann zu keinem Punkt mehrmals gegangen werden. Deshalb geht das an der Stelle nicht, weil er dort unendlich im Kreis laufen würde, bzw. wenn kein Punkt gefunden wird, der Algorithmus abbricht.
    Ich habe dann folgenden Algorithmus versucht:

    VB.NET-Quellcode

    1. ​
    2. Dim pols As New List(Of Polygon)
    3. Dim marked As New List(Of Point)
    5. For y = 0 To img.Height - 1
    6. For x = 0 To img.Width - 1
    7. Dim s As New Point(x, y)
    8. If Not lbmp.GetPixel(s.X, s.Y).ToArgb = Color.Black.ToArgb AndAlso Not marked.Contains(s) Then
    9. Dim n As Point = s
    10. Dim pol As New Polygon
    11. Dim dir As Integer = 0
    12. Do
    13. If n.X >= 0 AndAlso n.X < img.Width AndAlso n.Y >= 0 AndAlso n.Y < img.Height Then
    14. If Not lbmp.GetPixel(n.X, n.Y).ToArgb = Color.Black.ToArgb Then
    15. marked.Add(n)
    16. pol.Points.Add(n)
    17. dir += 1
    18. If dir > 7 Then dir -= 8
    19. Else
    20. dir -= 1
    21. If dir < 0 Then dir += 8
    22. End If
    23. n = SetDirection(n, dir)
    24. If s = n Then Exit Do
    25. Else
    26. Exit Do
    27. End If
    28. Loop
    29. pols.Add(pol)
    30. End If
    31. Next
    32. Next
    34. Private Shared Function SetDirection(ByVal point As Point, ByVal dir As Integer) As Point
    35. Select Case dir
    36. Case 0
    37. Return New Point(point.X + 1, point.Y)
    38. Case 1
    39. Return New Point(point.X + 1, point.Y - 1)
    40. Case 2
    41. Return New Point(point.X, point.Y - 1)
    42. Case 3
    43. Return New Point(point.X - 1, point.Y - 1)
    44. Case 4
    45. Return New Point(point.X - 1, point.Y)
    46. Case 5
    47. Return New Point(point.X - 1, point.Y - 1)
    48. Case 6
    49. Return New Point(point.X, point.Y + 1)
    50. Case 7
    51. Return New Point(point.X + 1, point.Y + 1)
    52. End Select
    53. End Function


    Das Ergebnis:
    Screenshot_3.bmp
    Alle Polygone sind zerstückelt und unvollständig, außerdem sind sie nicht in sich geschlossen. Der Algorithmus ist von hier: lmb.informatik.uni-freiburg.de…raktikum/BVAnl_muster.pdf

    @~blaze~ kannst du mir dein Vorhaben noch ein mal genauer erläutern ?

    mfG Frank

    @xd-franky-5 Welchen Abstand hat dort der Punkt, den er nicht findet?
    Was sagt Deine Analyse des Algorithmus', wenn Du ihn schrittweise abarbeitest und Du den Zielpunkt sozusagen siehst?
    Vergrößere ggf. den Suchabstand.
    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!

    - Beginne mit der Menge der Punkte, wobei jeder Punkt als eigenständige Zusammenhangskomponente (Eine Zusammenhangskomponente ist ein zusammenhängender Teilgraph, wobei ein Teilgraph ein "Graph in einem Graphen" ist, d.h. quasi eine Art Unterteilung) betrachtet wird

    Wir betrachten die Punkte, die du hast, als Graph. Ein Graph hat Knoten V und Kanten E, wobei am Anfang keine einzige Verbindung existiert, d.h. E ist leer. Die Knoten sind in deinem Fall Punkte (z.B. Instanzen vom Typ Point oder Vector), die Kanten sind Verbindungen zwischen zwei Punkten, d.h. irgendwas, was zwei Punkte fasst, wie bspw. Tuple(Of Point, Point) (ich würde nicht Tuple verwenden, sondern ValueTuple oder einen eigenen Typ definieren. Strukturen sind an dieser Stelle handlicher).
    (Den Begriff "Zusammenhangskomponente" versuche ich bei der Erklärung jetzt mal wegzulassen, der ist nur unnötig komplex für einen so simplen Fakt)


    - Verbinde immer zwei benachbarte Zusammenhangskomponenten (d.h. Komponenten mit geringstem minimalen Abstand), sofern der Abstand unterhalb eines Schwellwerts liegt, bis keine solche Verbindung mehr erstellt werden kann
    Das Abbruchkriterium des Schwellwerts ist in diesem Fall ggf. nicht optimal. Ggf. kannst du den Schwellwert in einem vorhergehenden Schritt auswerten. Es wäre vermutlich eine Heuristik anzuwendne, wie bspw. der durchschnittliche Abstand aller Nachbarn.

    Du beginnst bei der Menge aller Punkte und fügst in den Graphen weitere Kanten hinzu und zwar immer jene zwischen zwei Punkten, die benachbart sind.
    Für die Frage, ob zwei Punkte benachbart sind, hatte ich vorgeschlagen, den Abstand zwischen den Punkten zu nehmen und den nach oben hin zu begrenzen (durch den Schwellwert). Das halte ich im Nachhinein doch nicht nur für ein nicht-optimales, sondern für ein schlechtes Kriterium.
    Da kann man ziemlich viel Unfug anstellen, wie bspw. die lokale Punktdichte einberechnen oder sowas.
    Für dich ist es vmtl. genug, wenn du folgendes machst:
    - Für alle Punkt-Paare (P1, P2): Wenn der Abstand von P1 und P2 unterhalb eines Schwellwertes liegt, füge die Kante zum Graphen hinzu

    Jetzt hast du einige Kanten zu viel, die du im Nachhinein wieder entfernen willst. Die einzelnen "Teile" (= Zusammenhangskomponenten) sollten sich bereits halbwegs als H bzw. Rechteck identifizieren lassen, sonst ist der Schwellwert zu hoch (H und Rechteck sind keine getrennten Teile) oder zu niedrig (Es gibt noch unverbundene Kanten, die verbunden werden sollten).

    Jetzt entfernen wir die Kanten, die zu viel sind. Zu bestimmen, was zu viel ist, ist nicht ganz trivial, schätze ich. Ich denke, ein gutes Resultat bekommt man, wenn man all jene Kanten entfernt, die schlechter als Nachbarn geeignet sind und dass sich dies aus dem Grad der Erreichbarkeit und Abständen ermitteln lässt.
    Ich würde mal versuchen, alle Kanten (P1, P2) zu entfernen, für die es eine Folge von Kanten (P1, ..., P2) gibt, deren Grad unterhalb eines Wertes liegt (bspw. 3) und für deren Teilkanten gilt, dass alle einen geringeren Abstand haben, als (P1, P2).

    Als Beispiel ein rechtwinkliges Dreieck A, B, C:
    Wenn AC die Hypotenuse eines rechtwinkligen Dreiecks ist, dann ist AB->BC besser, als AC direkt, da die Längen von AB und BC jeweils kürzer sind, als die von AC. Dadurch verhinderst du, dass Diagonalen zwischen bleiben, obwohl noch ein weiterer Punkt vorhanden ist.

    Ich würde das erst mal so ineffizient stehen lassen. Optimieren kannst du, sobald es soweit läuft.

    Viele Grüße
    ~blaze~

    @RodFromGermany Ja die Punkte sind unterschiedlich weit voneinander entfernt, so 1-3 Pixel. Klar könnte ich den Such-Kernel bei jedem Punkt anpassen, dann würde er um das Problem drum herum kommen, aber ist das noch Ressourcensparend ?

    @~blaze~ also ich nehm' das mal so auf:
    Ich habe die Liste an Punkten und gehe jeden durch und suche in einem 3x3-Kernel nach dem nächsten Punkt, wenn keiner gefunden, dann 5x5 usw. dann verbinde ich diese zu einer Liste an Instanzen der Klasse "Edge (inherits List(Of Point))". Dann gehe ich rekursiv alle Edges durch, gehe an den Anfang der Edge und suche wiederum in allen Edges am Ende einen Punkt, welcher benachbart ist (wieder 3x3 ... -Kernel). Dann mache ich das gleiche mit dem Ende des ausgesuchten Edges. Und das so oft bist nichts mehr zu verbinden ist. Die Kernel sind auf einen Threshold begrenzt, welcher von mir selbst ausgesucht wird.

    Aber ich muss hierbei ja auch den Kernel anpassen für jedes Pixel. Was ist nun Effizienter ?

    EDIT: Mein Vorhaben nochmal stark verallgemeinert: Ich gebe ein Schwarz-Weiß-Bild ein und möchte eine Liste von Polygonen zurück :)

    mfG Frank

    Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von „xd-franky-5“ ()

    xd-franky-5 schrieb:

    ist das noch Ressourcensparend ?
    Dein Punkt-Such-Algo isses nicht.
    Wenn Du Dir die Pixel in ein Byte-Array holst, kannst Du mit Index-Operationen wesentlich schneller und eleganter Deine Punktwolken durchmustern.
    Wenn Du über solch nachdenkst, denke auch daran, das ganze in C# zu machen und mit unsafe-Operationen auf dem Speicher selbst zu arbeiten.
    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 Ich arbeite gerade erstmal mit Lockbits und übersetze es später dann in C# mit Unsafe.

    @~blaze~ Ja die Punkte sind Pixel die alle miteinander verbunden sind (meistens). Ich habe nach langer Googlezeit noch ein paar Algorithmen gefunden. Ich melde mich gleich noch mal.

Facebook
Telefonspende