linkcad.geom

Das Geometriemodul stellt 2D-Primitive für Koordinatenrechnung und Formbearbeitung bereit.

from linkcad.v1.geom import Point, Vector, Bounds, Transformation, Angle, Resolution

Koordinaten sind ganze Zahlen in Datenbankeinheiten. Point und Vector sind reine Wertetypen — keine Datenbankobjekte, sie lassen sich frei erzeugen.

Klassen

Point

Eine 2D-Koordinate.

from linkcad.v1.geom import Point

p = Point(1000, 2000)
print(p.x, p.y)
print(p[0], p[1])          # indexable, so a Point unpacks like a tuple

Eigenschaft / Methode	Beschreibung
`Point()` / `Point(x, y)`	Einen Punkt erzeugen
`x`, `y`	Koordinatenkomponenten; zuweisbar
`distance_to(other)`	Euklidischer Abstand
`equals(other, tolerance=1e-12)`	Gleichheit innerhalb einer Toleranz
`+`, `-`	Punktarithmetik
`*`, `/`	Mit einer ganzen Zahl skalieren
`==`, `!=`	Exakter Vergleich
`p[0]` / `p[1]`	Indexzugriff auf `x` und `y`

Überall, wo LinkCAD Stützpunkte akzeptiert, funktionieren auch einfache (x, y)-Tupel:

cell.add_polygon(layer, [(0, 0), (1000, 0), (1000, 1000)])
cell.add_polygon(layer, [Point(0, 0), Point(1000, 0), Point(1000, 1000)])

Vector

Eine 2D-Richtung oder ein Versatz.

from linkcad.v1.geom import Vector

v = Vector(100, 200)
print(v.length)

Eigenschaft / Methode	Beschreibung
`Vector()` / `Vector(x, y)`	Einen Vektor erzeugen
`x`, `y`	Vektorkomponenten; zuweisbar
`length`	Betrag des Vektors
`normalize()`	An Ort und Stelle auf Einheitslänge bringen
`+`, `-`	Vektorarithmetik
`*`, `/`	Multiplikation und Division mit einem Skalar

Transformation

Eine 2D-Transformation: gleichmäßige Skalierung, Drehung und Verschiebung. Erzeugen Sie eine und setzen Sie sie dann an Ort und Stelle zusammen — die verändernden Methoden geben die Transformation selbst zurück und lassen sich daher verketten.

from linkcad.v1.geom import Transformation

xform = Transformation()
xform.rotate(45.0).translate(1000, 2000)

print(xform.rotation.degrees, xform.translation.x, xform.translation.y)

Die Reihenfolge zählt. rotate() dreht auch einen bereits gesetzten Versatz mit; drehen Sie also zuerst und verschieben Sie danach, wenn der Versatz die endgültige Position sein soll.

Methode / Eigenschaft	Beschreibung
`Transformation()`	Identitätstransformation
`Transformation(scale, rotation, offset)`	Aus Skalierungsfaktor, `Angle` und `Vector` erzeugen
`translate(dx, dy)`	Eine Verschiebung hinzufügen. Koordinaten werden auf Datenbank-Ganzzahlen gerundet
`rotate(degrees)`	Eine Drehung in Grad hinzufügen
`scale(factor)`	Gleichmäßige Skalierung hinzufügen
`scaling`	Skalierungsfaktor; zuweisbar
`rotation`	Dreh-`Angle` (schreibgeschützt)
`translation`	Verschiebungs-`Vector` (schreibgeschützt)
`inverse`	Die inverse Transformation
`is_identity`	`True`, wenn die Transformation nichts bewirkt
`transform_point(point)`	Die Transformation auf einen `Point` anwenden; liefert einen `Point`

transform_point() nimmt einen Datenbank-Point entgegen und liefert einen zurück, das Ergebnis lässt sich also direkt an cell.add_polygon() weiterreichen:

from linkcad.v1.geom import Point, Transformation

xform = Transformation()
xform.rotate(90.0).translate(1000, 2000)

moved = [xform.transform_point(Point(x, y)) for x, y in [(0, 0), (100, 0), (100, 100)]]
cell.add_polygon(layer, moved)

Bounds

Ein achsparalleler Begrenzungsrahmen. cell.bounds und cell_object.bounds liefern einen.

b = cell.bounds
if not b.empty:
    print(b.min_x, b.min_y, b.width, b.height)

Eigenschaft / Methode	Beschreibung
`Bounds()` / `Bounds(min_pt, max_pt)`	Einen leeren Rahmen erzeugen oder einen aus zwei `Point`s
`min_xy` / `max_xy`	Eckpunkte
`min_x` / `max_x` / `min_y` / `max_y`	Einzelne Kanten
`width` / `height`	Abmessungen
`center`	Mittelpunkt
`empty`	`True`, wenn der Rahmen nichts enthält
`contains(point, tolerance=0)`	Test, ob ein Punkt enthalten ist
`overlaps(other)`	Überlappungstest

Jede Messgröße an Bounds ist ein Substantiv und daher eine Eigenschaft. Dies war die einzige Stelle der API, an der die Bindung die C++-Schreibweise durchscheinen ließ — minXY(), maxX() —, und das tut sie nicht mehr.

Angle

Ein Winkelwert, überall dort verwendet, wo LinkCAD eine Winkelgröße annimmt oder zurückgibt.

from linkcad.v1.geom import Angle

a = Angle.from_degrees(45.0)
b = Angle.from_radians(0.785398)
print(a.degrees, a.radians)

Factory / Eigenschaft / Methode	Beschreibung
`Angle()`	Nullwinkel
`Angle.from_degrees(degrees)`	Aus Grad erzeugen
`Angle.from_radians(radians)`	Aus Bogenmaß erzeugen
`angle.degrees`	Wert in Grad
`angle.radians`	Wert im Bogenmaß
`angle.equals(other, tolerance_radians=1e-12)`	Vergleich innerhalb einer Toleranz
`Angle.zero` / `Angle.pi_half` / `Angle.pi` / `Angle.two_pi`	Konstanten für 0°, 90°, 180° und 360°

Resolution

Steuert, wie gekrümmte Formen (Kreise, Kreisbögen, Ellipsen, NURBS) bei Operationen wie Zusammenführen oder Auflösen in Polygonstützpunkte tesseliert werden.

from linkcad.v1.geom import Resolution

res = Resolution()
res.minimum_facets = 32   # at least 32 segments per full circle
res.maximum_error = 1     # max deviation in database units

print(res.segment_count(10_000))

Eigenschaft / Methode	Beschreibung
`Resolution()` / `Resolution(min_facets=0, error_max=...)`	Erzeugen
`minimum_facets`	Mindestanzahl der Polygonsegmente pro Vollkreis; zuweisbar
`maximum_error`	Maximal zulässige Abweichung von der echten Kurve, in Datenbankeinheiten; zuweisbar
`segment_count(diameter)`	In wie viele Segmente ein Kreis dieses Durchmessers zerlegt würde