Forum der Vereinigung der Sternfreunde

Liebe Sternfreunde,

ich bemühe mich, meine Programme zu "illustrieren", also nicht nur Listen, sondern auch eine grafische Ausgabe zu erzeugen. Die Funktionen hierzu möchte ich nicht in jeden Quellcode einfügen und habe sie deshalb in ein Modul ausgelagert. Es liegt zwar auf der Fachgruppenseite, aber wenigstens ein Mal sollte es auch hier abrufbar sein.

Die Funktionen beruhen auf der Turtle-Grafik des Python, die immer dabei ist. Deshalb habe ich alles hierauf aufgebaut: Es bracht kein Modul nachgeladen zu werden. Die kleine Bibliothek enthält Funktionen für Punkte und Linien in verschiedenen Variationen sowie Koordinatensysteme 2D und 3D.

# Plot und Koordinatensystem, auch 3D
from math import *
from turtle import *

# im 2D-Kooridinatensystem oder ohne Koordinaten
# ########################

def plot(x,y, thickness, col1, col2, col3): # einen Punkt setzen mit berechneter Farbe
    color(col1, col2, col3)
    penup()
    goto(x,y)
    pendown()
    dot(thickness)
    hideturtle()

def Plot(x,y, thickness, col): # einen Punkt setzen mit benannter Farbe
    color(col)
    penup()
    goto(x,y)
    pendown()
    dot(thickness)
    hideturtle()

def PLOT(x,y,thickness, col): # Punkt mit berechnetem Grauwert setzen
    plot(x,y,thickness,col,col,col)


def Line(x0,y0,x1,y1, thickness, col):  # Linie ziehen, benannte Farbe
    color(col)
    width(thickness)
    if (x1<x0): #dx stets>0 wg.atan
        h=x0;x0=x1;x1=h
        h=y0;y0=y1;y1=h
    penup(); goto(x0,y0)
    dx=x1-x0; dy=y1-y0
    pendown()
    if (dx<1e-10):
        setheading(90)
        forward(dy)
    else:
        setheading(180*atan(dy/dx)/pi)
        forward(sqrt(dx*dx+dy*dy))
    hideturtle()

def line(x0,y0,x1,y1): # dünne schwarze Linie
    Line(x0,y0,x1,y1, 1, 'black')

def greenline(x0,y0,x1,y1): # dünne grüne Linie
    Line(x0,y0,x1,y1, 1, 'lightgreen')

# Koordinatensystem 2D
def initKoor(x0,x1,stepX, y0,y1,stepY):
    reset()
    tracer(0,0) 
    setworldcoordinates(x0-0.01*(x1-x0),y0-0.01*(y1-y0),x1+0.01*(x1-x0),y1+0.01*(y1-y0))
    line(x0,y0,x0,y1)
    line(x0,y0,x1,y0)
    x=x0;y=y0
    while (y<=y1):
        if y>y0+1e-10:
            greenline(x,y,x1,y)
        line(x,y,x+0.01*(x1-x0),y)
        write(str(round(y, 4)), font=('Arial',10))
        y=y+stepY
    x=x0;y=y0
    while (x<=x1):
        if x>x0+1e-10:
            greenline(x,y,x,y1)
        line(x,y,x,y+0.01*(y1-y0))
        write(str(round(x, 4)), font=('Arial',10))
        x=x+stepX
    update()

X0=0;Y0=0;Z0=0;XE=0;YE=0;ZE=0
s30=0.5;c30=0.866025 # cos(30°)


# im 3D-Koordinatensystem
# ########################

# im 3d_koordinatensystem sind berechnete Farben wenig nützlich
# deshalb gibt es nur Funktionen mit benannten Farben

def Line3D(x0,y0,z0, x1,y1,z1,thickness,col): # Linie mit benannter Farbe
    dy0=(y0-Y0)/(YE-Y0) # /2 = Anpassung an die Achse
    dy1=(y1-Y0)/(YE-Y0) # /2 = Anpassung an die Achse
    Line(x0+c30*dy0*(XE-X0), z0+s30*dy0*(ZE-Z0), x1+c30*dy1*(XE-X0), z1+s30*dy1*(ZE-Z0),thickness,col) 
    
def line3D(x0,y0,z0,x1,y1,z1): # dünne schwarze Linie
    Line3D(x0,y0,z0,x1,y1,z1, 1, "black")

def greenline3D(x0,y0,x1,y1): # dünne grüne Linie
    Line3D(x0,y0,Z0, x1,y1,Z0, 1, 'lightgreen')

def PLOT3D(x,y,z,thickness, col): # Punkt mit benannter Farbe, mit Linie auf die (0,0)-Ebene
    dy=(y-Y0)/(YE-Y0) # /2 = Anpassung an die Achse
    Line(x+c30*dy*(XE-X0), 0+s30*dy*(ZE-Z0), x+c30*dy*(XE-X0), z+s30*dy*(ZE-Z0),1,col) 
    Plot(x+c30*dy*(XE-X0),                                      z+s30*dy*(ZE-Z0), thickness, col)

def Plot3D(x,y,z,thickness, col): # Punkt mit benannter Farbe, mit Linie auf die xy-Grundebene
    dy=(y-Y0)/(YE-Y0) # /2 = Anpassung an die Achse
    Line(x+c30*dy*(XE-X0), Z0+s30*dy*(ZE-Z0), x+c30*dy*(XE-X0), z+s30*dy*(ZE-Z0),1,col) 
    Plot(x+c30*dy*(XE-X0),                                      z+s30*dy*(ZE-Z0), thickness, col)

def plot3D(x,y,z): # fetter schwarzer Punkt mit Linie auf die xy-Grundebene
    Plot3D(x,y,z,5,"black")

# das 3D-Koordinatensystem selbst
def initKoor3D(x0,x1,stepX, y0,y1,stepY, z0,z1,stepZ):
    reset()
    global X0, Y0, Z0, XE, YE, ZE
    X0=x0;  Y0=y0;  Z0=z0;  XE=x1;  YE=y1;  ZE=z1
    tracer(0,0)  
    setworldcoordinates(x0-0.01*(x1-x0),z0-0.01*(z1-z0),x1+0.01*(x1-x0),z1+0.01*(z1-z0))
    print(x0-0.01*(x1-x0),z0-0.01*(z1-z0),x1+0.01*(x1-x0),z1+0.01*(z1-z0))
    #x-Koordinate
    line3D(x0,y0,z0,x1,y0,z0)
    x=x0
    while (x<=x1):
        if x>x0+1e-10:
            greenline3D(x,y0,x,y1)
        line3D(x,y0,z0,x,y0+0.01*(y1-y0),z0)
        write(str(round(x, 4)), font=('Arial',10))
        x=x+stepX
    #y-Koordinate, 30 Grad
    line3D(x0, y0, z0, x0, y1 ,z0) 
    y=y0
    while (y<=y1):
        if y>y0+1e-10:
            greenline3D(x0,y,x1,y)
        line3D(x0,y,z0, x0+0.01*(x1-x0), y,z0)
        write(str(round(y, 4)), font=('Arial',10))
        y=y+stepY
    #z-Koordinate
    line3D(x0,y0,z0,x0,y0,z1)
    x=x0;y=y0;z=z0
    while (z<=z1):
        line3D(x0,y0,z, x0+0.01*(x1-x0), y0,z)
        write(str(round(z, 4)), font=('Arial',10))
        z=z+stepZ
    update()
 

_________________
Uwe Pilz, Fachgruppen Kometen und Astrophysik/Algorithmen.
Oft benutzte Instrumente: Fujinon 16x70 FMT-SX-2, TMB Apo 105/650, Skywatcher Evostar 120/900 ED, Ninja Dobson 320/1440, Smartscope Dwarf-3