linkcad.db

Das Datenbankmodul bietet Zugriff auf die In-Memory-Zeichnungsdatenbank von LinkCAD. Alle Datenbankobjekte werden aus Performance-Gründen von nativen Implementierungen getragen.

Verwenden Sie in Skripten und Plugins den stabilen Namensraum linkcad.v1.db. Er spiegelt den gesamten öffentlichen Namensraum von linkcad.db, es sind also dieselben Objekte.

from linkcad.v1 import db

with db.Drawing("scratch") as dwg:
    cell = dwg.add_cell("TOP")

Oder importieren Sie die Namen, die Sie verwenden:

from linkcad.v1.db import (
    Drawing, Cell, Layer, Object, DrawingObject, CellObject, Shape,
    Polygon, Polyline, Arc, Ellipse, Donut, Nurbs, Text, Ref,
    Color, Property, ReadLock, WriteLock, Transaction,
    Unit, ObjectType, CellContext, EndCap, FillRule,
    BooleanOperation, MergeLayerPolarityResult, TextStyle, TextStyleMask,
)

Regeln vorab

Die API folgt durchgehend denselben Konventionen — in diesem Modul und in jedem anderen. Wer sie kennt, muss selten etwas nachschlagen:

Ein Substantiv ist eine Eigenschaft, ein Verb ist eine Methode. shape.area, cell.shapes, polygon.vertices, arc.radius, obj.bounds, obj.selected — ohne Klammern. destroy(), clone(), rotate(), reverse(), toggle_selection() behalten ihre.
Ein Getter/Setter-Paar ist eine schreib- und lesbare Eigenschaft, niemals zwei Namen. Weisen Sie zu, statt einen Setter aufzurufen: arc.center = Point(0, 0), layer.enabled = False, obj.selected = True. Auf Geometrie gibt es keine set_*-Methoden.
Geometrie wird von dem Objekt erzeugt, dem sie gehören wird. Eine Zeichnung erzeugt Zellen und Ebenen (drawing.add_cell, drawing.add_layer), eine Zelle erzeugt Formen (cell.add_polygon, cell.add_arc, cell.add_ref, …). Es gibt weder freistehende Konstruktoren noch statische Fabrikmethoden.
Wenn ein Zugriff Parameter braucht, deckt die Eigenschaft den Normalfall ab und eine filtered_*-Methode den Rest — cell.shapes sind alle Formen, cell.filtered_shapes(selected_only=True) schränkt ein.

Zwei weitere Konventionen ersparen an jeder Aufrufstelle eine Umwandlung:

Eine Koordinate ist ein Point oder ein (x, y)-Paar, beliebig gemischt, überall dort, wo linkcad.db eine entgegennimmt — in Stützpunktfolgen, bei add_arc(center=…), add_text(position=…), text.position = ….
Eine Ebene ist eine Layer, ein Ebenenname oder None. obj.layer = "METAL1" verschiebt das Objekt auf diese Ebene und erzeugt sie, falls sie nicht existiert; obj.layer = None verschiebt es auf die Standardebene.

Klassen

Drawing

Der Container der obersten Ebene für alle Layoutdaten.

Eine Zeichnung hält die gesamte Datenbank im Speicher und muss deterministisch freigegeben werden — überlebt eine bis zum Beenden des Interpreters, stürzt der Prozess ab. Als Kontextmanager verwendet, kann das nicht vergessen werden:

from linkcad.v1.db import Drawing

with Drawing("scratch") as dwg:
    cell = dwg.add_cell("TOP")
    dwg.main_cell = cell
    metal = dwg.add_layer("METAL1")
    cell.add_polygon(metal, [(0, 0), (10_000, 0), (10_000, 10_000), (0, 10_000)])

Innerhalb eines Tool-Plugins wird die Zeichnung an run() übergeben und gehört der Anwendung — zerstören Sie sie dort nicht.

Eigenschaft / Methode	Beschreibung
`Drawing(name="")`	Zeichnung erzeugen. Ohne `name` vergibt LinkCAD einen eindeutigen Namen
`with Drawing(...) as dwg:`	Empfohlene Form; gibt die Datenbank beim Verlassen frei
`drawing.name`	Zeichnungsname
`drawing.units`	Datenbankeinheiten pro Meter, als Fließkommazahl (z. B. `1e9` für eine Nanometer-Datenbank). `0.0` bedeutet, dass die Zeichnung ihre Einheiten nicht deklariert. Eine Zuweisung löst `RuntimeError` aus, sobald die Datenbank etwas enthält — setzen Sie den Wert also zuerst
`drawing.main_cell`	Hauptzelle (Top-Zelle) lesen oder setzen
`drawing.cells`	Alle Zellen, als Liste
`drawing.layers`	Alle Ebenen, als Liste
`drawing.cell(name)`	Zelle nach Namen suchen; `None`, wenn nicht gefunden
`drawing.layer(name)`	Ebene nach Namen suchen; `None`, wenn nicht gefunden
`drawing.add_cell(name)`	Zelle hinzufügen oder die bestehende dieses Namens zurückgeben
`drawing.add_layer(name)`	Ebene hinzufügen oder die bestehende dieses Namens zurückgeben
`drawing.modif_time` / `drawing.access_time`	Zeitstempel in Unix-Sekunden
`drawing.undo_enabled`	Aufzeichnung für Rückgängig aktivieren oder deaktivieren
`drawing.begin_undo_marker(tag=0)` / `drawing.end_undo_marker()`	Eine rückgängig machbare Transaktion manuell klammern
`drawing.undo()` / `drawing.redo()`	Die letzte Transaktion rückgängig machen oder wiederholen
`drawing.can_undo` / `drawing.can_redo`	Tupel `(verfügbar, tag)`
`drawing.destroy_layer_by_name(name)`	Ebene nach Namen löschen; `True`, wenn sie existierte
`drawing.rename_layer(from_name, to_name)`	Ebene umbenennen; `True` bei Erfolg
`drawing.boolean_layers_by_name(op, result_layer, operand_layer, maximum_error=100, minimum_facets=16)`	Boolesche Operation zweier Ebenen anhand ihrer Namen; `result_layer` ist Operand A und nimmt das Ergebnis auf
`drawing.merge_layer_polarity_group(group_name, maximum_error=100, minimum_facets=16, progress_from=0, progress_to=100)`	Eine Ebenengruppe mit aufgeschobener Polarität zusammenführen
`drawing.merge_all_polarity_groups(maximum_error=100, minimum_facets=16, progress_from=0, progress_to=100)`	Alle Ebenengruppen mit aufgeschobener Polarität zusammenführen
`drawing.destroy()`	Die Zeichnung und ihren Inhalt zerstören
`drawing.memory_usage`	Speicherverbrauch der nativen Datenbank in Bytes
`drawing.locked`	`True`, wenn irgendein Thread eine Sperre auf der Datenbank hält
`drawing.locked_by_this_thread`	`True`, wenn der aufrufende Thread die Schreibsperre hält

Die letzten drei lesen prozessweiten Zustand und lassen sich daher sowohl über die Klasse als auch über eine Instanz abfragen: Drawing.memory_usage und dwg.memory_usage liefern dieselbe Zahl.

Ebenen-Hilfsmethoden, die die Zeichnung verändern, erzeugen ihre eigene rückgängig machbare Transaktion.

from linkcad.v1.db import BooleanOperation, Drawing, MergeLayerPolarityResult

with Drawing("example") as dwg:
    ok = dwg.boolean_layers_by_name(
        BooleanOperation.Or,
        result_layer="metal",
        operand_layer="vias",
    )

    result = dwg.merge_all_polarity_groups()
    if result != MergeLayerPolarityResult.Success:
        raise RuntimeError("Polarity merge failed")

Vergleichen Sie Enum-Werte mit ==, nicht mit is. Die Bindings liefern bei jedem Lesen ein frisches Python-Objekt, sodass result is MergeLayerPolarityResult.Success selbst nach einer erfolgreichen Zusammenführung False ergibt.

drawing.units gibt an, wie viele Datenbankeinheiten einen Meter ergeben — genau das brauchen Sie, um eine physikalische Größe in die ganzen Zahlen umzurechnen, die die Datenbank speichert:

units_per_meter = drawing.units
if units_per_meter <= 0.0:
    raise ValueError("This drawing does not declare its database units")

seven_microns = 7.0 * 1e-6 * units_per_meter

Plugins haben es einfacher: benennen Sie eine Arbeitseinheit am DrawingContext oder WriterContext, und LinkCAD rechnet für Sie um. Siehe linkcad.plugin.

Cell

Ein benannter Container für Formen und Zellenreferenzen. Zellen stammen von der Zeichnung, der sie gehören:

cell = drawing.add_cell("TOP")       # creates, or returns the existing "TOP"
cell = drawing.cell("TOP")           # looks up; None if not found

Geometrie erzeugen

Jeder Formtyp folgt demselben Muster: add_<etwas>(layer, …) und gibt das neue Objekt zurück.

Koordinaten sind Point-Objekte oder einfache (x, y)-Tupel, beliebig gemischt — sowohl in einer Stützpunktfolge als auch als einzelne Koordinate wie das center eines Kreisbogens, Kreises oder Rings oder die position eines Textes. Ein Paar besteht aus genau zwei Koordinaten; alles andere wird abgelehnt statt abgeschnitten.

Methode	Beschreibung
`cell.add_polygon(layer, vertices)`	Geschlossenes Polygon hinzufügen
`cell.add_polyline(layer, vertices, width=0, closed=False, end_cap=EndCap.Round)`	Polylinie hinzufügen
`cell.add_arc(layer, center, radius, width=0, start_angle=None, end_angle=None)`	Kreisbogen hinzufügen, gegen den Uhrzeigersinn gezeichnet, wenn `start_angle <= end_angle`. Ohne Winkelangaben entsteht ein vollständiger Kreisumriss
`cell.add_circle(layer, center, diameter)`	Gefüllten Kreis hinzufügen
`cell.add_donut(layer, center, mean_diameter, width)`	Ring hinzufügen; `mean_diameter` ist `(außen + innen) / 2`
`cell.add_text(layer, content, position, height=1.0, font="")`	Textform hinzufügen
`cell.add_nurbs(layer, control_points, degree, knots, width=0, weights=None, periodic=False)`	NURBS-Kurve hinzufügen; der Grad muss 1, 2, 3 oder 5 sein
`cell.add_ref(cell, transformation=None, columns=1, rows=1, column_spacing=0, row_spacing=0, layer=None)`	Eine andere Zelle hier platzieren. Für eine Anordnung `columns`/`rows` über 1 setzen

from linkcad.v1.db import Drawing, EndCap
from linkcad.v1.geom import Angle, Point, Transformation

with Drawing("shapes") as dwg:
    top = dwg.add_cell("TOP")
    dwg.main_cell = top
    metal = dwg.add_layer("METAL1")

    top.add_polygon(metal, [(0, 0), (1000, 0), (1000, 1000), (0, 1000)])
    top.add_polyline(metal, [(0, 0), (2000, 2000)], width=100, end_cap=EndCap.SquareFlat)
    top.add_arc(metal, Point(5000, 0), radius=1000, width=50,
                start_angle=Angle.from_degrees(0), end_angle=Angle.from_degrees(90))
    top.add_circle(metal, Point(0, 5000), diameter=800)
    top.add_donut(metal, Point(3000, 5000), mean_diameter=800, width=100)
    top.add_text(metal, "TOP", Point(0, 8000), height=500)

    stamp = dwg.add_cell("STAMP")
    stamp.add_circle(metal, Point(0, 0), diameter=200)
    top.add_ref(stamp, Transformation().translate(10_000, 0), columns=4, rows=2,
                column_spacing=1000, row_spacing=1000)

Eine Zelle untersuchen

Eigenschaft / Methode	Beschreibung
`cell.name`	Zellenname
`cell.shapes`	Jede Form der Zelle, jeweils als ihr tatsächlicher Typ (`Polygon`, `Polyline`, …)
`cell.filtered_shapes(selected_only=False)`	Formen, eingeschränkt. `shapes` ist dies mit den Standardwerten
`cell.cell_objects`	Alles, was die Zelle enthält, einschließlich `Ref`-Objekten, jeweils als tatsächlicher Typ
`cell.filtered_cell_objects(selected_only=False)`	Zellenobjekte, eingeschränkt
`cell.bounds`	Begrenzungsrahmen von allem in dieser Zelle und ihren Unterzellen
`cell.filtered_bounds(layer=None)`	Begrenzungsrahmen, auf eine Ebene eingeschränkt
`cell.nesting_level`	Höchste Verschachtelungstiefe (0 für die Top-Zelle)
`cell.child_levels`	Anzahl der Ebenen unterhalb dieser Zelle
`cell.enabled`	`True`, wenn die Zelle in irgendeinem Kontext aktiviert ist
`cell.enabled_in_context(context_cell)`	Ob die Zelle innerhalb einer anderen Zelle aktiviert ist
`cell.enable(enabled=True, context_cell=None, context=CellContext.Descend)`	Zelle aktivieren oder deaktivieren
`cell.uses_layer(layer, context=CellContext.Descend, enabled_only=False)`	Ob die Zelle etwas auf einer Ebene enthält
`cell.first_shape_layer`	Erste von einer enthaltenen Form verwendete Ebene
`cell.selected_count`	Anzahl der ausgewählten Zellenobjekte
`cell.first_selected`	Erstes ausgewähltes Zellenobjekt oder `None`
`cell.modif_time` / `cell.access_time`	Zeitstempel in Unix-Sekunden
`cell.clone(name)`	Die Zelle unter neuem Namen kopieren

Da cell_objects die tatsächlichen Typen zurückgibt, funktioniert isinstance erwartungsgemäß:

from linkcad.v1 import db

for obj in cell.cell_objects:
    if isinstance(obj, db.Ref):
        print(f"reference to {obj.ref_cell.name}")
    elif isinstance(obj, db.Polygon):
        print(f"polygon with {obj.vertex_count} vertices")

Layer

Eine benannte Ebene mit Anzeigeeigenschaften. Ebenen stammen von der Zeichnung:

metal = drawing.add_layer("METAL1")   # creates, or returns the existing layer
metal = drawing.layer("METAL1")       # looks up; None if not found

Eigenschaft / Methode	Beschreibung
`layer.name`	Ebenenname
`layer.color`	Ebenenfarbe als gepackter RGBA-`int`
`layer.enabled`	Ob die Ebene aktiviert ist; zuweisbar
`layer.hidden`	Ob die Ebene ausgeblendet ist; zuweisbar
`layer.used`	`True`, wenn eine aktivierte Zelle etwas auf der Ebene ablegt
`layer.move_before(other_layer=None)`	Innerhalb der Ebenenliste umsortieren
`layer.clone(drawing, name)`	Ebene kopieren, optional in eine andere Zeichnung. Beide Argumente sind auch als Schlüsselwörter zulässig, wobei `drawing=None` diese Zeichnung meint
`layer.destroy()`	Ebene zerstören

Es gibt keine statischen Fabrikmethoden: drawing.add_layer() erzeugt eine Ebene und drawing.layer() schlägt eine nach.

Object

Basisklasse für jedes Datenbankobjekt.

Eigenschaft / Methode	Beschreibung
`obj.id`	Objekt-ID
`obj.valid`	`False`, sobald das Objekt zerstört wurde
`obj.dynamic_type`	Der tatsächliche Typ des Objekts, als `ObjectType`
`obj.drawing`	Die `Drawing`, zu der dieses Objekt gehört
`obj.destroy()`	Objekt entfernen und zerstören. Danach ist es ungültig

DrawingObject (Basis von Layer und Cell) ergänzt nichts über Object hinaus.

CellObject

Basisklasse für alles, was in einer Zelle lebt — alle Formen und Ref.

Eigenschaft / Methode	Beschreibung
`obj.owning_cell`	Die `Cell`, die dieses Objekt enthält
`obj.bounds`	Begrenzungsrahmen (`Bounds`)
`obj.layer`	Die `Layer` des Objekts; zuweisbar
`obj.layer_name`	Ebenenname
`obj.selected`	Auswahlzustand; zuweisbar
`obj.toggle_selection()`	Auswahlzustand umschalten

layer ist auf jedem Zellobjekt schreib- und lesbar, Ref eingeschlossen, und nimmt eine Layer, einen Ebenennamen oder None entgegen:

obj.layer = drawing.layer("METAL1")   # a Layer
obj.layer = "METAL2"                  # by name; created if it does not exist
obj.layer = None                      # the default layer

toggle_selection() übersteht die Getter/Setter-Regel, weil es nicht selected = not selected ist: das wären ein Lesen und ein Schreiben unter zwei getrennten Sperren, und die Datenbank bietet das Umschalten als eine einzige Operation an.

Shape

Basisklasse für geometrische Formen: Polygone, Polylinien, Kreisbögen, Ellipsen, Ringe, NURBS und Text. Erweitert CellObject.

Eigenschaft / Methode	Beschreibung
`shape.closed`	`True`, wenn die Form geschlossen ist
`shape.width`	Leiterbahnbreite in Datenbankeinheiten (0 bei gefüllten Formen)
`shape.area`	Eingeschlossene Fläche, in quadratischen Datenbankeinheiten
`shape.equivalent_to(other, ignore_sense=True)`	Zwei Formen auf Gleichwertigkeit prüfen
`shape.layer` / `shape.bounds`	Von `CellObject` geerbt; `layer` ist dort schreib- und lesbar
`shape.destroy()`	Diese Form entfernen und zerstören

vertices gehört nicht zu Shape: nur Polygon, Polyline und Nurbs besitzen es. Kurven — Kreisbögen, Kreise, Ringe — werden über Mittelpunkt und Radius beschrieben und vom Host bei Bedarf tesseliert.

total = sum(shape.area for shape in cell.shapes if shape.closed)
print(f"filled area: {total}")

Polygon

Eine geschlossene gefüllte Form. Erweitert Shape. Wird mit cell.add_polygon(layer, vertices) erzeugt.

Eigenschaft / Methode	Beschreibung
`polygon.vertices`	Stützpunkte als Liste von `Point`. Zuweisbar sind `Point`-Objekte oder `(x, y)`-Tupel
`polygon.vertex_count`	Anzahl der Stützpunkte
`polygon.head` / `polygon.tail`	Erster und letzter Stützpunkt
`polygon.is_box`	`True`, wenn das Polygon ein achsparalleles Rechteck ist
`polygon.is_self_intersecting`	`True`, wenn sich der Umriss selbst kreuzt
`polygon.has_bulges`	`True`, wenn eine Kante eine Wölbung ungleich null trägt
`polygon.add_vertex(point)`	Einen Stützpunkt anhängen
`polygon.add_vertices(points)`	Mehrere Stützpunkte anhängen

poly = cell.add_polygon(layer, [(0, 0), (1000, 0), (1000, 1000)])
poly.add_vertex((0, 1000))
poly.vertices = [(p.x * 2, p.y * 2) for p in poly.vertices]

Polyline

Ein offener oder geschlossener Pfad mit optionaler Breite. Erweitert Shape. Wird mit cell.add_polyline(...) erzeugt.

Eigenschaft / Methode	Beschreibung
`polyline.vertices`	Stützpunkte als Liste von `Point`; zuweisbar
`polyline.vertex_count`	Anzahl der Stützpunkte
`polyline.head` / `polyline.tail`	Erster und letzter Stützpunkt
`polyline.width`	Pfadbreite in Datenbankeinheiten
`polyline.closed`	Ob der Pfad geschlossen ist
`polyline.end_cap_style`	`EndCap`-Wert
`polyline.add_vertex(point)` / `polyline.add_vertices(points)`	Stützpunkte anhängen
`polyline.reverse()`	Reihenfolge der Stützpunkte umkehren

Arc

Ein Kreisbogen. Erweitert Shape. Wird mit cell.add_arc(...) erzeugt.

from linkcad.v1.geom import Angle, Point

arc = cell.add_arc(
    layer,
    center=Point(0, 0),
    radius=10_000,
    width=500,
    start_angle=Angle.from_degrees(0),
    end_angle=Angle.from_degrees(90),
)

arc.center = Point(1000, 1000)
arc.radius = 12_000

Eigenschaft	Beschreibung
`arc.center`	Mittelpunkt; zuweisbar
`arc.radius`	Radius in Datenbankeinheiten; zuweisbar
`arc.width`	Strichbreite in Datenbankeinheiten; zuweisbar
`arc.start_angle`	Startwinkel als `Angle`, gegen den Uhrzeigersinn von der x-Achse gemessen
`arc.end_angle`	Endwinkel als `Angle`

Ellipse

Ein Kreisprimitiv. Erweitert Shape. Wird mit cell.add_circle(layer, center, diameter) erzeugt.

Eigenschaft	Beschreibung
`ellipse.center`	Mittelpunkt; zuweisbar
`ellipse.diameter`	Durchmesser in Datenbankeinheiten; zuweisbar
`ellipse.radius`	Radius, halber Durchmesser (schreibgeschützt)

Donut

Ein Ring-/Kreisring-Primitiv. Erweitert Shape. Wird mit cell.add_donut(layer, center, mean_diameter, width) erzeugt.

Eigenschaft	Beschreibung
`donut.center`	Mittelpunkt; zuweisbar
`donut.mean_diameter`	Mittlerer Durchmesser, `(außen + innen) / 2`; zuweisbar
`donut.width`	Ringbreite; zuweisbar
`donut.outer_diameter` / `donut.inner_diameter`	Abgeleitete Durchmesser (schreibgeschützt)
`donut.mean_radius` / `donut.outer_radius` / `donut.inner_radius`	Abgeleitete Radien (schreibgeschützt)

Nurbs

Eine nicht-uniforme B-Spline-Kurve. Erweitert Shape. Wird mit cell.add_nurbs(...) erzeugt.

from linkcad.v1.geom import Point

nurbs = cell.add_nurbs(
    layer,
    control_points=[Point(0, 0), Point(10, 20), Point(20, 20), Point(30, 0)],
    degree=3,
    knots=[0.0, 0.0, 0.0, 0.0, 1.0, 1.0, 1.0, 1.0],
    width=5,
)

Eigenschaft / Methode	Beschreibung
`nurbs.width`	Strichbreite; zuweisbar
`nurbs.degree`	Grad der Kurve
`nurbs.knots` / `nurbs.knot_count`	Knotenvektor und Anzahl
`nurbs.vertices` / `nurbs.control_points`	Kontrollpunkte als `Point`-Objekte (beide Namen sind gleichwertig)
`nurbs.control_point_count`	Anzahl der Kontrollpunkte
`nurbs.weights`	Gewichtungsvektor
`nurbs.rational`	`True`, wenn Gewichtungen vorhanden sind
`nurbs.periodic`	`True`, wenn die Kurve periodisch/geschlossen ist; zuweisbar

Text

Formatierte Textgeometrie. Erweitert Shape. Wird mit cell.add_text(...) erzeugt.

from linkcad.v1.geom import Angle, Point

label = cell.add_text(
    layer,
    content="Hello LinkCAD",
    position=Point(100, 200),
    height=12.5,
    font="simplex.shx",
)

label.content = "Goodbye"
label.rotate(Angle.from_degrees(90))

Eigenschaft / Methode	Beschreibung
`text.content`	Formatierter Textinhalt; zuweisbar. `text.text` ist ein Alias
`text.font`	Schriftname; zuweisbar
`text.position`	Ankerpunkt; zuweisbar
`text.height`	Texthöhe; zuweisbar
`text.line_spacing`	Zeilenabstand; zuweisbar
`text.box_width`	Umbruchbreite; zuweisbar
`text.rotation`	Rotations-`Angle`. Eine Zuweisung dreht relativ zu einer umschließenden Referenz
`text.rotate(angle, absolute=False)`	Drehen; mit `absolute=True` werden Drehungen umschließender Referenzen ignoriert
`text.width_factor`	Horizontale Skalierung; zuweisbar
`text.stroke_width`	Strichbreite; zuweisbar
`Text.escape(content)`	Reinen Text für die formatierte Textspeicherung maskieren

Ref

Eine platzierte Instanz einer anderen Zelle mit zugehöriger Transformation. Erweitert CellObject. Wird mit cell.add_ref(...) erzeugt.

from linkcad.v1.geom import Transformation

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

ref = parent_cell.add_ref(child_cell, xform)
ref.columns = 4
ref.column_spacing = 5000

Eigenschaft / Methode	Beschreibung
`ref.ref_cell`	Die referenzierte `Cell`; zuweisbar
`ref.transformation`	Platzierungs-`Transformation` (gilt für die gesamte Anordnung); zuweisbar
`ref.columns` / `ref.rows`	Größe der Anordnung; 1 bedeutet eine einzelne Instanz
`ref.column_spacing` / `ref.row_spacing`	Raster der Anordnung in Datenbankeinheiten
`ref.apply_transformation(transformation)`	Eine zusätzliche Transformation anwenden
`ref.clone(cell=None, transformation=None)`	Die Referenz kopieren, optional in eine andere Zelle
`ref.destroy()`	Diese Referenz entfernen und zerstören

cell.add_ref() löst ValueError aus, statt etwas Unbrauchbares zurückzugeben: bei einer zirkulären Hierarchie — eine Zelle in einem ihrer eigenen Nachfahren zu platzieren — und bei einer fehlenden Zielzelle, was früher eine Referenz ins Leere erzeugte. Fangen Sie die Ausnahme ab, wenn die Zellen aus Benutzereingaben stammen:

try:
    ref = parent_cell.add_ref(child_cell, xform)
except ValueError as exc:
    print(f"cannot place '{child_cell.name}': {exc}")

Color

Ein RGB-Farbwert.

Eigenschaft / Methode	Beschreibung
`Color()` / `Color(red, green, blue)`	Eine Farbe erzeugen
`color.red` / `color.green` / `color.blue`	Kanäle (0-255); zuweisbar

layer.color ist eine gepackte RGBA-Ganzzahl und kein Color; verwenden Sie Color, wo eine API danach fragt.

Property

Eine benannte Eigenschaft, die an ein Datenbankobjekt gehängt ist.

Eigenschaft / Methode	Beschreibung
`prop.owner_type`	Typ des Objekts, an dem die Eigenschaft hängt, als `ObjectType`
`prop.destroy()`	Die Eigenschaft zerstören
`Property.properties(drawing, holding_type)`	Eigenschaftsnamen für einen Objekttyp auflisten
`Property.lookup_type(drawing, name, holding_type)`	Typ einer Eigenschaft anhand ihres Namens nachschlagen

from linkcad.v1.db import ObjectType, Property

for name in Property.properties(drawing, ObjectType.Cell):
    print(name, Property.lookup_type(drawing, name, ObjectType.Cell))

Enums

ObjectType

Der konkrete Typ eines Datenbankobjekts, geliefert von obj.dynamic_type und prop.owner_type und entgegengenommen von den Klassenmethoden von Property.

Gruppe	Werte
Container	`Drawing`, `Layer`, `Cell`
Zellobjekte	`Ref`, `Arc`, `Polygon`, `Polyline`, `Donut`, `Text`, `Ellipse`, `Nurbs`
Basisklassen	`Object`, `DrawingObject`, `CellObject`, `Shape`, `Property`
Eigenschaften	`BooleanProperty`, `IntegerProperty`, `RealProperty`, `StringProperty`, jeweils zusätzlich in einer `Drawing…`- / `Cell…`- / `CellObject…`- / `Layer…`-Form
Platzhalter	`Invalid`

CellContext

Steuert, ob eine Operation in Unterzellen absteigt.

Wert	Beschreibung
`CellContext.Descend`	Unterzellen einbeziehen
`CellContext.DontDescend`	Nur diese Zelle

Unit

Benannte Maßeinheiten, verwendet von einheitenbewussten APIs und Optionsdialogen.

Wert	Beschreibung
`Unit.Picometer`, `Unit.Nanometer`, `Unit.Micron`, `Unit.Millimeter`, `Unit.Centimeter`, `Unit.Meter`	Metrische Einheiten
`Unit.Mil`, `Unit.Inch`, `Unit.Feet`	Imperiale Einheiten
`Unit.Point`	Typografischer Punkt (1/72 Zoll)
`Unit.Database`	Datenbankeinheiten (Pikometer)
`Unit.DotsPerInch`, `Unit.Facets`	Auflösungs- und Zähl-„Einheiten“ für Optionsdialoge

Es gibt außerdem ein Mitglied für „keine Einheit“; weil None ein Python-Schlüsselwort ist, erreicht man es nur als getattr(Unit, "None").

drawing.units liefert kein Unit. Es ist eine Fließkommazahl mit Datenbankeinheiten pro Meter — siehe Drawing.

EndCap

Linienende-Stil für Polylinien. Wird auch aus linkcad.v1.plugin re-exportiert.

Wert	Beschreibung
`EndCap.Round`	Rundes Ende
`EndCap.SquareExtended`	Rechteckiges Ende, über den Endpunkt hinaus verlängert
`EndCap.SquareFlat`	Rechteckiges Ende, das am Endpunkt abschließt

FillRule

Füllregel für Polygone. Wird für Writer-APIs auch aus linkcad.v1.plugin re-exportiert.

Wert	Beschreibung
`FillRule.NonZero`	Non-Zero-Winding-Regel
`FillRule.EvenOdd`	Even-Odd-Füllregel

BooleanOperation

Boolesche Operation auf Ebenenniveau für drawing.boolean_layers_by_name().

Wert	Beschreibung
`BooleanOperation.Or`	Operandenebene mit der Ergebnisebene vereinigen
`BooleanOperation.AMinusB`	Operandenebene von der Ergebnisebene abziehen

MergeLayerPolarityResult

Ergebnis der Hilfsfunktionen zum Zusammenführen aufgeschobener Polarität.

Wert	Beschreibung
`MergeLayerPolarityResult.Success`	Zusammenführung erfolgreich abgeschlossen
`MergeLayerPolarityResult.Failure`	Zusammenführung fehlgeschlagen

TextStyle und TextStyleMask

TextStyle enthält Bit-Flags für Textausrichtung, Orientierung und Zeilenabstand. TextStyleMask wählt aus, welche Gruppen von Stil-Bits DrawingBuilder.set_text_style() ändert.

Enum	Häufige Werte
`TextStyle`	`Default`, `AlignHLeft`, `AlignHCenter`, `AlignHRight`, `AlignVBaseline`, `AlignVBottom`, `AlignVMiddle`, `AlignVMiddleAscent`, `AlignVTop`, `OrientH`, `OrientV`, `LineSpacingExact`, `LineSpacingCompact`
`TextStyleMask`	`None_`, `AlignH`, `AlignV`, `Orient`, `LineSpacing`

Sperren

Welche Sperre nötig ist, hängt vom Ausführungskontext ab.

Plugin-Kontext (`@tool`, `@format_reader`, `@format_writer`)

Das Framework hält die passende Sperre, bevor es run(), read() oder write() aufruft. Für Leseoperationen ist keine explizite Sperre nötig. Schreiboperationen, die rückgängig machbar sein sollen, brauchen eine Transaction:

from linkcad.v1.db import Transaction

def run(self, drawing):
    for cell in drawing.cells:
        print(cell.name)

    with Transaction(drawing, "My Operation"):
        result = drawing.add_cell("RESULT")
        layer = drawing.add_layer("OUTPUT")
        result.add_polygon(layer, [(0, 0), (100, 0), (100, 100), (0, 100)])

    return {"summary": "Created RESULT"}

Eigenständige Skripte (`linkcad --python-script`)

Skripte außerhalb des Plugin-Frameworks müssen Sperren explizit anfordern:

from linkcad.v1.db import Drawing, ReadLock, WriteLock

with Drawing("scratch") as dwg:
    with ReadLock():
        for cell in dwg.cells:
            print(cell.name)

    with WriteLock():
        for layer in list(dwg.layers):
            if layer.name.startswith("TEMP_"):
                dwg.destroy_layer_by_name(layer.name)

ReadLock

Kontextmanager für Nur-Lese-Zugriff in eigenständigen Skripten.

from linkcad.v1.db import ReadLock

with ReadLock():
    main = dwg.main_cell
    for shape in main.shapes:
        print(shape.bounds)

WriteLock

Kontextmanager für Schreibzugriff in eigenständigen Skripten. Erzeugt keinen Rückgängig-Eintrag.

from linkcad.v1.db import WriteLock

with WriteLock():
    for cell in dwg.cells:
        for obj in list(cell.cell_objects):
            if obj.layer_name == "SCRATCH":
                obj.destroy()

Transaction

Kontextmanager für Schreibzugriff, der einen einzelnen rückgängig machbaren Eintrag im Verlauf erzeugt. Verwenden Sie ihn in Tool-Plugins. Er nimmt entweder eine Beschreibungszeichenkette entgegen, die im Menü „Edit“ erscheint, oder eine numerische Kennung.

from linkcad.v1.db import Transaction

with Transaction(drawing, "Create Panel"):
    panel = drawing.add_cell("PANEL")
    panel.add_ref(drawing.cell("UNIT"))

Die Transaktion wird bestätigt, wenn der Block normal endet, und zurückgerollt, wenn eine Ausnahme entweicht. transaction.commit() bestätigt vorzeitig.