Elementare Zeichenfunktionen - Cinderella Dokumentation
Description: The user's guide to the Interactive Geometry Software Cinderella

Zum Inhalt

# Elementare Zeichenfunktionen

Die in diesem Abschnitt beschriebenen Operatoren werden verwendet, um Punkte, Linien und Strecken in einem Konstruktionsfenster zu zeichnen.

#### Zeichnen: `draw(<expr>)`

Beschreibung: Die Funktion `draw(<expr>)` ist ein multifunktionaler Operator. Je nach Bedeutung von `<expr>` werden die entsprechenden Objekte gezeichnet, falls möglich. Derzeit gibt es drei mögliche Eingaben, die zu einer Zeichnungsaktion führen. Für die ersten beiden nehmen wir an, dass `x`, `y` und `z` Zahlen sind.

Code | Ergebnis |
`draw([x,y])` | Zeichnet einen Punkt mit x-Koordinate `x` und y-Koordinate `y` |
`draw([x,y,z])` | Zeichnet einen Punkt mit homogenen Koordinaten gegeben durch `[x,y,z]` |

Ein Wort zu homogenen Koordinaten: Wenn `[x,y,z]` die homogenen Koordinaten eines Punktes sind, dann hat der entsprechende zu zeichnende Punkt die xy-Koordinaten `[x/z,y/z]`. Punkte, die homogene Koordinaten mit `z=0` haben, entsprechen „Punkten im Unendlichen". Sie werden in einer üblichen euklidischen Cinderella-Ansicht nicht sichtbar sein. Sie werden jedoch in der sphärischen Ansicht gezeichnet (oder wenn eine lokale projektive Basis gesetzt ist (siehe Skript-Koordinatensystem).

Zeichnen einer Strecke: Eine Strecke kann gezeichnet werden, indem eine Liste von zwei Punkten angegeben wird. Die Punkte können entweder in euklidischen oder homogenen Koordinaten angegeben werden, die wir im Folgenden für `a` und `b` annehmen.

Code | Ergebnis |
`draw([a,b])` | Zeichnet eine Strecke von `a` zu `b` |

Beispiel: Der folgende Code erzeugt das unten abgebildete Bild. Beachten Sie, dass sowohl euklidische als auch homogene Koordinaten angegeben sind. Darüber hinaus erscheinen die Strecken vor den Punkten, da ihre Zeichnungsoperatoren nach den Zeichnungsoperatoren für die Punkte aufgerufen werden.

    A=[0,0];
    B=[0,2,2];
    C=[1,1,1];
    D=[1,0];
    E=[0.5,1.5];
    linesize(3);
    pointsize(10);
    draw(A);draw(B);
    draw(C);draw(D);draw(E);

    ![](../assets/wiki_up/HouseX.png)
    draw([A,B]);draw([B,C]);
    draw([C,D]);draw([D,A]);
    draw([C,E]);draw([B,E]);

Zeichnen einer Linie: Homogene Koordinaten können auch verwendet werden, um Linien darzustellen. Man kann sich diese Codierung für Linien durch drei reelle Zahlen `[a,b,c]` als Codierung einer Linie mit der impliziten Gleichung `a∗x+b∗y+c=0` vorstellen. Ein Punkt mit euklidischen Koordinaten `[x,y]` liegt auf dieser Linie dann und nur dann, wenn die Gleichung erfüllt ist. Ein Punkt mit homogenen Koordinaten `[x,y,z]` liegt auf dieser Linie dann und nur dann, wenn die Gleichung `a∗x+b∗y+c∗z=0` erfüllt ist.

Um CindyScript zu mitteilen, ob eine Liste von drei reellen Zahlen `[a,b,c]` ein Punkt oder eine Linie ist, wird ein internes Flag für die Liste durch Operationen gesetzt, die Linien als Ausgabe erzeugen. So berechnet beispielsweise die Operation `join(A,B)` die Linie durch zwei Punkte `A` und `B` und setzt das interne Line-Flag. Wenn der Zeichnungsoperator auf das Ergebnis dieser Operation angewendet wird, wird die Linie gezeichnet. Man kann das Setting des Line-Flags auch erzwingen, indem man den Operator `line(<expr>)` anwendet.

Beispiele: Jeder der folgenden zwei Zeichnungsoperationen zeichnet eine Linie:

    draw(line([1,1,0.5]));
    draw(join([1,2],[2,-1]));

Modifizierer: Der Zeichnungsoperator kann mit den Modifizierern umgehen, die in der folgenden Tabelle zusammengefasst sind:

Modifizierer | Parameter | Effekt
--- | --- | ---
`point size` | `<real>` | setzt die Punktgröße
`line size` | `<real>` | setzt die Liniengröße
`size` | `<real>` | setzt die Liniengröße und die Punktgröße
`pointcolor` | `[<real1>,<real2>,<real3>]` | setzt die Punktfarbe auf einen RGB-Wert
`linecolor` | `[<real1>,<real2>,<real3>]` | setzt die Linienfarbe auf einen RGB-Wert
`color` | `[<real1>,<real2>,<real3>]` | setzt die Punktfarbe und die Linienfarbe auf einen RGB-Wert
`alpha` | `<real>` | setzt die Deckkraft auf den Wert `<real>`
`noborder` | `<bool>` | `noborder→true` schaltet den Rand von Punkten aus
`border` | `<bool>` | `border→true` das Gegenteil des letzten Modifizierers
`dashtype` | `<int>` | Geben Sie einen bestimmten Bindestrichtyp an (Werte 0..4 erlaubt)
`dashing` | `<real>` | Größe des Bindestrichs
`dashpattern` | `<list>` | Geben Sie ein individuelles Bindestrichmuster an

Modifizierer haben nur lokale Effekte. Dies bedeutet, dass die Standard-Erscheinungseinstellungen nicht beeinträchtigt werden, wenn ein Modifizierer verwendet wird.

Beispiel: Der folgende Code zeigt den Effekt der Bindestrich-Modifizierer.

    linesize(3);
    draw((0,0),(0,6),dashtype->0);
    draw((1,0),(1,6),dashtype->1);
    draw((2,0),(2,6),dashtype->2);
    draw((3,0),(3,6),dashtype->3);
    draw((4,0),(4,6),dashtype->4);
    draw((6,0),(6,6),dashing->4);
    draw((7,0),(7,6),dashing->6);
    draw((8,0),(8,6),dashing->8);
    draw((9,0),(9,6),dashing->10);
    draw((11,0),(11,6),dashpattern->[0,4,2,4]);
    draw((12,0),(12,6),dashpattern->[0,2,2,2,4,2]);
    draw((13,0),(13,6),dashpattern->[0,4,2,4]);
    draw((14,0),(14,6),dashpattern->[4,2,1,2]);

Siehe auch: Skript-Koordinatensystem und Geometrische Operatoren

#### Strecken zeichnen: `draw(<expr>,<expr>)`

Beschreibung: Der Zeichnungsoperator mit zwei Argumenten kann auch zum Zeichnen einer Strecke verwendet werden. Beide Argumente müssen Punkte darstellen, entweder in euklidischen oder homogenen Koordinaten. Somit zeichnet `[draw([0,0],[1,1])]` eine Strecke von `[0,0]` zu `[1,1]`.

Modifizierer: Dieser Operator kann die gleichen Modifizierer wie der Operator `draw(<expr>)` verarbeiten. Allerdings haben die Modifizierer, die spezifisch für Punkte sind, keine Auswirkung.

#### Listen von Objekten zeichnen: `drawall(<list>)`

Beschreibung: Der Operator `drawall(<list>)` nimmt eine Liste als Argument. Jedes Element der Liste sollte so beschaffen sein, dass es vom üblichen Operator `draw(<expr>)` gezeichnet werden könnte. Der Operator `drawall` wendet dann den Zeichnungsoperator auf jeden Eintrag der Liste an. Der Operator `drawall` ist äußerst nützlich, um komplexere mathematische Bilder zu zeichnen, die strukturierte oder hochgradig zusammenhängende mathematische Inhalte beinhalten.

Beispiel: Der folgende Code erzeugt das unten abgebildete Bild. Die zweite Zeile definiert eine Funktion, die eine Zahl auf einen Punkt auf dem Einheitskreis abbildet. Die Zeile `steps=2*pi*(1..n)/n;` initialisiert die Variable `steps` mit einer Liste von 17 Winkeln, die 17 Punkten auf dem Einheitskreis entsprechen. Diese Punkte werden der Variable `pts` durch die Zeile `pts=apply(steps,f(#))` zugewiesen. Die Variable `segs` enthält alle Paare solcher Punkte. In den letzten zwei Zeilen wird der Operator `draw` verwendet, um diese Listen von Objekten zu zeichnen.

    n=17;
    f(x):=[sin(x),cos(x)];
    steps=2*pi*(1..n)/n;
    pts=apply(steps,f(#));
    segs=pairs(pts);
    drawall(segs,alpha->0.9);
    drawall(pts,size->4);

Modifizierer: Dieser Operator kann die gleichen Modifizierer wie der Operator `draw(<expr>)` verarbeiten.

#### Punkte verbinden: `connect(<list>)`

Beschreibung: Dieser Operator nimmt eine Liste von Punkten als Eingabe und verbindet sie durch Liniensegmente.

Beispiel: Der folgende Code zusammen mit einer Sammlung von Punkten einer Konstruktion erzeugt das unten abgebildete Bild. Die erste Zeile ordnet der Variable `pts` alle Punkte einer Konstruktion zu. Die zweite Zeile ordnet `sortpts` eine Liste dieser Punkte zu, die nach der x-Koordinate der Punkte sortiert wurde. Schließlich verbindet der Operator `connect` diese Punkte in der gegebenen sequenziellen Reihenfolge.

    pts=allpoints();
    sortpts=sort(pts,#.x);
    connect(sortpts);

Modifizierer: Dieser Operator kann die gleichen Modifizierer wie der Operator `draw(<expr>)` verarbeiten.

#### Polygon zeichnen: `drawpoly(<list>)`

Beschreibung: Dieser Operator nimmt eine Liste von Punkten als Eingabe und zeichnet den Rand des durch diese Liste beschriebenen Polygons.

Modifizierer: Dieser Operator kann die folgenden Modifizierer verarbeiten:

Modifizierer | Parameter | Effekt
--- | --- | ---
`color` | `[<real1>,<real2>,<real3>]` | setzt die Punktfarbe und die Linienfarbe auf einen RGB-Wert
`alpha` | `<real>` | setzt die Deckkraft auf den Wert `<real>`

#### Polygon ausfüllen: `fillpoly(<list>)`

Beschreibung: Dieser Operator nimmt eine Liste von Punkten als Eingabe und erstellt ein Polygon daraus.

Beispiel: Der folgende Code erstellt das unten abgebildete Bild. In jedem Iterationsschritt der `repeat`-Schleife wird das Quadrat gezeichnet, und danach wird das Koordinatensystem gedreht und skaliert.

    sq=[[-1,-1],[-1,1],[1,1],[1,-1]];
    repeat(300,i,
      fillpoly(sq,color->hue(i/10));
      rotate(4°);
      scale(0.95);
    )

Modifizierer: Dieser Operator kann die folgenden Modifizierer verarbeiten:

Modifizierer | Parameter | Effekt
--- | --- | ---
`color` | `[<real1>,<real2>,<real3>]` | setzt die Punktfarbe und die Linienfarbe auf einen RGB-Wert
`alpha` | `<real>` | setzt die Deckkraft auf den Wert `<real>`

#### Kreise zeichnen: `drawcircle(<point>,<radius>)`

Beschreibung: Zeichnet einen Kreis an `<point>` mit einem Radius, der durch eine Zahl `<radius>` gegeben ist. Der Punkt kann entweder in euklidischen oder homogenen Koordinaten angegeben werden.

Modifizierer: Dieser Operator kann die gleichen Modifizierer wie der Operator `draw(<expr>)` verarbeiten.

#### Kreise ausfüllen: `fillcircle(<point>,<radius>)`

Beschreibung: Zeichnet das Innere eines Kreises an `<point>` mit einem Radius, der durch eine Zahl `<radius>` gegeben ist. Der Punkt kann entweder in euklidischen oder homogenen Koordinaten angegeben werden.

Modifizierer: Dieser Operator kann die folgenden Modifizierer verarbeiten:

Modifizierer | Parameter | Effekt
--- | --- | ---
`color` | `[<real1>,<real2>,<real3>]` | setzt die Füllfarbe auf einen RGB-Wert
`alpha` | `<real>` | setzt die Deckkraft auf den Wert `<real>`

Beispiel: Der folgende Code zeigt eine kombinierte Verwendung der Operatoren `drawcircle` und `fillcircle`.

    repeat(100,i,
     fillcircle((0,0),1,color->hue(i/70`;
     drawcircle`0,0),1,color->(0,0,0`;
     translate`1.5,0));rotate(26°);scale(.95);
    );

Diese Seite wurde automatisch mit KI (Claude) übersetzt und wartet noch auf Überprüfung. → Alle KI-übersetzten Seiten