Wendeltreppenprogramm für glatte Unterseite und beidseitigen Handlauf (Software)

Martin Vogel , Dortmund / Bochum, Fri, 22.06.2018, 13:47 (vor 2134 Tagen) @ Martin Vogel

Weil es viel einfacher ist, überflüssige Elemente zu löschen, als fehlende Elemente hinzuzufügen, erzeugt das in den letzten beiden Foreneinträgen vorgestellte Python-Wendeltreppenprogramm für AutoCAD und BricsCAD jetzt auch gleich noch zwei Handläufe.

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]")

--
Dipl.-Ing. Martin Vogel
Leiter des Bauforums

Bücher:
CAD mit BricsCAD
Bauinformatik mit Python

Tags:
Python, CAD, AutoCAD, BricsCAD, Wendeltreppe