Eine Wahlmöglichkeit besteht nicht. Die Geländer sind 100 cm hoch, der Handlaufdurchmesser beträgt 7 cm, pro Stufe werden auf der Innenseite ein und auf der Außenseite zwei Geländerstäbe mit 2,5 cm Durchmesser angeordnet. Wer das variabel haben möchte, darf das Pythonprogramm gerne an seine Bedürfnisse anpassen.

Download: ZIP-Datei

So sieht eine mit dem Programm erzeugte und mit Materialien (Marmor, Messing) versehene Wendeltreppe aus.

#!/usr/bin/env python3
#
# Dieses Programm benötigt mindestens Python 3.6
 
from math import pi, degrees, radians, sin, cos
import os.path
 
print("""
Dieses Programm erzeugt eine AutoCAD/BricsCAD-Scriptdatei zur Konstruktion
einer Wendeltreppe in einer leeren Zeichnungsdatei.
 
Autor:  Martin Vogel, 2018
Lizenz: Namensnennung - Weitergabe unter gleichen Bedingungen 3.0 Deutschland
        (CC BY-SA 3.0 DE) https://creativecommons.org/licenses/by-sa/3.0/de/
Info:   https://bauforum.wirklichewelt.de/index.php?id=11644
""")
 
# Funktion zur Eingabe einer Gleitkommazahl (mit optionalem Vorgabewert):
def fi(s, vorgabe=None):
    while True:
        print(f"{s}{f' ({vorgabe})' if vorgabe else ''}: ", end="")
        inp = input().replace(",", ".")
        if not inp:
            inp = vorgabe
        try:
            return float(inp)
        except:
            print("Fehler: Eingabe wurde nicht als Zahl erkannt.")
 
# Funktion zur Koordinatendrehung im Gegenuhrzeigersinn (GUZ)
def rot(x, y, grad):
    w = radians(grad)
    return x * cos(w) - y * sin(w), x * sin(w) + y * cos(w)
 
# Funktion zum Finden eines noch nicht benutzten Dateinamens
def freiername(maske):
    # Die Maske ist ein Musterdateiname, der um eine fortlaufende Zahl
    # in einer Klammer vor der Dateinamenerweiterung ergänzt wird.
    # Wo ist der letzte Punkt in der Maske?
    p = len(maske) - maske[::-1].find(".") - 1
    # Eventuell wird der Dateiname in der Maske noch gar nicht verwendet.
    name = maske
    i = 1
    # Ansonsten erhöhen wir den Zähler i, bis ein freier Name gefunden wurde.
    while os.path.isfile(name):
        i += 1
        # aus "Wendeltreppe.scr" wird "Wendeltreppe(2).scr"
        name = maske[:p] + f"({i})" + maske[p:]
    return name
 
# Für die Geländerabmessungen ist keine Interaktion vorgesehen.
# Geländerhöhe
hg = 100
# Geländerhandlaufdurchmesser
dg = 7
# Geländerstabdurchmesser
ds = 2.5
# Der Abschlusskugeldurchmesser ist etwas größer als der Handlaufdurchmesser.
dk = 1.5 * dg
 
# Abfrage der Treppenparameter und Berechnung der abhängigen Werte
 
# Außendurchmesser
print("Der Außendurchmesser sollte nicht kleiner als 120 cm sein.")
da = fi("Außendurchmesser der Treppe", 250)
 
# Die Lauflinie ist die Linie, auf der die Treppe am bequemsten zu gehen ist.
# Wir legen sie 30 cm vom inneren Rand des äußeren Handlaufs aus nach innen an.
dl = da - 2 * dg - 60
print(f"\nDer Durchmesser der Lauflinie beträgt {dl} cm.")
 
# Der Umfang der Lauflinie ist die Strecke, die man bei einer vollen
# Wendelumdrehung horizontal zurücklegen würde
ul = pi * dl
print(f"Ihr Umfang beträgt {ul:.1f} cm.")
 
# Innendurchmesser
# Wenn der Innendurchmesser null ist, kann die Unterseite nicht ausgeformt
# werden.
print("\nDer Innendurchmesser muss größer als null sein.")
di = fi("Innendurchmesser der Treppe", 50)
 
# Wie hoch soll die Treppe sein? Gemessen wird von der Unterkante der
# untersten Stufe bis zur Oberkante der obersten Stufe.
ht = fi("\nHöhe der Treppe", 260)
 
# Wie viele Stufen werden benötigt (Idealhöhe 17 cm)?
n = round(ht / 17)
print(f"\nDie Treppe erhält {n} Stufen.")
 
# Welche Stufenhöhe ergibt sich aus dieser Anzahl?
hs = ht / n
print(f"Die Stufenhöhe beträgt {hs:.1f} cm.")
 
# Die rechnerische Auftrittslänge (Stufentiefe) ergibt sich aus der
# Schrittmaßregel.
ra = 63 - 2 * hs
 
# Der rechnerische Drehwinkel der Treppe hat vermutlich ein recht krummes Maß.
rw = 360 * n * ra / ul
 
# Wir runden ihn auf ein Vielfaches von 15°.
rwg = int(round(rw / 15) * 15)
 
# Vermutlich sind ohnehin nur Vielfache von 90° gewünscht.
# Wir halten uns da raus.
print("\nLinks herum ansteigende Treppen besitzen einen positiven Drehwinkel,"
      "\nrechts herum ansteigende Treppen einen negativen.")
wt = fi("Gesamtdrehwinkel der Treppe", rwg)
 
# Daraus ergibt sich der Drehwinkel einer einzelnen Stufe.
ws = wt/n
 
# Alle Geometriewerte sind eingesammelt,
# die Scriptdatei kann geschrieben werden:
wtn = freiername("Wendeltreppe.scr")
with open(wtn, "w") as scr:
    # Koordinateneingabe geht vor Objektfang
    scr.write("OSnapCoord 1\n")
    # Einheit Zentimeter
    scr.write("_InsUnits 5\n")
    # Definierende Geometrie automatisch löschen (z. B. Handlauf-Spirale)
    scr.write("DelObj 2\n")
    # Seitenansicht, um sicherzustellen, dass beim Ausformen der
    # Treppenunterseite alle Stufenrückseiten angeklickt werden können.
    scr.write("-APunkt 0,-1,0\n")
    # Dummykörper als Zoomziel
    scr.write(f"Zylinder 0,0,0 {da/2} {ht+hg+hs}\n")
    scr.write("Zoom Objekt L \n")
    scr.write("_Erase L \n")
 
    # Die Unterseite der Wendeltreppe wird als Ausformungskörper entlang
    # der Rückseiten der (späteren) Stufenprofile angelegt.
 
    # In der Liste Lp merken wir uns einen Punkt pro Querschnitt, den
    # wir beim Ausformen anklicken können.
    Lp = []
 
    # Für alle Stufen ab der zweiten:
    for i in range(1,n+1):
        # Die Hinterseite jeder Stufe ist ein Rechteck.
        # Koordinaten auf der x-y-Ebene:
        xi, yi = rot(di/2, 0, i*ws)
        xa, ya = rot(da/2, 0, i*ws)
        # Vier Punkte im Raum:
        p0 = f"{xi},{yi},{(i-1)*hs}"
        p1 = f"{xa},{ya},{(i-1)*hs}"
        p2 = f"{xa},{ya},{i*hs}"
        p3 = f"{xi},{yi},{i*hs}"
        # CAD-Befehl zum Zeichnen der geschlossenen 3D-Polylinie:
        scr.write(f"3DPoly {p0} {p1} {p2} {p3} s\n")
        # Wir merken uns einen Anklickpunkt ganz außen auf halber Stufenhöhe.
        Lp.append(f"{xa},{ya},{(i-0.5)*hs}")
 
    # Ausformen der "Rampe"
    scr.write(f"_Loft {' '.join(Lp)}\n\n\n")
 
    # Drehrichtung der Handläufe
    twist = "GUZ" if wt>0 else "UZ"
 
    # Handlauf außen:
    # Pfad
    scr.write(f"Spirale 0,0,{hg+hs} {da/2-dg/2}  "
              f"_T {abs(wt)/360} _W {twist} A 0,0,{hg+hs+ht}\n")
    # Profil
    scr.write(f"Kreis 0,0,0 {dg/2}\n")
    # Extrudiere Profil entlang Pfad
    scr.write(f"_Sweep l  {da/2-dg/2},0,{hg+hs}\n")
 
    # Handlauf innen:
    # Pfad
    scr.write(f"Spirale 0,0,{hg+hs} {di/2+dg/2}  "
              f"_T {abs(wt)/360} _W {twist} A 0,0,{hg+hs+ht}\n")
    # Profil
    scr.write(f"Kreis 0,0,0 {dg/2}\n")
    # Extrudiere Profil entlang Pfad
    scr.write(f"_Sweep l  {di/2+dg/2},0,{hg+hs}\n")
 
    # Geländerstäbe außen:
    # Für alle Stufen je zwei Stäbe in den Viertelspunkten
    for i in range(n):
        x,y = rot(da/2-dg/2, 0, (i+1/4)*ws)
        scr.write(f"Zylinder {x},{y},{(i+1)*hs} {ds/2} {hg+hs/4}\n")
        x,y = rot(da/2-dg/2, 0, (i+3/4)*ws)
        scr.write(f"Zylinder {x},{y},{(i+1)*hs} {ds/2} {hg+hs*3/4}\n")
 
    # Geländerstäbe innen:
    # Für alle Stufen je ein Stab in Stufenmitte
    for i in range(n):
        x,y = rot(di/2+dg/2, 0, (i+0.5)*ws)
        scr.write(f"Zylinder {x},{y},{(i+1)*hs} {ds/2} {hg+hs/2}\n")
 
    # Noch etwas Deko: Kugeln als Handlaufabschluss
    scr.write(f"Kugel {(di+dg)/2},0,{hg+hs} {dk/2}\n")
    scr.write(f"Kugel {(da-dg)/2},0,{hg+hs} {dk/2}\n")
    x, y = rot((di+dg)/2,0,wt)
    scr.write(f"Kugel {x},{y},{hg+ht+hs} {dk/2}\n")
    x, y = rot((da-dg)/2,0,wt)
    scr.write(f"Kugel {x},{y},{hg+ht+hs} {dk/2}\n")
 
    # Nun werden die einzelnen Stufen auf die „Rampe“ gesetzt.
 
    # Für alle Stufen:
    for i in range(n):
        # Die Vorderseite jeder Stufe ist ein Rechteck.
        # Koordinaten auf der x-y-Ebene:
        xi,yi = rot(di/2, 0, i*ws)
        xa,ya = rot(da/2, 0, i*ws)
        # Vier Punkte im Raum:
        p0 = f"{xi},{yi},{i*hs}"
        p1 = f"{xa},{ya},{i*hs}"
        p2 = f"{xa},{ya},{(i+1)*hs}"
        p3 = f"{xi},{yi},{(i+1)*hs}"
        # CAD-Befehl zum Zeichnen der geschlossenen 3D-Polylinie:      
        scr.write(f"3DPoly {p0} {p1} {p2} {p3} s\n")
        # Durch Rotieren der Stufenvorderseite um die Mittelachse entsteht die
        # Stufe als Volumenkörper. Der Drehwinkel ist so gewählt, dass die
        # Stufen sich jeweils an einer Kante berühren. Diese liegt außerdem
        # genau auf der oberen Fläche der Rampe.
        scr.write(f"Rotation l  0,0,0 0,0,1 {ws}\n")       
 
    # Anzeige anpassen, perspektivische Ansicht von vorne rechts:
    scr.write("-APunkt 1,-1,1\n")
    scr.write("Perspective 1\n")
    scr.write(f"Zoom Grenzen\n")
 
    # Automatisches Löschen erzeugender Geometrie wieder ausschalten.
    scr.write("DelObj 0\n")
 
print(f"""
Fertig. 
 
Starten Sie die erzeugte Scriptdatei "{wtn}" im CAD-Programm
in einer leeren Zeichnung (Einheit Zentimeter) mit dem Befehl SCRIPT!
""")
input("[Enter]")

Die neue Version des Pythonprogramms verzichtet darauf, die Stufen der Wendeltreppe als eigenen Block zu definieren. Das sorgte für die Unbequemlichkeit, das Script nicht erneut in derselben Zeichnungsdatei laufen lassen zu können.

Beim Konstruieren von Wendeltreppen mit mehreren Windungen kam es beim Testen des Programms gelegentlich vor, dass der Ausformen-Befehl ein paar Stufen nicht mitbekam und das CAD-Programm eine originelle Betonschleife konstruierte. In diesem Fall hilft es, mit der Maus die Ansicht so zu drehen und zu zoomen, dass alle Stufen gut erkennbar sind und sich nicht gegenseitig verdecken, die missratene Wendeltreppe zu löschen und die Ausführung des Scriptes mittels SCRIPT zu wiederholen.

#!/usr/bin/env python3
# benötigt mindestens Python 3.6
 
from math import pi, degrees, radians, sin, cos
 
print("""
Dieses Programm erzeugt eine AutoCAD/BricsCAD-Scriptdatei für eine
Wendeltreppe.
""")
 
def fi(s, vorgabe=None):
    "float input"
    while True:
        print(f"{s}{f' ({vorgabe})' if vorgabe else ''}: ",end="")
        inp = input().replace(",",".")
        if not inp:
            inp = vorgabe
        try:
            return float(inp)
        except:
            print("Fehler: Eingabe wurde nicht als Zahl erkannt.")
 
print("Der Außendurchmesser sollte nicht kleiner als 120 cm sein.")
da = fi("Außendurchmesser der Treppe", 250)
du = da - 60
ul = pi * du
print(f"\nDer Durchmesser der Lauflinie beträgt {du} cm.")
print(f"Ihr Umfang beträgt {ul:.1f} cm.")
print("\nDer Innendurchmesser muss größer als null sein.")
di = fi("Innendurchmesser der Treppe", 50)
ht = fi("\nHöhe der Treppe", 260)
n = round(ht/17)
hs = ht/n
print(f"\nDie Treppe erhält {n} Stufen.")
print(f"Die Stufenhöhe beträgt {hs:.1f} cm.")
# rechnerischer Auftritt aus Schrittmaßregel
ra = 63 - 2 * hs
# rechnerischer Winkel der Treppe
rw = 360 * n * ra / ul
# gerundet auf 15°
rwg = int(round(rw/15)*15)
print("\nLinks herum ansteigende Treppen besitzen einen positiven Drehwinkel,"
      "\nrechts herum ansteigende Treppen einen negativen.")
wt = fi("Gesamtdrehwinkel der Treppe",rwg)
# Winkel einer Stufe
ws = wt/n
 
# Koordinatendrehung
def rot(x, y, grad):
    w = radians(grad)
    return x * cos(-w) - y * sin(w), x * sin(w) + y * cos(-w)
 
with open("WENDELTREPPE.SCR","w") as scr:
    # Koordinateneingabe geht vor Objektfang
    scr.write("OSnapCoord 1\n")
    # Einheit Zentimeter
    scr.write("_InsUnits 5\n")
 
    # Die Unterseite der Wendeltreppe wird als Ausformungskörper entlang
    # der Rückseiten der (späteren) Stufenprofile angelegt.
 
    # In der Liste Lp merken wir uns einen Punkt pro Querschnitt, den
    # wir beim Ausformen anklicken können.
    Lp = []
 
    # Für alle Stufen ab der zweiten:
    for i in range(1,n+1):
        # Hinterseite der Stufe
        xi,yi = rot(di/2, 0, i*ws)
        xa,ya = rot(da/2, 0, i*ws)
        p0 = f"{xi},{yi},{(i-1)*hs}"
        p1 = f"{xa},{ya},{(i-1)*hs}"
        p2 = f"{xa},{ya},{i*hs}"
        p3 = f"{xi},{yi},{i*hs}"
        scr.write(f"3DPoly {p0} {p1} {p2} {p3} s\n")
        Lp.append(p1)
 
    # Ausformen
    scr.write(f"_Loft {' '.join(Lp)}\n\n\n")
 
    # Nun werden die einzelnen Stufen auf die „Rampe“ gesetzt.
 
    # Für alle Stufen:
    for i in range(n):
        # Vorderseite der Stufe
        xi,yi = rot(di/2, 0, i*ws)
        xa,ya = rot(da/2, 0, i*ws)
        p0 = f"{xi},{yi},{i*hs}"
        p1 = f"{xa},{ya},{i*hs}"
        p2 = f"{xa},{ya},{(i+1)*hs}"
        p3 = f"{xi},{yi},{(i+1)*hs}"
        scr.write(f"3DPoly {p0} {p1} {p2} {p3} s\n")
        # Rotieren
        scr.write(f"Rotation l  0,0,0 0,0,1 {ws}\n")       
 
    # Anzeige anpassen
    scr.write("-APunkt -1,-1,1\n")
    scr.write(f"Zoom Fenster {-da/2},{-da/2},0 {da/2},{da/2},{ht}\n")
 
print("""
Fertig. 
 
Starten Sie die erzeugte Scriptdatei WENDELTREPPE.SCR im CAD-Programm
in einer leeren Zeichnung (Einheit Zentimeter) mit dem Befehl SCRIPT!
""")
input("[Enter]")

Wer LISP mag, kann zum Beispiel das 1995 von Xue-dong Zhao geschriebene Spiral-Stair-Script SPST.LSP so anpassen, dass es auch unter aktuellen Programmversionen noch läuft. Es ist nach kurzer Suche an verschiedenen Orten im Web zu finden.

Man könnte aber auch einfach ein kleines Pythonprogramm schreiben, das eine Scriptdatei für AutoCAD oder BricsCAD zum Zeichnen einer Wendeltreppe erzeugt. Diese kann die Treppe dann gleich so bemessen, dass sie bequem zu gehen ist.

Das unten zu findende Programm Wendeltreppe.py fragt zuerst nach der gewünschten Höhe der Treppe in Zentimetern. Daraus ermittelt es die Zahl der Stufen, die erforderlich ist, um der optimalen Stufenhöhe von 17 Zentimetern so nah wie möglich zu kommen.

Der Innen- und der Außendurchmesser der Wendel bestimmen die Stufenbreite. 30 Zentimeter vom äußeren Rand entfernt befindet sich die Lauflinie, welche die für eine bequeme und sichere Nutzung der Treppe optimale Stufentiefe und den erforderlichen Drehwinkel (auf 15° gerundet) festlegt. Dieser Drehwinkel kann noch verändert werden, um mehr Freiheit in der Gestaltung der Treppengeometrie zu haben.

Sind alle Geometrieparameter festgelegt, schreibt das Pythonprogramm das CAD-Script WENDELTREPPE.SCR. Wer BricsCAD verwendet, kann diese Datei einfach doppelklicken und hat im nächsten Augenblick eine fertige Wendeltreppe auf dem Bildschirm, bei der nur noch ein paar Kleinigkeiten wie Handlauf, Geländerstäbe oder eine schöne, ebenmäßig geformte Unterseite ergänzt werden müssen. AutoCAD unterstützt das Doppelklicken von Scriptdateien nicht; hier müssen Sie in einer neuen, leeren Datei den Befehl SCRIPT eintippen und im sich öffnenden Dialogfenster die Datei WENDELTREPPE.SCR suchen und ausführen.

#!/usr/bin/env python3
# benötigt mindestens Python 3.6
 
from math import pi, degrees
 
print("""
Dieses Programm erzeugt eine AutoCAD/BricsCAD-Scriptdatei für eine
Wendeltreppe.
 
Starten Sie die erzeugte Scriptdatei WENDELTREPPE.SCR im CAD-Programm
in einer leeren Zeichnung (Einheit Zentimeter) mit dem Befehl SCRIPT!
""")
 
def fi(s, vorgabe=None):
    "float input"
    while True:
        print(f"{s}{f' ({vorgabe})' if vorgabe else ''}: ",end="")
        inp = input().replace(",",".")
        if not inp:
            inp = vorgabe
        try:
            return float(inp)
        except:
            print("Fehler: Eingabe wurde nicht als Zahl erkannt.")
 
da = fi("Außendurchmesser der Treppe", 250)
du = da - 60
ul = pi * du
print(f"Der Durchmesser der Lauflinie beträgt {du} cm.")
print(f"Ihr Umfang beträgt {ul:.1f} cm.")
di = fi("Innendurchmesser der Treppe", 50)
ht = fi("Höhe der Treppe", 260)
n = round(ht/17)
hs = ht/n
print(f"Die Treppe erhält {n} Stufen.")
print(f"Die Stufenhöhe beträgt {hs:.1f} cm.")
# rechnerischer Auftritt aus Schrittmaßregel
ra = 63 - 2 * hs
# rechnerischer Winkel der Treppe
rw = 360 * n * ra / ul
# gerundet auf 15°
rwg = int(round(rw/15)*15)
wt = fi("Gesamtdrehwinkel der Treppe",rwg)
# Winkel einer Stufe
ws = wt/n
# Vorderseite der Stufe
p0 = f"{di/2},0,0"
p1 = f"{da/2},0,0"
p2 = f"{da/2},0,{hs}"
p3 = f"{di/2},0,{hs}"
 
with open("WENDELTREPPE.SCR","w") as scr:
    # Koordinateneingabe geht vor Objektfang
    scr.write("OSnapCoord 1\n")
    # Einheit Zentimeter
    scr.write("_InsUnits 5\n")
    # Vorderseite der Stufe
    scr.write(f"3DPoly {p0} {p1} {p2} {p3} s\n")
    # Rotieren
    scr.write(f"Rotation l  0,0,0 0,0,1 {ws}\n")
    # Block definieren
    scr.write(f"-Block Stufe 0,0,0 l \n")
    for i in range(n):
        scr.write(f"_-Insert Stufe\n0,0,{i*hs} 1 1 {i*ws}\n")
    # Anzeige anpassen
    scr.write("-APunkt -1,-1,1\n")
    scr.write("Zoom G\n")
 
input("Fertig. [Enter]")