Das deutsche Python-Forum

Hallo an alle, ich habe wieder mal ein Problem und nachdem ich bei meinen letzten Fragen gute Erfahrungen gemacht habe, dass mir immer wer helfen konnte, poste ich wieder hier. An dieser Stelle schon mal herzlichen Dank an alle für eine Antwort.

Die Fragestellung ist etwas komplexer: Ich habe ein Netz, welches aus Dreiecken aufgebaut ist. Ein jedes Dreieck besteht aus 3 Linien, jede Linie wiederum aus 2 Punkten. Diese Informationen habe ich folgendermaßen in einer Liste (Listenname = Endliste3) abgespeicher:

Ein Element einer Liste sieht folgendermaßen aus:

[FID_Dreieck, FID_Linie, [[FID_PUNKT1, [X_Koordinate, Y_Koordinate, Z_Koordinate], [FID_PUNKT2, [X_Koordinate, Y_Koordinate, Z_Koordinate]]]

Wenn 2 Dreiecke benachbart sind, so stimmen die Koordinaten (XYZ) einer Linie überein, die FID_LINIE und FID_PUNKT1 und FID_PUNKT2 sind aber unterschiedlich

Nun soll beim Dreieck mit der FID_Dreieck = 0 begonnen werden. Der Wert der FID_Dreieck soll mit 0 überschrieben werden und in eine neue Liste (Listenname=owner) geschrieben werden (das erste Element, das ich betrachte). Dann soll ein benachbartes Dreieck gefunden werden. Für dieses Dreieck soll der FID_Dreieck mit 1 überschrieben und in eine weitere Liste geschrieben werden (Listenname=neighbour) (das 2. Dreieck, das ich betrachte). Gleichzeitig sollen in eine dritte Liste die FID der Punkte der gemeinsamen Linie geschrieben werden (Listenname=internal_faces). Wenn das gemacht wurde, soll vom Owner zum Neigbour gegangen werden, sprich ich suche dann vom Dreieck, welches vorher als Neighbour identifiziert worden war und nun der neue Owner ist, die weiterenen Nachbarn über das selbe Verfahren, bis ich durch alle Dreiecke durchiteriert habe. Sprich, so muss in die Owner-Liste eine 1 für das 2. Dreieck geschrieben werden und in die Neigbour-Liste eine 2 für den neu gefundenen Nachbarn usw.

Ich habe auch schon versucht, einen Code zu verfassen und bitte um Hilfe. Danke (wie bereits erwähnt) schon im Voraus!

Code: Alles auswählen


erstes_Tri = Endliste3[0] # vorher hab ich die Liste nach dem 0. Eintrag sortiert, sodass das 0. Element die FID_Dreieck = 0 hat
tri_index_Start = erstes_Tri[0]
tri_index_aktuell = 99999999999999

#while tri_index_Start != tri_index_aktuell: --> solange nicht durch alle Elemente durch
 #   for t in Endliste3: # iteriere durch alle Elemente der Liste,
# wenn die Koordinaten einer Linie zweier unterschiedlicher Dreiecke gleich sind
#        if  erstes_Tri[2][0][1] == t[2][0][1] and erstes_Tri[2][1][1] == t[2][1][1] and erstes_Tri[0] != t[0]: 
            #schreibe überschreibe FID_Dreieck mit laufender Nummer 
            #FID_Dreieck = laufende_Nummer --> nicht lauffähig
            #füge die neue FID_Dreieck zur Liste owner hinzu.
#            owner.append(FID_Dreieck) --> das hier ist noch nicht lauffähig
 #           internal_faces.append(erstes_Tri[2][0][0]) #--> FID_Linie in die Liste internal_faces schreiben
#            internal_faces.append(erstes_Tri[2][1][0])# --> FID_Linie in die Liste internal_faces schreiben
            # schreibe überschreibe die FID_Dreieck des Nachbarn mit der nächst höheren Laufvariablen
            # und füge die neue FID_Dreieck der Liste neighbour zu
            #FID_Dreieck = laufende_Nummer+1
 #           neighbour.append(FID_Dreieck) --> nicht lauffähig
            #  --> gehe vom Owner zu neigbour 
            # --> und verfahre weiter: setze FID_owner = neue Laufvariable und ....

sehr verschachtelt das ganze und ich bin mir auch nicht sicher, ob es hierfür eine Lösung gibt. Freue mich aber über jeden Anstoß und über jede Hilfe.

Danke.

Du beschreibst da einen Algorithmus und eine Handvoll Datenstrukturen, allerdings ist mir noch nicht ganz klar, welche übergeordnete Aufgabenstellung vorliegt. Ich vermute mal, es geht darum, ein Verzeichnis benachbarter Dreiecke aufzubauen, so daß du zu jedem Dreieck schnell die Nachbarn abrufen kannst?

Abgesehen davon würde ich dir empfehlen, dir dieses Problem gut zu merken, weil es sich auch sehr schön objektorientiert lösen läßt. Wenn du eine Lösung für den jetzigen Ansatz mit verschachtelten Listen hast, könntest du dich mit Klassen beschäftigen und eine entsprechende Variante entwickeln. Dann hättest du zumindest das Problem vieler Einsteiger nicht mehr, die sich oft fragen, an welchem Beispiel sie OOP sinnvoll erlernen könnten.

ja, es geht darum, von einem Dreieck aus den Nachbarn zu finden und dann von diesem wiederum den Nachbarn usw. Ist der Ansatz, so wie ich ihn versuche falsch?

Geht es nur um das Durchlaufen, oder mußt du dann später noch zurückspringen können? Also z.B. sagen: Was sind die Nachbarn für Dreieck XY? Brauchst du die Daten am Ende in einer ganz bestimmten Form, oder reicht eine "günstige" Datenstruktur?

Ob dein Ansatz falsch ist, kann ich noch nicht so recht sagen. Die Beschreibung war mir etwas zu kompliziert, und ich wollte erst einmal sichergehen, daß ich das Grundproblem verstanden habe.

Ich muss nur wissen, welche Dreiecke benachbart sind, sprich von jedem Dreieck (owner) einen Nachbarn (neighbour) finden. Auch wenn ein Dreieck im Netz mehrere Nachbarn hat, muss ich nur einen finden, zu dem hingehen, den nächsten finden usw. bis ich zu jedem Dreieck eine Beziehung Owner - Neighbour habe

Gut, dann schauen wir uns erst einmal die benötigten Datenstrukturen an.

Für Owner und Neighbour hattest du zwei Listen vorgesehen, wenn ich dich richtig verstanden habe. Der Nachbar von Owner i findet sich dann in der Nachbarliste an Stelle i. Zumindest dann, wenn du immer einen Nachbarn findest. Was am Rand ja nicht gegeben sein muß. Aber da könntest du dir mit Platzhaltern (z.B. 'None') behelfen.
Ich persönlich finde solche parallelen Datenstrukturen nicht so toll. Ich würde an der Stelle vermutlich eine Liste von Tupeln (Owner, Neighbour) oder ein Dictionary nehmen.

Wie die Datenstruktur für 'internal_faces' aussehen sollte, hängt davon ab, was du später damit machen möchtest. Belassen wir es erst einmal bei der Liste.

Du solltest zwei Dinge im Auge behalten:

Du läufst Gefahr, daß zwei Dreiecke den selben Nachbarn haben und ein Teil der Suche womöglich immer wieder von vorne ausgeführt wird. Du mußt dir also unbedingt merken, welche Dreiecke du schon betrachtet hast, und den Durchlauf an dieser Stelle unter- oder abbrechen. Die Schlüssel des Dictionaries mit den Ownern könnten zum Beispiel als Verzeichnis dienen.

Die Laufzeit: Du wirst in deiner ersten Lösung wohl immer wieder die Liste der Dreiecke durchlaufen, um einen Nachbarn zu finden. Hast du n Dreiecke, wohl bis zu n mal. Die Laufzeit (worst case) deines Programms würde dann quadratisch mit der Anzahl der Dreiecke steigen - nicht besonders gut. Wenn du deine erste Lösung fertig hast, solltest du dir noch mal Gedanken machen, wie vermieden werden kann, daß immer die komplette Liste der Dreiecke durchsucht werden muß.

Die Einteilung in 2 Listen (owner und neighbour) muss so vorgenommen werden, da die Daten dann in dieser Form eben in ein Programm eingelesen werden müssen. Leider.
Wie kann ich formulieren, dass die Schlüssel des Dictionary mit den Owner als Verzeichnis dienen?

Also, ich habe mir das ganze folgendermaßen überlegt:

Code: Alles auswählen


owner = list()
neighbour = list()
internal_faces = list()
erstes_Tri = Endliste3[0]

P = 0
    for FID in Endliste3: #gehe durch die Endliste
        for FID_2 in Endliste3: #vergleiche die Endliste erneut
            if FID[2][0][1]==FID_2[2][0][1] and FID[2][1][1]==FID_2[2][1][1] and FID[0] <> FID_2[0]: #wenn 2 Dreiecke benachbart sind
               neueFID_owner = FID[0]  #setze die FID auf 0
               neueFID_owner = P
               neueFID_neighbour = FID_2[0] #setze die FID_2 auf 1
               neueFID_neighbour = P+1
               owner.append(FID[0]) #schreibe die neue FID in Liste owner
               neighbour.append(FID_2[0]) #schreibe die neue FID_2 in Liste neighbour
               internal_faces.append(FID[2][0][0])
               internal_faces.append(FID[2][1][0])
            P=P+1

Was mir im Code jetzt noch fehlt, sind die Schritte, dass der gefundene Nachbar zum neuen Owner wird und von dem ein neuer Nachbar gesucht wird, sowie dass sichergestellt wird, dass immer nur ein neuer Nachbar gefunden wird und nicht ein alter (sonst Endlosschleife).

Vielleicht hat jemand einen Tipp oder kann mir weiterhelfen...

Danke

Michi_J hat geschrieben:Was mir im Code jetzt noch fehlt, sind die Schritte, dass der gefundene Nachbar zum neuen Owner wird und von dem ein neuer Nachbar gesucht wird, sowie dass sichergestellt wird, dass immer nur ein neuer Nachbar gefunden wird und nicht ein alter (sonst Endlosschleife).

Vielleicht hat jemand einen Tipp oder kann mir weiterhelfen...

Danke

Ich bin mir nicht sicher, dass ich dein Problem vollständig erfasst habe, aber vielleicht helfen dir folgende Überlegungen weiter:
- schreibe eine Funktion:

Code: Alles auswählen

def search(owner, liste):

die zu einem gegebenen Element aus einer Liste den Nachbarn liefert.
- nimm das erste Listenelement (als Owner) aus der Liste heraus
die folgenden Schritte in einer Schleife:
- rufe deine Funktion mit owner und der Restliste auf.
- nimm das gefundene Element aus der Restliste heraus
die Suche ist abgeschlossen, wenn entweder die Funktion keinen Nachbarn mehr findet, oder wenn die Liste leer ist.
HTH
Norbert
(edit: das schreit geradezu nach Rekursion...)

@ntrunk: Wenn es mehr als 500-1000 Dreiecke gibt schreit das eher nicht nach Rekursion -- dafür ist Python nicht geeignet.

hmm... es sind im Anwendungsfall über 1000 Dreiecke...

ich glaub die Funktion search() hilft mir schon weiter, ich weiß allerdings nicht wirklich, wie ich sie umsetzen kann. Im Grunde muss ich von einem Dreieck (owner) ein beliebiges benachbartes Dreieck suchen (neighbour). Das erste Dreieck erhält die FID 0, der Nachbar die FID 1. Dann will ich den gefundenen Nachbarn als owner setzen und von dort wieder einen neuen Nachbarn suchen. Dann erhält der neue owner die FID 1, der Nachbar die 2 usw.

Schlussendlich sollen dann 2 Listen owner und neigbour entstehen wobei der erste Eintrag der owner-liste und der erste Eintrag der neighbour-liste übereinstimmen. Das gleiche gilt für den 2. Eintrag usw.

hm... kann mir hierzu jemand einen Tipp geben?

Versuchst du einem TIN 'ne Topologie zu verpassen, oder warum bastelst du da an den Kanten rum?

Michi_J hat geschrieben:hm... kann mir hierzu jemand einen Tipp geben?

Ich habe mir jetzt dein Ausgangsposting 3 mal durchgelesen und muss gestehen, dass ich immer weniger verstehe, auf was du eigentlich hinaus willst.

Bei meiner vorigen Antwort bin ich davon ausgegangen, dass du ausgehend von einer Liste mit Dreiecken eine Liste erhalten möchtest, die eine "Kette" von aneinander hängenden Dreiecke enthält. Da bin ich mir jetzt allerdings gar nicht mehr so sicher (war ich ja auch vorher schon nicht) ... :K sorry...

Vielleicht hilft es, wenn du, mal ohne gleich an Datenstrukturen zu denken, umgangssprachlich beschreibst, was du erreichen willst.

Gruß
Norbert

Doch genau das möchte ich erhalten: eine "Kette" benachbarter (zusammenhängender) Dreiecke.
Ich hab eine Liste aus Dreiecken und weiß, wie man herausfinden kann, dass sie benachbart sind. Dann sollen diese nacheinander in eine neue Liste gepackt werden, sodass eben, wie du es nennst, eine Kette entsteht.

Michi_J hat geschrieben:Doch genau das möchte ich erhalten: eine "Kette" benachbarter (zusammenhängender) Dreiecke.
Ich hab eine Liste aus Dreiecken und weiß, wie man herausfinden kann, dass sie benachbart sind. Dann sollen diese nacheinander in eine neue Liste gepackt werden, sodass eben, wie du es nennst, eine Kette entsteht.

Aha.
Dann schau'n mer mal (ungetestet mangels geeigneter Testdaten):

Code: Alles auswählen

def get_chain_of_triangles(triangles):
    """
    Diese Funktion erstellt fuer das 1. Element aus triangles eine Kette
    von benachbarten Elementen
    """

    # Eine Kopie der Ausgangsliste erstellen, damit das Original nicht
    # veraendert wird
    triangles_left = triangles[:]
    
    # Das erste Element der Resteliste ist der Ursprung der Kette
    result = [triangles_left.pop(0)]
    
    # Solange noch Elemente in der Resteliste sind
    while triangles_left:
        
        # nachbar suchen zu dem jeweils letzten Element der Ergebnisliste
        neighbour_index = search(triangles_left, result[-1])
        
        # wenn gefunden, das Element aus der Resteliste entfernen und an die
        # Ergebnisliste anfuegen.
        if neighbour_index != -1:
            result.append(triangles_left.pop(neighbour_index))
        else:
            break

    return result

def search_for_neighbour(triangles_left, owner):
    """
    Diese Funktion sucht in triangles_left den 1. Nachbarn von owner
    und gibt dessen Index zurueck, oder -1, falls owner keinen Nachbarn hat.
    """
    for i,triangle in enumerate(triangles_left):
        
        # hier den Vergleich anstellen,ob triangle der nachbar von owner ist
        if  [...]
            return i
    return -1

Kannst du damit was anfangen?

Gruß
Norbert

Nachtrag: bitte keine Mehrfachposts zum gleichen Problem machen.

@ ntrunk: Vielen Dank für deine Hilfe, ich werde jetzt mal gleich probieren, obs so funktioniert.
Das Mehrfachposten war wirklich keine allzu gute Idee...

mein Fehler

Anbei mein Testdatensatz (Endliste3):

[(0, 2, [[4, [-44125.5, 251484.5, 453.01429999999999]], [5, [-45625.5, 249824.5, 424.90600000000001]]]), (0, 18, [[36, [-45625.5, 249824.5, 424.90600000000001]], [37, [-47255.5, 254754.5, 408.16120000000001]]]), (0, 20, [[40, [-47255.5, 254754.5, 408.16120000000001]], [41, [-44125.5, 251484.5, 453.01429999999999]]]), (1, 0, [[0, [-45625.5, 249824.5, 424.90600000000001]], [1, [-46505.5, 249454.5, 423.92090000000002]]]), (1, 16, [[32, [-46505.5, 249454.5, 423.92090000000002]], [33, [-47255.5, 254754.5, 408.16120000000001]]]), (1, 19, [[38, [-45625.5, 249824.5, 424.90600000000001]], [39, [-47255.5, 254754.5, 408.16120000000001]]]), (2, 12, [[24, [-46505.5, 249454.5, 423.92090000000002]], [25, [-47265.5, 254754.5, 408.0419]]]), (2, 14, [[28, [-47265.5, 254754.5, 408.0419]], [29, [-47255.5, 254754.5, 408.16120000000001]]]), (2, 17, [[34, [-46505.5, 249454.5, 423.92090000000002]], [35, [-47255.5, 254754.5, 408.16120000000001]]]), (3, 5, [[10, [-46505.5, 249454.5, 423.92090000000002]], [11, [-48415.5, 254624.5, 399.47649999999999]]]), (3, 10, [[20, [-48415.5, 254624.5, 399.47649999999999]], [21, [-47265.5, 254754.5, 408.0419]]]), (3, 13, [[26, [-46505.5, 249454.5, 423.92090000000002]], [27, [-47265.5, 254754.5, 408.0419]]]), (4, 11, [[22, [-48415.5, 254624.5, 399.47649999999999]], [23, [-47265.5, 254754.5, 408.0419]]]), (4, 28, [[56, [-48415.5, 254624.5, 399.47649999999999]], [57, [-47265.5, 254764.5, 408.0222]]]), (4, 30, [[60, [-47265.5, 254764.5, 408.0222]], [61, [-47265.5, 254754.5, 408.0419]]]), (5, 31, [[62, [-47265.5, 254764.5, 408.0222]], [63, [-47265.5, 254754.5, 408.0419]]]), (5, 32, [[64, [-47265.5, 254764.5, 408.0222]], [65, [-47255.5, 254764.5, 408.096]]]), (5, 34, [[68, [-47255.5, 254764.5, 408.096]], [69, [-47265.5, 254754.5, 408.0419]]]), (6, 33, [[66, [-47265.5, 254764.5, 408.0222]], [67, [-47255.5, 254764.5, 408.096]]]), (6, 46, [[92, [-47265.5, 254764.5, 408.0222]], [93, [-49255.5, 258014.5, 431.06569999999999]]]), (6, 48, [[96, [-49255.5, 258014.5, 431.06569999999999]], [97, [-47255.5, 254764.5, 408.096]]]), (7, 49, [[98, [-49255.5, 258014.5, 431.06569999999999]], [99, [-47255.5, 254764.5, 408.096]]]), (7, 50, [[100, [-49255.5, 258014.5, 431.06569999999999]], [101, [-43915.5, 258794.5, 414.2158]]]), (7, 51, [[102, [-43915.5, 258794.5, 414.2158]], [103, [-47255.5, 254764.5, 408.096]]]), (8, 38, [[76, [-45435.5, 254754.5, 408.15609999999998]], [77, [-47255.5, 254764.5, 408.096]]]), (8, 52, [[104, [-43915.5, 258794.5, 414.2158]], [105, [-47255.5, 254764.5, 408.096]]]), (8, 53, [[106, [-43915.5, 258794.5, 414.2158]], [107, [-45435.5, 254754.5, 408.15609999999998]]]), (9, 8, [[16, [-48415.5, 254624.5, 399.47649999999999]], [17, [-49995.5, 254754.5, 402.4579]]]), (9, 25, [[50, [-49995.5, 254754.5, 402.4579]], [51, [-49995.5, 254764.5, 402.11309999999997]]]), (9, 26, [[52, [-49995.5, 254764.5, 402.11309999999997]], [53, [-48415.5, 254624.5, 399.47649999999999]]]), (10, 27, [[54, [-49995.5, 254764.5, 402.11309999999997]], [55, [-48415.5, 254624.5, 399.47649999999999]]]), (10, 40, [[80, [-49995.5, 254764.5, 402.11309999999997]], [81, [-49995.5, 257504.5, 398.87670000000003]]]), (10, 41, [[82, [-49995.5, 257504.5, 398.87670000000003]], [83, [-48415.5, 254624.5, 399.47649999999999]]]), (11, 42, [[84, [-49995.5, 257504.5, 398.87670000000003]], [85, [-48415.5, 254624.5, 399.47649999999999]]]), (11, 43, [[86, [-49995.5, 257504.5, 398.87670000000003]], [87, [-49255.5, 258014.5, 431.06569999999999]]]), (11, 44, [[88, [-49255.5, 258014.5, 431.06569999999999]], [89, [-48415.5, 254624.5, 399.47649999999999]]]), (12, 3, [[6, [-48415.5, 254624.5, 399.47649999999999]], [7, [-49995.5, 249994.5, 409.14229999999998]]]), (12, 7, [[14, [-49995.5, 249994.5, 409.14229999999998]], [15, [-49995.5, 254754.5, 402.4579]]]), (12, 9, [[18, [-48415.5, 254624.5, 399.47649999999999]], [19, [-49995.5, 254754.5, 402.4579]]]), (13, 22, [[44, [-45435.5, 254754.5, 408.15609999999998]], [45, [-47255.5, 254754.5, 408.16120000000001]]]), (13, 36, [[72, [-47255.5, 254754.5, 408.16120000000001]], [73, [-47255.5, 254764.5, 408.096]]]), (13, 39, [[78, [-45435.5, 254754.5, 408.15609999999998]], [79, [-47255.5, 254764.5, 408.096]]]), (14, 29, [[58, [-48415.5, 254624.5, 399.47649999999999]], [59, [-47265.5, 254764.5, 408.0222]]]), (14, 45, [[90, [-49255.5, 258014.5, 431.06569999999999]], [91, [-48415.5, 254624.5, 399.47649999999999]]]), (14, 47, [[94, [-47265.5, 254764.5, 408.0222]], [95, [-49255.5, 258014.5, 431.06569999999999]]]), (15, 1, [[2, [-46505.5, 249454.5, 423.92090000000002]], [3, [-49995.5, 249994.5, 409.14229999999998]]]), (15, 4, [[8, [-48415.5, 254624.5, 399.47649999999999]], [9, [-49995.5, 249994.5, 409.14229999999998]]]), (15, 6, [[12, [-46505.5, 249454.5, 423.92090000000002]], [13, [-48415.5, 254624.5, 399.47649999999999]]]), (16, 15, [[30, [-47265.5, 254754.5, 408.0419]], [31, [-47255.5, 254754.5, 408.16120000000001]]]), (16, 35, [[70, [-47255.5, 254764.5, 408.096]], [71, [-47265.5, 254754.5, 408.0419]]]), (16, 37, [[74, [-47255.5, 254754.5, 408.16120000000001]], [75, [-47255.5, 254764.5, 408.096]]]), (17, 21, [[42, [-47255.5, 254754.5, 408.16120000000001]], [43, [-44125.5, 251484.5, 453.01429999999999]]]), (17, 23, [[46, [-45435.5, 254754.5, 408.15609999999998]], [47, [-47255.5, 254754.5, 408.16120000000001]]]), (17, 24, [[48, [-45435.5, 254754.5, 408.15609999999998]], [49, [-44125.5, 251484.5, 453.01429999999999]]])]

jedes einzelne Listenelement ist folgendermaßen aufgebaut:

(FID_Dreieck, FID_Linie[[FID_Punkt1, [Koordinaten_Punkt1 X, Y, Z]], [FID_Punkt2, [Koordinaten_Punkt2 X, Y, Z]]])
jedes Dreieck besteht aus drei Linien, jede Linie aus 2 Punkten. Wenn jetzt die Koordinaten einer Linie von 2 unterschiedlichen Dreiecken gleich sind, so sind die beiden Dreiecke benachbart:

Code: Alles auswählen

            if Eintrag0[2][0][1]== Eintrag1[2][0][1] and Eintrag0[2][1][1]== Eintrag1[2][1][1] and Eintrag0[0] <> Eintrag1[0]:

@ ntrunk: Vielen Dank für deine Antwort!

Das deutsche Python-Forum

Durchlauf durch Liste und Vergleich der Einträge

Durchlauf durch Liste und Vergleich der Einträge

Re: Durchlauf durch Liste und Vergleich der Einträge

Re: Durchlauf durch Liste und Vergleich der Einträge

Re: Durchlauf durch Liste und Vergleich der Einträge

Re: Durchlauf durch Liste und Vergleich der Einträge

Re: Durchlauf durch Liste und Vergleich der Einträge

Re: Durchlauf durch Liste und Vergleich der Einträge

Re: Durchlauf durch Liste und Vergleich der Einträge

Re: Durchlauf durch Liste und Vergleich der Einträge

Re: Durchlauf durch Liste und Vergleich der Einträge

Re: Durchlauf durch Liste und Vergleich der Einträge

Re: Durchlauf durch Liste und Vergleich der Einträge

Re: Durchlauf durch Liste und Vergleich der Einträge

Re: Durchlauf durch Liste und Vergleich der Einträge

Re: Durchlauf durch Liste und Vergleich der Einträge

Re: Durchlauf durch Liste und Vergleich der Einträge

Re: Durchlauf durch Liste und Vergleich der Einträge

Re: Durchlauf durch Liste und Vergleich der Einträge

Re: Durchlauf durch Liste und Vergleich der Einträge

Re: Durchlauf durch Liste und Vergleich der Einträge