linkcad.libgraph

Hochleistungs-Engine für boolesche Geometrie auf Polygonen. Umhüllt die native Bibliothek libgraph.

from linkcad.v1.libgraph import (
    ShapeProcessor, ShapeGroup, Operation, FillRule, HolesMode, Result,
    boolean_and, boolean_or, boolean_xor, boolean_difference,
    succeeded, failed,
)

Hilfsfunktionen

Für einfache Operationen mit zwei Polygonen verwenden Sie diese Funktionen direkt. Jede nimmt Stützpunktlisten als Folgen von (x, y)-Tupeln entgegen und gibt eine Liste von Ergebnispolygonen zurück (jeweils eine Liste von (x, y)-Tupeln). Bei Fehlschlag lösen sie RuntimeError aus.

from linkcad.v1.libgraph import boolean_and, boolean_or, boolean_xor, boolean_difference

square   = [(0, 0), (10, 0), (10, 10), (0, 10)]
triangle = [(5, 5), (15, 5), (10, 15)]

result = boolean_and(square, triangle)          # intersection
result = boolean_or(square, triangle)           # union
result = boolean_xor(square, triangle)          # exclusive OR
result = boolean_difference(square, triangle)   # square minus triangle

Funktion	Beschreibung
`boolean_and(vtx1, vtx2, fill_rule=FillRule.EvenOdd)`	Schnittmenge zweier Polygone
`boolean_or(vtx1, vtx2, fill_rule=FillRule.EvenOdd)`	Vereinigung zweier Polygone
`boolean_xor(vtx1, vtx2, fill_rule=FillRule.EvenOdd)`	Symmetrische Differenz zweier Polygone
`boolean_difference(vtx1, vtx2, fill_rule=FillRule.EvenOdd)`	Differenz — Bereiche in `vtx1`, aber nicht in `vtx2`

Koordinaten sind ganze Zahlen. Wenn Ihre Geometrie in Datenbankeinheiten vorliegt, ist das bereits erfüllt.

ShapeProcessor

Für Operationen mit mehreren Polygonen oder wenn Sie Füllregel und Lochbehandlung steuern müssen, verwenden Sie ShapeProcessor:

from linkcad.v1.libgraph import (
    FillRule, HolesMode, Operation, ShapeGroup, ShapeProcessor, succeeded,
)

sp = ShapeProcessor()
sp.add_polygon(ShapeGroup.A, [(0, 0), (10, 0), (10, 10), (0, 10)])
sp.add_polygon(ShapeGroup.B, [(5, 5), (15, 5), (10, 15)])

result = sp.execute(Operation.And, FillRule.NonZero, HolesMode.Link)
if not succeeded(result):
    raise RuntimeError(f"Boolean failed: {result}")

polygons = []
while sp.has_next_polygon():
    poly = sp.get_next_polygon()
    if poly is None:
        break
    polygons.append(poly)

Eigenschaft / Methode	Beschreibung
`ShapeProcessor(granularity=1)`	Einen neuen Prozessor erzeugen
`sp.add_polygon(group, vertices, combine_with_previous=False)`	Ein Polygon zu Gruppe A, B oder AB hinzufügen. Gibt eine interne Form-ID zurück
`sp.execute(operation, fill_mode=FillRule.NonZero, hole_mode=HolesMode.Link, process_vertically=False)`	Die Operation ausführen; gibt ein `Result` zurück
`sp.has_next_polygon()`	Ob weitere Ergebnispolygone verfügbar sind
`sp.get_next_polygon()`	Nächstes Ergebnispolygon oder `None`, wenn erschöpft
`sp.get_next_hole()`	Nächstes Loch des aktuellen Polygons oder `None`. Nur mit `HolesMode.Extract` sinnvoll
`sp.clear()`	Alle Polygone verwerfen und für die Wiederverwendung vorbereiten
`sp.empty`	`True`, wenn der Prozessor keine Polygone enthält
`sp.set_license(license)`	Einen Lizenzschlüssel setzen; gibt `True` zurück, wenn er gültig ist

execute() gibt ein Result zurück; ein Attribut sp.result gibt es nicht. Prüfen Sie es mit den Hilfsfunktionen des Moduls:

Funktion	Beschreibung
`succeeded(result)`	`True` bei `SuccessModified` oder `SuccessNotModified`
`failed(result)`	`True` bei jedem Fehlerergebnis

Setzen Sie combine_with_previous=True bei add_polygon(), um einen Unterpfad — ein Loch oder eine zweite Kontur — an das unmittelbar zuvor hinzugefügte Polygon anzuhängen.

Enums

ShapeGroup

Bestimmt, zu welchem Operanden ein Polygon gehört.

Wert	Beschreibung
`ShapeGroup.A`	Erster Operand
`ShapeGroup.B`	Zweiter Operand
`ShapeGroup.AB`	Gehört gleichzeitig zu beiden Operanden

Operation

Die auszuführende boolesche Operation.

Wert	Beschreibung
`Operation.Or`	Vereinigung (A ∪ B)
`Operation.And`	Schnitt (A ∩ B)
`Operation.Xor`	Symmetrische Differenz (A △ B)
`Operation.AMinusB`	Differenz (A − B)
`Operation.BMinusA`	Differenz (B − A)
`Operation.SplitOnB`	Die Polygone in A entlang der Kontur von B teilen
`Operation.Noop`	Die Polygone in A vereinfachen, ohne sie zu kombinieren
`Operation.KeepInternalEdges`	Vereinigung unter Beibehaltung innerer Kanten
`Operation.OrNoMerge`	Vereinigung ohne Zusammenführen innerer Kanten
`Operation.AndNoMerge`	Schnitt ohne Zusammenführen innerer Kanten
`Operation.XorNoMerge`	XOR ohne Zusammenführen innerer Kanten
`Operation.AMinusBNoMerge`	A − B ohne Zusammenführen innerer Kanten
`Operation.BMinusANoMerge`	B − A ohne Zusammenführen innerer Kanten

FillRule

Bestimmt, wie überlappende Polygonkanten „innen“ und „außen“ festlegen.

Wert	Beschreibung
`FillRule.NonZero`	Non-Zero-Winding-Regel
`FillRule.EvenOdd`	Even-Odd-Regel (am schnellsten)
`FillRule.NonZeroGroup`	Non-Zero-Winding-Regel je Gruppe
`FillRule.EvenOddGroup`	Even-Odd-Regel je Gruppe
`FillRule.OuterGroup`	Nur den äußersten Bereich füllen

HolesMode

Bestimmt, wie Löcher in den Ausgabepolygonen dargestellt werden.

Wert	Beschreibung
`HolesMode.Extract`	Löcher separat über `get_next_hole()` zurückgeben
`HolesMode.Link`	Löcher mit der Außenkontur über Brücken der Breite null verbinden
`HolesMode.Split`	Das Ergebnis in einfache Polygone ohne Löcher zerlegen
`HolesMode.Keep`	Löcher als separate Polygone beibehalten

Result

Von ShapeProcessor.execute() zurückgegebener Status.

Wert	Beschreibung
`Result.SuccessModified`	Erfolgreich; die Geometrie hat sich geändert
`Result.SuccessNotModified`	Erfolgreich; die Geometrie lag bereits in der gewünschten Form vor
`Result.Failed`	Operation fehlgeschlagen
`Result.Cancelled`	Operation abgebrochen
`Result.NoLicense`	Ungültiger Lizenzschlüssel
`Result.InvalidFillRule`	Füllregel für diese Operation nicht zulässig
`Result.InvalidHolesMode`	Lochmodus für diese Operation nicht zulässig