Wikibooks
dewikibooks
https://de.wikibooks.org/wiki/Hauptseite
MediaWiki 1.48.0-wmf.3
first-letter
Medium
Spezial
Diskussion
Benutzer
Benutzer Diskussion
Wikibooks
Wikibooks Diskussion
Datei
Datei Diskussion
MediaWiki
MediaWiki Diskussion
Vorlage
Vorlage Diskussion
Hilfe
Hilfe Diskussion
Kategorie
Kategorie Diskussion
Regal
Regal Diskussion
TimedText
TimedText talk
Modul
Modul Diskussion
Veranstaltung
Veranstaltung Diskussion
Fruchtbringendes Wörterbuch: W
0
1516
1093533
1068255
2026-11-08T16:14:38Z
~2026-56577-89
117089
1093533
wikitext
text/x-wiki
{{:Fruchtbringendes_Wörterbuch: Vorlage:Navigation}}
* '''Wafer:''' Halbleiterscheibe, Rohling
* '''walken:''' laufen, gehen<!--vgl. (Textilien) walken-->, siehe [[Fruchtbringendes Wörterbuch: N|Nordic Walking]]
* '''Walkman:''' Kategorie: tragbarer Kassettenspieler, mobiles Audiokassettenabspielgerät <!--(Walkman ist eine Marke)-->
* '''Wallpaper:''' Hintergrundmuster, Tapete, ggf. Hintergrundbild<!--Desktop wallpaper-->
* '''Warlord:''' Kriegsherr, Kriegsfürst, Truppenführer, <!--(Lokal-)-->Despot, ggf. Räuberfürst, Räuberhauptmann
* '''Warm-up:''' Warmlauf, Aufwärmen
* '''wash and wear:''' bügelfrei
* '''Watch-dog:''' Wächter,<!--1.--> Totmannschaltung,<!--2.--> Anstandswauwau, Aufpasser(in), ggf. Wächterschaltung
* '''Waterboarding:''' Ertränkungsfolter, Erstickungsfolter
* '''wearable computing:''' Rechnertragbarkeit
* '''Web:''' *Webb<!-- eines der schlechten Prinzipien der neuen Rechtschreibung, das e ist auch so schon kurz -->, Netz, WWW
* '''Web-:''' Netz-, Internet-<!-- Internet ≠ WWW -->
* '''Web sharing (EDV):''' Netzfreigabe, Fernfreigabe, WWW-Freigabe
* '''Webcam:''' Netzkamera, Internetkamera
* '''Webcast:''' Internetradiosendung, Netzradiosendung
* '''Webcasting:''' siehe auch [[Fruchtbringendes Wörterbuch: C|Casting]]; Netzrundfunk, Internetradio
* '''Webdesign:''' WWW-Seitengestaltung, Netzseitengestaltung
* '''Webhosting:''' Bereitstellung von Netzressourcen
* '''Webinar:''' <!--Seminar übers Netz--> Internetseminar (12/2013: 14.000), Netzseminar (12/2013: 103)
* '''Weblog<!-- (Blog)-->:''' Internettagebuch (1/2004: 1.920; 12/2004: 10.000; 04/2005: 12.200; 11/2006: 211.000), Netztagebuch (04/2005: 725; 11/2006 21.900), Netzjournal, Journal
* '''Webmaster:''' Seitenbetreuer (12/2004: 739)
* '''Webmailer:''' <!--Netzbüro-->?
* '''Website:''' Internet-Angebot (1/2004: 176.000), Internet-Auftritt (1/2004: 294.000), Netzstandort (1/2004: 89) [ISO/IEC], Netzstelle (1/2004: 72), Netzplatz, Webpräsenz, *Netzpräsenz, <!--manchmal-->Netz-Adresse, Plattform
* '''Webspace:''' Netzspeicherplatz
* '''Welcome Party:''' Begrüßungsabend, Willkommensfeier, Kennenlernfete
* '''Wellness:''' ist [[Fruchtbringendes Wörterbuch: Pseudoenglisch|Pseudoenglisch]]; Gutfühl, Wohlfühl-, Verwöhn-, Entspannungs-, Wohlfühlkur, *Wellnis, ... zum Wohlfühlen, fürs Wohlgefühl, Wohlbefinden, Wohlergehen, Wohlsein
* '''Werbespot:''' (kurzer) Werbefilm
* '''Westbank:''' West-Jordan-Land
* '''Wet computing:''' nasse Informatik
* '''Whale watching:''' Walsafari, Walbeobachtung
* '''Whataboutism, Whataboutery:''' Gegenvergleich, Gegenrechnung, Aufrechnung (für das konkrete Argument); Gegenrechnerei, Aufrechnerei (für die allgemeine Argumentationstrategie)
* '''Whats-App:''' der Säpp (Mehrzahl: die Säppen) [Spaßbildung – ähnlich wie im Engl. Ist durch andere Auftrennung der engl. Zusammensetzung entstanden und kingt dadurch an bairisch ‚Sepp‘ (d.i. ‚Joseph‘) an]
* '''Whats-App-Gruppe:''' die Funkrunde, die *Säppgruppe
* '''Whistleblower:''' *Alarmpfeifer (4/2010: 7), *Alarmpfeife, Hinweisgeber, Informant, Aufdecker, Tippgeber, Zuträger, Entlarver, Enthüller, Offenleger, Ans-Tageslicht-Bringer, Vorhanglupfer, Kartenaufdecker, Türaufstoßer, Geheimnislüfter, Ohrenbläser; ggf.(negativ konnotiert!): der Petzer, die Petze, Ausplauderer, Ausposauner, Verpfeifer, Denunziant, Anschmierer, Anschwärzer, Nestbeschmutzer, Verräter
* '''Whistleblowing:''' Alarm schlagen
* '''White-collar worker:''' (Büro-)Angestellter, Schlips<!--(träger) -->
* '''White list:''' Weiße Liste, Durchwinkliste, Verschonliste, Einschlußliste<!--, Gutliste-->
* '''Whiteout:''' Weißblendung, Milchwetter
* '''White paper:''' Weißbuch, Faktenpapier
* '''Whitespace:''' Durchschuß, Leerraum
* '''White trash:''' weißer Abschaum [gefunden in der FAZ], heruntergekommene Stammbevölkerung
* '''Who is who:''' Wer ist’s? [Hieß früher so.<!-- siehe hier das Standardwerk von (Herrmann A. L.) Degener ''Wer ist's?'': http://www.eurobuch.com/search_results.php?author=Degener&title=Wer%20ist%E2%80%99s%3F -->], Wer ist Wer?, Wer ist was?
* '''Widget:''' Vorrichtung, Gerät
* '''Widget (EDV):''' Fensterelement, Trickfenster, ''als Entsprechung zu [[Fruchtbringendes Wörterbuch:_A|Applet]] z.B. in den Betriebssystemen Android oder Windows Vista:'' Minianwendung, Miniprogramm
* '''Wildcard:''' Platzhalter (03/2004: 114.000), Joker<!--, ggf. Freilos-->
* '''win-win situation:''' Situation zum gegenseitigen Vorteil, Doppelsieg-Situation, Situation ohne Verlierer
* '''Windchill:''' Windkühle, Windfrösteln
* '''Window dressing:''' Kursaufhübschung
* '''Windsurfen:''' Brettsegeln<!--Von engl. Board-Sailing; => Surfboard = Segelbrett--> (11/2006: 812)
* '''Wingsuit:''' Flügelanzug
* '''wipe (EDV):''' ausradieren
* '''wireless:''' drahtlos, kabellos, schnurlos, Radio, Funk (für Kompositionen: Funkmaus, Funktastatur)
* '''Wireless LAN:''' Drahtlosnetzwerk (1/2006: 15.300), drahtloses Netzwerk (1/2011: 132.000), Funknetz
* '''Wishlist:''' Wunschliste
* '''Wizard:''' Assistent ''(Windows-Terminologie)'', Helferlein, Einrichtungsprogramm, Abfrageprogramm (fragt die sonst verstreuten Optionen der Reihe nach ab)
* '''WLAN-Hotspot:''' Funkzelle [gefunden bei Spiegel-Online]
* '''WLAN:''' Wireless Lan, Drahtlosnetzwerk
* '''Wohncontainer:''' Wohnbehälter
* '''Womanizer:''' Schürzenjäger, Weiber-, Frauenheld, Frauenschwarm, Herzensbrecher, Frauenaufreißer, Frauenversteher, Casanova, Verführer, Schwerenöter, Frauentyp, -liebling
* '''Woo-hoo!:''' Juhu! Hurra! Heißa! Juchhe(i)!
* '''Wording:''' Ausdrucksweise, Textgebung, Wortgebung, Wortwahl, Formulierung
* '''Working poor:''' Geringverdiener, Präkärverdiener
* '''Work-life balance:''' Vereinbarkeit von Beruf und Familie (7/2004: 22.900), Vereinbarkeit von Beruf und Privatleben (7/2004: 519).
* '''Workaholic:''' Arbeitssüchtiger, Arbeitstier
* '''Workaround (EDV):''' Umgehungslösung (8/2005: 836), Umgehung, Umschiffung, Behelf(slösung), Provisorium, ggf. Notlösung
* '''Workbench:''' Werkbank
* '''Workflow:''' Arbeitsablauf
* '''Workload:''' Arbeitsumfang, Arbeitspensum, Last
* '''Work order:''' Arbeitsauftrag
* '''Workshop:''' 1. Seminar, Arbeitstreff, Arbeitstagung, Arbeitskreis; 2. Werkstatt;
* '''Workstation (EDV):''' 1. Arbeitsplatzrechner; 2. Zahlenfresser
* '''World Wide Web (WWW):''' Weltweites Netz <!--Name-->, Weltnetz [im Gegensatz zu Internetz]
* '''Worst case:''' schlimmst(möglich)er Fall<!-- (SMF)-->, (Super-)GAU<!-- analog: SAF-->
* '''Wow!:''' (freudig erstaunter Ausruf) Donnerwetter! Toll! Wahnsinn! Potzblitz! Sapperlot!
* '''Wrap:''' Fladenwickel (Tortilla), Rolle, Wickel<!--, Teigtasche-->
* '''Wrapper:''' Hülle, Umschlag, Mantel
* '''Wrestling:''' siehe [[Fruchtbringendes Wörterbuch: C|Catchen]], Leitet sich vom Englischen Wort "Wrestling" für "Ringen" ab.
{{:Fruchtbringendes_Wörterbuch: Vorlage:Navigation}}
{{:Fruchtbringendes_Wörterbuch: Vorlage:Navigation2}}
lf2folrpvkiukt32p5eggye0b3z1mwv
Benutzer:Klaus Eifert
2
10888
1093550
1090207
2026-11-08T21:03:34Z
Klaus Eifert
1604
1093550
wikitext
text/x-wiki
__NOTOC__
{{Editcount|Klaus+Eifert}}
<div align="center" style="position:relative; top:-35px;">Am '''{{CURRENTDAYNAME}}''', dem {{CURRENTDAY}}.{{CURRENTMONTH}}.{{CURRENTYEAR}}, gibt es {{NUMBEROFARTICLES}} Kapitel in {{NUMBEROFBOOKS}} Büchern, davon {{Vorlage:NUMBEROFREADYBOOKS}} fertige</div> <!-- <blockquote width=70%; style="background:#f4f4ff; border: 2px solid #999; border-right-width: 2px"></blockquote> -->
{|
|valign="top"|
Die Wikiidee in einem Satz erklärt: '''Die Wiki-Idee ist, nie anderen, sondern immer sich selber die Arbeit aufzuhalsen.''' <small>Benutzer:Hjn</small><br />
Der vielleicht zweitwichtigste Satz: '''Sei mutig!''' <small>(aber nicht, ohne vorher gut nachzudenken!)</small>
<!-- <blockquote width=70%; style="background:#f4f4ff; border: 2px solid #999; border-right-width: 2px">
<center>''' Vom 16. bis zum 30. August mache ich Urlaub in einer Gegend ohne Internet. '''</center>
</blockquote> -->
Ich arbeite als EDV-Berater und Computertechniker.
E-Mails sind willkommen: Klicke [[Spezial:Emailuser/Klaus_Eifert|'''hier''']].
== Meine Bücher ==
[[Spezial:Recentchangeslinked/Benutzer:Klaus Eifert/ Seiten|'''alle Änderungen''' der letzten 30 Tage an meinen Büchern]]<br />
(siehe [[Computerhardware: Seiten|Computerhardware]], [[Internet: Seiten|Internet]],
[[Datensicherung: Seiten|Datensicherung]], [[Wikijunior Sprachen/ Seiten|Wikijunior Sprachen]])
<nowiki><tt></nowiki> durch <nowiki><code></nowiki> ersetzen
<!-- Die folgenden beiden Zeilen gehört zusammen. Trenne sie nicht! -->
{{Anker|Projekte}}
'''Projekte:'''
* [[Computerhardware für Anfänger]]: [[Computerhardware: Glossar|Vorlage zum Glossar]], [http://de.wikibooks.org/w/index.php?title=Spezial%3APr%C3%A4fixindex&from=Computerhardware/_NAV&namespace=0 Links auf Navigation]
* [[Hardware für Fortgeschrittene]]
* [[Computerhardware]]: [[Computerhardware: Notizen|Notizen]], ([http://de.wikibooks.org/w/index.php?title=Spezial%3APr%C3%A4fixindex&from=Computerhardware&namespace=0 Alle Seiten])
* [[Datensicherung]], [[Datensicherung für Anfänger]]: [[Datensicherung: Notizen|Notizen]], ([http://de.wikibooks.org/w/index.php?title=Spezial%3APr%C3%A4fixindex&from=Datensicherung&namespace=0 Alle Seiten]), ([http://de.wikibooks.org/w/index.php?title=Spezial%3APr%C3%A4fixindex&from=Datensicherung/_Theorie&namespace=0 Theorie], [http://de.wikibooks.org/w/index.php?title=Spezial%3APr%C3%A4fixindex&from=Datensicherung/_Werkzeuge&namespace=0 Werkzeuge], [http://de.wikibooks.org/w/index.php?title=Spezial%3APr%C3%A4fixindex&from=Datensicherung/_Beispiel&namespace=0 Beispiele])
* [[Internet für Anfänger]]: [[Internet]], [[Internet: Notizen|Notizen]], [http://de.wikibooks.org/w/index.php?title=Spezial%3AAlle+Seiten&from=Internet&to=Internetz&namespace=0 Alle Seiten], [[Internet: Glossar|Vorlage zum Glossar]], [http://de.wikibooks.org/w/index.php?title=Spezial%3APr%C3%A4fixindex&from=Internet/_NAV&namespace=0 Links auf Navigation]
* [[Interrupts 80x86]] ([http://de.wikibooks.org/w/index.php?title=Spezial%3AAllpages&from=Interrupts+80x86&namespace=0 Alle Seiten], [[Spezial:Recentchangeslinked/Interrupts_80x86| letzte Änderungen]], [http://de.wikibooks.org/w/index.php?title=Spezial:Prefixindex&from=Interrupts_80x86&namespace=1 Diskussionsseiten])
* [[Maschinensprache i8086]] ([http://de.wikibooks.org/w/index.php?title=Spezial%3AAllpages&from=Maschinensprache+i8086&namespace=0 Alle Seiten], [[Spezial:Recentchangeslinked/Maschinensprache_i8086| letzte Änderungen]], [http://de.wikibooks.org/w/index.php?title=Spezial:Prefixindex&from=Maschinensprache_i8086&namespace=1 Diskussionsseiten])
* [[Wikijunior Sprachen]]
* [[Wikibooks:Warum viele Wiki-Lehrbücher scheitern|Warum viele Wiki-Lehrbücher scheitern]]
{{Unterseiten|seite=Hilfe:Start/|titel=Hilfe:Start}}
{{Unterseiten|seite=Benutzer:Klaus Eifert/__|titel=Meine Benutzer-Unterseiten}}
{{Unterseiten|seite=Hilfe:Bilder/__|titel=Hilfe:Bilder}}
[[Benutzer Diskussion:Klaus E.|Klaus E.]], [[Benutzer Diskussion:ThePacker|ThePacker]],
[[Benutzer Diskussion:Juetho|Juetho]] und [[Benutzer:Klaus Eifert/ Benutzer|Wichtige Benutzer]]<br />
{{w|Wikipedia:Administratoren/Notizen|Admin-Notizen}}, [[/_Notizen|Notizen]], [[/_Werkstatt]]
<code><nowiki>{{inuseby|~~~~}}</nowiki></code>
<code><nowiki><br style="clear:left;" /></nowiki></code>
<nowiki><!-- Die vorstehende Überschrift dient als Ziel eines Links. Verändere sie nicht! --></nowiki><br />
<nowiki><!-- Die folgende Zeile und dient als Ziel eines Links. Die folgenden beiden Zeilen gehört zusammen. Trenne sie nicht! --></nowiki><br />
'''<nowiki>{{Anker|xyz}}</nowiki>''' Pfeile: → ← ↓ ↑ ⇒ ⇐ ⇓ ⇑ <math>
<nowiki><blockquote width=80%; style="background:#f4f4ff; border: 1px solid #999; border-right-width: 2px">xxx</blockquote></nowiki>
<code><nowiki> {{Regal|ort=EDV}} {{Vorlage:StatusBuch|0}} {{subst:Projektdefinition}} [[Kategorie:Buch]] {{Buchkandidat|201703xx}} {{subst:Willkommen|~~~|~~~~}}</nowiki></code>
=== Benutzersperrverfahren ===
Die Antragstellung sollte nicht vorrangig den Admins überlassen werden, da die Admins ohnehin oft wegen allerlei Missbrauchsvorwürfen in der Kritik stehen. Letztlich haben die Admins die Aufgabe, den Willen der Community auszuführen. Das setzt voraus, dass die Community ihren Willen äußert!
|valign="top"|
* [http://tools.wikimedia.de/~daniel/WikiSense/Contributors.php Autorenliste]
* [http://tools.wikimedia.de/~interiot/cgi-bin/Tool1/wannabe_kate?username=Klaus+Eifert&site=de.wikibooks.org Beitragszähler]
* [[:Kategorie:Vorlage für Projektarbeit|Projekt-Vorlagen]]
* [http://stats.wikimedia.org/wikibooks/EN/CategoryOverview_DE_Complete.htm Kategorienbaum]
* [http://de.wikibooks.org/w/index.php?title=Spezial%3AAllpages&from=&namespace=10 Alle Vorlagen]
* [http://de.wikibooks.org/w/index.php?title=Spezial%3AAllpages&from=&namespace=12 Alle Hilfeseiten]
* [http://de.wikibooks.org/w/index.php?title=Spezial%3AAllpages&from=&namespace=4 Alle WB-Seiten]
* [http://de.wikibooks.org/wiki/Spezial:Pr%C3%A4fixindex Alle Artikel)]
* [http://de.wikibooks.org/w/index.php?title=Spezial%3ALog&type=&user=Klaus+Eifert&page= Logbücher]
* [http://de.wikibooks.org/w/index.php?title=Spezial%3ALog&type=move&user=&page= Verschiebelogbuch]
* [http://de.wikibooks.org/wiki/Spezial:MediaWiki-Systemnachrichten System-Texte]
* [[Spezial:Log/newusers|Neue Benutzer]]
* [[Benutzer:MichaelFrey/ Kontrolle|Neue Bücher]]
* [[:Kategorie:Wikibooks: Schnelllöschkandidaten| SLA]]
* [[Wikibooks:Meinungsbilder/_Benutzersperrungen#Zusammenfassung_und_Auswertung|Benutzersperrung]]
* [[Spezial:Massenlöschung|Massenlöschung]]
* [[Hilfe:Wartungsarbeiten/ Textbausteine | '''Textbausteine''']]
* [[Benutzer:ThePacker/ Fantasy|Textbausteine TP]]
* [[Wikibooks:Meinungsbilder|Meinungsbilder]]
* [[Wikibooks:Ich brauche Hilfe|WB:Ich brauche Hilfe]]
* [[Wikibooks:Abstellraum|Abstellraum]]
* [[:Kategorie:Wikibooks:Buchkandidat|Buchkandidaten]]
* [[Mathe_für_Nicht-Freaks:_Projekte/LMU_Buchprojekte#Wie_Inhalte_in_der_Druckversion_ausgeblendet_werden_k.C3.B6nnen|Druckversion ausblenden]]
* [[:Kategorie:todo]]
Zugriffsstatistiken:
* [http://stats.wikimedia.org/wikibooks/DE/TablesWikipediaDE.htm WB Autorenaktivität]
* [http://toolserver.org/~luxo/contributions/contributions.php?user=Klaus_Eifert&lang=de alle Projekte]
* [https://tools.wmflabs.org/topviews/?project=de.wikibooks.org&platform=all-access&date=2020-04&excludes= Wikibooks April 2020]
|valign="top"|
Häufig benötigt:
* [[Benutzer:Juetho/ Druckausgaben|Juetho/ Druck]]
* {{w|Wikipedia:Richtlinien|Richtlinien}}
* {{w|Wikipedia:Textplagiat|Textplagiat}}
* {{w|Großzitat}}
* {{w|Wikipedia:Datumskonventionen|Datumskonventionen}}
* [[Bild:Commons-logo.svg|18px]] [http://commons.wikimedia.org/wiki/Special:Contributions/Sundance_Raphael Bilder SR]
* [http://commons.wikimedia.org/wiki/Category:Nuvola_icons Nuvola Icons]
* [http://meta.wikimedia.org/wiki/Hilfe:Mathematische_Formeln Math. Formeln]
Cool:
* {{w|Benutzer:Bdk/Selbstverständlichkeiten|Selbstverständlich}}
* {{w|Benutzer:Elian/Admins|Admins}}, {{w|Benutzer:Skriptor/Vorübergehende Gäste | Gäste}}
* {{w|Benutzer:Elian/WTFISNPOV|NPOV}},
* {{w|Benutzer:Elian/Der Preis der Freiheit|Preis der Freiheit}}
* {{w|Benutzer:Nina/Manifest|Manifest}}
* {{w|Benutzer:Björn_Bornhöft/DasBee/IP-Hinweise|Zensur <small>(letzer Abschnitt)</small>}}
* {{w|Wikipedia:Sei grausam|Sei grausam}}
* [http://help.wikia.com/wiki/Advice:Building_a_Community#A_wiki_is_a_volunteer_project Communitybildung]<br />
Humor:
* [[/_AGB u. a. Humor|Humor]]
* [[w:Benutzer:Thogo/Spaß|TG/Spaß]]
* [[:m:Die Falsche Version|Die Falsche Version]]
* [[:m:Wie man seine Meinung durchsetzt|seine Meinung durchsetzen]]
* [[w:Benutzer:Streifengrasmaus/Alternative Diskussionsregeln|Diskussionsregeln]]
* {{w|Benutzer:Elian/Deppenregeln|Deppenregeln}}
* {{w|Benutzer:Avatar/Wer schreibt die Wikipedia|Wer schreibt die Wikipedia}}<br />
|}
----
[[Bild:Baustelle.gif|thumb|right|250px|<code><nowiki>[[Bild:Baustelle.gif|right|250px]]</nowiki></code>]]
Gefunden:
* Wenn man den Sumpf trockenlegen will, soll man nicht die Frösche fragen. <small>Philipendula 23:16, 10. Aug 2006 (CEST)</small>
=== Zeitdiebe ===
* Es gibt Diebe, die nicht bestraft werden und einem das Kostbarste stehlen: die Zeit. <small> Napoleon Bonaparte</small>
* Popper: „Wer’s nicht einfach und klar sagen kann, der soll schweigen und weiterarbeiten, bis er’s klar sagen kann“
<blockquote width=70%; style="background:#f4f4ff; border: 2px solid #999; border-right-width: 2px">
<center>Sag, was du willst, kurz und bestimmt, lass alle schönen Phrasen fehlen.<br />
Wer nutzlos unsere Zeit uns nimmt, bestiehlt uns – und du sollst nicht stehlen.
'''</center>
</blockquote>
<div style="text-align:right;font-style:italic;font-size:95%;margin-left:30%;margin-bottom:5%">
Um Experten zum Mitwirken und Bleiben zu bewegen, darf nur wenig Geduld für diejenigen aufgebracht werden, die die Ziele der Wikipedia nicht verstehen, und erst recht nicht für jene anmaßenden Kleingeister, die nicht in der Lage sind, konstruktiv mit anderen zusammenzuarbeiten oder ihre eigenen Wissenslücken wahrzunehmen (insgesamt die störendste Gruppe in der Wikipedia). Eine weniger nachsichtige Haltung gegen Störungen würde das Projekt wesentlich freundlicher, einladender und offener für die große Mehrheit der intelligenten, wohlgesinnten Menschen im Internet machen.
:-- [[w:Larry Sanger|Larry Sanger]], Mitbegründer der Wikipedia
</div>
[[Kategorie:User ru-3]]
[[Kategorie:User en-1]]
0uu4ldb4etcjuhz8aodx8zyqghpqw1t
Traktorenlexikon: ARGO
0
17880
1093570
1066618
2026-11-09T10:31:24Z
~2026-51726-01
116953
1093570
wikitext
text/x-wiki
{{:Traktorenlexikon: Navigation}}
Die '''ARGO Tractors [[w:Aktiengesellschaft (Italien)|S.p.A.]]''' ist ein Unternehmen des [[w:ARGO|ARGO S.p.A]] Konzerns mit Sitz in [[w:Fabbrico|Fabbrico]] in Italien.<ref name="Unternehmen">''[https://www.argotractors.com/de/wer-wir-sind/ www.argotractors.com - Unternehmen - Wer wir sind]''</ref> Sie ist im Besitz der italienischen Familie Morra. Jährlich werden ca. 22.000 (Stand 2017) Traktoren<ref name="Unternehmen"/> der Marken [[Traktorenlexikon: Landini|Landini]], [[Traktorenlexikon: McCormick|McCormick]] und [[Traktorenlexikon: Valpadana|Valpadana]] gefertigt und vermarktet.
==Geschichte==
'''1987''' wurde Pegoraro, ein Hersteller von Bodenbearbeitungsmaschinen, übernommen.
'''1994''' von [[Traktorenlexikon: Massey Ferguson|Massey Ferguson]] wird die Aktienmehrheit an [[Traktorenlexikon: Landini|Landini]] erworben.
'''1995''' [[Traktorenlexikon: Valpadana|Valpadana]] kommt hinzu.
'''1999''' Durch die Vereinigung von [[Traktorenlexikon: Case-IH|Case-IH]] und [[Traktorenlexikon: New Holland| New Holland]] zu [[Traktorenlexikon: CNH|Case New Holland]] mussten diese "aus kartellrechtlichen Gründen" Werke und Marken verkaufen. Die Marke McCormick und ihr Werk in Doncaster wurde von der ARGO übernommen.
'''2001''' wurde die italienische [[w:Laverda S.p.A.|Laverda S.p.A.]] übernommen.
'''2004''' die Laverda S.p.A. Übernimmt die Fella-Werke.
'''2007''' Gründung der ARGO Tractors S.p.A. zur Neustrukturierung des Traktorenbaus.<ref name="Unternehmen"/>
Die Fabrik im englischen Doncaster wird geschlossen. Seitdem werden die Traktoren in Italien hergestellt.<ref>{{Internetquelle | url=http://www.fwi.co.uk/articles/14/12/2007/108728/mccormick39s-doncaster-tractor-factory-shuts-its.htm | titel=McCormick's Doncaster tractor factory shuts its doors | autor=Peter Hill | hrsg=Farmers Weekly | datum=2007-12-14 | zugriff=2013-12-23}} </ref>
'''2011''' ARGO verkauft seine Getriebefertigung in Saint Dizier an [[Traktorenlexikon: YTO|YTO]].
'''2018''' [[w:Joint-Venture|Jointventure]] mit der Anadolu-Gruppe. Ein gemeinsammes Werk wird im türkischen Landkreis [[w:Çayırova|Çayırova]] errichtet.<ref name="Unternehmen"/>
==Typen==
Unter dem Markennamen ARGO werden keine Traktoren vertrieben sondern u.a. die folgenden Marken:
*[[Traktorenlexikon: Landini|Landini]], Traktoren
*[[Traktorenlexikon: McCormick|McCormick]], Traktoren
*[[Traktorenlexikon: Valpadana|Valpadana]], Kleintraktoren
* S.E.P., Einachsschlepper und Mähmaschinen
==Weblinks==
{{Wikipedia1|ARGO}}
* [http://www.argotractors.com/de/ Homepage von ARGO Tractors]
* [https://www.youtube.com/watch?v=P3bl2vjG_ww ARGO - Die Geschichte hinter Landini, McCormick und Valpadana] 2026, 08:34 Min. (YouTube)
==Einzelnachweise==
<references />
{{:Traktorenlexikon: Navigation}}
1qv5yiv07qgchahx1gor3qpesbfebhb
Hardware für Fortgeschrittene
0
101274
1093551
850276
2026-11-08T21:06:01Z
Klaus Eifert
1604
1093551
wikitext
text/x-wiki
{{Vorlage:StatusBuch|1}}
<div style="float:right; margin-left:20px; margin-bottom:20px; font-size:0.9em;"> __TOC__ </div>
* [[Computerhardware: VorwortF|Vorwort]]
== Zentraleinheit ==
* [[Computerhardware: BIOS Grundbegriffe|Grundbegriffe rund ums BIOS]]
* [[Computerhardware: CMOS und RTC|CMOS, RTC, BIOS]]
* [[Computerhardware: Busse|Bus-Systeme]]
* [[Computerhardware: USB-Bus|USB-Bus]]
* [[Computerhardware: Energiesparfunktionen|Energiesparfunktionen]]
== Kühlung ==
* [[Computerhardware: Wichtigkeit der Kühlung|Wichtigkeit der Kühlung]]
* [[Computerhardware: Der leise PC|Der leise PC]]
* [[Computerhardware: Leise Komponenten|Leise Komponenten]]
== RAM ==
* [[Computerhardware: RAM: Grundwissen|Grundwissen]]
== Massenspeicher ==
* [[Computerhardware: Firmware|Firmware]]
* [[Computerhardware: SSD: Details|SSD Details]]
== Optische Massenspeicher ==
* [[Computerhardware: Red Book: Audio-CD|Red Book: Audio-CD]]
== Netzteil ==
* [[Computerhardware: Wirkungsgrad|Wirkungsgrad]]
== Wunsch-PC zusammenstellen ==
* [[Computerhardware: Komponenten: Kriterien|Kriterien]]
== Den Wunsch-PC montieren ==
----
[[Computerhardware: Musterkapitel|Musterkapitel]]
[[Kategorie:Buch]]
owgmcfdj0q0wbd8xeyrd7ncseqab519
Astronomie von der Frühgeschichte bis zur Neuzeit/ Astronomische Bezugssysteme
0
114817
1093527
1093177
2026-11-08T13:30:35Z
Bautsch
35687
/* Königssterne */ Präzessionsaspekt
1093527
wikitext
text/x-wiki
[[Datei:Armillarsphaere.Historisches.Museum.Basel.P1023929.jpg|mini|rechts|hochkant=1.5|Eine historische '''Armillarsphäre''' im Historischen Museum in Basel. Die drei gegeneinander geneigten Ringe mit den Teilkreisen in der Mitte der Kugel stehen für die Ebenen des '''Äquators''', des '''Horizonts''' und der '''Ekliptik'''.]]
Bei der unmittelbaren Beobachtung der Bahnen der Fixsterne gibt es zwei natürliche Bezugssysteme, nämlich das horizontale und das äquatoriale. Für die Beobachtung der sieben gegenüber dem Fixsternhimmel beweglichen Wandelgestirne ist es sinnvoll, neben der '''Horizontebene''' und der '''Äquatorebene''' eine weitere Ebene einzuführen, nämlich die '''Ekliptikebene'''. Der Name '''Ekliptik''' leitet sich von der lateinischen Bezeichnung ''linea ecliptica'' (''Verdeckungslinie'') ab, die wiederum auf das altgriechische Wort ''ἐκλειπτική'' (''ekleiptikē'' für ''verdeckend'') zurückgeht. Die sieben Wandelgestirne können sich entlang der Ekliptiklinie bei Konjunktionen nicht nur begegnen, sondern die nähergelegenen können die fernerliegenden Wandelgestirne manchmal sogar bedecken, wie zum Beispiel bei Mond- oder Sonnenfinsternissen sowie bei Transiten.
In der folgenden Tabelle sind wichtige Eigenschaften der drei genannten Bezugssysteme zusammengefasst:
{| class="wikitable"
|+ Polare terrestrische Bezugssysteme
! Merkmal !! Horizontsystem || Äquatorsystem || Ekliptiksystem
|-
| '''Zentrum''' || Standpunkt auf<br/>der Erdoberfläche || Erdmittelpunkt || Erdmittelpunkt
|-
| '''Hauptrotationsachse''' || Lotgerade || Erdachse || Erdbahnachse
|-
| '''Oberer Pol der Hauptrotationsachse''' || Zenit || Himmelsnordpol || Ekliptiknordpol
|-
| '''Unterer Pol der Hauptrotationsachse''' || Nadir || Himmelssüdpol || Ekliptiksüdpol
|-
| '''Bezugsebene senkrecht zur Hauptrotationsachse''' || Horizontebene || Äquatorebene || Ekliptikebene
|-
| '''Rand der Bezugsebene''' || Horizont || Himmelsäquator || Ekliptiklinie
|-
| '''Bezugsrichtung in der Bezugsebene''' || Norden || Frühlingspunkt || Frühlingspunkt
|-
| '''Winkelkoordinate in der Bezugsebene''' || Azimut<br/>('''rechtsläufig''') || Rektaszension<br/>(linksläufig) || Ekliptikale Länge<br/>(linksläufig)
|-
| '''Winkelkoordinate senkrecht zur Bezugsebene'''<br/>(nach Norden positiv, nach Süden negativ) || Höhenwinkel || Deklinationswinkel || Ekliptikale Breite
|}
[[Datei:Triangle sphérique.svg|mini|rechts|hochkant=1|Die drei Punkte <math>A</math>, <math>B</math> und <math>C</math> auf der Einheitskugel bilden ein '''sphärisches Dreieck''' mit den Bogenlängen der Dreiecksseiten <math>a</math>, <math>b</math> und <math>c</math> sowie den Dreieckswinkeln <math>\alpha</math>, <math>\beta</math> und <math>\gamma</math>.]]
Allen drei polaren Bezugssystemen ist gemein, dass eine beliebige Richtung zu einem Himmelsobjekt mit zwei Winkelangaben beschrieben werden kann. Hierzu wird für die Einheitskugel eine Bezugsebene definiert, die durch einen Großkreis der Einheitskugel läuft. Vom Zentrum der Einheitskugel aus gesehen wird innerhalb dieser Bezugsebene dann noch eine ausgezeichnete Bezugsrichtung festgelegt. Der erste Winkel wird von dieser Bezugsrichtung aus in der Bezugsebene gemessen, und der zweite Winkel wird senkrecht zur Bezugsebene ermittelt. Die beiden Pole des entsprechenden Bezugssystems stehen dann im Mittelpunkt der Einheitskugel exakt im rechten Winkel zur Bezugsebene. Durch die Verwendung der Einheitskugel sind die Bogenlängen auf beliebigen sphärischen Dreiecksseiten identisch mit den entsprechenden Mittelpunktswinkeln (Zentriwinkeln).
Zwischen den Bezugssystemen können die beiden jeweiligen Winkelkoordinaten mithilfe von geometrischen Transformationen eindeutig abgebildet werden. Hierfür ist die Betrachtung von sphärischen Dreiecken auf der Einheitskugel hilfreich und anschaulich. Der islamischen Mathematik des späten Frühmittelalters verdanken wir den '''Sinussatz für sphärische Dreiecke''', mit dem die '''sphärische Trigonometrie''' begründet wurde.<ref>{{Literatur |Autor=Victor J. Katz |Titel=A History of Mathematics – An Introduction |Auflage=3 |Verlag=Addison-Wesley / Pearson |Ort=Boston |Datum=2009 |ISBN=978-0-321-38700-4 |Seiten=311}}</ref> Bei diesem Sinussatz werden die drei Winkel <math>\alpha</math>, <math>\beta</math> und <math>\gamma</math> in den Dreieckspunkten <math>A</math>, <math>B</math> und <math>C</math> mit den Bogenlängen der drei jeweils gegenüberliegenden Seiten <math>a</math>, <math>b</math> und <math>c</math> ins Verhältnis gesetzt, und diese Verhältnisse sind identisch:
:<math>\frac {\sin a} {\sin \alpha} = \frac {\sin b} {\sin \beta} = \frac {\sin c} {\sin \gamma}</math>
Dies bedeutet insbesondere, dass ein sphärisches Dreieck mit drei gleichlangen Bogenlängen auch drei gleiche Winkel hat und umgekehrt.
Bei einem gleichschenkligen sphärischen Dreieck, dessen Punkt <math>C</math> sich im Pol der Bezugsebene befindet und dessen gleichlange Schenkel <math>a = b</math> rechtwinklig auf die dritte Dreiecksseite in der Bezugsebene stoßen <math>\left( \sin \alpha = \sin \beta = 1 \right)</math>, ist der Sinus der Bogenlänge <math>\sin c</math> dieser dritten Dreiecksseite proportional zum Sinus des Winkels <math>\sin \gamma</math> zwischen den beiden gleichlangen Schenkeln:
:<math>\frac {\sin c} {\sin \gamma} = \sin a = \sin b</math>
Wenn die beiden gleichlangen Schenkel vom Polpunkt <math>C</math> bis zur Bezugsebene reichen <math>\left( \sin a = \sin b = 1 \right)</math>, dann entspricht der Winkel <math>\gamma</math> genau dem Drehwinkel <math>c</math> in der Bezugsebene um deren Polachse beziehungsweise der entsprechenden Bogenlänge in der Bezugsebene:
:<math>\frac {\sin c} {\sin \gamma} = 1 \, \Longrightarrow \, \sin c = \sin \gamma \, \Longrightarrow \, c = \gamma</math>
Die beiden gleichlangen Schenkel <math>a</math> und <math>b</math> werden durch die Drehung eines der beiden Schenkel um diesen Drehwinkel um die Polachse <math>c = \gamma</math> folglich zur Deckung gebracht
<div style="clear:both"></div>
==Der Horizont==
[[Datei:Compass rose german.svg|mini|Kompassrose mit den Abkürzungen der Himmelsrichtungen.]]
Das horizontale Koordinatensystem entspricht der täglichen Erfahrung der Umwelt, da die beiden Augen des Menschen in der Regel horizontal nebeneinander ausgerichtet sind. Ein Stein fällt im Horizontsystem immer senkrecht von oben nach unten in Richtung Erdmittelpunkt. Es ist das am häufigsten verwendete Koordinatensystem für die Orientierung im Alltag. Der ideale Horizont ist eine Kreislinie, in deren Mittelpunkt der Beobachter steht. Die Lotrichtung steht senkrecht auf dem entsprechenden Kreis, und deswegen hat jeder Punkt auf der Erdoberfläche ein anderes Horizontsystem, in welchem zu jedem Zeitpunkt ein anderer Ausschnitt des Himmels gesehen werden kann.
Für die Angabe von Richtungen werden die Haupthimmelsrichtungen '''Norden''', '''Osten''', '''Süden''' und '''Westen''' verwendet. Der mathematische Horizont befindet sich rund um einen Beobachter genau in der gleichen Höhe über der Erdoberfläche und spannt die Horizontebene auf. Die vier Haupthimmelsrichtungen liegen dabei in der Horizontebene und jeweils senkrecht zu ihren beiden benachbarten Haupthimmelsrichtungen.
In Bezug auf die Nordrichtung oder alternativ in Bezug auf die Südrichtung kann auch der '''Azimut''' als rechtsläufiger Winkel <math>a</math> angegeben werden, wobei bei Bezug auf Norden die Nordrichtung 0 Bogengrad entspricht, die Ostrichtung 90 Bogengrad, die Südrichtung 180 Bogengrad und die Westrichtung 270 Bogengrad.
Die Höhe über dem Horizont wird als '''Höhenwinkel''' <math>h</math> von 0 bis 90 Bogengrad angegeben, wobei 0 Bogengrad auf dem Horizont und 90 Bogengrad senkrecht über dem Beobachter im '''Zenit''' liegt. Negative Winkel liegen unter dem Horizont, und der '''Nadir''' liegt exakt unter dem Beobachter bei einem Höhenwinkel von -90 Bogengrad. Der '''Meridian''' ist der Großkreis, der durch den Nord- und Südpunkt sowie durch Zenit und Nadir geht.
Von der Erde aus kann die Lage aller Objekte im Horizontsystem eindeutig bestimmt werden, wobei sich die Richtungen und Höhen der Gestirne am Himmel durch die Rotation der Erde kontinuierlich ändern. Nach einem siderischen Tag, der wegen der gleichzeitigen Bewegung der Erde um die Sonne knapp vier Minuten kürzer ist als ein durchschnittlicher Sonnentag (auch bürgerlicher Tag oder Kalendertag), ist ein Stern von einem bestimmten Punkt auf der Erdoberfläche wieder in der gleichen Himmelsrichtung (Azimut) und in der gleichen Höhe über dem Horizont zu sehen. Die Lage der Himmelsrichtungen kann also durch die Bewegung der Sonne oder der Sterne bestimmt werden.
Es gibt verschiedene weitere Möglichkeiten, die Richtungen im Horizontsystem mit einfachen Mitteln zu ermitteln. Selbst als es noch keine Kompasse gab, war es möglich, die Himmelsrichtungen zu bestimmen:
Die Himmelspole (siehe unten) befinden sich in der Verlängerung der Erdachse und zeichnen sich dadurch aus, dass sich ihre Lage und die Lage der dort am Himmel befindlichen Fixsterne gegenüber dem Horizontsystem trotz der Erdrotation innerhalb eines Tages nicht ändert. Diese Lage lässt sich durch die Beobachtung der in der Nähe der Pole gelegenen zirkumpolaren Sterne, die nie unter den Horizont fallen, leicht herausfinden. Heute markiert der Polarstern (Polaris, α Ursa Minor) ungefähr den Himmelsnordpol. Durch die Präzession der gegen die Ekliptik geneigten Erdachse wandern die Himmelspole im Laufe von Jahrtausenden allerdings auf kreisförmigen Bögen um die Pole der Ekliptik, so dass ein bestimmter Ort auf diesen Bögen ungefähr alle 25800 Jahre von den Himmelspolen erreicht wird. Fällt man von einem Himmelspol das Lot auf den Horizont, findet man dort auf der Nordhalbkugel den Nordpol beziehungsweise auf der Südhalbkugel den Südpol.
Bei den beiden Tag-und-Nacht-Gleichen zum Frühlingsanfang und zum Herbstanfang, geht die Sonne exakt im Osten oder im Westen auf und unter.
Alle Gestirne kulminieren auf dem Meridian. Auf der Nordhalbkugel kann dies auf dem südlichen Meridian anhand der maximalen Höhe über dem Horizont beobachtet werden, und auf der Südhalbkugel auf dem nördlichen Meridian. Bei der '''oberen Kulmination''' der Sonne oder des Mondes auf dem Meridian erreicht der durch das Licht der Himmelskörper hervorgerufene Schatten eines senkrecht auf der Erdoberfläche stehenden Stabes seine kürzeste Länge in Richtung zu den Himmelspolen beziehungsweise zu den Polen der Erdachse (siehe auch [[Quadriviale_Kuriositäten/_Stabdolche|Stabdolche]]).
<gallery caption="Der Sternenhimmel auf 53 Bogengrad nördlicher Breite zur Tag-und-Nacht-Gleiche im Frühling mit Darstellung in Blickrichtung Horizont in Mercator-Projektion" perrow=2 mode=packed widths=480 heights=270 style="text-align: left">
hozizontal.Morgen.Fruehling.png|Morgens beim Sonnenaufgang genau in Richtung Osten: flache Ekliptik (gelb), Äquator (hellblau), horizontales Koordinatensystem mit Meridian (grün).
hozizontal.Abend.Fruehling.png|Abends bei Sonnenuntergang genau in Richtung Westen: steile Ekliptik (gelb), Äquator (hellblau), horizontales Koordinatensystem mit Meridian (grün).
</gallery>
=== Kimmtiefe ===
[[Datei:Zenit-Nadir-Horizont.svg|mini|Die Lage vom Zenit, vom Nadir sowie vom senkrecht zur Verbindungslinie von Zenit und Nadir befindlichen mathematischen Horizont und vom freisichtigen Landschaftshorizont für einen Beobachter auf der Erdoberfläche.]]
Im Jahr 1023 ermittelte der persische Universalgelehrte al-Biruni mit einem von ihm entwickelten Messverfahren mit einer beachtlichen Genauigkeit den Radius der Erdkugel. Hierfür bestimmte er die Höhe eines Berges über dem Ozean sowie die von dort zu beobachtende Kimmtiefe, also den Winkel zwischen dem mathematischen Horizont und dem Landschaftshorizont. Die atmosphärische Refraktion, die diesen Messwert beeinflusst, kannte er allerdings noch nicht und konnte sie deswegen auch nicht berücksichtigen.
→ Zur mathematische Definition der Kimmtiefe und zur Näherungsrechnung siehe [[Quadriviale_Kuriositäten/_Die_Stele_vom_Rocher_des_Doms#Kimmtiefe|Kimmtiefe]].
→ Zur atmosphärischen Refraktion siehe [[Quadriviale_Kuriositäten/_Die_Stele_vom_Rocher_des_Doms#Atmosphärische Refraktion|atmosphärische Refraktion]].
=== Die Auf- und Untergänge ===
Bei jahrelanger Betrachtung des Nachthimmels wird es jedem aufmerksamen Beobachter auffallen, dass alle Sterne stets an der gleichen Stelle des Horizonts auf- und untergehen. Auf- und Untergang geschehen in Bezug auf die Fixsterne jedoch Tag für Tag knapp vier Minuten früher, bevor nach einem vollständigen Sonnenjahr erneut die gleichen Tageszeiten erreicht werden. Auf diese Weise ist nachts der gesamte Himmel der Hemisphäre im Laufe eines Jahres zu sehen. In einem Abstand von sechs Monaten (also einem halben Jahr) sieht der Nachthimmel zur gleichen Nachtzeit demzufolge vollkommen anders aus.
Alle Objekte auf dem Himmelsäquator gehen täglich zu sich um knapp vier Minuten verschiebenden Tageszeiten genau im Osten auf und genau im Westen unter. Zu den Sternen im Bereich des Himmelsäquators gehören zum Beispiel der rechte Gürtelstern Mintaka (δ Orionis) im Sternbild Orion, die Sterne Zaniah (η Virginis), Porrima (γ Virginis) und Heze (ζ Virginis) im Sternbild Jungfrau (Virgo), der Stern Almizan III (θ Aquilae) in der linken Flügelspitze des Sternbilds Adler (Aquila) sowie der Stern Sadalmelik (α Aquarii) im Sternbild Wassermann (Aquarius).
Je nach geographischer Breite der Beobachtung gibt es mehr oder weniger Sterne die nie untergehen beziehungsweise nie aufgehen. Diese Sterne werden als '''zirkumpolar''' bezeichnet. Am Nordpol und am Südpol der Erde sind alle Sterne stets zirkumpolar. Vom Erdäquator aus ist kein Stern zirkumpolar, so dass innerhalb eines Tages jeder Stern zwölf Stunden lang über dem Horizont und zwölf Stunden lang unter dem Horizont steht.
<gallery caption="Zirkumpolarität" perrow=2 widths=480 heights=480>
2016-11 Aurora circumpolar Shipshaw river Saguenay 02.jpg|Langzeitbelichtete Aufnahme des Nachthimmels in Richtung Norden. Während der Aufnahme bewegten sich alle Sterne entgegen dem Uhrzeigersinn um den Himmelsnordpol. In unmittelbarer Nähe des Himmelsnordpols oben in der Mitte befindet sich der Polarstern (Polaris) im Sternbild Kleiner Bär (Urs Minor), der seine Lage während der Aufnahme kaum verändert und deswegen keine Spur erzeugt hat. Unten im grünlichen Polarlicht sind noch die Sternspuren von '''zirkumpolaren''' Sternen zu sehen, die nie unterhalb des Horizonts auftauchen. Die weiter außen den Horizont kreuzenden Sternspuren markieren deren Untergänge (links hinter den Silhouetten der Bäume in Richtung Westen) und deren Aufgänge (rechts in Richtung Osten).
Zirkumpolaritaet.png|Tägliche Sternenbahnen im horizontalen (grün) System mit den Auf- und Untergangspunkten am Horizont beziehungsweise den zirkumpolaren Kreisbahnen in Polnähe. Der Betrachter befindet sich im Mittelpunkt (schwarz) der grünen Scheibe, die die Horizontebene repräsentiert.
</gallery>
==Die Himmelspole==
[[Datei:Himmelskoordinaten.png|mini|hochkant=2|Beziehung zwischen horizontalem und äquatorialem Koordinatensystem bei einer Himmelsbeobachtung auf dem Breitengrad <math>\phi</math>.<br/>Im '''Horizontsystem''' die vier Himmelsrichtungen Norden (N), Osten (O), Süden (S) und Westen (W), senkrecht nach oben der Zenit, senkrecht nach unten der Nadir, die orthogonalen Koordinaten <math>x</math>, <math>y</math> und <math>z</math> sowie der Azimut <math>a</math> und der Höhenwinkel <math>h</math>.<br/>Im '''Äquatorialsystem''' die beiden Himmelspole Nordpol und Südpol, der Stundenwinkel <math>\tau</math> und die Deklination <math>\delta</math>.]]
Ein '''Tag''' ist durch die Eigenrotation der Erde um ihre Achse definiert, die durch den geographischen '''Nordpol''' und '''Südpol''' verläuft. In ihren Verlängerungen markiert diese Achse den '''Himmelsnordpol''' beziehungsweise den '''Himmelssüdpol'''.
Die Himmelspole sind die beiden Schnittpunkte der gedachten Verlängerung der Rotationsachse der Erde mit der Himmelssphäre. Wo die Sterne an der Horizontlinie auf- und untergehen, hängt von der geographischen Breite der Beobachtung ab. So sind genau auf dem Nordpol der Erde alle Sterne der nördlichen Hemisphäre zirkumpolar und der '''Himmelsnordpol''' steht im Zenit. Genau auf dem Südpol der Erde sind alle Sterne der südlichen Hemisphäre zirkumpolar und der Himmelssüdpol steht im Zenit.
Der '''Himmelsäquator''' ist die Projektion des Erdäquators in die Himmelssphäre. Er steht demzufolge senkrecht zur Polachse. Beobachter auf dem Erdäquator sehen den Himmelsäquator von Osten genau über den Zenit nach Westen laufen. Auch für alle zwischen Äquator und Pol positionierten Beobachter kreuzt der Himmelsäquator den Horizont stets exakt in östlicher und in westlicher Richtung, erreicht dabei allerdings nicht den Zenit. Der Winkelabstand des Zenits zum Himmelsäquator <math>z</math> ('''Zenitabstand''') ergibt sich unmittelbar aus der geographischen Breite <math>\phi</math> der Beobachtung:
:<math>z = 90^\circ - \phi</math>
Bei nächtlichen Beobachtungen der Fixsterne fällt auf, dass diese sich innerhalb eines siderischen (lateinisch ''sideris'' = ''des Sterns'', also auf den Fixsternhimmel bezogenen) Tages von knapp 24 Stunden immer auf dem gleichen Kreis von Osten nach Westen einmal um die '''Himmelspole''' drehen und danach im Bezug zum Horizontsystem wieder an der gleichen Stelle stehen. Ein siderischer Tag dauert hierbei ungefähr vier Minuten kürzer als ein Sonnentag, weil die Sonne sich bezogen auf den Fixsternhimmel scheinbar - bedingt durch den Umlauf der Erde um die Sonne - täglich um ein kleines Stück nach Osten (auf der nördlichen Halbkugel also nach links) bewegt. Nach einem Jahr summieren sich diese täglichen Differenzen zu einem ganzen Tag auf, so dass sich jeder beliebige Stern nach einem Sonnenjahr zur gleichen Tageszeit auf- und untergeht beziehungsweise sich zu den gleichen Tageszeiten an der gleichen Stelle im Horizontsystem beziehungsweise in der entsprechenden Himmelsrichtung befindet. Dies kann durch die folgenden überschlägigen Rechnungen leicht nachvollzogen werden:
:<math>4 \,\frac {\text{Minuten}} {\text{Tag}} \cdot 360 \,\frac{\text{Tage}} {\text{Jahr}} = 1440 \,\frac {\text{Minuten}} {\text{Jahr}}</math>
:<math>\frac {1440 \,\frac {\text{Minuten}} {\text{Jahr}}} {60 \,\frac {\text{Minuten}} {\text{Stunde}}} = 24 \,\frac {\text{Stunden}} {\text{Jahr}}</math>
:<math>\frac {24 \,\frac {\text{Stunden}} {\text{Jahr}}} {24 \,\frac {\text{Stunden}} {\text{Tag}}} = 1 \,\frac {\text{Tag}} {\text{Jahr}}</math>
Der nördliche Himmelspol ist heute leicht durch den Polarstern (Polaris) im Kleinen Bären (Ursa Minor) zu finden, der die ganze Nacht (und den ganzen Tag) an derselben Stelle ziemlich genau im Norden des horizontalen Bezugssystems liegt. Alle anderen Sterne verändern im horizontalen Bezugssystem ständig ihre Lage.
Die Sterne in der Nähe des sichtbaren Himmelspols sind für einen bestimmten Beobachtungspunkt immer über dem Horizont und werden '''zirkumpolare''' Sterne genannt. Die zirkumpolaren Sterne des gegenüberliegenden, nicht sichtbaren Himmelspols sind nie zu sehen. Am Nordpol und am Südpol der Erde sind alle Sterne der jeweiligen Hemisphäre zirkumpolar, auf dem Äquator der Erde ist es keiner. Wegen der Neigung der Ekliptik ist von überall auf der Erde aus gesehen kein einziges ekliptikales Sternbild der Lebewesenkreiszeichen vollständig zirkumpolar.
Alle sichtbaren Sterne, die nicht zirkumpolar sind, gehen im Verlauf eines Vierundzwanzigstundentages irgendwann am östlichen Horizont auf und am westlichen Horizont unter. Die Sterne genau in der Mitte zwischen den beiden Himmelspolen liegen auf dem '''Himmelsäquator''', und sie beschreiben den größten Tageskreis am Himmel, der jeweils exakt 180 Bogengrad über dem und unter dem Horizont verläuft.
Die beiden Winkel im '''äquatorialen Koordinatensystem''', die die Lage eines beliebigen Himmelskörpers definieren, sind der '''Stundenwinkel''' <math>\tau</math> oder die '''Rektaszension''' <math>\alpha</math> entlang des Himmelsäquators und die '''Deklination''' <math>\delta</math> senkrecht dazu in Richtung der Himmelspole, nach Norden positiv und nach Süden negativ. Der Stundenwinkel eines Himmelsobjekts entspricht der Zeit, die seit dem letzten Durchgang des betreffenden Himmelsobjekts durch den Meridian vergangen ist, und Stundenwinkel und Rektaszension werden daher meist in Stunden angegeben. Die Rektaszension wird allerdings auf den [[Die Himmelstafel von Tal-Qadi#Der Frühlingspunkt|Frühlingspunkt]] bezogen, der sich zum Frühlingsanfang in der Sonnenmitte befindet. Die Rektaszension und die Deklination aller Fixsterne sind abgesehen von deren geringfügiger Eigenbewegung und der Verschiebung des Frühlingspunktes durch die sehr langsame Präzession der Erdachse innerhalb von wenigen Jahren praktisch konstant und werden daher in Sternenkatalogen angegeben. Die größte Differenz von Deklinationen gleichzeitig sichtbarer Himmelsobjekte wird immer in südlicher Richtung auf dem Meridian erreicht die kleinste Differenz in nördlicher Richtung auf dem Meridian.
Die '''Polhöhe''' <math>\phi</math> ist der kleinste Winkel zwischen dem Horizont und einem Himmelspol entlang des Meridians, der genau der geographischen Breite des entsprechenden Beobachters auf der Erdkugel entspricht. Der Winkel zwischen Zenit und Himmelspol ergänzt die Polhöhe zu einem rechten Winkel mit 90 Bogengrad und entspricht gleichzeitig der Neigung zwischen Horizontalebene und Äquatorialebene. Beide Bezugssysteme teilen sich sowohl den '''Ostpunkt''' als auch den '''Westpunkt'''. Am Nordpol ist die Polhöhe +90 Bogengrad, am Südpol ist sie -90 Bogengrad, und auf dem Äquator beträgt sie 0 Bogengrad.
<gallery caption="Der Sternenhimmel auf 53 Bogengrad nördlicher Breite zur Tag-und-Nacht-Gleiche im Frühling mit Darstellung in Blickrichtung Himmelsäquator (hellblau) in Mercator-Projektion" perrow=2 mode=packed widths=600 heights=360>
aequatorial.Morgen.Fruehling.png|Morgens beim Sonnenaufgang genau in Richtung Osten: nach unten gewölbte Ekliptik (gelb), horizontales Koordinatensystem mit Meridian und Zenit grün.
aequatorial.Abend.Fruehling.png|Abends bei Sonnenuntergang genau in Richtung Westen: nach oben gewölbte Ekliptik (gelb), horizontales Koordinatensystem mit Meridian und Zenit grün.
</gallery>
==Der Frühlingspunkt==
[[Datei:Ecliptic-4.svg|mini|hochkant=2|Die um <math>\epsilon</math> geneigte Lage der kreisbogenförmigen Ekliptik in Bezug zum Himmelsäquator mit seinem äquatorialen Koordinatensystem mit den Koordinaten <math>\alpha</math> (Rektaszension) und <math>\delta</math> (Deklination), die hier für die ekliptikale Länge <math>\lambda</math> dargestellt sind.]]
Der Frühlingspunkt ('''Äquinoktialpunkt''') hatte und hat eine herausragende Bedeutung in der Himmelskunde. Wenn die Sonne (und mit ihr ein gleichzeitig auftretender Neumond) im Frühlingspunkt steht, geht sie zum Frühlingsanfang dort überall auf der Erde morgens um 6 Uhr Ortszeit genau im Osten auf und abends um 18 Uhr Ortszeit exakt im Westen unter. Da der Vollmond von der Erde aus gesehen der Sonne immer gegenübersteht, steht ein Vollmond, der zum Frühlingsanfang auftritt, gegenüber dem Frühlingspunkt im Herbstpunkt und geht abends gegen 18 Uhr im Osten auf und morgens gegen 6 Uhr im Westen unter.
Umgekehrt steht die Sonne (und mit ihr ein gleichzeitig auftretender Neumond) zum Herbstanfang im Herbstpunkt und geht dort überall auf der Erde morgens um 6 Uhr Ortszeit genau im Osten auf und abends um 18 Uhr Ortszeit exakt im Westen unter. Ein gleichzeitig auftretender Vollmond befindet sich dann in der Nähe des Frühlingspunktes und geht morgens um 6 Uhr Ortszeit im Osten auf und abends um 18 Uhr Ortszeit im Westen unter.
Der Frühlingspunkt durchwandert innerhalb eines Tages den Großkreis des Himmelsäquators einmal vollständig. Da die Sonne im Gegensatz zum feststehenden Frühlingspunkt innerhalb eines Sonnentages von exakt 24 Stunden à 60 Minuten knapp ein Dreihundertsechzigstel (also ein Bogengrad) auf dem Ekliptikkreis entgegen der täglichen Sonnenbahn weitergelaufen ist, erreicht sie dieselbe Höhe über dem Horizont oder denselben Meridian bei der Kulmination auf demselben erst etwas später als der Frühlingspunkt, Die folgende Abschätzung ergibt die ungefähre Zeitdifferenz:
:<math>24 \, \text {h} \cdot 60 \frac {\text {min}} {\text {h}} = 1440 \, \text {min}</math>
:<math>\frac {1440 \, \text {min}} {360\text {°}} = 4 \frac {\text {min}} {\text {°}}</math>
Aus diesem Grund ist ein siderischer Tag, also die Zeitspanne, die der Frühlingspunkt oder jeder andere feste Punkt auf dem Himmelsäquator für einen vollständigen Umlauf mit 360 Bogengrad benötigt, gegenüber dem Sonnentag um diese vier Minuten verkürzt.
[[Datei: Equinox path.png|mini|hochkant=2|Die Wanderung des Frühlingspunktes entlang der Ekliptik.]]
Bedingt durch die '''Präzession''' der Erdachse verändern sich im Zyklus von zirka 25800 Jahren nicht nur die Lage der Himmelspole entlang einer Kreisbahn, sondern auch der Frühlingspunkt. Er durchwandert in dieser Zeit in westlicher Richtung genau einmal die gesamte Ekliptik mit ihren 360 Bogengrad. In jedem der '''zwölf Sternbilder''' entlang dieses '''Zodiaks''' mit einem Winkel von 30 Bogengrad pro Sternzeichensegment liegt er also für 2150 Jahre. Anders ausgedrückt: der Frühlingspunkt verschiebt sich in einhundert Jahren um 1,4 Bogengrad, in zehn Jahren um 8,4 Bogenminuten beziehungsweise pro Jahr um 50 Bogensekunden nach Westen. Die Lage der Ekliptik im Bezug auf den Fixsternhimmel bleibt jedoch unverändert.
Siehe hierzu auch:
→ [[Quadriviale Kuriositäten/ Zahlen#Zur Zwölf|'''Zur Zwölf''']].
→ [[Die_Himmelstafel_von_Tal-Qadi/_Astronomische_Bezugssysteme#Der_Zodiak|'''Der Zodiak''']].
→ [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Astronomische_Bezugssysteme#Präzession|'''Präzession''']].
Von vor 4500 Jahren bis heute ist der Frühlingspunkt vom Sternbild Stier (Taurus) gut 60 Bogengrad nach Westen gewandert, so dass dieses Sternbild zum Frühlingsanfang heute nicht mehr gleichzeitig mit der Sonne, sondern erst gut vier Stunden nach der Sonne untergeht und daher abends im Westen gut sichtbar ist, weil die Sonne sich vor dem Untergang der Hyaden und [[Die_Himmelstafel_von_Tal-Qadi/_Die_Plejaden|'''Plejaden''']] bereits deutlich unter dem Horizont befindet. Vor rund 3000 Jahren befand sich der Frühlingspunkt dann schon im Sternbild Widder (Aries) und heute bereits im Sternbild Fische (Pisces).
Dieses Wanderverhalten war bereits in der Antike bekannt, und wurde von dem babylonischen Gelehrten {{w|Kidinnu}} (* vermutlich um 400 vor Christus; † vermutlich 330 vor Christus) dargestellt. {{w|Nikolaus Kopernikus}} erkannte und benannte vor 500 Jahren die Präzession der Erdachse als Ursache für die Wanderung des Frühlingspunktes, und erst {{w|Friedrich Wilhelm Bessel}} konnte die Präzessionskonstante mit hoher Genauigkeit bestimmen, was 1813 von der Preußischen Akademie der Wissenschaften mit der Verleihung eines Preises gewürdigt wurde.
Der Frühlingspunkt stellt einen Anker in den Sonnenkalendern (auch Solarkalender) dar. Das jüdische Pessach sowie auch das christliche Osterfest finden seit jeher nach der Tag-Und-Nacht-Gleiche ('''Äquinoktium''') im Frühjahr statt. Der Ostersonntag ist zum Beispiel der erste Sonntag nach dem ersten Vollmond, der auf dieses Äquinoktium folgt. Die Bestellung von Ackerflächen und die Aussaat von Pflanzensamen wurden und werden in vielen Kulturen mit Bezug auf den Termin des astronomischen Frühlingsanfangs durchgeführt, um gute Ernteerträge zu erhalten.
Die Lage des Frühlingspunkts bei der ekliptikalen Länge 0 Bogengrad kann im Fixsternhimmel nicht direkt im Bezug zum Fixsternhimmel beobachtet werden, weil das Sonnenlicht zum Frühlingsbeginn die Sterne in der Umgebung des Frühlingspunktes bei weitem überstrahlt. Ein gleichzeitig auftretender Vollmond hat die ekliptikale Länge 180 Bogengrad und befindet sich also im Herbstpunkt. Zur Tag-und-Nacht-Gleiche im Herbst steht die Sonne dann im Herbstpunkt bei der ekliptikalen Länge 180 Bogengrad. Der Herbstpunkt, in dem die Sonne zum Herbstbeginn exakt im Westen untergeht, befindet sich auf der Ekliptik also direkt gegenüber dem Frühlingspunkt, der gleichzeitig exakt im Osten gegebenenfalls mit einem gleichzeitig dort auftretenden Vollmond aufgeht. Aber auch während der Sonnenaufgänge und Sonnenuntergänge kann der Fixsternhimmel nicht beobachtet werden.
Seit Uhren zur Verfügung stehen, kann die Sternzeit mit ihnen als der Stundenwinkel des Frühlingspunktes gemessen werden. Ohne eine genaue Zeitmessung ist die Bestimmung der Lage des Frühlingspunktes keineswegs eine triviale Aufgabe. Die Aufgabe der Zeitmessung kann mit dem Mond oder dem Planeten Jupiter bewerkstelligt werden. Er bewegt sich innerhalb von knapp zwölf Jahren einmal vollständig durch die Ekliptik. Im Raster von drei Jahren wandert er auf der Ekliptiklinie jeweils ungefähr 90 Bogengrad weiter und steht dann ausgehend vom Frühlingspunkt als Startpunkt bei den ekliptikalen Längen 0 Bogengrad (Frühlingspunkt), 90 Bogengrad, 180 Bogengrad (Herbstpunkt) und 270 Bogengrad. Da er während der zwölf Jahre seiner siderischen Umlaufzeit häufig und wegen seiner großen Helligkeit nicht nur nachts, sondern auch in der Dämmerung gut gesehen werden kann, ist es möglich, die Lage von Frühlings- und Herbstpunkt indirekt durch die Winkelmessung der Lage des Planeten Jupiter zu bestimmen. Der Saturn hat wegen seiner noch größeren Entfernung von der Erde zwar eine geringere Parallaxe zum Fixsternhimmel als der Jupiter, ist aber auch deutlich weniger hell als dieser. Er hat eine siderische Umlaufzeit von fast dreißig Jahren und verändert seine ekliptikale Länge darum im Mittel ungefähr um 12 Bogengrad pro Jahr.
Eine weitere grobe Möglichkeit besteht darin, den Mond zu beobachten, der für einen siderischen Umlauf fast 28 Tage braucht, im Mittel also knapp sieben Tage für ein Viertel des siderischen Umlaufs. Kulminiert der '''abnehmende''' Halbmond bei der Tag-und-Nacht-Gleiche während des Sonnenaufgangs zum Herbstbeginn auf dem südlichen Meridian, so muss er eine Woche (sieben Tage) zuvor als Vollmond beim Frühlingspunkt gestanden haben, beziehungsweise muss er eine Woche zuvor beim Herbstpunkt gestanden haben, wenn die Sonne zum Frühlingsbeginn aufgegangen ist. Entsprechend kann auch der auf dem südlichen Meridian kulminierende '''zunehmende''' Halbmond bei der Tag-und-Nacht-Gleiche während des Sonnenuntergangs beobachtet werden: eine Woche später erreicht er im im Frühling den Herbstpunkt beziehungsweise im Herbst den Frühlingspunkt. Wegen der gerundeten Rechnung mit ganzen Zahlen und aufgrund der Exzentrizität der Mondbahn können sich hierbei allerdings Winkelfehler von über 10 Bogengrad ergeben. Wenn die Lage des Mondes in seinen 27 oder 28 [[Die Himmelstafel von Tal-Qadi/ Konjunktionen#Mondhäuser|Mondhäusern]] während der Tag-und-Nacht-Gleichen langfristig mitgezählt wird, kann dieser Fehler durch langjährige Mittel ausgeglichen werden.
<div style="clear:both"></div>
==Die Ekliptik==
[[Datei:Tageslaenge.svg|mini|hochkant=2|Die vier Polar- und Wendekreise während der Sommersonnenwende auf der Nordhalbkugel. Die Ekliptik liegt in dieser Darstellung genau horizontal zwischen Erd- und Sonnenmittelpunkt.]]
Von der Erde aus gesehen scheint es, als wenn die Sonne innerhalb eines Sonnenjahres auf einer scheinbaren Kreisbahn durch den Fixsternhimmel zieht, so dass sie an jedem Tag des Jahres bei anderen Sternen steht. Diese Bahn wird von Astronomen als '''Ekliptik''' oder '''Ekliptiklinie''' bezeichnet, und sie ist um den Winkel <math>\epsilon</math> von gut 23 Bogengrad gegenüber dem Himmelsäquator geneigt. Die Verbindungslinie zwischen Erdmittelpunkt und Sonnenmittelpunkt liegt dabei in einer Fläche, die '''Ekliptikebene''' genannt wird. Die Bezeichnung ''Ekliptik'' geht auf den lateinischen Begriff ''linea ecliptica'' (zu Deutsch: ''Bedeckungslinie''). Von einer Eklipse sprechen Astronomen bei der Bedeckung der Sonne durch den Neumond (Sonnenfinsternis) oder beim Wandern des Mondes durch den Erdschatten (Mondfinsternis). Diese Bedeckungen treten nur auf, wenn sich der Mond ebenfalls in der Ekliptikebene befindet. Nach einem Sonnenjahr steht die Sonne in der Ekliptikebene von der Erde aus gesehen wieder beim gleichen Fixstern.
Alle sieben mir bloßem Auge sichtbaren '''Wandelgestirne''' ziehen von der Erde aus gesehen mit verschiedenen Geschwindigkeiten entlang der Ekliptikline durch den Fixsternhimmel. Die Sonne liegt immer auf der Ekliptikebene, wohingegen die anderen Wandelgestirne um die Ekliptiklinie pendeln und dabei verschiedene nördliche oder südliche ekliptikale Breiten in Bezug auf die Ekliptiklinie erreichen. Diese Wandelgestirne haben unseren sieben Wochentagen die Namen gegeben.
→ Siehe [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Kalenderführung#Die_Siebentagewoche|Wikibook-Abschnitt "Die Siebentagewoche"]].
→ Siehe auch [[Quadriviale_Kuriositäten/_Zahlen#Zur_Sieben|Wikibook-Abschnitt "Zur Sieben"]].
Die Ekliptik ist also die gedachte Ebene, in der die Erdbahn während eines Jahres um die Sonne läuft. Wegen der Neigung gegenüber dem Himmelsäquator ist von der '''Schiefe der Ekliptik''' die Rede.
Durch die Lage der Ekliptik sind vier Breitenkreise auf der Erdoberfläche festgelegt:
* Der '''nördliche Wendekreis''' der Sonnenbahn, auf dem die Sonne zur '''Sommersonnenwende''' mittags im Zenit steht.
* Der '''südliche Wendekreis''' der Sonnenbahn, auf dem die Sonne zur '''Wintersonnenwende''' mittags im Zenit steht.
* Der '''nördliche Polarkreis''', wo die Sonne zur '''Sommersonnenwende''' gerade nicht mehr untergeht beziehungsweise wo die Sonne zur '''Wintersonnenwende''' gerade noch nicht aufgeht.
* Der '''südliche Polarkreis''', wo die Sonne zur '''Wintersonnenwende''' gerade nicht mehr untergeht beziehungsweise wo die Sonne zur '''Sommersonnenwende''' gerade noch nicht aufgeht.
{| class="wikitable"
|+ Die scheinbare tägliche Bewegung der Sonne
|-
| [[Datei:Sun-Ecliptic-4Seasons-aDayOnEarth-LookingWest.gif|mini|320px|links|Animation der scheinbaren täglichen Bewegung der Sonne '''zu Beginn der vier Jahreszeiten''' mit den drei Ebenen des Horizonts (grün), des Äquators (rot) und der Ekliptik (blau). Die Blickrichtung verläuft von vorne im Osten (Sonnenaufgang) nach hinten im Westen (Sonnenuntergang).]] || Die scheinbaren Sonnenbahnen verlaufen in den Tagbögen oberhalb und in den Nachtbögen unterhalb der ruhenden '''grünen Horizontalebene''', die für eine geographische Breite von 50 Bogengrad dargestellt sind. Im Süden erreichen die Tagbögen mittags ihre oberen Scheitelpunkte, und im Norden erreichen die Nachtbögen um Mitternacht ihre unteren Scheitelpunkte. Der senkrecht auf der Horizontalebene stehende '''schwarze Zeiger''' ist zum '''Zenit''' ausgerichtet.</br>Die '''braune Rotationsachse der Erde''' verläuft von links unten (Himmelssüdpol) nach rechts oben (Himmelsnordpol). Die Sonne im '''Frühlingspunkt''' ist grün eingefärbt, und ihr gegenüber befindet sich die Sonne im '''Herbstpunkt''', wenn es jeweils die Tag-und-Nacht-Gleiche gibt. Zu diesen beiden Zeitpunkten befindet sich Sonne auf dem als roten Kreis dargestellten '''Himmelsäquator'''.</br>Die Ebene der '''Ekliptik''' ist als rotierende '''blaue Scheibe''' dargestellt. Die obere Sonne stellt die Situation bei der '''Sommersonnenwende''' dar, und die untere bei der '''Wintersonnenwende'''. Während der Zeit der Sommersonnenwende ist die Ekliptik mittags am stärksten und um Mitternacht am geringsten gegenüber der Horizontalebene geneigt, und während der Zeit der Wintersonnenwende ist es umgekehrt.
|}
Zu jedem Zeitpunkt des Tages und des Jahres hat die Ekliptik gegenüber dem Horizont eine variierende Lage und eine andere Bogenlänge oberhalb des Horizonts, jedoch befindet sich der höchste Scheitel immer ungefähr in südlicher Richtung. Der Vollmond erreicht zur Sommersonnenwende um Mitternacht nur eine geringe Horizonthöhe, die Sonne steht dann mittags allerdings mit bei maximaler Horizonthöhe (unter Umständen sogar im Zenit bei einer Horizonthöhe von 90 Bogengrad), und es gibt somit den längsten Tag des Jahres. Zur Wintersonnenwende ist es umgekehrt, und es resultiert der niedrigste Sonnenstand und damit der kürzeste Tag des Jahres. Bei der Tag-und-Nacht-Gleiche zum Herbstanfang erreicht die Ekliptik zum Sonnenaufgang ihre maximale Höhe und maximal über dem Horizont sichtbare Bogenlänge und zum Sonnenuntergang das jeweilige Minimum, bei der Tag-und-Nacht-Gleiche zum Frühlingsanfang ist es wiederum umgekehrt.
{| class="wikitable"
|+ Die Lage des Bogens der Ekliptik über dem Horizont zu verschiedenen Zeitpunkten
!title="Jahreszeit"| Jahreszeit
!title="morgens"| morgens
!title="mittags"| mittags
!title="abends"| abends
!title="nachts"| nachts
|-
| Frühlings-</br>anfang || [[Datei:Ekliptik.A.png|240px]] || [[Datei:Ekliptik.B.png|240px]] || [[Datei:Ekliptik.C.png|240px]] || [[Datei:Ekliptik.D.png|240px]]
|-
| Sommer-</br>anfang || [[Datei:Ekliptik.B.png|240px]] || [[Datei:Ekliptik.C.png|240px]] || [[Datei:Ekliptik.D.png|240px]] || [[Datei:Ekliptik.A.png|240px]]
|-
| Herbst-</br>anfang || [[Datei:Ekliptik.C.png|240px]] || [[Datei:Ekliptik.D.png|240px]] || [[Datei:Ekliptik.A.png|240px]] || [[Datei:Ekliptik.B.png|240px]]
|-
| Winter-</br>anfang || [[Datei:Ekliptik.D.png|240px]] || [[Datei:Ekliptik.A.png|240px]] || [[Datei:Ekliptik.B.png|240px]] || [[Datei:Ekliptik.C.png|240px]]
|}
Besonders '''steile Aufgänge''' im Osten und '''Untergänge''' im Westen sind also zu den folgenden Tageszeiten zu sehen:
* Beim Frühlingsanfang (Tag-und-Nacht-Gleiche) am Abend
* Beim Sommeranfang (Sonnenwende) am Mittag
* Beim Herbstanfang (Tag-und-Nacht-Gleiche) am Morgen
* Beim Winteranfang (Sonnenwende) um Mitternacht
<gallery caption="Der Sternenhimmel auf 53 Bogengrad nördlicher Breite zur Tag-und-Nacht-Gleiche im Frühling mit Darstellung in Blickrichtung Ekliptik (gelb) in Mercator-Projektion" perrow=2 mode=packed widths=480 heights=270>
ekliptikal.Morgen.Fruehling.png|Morgens beim Sonnenaufgang genau in Richtung Osten: Himmelsäquator nach oben gewölbt (hellblau), horizontales Koordinatensystem mit Meridian und Zenit grün.
ekliptikal.Abend.Fruehling.png|Abends bei Sonnenuntergang genau in Richtung Westen: Himmelsäquator nach unten gewölbt (hellblau), horizontales Koordinatensystem mit Meridian und Zenit grün.
</gallery>
<gallery caption="Steile Ekliptik" mode=packed widths=360 heights=360>
Altlicht.16.9.2020.P1079087.jpg|Aufgehendes Altlicht anderthalb Tage vor Neumond (Mondalter 28 Tage, nördliche ekliptikale Breite 4,3 Bogengrad, Mondsichel 2,4 Prozent) kurz vor Herbstbeginn am 16. September 2020 beim Morgenletzt über dem östlichen Horizont. Die Sonne stand wegen der steilen Ekliptiklinie zu diesem Zeitpunkt noch deutlich unter dem östlichen Horizont, und die Ekliptik hatte im Süden eine maximale Höhe von 60 Bogengrad.
Neulicht.P1092200.jpg|Untergehendes Neulicht anderthalb Tage nach Neumond (Mondalter 1,4 Tage, südliche ekliptikale Breite 3,0 Bogengrad, Mondsichel 2,2 Prozent) kurz nach Frühlingsbeginn am 13. April 2021 beim Abenderst gut 19 Bogengrad über dem westlichen Horizont. Die Sonne stand während der Aufnahme noch 6,5 Bogengrad über dem westlichen Horizont, und die Ekliptik hatte im Süden eine maximale Höhe von knapp 60 Bogengrad. Die Mondsichel ist nur geringfügig heller als das Himmelsblau, und deswegen beträgt der Kontrast zwischen Mondsichel und Himmel nur ungefähr zehn Prozent.
Neulicht.37Tauri.P1138734.jpg|Untergehendes Neulicht beim Abenderst (akronychischer Untergang) am 2. Mai 2022 von Berlin aus gesehen bei einer Höhe von 9,4 Bogengrad über dem Horizont im Goldenen Tor der Ekliptik (Mondalter 1,8 Tage, nördliche ekliptikale Breite 0,5 Bogengrad, Mondsichel 3,4 Prozent). Die Sonne stand während der Aufnahme wenige Minuten nach Einbruch der bürgerlichen Dämmerung 7,1 Bogengrad unter dem Horizont. Die Ekliptik hatte in Richtung Südsüdwest eine Höhe von gut 50 Bogengrad.
</gallery>
Besonders '''flache Aufgänge''' im Osten und '''Untergänge''' im Westen sind entsprechend zu den folgenden Tageszeiten zu sehen:
* Beim Frühlingsanfang (Tag-und-Nacht-Gleiche) am Morgen
* Beim Sommeranfang (Sonnenwende) um Mitternacht
* Beim Herbstanfang (Tag-und-Nacht-Gleiche) am Abend
* Beim Winteranfang (Sonnenwende) am Mittag
<gallery caption="Flache Ekliptik" mode=packed widths=360 heights=360>
Untergehender.Fruehlingsvollmond.P1127692.jpg|Untergehender Mond einen Tag nach Vollmond (Mondalter 15,7 Tage, nördliche ekliptikale Breite 2,5 Bogengrad) zum Frühlingsbeginn 3 Bogengrad über dem westlichen Horizont. Die Sonne stand zu diesem Zeitpunkt bereits fast ebenso hoch über dem östlichen Horizont, und die Ekliptik hatte im Süden eine maximale Höhe von nur gut 14 Bogengrad.
Waxing.new.moon.P1105584.jpg|Tiefstehende, in Richtung Westen untergehende Mondsichel am 9. Oktober 2021 mit durch die Brechung des Lichts auf dem langen Weg durch die Atmosphäre bedingter grünlicher Oberkante und rötlicher Unterkante.
Neulicht.18.8.2023.5Prozent.P1174371.jpg|Tiefstehendes, im Dunst am 18. August 2023 über dem westlichen Horizont eine halbe Stunde nach Sonnenuntergang im Sternbild Löwe (Leo) untergehendes Neulicht mit einer Mondsichel von fünf Prozent. Die nördliche ekliptikale Breite des Mondes betrug zwei Bogengrad und die Höhe über dem Horizont vier Bogengrad.
</gallery>
→ In Bezug auf die vier Tages- und Jahreszeiten siehe auch [[Quadriviale Kuriositäten/ Zahlen#Zur Vier|Exkurs '''Zur Vier''']].
Die '''ekliptikale Länge''' <math>\lambda</math> wird üblicherweise vom Frühlingspunkt aus als Winkel zwischen -180 und +180 Bogengrad in der Ebene der Ekliptik angegeben, zum Frühlingsanfang steht die Sonne also bei der ekliptikalen Länge null. Die '''ekliptikale Breite''' <math>\beta</math> wird wiederum senkrecht dazu als Winkel zwischen -90 und +90 Bogengrad in Richtung der Pole der Ekliptik bestimmt. Die ekliptikale Breite der Sonne <math>\beta_{Sonne}</math> ist definitionsgemäß null. Die Deklination <math>\delta</math> eines Punktes auf der Ekliptik liegt immer zwischen <math>-\epsilon</math> und <math>+\epsilon</math>. Im Frühlings- und Herbstpunkt ist die Deklination der Sonne gleich null, zum Sommeranfang ist sie <math>+\epsilon</math> und beim Winterbeginn <math>-\epsilon</math>.
→ Zur scheinbaren Begegnung von beweglichen Gestirnen mit Himmelsobjekten siehe auch [[Die Himmelstafel von Tal-Qadi/ Konjunktionen|Exkurs '''Konjunktionen''']].
=== Beobachtungen in der Nähe der Ekliptik ===
Alle sieben Wandelgestirne können entlang der Ekliptiklinie ohne technische Hilfsmittel beobachtet werden, teilweise sogar bei Tageslicht und immer auch in der Dämmerung.
Die Mondsichel kann drei Tage vor oder nach Neumond durchaus auch am Mittag gesehen werden, wenn ihre Lage am Himmel bekannt ist und sie daher mit bloßem Auge fixiert werden kann. Die Schattenseite des Mondes ist vom Himmelsblau dabei nicht zu unterscheiden, und nur die schmale Sichel leuchtet etwas heller und weißlicher als der Himmel.
Befindet sich die Sonne in Horizontnähe und die '''Venus''' bei großer Elongation, gelingt auch deren Beobachtung am Taghimmel mit bloßem Auge. Die Venus ist nach der Sonne und dem Mond mit Abstand der hellste Planet und wird wegen ihres Glanzes in der poetischen Literatur auch als „Morgenstern“ beziehungsweise „Abendstern“ bezeichnet. Ihre Aufgänge als „Morgenstern“ und ihre Untergänge als „Abendstern“ auf der Ekliptik wurden bereits im 17. vorchristlichen Jahrhundert berechnet und auf den '''Venus-Tafeln''' des babylonischen Königs Ammi-saduqa festgehalten. Auf einigen der keltischen '''Bronzescheiben von {{w|Monasterevin}}''' (Irland, erstes bis zweites nachchristliches Jahrhundert<ref>Robert David Stevick: [https://content.lib.washington.edu/insdsgnweb/media/stevick_2006_0.pdf The Forms of the Monasterevin-Type Discs], The Journal of the Royal Society of Antiquaries of Ireland, Band 136, Seiten 112 bis 140, 2006</ref>) ist möglicherweise der scheinbare Verlauf der Venus- und Merkurpositionen am Abend- und Morgenhimmel über dem Horizont in Bezug zur Sonne künstlerisch dargestellt. Die anderen Planeten (etwas irreführend manchmal auch als Wandel- oder Wander'''sterne''' bezeichnet) sind nur zwischen Sonnenuntergang und Sonnenaufgang sichtbar.
Am schwierigsten ist in nördlichen Breiten die Beobachtung des innersten Planeten '''Merkur''', weil dieser nur kurzzeitig (bei großer Elongation) und bei guten Sichtverhältnissen während der Dämmerung beobachtet werden kann. Am besten gelingt dies, wenn die Ekliptik möglichst steil auf der Horizontlinie steht, weil dann die Sonne weit genug unter dem Horizont steht und den Himmel noch nicht zu sehr aufhellt. Dies ist um die Tag-und-Nacht-Gleichen der Fall – im Frühjahr am Abend (der Merkur muss dann eine große östliche Elongation haben), und im Herbst am Morgen (der Merkur muss dann eine große westliche Elongation haben). Entsprechendes gilt im Übrigen auch für das Alt- und Neulicht des Mondes sowie für die Venus.
<gallery widths="360" heights="360" mode="packed" caption="Beobachtungen bei Tageslicht und während der Dämmerung">
Datei:Sonnenflecke.P1104705.jpg|Die leuchtende Sphäre der '''Sonne''' ist durch einen ausgesprochen präzisen Kreis begrenzt. In der Nähe des Horizonts erscheint die Sonne wegen der atmosphärischen Refraktion etwas verbreitert und bekommt wegen der atmosphärischen Dispersion und der Rayleigh-Streuung des blauen Lichtanteils oben einen grünlichen und unten einen rötlichen Rand.<br/>Wenn die Sonne beim Sonnenaufgang oder Sonnenuntergang so nahe am Horizont steht, dass sie angesehen werden kann, ohne die Augen zu schädigen, können größere Sonnenflecke auch ohne optische Hilfsmittel erkennbar sein, sofern es zu diesem Zeitpunkt welche gibt:<br/>[[Datei:Sonnenfleck.mit.blossem.Auge.png]]
Datei:Mittagsmondsichel.P1104669.jpg|Die bei wolkenlosem Himmel durch das direkte Sonnenlicht in 14 Prozent der Kreisfläche der sichtbaren Mondscheibe belichtete, '''abnehmende Mondsichel''' mit einer scheinbaren Helligkeit von -8<sup>m</sup> um die Mittagzeit 34 Bogengrad über dem westlichen Horizont. Die Modulation (Michelson-Kontrast) an der äußeren Kante der Mondsichel beträgt nur gut zwei Prozent und war mit bloßem Auge gerade noch so wahrnehmbar.
Datei:Venus.Tageslicht.mag.P1067711.png|Die '''Venussichel''' in großem Glanz in über 30 Bogengrad Höhe über dem westlichen Horizont eine Viertelstunde vor Sonnenuntergang am Taghimmel.
Datei:Merkur.10Bogengrad.ueber.Horizont.Stangenhagen.P1105882.jpg|Der Planet '''Merkur''' bei maximaler westlicher Elongation (halb rechts oben im Bild, nördliche ekliptikale Breite 2 Bogengrad) und bei großem Glanz mit einer scheinbaren Helligkeit von 0<sup>m</sup> in 10 Bogengrad Höhe über dem östlichen Horizont in Stangenhagen (Brandenburg). Der Merkur war zu Beginn der bürgerlichen Dämmerung und gut eine Stunde nach seinem Aufgang gerade noch sichtbar. Die sieben Bogensekunden große Planetenscheibe war zu 56 Prozent durch die Sonne beleuchtet, die sich zum Zeitpunkt der Aufnahme noch gut 6 Bogengrad unter dem Horizont befand.
</gallery>
Die drei äußeren Planeten, Mars, Jupiter und Saturn, können von der Erde aus gesehen jede ekliptikale Länge annehmen und bewegen sich langsamer entlang der Ekliptik. Sie sind hell genug, um mit bloßem Auge in der Dämmerung sichtbar zu sein, zudem können sie aber auch bei ihrer Kulmination auf dem südlichen Meridian beobachtet werden.
<gallery widths="360" heights="360" mode="packed" caption="Die drei äußeren Planeten">
Datei:Goldenes.Tor.der.Ekliptik.Mars.P1091617.jpg|In der Bildmitte der rote Planet '''Mars''' im Goldenen Tor der Ekliptik: ekliptikale Länge = 62,7 Bogengrad, ekliptikale Breite = 1,5 Bogengrad (nördlich), scheinbare Helligkeit = 1<sup>m</sup>. Links im Sternbild Stier (Taurus) der Rote Riese '''Aldebaran''' (α Tauri) mit dem offenen Sternhaufen der '''Hyaden''', und rechts der offene Sternhaufen der '''Plejaden'''.
Datei:Internationaler.Sternenpark.Westhavelland.Sommermilchstrasse.Saturn.Jupiter.P1024377.jpg|Die beiden Planeten '''Jupiter''' und '''Saturn''' im Bereich der Sommermilchstraße vom Internationalen Sternenpark Westhavelland aus gesehen. Halb links unten im Sternbild Schütze (Sagittarius) der helle Planet Jupiter (scheinbare Helligkeit = -2,5<sup>m</sup>) in einer Höhe über dem Horizont von 15 Bogengrad, links daneben der etwas dunklere Planet Saturn (scheinbare Helligkeit = 0<sup>m</sup>) in einem Abstand von rund neun Bogengrad. Oben in der Milchstraße das Sternbild Adler (Aquila).
</gallery>
Von den in der nördlichen Hemisphäre zu sehenden Sternen ist lediglich der nur 8,6 Lichtjahre entfernte und schon vom griechischen Dichter Homer als Hundsstern erwähnte '''Sirius''' (α Canis Majoris) im Sternbild Großer Hund (Canis Major) mit -1,5<sup>m</sup> heller als der Saturn. Die nächsthelleren Sterne '''Arktur''' (α Bootis) im Sternbild Bärenhüter (Bootes), '''Wega''' (α Lyrae) im Sternbild Leier (Lyra), '''Capella''' (α Aurigae) im Sternbild Fuhrmann (Auriga) und '''Rigel''' (β Orionis) im Sternbild Orion sind mit rund 0<sup>m</sup> bereits anderthalb Größenordnungen dunkler als Sirius und eine halbe Größenklasse dunkler als der Saturn. Die Sterne dieser Aufzählung liegen allerdings nicht in Ekliptiknähe und bilden deswegen keine spektakulären Konjunktionen mit den sieben Wandelgestirnen.
[[Datei:Ekliptik.helle.Objekte.png|mini|hochkant=2|rechts|Die sieben hellsten feststehenden Himmelsobjekte in der Nähe der Ekliptik liegen zwischen den Sternbildern Stier (Taurus, rechts) und Skorpion (Scorpio, links). Der Bogen der Ekliptik wird von den Wandelgestirnen entgegen dem Uhrzeigersinn vom Frühlingspunkt rechts zum Herbstpunkt links durchlaufen. In der Nähe unteren Bogenhälfte befinden sich keine hellen Fixsterne in der Nähe der Ekliptik, der helle Stern Fomalhaut (α Piscis Austrini) im Sternbild Südlicher Fisch (Piscis Austrinus) dient lediglich zur Orientierung. Außerhalb des Bogens liegende Punkte befinden sich nördlich der Ekliptik und innen liegende südlich.]]
Die hellsten in Ekliptiknähe liegenden Sterne sind '''Antares''' (α Scorpii, 1,0<sup>m</sup>) im Sternbild Skorpion (Scorpio), '''Spica''' (α Virginis, 1,0<sup>m</sup>) im Sternbild Jungfrau (Virgo), '''Regulus''' (α Leonis, 1,5<sup>m</sup>) im Sternbild Löwe (Leo), '''Pollux''' (β Geminorum, 1,0<sup>m</sup>) im Sternbild Zwillinge (Gemini) und '''Aldebaran''' (α Tauri, 1,0<sup>m</sup>) im Sternbild Stier (Taurus) sowie die beiden offenen Sternhaufen der '''Hyaden''' (0,5<sup>m</sup>) und der '''Plejaden''' (Messier 45, 1,5<sup>m</sup>), die beide ebenfalls im Sternbild Stier (Taurus) liegen. Diese Sterne beziehungsweise Sternhaufen stehen regelmäßig in dichter Konjunktion mit den sieben Wandelgestirnen und werden manchmal sogar von ihnen bedeckt.
[[Datei:Antares.Aldebaran.Horizont.png|zentriert|hochkant=4|mini|Antares und Aldebaran von Eridu im Süden Sumers aus gesehen gleichzeitig dicht unter dem Horizont.]]
Die beiden Roten Riesen Aldebaran und Antares liegen nur geringfügig südlich der Ekliptik und unterscheiden sich in ihrer ekliptikalen Länge um fast genau 180 Bogengrad. Die beiden äußersten Pole dieser Reihe, der Stern Antares und der Sternhaufen der [[Die_Himmelstafel_von_Tal-Qadi/_Die_Plejaden|'''Plejaden''']], werden in ihrer Eigenschaft als Kalendergespann auch als '''Plejaden-Waage''' bezeichnet.<ref name="ErnstVonBunsen">Ernst von Bunsen: ''Die Plejaden und der Thierkreis oder: Das Geheimnis der Symbole'', Verlag von Mitscher und Röstell, Berlin, 1879</ref> Das westlich vom Sternbild Stier (Taurus) angrenzende Sternbild Widder (Aries, im Bild rechts unten) ist nach dem ersten Band des Tetrabiblos des Ptolemäus über "astrologische Elemente" das "Haus des Mars". In der Mythologie wird der römische Kriegsgott '''Mars''', dem unter anderem auch der '''Stier''' heilig war, mit den entsprechenden Göttern der griechischen Mythologie '''Ares''' sowie der nordischen Mythologie '''Tyr''' und gleichzeitig mit dem mythologischen Stier (auf Dänisch ebenfalls "tyr") in Verbindung gebracht. Der "Gegen-Mars" ist der "Anti-Ares" beziehungsweise '''Antares''' (α Scorpio), der Rote Überriese im Sternbild Skorpion (Scorpio), der auf der Ekliptik genau gegenüber vom Roten Riesen Aldebaran im Sternbild Stier (Taurus) steht.
→ Siehe auch [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Der_Fixsternhimmel#Die_sieben_hellsten_Objekte_der_Ekliptik|'''Die sieben hellsten Objekte der Ekliptik''']].
Vor gut 5000 Jahren – als die Keilschrift erfunden wurde<ref>Ira Spar: [https://www.metmuseum.org/toah/hd/wrtg/hd_wrtg.htm The Origins of Writing], Heilbrunn Timeline of Art History, Essays, Department of Ancient Near Eastern Art, The Metropolitan Museum of Art, Oktober 2004</ref> und die ersten zeichnerischen Darstellungen von Gottheiten auftauchen – befanden sich '''Aldebaran''' neben dem '''Frühlingspunkt''' und '''Antares''' neben dem '''Herbstpunkt'''. Dies bedeutet, dass zum Frühlingsanfang die Sonne genau im Osten zusammen mit Aldebaran aufgegangen ist, während Antares gleichzeitig im Westen untergegangen ist. Beziehungsweise ist die Sonne genau im Westen zusammen mit Aldebaran untergegangen, während Antares gleichzeitig im Osten aufgegangen ist. Umgekehrt zum Herbstbeginn: hier ging die Sonne genau im Osten zusammen mit Antares auf, während gleichzeitig Aldebaran im Westen unterging. Beziehungsweise ist die Sonne genau im Westen zusammen mit Antares untergegangen, während Aldebaran gleichzeitig im Osten aufgegangen ist.
Für die damaligen Menschen waren diese beiden sehr hellen und rot leuchtenden Sterne daher ein Gespann, um auf einfache Weise die Zeitpunkte des Frühlings- und des Herbstanfangs im '''Sonnenjahr''' zuverlässig zu bestimmen. Der in der obigen Tabelle ("Die Lage des Bogens der Ekliptik über dem Horizont zu verschiedenen Zeitpunkten") beschriebene Halbbogen auf der Ekliptik befand sich damals zum Frühlingsbeginn bei Sonnenuntergang und zum Herbstbeginn bei Sonnenaufgang vollständig oberhalb des Horizonts. Zum Sommerbeginn war dieser Halbbogen um Mitternacht vollständig unter dem Horizont und daher gar nicht zu sehen. Dafür war der sichtbare Teil der Ekliptik zum Winterbeginn um Mitternacht vom Stern Antares Osten bis zu den Plejaden im Westen vollständig und fast gleichmäßig in 45-Grad-Schritten durch die oben angegebenen fünf Sterne markiert, wobei die Ekliptik den Meridian im Süden bei maximaler Höhe schnitt.
====Königssterne====
Die vier Königssterne sind helle ekliptiknahe Sterne, die in alten Zeiten zur örtlichen Orientierung am Nachthimmel und zur zeitlichen Orientierung im Sonnenjahr genutzt werden konnten.
Der in seiner Region mit Abstand hellste und noch einigermaßen nahe an der Ekliptik liegende Stern '''Fomalhaut''' im Sternbild Südlicher Fisch (Piscis Austrinus) diente südlich des 40. Breitengrads der Nordhalbkugel lebenden alten Völkern neben den deutlich weiter nördlich liegenden hellen Sternen '''Aldebaran''', '''Regulus''' und '''Antares''' als vierter Königsstern zur Orientierung am Sternenhimmel.<ref>Dirk Lorenzen: [https://www.deutschlandfunk.de/fomalhaut-im-suedlichen-fisch-der-herbststern-100.html Fomalhaut im Südlichen Fisch - Der Herbststern], Deutschlandfunk, 9. November 2016</ref> Jeder dieser vier Sterne markiert die Hauptrichtung eines Himmelsquadranten. Im Gegensatz zu Fomalhaut können die drei anderen Königssterne vom Mond bedeckt werden, Die Bezeichnung "'''königliche Sterne'''" geht auf den französischen Astronomen Charles François Dupuis (1742–1809) zurück, der ihn 1795 im Kapitel über die "Spuren des Naturkults, die sich in allen Denkmälern widerspiegeln" seines Buchs "L’origine de tous les cultes, ou la réligion universelle" ("Der Ursprung aller Kulturen, oder die universelle Religion") prägte.<ref>Charles François Dupuis: [https://gallica.bnf.fr/ark:/12148/bpt6k65440490/f65 ''Origine de tous les cultes, ou Religion universelle''], Band 1, H. Agasse, Paris, 1795, Kapitel III ''Vestiges du Cults de la Nature, empreints dans touts les Monumens'', Seite 43 ff.</ref>
'''Aldebaran''' (α Tauri im Sternbild Stier) markiert als hellster Stern im Sternbild Himmelsstier zusammen mit den benachbarten Plejaden das Goldene Tor der Ekliptik. Es lag zur Zeit der Sumerer beim Frühlingspunkt der Sonne und hat von den vier Königssternen heute die nördlichste Deklination. Somit erreicht er bei der Kulmination auf dem südlichen Meridian auch die größte Höhe über dem Horizont. Er ist der 14.-hellste Stern des gesamten Nachthimmels. Vom Himmelsnordpol aus gemessen wird er lediglich von den Sternen Arktur im Bärenhüter (Bootes), Wega in der Leier (Lyra) und Capella im Fuhrmann (Auriga) in der scheinbaren Helligkeit übertroffen.
→ Siehe auch [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Astronomische_Bezugssysteme#Der_Himmelsstier|'''Der Himmelsstier''']].
'''Regulus''' (α Leonis im Sternbild Löwe) hat von den vier Königssternen die größte ekliptikale Breite. Durch seine Eigenbewegung lag er vor 7000 Jahren exakt auf der Ekliptiklinie und hat sich inzwischen um knapp ein halbes Bogengrad nach Norden verschoben. Er stand zu Zeiten der Sumerer bei der größten Deklination und erreichte bei der Kulmination auf dem südlichen Meridian somit die größte Höhe über dem Horizont. Bei den Sumerern hieß der Stern LU.GAL (großer Mann = Herrscher), und er befindet sich auf dem oberen babylonischen Himmelsweg des Enlil (Ellii).<ref name="Gautschy" /> Er ist der hellste Stern des Sternbilds Löwe (Leo) und der 21.-hellste Stern des gesamten Nachthimmels.
→ Siehe auch [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Astronomische_Bezugssysteme#Der_Löwe|'''Der Löwe''']].
'''Antares''' (α Scorpii im Sternbild Skoprion) befindet sich ziemlich genau gegenüber dem Goldenen Tor der Ekliptik und markierte zu Zeiten der Sumerer im Himmelsskorpion den Herbstpunkt. Der sumerische Ausdruck GAB.GIR.TAB bedeutet "Brust des Skorpions", im Arabischen wird er Qualbu ("Herz des Skorpions" genannt), und der heute gebräuchliche Name Antares kommt aus dem Altgriechischen von anti ("gegen") und Ares (bei dem Römern Mars) - bedeutet also "Gegenmars", vermutlich aufgrund seiner großen Helligkeit und seiner starken Rotfärbung als Roter Überriese. Er ist der 16.-hellste Stern des gesamten Nachthimmels.
→ Siehe auch [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Astronomische_Bezugssysteme#Der_Himmelsskorpion|'''Der Himmelsskorpion''']].
'''Fomalhaut''' (α Piscis Austrini im Sternbild Südlicher Fisch) erreicht von den vier Königssternen auf der nördlichen Erdhalbkugel die geringste Höhe über dem Horizont und hat gleichzeitig auch die kleinste ekliptikale Breite. Sein Name kommt vom arabischen Ausdruck "fam al-ḥūt", was "Maul des Fisches" bedeutet. Er befindet sich auf dem unteren babylonischen Himmelsweg des Ea (Enki) im kosmischen Urozean. Sie Sumerer nannten ihn einfach nur KUA, was "Fisch" bedeutet.<ref name="Gautschy">Rita Gautschy: [https://www.gautschy.ch/~rita/archast/babylon.html Babylonische Astronomie]</ref> Er ist der 18.-hellste Stern des gesamten Nachthimmels.
→ Siehe auch [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Astronomische_Bezugssysteme#Der_Urozean|'''Der Urozean''']].
<gallery caption="Die vier Königssterne im Jahr 2500 vor Christus von rechts nach links vom Frühlingspunkt nach Osten" widths=768 heights=540>
Aldebaran.2500.vor.Christus.png|Aldebaran im Frühlingsäquinoktium (Tag-und-Nacht-Gleiche bei einer äquatorialen Länge (Rektaszension) von 0 Stunden und einer ekliptikalen Länge von 0°).
Regulus.2500.vor.Christus.png|Regulus im Sommersolstitium (Sommersonnenwende bei einer äquatorialen Länge (Rektaszension) von 6 Stunden und einer ekliptikalen Länge von 90°).
Antares.2500.vor.Christus.png|Antares im Herbstäquinoktium (Tag-und-Nacht-Gleiche bei einer äquatorialen Länge (Rektaszension) von 12 Stunden und einer ekliptikalen Länge von 180°).
Fomalhaut.2500.vor.Christus.png||Fomalhaut im Wintersolstitium (Wintersonnenwende bei einer äquatorialen Länge (Rektaszension) von 18 Stunden und einer ekliptikalen Länge von 270°).
</gallery>
→ Siehe auch [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Astronomische_Bezugssysteme#Babylonische_Himmelswege|'''Babylonische Himmelswege''']].
[[Datei:Persische.Koenigssterne.png|mini|rechts|hochkant=2|Die vier persischen Königssterne Taschter, Venant, Haftorang und Satevis nahe der Ekliptik. In der Bildmitte befindet sich der südliche Ekliptikpol, die Punkte außerhalb des Ekliptikkreises (rot) haben nördliche ekliptikale Breiten,]]
[[Datei:The four supporters (angels) of the celestial throne Wellcome L0030654.jpg|mini|rechts|hochkant=2|Die vier in und um einen Kreis als '''Stier (Taschter)''', '''Löwe (Venant)''', '''Adler (Haftorang)''' und '''Mann (Satevis)''' dargestellten '''Cherubim''' aus dem persischen Manuskript 373 der Wellcome-Sammlung in London. Bei dieser astronomischen Handschrift aus dem 17. Jahrhundert handelt es sich um einen illustrierten Kalender.]]
Die vier Königssterne werden im Bundahischn erwähnt, ein mittelpersischer Text über die Weltentstehung sowie ihre Mythen und Legenden, die im Zoroastrismus eine Rolle spielen:<ref>Julie M Gillentine: ''Perisa's Royal Stars'', Atlantis Rising Magazine, Nummer 27, Seite 48 ff., 2001</ref> Die Texte scheinen 1500 Jahre lang nur mündlich tradiert worden zu sein und sind in dieser langen Zeitspanne sicherlich Änderungen unterworfen gewesen. Die ersten Verschriftlichungen hat es wohl schon im 5. Jahrhundert gegeben, und die ältesten erhaltenen Schriften stammen aus dem 9. bis 13. Jahrhundert. Es ist unklar, welcher der vier genannten Namen mit welchem Stern verknüpft ist. Der Orientalist Abraham Hyacinthe Anquetil-Duperron (1731–1805) stellt die Zuordnung in der Übersetzung in seinem Buch "Zend-Avesta, ouvrage de Zoroastre" von 1771 im Kapitel 87 (LXXXVII) dar. Das '''Avesta''' ist eine heilige Schriftensammlung der zoroastrischen Religion. Das Präfix '''Zend''' steht für "Kommentar" beziehungsweise "Interpretation".
<blockquote>
J'écris l''''Iescht de Taschter.'''<br/>
(Cet Iescht se récite le jour Taschter, et les jours Khordad, Ardafréoüesch et Bád, Hamkars de Taschter).<br/>
'''Au nom de Dieu.'''<br/>
'''Ormusd''' , Roi excellent, que la gloire et l'éclat du lumineux , du brillant Taschter augmentent ! Qu'il vienne (à mon secours) !<br/>
...<br/>
Que '''Taschter''' [1] , astre éclatant de lumiere et de gloire, me soit favorable ,<br/>
(avec) '''Satevis''' , qui est près de l'eau [2] , fort , donné d'Ormusd , (avec) les astres germes de l'eau , germes de la terre , germes des arbres donnés d'Ormusd ,<br/>
(avec) l'astre '''Venant''' [3] donné d'Ormusd ,<br/>
et les astres qui (composent) l''''Haftorang''' [4] donné d'Ormusd , éclatant de lumiere , source de santé ;<br/>
je fais izeschné et néaesch à ces (Astres) et c. jusqu'a , avertissez-le de cela.<br/>
<br/>
[1] J'ai exposé dans le Mém. cité ci-d. T. I. p. 116. not. 1. ( Mém. de l'Acad. des Belles-Lettres, T. XXXIV , p. 397 , 398 ) , les raisons qui me porrent à croire que Taschter est Sirius , étoile placée dans la bouche du grand Chien.<br/>
[2] Seteoûeschehé : Satvis qui est près de l'eau ( ou , qui augmente l'eau ) , me paroît être l'œil austral du Taureau , étoile de la premiere grandeur. Schetvi , en Arabe , signifie pluye d'Hiver , Hiver.<br/>
[3] Venetó : Venant, dans le Boun-dehesch , garde le Midi ; et le mot venéanté , signifie qui garde , qui veille. Cet Astre me paroît répondre au Piéd d'Orion , étoile de la premiere grandeur.<br/>
[4] Haptôriag : les sept especes ( d'étoiles ) ; la grande Ourse ou la petite Ourse.
</blockquote>
'''Anmerkungen:'''
''Der Begriff '''Jescht''' (französisch: Iescht) ist ein heiliges Gebet, das in der zoroastrischen Tradition des Avesta steht. Bei '''Ormuzd''' (französisch: Ormusd) handelt es sich um '''Ahura Mazda''', den Schöpfergott im altpersischen Zoroastrismus. Bei den Persern bedeutete das Wort "Vanant" ("'''Venant'''") so viel wie "Eroberer" oder "Sieger". ''
[[Datei:Skorpion.Haftorang.png|mini|links|hochkant=1.5|Die sieben ekliptiknahen hellen Sterne im Himmelsskorpion:<br/>Antares (Haftorang) / Acrab / Zuben Eschamali ("nördliche Klaue") / Dschubba / Zuben Elgenubi ("südliche Klaue") / Fang / Zuben Acrabi ("Klaue des Skorpions") = Brachium ("Arm").]]
Anquetil-Duperron identifiziert Taschter mit dem hellsten Stern des Nachthimmels, Sirius im Großen Hund (Canis Major). Da Savetis "dem Wasser nah" steht (laut Anquetil-Duperron alternativ auch "das Wasser vermehrend" sowie dem Winterregen und dem südlichen Auge des Stieres (Taurus) zugeordnet, also seiner Meinung Aldebaran), liegt eine Identifizierung mit Fomalhaut im Südlichen Fisch (Piscis Austrinus) unterhalb des Sternbilds Wassermann (Aquarius) sehr nahe. Anquetil-Duperron hält Venant für den "Wächter des Südens" ("garde le Midi") und Haftorang als zu Haptoriag zugehörig, was "die sieben Species" bedeuten soll (Avestisch und Altpersich "hapta" = altgriechisch "hepta" = lateinisch "septem" = deutsch = "sieben") und von ihm mit den sieben hellsten Sternen des Großen oder des Kleinen Bären ("Ourse") identifiziert wird. Es könnte sich mit dieser Herleitung aber auch genauso gut um die sieben Wandelgestirne, das Siebengestirn (Plejaden) oder das Sternbild Orion handeln. Ferner sei darauf hingewiesen, dass der große Himmelsskorpion (heute Skorpion und Waage) ebenfalls sieben auffällige ekliptiknahe Sterne hat (siehe Abbildung links).
Johann Friedrich Kleuker (1749–1827) übersetzt in seinem 1777 erschienenen Buch "Zend-Avesta – Zoroasters lebendiges Wort" diesen französischen Text wie folgt:
<blockquote>
'''Jescht-Taschter.'''<br/>
(Er wird gesprochen am Tage Taschter, und in den Tagen Khordad, Ardafreouesch und Bad, Taschter's Hamkars.)<br/>
'''Im Namen Gottes.'''<br/>
'''Ormuzd''', König der Herrlichkeit! Daß Glorie und Glanz des Lichtfunkelden, blitzenden Taschters hoch werden! Daß er zu meiner Hülfe eile!<br/>
(Gebete.)<br/>
Hold sey mit '''Taschter'''! Stern des Licht- und Glanzblizes,<br/>
mit '''Satevis''' – dem Wasser nah – dem starken Ormuzdsohn und mit den Sternen – Keimen des Wassers, Keimen der Erde, Keimen der Ormuzd geschaffnen Bäume;<br/>
mit '''Venant''' Ormuzdsohn<br/>
und mit dem Ormuzdgebohrnen Gestirn '''Haftorang''' – Lichtglänzend und Gesundheitquillend:<br/>
mein Lobgesang mit Demuth sey heilig diesen Sternen!
</blockquote>
Im zweiten Abschnitt der sechsten Carde dieses Gebets heißt es etwas später:
<blockquote>
O Saperman Zoroaster, '''Taschter''', in Licht und Glorie glänzend,<br/>
vereinigte sich zehn '''Nächte''' durch mit einem großen, glanzlichten Körper,<br/>
mit '''Stieres''' Körper, dessen Hörner Gold und dessen Augen blitzend waren.
</blockquote>
Die sich auf der Ekliptiklinie fast genau gegenüberstehenden und besonders hellen und glänzenden Sterne, der Rote Riese Aldebaran und der Rote Überriese Antares, können in der beginnenden Dämmerung als erste Sterne am Himmel gesehen werden und zeigen eine deutliche Rotfärbung und Szintillation. Sie können also mit den mit "Glanz" und "Funkeln" attribuierten beiden Sternen Taschter und Haftorang identifiziert werden. Ordnet man Satevis wie oben beschrieben den Wassersternbildern zu und interpretiert Venant als den von den vier Königssternen bei seiner Kulmination auf dem südlichen Meridian im Winter am höchsten stehenden Stern als den "Wächter des Südens", dann ergibt sich zwanglos die folgende Aufteilung:
{| class="wikitable"
|+ Die vier persischen Königssterne
! Stern !! Bayer-Bezeichnung !! Persische Bezeichnung !! Größenklasse !! Bemerkung
|-
| Aldebaran || α Tauri || '''Taschter''' (Tishtrya) || 0,9<sup>m</sup> || Stern des Licht- und Glanzblitzes
|-
| Regulus || α Leonis || '''Venant''' (Vanant) || 1,4<sup>m</sup> || Sohn des Ormuzd (Ahura Mazda), Wächter des Südens
|-
| Antares || α Scorpii || '''Haftorang''' (Haptoiringa) || 1,0<sup>m</sup> || Lichtglänzend und gesundheitquillend
|-
| Fomalhaut || α Piscis Austrini || '''Satevis''' (Satavaesa) || 1,2<sup>m</sup> || Dem Wasser nah
|}
Die Beschreibung der Richtungen der Wächter bezieht sich also nicht auf die Sichtbarkeit, sondern auf eine Kombination von Jahreszeit und Tageszeit, wie zum Beispiel auf den Zeitpunkt des morgendlichen Sonnenaufgangs zum Frühlingsäquinoktium im Osten. Für die in der oben in der Tabelle angegebene Richtung von Aldebaran (Taschter) im Osten ergeben sich in den vier Jahreszeiten folgende Sonnenrichtungen, die dann mit der Richtung des jeweiligen Wächters übereinstimmt. Es handelt sich also nicht um die Richtungen, in denen die vier Königssterne beobachtet werden konnten, sondern Aldebaran befindet sich zu allen vier angegebenen Kombinationen von Jahreszeiten und Tageszeiten stets im Osten, Regulus stets im Norden, Antares stets im Westen und Fomalhaut stets im Süden:
{| class="wikitable"
|+ Die jahreszeitlichen Positionen der Sonne
! Jahreszeitpunkt !! Tageszeit !! Sonnenrichtung || Sonne in Konjunktion<br/>mit dem Stern || Sonne und Stern<br/>im Sternbild
|-
|Frühlingsäquinoktium || Morgen || Osten || Aldebaran / '''Taschter''' || Stier (Taurus)
|-
|Sommersonnenwende || Mittag || Süden || Regulus / '''Venant''' || Löwe (Leo)
|-
|Herbstäquinoktium || Abend || Westen || Antares / '''Haftorang''' || Skorpion (Scorpio)
|-
|Wintersonnenwende || Mitternacht || Norden || Fomalhaut / '''Satevis''' || Südlicher Fisch (Piscis Austrinus)
|}
Diese Einteilung des Himmels mit den "vier persischen Himmelswächtern" in vier Quadranten wurde vom französischen Astronomen und Physiker François Arago (1786–1853) explizit geteilt. Die Mutmaßung, dass der Ursprung der altpersischen Mythen aus der Zeit vor 5000 Jahren stammen muss, ist durch Schriftzeugnisse nicht belegt, da die ältesten indoiranischen Traditionen und Überlieferungen mit unklarer Herkunft nur bis ins zweite vorchristliche Jahrtausend zurückverfolgt werden können. Nichtsdestoweniger markierten die vier Königssterne vor rund 5000 Jahren die vier Hauptpunkte der Sonnenbahn an der Ekliptik. Die folgende Tabelle veranschaulicht die Wanderung des Frühlingspunktes in den letzten Jahrtausenden:
{| class="wikitable"
|+ Astronomische Längen vom Frühlingspunkt und den vier Königssternen
! Objekt !! !! Ekliptikale Länge zur<br/>Epoche J-3000.0 !! Ekliptikale Länge<br/>zur Epoche J2000.0 !! Differenz<br/>zur Epoche J2000.0 !! !! Deklination<br/>zur Epoche J-3000.0 !! Deklination<br/>zur Epoche J2000.0 !! Differenz<br/>zur Epoche J2000.0
|-
| Frühlingspunkt || || 0° || 0° || 0° || || 0h || 0h || 0h
|-
| Aldebaran || || 000°36' || 069°47' || 69°11' || || 00h11m || 04h35m || 04h24m
|-
| Regulus || || 081°03' || 149°50' || 68°47' || || 05h21m || 10h08m || 04h47m
|-
| Antares || || 180°42' || 249°46' || 69°04' || || 11h56m || 16h29m || 04h33m
|-
| Fomalhaut || || 264°12' || 333°51' || 69°39' || || 17h30m || 22h58m || 05h28m
|}
In 5000 Jahren ist der Frühlingspunkt also zirka 69,2 Bogengrad weiter nach Westen gelaufen, was in die jährliche Wanderung von einer Bogenminute oder die Dauer des Präzessionszyklus von rund 26000 Jahren umgerechnet werden kann:
:<math>\frac {69,2^\circ} {5000 \text{ a}} = 0,01384 \frac {^\circ} {\text{a}} \approx 0,83 \frac {\text{'}} {\text{a}} \approx 50 \frac {\text{''}} {\text{a}}</math>
:<math>\frac {5000 \text{ a}} {69,2^\circ} \approx \frac {26000 \text{ a}} {360^\circ}</math>
→ Siehe auch [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Astronomische_Bezugssysteme#Präzession|'''Präzession''']].
Die drei Zweige der indoeuropäischen Sprachen, die von den meisten Forschern der indoiranischen Sprachgruppe beziehungsweise der urindoiranischen Sprache zugeordnet werden, gehen von der Jamnaja-Kultur aus, die sich von 3600 bis 2300 vor Christus in der Gegend nördlich des Schwarzen Meeres gebildet hatte. Dafür gibt es mittlerweile auch archäologische und genetische Belege. Zu den indoeuropäischen Sprachen zählen auch Vedisch (Altindisch) und Altiranisch (Avestisch, Altpersisch, Medisch, Skytisch) sowie die keltischen Sprachen. Arago schreibt in seiner posthum erschienenen ''Astronomie populaire'':<ref>François Arago: ''Astronomie populaire'', Tome premier, Chapitre IX: ''Sur les moyens de connaître les constellations des anciens'', S. 342, Paris / Leipzig, 1854</ref>
<blockquote>
Ces quatre étoiles, très-brillantes et très-remarquables, appelées aussi '''étoiles royales''',<br/>
étaient sans doute les '''quatre gardiens du ciel''' des Perses, 3000 ans avant J.-C.<br/>
Alors Aldebaran était dans '''l'équinoxe du printemps''' et gardien de l’'''est''';<br/>
Antarès, ou le coeur du Scorpion, se trouvait précisément dans '''l'équinoxe d’automne''' et était le gardien de l’'''ouest''';<br/>
enfin Régulus n’était qu’à une petite distance du '''solstice d’été''',<br/>
et Fomalhaut à une petite distance du '''solstice d’hiver''',,<br/>
de manière à désigner pour les Perses le '''midi''' et le '''nord'''.
</blockquote>
<blockquote>
Diese vier sehr hellen und auffälligen Sterne, die auch als '''königliche Sterne''' bezeichnet werden,<br/>
waren zweifellos die '''vier Wächter des Himmels''' der Perser, 3000 vor Christus.<br/>
Damals stand Aldebaran im '''Frühlingspunkt''' und war der Wächter des '''Ostens''';<br/>
Antares, oder das Herz des Skorpions, befand sich genau im '''Herbstpunkt''' und war der Wächter des '''Westens''';<br/>
schließlich lag Regulus nur in geringer Entfernung vom Punkt der '''Sommersonnenwende''',<br/>
und Fomalhaut in geringer Entfernung vom Punkt der '''Wintersonnenwende''',,<br/>
sodass sie für die Perser den '''Süden''' und den '''Norden''' markierten.
</blockquote>
Die vier Sternbilder, die den vier christlichen Evangelistensymbolen Stier (Lukas), Löwe (Markus), fliegender Adler (Johannes) und Mensch (Matthäus) entsprechen, sind mit diesen vier Königssternen verknüpft: der Stier (Taurus) mit Aldebaran, der Löwe (Leo) mit Regulus, der über Skorpion (Scorpio) fliegende Adler (Aquila) mit Antares und der menschliche Wassermann (Aquarius) mit Fomalhaut im Südlichen Fisch (Piscis Austrinus), der zu Füßen des Wassermanns liegt.
→ Siehe auch [[Quadriviale_Kuriositäten/_Zahlen#Bedeutung_der_Vier_in_Religionen|'''Die vier Evangelistensymbole''']].
Andere Autoren wie der französische Astronom Jean Sylvain Bailly (1736–1793) ordnen die vier persischen Königssterne als Wächter über die vier Himmelsrichtungen in einer anderen Reihenfolge zu, wobei Venant hierbei nicht der Wächter des Südens, sondern des Nordens ist.<ref>Jean Sylvain Bailly: ''Histoire de l'astronomie ancienne, depuis son origine jusqu'a l'établissement de l'école d'Alexandrie.'' Livre Neuvieme ''Des constellations, du zodiaque , & des planispheres anciens.'', § X., p 480–481, De Bure, Paris, 1781</ref> Hierbei ist aus astronomischer Sicht anzumerken, dass alle vier Königssterne bei dieser jahreszeitlichen Zuordnung – wenn überhaupt – nur kurz nach Sonnenuntergang im Westen zu sehen waren und keineswegs als Wächter ihrer Himmelrichtungen wahrgenommen werden konnten:
{| class="wikitable"
|+ Die vier persischen Königssterne nach Himmelsrichtungen nach Bailly (1781)
! Stern !! Bayer-Bezeichnung !! Persische Bezeichnung !! Konjunktion mit der Sonne<br/>zur Epoche J-2000 !! Umschreibung der Lage<br/>bei Sonnenaufgang<br/>zum Frühlingsäquinoktium
|-
| Aldebaran || α Tauri || Tascheter/Taschter || Frühlingsäquinoktium || Wächter des Ostens
|-
| Regulus || α Leonis || Venant || Sommersonnenwende || Wächter des Nordens
|-
| Antares || α Scorpii || Satevis || Herbstäquinoktium || Wächter des Westens
|-
| Fomalhaut || α Piscis Austrini || Haftorang/Hastorang || Wintersonnenwende || Wächter des Südens
|}
====Der Himmelsstier====
{{Wiktionary|Stier}} [[Datei:Stiersymbol.P1079912.png|mini|rechts|hochkant=1.5|Asterismus des Himmelsstieres mit den Bezeichnungen der hellsten Sterne. Der Stern γ Tauri (Hyadum I) im Maul des Stierkopfes ist der einzige in dieser Darstellung, von dem drei gelbe Linien ausgehen.]]
Das deutsche Wort „'''Stier'''“ lässt sich auf die beiden verwandten mittelhochdeutschen Wörter „'''stier'''“ (glasig blickend) und „'''sterre'''“ (starr, unbeweglich) zurückführen. Auch die deutschen Wörter „'''stieren'''“ (starr blicken) und „'''starren'''“ (bewegungslos auf etwas schauen) sind damit verwandt. Das althochdeutsche Wort „'''stiuri'''“ bedeutet „stark“. Auch die folgenden Wörter für „Stier“ scheinen auf ein altes gemeinsames Lehnwort zurückzugehen: assyrisch „'''šûru'''“, hebräisch „'''šōr'''“, phönizisch „'''thōr'''“ und aramäisch „'''tōra'''“ beziehungsweise im verwandten Mittelpersisch (Pahlavi, Zoroastrier) "'''tôrâ'''" (man bemerke die Übereinstimmung zum hebräischen Begriff „Tora“ für den Pentateuch, also die fünf Bücher Mose), altgriechisch „ταυρος“ („'''tauros'''“), lateinisch „'''taurus'''“.<ref>Hermann Güntert: [https://www.google.de/books/edition/Les_g%C3%A8tes/93Kpr95vO0YC?hl=de&gbpv=1&dq=aram%C3%A4isch%20tora%20stier&pg=RA1-PA56&printsec=frontcover&bsq=aram%C3%A4isch%20 Indogermanisch und Semitisch], Kapitel V. ''Sprachliche Beziehungen der Indogermanen zu anderen Völkergruppen'', in: ''Kultur und Sprache'' / ''Der Ursprung der Germanen'', Seite 56, Carl Winter, Heidelberg, 1934</ref> Hierbei fällt auf, dass auch die nordische Himmelsgottheit „'''Thor'''“ genannt wird und dass diese mit den antiken Himmelsgottheiten „'''Zeus'''“ beziehungsweise „'''Jupiter'''“ gleichgesetzt wird. Diese Gottheiten sollen mit dem Fahren eines Wagens über ein Gewölbe ein gewaltiges Donnern verursachen. In Israel hat sich Jahwe vermutlich unter phönizischem Einfluss zum Himmelsgott entwickelt, wobei er mit den Gestirnen in Verbindung gebracht wurde. Als Prototyp der Vorstellung von Jahwe als Himmelsgott findet sich in der westsemitischen Gottheit „Baal des Himmels“ (Baalschamem).<ref>Izak Cornelius: [https://www.bibelwissenschaft.de/stichwort/21206/ 4. Der Himmelsgott in der Religionsgeschichte von Israel und Juda], in: ''Himmelsgott'', Deutsche Bibelgesellschaft, Februar 2011</ref><ref>Matthias Albani: ''Der eine Gott und die himmlischen Heerscharen - Zur Begründung des Monotheismus bei Deuterojesaja im Horizont der Astralisierung des Gottesverständnisses im Alten Orient'', Evangelische Verlagsanstalt, 2000, ISBN 3-374-01820-3</ref> Im Zoroastrismus hat das ursprüngliche Rind, der ursprüngliche Stier beziehungsweise der Urochse den avestischen Namen '''Gav-aevo-data'''. Nachdem dieses Tier getötet wurde, floh es als Seele Goshorun (avestisch: "Geush Urvan") zu den Stern-, Mond- und Sonnenstationen auf der Ekliptik und beklagte dort die Zerstörung der Welt. Nach seiner Besänftigung wurde es zum Urahn aller Nutztiere.
Das mittelhochdeutsche Wort „'''sterre'''“ kann auch mit „Stern“ übersetzt werden und ist mit dem Wort „Gestirn“ eng verwandt. Im Lateinischen heißt es ebenfalls sehr lautähnlich „'''aster'''“ beziehungsweise „astrum“ sowie im Altgriechischen „'''ἄστρον'''“ („astron“). Das englische Wort „'''star'''“ bedeutet „Stern“ und „'''starry'''“ bedeutet „gestirnt“.
→ Zur Etymologie des Wortes "Stier" in verschiedenen Sprachen siehe auch [[Die_Himmelstafel_von_Tal-Qadi/_Die_Plejaden#Zusammenhang_mit_dem_Stier|Kapitel '''Die Plejaden''', Abschnitt '''Zusammenhang mit dem Stier'''.]]
Insofern ist es wenig überraschend, in einem wichtigen Sternbild des Lebewesenkreises (Zodiak) einen Stier am Nachthimmel zu finden. In diesem Sternbild befand sich im Neolithikum der Frühlingspunkt der Sonne. Der ursprüngliche sehr großflächige Asterismus des '''Himmelsstieres''' (lateinisch: „taurus caeli“, griechisch: „ταυρος Ολίμπου“ / „tauros Olympou“) ist als Konstellation sehr gut erkennbar und deutlich größer als das heutige verstümmelte Sternbild Stier (Taurus). Es befindet sich ferner in der Himmelsregion der aktuellen Sternbilder Walfisch (Cetus), Widder (Aries) und Fuhrmann (Auriga). Weiter westlich schließen sich die Lebewesenkreiszeichen Fische (Pisces) und Wassermann (Aquarius) an. Südlich vom Stier befindet sich das Sternbild Fluss Eridanus, südlich vom Widder das Sternbild Walfisch (Cetus) und südlich vom Wassermann das Sternbild Südlicher Fisch (Piscis Austrinus). Es ist festzuhalten, dass diese fünf Sternbilder allesamt mit Wasser in Verbindung stehen.
Als eines der zwölf Ekliptiksternbilder hat der Stier seit der babylonischen Zeit allerdings nur eine ekliptikale Gesamtlänge von 30 Bogengrad. In der römischen Mythologie wird die '''Tauroktonie''' (Kunstwort aus lateinisch "taurus" ("Stier") und altgriechisch "σκοτώνω" ("skotono" = "Herausschneiden")) beschrieben: die ikonischen Darstellungen zeigen den römischen Gott '''Herakles''', der den Stier durch einen Dolchstoß tötet. Vom ursprünglichen Himmelsstier wurde das Sternbild Widder (Aries) "herausgeschnitten", so dass heute nur noch der vordere Teil des Stieres einschließlich der Plejaden zum Sternbild Stier (Taurus) gehört. Plinius der Ältere hat dem griechischen Astronomen und Dichter Kleostratos von Tenedos zugeschrieben, das Sternbild Widder erst im sechsten Jahrhundert vor Christus benannt zu haben.<ref>Johann Evangelista Rivola: ''Über die griechischen Sternbilder insbesondere die Plejaden'', astronomisch-mythologische Abhandlung, Malsch und Vogel, Karlsruhe, 1858</ref>
Bei den '''Arabern''' gehören die Plejaden (arabisch: "Thuraya") sowohl zum Asterismus "Hände der Thuraya" als auch als fetter Schwanz des Lammes zum Asterismus "Lamm" (Widder).<ref name="lamb" />
Der große Himmelsstier umfasst die folgenden Hauptsterne:
{| class="wikitable sortable" cellpadding="2" cellspacing="1"
|+ Die Hauptsterne des Asterismus „Himmelsstier“
|-
! title="Astronomische Bezeichnung"|Astronomische<br/>Bezeichnung
! title="Eigenname"|Eigenname
! title="Lage"|Lage im<br/>Himmelsstier
! title="Scheinbare Helligkeit"|Scheinbare<br/>Helligkeit
|-
| ζ Tauri
| Tien Kuan
| Rechte Hornspitze
| 3,0<sup>m</sup>
|-
| β Tauri
| Elnath
| Linke Hornspitze
| 1,7<sup>m</sup>
|-
| α Tauri
| Aldebaran
| Rechtes, rotes Auge
| 0,9<sup>m</sup>
|-
| ε Tauri
| Ain
| Linkes Auge
| 3,5<sup>m</sup>
|-
| γ Tauri
| Hyadum I
| Maul
| 3,6<sup>m</sup>
|-
| M45 (Taurus)
| Plejaden
| Rücken
| 1,6<sup>m</sup>
|-
| 41 Aries
| Bharani / Nair al Butain
| Schwanz
| 3,6<sup>m</sup>
|-
| α Aries
| Hamal
| Hinterlauf
| 2,0<sup>m</sup>
|-
| β Aries
| Sheratan
| Hinterlauf
| 2,6<sup>m</sup>
|-
| α Cetis
| Menkar
| Vorderlauf
| 2,5<sup>m</sup>
|}
<gallery caption="Der Asterismus Himmelsstier" widths="1024" heights="768" perrow="1">
Himmelsstier.P1117152.jpg|Astrophotographie vom Himmelsstier am winterlichen Abendhimmel in Richtung südlicher Meridian. Die Ekliptiklinie verläuft horizontal etwas unterhalb der Bildmitte.<br/>In der Mitte das Sternbild '''Stier (Taurus)''' mit dem hellsten Stern '''Aldebaran''' im offenen Sternhaufen der '''Hyaden''', darüber in der Bildmitte auf dem Meridian der offene Sternhaufen der '''Plejaden (Siebengestirn)'''. Die beiden Hornspitzen befinden sich links, der Hinterlauf wird durch das Sternbild '''Widder (Aries)''' mit dem hellsten Stern '''Hamal''' gebildet.<br/>Links oben das Sternbild '''Fuhrmann (Auriga)''' mit dem hellsten Stern '''Capella'''.<br/>Oben in der Mitte das Sternbild '''Perseus''' mit dem hellsten Stern '''Mirfak''', rechts darunter der Stern '''Algol'''.<br/>Rechts oben das Sternbild '''Andromeda''' mit den beiden hellen Sternen '''Alamak''' (links) und '''Mirak''' (rechts).<br/>Direkt darunter das kleine Sternbild '''Dreieck (Triangulum)'''.<br/>Rechts unten das Sternbild '''Walfisch (Cetus)''' mit dem hellsten Stern '''Menkar''' im Vorderlauf.<br/>Links unten das '''Sternbild Orion''' mit den beiden hellen Sternen '''Beteigeuze''' (links) und '''Bellatrix''' (rechts).
Himmelsstier.Sternbilder.P1117152.png|Gleiche Aufnahme mit Beschriftungen der heutigen Sternbilder und der wichtigsten Sterne.<br/>Der grünliche Planet Uranus befand sich zum Zeitpunkt der Aufnahme auf halber Strecke zwischen Menkar und Hamal etwas südlich der Ekliptiklinie.
</gallery>
<gallery caption="Der Asterismus Himmelsstier" mode="packed" widths="300" heights="300">
Vollmond.Trichter.Thuraya.P1079912.jpg|Astronomische Aufnahme des Asterismus des '''Himmelsstieres mit dem Vollmond''' in der Himmelsregion der heutigen Sternbilder Stier (Taurus, links oben), Walfisch (Cetus, unten) und Widder (Aries, rechts). Die Ekliptik verläuft von rechts unten durch das Goldene Tor der Ekliptik in der Bildmitte nach links oben durch die Mitte zwischen den Spitzen der Stierhörner.
Vollmond.Stiersymbol.P1079912.png|Dieselbe astronomische Aufnahme mit dem eingeblendeten Asterismus des Himmelsstieres. Die Ekliptiklinie kreuzt in etwa die Mittelpunkte der drei gedachten Verbindungslinien Menkar-Sheratan, Aldebaran-Plejaden und Tien Kuan-Elnath.
Stiersymbol.Magura.png|'''[[Die_Höhlenmalerei_in_der_Magura-Höhle#Zweite_Station|Der Himmelsstier in einer Höhlenmalerei in der Höhle von Magura]]''' (Wikibook Die Höhlenmalerei in der Magura-Höhle, Abschnitt Zweite Station). Der Fußabdruck auf der Ekliptik kann als Symbol für den Eintritt der sieben entlang der Ekliptik wandernden Wandelgestirne aus dem dunklen Trichter der Thuraya (rechts unten) mit den heutigen Sternbildern Widder (Aries), Fische (Pisces) und Wassermann (Aquarius) in das Goldene Tor der Ekliptik (Bildmitte) im heutigen Sternbild Stier (Taurus) gedeutet werden.
Himmelstafel.Tal-Qadi.Himmelsstier.png|Der Himmelsstier und die '''[[Die Himmelstafel von Tal-Qadi]]'''. Die Öffnung zwischen den Vorder- und Hinterläufen umspannt genau die lange grade Kante der Himmelstafel. Das Goldene Tor der Ekliptik wird demnach durch den Bogen mit den Beinen und dem Körper des Himmelsstieres gebildet.<ref>Markus Bautsch: ''Betrachtungen zur Himmelstafel von Tal-Qadi'', in: ''Journal für Astronomie'', Nummer 80, Seiten 109 bis 113, Vereinigung der Sternfreunde, Heppenheim, Januar 2022, ISSN 1615-0880</ref>
250_Himmelsstier.Mondhaeuser.Ekliptik.png|Darstellung des Himmelsstiers in den fünf ersten [[Die Himmelstafel von Tal-Qadi/ Konjunktionen#Manazil_al-Qamar|'''Mondhäusern des arabischen Manazil al-Qamar''']] mit den hellsten ekliptiknahen Sternen. Die rote Linie markiert die Lage der Ekliptik, und unten sind die dazugehörigen ekliptikalen Längen zum Frühlingspunkt der Epoche J0000.0 sowie rechts die ekliptikalen Breiten aufgetragen.
</gallery>
Das Sternbild Stier (Taurus) gehörte schon immer und überall zu den bedeutendsten Sternbildern.<ref>[https://www.scinexx.de/dossierartikel/stierschaedel-mit-sternenbezug/ Stierschädel mit Sternenbezug – Himmelswissen der Steinzeit älter als gedacht], scinexx, 1. Februar 2008</ref> Neben den beiden offenen Sternhaufen der Hyaden und der [[Die_Himmelstafel_von_Tal-Qadi/_Die_Plejaden|'''Plejaden''']] ist der helle Rote Riese '''Aldebaran''' besonders markant und wird häufig als das leuchtende rechte Auge des Stieres betrachtet. Im 18. Jahrhundert wurde er in Deutschland auch als das Ochsenauge bezeichnet.<ref>Siehe Schlagwort "Aldebaran" in: ''Johann Heinrich Zedlers Grosses vollständiges Universal-Lexikon aller Wissenschaften und Künste'', 1731-1754, Spalte 1095</ref> Der Name Aldebaran stammt aus dem Arabischen und bedeutet der (den Plejaden beim Aufgang am östlichen Morgenhimmel) Folgende. Der Stern Elnath ist heute gleichzeitiger Bestandteil des Sternbilds Fuhrmann (Auriga).
Die scheinbare Sonnenbahn wird '''[[Die_Himmelstafel_von_Tal-Qadi/_Astronomische_Bezugssysteme#Die_Ekliptik|Ekliptiklinie]]''' genannt. Sie dient als Bezugslinie für die astronomischen Koordinaten des Ekliptiksystems. Alle sieben mit bloßem Auge sichtbaren Wandelgestirne ziehen entlang der Ekliptiklinie aus dem dunklen '''[[Die_Himmelstafel_von_Tal-Qadi/_Astronomische_Bezugssysteme#Der_Trichter_der_Thuraya|Trichter der Thuraya]]''' durch das Goldene Tor der Ekliptik in die sternenreicheren Regionen des Himmels. Üblicherweise werden die ekliptikalen Längen vom '''[[Die_Himmelstafel_von_Tal-Qadi/_Astronomische_Bezugssysteme#Der_Frühlingspunkt|Frühlingspunkt]]''' aus gemessen, und die ekliptikalen Breiten senkrecht zu dieser Linie nach Norden und nach Süden. Der Frühlingspunkt lag vor gut 5000 Jahren (also zur Epoche J-3000) im '''[[Die_Himmelstafel_von_Tal-Qadi/_Astronomische_Bezugssysteme#Das_Goldene_Tor_der_Ekliptik|Goldenen Tor der Ekliptik]]''', also mitten im Himmelsstier, bei der damaligen ekliptikalen Länge des Sterns Aldebaran (α Tauri, Alphastern oder das rote Ochsenauge des Sternbilds Stier (lateinisch: „Oculus Tauri“)<ref>Johann Elert Bode: [https://books.google.de/books?id=OIsoAAAAcAAJ&pg=PA296&lpg=PA296 Deutliche Anleitung zur Kenntniß des gestirnten Himmels], "Zum gemeinnützigen und beständigen Gebrauch", Seite 296, Dieterich Anton Harmsen, Hamburg, 1772</ref><ref>Siehe auch Schlagwort „Aldebaran“ in: ''Johann Heinrich Zedlers Grosses vollständiges Universal-Lexikon aller Wissenschaften und Künste'', 1731-1754, Spalte 1095</ref><ref>Damond Benningfield: [https://www.deutschlandfunk.de/das-rote-stierauge-102.html Das rote Stierauge], Deutschlandfunk, 16. Januar 2000</ref>) von null Bogengrad. Die Sonne stand zum Frühlingsbeginn, der damals häufig den Jahresbeginn markierte, demnach in '''[[Die_Himmelstafel_von_Tal-Qadi/_Konjunktionen|Konjunktion]]''' zu diesem Stern. Während eines Sonnenjahres zog die Sonne auf ihrer kreisförmigen Bahn vom Jahres'''anfang''' beim Stern Aldebaran bis zum Jahres'''ende''' beim Stern '''Ain''' (ε Tauri, der andere Augenstern) mit der ekliptikalen Länge von rund 359 Bogengrad kurz vor dem erneuten Erreichen des Frühlingspunktes.
[[Datei:Coeli.enarrant.gloriam.Dei.RP-P-OB-57.078.png|mini|rechts|hochkant=2|Der Kupferstich "Coeli enarrant gloriam Dei" von Bernard Picart (* 1673 ; † 1733), Amsterdam, 1727.]]
In diesem Zusammenhang ist es interessant, die Verse zwei bis sieben aus Psalm 19 zu reflektieren:<ref>[https://www.bibelwissenschaft.de/bibelstelle/Ps18/VULG/ Psalm 18 (19), Verse 2 bis 7], Vulgata, Psalmi iuxta Hebraicum translatus</ref>
<blockquote>
2 Caeli enarrant gloriam Dei et opus manus eius adnuntiat firmamentum
3 Dies diei eructat verbum et nox nocti indicat scientiam
4 Non est sermo et non sunt verba quibus non audiatur vox eorum
5 In universam terram exivit sonus eorum et in finibus orbis verba eorum
6 Soli posuit tabernaculum in eis et ipse quasi sponsus procedens de thalamo suo exultavit ut fortis ad currendam viam
7 A summitate caeli egressus eius et cursus eius usque ad summitatem illius nec est qui se abscondat a calore eius
</blockquote>
Die Einheitsübersetzung hat diese Verse folgendermaßen ins Deutsch übertragen:<ref>[https://www.bibleserver.com/EU/Psalm19,2-7 Psalm 19, Verse 2 bis 7], Einheitsübersetzung (2016)</ref>
<blockquote>
2 Die Himmel erzählen die Herrlichkeit Gottes und das Firmament kündet das Werk seiner Hände.
3 Ein Tag sagt es dem andern, eine Nacht tut es der andern kund,
4 ohne Rede und ohne Worte, ungehört bleibt ihre Stimme.
5 Doch ihre Botschaft geht in die ganze Welt hinaus, ihre Kunde bis zu den Enden der Erde. Dort hat er der Sonne ein Zelt gebaut.
6 Sie tritt aus ihrem Gemach hervor wie ein Bräutigam; sie frohlockt wie ein Held, ihre Bahn zu laufen.
7 Am einen Ende des Himmels geht sie auf und läuft bis ans andere Ende; nichts kann sich vor ihrer Glut verbergen.
</blockquote>
Die Deutung der beiden Sterne Aldebaran und Ain als die Augensterne des Himmelsstieres ist sehr alt:
Der erste Buchstabe unseres Alphabets A wird im Altgriechischen mit '''Alpha''' (groß: Α, klein: α) bezeichnet. Dieser wiederum hat seine Entsprechungen in noch älteren Alphabeten. Im Hebräischen wird er '''Aleph''' genannt und im Arabischen '''Alif'''. Der helle Stern Aldebaran (alpha Tauri) kann mit dem ersten Buchstaben '''Aleph''' des bereits im zweiten vorchristlichen Jahrtausend verwendeten phönizischen Alphabets in Zusammenhang gebracht werden:<ref name="ErnstVonBunsen">Ernst von Bunsen: ''Die Plejaden und der Thierkreis oder: Das Geheimnis der Symbole'', Verlag von Mitscher und Röstell, Berlin, 1879</ref> In der sehr alten protosinaitischen und phönizischen Sprache wurden für diesen Buchstaben die folgenden Schriftzeichen verwendet:
<gallery caption="Die ersten Buchstaben in alten Alphabeten" widths="180" heights="180" perrow="2">
Proto-Canaanite_letter_alp.svg|Der protosinaitische Buchstabe '''alp''' (um 1500 vor Christus).
PhoenicianA-01.svg|Der phönizische Buchstabe '''alf''' (um 1000 vor Christus).
</gallery>
Dieser Buchstabe wird paläographisch mit dem Begriff „Ochse“ beziehungsweise „Stier“ gedeutet. Die Ägypter kannten die Hieroglyphe [[Datei:Abydos-Bold-hieroglyph-F1.png|30px]] (F1) für „Ochsenkopf“. In Anatolien wurde im 2. und 1. Jahrtausend vor Christus die luwische Hieroglyphe [[Datei:Hieroglyph_Luwian_BOS.jpg|40px]] für „Rind“ verwendet.
Auch der Buchstabe O unseres Alphabets hat eine Entsprechung im Altgriechischen, den Buchstaben Omikron (groß: Ο, klein: ο) . Auch dieser hat Entsprechungen in noch älteren Alphabeten. Im Hebräischen wird er '''Ajin''' und im Arabischen wird er '''Ain''' genannt. In der sehr alten protosinaitischen und phönizischen Sprache wurden die folgenden Schriftzeichen verwendet:
<gallery caption="Die Augen-Buchstaben in alten Alphabeten" widths="180" heights="180" perrow="2">
Proto-Canaanite letter en.svg|Der protosinaitische Buchstabe '''en''' (um 1500 vor Christus).
PhoenicianO-01.svg|Der phönizische Buchstabe '''ain''' (um 1000 vor Christus).
</gallery>
Dieser Buchstabe wird paläographisch mit dem Begriff „Auge“ gedeutet. Die Ägypter benutzen für diesen Begriff die Hieroglyphe [[Datei:Hieroglyph D4.svg|40px]] (D4).
===== Mythologie =====
In der Mythologie wird das Sternbild Stier (Taurus) auch unter den folgenden Bezeichnungen geführt:<ref>[https://www.zedler-lexikon.de/index.html?c=blaettern&zedlerseite=ze400032&bandnummer=40&seitenzahl=0032&dateiformat=1&view=150&supplement=0%27) Johann Heinrich Zedlers Grosses vollständiges Universal-Lexicon aller Wissenschafften und Künste "Stier, Taurus"] 1731–1751</ref>
* '''Altor''' (lateinisch für "Fürsorger" / "Ernährer")
* '''Aratus''' (altgriechisch: "Ἄρατος" = "Aratos", in der griechischen Mythologie der Sohn des Gottes Asklepios und der Aristodama)
* '''Ataur''' (arabisch für "Gabe")
* '''Bubulum caput''' (lateinisch für "Rinderkopf")
* '''Io''' (in der griechischen Mythologie die Tochter des Flussgottes Inachos und der Melia sowie eine Geliebte des Gottes Zeus)
* '''Isis''' (in der ägyptischen Mythologie die Göttin der Geburt, der Wiedergeburt und der Magie)
* '''Mesoris''' (Monat im alten ägyptischen und koptischen Kalender, auch: Mesori, Mesut-Re, griechisch Mesore, koptisch Mesori, arabisch Mesra)
* '''Osiris''' (altgriechisch "Ὄσιρις" = Osiris, ein altägyptischer Gott des Jenseits und der Wiedergeburt)
* '''Portitor Europae''' (lateinisch für "Fährmann der Europa")
Ernst Christian Ludwig von Bunsen (* 1819; † 1903) wies Ende des 19. Jahrhunderts darauf hin, dass die eine der älteren chaldäischen Formen des hebräischen Gottesnamens „JHWH“, nämlich '''„JAO“''' mit kosmischen Symbolen verknüpft sein könnte. Die beiden paläographischen Buchstaben „A“ (Alpha, Aleph) und „O“ (Omikron, Ajin) waren vor 4000 Jahren vom Frühlingspunkt gerechnet mit dem ersten Zeichen Stier und dem letzten Zeichen Widder des Lebewesenkreises (Zodiak) verbunden. Die Sonne war bei den Phöniziern mit dem Buchstaben „J“ verknüpft, und wenn dieses „J“ dem „A“ und dem „O“ vorangestellt wird, ergibt sich die Buchstabenfolge „JAO“ (Iota - Alpha - Omikron beziehungsweise Jod, Aleph, Ajin). Dies symbolisiert den jährlichen Sonnenlauf der Sonne „J“ von Frühlingspunkt „A“ entlang der Ekliptiklinie bis zum letzten Lebewesenkreiszeichen Widder (Aries) „O“.<ref>Ernst von Bunsen: ''Die Überlieferung. Ihre Entstehung und Entwicklung'', neuntes Kapitel "Früheste Astrologie", Seite 140, Fußnote 1), Friedrich Arnold Brockhaus, Leipzig, 1889</ref> Es wäre auch denkbar, dass die beiden Buchstaben „A“ und „O“ unmittelbar mit den beiden sehr auffälligen Augensternen des Himmelsstiers im Frühlingspunkt der Sonnenbahn Aldebaran (α Tauri = alpha Tauri = Aleph, ekliptikale Länge zur Epoche J-3000 = 0 Bogengrad) und Ain (ε Tauri = epsilon Tauri, Ajin, ekliptikale Länge zur Epoche J-3000 = 359 Bogengrad) verknüpft sind, was auch ganz ohne die Voraussetzung des Zodiaks eine Erklärung liefern würde, der erst später als die Alphabete entwickelt wurde. Wie auch immer, solche Zusammenhänge würden erklären, dass der Gottesname mit dem göttlichen Himmelsstier in Zusammenhang steht.
:'''Anmerkung''':
:Wie weiter oben ausgeführt, bedeutet das aramäische Wort '''„tōra“''' „Stier“. Unter der Annahme, dass nach dem zweiten Gebot von Gott kein Bild gemacht werden darf (Bilderverbot),<ref>Deuteronomium,, 20. Kapitel, Vers 4 (Einheitsübersetzung (2016): "Du sollst dir kein Kultbild machen und keine Gestalt von irgendetwas am Himmel droben, auf der Erde unten oder im Wasser unter der Erde."</ref> wäre es durchaus nahliegend, das ursprünglichste Wort Gottes des jüdischen Glaubens (namentlich die fünf Bücher Mose der Bibel, den Pentateuch der Septuaginta beziehungsweise die '''Tora''' des Talmuds) mit dem Namen des Stieres, der als Himmelsbild Gott repräsentiert, gleichzusetzten, also mit dem aramäischen Namen „tōra“.
:Vergleiche hierzu auch die Anfertigung zweier goldene Rinderfiguren als Gottesbild durch Jerobam I., den ersten König des Nordreichs Israel, die im zwölften Kapitel des ersten Buchs der Könige beschrieben ist:<ref>[https://www.bibleserver.com/EU/1.K%C3%B6nige12%2C28-30 1. Buch der Könige, Kapitel 12, Verse 28 bis 30], Einheitsübersetzung (2016)</ref>
::28 So ging er mit sich zu Rate, ließ '''zwei goldene Kälber''' anfertigen und sagte: Ihr seid schon zu viel nach Jerusalem hinaufgezogen. '''Hier sind deine Götter, Israel,''' die dich aus Ägypten heraufgeführt haben.
::29 Er stellte das eine Kalb in Bet-El auf, das andere brachte er nach Dan.
::30 Dies wurde Anlass zur Sünde. Das Volk zog vor dem einen Kalb her bis nach Dan.
Der Stier wird offenbar seit jeher im Zusammenhang mit der Urflut und der Sonne gesehen. Viele Mythen bringen auch die Elemente Himmel, Mond, Gestirne, Schöpfer, Gold oder Lichtbringer im Zusammenhang mit Rindern, wie zum Beispiel in der Sage über die kolossale himmlische "Rote Kuh" im zehnten Gesang des finnischen Epos Kalevala (Verse 361 ff.):<ref>Ernst Ludwig Rochholz: [https://www.google.de/books/edition/Naturmythen/IA134iTfQoAC 4. Sturmthiere - 1) Gespenstische Dorfthiere], in: ''Naturmythen - Neue Schweizersagen'', Verlag Benedictus Gotthelf Teubner, Leipzig, 1862</ref><ref>Friedrich Leberecht Wilhelm Schwartz: [https://www.google.de/books/edition/Sonne_mond_und_sterne/pshPAAAAcAAJ Kapitel VI: Thierartige an die Sonne mit besonderer Berücksichtigung der Sonnenstrahlen sich anschließende Vorstellungen], in: ''Sonne, Mond und Sterne - ein Beitrag zur Mythologie und Culturgeschichte der Urzeit'', Verlag Wilhelm Hertz (Bessersche Buchhandlung), 1864</ref>
<blockquote>
Eine Kuh dringt aus dem Feuer,<br/>
Golden strahlen ihre Hörner,<br/>
An der Stirn der Bär vom Himmel,<br/>
Auf dem Kopf das Rad der Sonne.
</blockquote>
Stiere wurden im Altertum häufig in Abbildungen dargestellt, in denen Bezüge zu Gegenständen, Lebewesen oder Gottheiten zu erkennen sind. Im Alten Testament wir der Stier mit den Attributen Fruchtbarkeit, Macht, Kampf und Stärke in Verbindung gebracht.<ref> Klaus Koenen: [https://www.bibelwissenschaft.de/stichwort/30502/ 2. Stierbilder als Symbol von Macht und Stärke], in: ''Stierbilder'', Deutsche Bibelgesellschaft, November 2009</ref>
<gallery mode="packed" widths="300" heights="300" caption="Alte Darstellungen des Himmelsstiers">
LascauxHimmelsstier.png|Stierkörper in der Höhle der Stiere von '''Lascaux''' in Frankreich. Über dem Rücken befinden sechs Punkte sich an der Stelle, wo sich im Himmelsstier die Plejaden befinden.
Apis MET 04.2.486 EGDP014918.jpg|Der altägyptische '''Apis-Stier''' wurde bereits vor 5000 Jahren in der Frühdynastischen Periode verehrt, war schwarz und hatte als heilige Zeichen ein auf der Spitze stehendes weißes Dreieck auf der Stirn sowie eine weiße Mondsichel auf seiner rechten Seite. Im Neuen Reich seit der zweiten Hälfte des zweiten vorchristlichen Jahrtausends wurde er mit der Sonnenscheibe zwischen den Hörnern dargestellt.
Stierkopf.Bronze.3.JahrtausendBC.P1151451.jpg|Babylonischer Stierkopf aus der frühen Bronzezeit in der Vorderasiatischen Ausstellung des Pergamonmuseums in Berlin.
Hadad.Syrien.swTBB521.png|Stierköpfiges Relief an einer Stele aus Basalt in '''Tell el-Aš’ari''' in Süden von '''Syrien''' aus dem 9. bis 8. Jahrhundert vor Christus mit einer lunarisierten Darstellung des aramäischen Mondgottes Hadad. Die dem Himmelsstier entsprechenden Bestandteile sind hellblau hervorgehoben.<ref>Gabriele Theuer: [https://www.bibelwissenschaft.de/stichwort/27985/ Mond, 2. Mondgottverehrung in Syrien-Palästina, 2.3. Der Mondgott bei den Aramäern – der Mondkult von Haran (Eisenzeit)], WiBiLex, Das wissenschaftliche Bibellexikon im Internet, Deutsche Bibelgesellschaft, April 2010</ref>
Athens Bull Rhyton 020911.jpg|Rhyton in Form eines Stierkopfes aus Grab IV des Gräberrundes aus der Bronzezeit auf der '''Zitadelle von Mykene''' in Griechenland.
Gemme.Mond.Stern.Sonne.ain.kaf.ros.kaf.kaf.lamd.2Stierkoepfe.png|Gemme mit der Darstellung von liegender Mondsichel, Stern und Sonne mit elf zackenförmigen Strahlen, mit einer Inschrift mit den phönizischen Buchstaben lamd, kaf, kaf, ros, kaf, ain (von rechts nach links, dies entspricht hebräisch „לככרכע“, griechisch „λκκρκο“ beziehungsweise lateinisch „lkkrko“) sowie mit zwei Stierköpfen aus der kaiserlichen Nationalbibliothek in Paris. Die Übersetzung der Inschrift dürfte „dem mächtigen Baal“ bedeuten.<ref>Moritz Abraham Levy: [https://books.google.de/books?id=w2o6AAAAcAAJ&lpg=PA31&ots=CFLP1IzvXr&dq=phoenizische%20buchstaben%20sonne%20mond&hl=de&pg=PA36#v=onepage&q&f=false Phönizische Studien - II. Backsteine, Gemmen und Siegel aus Mesopotamien mit phönizischer (altsemitischer) Schrift - B "Gemmen und Siegel" - Nummer 11], Seite 36 und 37, siehe auch Tafel 10, Band 2, Leuckart, Breslau, September 1857</ref>
Taureau.Gavrinis.png|Steinzeitliches Stierornament mit langen Hörnern auf einem zirka 6000 Jahre alten Menhir in einem '''Dolmen aus Gavrinis und Table des Marchands''' am Golf von Morbihan in der südlichen Bretagne.<ref>Charles-Tanguy Le Roux, Jean-Paul Gisserot, Philippe Laplace: ''Gavrinis'', Editions Jean-Paul Gisserot, 1995, ISBN 9782877471459</ref><ref>Charles-Tanguy Le Roux: ''A propos des fouilles de Gavrinis (Morbihan) : nouvelles données sur l'art mégalithique armoricain'', Bulletin de la Société préhistorique française, 81-8, 1984, Seiten 240 bis 245</ref><ref>Éric Gaumé: ''Cornes d'aurochs (supplique pour le réexamen d'une gravure néolithique de bovidé dans l'île morbihannaise de Gavrinis, Bretagne)'', Bulletin de la Société préhistorique française, 104-1, März 2007, Seiten 81 bis 88</ref><ref>Jean-Pierre Mohen: ''Le menhir au taureau brisé de Gavrinis (Morbihan)'', in: ''Pierres vives de la préhistoire: Dolmens et menhirs'', Odile Jacob, 2009, Seiten 133 ff, ISBN 9782738123077</ref> Unter den Hörnern ist ein Zeichen zu sehen, das eine auffällige Ähnlichkeit zu Zeichen aus der bulgarischen Magura-Höhle aber auch zum chinesischen Schriftzeichen für „Rind“ [[Datei:牛-bronze.svg|40px]] in der Bronzeinschrift der alten Shang-Dynastie aufweist.
Urfa Göbeklitepe Building A 5336.png|Stierdarstellung auf dem Pfeiler 2 in Anlage A auf dem Hügel von Gobekli Tepe (älteste Siedlungsschicht III, 9600 bis 8800 vor Christus)
Hathor cow.svg|Im alten Ägypten wurde die Himmelsgöttin Hathor zunächst in der Darstellung einer Kuh und später als allumfassenden Muttergottheit verehrt.
</gallery>
[[Datei:BlumeDesLebens19.png|mini|rechts|Hexagonaler Ring mit neunzehn jeweils um eine Radiuslänge überlappenden Kreisen.]]
Der Himmelsstier symbolisiert die Erschaffung des Himmels als Bringer aller Gestirne:
* '''Sieben''' Wandelgestirne:
** '''Ein''' zentrales Hauptgestirn (die '''Sonne''').
** '''Sechs''' weitere Wandelgestirne: der '''Mond''' und die fünf mit bloßem Auge sichtbaren Planeten '''Merkur''', '''Venus''', '''Mars''', '''Jupiter '''und '''Saturn'''.
* Die '''Fixsterne''' repräsentiert durch den '''Zodiak''' mit seinen '''zwölf''' Lebewesenzeichen ('''Stier, Zwillinge, Krebs, Löwe, Jungfrau, Waage, Skorpion, Schütze, Steinbock, Wassermann, Fische, Widder''').
Dies sind insgesamt neunzehn Bestandteile. Ein symmetrischer hexagonaler Ring aus '''neunzehn''' gleichgroßen Kreisen ist wie folgt aufgebaut:
* '''Sieben''' innenliegende Kreise:
** '''Ein''' zentraler Kreis.
** '''Sechs''' Kreise umgeben den zentralen Kreis gleichmäßig.
* Je zwei Kreise liegen mit ihren Mittelpunkten gleichmäßig verteilt im äußeren Bereich auf den Umfängen der sechs mittleren Kreise; zusammen sind dies '''zwölf''' Kreise.
[[Datei:VAT4105.Gilgamesch-Epos.P1151472.jpg|mini|rechts|hochkant=2|Auszug aus dem Gilgamesch-Epos auf der babylonischen gebrannten Tontafel VAT 4105 mit Keilschrift im Vorderasiatischen Museum in Berlin aus dem 18./17. Jahrhundert vor Christus.]]
Der Göttervater ''Zeus'' näherte sich der Königstochter ''Europa'' als Stier. Auch in orientalischen Mythen taucht die Vorstellung des Himmelsstieres in der Form des Urstieres auf. Schon im uralten '''Gilgamesch-Epos''' wird der Himmelsstier erwähnt. Die sechste Tafel aus dem prähistorischen Mesopotamien beschreibt, wie der Göttervater An der Stadt Uruk den Himmelsstier ausgesendet hatte, um Gilgamesch zu bestrafen. In Uruk angelangt, richtete der Himmelsstier große Zerstörungen an und tötete hunderte von Männern.
Auch in der antiken Dichtkunst wurde auf den Himmelsstier Bezug genommen. Im griechischsprachigen Werk „Hoi Tēs Hērōikēs Poiēseōs Palaioi Poiētai Pantes“ (lateinische Übersetzung: „Poetae Graeci vete res carminis heroici scriptores, qui extant, omnes“, zu Deutsch: „Alle alten griechischen Poeten der heroischen Dichtkunst, die als Verfasser herausragen“) des Jacobus Lectius von 1606, also kurz vor der Erfindung des Fernrohrs, das die Möglichkeiten der Einblicke in den Nachthimmel revolutioniert hat, wird der Himmelsstier im ersten Buch der Dionysiaka (Διονυσιακά) des Nonnos von Panopolis noch direkt mit dem obersten römischen Gott Jupiter (respektive mit dem obersten griechischen Gott Zeus) in Verbindung gebracht:<ref>Jacobus Lectius: [https://books.google.de/books?id=Jn9UAAAAcAAJ&lpg=RA1-PA312&dq=%22taurus%20caeli%22&hl=de&pg=RA1-PA312#v=onepage&q&f=false Hoi Tēs Hērōikēs Poiēseōs Palaioi Poiētai Pantes – 'Iupiter taurus in caelo relatus], 1606</ref>
<blockquote>
'''Iupiter taurus in caelo relatus'''<br/>
Iupiter maritus, surgens vero ad pedes agitatoris in caelo<br/>
sponsus stellatus fulgebat Taurus caeli.
</blockquote>
Zu Deutsch:
<blockquote>
'''Jupiter, der in den Himmel gebrachte Stier'''<br/>
Jupiter der Ehemann, sich wahrhaft erhebend zu Füßen des himmlischen Lenkers,<br/>
der gestirnte Bräutigam, leuchtete als '''Himmelsstier'''.
</blockquote>
An dieser Stelle sei angemerkt, dass sich der Asterismus Himmelsstier am Himmel direkt unter den beiden Füßen des Sternbilds Perseus befindet. Der Heroe Perseus ist in der griechischen Mythologie der Sohn des Zeus. Bei den Babyloniern hieß das Sternbild SU.GI zu Deutsch „Alter Mann“, was rein geometrisch gut zum Sternbild Perseus passen würde, es gibt jedoch auch die Deutung als der „Wagenlenker“ im angrenzenden Sternbild Fuhrmann (Auriga).<ref>Ernst Friedrich Weidner: [https://archive.org/details/alterundbedeutun00weiduoft/page/48/mode/2up <sup>kakkab</sup> GAM,<sup>kakkab</sup> SU-GI und <sup>kakkab</sup> Lu-lim], in: ''Alter und Bedeutung der babylonischen Astronomie und Astrallehre nebst Studien über Fixsternhimmel und Kalender'', Seite 49 ff., Hinrichs, Leipzig, 1914</ref> Wie auch immer, in beiden Fällen befindet sich der Himmelsstier zu Füßen des SU.GI.
Der himmlische Flussgott der griechischen Mythologie ''Acheloos'' soll sich während seines Kampfes mit Kontrahenten ''Herakles'' bei des Donners Brüllen in einen Stier gewandelt haben. In diesem Umfeld kann auch der kretische ''Minotaurus'' gesehen werden; ihm müssen in jedem Jahr '''sieben''' Jünglinge und '''sieben''' Jungfrauen dargebracht werden, die als die '''sieben winterlichen Sonnen- und Mondwesen''' gelten.
→ Siehe hierzu auch: '''[[Die_Höhlenmalerei_in_der_Magura-Höhle#Dritte_Station|Die Höhlenmalerei in der Magura-Höhle / Dritte Station]]'''.
In keltischen Sagen steigt dieser aus himmlischen Wassern empor und mischt sich unter irdische Herden. Eine mongolische Sage erwähnt den himmlischen Stier ''Bucha Nojan'' als die gute Gottheit, die jegliches Erdenglück gespendet hat.<ref>Wilhelm Schwartz: ''Der Ursprung der Mythologie dargelegt an der griechischen und deutschen Sage'', Verlag Wilhelm Hertz, Bessersche Buchhandlung, Berlin, 1860</ref>
Bei den persischen Parsen, die der Lehre des Zoroastrismus folgen, war der '''Stier''' das erste Geschöpf. Dieser wurde vom bösen Geist Ahriman erlegt, woraufhin aus dem Stierkörper der Mensch und die heilsame Pflanzenwelt hervorgingen. Der Urstier wird deswegen als Keim alles Guten angesehen, und es wird geglaubt, dass seine Seele im '''Himmel''' fortbesteht. Ahriman ist der Widersacher von Ormuzd (Ahura Mazda), der als Gottheit Licht, Tag und Leben geschaffen hat. Ahriman gilt dagegen als der Verursacher von Finsternis, Nacht und Tod, und ihm sind alle anderen bösen Geister untertan. Zu diesen schlechten Geschöpfen zählen auch die Schlangen.<ref>Georg Weber: [https://www.google.de/books/edition/Allgemeine_Weltgeschichte_Geschichte_des/Wa-jX1UshpIC Arier und Iranier - II. Die Iranier, Meder und Perser], Allgemeine Weltgeschichte / Geschichte des Morgenlandes, zweite Auflage, Verlag Wilhelm Engelmann, Leipzig, 1882</ref>
Der folgende Sachverhalt ist in diesem Kontext bemerkenswert: das Sternbild Stier (Taurus, heutige ekliptikale Längen 49 bis 90 Bogengrad) auf der einen Seite sowie die Sternbilder Schlange (Serpens) und Schlangenträger (Ophiuchus) nördlich des Skorpions (Scorpio) auf der anderen Seite befinden sich in der Himmelssphäre zwischen Ekliptik und Himmelsäquator an gegenüberliegenden Stellen, so dass sich die ekliptikalen Längen um 180 Bogengrad beziehungsweise die Rektaszensionen auf wenige Minuten genau um 12 Stunden unterschieden. Das Sternbild Schlange ist zweigeteilt in den Schlangenkopf (Serpens Caput, heutige ekliptikale Längen 216 bis 244 Bogengrad) und den Schlangenschwanz (Serpens Cauda, heutige ekliptikale Längen 260 bis 285 Bogengrad), die durch den Schlangenträger (Ophiuchus, heutige ekliptikale Längen 240 bis 283 Bogengrad) mittig unterbrochen werden.
Der Dualismus zweier Widersacher beziehungsweise zweier Gegenpole, die mit den beiden mythischen Gestalten des Stieres und der Schlange beziehungsweise mit den Attributen Licht, Finsternis oder Urflut in Verbindung gebracht werden können, taucht in erstaunlich vielen Traditionen auf.<ref>Ernst von Bunsen: ''Die Überlieferung. Ihre Entstehung und Entwicklung'', neuntes Kapitel "Früheste Astrologie", Friedrich Arnold Brockhaus, Leipzig, 1889</ref>
{| class="wikitable sortable" cellpadding="2" cellspacing="1"
|+ Zum Dualismus „Licht / Finsternis“
|-
! title="Kultur / Religion"|Kultur<br/>Religion
! title="Sprache"|Sprache
! title="Gottheit"|Gottheit
! title="Widersacher"|Widersacher
|-
| Vedisch
| Sanskrit
| Indra
| Vritra
|-
| Zoroastrismus
| Altiranisch
| Ahura Mazda
| Ahriman
|-
| Ägyptische Mythologie
| Altägyptisch
| Re
| Apophis
|-
| Judentum
| Hebräisch
| JHWH („Jahwe“)
| Satan
|-
| Griechische Mythologie
| Altgriechisch
| Zeus
| Ophion
|-
| Hinduismus
| Sanskrit
| Krishna
| Kaliya
|}
====Der Löwe====
Das Sternbild '''Löwe''' markierte vor viereinhalbtausend Jahren den Bereich der Ekliptik, der am weitesten nördlich über dem Himmelsäquator lag.
"Der große Drache, die alte Schlange" aus dem zwölften Kapitel der Offenbarung des Johannes (ergo das Sternbild Wasserschlange (Hydra)) liegt entlang des Himmelsäquators genau zwischen Himmelsskorpion und Himmelsstier,<ref>Ernst von Bunsen: ''Die Plejaden und der Thierkreis oder: Das Geheimnis der Symbole'', Kapitel ''Das Weihnachts- und Osterfest'', Abschnitte ''Symbole des Guten und des Bösen / Sternbilder in Dan und Bethel'', Seite 291 bis 313, Verlag von Mitscher und Röstell, Berlin, 1879</ref> also südlich des Weges des Enlil beziehungsweise zwischen den beiden Wegstücken des Anu.
Es ist interessant festzuhalten, dass die beiden zusammengehörigen und beschrifteten, um 200 vor Christus entstandenen seleukidischen Ritzzeichnungen AO 6448 aus der Abteilung Vorderasiatische Altertümer des Musée du Louvre in Paris und VAT 07847 aus dem Vorderasiatischen Museum der Staatlichen Museen zu Berlin die häufig gezeigten Attribute "Kornähre" (der Jungfrau), "Rabe", "Schlange" und "Löwe" aus der Region zwischen Himmelsskorpion (Herbstpunkt) und Himmelsstier (Frühlingspunkt) in einen astronomischen Zusammenhang mit den Planeten Merkur und Jupiter stellen:
<gallery caption="Zwei seleukidische Ritzzeichnungen mit astronomischen Darstellungen" widths=600 heights=450 perrow=2>
VAT7647.Jupiter.Loewe.Wasserschlange.P1151457.jpg|Der Planet '''Jupiter''' (links) beim nördlichen Sternbild '''Löwe''' (Leo, rechts) und beim südlichen Sternbild '''Wasserschlange''' (Hydra, unter dem Löwen). Das Original befindet sich mit der Bezeichnung „Zodiakal-Kalender des Sternzeichens Löwe“ und der Signatur VAT 07847 im Vorderasiatischen Museum der Staatlichen Museen zu Berlin (Abmessungen der Tontafel: Höhe 9,5 Zentimeter)
Cycle_de_la_vierge.jpg|Der Planet '''Merkur''' (in der Mitte) beim nördlichen Sternbild '''Jungfrau''' (Virgo, rechts) und beim südlichen Sternbild '''Rabe''' (Corvus, links), der nördlich der '''Wasserschlange''' (Hydra, unter dem Raben) auf deren Schwanz steht. Das Original befindet sich mit der Bezeichnung „Zodiakal-Kalender des Sternzeichens Jungfrau (die Furche)“ und der Signatur AO 6448 in der Abteilung Vorderasiatische Altertümer des Musée du Louvre in Paris (Abmessungen der Tontafel: Höhe 11,5 Zentimeter, Breite 19 Zentimeter, Dicke 3 Zentimeter)
</gallery>
<gallery caption="Zusammengesetzte seleukidische Ritzzeichnungen mit astronomischen Darstellungen" widths=1200 heights=200 perrow=1>
.Jupiter.Hydra.Leo.Corvus.Merkur.Virgo.png|Astronomische Elemente der beiden zusammengehörigen, seleukidischen Ritzzeichungen AO 6448 (Abteilung Vorderasiatische Altertümer des Musée du Louvre in Paris) und VAT 07847 (Vorderasiatisches Museum der Staatlichen Museen zu Berlin).<br/>Von links nach rechts: Planet '''Jupiter''' (sumerisch <sup>d</sup>Sag-me-gar), '''Wasserschlange''' (Hydra, sumerisch <sup>mul</sup>MUŠ), '''Löwe''' (Leo, sumerisch <sup>mul</sup>UR.GU.LA), '''Rabe''' (Corvus, sumerisch <sup>mul</sup>UGA<sup>mu en</sup>), Planet '''Merkur''' (sumerisch <sup>d</sup>GU<sub>4</sub>.UTU), '''Jungfrau''' mit Ähre (Virgo, sumerisch <sup>mul</sup>AB.SÍN). <ref>Nach Wayne Horowitz, Alestine Andre und Ingrid Kritsch: ''The Gwich’in Boy in the Moon and Babylonian Astronomy'', Arctic Anthropology, Volume 55, Number 1, Seiten 91 bis 104, 2018, ISSN 0066-6939</ref>
</gallery>
→ Siehe auch '''[[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Konjunktionen#Herbstbeginn_in_Uruk_im_Jahr_181_vor_Christus|Herbstbeginn in Uruk im Jahr 181 vor Christus]]'''.
====Der Himmelsskorpion====
[[Datei:Himmelsskorpion.png|mini|rechts|hochkant=2|Der '''Himmelsskorpion''' mit den Eigennamen seiner Sterne.]]
Der '''Himmelsskorpion''' umfasst die heutigen Ekliptiksternbilder '''Skorpion''' (Scorpius, links unten) und '''Waage''' (Libra, rechts oben). Wegen seiner Größe ist das Sternbild von den Babyloniern eben so wie der riesige Himmelsstier später geteilt worden, indem die beiden Scheren abgetrennt und dem eigenständigen Sternbild Waage zu geordnet wurden.
Die Ekliptiklinie durchquert den Bereich zwischen den beiden Scheren und den Kopf des Skorpions. Die '''Sonne''' läuft exakt entlang der Ekliptiklinie und trifft die Stirn des Skorpions fast mittig. Der '''Mond''' durchläuft auch bei größeren ekliptikalen Breiten stets die Scheren des Skorpions er kann alle ekliptiknahen Sterne dieses Sternbilds bedecken, von denen im Folgenden die hellsten Sterne aufgeführt sind
* Nördlich der Ekliptik:
** Zubenelhakrabi (γ Libri)
** Jabbah (ν Scorpii)
** Akrab (β Scorpii)
** Zubenelgenubi (α Libri)
** Jabhat al Akrab (ω Scorpii)
* Südlich der Ekliptik:
** Dschubba (δ Scorpii)
** Alniyat (σ Scorpii)
** Antares (α Scorpii)
** Fang (π Scorpii)
Der Rote Überriese '''Antares''' wird auch als das Herz des Skorpions gesehen. Viele Sternbezeichnungen, auch im Sternbild Waage, haben einen Bezug zu Skorpionen:
* Akrab / akribi / hakrabi = Skorpion
* Alniyat = Schlagadern
* Brachium = Arm (auch Cornu = Horn)
* Dschubba = Stirn
* Girtab = Skorpion
* Grafias = Klauen
* Jabbah = Scheitel der Stirn
* Lesath = Stich (Stachel)
* Shaula = erhobener Schwanz
* Zuben = Klaue
* elgenubi = südlich
* eschemali = nördlich
In der arabischen und ägyptischen Mythologie wird das Sternbild Skorpion (Scorpio) auch unter den folgenden Bezeichnungen geführt:<ref>[https://www.zedler-lexikon.de/index.html?c=blaettern&id=324651&bandnummer=36&seitenzahl=0355&supplement=0&dateiformat=1%27) Johann Heinrich Zedlers Grosses vollständiges Universal-Lexicon aller Wissenschafften und Künste "Skorpion, Scorpio, Scorpius"] 1731–1751</ref>
* '''Alacrab''', '''Alatrab''', '''Hacrab''' (arabisch für "Skorpion")
* '''Nepa''' (Gattung der Familie der Nepidae, Skorpionswanzen)
====Der Urozean====
Das Sternbild '''Wassermann''' markierte vor fünftausend Jahren den Bereich der Ekliptik, der am weitesten südlich unter dem Himmelsäquator lag. Der Frühlingspunkt befand sich noch im heutigen Sternbild Stier. Es ist im Laufe der Zeit immer weiter nach Westen gewandert, Im ersten vorchristlichen Jahrtausend wurde das Sternbild Widder (Aries) vom sehr großen Sternbild Himmelsstier abgetrennt (das übrig gebliebene Sternbild heißt Stier (Taurus)), um entlang der Ekliptiklinie zwölf in etwa gleich große Sternbilder mit einer ekliptikalen Längendifferenz von 15 Bogengrad bilden zu können. Die ekliptikale Länge 0° markiert in jeder Epoche den Frühlingspunkt auf der Ekliptik. Im ersten vorchristlichen Jahrtausend lag der Frühlingspunkt im Sternbild Widder (Aries) und wurde deswegen auch Widderpunkt genannt, auf den auch die vorislamischen arabischen Mondhäuser (Manazil al-Qamar) als den Frühlingspunkt zur Epoche J0000 Bezug nehmen. Die heutigen ekliptikalen Längen zur Epoche J2000 sind inzwischen um knapp 28 Bogengrad größer, und der Frühlingspunkt liegt entsprechend weiter westlich im Sternbild Fische (Pisces) auf der Länge des Sternes Deneb Kaitos Shemali beziehungsweise des kurz nur Shemali genannten Sternes ("nördlicher (Schwanz des Wales)", ι Ceti) im südlich angrenzenden Sternbild Walfisch (Cetus).
Der '''Urozean''' wird am Sternenhimmel durch die aneinandergrenzenden Wassersternbilder Fluss Eridanus, Walfisch (Cetus), Fische (Pisces), Wassermann (Aquarius), Südlicher Fisch (Piscis Austrinus) und Delphin (Delphinus) westlich des Himmelsstieres repräsentiert. Sadalmelik (α Aquarii) im Sternbild Wassermann (Aquarius) ist mit einer Größenklasse von nur 3<sup>m</sup> der hellste Stern im Trichter der Thuraya und befindet sich im 24. Mondhaus des Manazil al Qamar, zur Epoche J0000 bei einer ekliptikalen Länge von rund 305,5 Bogengrad, also ungefähr auf Höhe der etwas ekliptikferneren hellen Sterne Enif (ε Pegasi) im nördlichen Sternbild Pegasus und Fomalhaut (α Piscis Austrini) im südlichen Sternbild Südlicher Fisch (Piscis Austrinus). Die '''sieben Wandelgestirne''' werden bei ihrer Wanderschaft entlang der Ekliptiklinie aus dem dunklen Urozean hervorgebracht, bevor sie durch den Trichter der Thuraya und anschließend durch das helle Goldene Tor der Ekliptik und die dahinter liegenden helleren Sternbilder ziehen. Der helle sich angrenzende Abschnitt der Ekliptik wird durch die sehr hellen ekliptiknahen Sterne Aldebaran (α Tauri) im Stier (Taurus), Castor (α Geminorum) und Pollux (β Geminorum) in den Zwillingen (Gemini), Regulus (α Leonis) im Löwen (Leo), Spica (α Virginis) in der Jungfrau (Virgo) und Antares (α Scorpii) im Skorpion (Scorpio) markiert.
Besondere Bedeutung kommt hierbei dem Sonnenlauf zuteil, da die Sonne sich in der dunklen Jahreszeit (Winter) damals in diesem Urozean befand und bei der Tag-und-Nacht-Gleiche zu Frühlingsbeginn durch das Goldene Tor der Ekliptik trat.
Zu den sehr alten '''sumerischen Sternbildern''' dieser Region gehören die "erhabene Herrin" (Göttin der Geburtshilfe) '''Ninmaḫ''' im Sternbild Walfisch (Cetus), "der Großartige" (Herr Erde / Wasserhaus) '''Gott Enki''' (akkadisch '''Ea''') im Sternbild Wassermann (Aquarius), der '''Fisch''' im Sternbild Südlicher Fisch (Piscis Austrinus) und der '''Ziegenfisch''' (wörtlich: "Karpfenziege") beziehungsweise heute das Sternbild Steinbock (Capricornus). Enki und sein Begleiter, der Ziegenfisch, liegen auf der Ekliptik und sind mythologisch mit dem '''Süßwasserozean Abzu''' verbunden.
Die sumerischen Abgal waren insgesamt '''sieben Weise''', die von Enki vor der Flut aus dem Urozean erschaffen worden waren und alle ihre eigene mythologische Rolle hatten. Später verschmolzen sie mit den akkadischen '''Apkallu''' zu den babylonischen '''Schutzdämonen'''. In mehreren sumerischen Beschwörungen sind die Namen der sieben purūdu-Fisch-Weisen überliefert:<ref>Rykle Borger: ''Die Beschwörungsserie Bīt mēseri und die Himmelfahrt Henochs'', in: ''Journal of Near Eastern Studies'', Band 33, Nummer 2, April 1974, Seiten 183 bis 196</ref>
* '''U-Anna''', der die Pläne des Himmels und der Erde vollendet.
* '''U-Anne-dugga''', dem ein umfassender Verstand verliehen ist.
* '''Enmedugga''', dem ein gutes Geschick beschieden ist.
* '''Enmegalamma''', der in einem Hause geboren wurde.
* '''Enmebulugga''', der auf einem Weidegrund aufwuchs.
* '''An-Enlilda''', der Beschwörer der Stadt Eridu.
* '''Utuabzu''', der zum Himmel emporgestiegen ist.
<gallery caption="Der Urozean" widths="1200" heights="675" perrow="1">
Mondhaeuser.dunkler.Trichter.der.Thuraya.png|Westlich vom Goldenen Tor der Ekliptik zwischen dem offenen Sternhaufen der Plejaden und dem Roten Riesen Aldebaran gibt es im arabischen Manazil al-Qamar 5 zusammenhängende der 28 Mondhäuser (respektive Mondstationen) ohne helle ekliptiknahe Sterne (dunkelblauer Bereich in den Mondhäusern 2, 1, 28, 27 und 26). Die ekliptikalen Koordinaten werden durch die roten Linien beschrieben. Die ekliptikalen Längen beziehen sich auf die Epoche J0000. Alle Objekte zwischen den ekliptikalen Breiten -5 Bogengrad (südlich, unten) und +5 Bogengrad (nördlich, oben) können vom Mond bedeckt werden.
Urozean.Wassersternbilder.png|Die zusammenhängenden Wassersternbilder des Urozeans am Sternenhimmel: Fluss Eridanus, Walfisch (Cetus), Fische (Pisces), Wassermann (Aquarius), Südlicher Fisch (Piscis Austrinus), Delphin (Delphinus) sowie Ziegenfisch (Steinbock, Capricornus).
Enki.zwei.Apkallu.P1151511.jpg|Wasserbecken aus dem Hof des Tempels von '''Assur''' mit Relief an der Außenwand: der sumerische Weisheitsgott und Herrscher des Süßwasserozeans '''Enki''' mit Hörnerkrone flankiert von zwei '''Abgal'''-Priestern mit Fischmänteln (neuassyrische Periode, Herrschaft von Sennacherib, 704 bis 681 vor Christus, Vorderasiatisches Museum Berlin).
Dendera.Wassermann.Ziegenfisch.jpg|Die beiden Ekliptiksternbilder '''Wassermann''' (Aquarius) und '''Steinbock''' (Capricornus) respektive '''Ziegenfisch''' auf dem '''Zodiak von Dendera''' von ungefähr 50 vor Christus. Der Tempel von Dendera liegt 60 Kilometer nördlich von Luxor und war den ägyptischen Göttern Hatgor und Isis geweiht. Die originale Darstellung der Sternbilder der nördlichen Hemisphäre mit allen zwölf Tierkreiszeichen befand sich an der Decke des Mittelraums der nordöstlichen Anlage des Tempels und ist heute im Pariser Louvre ausgestellt.
</gallery>
===== Buch Hiob =====
Die Bibel beginnt bei der Beschreibung „Die Erschaffung der Welt“ mit den Worten:<ref>[https://www.bibleserver.com/EU/1.Mose1 Genesis 1], Einheitsübersetzung, 2016</ref>
<blockquote>
1 Im Anfang erschuf Gott Himmel und Erde.<br/>
2 Die Erde war wüst und wirr und Finsternis lag über der '''Urflut''' und Gottes Geist schwebte über dem Wasser.
</blockquote>
Der Prophet Hiob erwähnt die Urflut in seinem 28. Kapitel „Gottesfurcht als Weg zur Weisheit“:<ref>[https://www.bibleserver.com/EU/Hiob28 Hiob 28], Einheitsübersetzung, 2016</ref>
<blockquote>
1 Wohl gibt es einen Fundort für das Silber, / eine Stätte für das Gold, wo man es läutert.<br/>
2 Eisen holt man aus der Erde, / aus Gestein wird Kupfer geschmolzen.<br/>
3 Er setzt dem '''Finstern''' eine Grenze, / er forscht hinein bis in das Letzte, bis ins '''düstere, dunkle''' Gestein.<br/>
4 Er gräbt einen Stollen, wo niemand wohnt und an sie denkt; / ohne Halt für den Fuß hängen sie, / fern von Menschen schweben sie.<br/>
...<br/>
12 Die Weisheit aber, wo ist sie zu finden / und wo ist der Ort der Einsicht?<br/>
13 Kein Mensch kennt die Schicht, in der sie liegt; / sie findet sich nicht in der Lebenden Land.<br/>
14 Die '''Urflut''' sagt: Bei mir ist sie nicht. / Der '''Ozean''' sagt: Bei mir weilt sie nicht.<br/>
15 Man kann nicht Feingold für sie geben, / nicht Silber als Preis für sie wägen.<br/>
...<br/>
20 Die Weisheit aber, wo kommt sie her / und wo ist der Ort der Einsicht?<br/>
21 Verhüllt ist sie vor aller Lebenden Auge, / verborgen vor den Vögeln des Himmels.<br/>
22 Abgrund und Tod sagen: / Unser Ohr vernahm von ihr nur ein Raunen.<br/>
23 '''Gott''' ist es, der den Weg zu ihr weiß, / er ist es, der ihren Ort kennt.<br/>
24 Denn er blickt bis hin zu den Enden der Erde; / was unter dem '''All des Himmels''' ist, sieht er.<br/>
25 Als er dem Wind sein Gewicht schuf / und die Wasser nach Maß bestimmte,<br/>
26 als er dem Regen das Gesetz schuf / und einen Weg dem Donnergewölk,<br/>
27 damals hat er sie gesehen und gezählt, / sie festgestellt und erforscht.<br/>
28 Zum Menschen aber sprach er: / Sieh, die Furcht des Herrn, das ist Weisheit, / das Meiden des Bösen ist Einsicht.
</blockquote>
Zehn Kapitel später, in seinem 38. Kapitel über die „Schöpfung und ihre Ordnung“, wird das Thema noch einmal kurz aufgegriffen:<ref>[https://www.bibleserver.com/EU/Hiob38 Hiob 38], Einheitsübersetzung, 2016</ref>
<blockquote>
28 Hat der Regen einen Vater / oder wer zeugte die Tropfen des Taus?<br/>
29 Aus wessen Schoß ging das Eis hervor, / des '''Himmels''' Reif, wer hat ihn geboren?<br/>
30 Wie unter einem Stein verbergen sich die Wasser / und wird fest die Fläche der '''Flut'''.<br/>
31 Knüpfst du die Bande des '''Siebengestirns''' / oder löst du des '''Orions''' Fesseln?<br/>
32 Führst du heraus '''Sterne des Tierkreises''' zu seiner Zeit, / lenkst du die '''Löwin''' samt ihren Jungen?<br/>
33 Kennst du die '''Satzungen des Himmels''', / setzt du auf der Erde seine Herrschaft durch?
</blockquote>
===== Griechische Mythologie =====
Nach den griechischen Sagen entführte der griechische Gott Zeus (römisch: Jupiter) die phönizische Prinzessin Europa aus Tyros nach Kreta, um sie heiraten zu können. Dafür verwandelte er sich in einen schönen weißen Stier, auf dessen Rücken Europa durch das Mittelmeer auf die Insel Kreta schwamm, wo Zeus geboren worden war. Aus der Ehe gingen dann die drei Söhne Minos, Rhadamanthys und Sarpedon hervor.
Das Motiv des schwimmenden hellen Stieres erinnert stark an den leuchtenden Himmelsstier, der am Sternenhimmel im Urozean der Wassersternbilder schwimmt. Die funkelnden Plejaden markieren die Stelle auf seinem Rücken, wo sich die Prinzessin Europa bei ihrer Entführung befand.
<gallery caption="Entführung der phönizischen Prinzessin Europa durch den schwimmenden griechischen Gott Zeus in Stiergestalt" perrow=2 widths=600 heights=400>
The_Abduction_of_Europa_mosaic_2008_crop.jpg|Antikes Mosaik in der Westlichen Ausgrabungsstätte auf der griechischen Insel Kos.
Mosaic_floor,_AM_Naxos,_190547.jpg|Spätantikes Bodenmosaik im Archäologisches Museum von Naxos aus einem Gebäude der griechischen Insel Naxos.
</gallery>
===== Der Lichtbringer und die Wassersternzeichen =====
In vielen kosmologischen Weltentstehungsmythen spielen eine Urflut sowie ein Lichtbringer zentrale Rollen. Der Lichtbringer ist leicht mit der Sonne in Verbindung zu bringen, die die Ursache für das natürliche Licht auf der Erdoberfläche ist. Aber auch die Urflut spiegelt sich in der Sagenwelt am Sternenhimmel wider. Die Haida, seit mehr als 16000 Jahren gehören sie in British Columbia im heutigen Südwesten Kanadas zu den First Nations, verehren zum Beispiel einen Raben (englisch: raven) als Lichtbringer:<ref>Carolyn Kenny: [https://voices.no/index.php/voices/article/view/1630/1390 Raven and the Transmission of Knowledge], in: ''Voices – A World Forum for Music Therapy'', Band 4, Nummer 2, 2004,ISSN 1504-1611</ref>
<blockquote>
Vor dem Raben war die Welt nichts weiter als eine '''gigantische Flut'''. Der Rabe war der Schöpfer der Dinge sowie der Verwandler, Magier und Heiler.<br/>
…<br/>
Er stahl ['''Sonne''', den '''Mond''', die '''Sterne''' und frisches Wasser] und flog durch den Schornstein aus dem Langhaus.<br/>
Sobald der Rabe draußen war, hängte er die '''Sonne''' in den Himmel.<br/>
Sie machte so viel Licht, dass er weit hinaus zu einer Insel mitten im Ozean fliegen konnte.<br/>
Als die '''Sonne''' unterging, befestigte er den '''Mond''' am Himmel und hängte die '''Sterne''' an verschiedenen Stellen auf.<br/>
…<br/>
Er flog zurück über das Land. Als er den richtigen Ort erreicht hatte, ließ er das ganze Wasser, das er gestohlen hatte, fallen.<br/>
Es fiel auf den Boden und wurde dort zur Quelle aller Süßwasserströme und Seen der Welt.
</blockquote>
In einer weiteren Legende der Haida tötet der Rabe den Wal. Der Rabe und der Wal sind uns auch heute als gleichnamige Sternbilder bekannt (Corvus und Cetus).
<gallery caption="Der Rabe der Haida und am Sternenhimmel" widths="900" heights="600" perrow=1>
Raven.BringerOfLight.P1044250.jpg|Beaver Crest Totempfahl aus dem Jahr 1987 von Norman Tait im Stanley-Park in Vancouver, der den in der Mythologie der Haida verehrten Raben darstellt.
TheRaven.BringerOfLight.P1117152.jpg|Der Rabe als Lichtbringer der Ureinwohner der nordamerikanischen Westküste interpretiert als Asterismus östlich der dunklen Wassersternzeichen. Links der Stern Tabit aus dem Sternbild Orion, in der Mitte das V mit dem offenen Sternhaufen der Hyaden und dem Roten Riesen Aldebaran. Rechts der offene Sternhaufen der Plejaden (Siebengestirn).
Raven.P1022937.png|Interpretation der Konstellation zwischen dem Stern Tabit (links) und dem Sternhaufen der Plejaden (rechts) als Rabe, wobei der Kopf des Raben dem Sternhaufen der Hyaden entspricht. Die beiden Augen sind die Sterne Aldebaran (links) und Ain (rechts) und die Schnabelspritze wird durch den Stern Prima Hyadum (γ Tauri) gebildet. Die Ekliptiklinie ist rot gepunktet dargestellt, und die Wandelgestirne wandern aus dem großen dunklen Trichter rechts unterhalb des Raben auf dieser Linie nach links oben.
</gallery>
====Babylonische Himmelswege====
In Mesopotamien waren die astronomischen Koordinatensysteme des irdischen Horizonts, des Himmelsäquators und der Ekliptik bereits bekannt, und schon die Sumerer hatten die Bezüge zwischen diesen Himmelssystemen gut durchdacht. Der heutige Skorpion und die Waage (ursprünglich die Scheren des Skorpions) haben zunächst den '''Himmelsskorpion''' gebildet, und der heutige (abgeschnittene) Stier und der Widder (ursprünglich das Hinterteil des Stieres) haben zunächst noch den vollständigen '''Himmelsstier''' gebildet. Diese beiden Riesensternbilder bildeten als Antagonisten eine Himmelswaage zwischen Frühlings- und Herbstpunkt.
Der Planet Jupiter zieht entlang der Ekliptik Jahr für Jahr in dieser Darstellung um knapp 30 Bogengrad nach links, um nach knapp zwölf Jahren wieder an seinem Ursprungsort bei der entsprechenden ekliptikalen Länge anzugelangen. Hierbei steht er also immer ein Jahr lang in einem der zwölf Ekliptiksternbilder des Zodiaks.
Die vier senkrecht aufeinander stehenden Hauptrichtungen entsprachen 2600 vor Christus den vier Hauptpunkten der Sonne zum Frühlingsäquinoktium (ekliptikale Länge = 0°), zur Sommersonnenwende (ekliptikale Länge = 90°), zum Herbstäquinoktium (ekliptikale Länge = 180°) und zur Wintersonnenwende (ekliptikale Länge = 270°), sowie gleichzeitig den vier persischen '''Königssternen''' Aldebaran (α Tauri), Regulus (α Leonis), Antares (α Scorpii) und Fomalhaut (α Piscis Austrini) beziehungsweise den späteren vier '''Evangelisten-Sternbildern''' Stier (Taurus), Löwe (Leo), fliegender Adler (Aquila, links oberhalb vom Skorpion wegfliegend) und Wassermann (Aquarius). Diese vier Lebewesen tauchen auch in der Dichtung des Umaiya ibn Abī s-Salt als die Beweger der Sonne beziehungsweise als die Träger des Throns (ḥamlat al-arsh) auf.
→ Siehe auch [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Die_Plejaden#Königssterne|'''Königssterne''']].
→ Siehe auch [[Quadriviale_Kuriositäten/_Zahlen#Bedeutung_der_Vier_in_Religionen|'''Bedeutung der Vier in Religionen''']].
In diesem Kontext sei auf die Lage der Ekliptik im äquatorialen Koordinatensystem der Sumerer hingewiesen. Die folgende Sternenkarte zeigt eine rechtwinklige Mercator-Projektion des Sternenhimmels mit horizontal ausgerichtetem, geradlinigem Himmelsäquator (braun) zur Epoche J-2600 in der Bildmitte, der definitionsgemäß bei der Deklination (bei der äquatorialen Höhe) Null liegt. Norden ist oben bei den positiven Deklinationen, Süden ist unten bei den negativen Deklinationen. Die Ekliptiklinie (blau) pendelt sinusförmig um den Himmelsäquator.
[[Datei:Ekliptik-2600BC.aequatorial.Mercator.png|links|mini|hochkant=4|Die babylonischen Wege des Himmels mit äquatorialen Himmelskoordinaten in Mercator-Projektion zur Epoche J-2600.<br/>Der Himmelsweg des '''Enlil/Ellii''' ("Herr Wind") liegt oben zwischen den beiden orangefarbenen Linien in den Ekliptiksternbildern Zwillinge, Krebs, Löwe und Jungfrau.<br/>Der Himmelsweg des '''Ea/Enki''' ("Wasserhaus"/"Herr Erde") liegt unten zwischen den beiden orangefarbenen Linien in den Ekliptiksternbildern Schütze, Steinbock (Ziegenfisch), Wassermann, Fische - letztere drei sind Teil des dunklen himmlischen '''Urozeans''',<br/>Die beiden Teilstücke des Himmelswegs des '''An/Anu''' ("Himmel") in der Mitte werden von den beiden archaischen großen Sternbildern Himmelsskorpion (heute Skorpion und Waage) und Himmelsstier (heute Stier und Widder) beherrscht.]]
<div style="clear:both"></div>
Die Neigung der Ekliptik zum Himmelsäquator betrug 2600 vor Christus fast 24 Bogengrad. Die orangefarbenen, horizontalen Orientierungslinien bei minimaler und maximaler äquatorialer Höhe mit einem Betrag von 24 Bogengrad sowie bei den beiden halben minimalen und maximalen äquatorialen Höhen mit einem Betrag von 12 Bogengrad schneiden die Ekliptik bei den Hauptpunkten einer Sinuskurve, die durch die Phasenwinkel beziehungsweise ihre ekliptikale Längen gekennzeichnet sind:
{| class="wikitable"
|+ Hauptpunkte der sinusförmigen Ekliptiklinie im äquatorialen System zur Epoche J-2600
! Phasenwinkel<br/>der Sinuskurve,<br/>ekliptikale Länge !! Ekliptikale Höhe !! Markierungsstern !! Sternbild
|-
| 0° || 0° || Aldebaran / Plejaden (Goldenes Tor der Ekliptik) || Stier (Taurus)
|-
| 30° || +12° || Alhena || Zwillinge (Gemini)
|-
| 90° || +24° || Regulus || Löwe (Leo)
|-
| 150° || +12° || Spica || Jungfrau (Virgo)
|-
| 180° || 0° || Antares || Skorpion (Scorpio)
|-
| 210° || -12° || Kaus Australis || Schütze (Sagittarius)
|-
| 270° || -24° || Fomalhaut || Südlicher Fisch (Pisces Australis) / Wassermann (Aquarius)
|-
| 330° || -12° || Hamal || Widder (Aries)
|}
Die Abschnitte entlang der Ekliptik werden auch die Himmelswege der Babylonier genannt und sind drei babylonischen Gottheiten zugeordnet, denen jeweils vier Monate eines jeden Sonnenjahres gehören. Der Weg des Anu liegt zwischen den beiden Wegen des Enlil und des Ea und von denen zweimal unterbrochen. Die Wege des Enlil und des Ea liegen jedoch bei größeren ekliptikalen Breiten und sind zusammenhängend.<ref>Matthieu Ossendrijver: ''Astronomie und Astrologie in Babylonien'', in: ''Babylon. Wahrheit. Katalog zur Ausstellung "Babylon. Mythos und Wahrheit"'', Pergamonmuseum Berlin, Seiten 373 bis 386, Tübingen, 2008</ref>
{| class="wikitable"
|+ Die babylonischen Wege des Himmels
! Sumerisch !! Akkadisch !! Ekliptikale Längen !! Ekliptikale Breiten !! Sternbilder
|-
| An || Anu || 330° bis 30° || -12° bis +12° || Widder / Stier (Himmelsstier)
|-
| Enlil || Ellii || 30° bis 150° || +12° bis +24° || Zwillinge / Krebs / Löwe / Jungfrau
|-
| An || Anu || 150° bis 210° || -12° bis +12° || Waage / Skorpion (Himmelsskorpion)
|-
| Enki || Ea || 210° bis 330° || -24° bis -12° || Schütze / Steinbock (Ziegenfisch) / Wassermann / Fische
|}
Die Himmelswege bekamen schon nach dem babylonischen Schöpfungsmythos Enuma Elisch drei Mal zwölf Markierungssterne, insgesamt also 36 Sterne. Davon lagen immer zwölf in einem der drei Wegstücke der drei babylonischen Gottheiten. Erst später wurde dann irgendwann der Zodiak mit seinen zwölf Ekliptiksternbildern gebildet, die demzufolge jeweils drei dieser Markierungssterne enthalten. Um welche konkreten Sterne es sich handelt ist nicht überliefert, viele sind jedoch sehr naheliegend - sowohl was ihren Abstand zur Ekliptiklinie als auch was ihre hinreichend große scheinbare Helligkeit betrifft.
Die beiden Wege des Anu werden jeweils vom Himmelsskorpion und vom Himmelsstier beherrscht:
[[Datei:Ekliptik-2600BC.aequatorial.Mercator.Himmelsskorpion.Himmelsstier.png|links|mini|hochkant=4|'''Himmelsskorpion''' im Herbstpunkt (ekliptikale Länge = 180°) und '''Himmelsstier''' im Frühlingspunkt (ekliptikale Länge = 0°), äquatoriales Koordinatensystem in rechtwinkliger Mercator-Projektion für die Epoche J-2600.]]
<div style="clear:both"></div>
====Mithraskult====
[[Datei:Himmelsskorpion.Himmelsstier.Mesopotamien-5000.png|rechts|mini|hochkant=2|'''Himmelsskorpion''' (links beim '''Herbstpunkt''' "O") und '''Himmelsstier''' (rechts beim '''Frühlingspunkt''' "W") am südlichen südmesopotamischen Nachthimmel 3000 vor Christus zur '''Tag-und-Nacht-Gleiche im Frühling''' beim '''Sonnenuntergang'''. Entlang der '''Ekliptik''' (roter gepunkteter Bogen) sind die folgenden Objekte zu sehen:<br/>'''Antares''' (α Scorpii) im Sternbild Skorpion (Scorpio) im Osten (die großen Scheren des Skorpions werden heute als das Sternbild Waage (Libra) geführt), '''Spica''' (α Virginis) im Sternbild Jungfrau (Virgo), '''Regulus''' (α Leonis) im Sternbild Löwe (Leo) in Zenitnähe, '''Pollux''' (α Gemini) im Sternbild Zwillinge (Gemini), '''Aldebaran''' (α Tauri) im Sternbild Stier (Taurus) im Westen (die Hinterbeine des Himmelsstieres werden heute als das Sternbild Widder (Aries) geführt).<br/>In Horizontnähe (grüne horizontale Linie) befinden sich sehr helle Sterne: '''Antares''' im Osten, '''Hadar''' (β Centauri) im Sternbild Zentaur (Centaurus) im Südosten, '''Canopus''' (α Carinae) im Sternbild Kiel des Schiffes (Carina) im Süden (zur Bedeutung von Canopus für die sumerische Stadt Eridu siehe auch [[Quadriviale_Kuriositäten/_Die_Stele_vom_Rocher_des_Doms#Canopus|Canopus]]), '''Rigel''' (β Orionis) im Sternbild Orion im Südwesten und '''Aldebaran''' im Westen.<br/>Zwischen dem Ekliptikbogen und dem Horizont befinden sich ferner: das Sternbild '''Rabe''' (Corvus), das Sternbild '''Wasserschlange''' (Hydra), der hellste Stern des Nachthimmels '''Sirius''' (α Canis Majoris), '''Prokyon''' (α Canis Minoris) und '''Beteigeuze''' (α Orionis).]]
'''Mithras''' ist eine römische Gottheit und stellt die mythologische Personifizierung der Sonne dar. In dieser Eigenschaft wurde er im Mithraismus verehrt. Ursprünglich geht sein Name auf die indoiranische Gottheit des Lichts '''Mithra''' aus der iranischen Mythologie und eventuell sogar auf die vedische Gottheit des himmlischen Lichtes am Tag '''Mitra''' zurück, die bereits im 14. vorchristlichen Jahrhundert belegt sind und eine indirekte Beziehung zum römischen Mithras haben. In Kleinasien der Name Mithra später zu Mithras hellenisiert.
Im Folgenden wird auf einige sehr auffällige Korrelationen zwischen den Mithras-Darstellungen und dem Sternenhimmel eingegangen. Der '''Himmelsskorpion''' umfasste ursprünglich auch das Sternbild '''Waage''' (Libra, die großen Scheren des Skorpions), und der '''Himmelsstier''' umfasste vor seiner astronomischen Zerteilung bei der '''Tauroktonie''' ("Stiertötung") auch das Sternbild '''Widder''' (Aries, Hinterteil des Stieres).
Mithras wird in seinem Kult häufig mit den folgenden Attributen dargestellt:
* Über Mithras stehen die Symbole für '''Sonne''' und '''Mond'''.
* Mithras Umhang zeigt auf der Innenseite '''Sterne'''.
* Er kniet auf dem Rücken des '''Stieres''' und sticht sein Messer in dessen Seite.
* Ein '''Hund''' und eine '''Schlange''' lecken am Blut aus der Wunde.
* Der Schwanz des Stieres ist als '''Ähre''' dargestellt.
* Auf dem Schwanz oder darüber ist ein '''Rabe''' dargestellt.
* Ein '''Skorpion''' greift das Geschlechtsteil des Stieres an.
* Manchmal werden auch ein '''Löwe''', ein '''Becher''' oder ein '''Hahn''' gezeigt.
* Mithras befindet sich unter einem '''Bogen'''.
* Die beiden '''Fackelträger Cautes und Cautopates''' rahmen die Szene ein. Manchmal tragen sie auch noch schlüsselartige Gegenstände in der jeweils freien Hand.
Es ist sehr auffällig, dass sämtliche dieser Attribute unmittelbar mit den ekliptiknahen Sternen des abendlichen Sternenhimmels zur Tag-und-Nacht-Gleiche im Frühling vor zirka 5000 Jahren in Verbindung gebracht werden können:
* '''Sonne''' und '''Neumond''' stehen im '''Frühlingspunkt''' bei '''Aldebaran''', beziehungsweise der '''Vollmond''' steht im Herbstpunkt bei '''Antares'''.
* Der '''Himmelsstier''' umfasst vor seiner Teilung die Sternbilder '''Stier''' (Taurus) und '''Widder''' (Aries). Auch Gilgamesch soll mit Hilfe seines Freundes Enkidu) (ähnlich wie Mithras) den Himmelsstier Gugalanna (sumerisch "GU<sub>4</sub>.GAL.AN.NA") getötet und geteilt haben.<ref>[https://etcsl.orinst.ox.ac.uk/section1/tr1812.htm Gilgamesh and the Bull of Heaven: translation – A version of unknown provenance, supplemented from Nippur mss.]. The Electronic Text Corpus of Sumerian Literature</ref>
* Der '''Hund''' symbolisiert die beiden hellen Sterne '''Sirius''' im Sternbild '''Großer Hund''' (Canis Major) und '''Prokyon''' im Sternbild '''Kleiner Hund''' (Canis Minor).
* Die '''Schlange''' entspricht dem Sternbild '''Wasserschlange''' (Hydra).
* Die '''Ähre''' entspricht dem hellen Stern '''Spica''' (lateinisch "Kornähre") im Sternbild '''Jungfrau''' (Virgo, sumerisch "Furche" oder "Göttin der Kornähre"). Alternativ könnte die Ähre auch das Siebengestirn (Plejaden) symbolisieren.<ref>Vergleiche auch die sieben Ähren des ägyptischen Pharaos in der [https://www.bibleserver.com/EU/1.Mose41 Genesis, Kapitel 41], Einheitsübersetzung 2016</ref>
* Der '''Rabe''' entspricht dem gleichnamigen Sternbild (Corvus).
* Der '''Skorpion''' entspricht dem gleichnamigen Sternbild '''Skorpion''' (Scorpio).
* Der fast im Zenit stehende Königsstern '''Regulus''' (sumerisch "LU.GAL" = "großer Mann" respektive "König") ist der hellste Stern des Sternbilds '''Löwe''' (Leo).
* Der '''Becher''' entspricht dem Sternbild '''Becher''' (Crater) nördlich der Wasserschlange (Hydra) und direkt westlich neben dem Raben (Corvus).
* Der '''Hahn''' (sumerisch "DAR.LUGAL" / akkadisch "Tarlugallu" / lateinisch "gallus") ist ein altes mesopotamisches Sternbild, das in der Nähe des Großen Hundes (Canis Major) vermutet wird.
* Der '''Bogen''' kann sich auf den Ekliptikbogen oder auf den Torbogen des Goldenen Tors der Ekliptik beziehen.
* Die beiden '''Fackelträger Cautes und Cautopates''' könnten als Träger der "gestirnten Zeichen" für die beiden Pfosten des '''Goldenen Tores der Ekliptik''' stehen (siehe unten im Abschnitt '''[[Die_Himmelstafel_von_Tal-Qadi/_Astronomische_Bezugssysteme#Das_Goldene_Tor_der_Ekliptik|Das Goldene Tor der Ekliptik]]''' bei "Vergiliae" (Plejaden) und "Suculae" (Hyaden)). In ihrer Funktion als Pförtner hätten sie die '''Schlüssel'''gewalt über das Tor. Ferner ist bemerkenswert, dass das die beiden Hauptsterne des alten Ekliptiksternbilds Zwillinge (Gemini), das direkt östlich vom Himmelsstier liegt, das Zwillingspaar der griechischen Mythologie (die Dioskuren) Kastor und Polydeukes (latinisiert: Castor und Pollux) repräsentieren.
<gallery widths="360" heights="360" mode="packed" caption="Mithras und die Tötung des Stieres">
Weiherelief.Mithras.P1068164.jpg|Weiherelief für Mithras, zweites Jahrhundert nach Christus, Antikensammlung des Neuen Museums n Berlin.
Datei:Mithras relief at the Römisch-Germanisches Museum Cologne.jpg|Kultrelief des Gottes Mithras aus dem zweiten oder dritten Jahrhundert im Römisch-Germanischen Museum in Köln.
Datei:(Venice) Mithras slaying the bull in the Museo archeologico nazionale..jpg|Mithras-Skulptur aus der zweiten Hälfte des zweiten Jahrhunderts in Rom ausgestellt im Archäologischen Nationalmuseum Venedig.
Datei:Tauroctony_Pio-Clementino_Inv870.jpg|Römisches Marmorrelief mit der Tauroktonie durch Mithras und der Inschrift: "Soli invicto deo / Atimetus Aug(ustorum) n(ostrorum) ser(vus) act(uarius) praediorum Romanianorum" (zu Deutsch: "Atimetus, Diener des einzigen unbesiegten Gottes unseres Augustus, Verwalter der römischen Landgüter") in den Musei di Antichità Classiche (Museum Pio-Clementino, Laocoön Halle, inv. 870) der Vatikanischen Museen.
Datei:0_Relief_représentant_Mithra_-_Louvre-Lens_(2).JPG|Marmorskulptur des Mithras aus dem zweiten Jahrhundert mit zwei Fackelträgern aus dem Capitol in Rom im Pariser Louvre (MR 818).
Mithras_tauroctony_Louvre_Ma3441.jpg|Mithraisches Relief aus weißem Marmor aus Fiano Romano bei Rom im zweiten bis dritten Jahrhundert, Louvre, Abteilung griechischer, etruskischer und römischer Altertümer, Denon-Flügel, Erdgeschoss (Ma 3441).
O.1054_color.jpg|'''Gilgamesch''', einer der frühen Könige vom sumerischen Uruk, tötet den Himmelsstier, mesopotamische Darstellung in Terrakotta, 2250–1900 vor Christus.
</gallery>
[[File:Sankt.Gallen.Stiftsbibliothek.Evangelium.Longum.Vorderseite.P1047872.jpg|mini|rechts|hochkant=2|Vorderseite mit Elfenbeinschnitzerei des Evangelistars Evangelium Longum.in der Stiftsbibliothek von Sankt Gallen (Codex Sangallensis 53)]]
Die Vorderseite des Evangelistars ''Evangelium Longum'' (Codex Sangallensis 53 der Stiftsbibliothek in Sankt Gallen, Schweiz) zeigt oben in der größten europäischen Elfenbeinschnitzerei zwei Fakelträger, die mit Sonne und Mond identifiziert werden, sowie weiter unten neben dem Thron, auf dem Jesus Christus sitzt, zwei Leuchttürme. Die Inschrift lautet:
<blockquote>
HIC RESIDET XPC VIRTVTVM STEMMATE SEPTVS
</blockquote>
<blockquote>
Hier thront Christus umgeben vom Kranz der Tugenden
</blockquote>
Diese bildliche Darstellung verweist somit auch auf das Sternbild Stier mit dem [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Bedeutung_in_anderen_Disziplinen#Der_Himmelsthron|Himmelsthron]] dem Goldenen Tor der Ekliptik (siehe folgender Abschnitt). Ferner sind auch die vier Evangelisten mit ihren Evangelistensymbolen zu sehen (siehe hierzu auch [[Quadriviale_Kuriositäten/_Zahlen#Bedeutung_der_Vier_in_Religionen|Bedeutung der Vier in Religionen]] sowie [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Astronomische_Bezugssysteme#Königssterne|Persiche Königssterne]]).
===Das Goldene Tor der Ekliptik===
Das '''Goldene Tor der Ekliptik''' ist der Bereich zwischen den beiden offenen Sternhaufen der Hyaden und der Plejaden im Sternbild Stier (Taurus), die die beiden Pfosten des Tores bilden. Die Ekliptik kreuzt die Verbindungslinie dieser beiden Sternhaufen in etwa mittig, und alle Planeten, der Mond und die Sonne laufen auf ihrer scheinbaren Bahn deswegen regelmäßig durch das Goldene Tor der Ekliptik hindurch.
Der Begriff "Goldenes Tor" taucht in deutschsprachigen Veröffentlichungen in diesem Kontext anscheinend erst Anfang der 1950er Jahren auf.<ref>Siehe zum Beispiel Oswald Thomas: ''Himmel und Weltall'', Seite 38, 4. vollständig neu bearbeitete und erweiterte Auflage, Deutscher Buchklub, Bochum, 1951</ref>
[[Datei:Mars.im.Goldenen.Tor.der.Ekliptik.P1091616.jpg|zentriert|hochkant=4|mini|Der rote Planet Mars (Mitte) im Goldenen Tor der Ekliptik zwischen dem offenen Sternhaufen der Hyaden (links) mit dem Roten Riesen Aldebaran (α Tauri) und dem offenen Sternhaufen der Plejaden (rechts).]]
Eine mannshohe, heute aufrecht stehende Stele im kleinen neolithischen Tempel von '''Mnajdra''' an der Südküste von Malta zeigt mehrere gebohrte Näpfchen, von denen eine Anhäufung an der linken Seite mit den Plejaden gleichgesetzt wurde.<ref>Frank Ventura: ''L'astronomija f'Malta'', Pubblikazzjonijiet Indipendenza, 2002, ISBN 9789993241287</ref> Betrachtet man die Stele, die vermutlich liegend gebohrt wurde, auf dem Kopf stehend, ergibt sich eine sehr ähnliche Darstellung wie in der Mitte der '''Himmelstafel von Tal-Qadi''', wo das Goldene Tor der Ekliptik abgebildet ist. Beide Darstellungen stammen aus der Tarxien-Phase der Insel und sind deswegen mindestens 4500 Jahre alt. Interessanterweise liegt der mysteriöse Bogen auf der '''Himmelsscheibe von Nebra''' an der gleichen Position wie der Bogen im mittleren Feld der Himmelstafel von Tal-Qadi, wenn die Asterismen links und rechts der Ekliptiklinie jeweils als die Hyaden mit Aldebaran und die Plejaden interpretiert werden.
<gallery caption="Sehr alte, mutmaßliche Darstellungen des Goldenen Tors der Ekliptik" widths=480 heights=480 perrow=3>
Mnajdra.Stele.Umzeichnung.png|Umzeichnung einer mindestens 4500 Jahre alten Stele im kleinen neolithischen Tempel von '''Mnajdra''' auf Malta mit zahlreichen Näpfchen nach einer älteren Photographie. Die Näpfchen stellen den Bereich des heutigen Sternbilds '''Stier''' (Taurus, gelbe Linien) dar, so wie es beim Untergang am westlichen Himmel beobachtet werden kann. Der Megalith steht heute gegenüber der Zeichnung auf den Kopf gedreht aufrecht mit dem Kreuz nach oben, welches der Darstellung erst viel später hinzugefügt worden ist. Der Mond und die fünf freisichtigen Planeten sind im '''Goldenen Tor der Ekliptik''' dargestellt, wo sie entlang der Ekliptiklinie regelmäßig zwischen den '''Hyaden''' (lγ, δ, ε, θ und π Tauri) mit dem Roten Riesen '''Aldebaran''' (α Tauri) (links) und den '''Plejaden''' (rechts) hindurchziehen oder diese teilweise sogar bedecken können. Hiermit würde es sich um eine der ältesten Darstellungen dieser Himmelsregion handeln. Am linken Rand ist ein großes Näpfchen zu sehen, das Beteigeuze im Sternbild Orion repräsentieren könnte. Die vier Näpfchen oben rechts können mit den sehr markanten Nachbarsternen Capella (α Aurigae) und Hassaleh (ι Aurigae) im Sternbild Fuhrmann (Auriga) sowie Mirfak (α Persei) und Algol (β Persei) im Sternbild Perseus identifiziert werden.
Himmelstafel.Tal-Qadi.Goldenes.Tor.png|Bildausschnitt auf der mindestens 4500 Jahre alten '''Himmelstafel von Tal-Qadi''' mit dem Goldenen Tor der Ekliptik. In der Mitte beim halbkreisförmigen Symbol die Lage der Ekliptiklinie, links davon der Kopf des Stieres mit den Hyaden und dem Roten Riesen Aldebaran, rechts die Plejaden und ganz links der Stern Beteigeuze.
Stele.Rocher.des.Doms.1.png|Mögliche Interpretation der Darstellung auf der → [[Quadriviale Kuriositäten/ Die Stele vom Rocher des Doms|'''Kalksteinstele vom Rocher des Domes''']] in der Umzeichnung mit der durch die Sonne (unten rechts) und zwischen zwei Pfeilern durch das Goldene Tor der Ekliptik im Sternbild Stier (Taurus) laufenden Ekliptiklinie (rot gestrichelt).
Himmelsscheibe.Nebra.GoldenesTor.P1034154.jpg|Lage des Goldenen Tors der Ekliptik auf dem südlichen Meridian vor 4000 Jahren auf der Himmelsscheibe von Nebra. Die Ekliptikline (rot gepunktet) ist von Osten (links) nach Westen (rechts) dargestellt. Oberhalb der Ekliptik befinden sich die Plejaden (gelber Kreis) und unterhalb der Ekliptik im V-förmigen Kopf des Stieres die Hyaden mit Aldebaran (links unten).
GoldenesTor.Mond.4.Dezember.2025.23.37h.png|Der Vollmond am 4. Dezember 2025 kurz vor Mitternacht (MEZ) sowie einen Tag nach der Bedeckung der Plejaden hinter dem Goldenen Tor (blaue Linie) nördlich der Ekliptik (orangefarbene Linie) während der Kulmination auf dem südlichen Meridian (grüne Linie).
</gallery>
Vor 4300 Jahren befand sich der Frühlingspunkt noch im Sternbild Stier (Taurus), vor 2150 Jahren im Sternbild Widder (Aries, aus dieser Epoche stammt das Synonym „Widderpunkt“ für den Frühlingspunkt) und heute im Sternbild Fische (Pisces). 2500 vor Christus lag der Frühlingspunkt genau zwischen den Hyaden und den Plejaden im '''Goldenen Tor der Ekliptik'''! Vor rund 4500 Jahren befand sich ein zum Herbstbeginn auftretender Vollmond also gleichzeitig im Frühlingspunkt und im Goldenen Tor der Ekliptik und ging abends um 18 Uhr Ortszeit genau im Westen unter.
[[Datei:Taurus.Aequinoktialpunkt.Plejaden.png|mini|hochkant=2|zentriert|Die Lage des Frühlingspunktes vor 4500 Jahren im '''Goldenen Tor der Ekliptik'''.]]
Auf der leicht beschädigten babylonischen Tontafel VAT 07851 im Vorderasiatischen Museum in Berlin aus der Stadt Uruk in seleukidischer Zeit (zirka zweites Jahrhundert vor Christus) befindet sich eine Ritzzeichnung mit dem Mond im Sternbild Stier (Taurus). Von links nach rechts sind die eindeutig mit Keilschrift gekennzeichneten Plejaden (in Keilschrift [[Datei:Assyrian_cuneiform_U1202F_MesZL_247.svg|40px]] [[Datei:Assyrian_cuneiform_U1202F_MesZL_247.svg|40px]] = MUL MUL = Plejaden (wörtlich "Sterne")), der Mond mit einem Kämpfer und einem Löwen, die innerhalb der Mondscheibe dargestellt sind, sowie dem Himmelsstier zu sehen.<ref>Wayne Horowitz, Alestine Andre, and Ingrid Kritsch: ''The Gwich’in Boy in the Moon and Babylonian Astronomy'', Arctic Anthropology, Vol. 55, No. 1, pp. 91–104, Board of Regents of the University of Wisconsin System, 2018, ISSN 0066-6939</ref> Eine möglicherweise vorhanden gewesene Beschriftung des Stieres ist wegen der Beschädigung der Tontafel im hinteren Teil der Stierdarstellung nicht erhalten, die Zuordnung ist dennoch eindeutig. Eine beschriftete und vollständige Darstellung des Himmelsstiers taucht in einer ähnlichen Zeichnung auf einer rituellen Tontafel im Königlichen Museum für Kunstgeschichte in Brüssel (TCL 6, 47; MRAH O.00175) aus dieser Zeit auf.<ref>Alasdair Livingstone: ''Mystical and Mythological Explanatory Works of Assyrian and Babylonian Scholars'', Eisenbrauns, 2007, ISBN 9781575061337</ref> Diese Darstellung ist am Himmel zwar nur in umgekehrter Reihenfolge von rechts nach links zu beobachten, stellt aber zweifelsohne den durch das '''Goldene Tor der Ekliptik''' zwischen dem Kopf des Stieres und den Plejaden hindurchziehenden Mond dar:
[[Datei:Tontafel.VAT 07851.P1068094.jpg|zentriert|hochkant=4|mini|Seleukidische Tontafel VAT 07851 aus Uruk / Warka im Neuen Museum in Berlin (ungefähr zweites Jahrhundert vor Christus). Der Mond mit bewaffnetem Mann einen Löwen bekämpfend (Mitte) zwischen dem offenen Sternhaufen der Plejaden (links) und dem Himmelsstier (rechts).]]
[[Datei:VAT.7851.Umzeichnung.png|zentriert|hochkant=4|mini|Umzeichnung der seleukidischen Ritzzeichnung auf der Tontafel VAT 07851 aus dem Vorderasiatischen Museum in Berlin.]]
Bemerkenswert ist die Tatsache, dass der '''Mond''' auf seinem Weg zum absteigenden Knoten der Mondbahn nach einer '''Bedeckung der Plejaden''' sich der Ekliptiklinie von Norden her nähert. Nach ungefähr sieben Tagen - also ein Mondviertel später - erreicht er auf seinem Weg entlang der Ekliptiklinie diesen Knoten beim ekliptiknahen und sehr hellen Königsstern Regulus (α Leonis), den Brust- beziehungsweise Herzstern im Sternbild '''Löwe''' (Leo), den er dann ebenfalls bedecken kann.
→ Siehe auch [[Die_Himmelstafel_von_Tal-Qadi/_Mondzyklen#Der_drakonitische_Zyklus|Kapitel '''Mondzyklen''', Abschnitt '''Der drakonitische Zyklus''']].
[[Datei:Hyaden.P10916XX.png|mini|rechts|hochkant=2|Der offene Sternhaufen der '''Hyaden''' ('''Suculae''') mit dem hellen Roten Riesen '''Aldebaran''' (α Tauri).]]
Die auffälligen und mit bloßem Auge leicht erkennbaren Sternhaufen der '''[[Die Himmelstafel von Tal-Qadi/ Die_Plejaden|Plejaden]]''' (lateinisch: "'''Vergiliae'''") und der '''Hyaden''' (lateinisch: "'''Suculae'''") bilden im Bezug zum Fixsternhimmel Asterismen. Zusammen mit dem Stern Aldebaran (er selber gehört nicht zu den Hyaden) stellen diese drei Objekte auf relativ engem Raum, in einem Winkelbereich von weniger als zehn Bogengrad, die drei hellsten Objekte in der Nähe der Ekliptik dar.<ref>Carl Friedrich von Klöden: ''Der Sternenhimmel. Eine vollständige populäre Sternenkunde, mit besonderer Beziehung auf die grosse Sternwandkarte des Landes-Industrie-Comptoirs'', Kapitel ''Anleitung zur Kenntnis der Sterne'', Teil II ''In der Nacht vom 29. März, Abends 10 1/2 Uhr'', Abschnitt b ''Aussicht nach Westen'', Seite 93, Weimar, 1848</ref> Gemeinsam bilden sie die beiden Pfosten des '''Goldenen Tors der Ekliptik''' im Sternbild Stier (Taurus). Auch der angelsächsische Benediktiner '''{{w|Beda Venerabilis}}''' (672 oder 673 bis 735) nannte die beiden Sternhaufen '''Plejaden" und "Hyaden''' Anfang des 8. Jahrhunderts in seinem Werk '''De natura rerum''' im elften Kapitel '''Vergiliae''' und '''Suculae'''. Er wies darauf hin, dass es sich um Frühlingszeichen am Himmel handelt und dass die Benennung von Sternen und Asterismen bei den ihm damals zur Verfügung stehenden Schriften nicht einheitlich gestaltet ist. Über die beiden Sternhaufen schreibt er "de signiferis signis per quae planetae currunt", also "von den Fahnenträgerzeichen, durch die die Planeten laufen".<ref>Beda Venerabilis: [http://monumenta.ch/latein/text.php?tabelle=Beda_Venerabilis&rumpfid=Beda%20Venerabilis,%20De%20Natura%20Rerum,%20%20%2011 De natura rerum - Kapitel 11 De stellis ("Über die Sterne")], Monumenta Informatik, Thalwil, Schweiz</ref> Das lateinische Wort "signifer" kann aber auch als Adjektiv mit "gestirnt" übersetzt werden, also "signiferis signis" = "gestirnte Zeichen". Bei den beiden Bezeichnungen bezieht Beda sich offenbar auch auf das 18. Kapitel "Naturae frugum" (Verse 246 bis 248, 280 und 313) in der "Naturalis historia" von '''{{w|Plinius der Ältere|Plinius dem Älteren}}''' (23 oder 24 bis 79) aus dem ersten Jahrhundert, der die beiden lateinschsprachigen Begriffe "vergiliae" und "suculae" ebenfalls verwendet hat.<ref>Gaius Plinius Secundus: [http://www.fh-augsburg.de/~harsch/Chronologia/Lspost01/PliniusMaior/plm_hi18.html Naturalis historia - Liber XVIII - Naturae frugum], Hochschule für angewandte Wissenschaften Augsburg</ref>
Alle sieben beweglichen Himmelsobjekte ziehen im Laufe der Zeit von der Erde aus betrachtet mehr oder weniger häufig, aber regelmäßig sehr nahe der Ekliptik durch diese Pforte und somit zwischen den beiden Sternhaufen hindurch.
→ Siehe auch [[Quadriviale Kuriositäten/ Zahlen#Zur Sieben|Exkurs '''Zur Sieben''']].
Der Erdmond, die Venus und der Merkur können aufgrund der etwas größeren Abweichung von der Ekliptik und der relativen Erdnähe gelegentlich einen Pfosten des Goldenen Tors streifen, treffen oder im Falle des Mondes und des Merkurs sogar etwas außerhalb der Plejaden vorbeiziehen. Die Venus, der dritthellste Wandelstern nach Sonne und Mond, bleibt stets südlich der Plejaden und nördlich von Aldebaran. Der Mond kann sowohl die Plejaden als auch den Stern Aldebaran bedecken.
<div style="clear:both"></div>
<gallery caption="Das Goldene Tor der Ekliptik" mode="packed" widths="300" heights="300">
Voynich.68r.Goldenes.Tor.der.Ekliptik.png|Ausschnitt vom rechten Bild auf der Seite 123 des Voynich-Manuskripts (um 1500) mit einer mutmaßlichen Darstellung des Goldenen Tors der Ekliptik: der groß dargestellte Stern Aldebaran links (Beschriftung: "dchol.dal", möglicherweise "Stern") und rechts davon sieben kleine Sterne der Plejaden (Beschriftung: "doaro", möglicherweise "Haufen"). Die geschwungene Linie (Beschriftung: "oalcheol") dürfte die Ekliptliklinie symbolisieren. Die Schrift des Manuskripts konnte noch nicht entschlüsselt werden.<ref>Joannes Richter: [https://de.scribd.com/document/577575939/Voynich-1-The-Roots-of-the-Voynich-Manuscript# The Roots of the Voynich-Manuscript], 7. Juli 2022, abgerufen am 22. April 2023</ref>
Bremiker.GoldenesTorDerEkliptik.GrauesKloster.1856.png|Das '''Goldene Tor der Ekliptik''' in ''De temporis e stellarum observationibus definiendi ratione apud veteres usitatissima'' aus dem Jahr 1856 vom deutschen Astronomen Carl Bremiker (* 1804; † 1877). Die Ekliptik verläuft auf der Linie von B nach A, und der Punkt C markiert das Goldene Tor der Ekliptik. '''Vergiliae''' = Plejaden; '''Suculae''' = Hyaden; Taurus = Stier; Aries = Widder.
Mars.im.Goldenen.Tor.der.Ekliptik.P1091607.jpg|Der am nordwestlichen Horizont im Sternbild Stier (Taurus) untergehende Mars (rote Scheibe unten halb rechts) drei Tage vor der Passage des Goldenen Tors der Ekliptik bei Annäherung an die Plejaden (rechts davon). Der Rote Riese Aldebran (α Tauri) befindet sich scheinbar im offenen Sternhaufen der Hyaden unten links im Kopf des Stieres. Am unteren Bildrand sind alle Sterne bis zur achten Größenklasse (8<sup>m</sup>), am oberen Bildrand alle Sterne bis zur neunten Größenklasse (9<sup>m</sup>) erkennbar. Links oben die Hornspitzen des Stieres mit den beiden Sternen Tien Kuan (ζ Tauri) und Elnath (β Tauri), oben in der Mitte Hassaleh (ι Aurigae) im Sternbild Fuhrmann (Auriga) und rechts oben das hintere Bein vom Sternbild Perseus.
Mars.im.Goldenen.Tor.der.Ekliptik.P1025010.jpg|Von links unten nach rechts oben befinden sich der hellste Stern des Nachthimmels Sirius (α Canis majoris) im Sternbild Großer Hund (Canis major), das Sternbild Orion mit seinen drei Gürtelsternen und dem Orionnebel, Der hellste Stern im Sternbild Stier (Taurus), Aldebaran (α Tauri), mit dem offenen Sternhaufen der Hyaden, der rote Planet Mars direkt im Goldenen Tor der Ekliptik und der offene Sternhaufen der Plejaden.
Goldenes.Tor.der.Ekliptik.Vollmond.P1079946.jpg|Hochaufgelöste Astrophotographie des sehr hellen Vollmonds (-13<sup>m</sup>) im Goldenen Tor der Ekliptik mit allen Fixsternen bis zur siebenten Größenklasse (7<sup>m</sup>) am südöstlichen Abendhimmel des 29. November 2020. Der Vollmond befindet sich zwischen den Plejaden (1,5<sup>m</sup>) oben in der Mitte und dem Kopf im Sternbild Stier (Taurus) mit dem hellsten Stern Aldebaran (1<sup>m</sup>) und den Hyaden unten links. Die Helligkeitsunterschiede im Objektraum betragen also 20 Größenklassen beziehungsweise dem Faktor einhundert Millionen oder 26 photographischen Lichtwertstufen.
Lunar.Corona.90percent.waning.moon.Aldebaran.P1105867.jpg|Der Mond im Goldenen Tor der Ekliptik bei leichter Bewölkung mit mehrfarbiger Korona (unten im Bild der Rote Riese Aldebaran, oben rechts die Plejaden). Die Farbe der Wolken ist im neutralen Grau (Farbtemperatur des Mondlichts = 4100 Kelvin).
Goldenes.Tor.der.Ekliptik.Venus.P1022936.jpg|Die Venus im Kegel des Zodiakallichts acht Bogengrad über dem westlichen Horizont elf Tage vor dem Erreichen des Goldenen Tors der Ekliptik. Die Venus hatte zum Zeitpunkt der Aufnahme eine nördliche ekliptikale Breite von rund drei Bogengrad.
</gallery>
Die ekliptikale Länge wird vom Frühlingspunkt aus entlang der Ekliptik gemessen. Für das Goldene Tor der Ekliptik beträgt sie heute zirka 64 Bogengrad. Im Übrigen sei darauf hingewiesen, dass die Verbindungslinie zwischen den Hyaden und den Plejaden bei der ekliptikalen Breite von 0 Bogengrad ziemlich genau mittig durch die Linie der Ekliptik geschnitten wird. Ferner ist die Ekliptik unter einem Winkel von rund 45 Bogengrad zu dieser Verbindungslinie geneigt. Auf diese Weise können sowohl die Lage der Ekliptik als auch deren Neigung zu jedem Zeitpunkt, von jeder Stelle der Erde und unmittelbar anhand der Ausrichtung des Goldenen Tors der Ekliptik abgelesen werden, ohne die Bahnen oder Lagen von Sonne, Mond oder Planeten beobachten zu müssen.
Der Vollständigkeit halber sei erwähnt, dass vor 4500 Jahren in jedem Jahr zum Frühlingsanfang die untergehende Sonne abends am westlichen Horizont im Goldenen Tor der Ekliptik stand, wobei dieses wegen des hellen Sonnenlichts selbst allerdings gar nicht zu sehen war. Heute ist dies am 25. Mai der Fall, da sich der Frühlingspunkt mittlerweile um gut zwei Monate (ein Monat entspricht einem Winkel 30 Bogengrad entlang der Ekliptik) nach Westen verschoben hat. Als Mitte des dritten Jahrtausends der Frühlingspunkt noch im Goldenen Tor der Ekliptik lag, konnten die Sumerer ihre überlieferten Plejaden-Schaltregeln einsetzten, um die Jahre zu ermitteln, in denen in ihrem Lunisolarkalender am Jahresende ein Schaltmonat eingefügt werden musste (siehe [[Die_Himmelstafel_von_Tal-Qadi/_Die_Plejaden#Schaltregeln|'''Plejaden-Schaltregeln''']]).
===Der Trichter der Thuraya===
[[Datei:Trichter.der.Thuraya.png|mini|rechts|hochkant=2|Westlich des Goldenen Tors der Ekliptik gibt es nur weniger auffällige Sternbilder und Sterne. Die hellsten Sterne nördlich und südlich der Ekliptik bilden in Richtung [[Die_Himmelstafel_von_Tal-Qadi/_Die_Plejaden|'''Plejaden''']] (arabisch ''Thuraya'') eine Art Trichter (orangefarben), durch den alle '''sieben Wandelgestirne''' in das Goldene Tor der Ekliptik eintreten. Dies sind nördlich der Ekliptik die Sterne Hamal im Widder (Aries) sowie Algenib, Markab und Enif im Sternbild Pegasus, und südlich der Ekliptik die Sterne Menkar und Diphda im Sternbild Walfisch (Cetus) sowie Fomalhaut im Sternbild Südlicher Fisch (Piscis Austrinus).]]
Die Beduinen kennen seit alters her das Sternbild '''Hände der Thuraya'''. Der Asterismus '''Thuraya''' ist die arabische Bezeichnung für die '''Plejaden''' beziehungsweise das '''Siebengestirn'''. Von diesem Asterismus gehen sowohl die beiden Arme der Thuraya als auch das Sternbild '''Lamm''' (al-hamal) aus.<ref>Danielle Adams: [http://onesky.arizona.edu/2015/12/thuraya-the-abundant-darling-of-the-heavens/ Thuraya, the Abundant Darling of the Heavens - The quintessential asterism], Two Deserts, one sky - Arab Star Calendars, 3 December 2015</ref> Dieses Lamm und der vom Betrachter aus gesehen linke Arm sind gleichzeitig Bestandteile des Körpers und der Beine des Himmelsstiers. In der linken Schulter der Thuraya liegt das Goldene Tor der Ekliptik.
Der Rand des Trichters ist mit fallender ekliptikaler Länge und Rektaszension (Reihenfolge der Sichtbarkeit von Osten nach Westen) durch die folgenden hellen Himmelsobjekte markiert:
* Offener Sternhaufen der [[Die_Himmelstafel_von_Tal-Qadi/_Die_Plejaden|'''Plejaden (Messier 45, M45)''']] im Sternbild Stier (Taurus)
* Nördlich der Ekliptik
** Der hellste Stern '''Hamal''' (α Arietis) im Sternbild Widder (Aries)
** '''Algenib''' (γ Pegasi) im Sternbild Pegasus
** '''Markab''' (α Pegasi) im Sternbild Pegasus
** Der hellste Stern '''Enif''' (ε Pegasi) im Sternbild Pegasus
* Südlich der Ekliptik
** '''Menkar''' (α Ceti) im Sternbild Walfisch (Cetus)
** Der hellste Stern '''Diphda''' (β Ceti, auch '''Deneb Kaitos''') im Sternbild Walfisch (Cetus)
** Der mit Abstand hellste Stern [[Quadriviale_Kuriositäten/_Die_Stele_vom_Rocher_des_Doms#Fomalhaut|'''Fomalhaut''' (α Piscis Austrini)]] im Sternbild Südlicher Fisch (Piscis Austrinus)
Bevor die sieben entlang der Ekliptik wandelnden Himmelskörper das Goldene Tor der Ekliptik im Sternbild Stier (Taurus) erreichen, durchlaufen sie in der Regel die Sternbilder Steinbock (Capricornus), Wassermann (Aquarius), Fische (Pisces) und schließlich Widder (Aries). In diesem Himmelsquadranten zwischen dem Stern Deneb Algedi (δ Capricorni), dem „Schwanz des Ziegenböckchens“ im Sternbild Steinbock, und dem Goldenen Tor der Ekliptik gibt es keinen einzigen ekliptiknahen Stern mit einer Größenklasse 3,5<sup>m</sup> oder heller. Lediglich die beiden Sterne Sadalmelik (α Aquarii) und Sadalsuud (β Aquarii) im Sternbild Wassermann erreichen die Größenklasse 3<sup>m</sup>, liegen mit einer nördlichen ekliptikalen Breite von 10,5 Bogengrad beziehungsweise 8,5 Bogengrad allerdings außerhalb der Bahnen der Wandelgestirne. Erst im Goldenen Tor der Ekliptik im Sternbild Stier (Taurus) übertreffen die Plejaden, die Hyaden sowie der Rote Riese Aldebaran (0,85<sup>m</sup>) diese Helligkeit, und zwar erheblich. Dies bedeutet, dass alle in diesem Himmelssegment in der Nähe der Ekliptik liegenden Fixsterne in der Helligkeit von mehreren hundert anderen Sternen des Nachthimmels sowie sehr deutlich von den sieben Wandelgestirnen übertroffen werden. Die sieben Wandelgestirne ziehen also aus einer dunklen und sternenarmen Himmelsregion, dem '''Trichter der Thuraya''', quasi wie durch einen Trichter oder einen Schlauch zum '''Himmelsstier''' in das '''Goldene Tor der Ekliptik'''. In diesem Zusammenhang ist bemerkenswert, dass das zentrale Mondhaus in der großen chinesischen Konstellation '''"Schwarze Schildkröte des Nordens"''' im chinesischen Mondkalender '''"Leere"''' genannt wird. Diese Konstellation erstreckt sich entlang der Ekliptik vom Sternbild Schütze (Sagittarius) über die Sternbilder Steinbock (Capricornus) und Wassermann (Aquarius) bis in das Sternbild Fische (Pisces) über einen ganzen Himmelsquadranten (90 Bogengrad), und das zentrale Mondhaus 虛 (Xū) befindet sich bei der ekliptikalen Länge der Sterne Deneb Algedi (δ Capricorni) und Sadalsuud (β Aquarii).
[[Datei:Haende.der.Thuraya.Vollmond.Sterne.P1079912.jpg|links|mini|hochkant=4|Mit dem beduinischen Sternbild '''Hände der Thuraya''' (grüne durchgezogene Linien, die Ekliptik ist als rot gepunktete Linie dargestellt). Die anatomischen Bestandteile von unten Mitte über die Plejaden (Thuraya) nach rechts oben: die amputierte Hand (al-'''kaf al-jadhma'''), Thuraya (die kleine Reichliche, ath-'''thuraya'''), das Schulterblatt (al-''''atiq'''), die Schulter (al-'''mankib'''), der Oberarm (al-'adud), die Ellenbogenspitze (ibrat al-'''mirfaq'''), der Ellenbogen (al-'''mirfaq'''), die Ellenbogengrube (al-ma'bid), der Unterarm von Thuraya (dhira’ ath-thuraya), die Tätowierung des Handgelenks (washm al-mi'sam), die Henna-gefärbte Hand (al-'''kaf''' al-khadib).<br/>
Thuraya wird von den Beduinen auch als der fette Schwanz des Asterismus ''Lamm'' (al-hamal) interpretiert. Dies entspricht dem griechischen Sternbild Widder (Aries). Der Stern Hamal steht für die kleinen Hörner des Lammes.<ref name="lamb">Danielle Adams: [http://onesky.arizona.edu/arab-star-names/the-lamb/ The Lamb - A folkloric celestial complex], Two Deserts, one sky - Arab Star Calendars, 2017</ref><br/>
Der Arm der Thuraya mit der amputierten Hand und der Asterismus Lamm bilden zusammen einen Trichter, durch den alle Wandelgestirne auf der Ekliptik in das Goldene Tor der Ekliptik zwischen den beiden offenen Sternhaufen der Hyaden beim Stern Ain und der Plejaden eintreten.]]
<div style="clear:both"></div>
<gallery caption="Der Trichter der Thuraya" widths="1200" heights="675" perrow="1">
Trichter.der.Thuraya.P1025200.jpg|Astrophotographie des Nachthimmels Anfang Oktober kurz vor Mitternacht über dem südöstlichen Horizont. Sternbilder von links nach rechts: Stier (Taurus) mit den Plejaden, Widder (Aries), Fische (Pisces). Links oben Perseus, oben in der Mitte Dreieck (Triangulum), rechts oben Pegasus und unten Walfisch (Cetus).
Trichter.der.Thuraya.P1025200.png|Einblendung der Bezeichnungen aller Sterne bis zur dritten Größenklasse (3,0<sup>m</sup>). Der südliche Meridian verläuft entlang des rechten Bildrands. Die Ekliptiklinie ist dunkelrot gestrichelt dargestellt.
Trichter.der.Thuraya.-2EV.P1025200.png|Reduktion der Helligkeit um zwei Blendenstufen. Der Trichter der Thuraya erstreckt sich von links im Goldenen Tor der Ekliptik bis nach rechts durch ein sich zunehmend aufweitendes Gebiet ohne hellere Sterne.
</gallery>
[[Datei:Fragment-de-STELE_8206.jpg|Vorderseite|mini|rechts|Die Vorderseite der → [[Quadriviale Kuriositäten/ Die Stele vom Rocher des Doms|'''Stele vom Rocher des Domes''']].]]
Eine prähistorische Darstellung des Trichters der Thuraya könnte auf der Vorderseite der → [[Quadriviale_Kuriositäten/_Die_Stele_vom_Rocher_des_Doms|'''Stele vom Rocher des Doms''']] zu sehen sein. Die beiden oben abgerundeten Pfeiler in der Ritzzeichnung würden in diesem Fall für die beiden Pfeiler des Goldenen Tors der Ekliptik stehen. Das große sternförmige Symbol repräsentiert ein helles Himmelsobjekt, namentlich die Sonne, den Mond oder eines der fünf weiteren freiäugig sichtbaren Wandelgestirne, das entlang der Ekliptiklinie regelmäßig durch diese beiden Pfeiler hindurchtritt.
<div style="clear:both"></div>
===Der Zodiak===
[[Datei:MUP.APIN.VAT09412.P1078712.jpg|mini|rechts|hochkant=1.5||1914 gefundene Tontafel mit Texten aus dem 687 vor Christus geschrieben babylonischen Kompendium '''MUL.APIN''' mit den Namen von Sternbildern, Irak, Assur/Qal'at Scherqat, VAT 09412, Neues Museum Berlin]]
Der Zodiak (griechisch ζῳδιακός = zodiakós) oder Lebewesenkreis (häufig unzutreffend auch als Tierkreis bezeichnet) beschreibt die zwölf Sternbilder entlang der Ekliptik. Die Mesopotamier kannten schon um 750 vor Christus insgesamt siebzehn Sternbilder, zu denen auch die zwölf Sternbilder des heutigen Zodiaks gehören:
* Borste (MUL.MUL / Plejaden / Siebengestirn)
* Himmelsstier ('''Stier / Taurus''')
* Wahrer Hirte des Anu / Treuer Himmelshirte (Orion)
* Alter Mann (Perseus)
* Krummer Stab (Wurfholz, Fuhrmann / Auriga)
* Große Zwillinge (zusammen mit den Kleinen Zwillingen heute die '''Zwillinge / Gemini''')
* '''Krebs (Cancer)'''
* '''Löwe (Leo)'''
* Furche (Ackerfurche, eine Ähre tragende '''Jungfrau / Virgo''')
* '''Waage (Libra)'''
* '''Skorpion (Scorpio)'''
* Pabilsag ('''Schütze / Sagittarius''')
* Ziegenfisch ('''Steinbock / Capricornus''')
* Großer (Enki / Ea, Herrscher des Süßwasserozeans, '''Wassermann / Aquarius''')
* Schwänze der Schwalbe ('''Fische / Pisces''')
* Annunitum (Aja, Anunitu, Kriegsgöttin und Gemahlin des Sonnengottes Šamaš, Andromeda)
* Lohnarbeiter ('''Widder / Aries''' und Dreieck / Triangulum)
In den MUL.APIN-Texten wird erwähnt, dass diese zusammen die Götter sind, die im Pfad des Mondes stehen, also in einem zirka elf Bogengrad breiten Band entlang der Ekliptik. Einige hundert Jahre später wurde die Ekliptik entlang des Sonnenpfades in zwölf gleich große Sternbilder aufgeteilt (oben in der Liste '''gefettet''' geschrieben), in denen sich die Sonne im Laufe eines Jahres jeweils einen Monat lang am Stück aufhält.
[[Datei:ZodiacCC - Degrees Dates Names Move DE.svg|mini|rechts|hochkant=1.5|Schema des Zodiaks: die zwölf Sternbilder des Lebewesenkreises entlang der Ekliptik.]]
Der Kreis mit den zwölf aneinander angrenzenden '''Lebewesenzeichen''' entlang der Ekliptiklinie wird auch '''Zodiak''' genannt. Alle zwölf Lebewesenzeichen nehmen einen eigenen ungefähr 30 Bogengrad langen Abschnitt des Vollkreises der Ekliptik ein.
* Die '''Sonne''' wandert entlang der Ekliptiklinie jeden '''Monat''' um ein Lebewesenzeichen weiter nach Osten.
* Der '''Jupiter''' wandert entlang der Ekliptiklinie jedes '''Jahr''' um ein Lebewesenzeichen weiter nach Osten.
In jeder der vier Jahreszeiten gibt es drei Monate, die einem der Lebewesenkreiszeichen zugeordnet werden können. Eines der Zeichen, die zu einer Jahreszeit gehören, ist jeweils menschlich (Zwillinge, Jungfrau, Schütze und Wassermann). Bevor diese Sternzeichen gebildet wurden, orientierten sich die alten Perser an den vier [[Astronomie von der Frühgeschichte bis zur Neuzeit/ Astronomische Bezugssysteme#Königssterne|'''Königssternen''']] Aldebaran (α Tauri, altpersisch: Taschter), Regulus (α Leonis, altpersisch: Venant), Antares (α Scorpii, altpersisch: Haftorang) und Fomalhaut (α Piscis Austrini, altpersisch: Satevis), die die Hauptpunkte der vier Jahreszeiten auf der Ekliptik markierten.
Von allen international standardisierten Sternzeichen liegen nur diese zwölf Lebewesenkreiszeichen auf der Ekliptik. Ihre ekliptikale Breite erstreckt sich von Süden nach Norden ungefähr zehn Bogengrad symmetrisch um die Ekliptiklinie. Sie teilen die 360 Bogengrad der ekliptikalen Längen allerdings nicht in gleichmäßig große Segmente ein. Bei den ekliptikalen Längen des Sternbilds Skorpion (Scorpio) schneidet die Ekliptiklinie eher das Sternbild Schlangenträger (Ophiuchus), das jedoch nicht zum Zodiak gezählt wird und das Sternbild Schlange (Serpent) in zwei separate Flächen rechts und links des Schlangenträgers teilt.
Die beiden offenen Sternhaufen der Plejaden und der Hyaden gehören zum Sternbild Stier (Taurus), und der offene Sternhaufen Praesepe (Krippe) gehört zum Sternbild Krebs (Cancer). Diese Sternhaufen liegen deswegen ebenfalls im Bereich der Ekliptik. Alle anderen Sternbilder, namentlich Orion und Großer Bär (Ursa Major, mit dem Asterismus Großer Wagen) liegen abseits der Ekliptik. Alle nördlich der Ekliptik liegenden Himmelsobjekte sind von der Nordhalbkugel aus irgendwann am Nachhimmel sichtbar.
* '''Frühling'''
** Widder (Aries)
** Stier (Taurus)
** Zwillinge (Gemini)
* '''Sommer'''
** Krebs (Cancer)
** Löwe (Leo)
** Jungfrau (Virgo)
* '''Herbst'''
** Waage (Libra)
** Skorpion (Scorpio)
** Schütze (Sagittarius)
* '''Winter'''
** Steinbock (Capricornus)
** Wassermann (Aquarius)
** Fische (Pisces)
Diese Sternbilder des Lebewesenkreises haben sich im Altertum seit dem siebenten vorchristlichen Jahrhundert entwickelt. Der vollständige Lebewesenzeichenkreis mit seinen zwölf Sternbildern entstand im 5. Jahrhundert vor Christus im persischen Achämenidenreich. Im darauffolgenden Jahrhundert entwickelte sich bei den Seleukiden die Aufteilung entlang der Ekliptik in einheitlich 30 Bogengrad lange abstrakte astrologische Sternzeichen. Hiermit vereinfachte sich die Vorausbestimmung der Positionen der sieben Wandelgestirne.<ref name="Ossendrijver380">Mathieu Ossendrijver: ''Astronomie und Astrologie in Babylonien.'' In: Joachim Marzahn, Beatrice André-Salvini, Jonathan Taylor: ''Babylon – Mythos und Wahrheit: Katalog zur Ausstellung in den Staatlichen Museen zu Berlin, Pergamonmuseum, 26.6.2008–5.10.2008''. Hirmer Verlag, München 2008, S. 380 ([https://www.researchgate.net/publication/314607078_Astronomie_und_Astrologie_in_Babylonien online]).</ref> In der späteren seleukidischen Zeit wurden diese Lebewesenkreiszeichen von den Griechen und danach auch von den Römern übernommen.
[[Datei:Zodiak.Dendera.NeuesMuseum.Berlin.Panorama.jpg|mini|rechts|hochkant=2|Deckengemälde nach dem '''Zodiak von Dendera''' in der ägyptischen Abteilung des Neuen Museums in Berlin. Der nach oben gerichtete Stier befindet sich auf dem Ziffernblatt in der Richtung von ein Uhr im inneren Kreis. Der Lebewesenkreis ist im Uhrzeigersinn dargestellt.]]
Die Lebewesenkreiszeichen tauchen etwas später auch in antiken Tempeln Ägyptens am Nilufer auf, wie zum Beispiel im Tempel von Dendera oder im Tempel von Esna, der ungefähr 50 vor Christus fertiggestellt wurde.<ref>Anja Semling: [https://www.mein-altaegypten.de/Website/C-Architektur-Tempel-Dendera.html Dendera – Gottestempel, geweiht der Göttin Hathor], abgerufen am 3. August 2025</ref><ref>Michelle Starr: [https://www.sciencealert.com/complete-depiction-of-the-zodiac-found-in-ancient-egyptian-temple Complete Depiction of The Zodiac Found in Ancient Egyptian Temple], science alert, 24. März 2023</ref> Der Tempel von Dendera liegt 60 Kilometer nördlich von Luxor und war den ägyptischen Göttern Hatgor und Isis geweiht. Die originale Darstellung der Sternbilder der nördlichen Hemisphäre mit allen zwölf auch heute noch bekannten Tierkreiszeichen befand sich an der Decke des Mittelraums der nordöstlichen Anlage des Tempels und ist heute im Pariser Louvre ausgestellt.
<gallery caption="Der Zodiak von Dendera" mode="packed">
Dendera.01.Stier.Widder.jpg|Stier (Taurus) und Widder (Aries)
Dendera.02.Widder.Fische.jpg|Widder (Aries) und Fische (Pisces)
Dendera.03.Fische.Wassermann.jpg|Fische (Pisces) und Wassermann (Aquarius)
Dendera.Wassermann.Ziegenfisch.jpg|Wassermann (Aquarius) und Ziegenfisch (Steinbock, Capricornus)
Dendera.05.Ziegenfisch.Schuetze.jpg|Ziegenfisch (Steinbock, Capricornus) und Schütze (Sagittarius)
Dendera.06.Schuetze.Skorpion.jpg|Schütze (Sagittarius) und Skorpion (Scorpio)
Dendera.07.Skorpion.Waage.jpg|Skorpion (Scorpio) und Waage (Libra)
Dendera.08.Waage.Jungfrau.jpg|Waage (Libra) und Jungfrau (Virgo)
Dendera.09.Jungfrau.Loewe.jpg|Jungfrau (Virgo) und Löwe (Leo)
Dendera.10.Loewe.Krebs.jpg|Löwe (Leo) und Krebs (Cancer)
Dendera.11.Krebs.Zwillinge.jpg|Krebs (Cancer) und Zwillinge (Gemini)
Dendera.12.Zwillinge.Stier.jpg|Zwillinge (Gemini) und Stier (Taurus)
</gallery>
'''Anmerkungen'''
* Das Sternzeichen Waage (Libra) steht zwischen den beiden Sternbildern Skorpion (Scorpio) und Jungfrau (Virga). Allerdings ist das Sternbild Waage recht klein und vergleichsweise unscheinbar. Im Altertum wurde es noch den beiden Scheren des Spinnentieres im großen Sternbild [[Astronomie von der Frühgeschichte bis zur Neuzeit/ Astronomische Bezugssysteme#Der Himmelsskorpion|'''Himmelsskorpion''']] zugeordnet. Es entspricht dem 16. Mondhaus ''Azobene'' (zu Deutsch ''die beiden Scheren'') des antiken astronomischen Ekliptiksystems ''Manazil al-Qamar'', das insgesamt 28 Sterngruppen ausweist.
* Das gleiche trifft auf den [[Astronomie von der Frühgeschichte bis zur Neuzeit/ Astronomische Bezugssysteme#Der Himmelsstier|'''Himmelsstier''']] zu, der aufgrund seiner Größe in die beiden angrenzenden Sternbilder Stier (Taurus) und Widder (Aries) geteilt wurde. Erst die Perser und Babylonier führten zwölf Sternzeichen und die regelmäßige Winkelstruktur auf der Ekliptik mit gleichgroßen Segmenten mit jeweils 30 Bogengrad ein. Es ist nicht überliefert, ob und welche Sternbilder in welchen Konstellationen vor 4500 Jahren in Gebrauch waren.''
* Im Sommerviertel kommt dem auffälligen [[Astronomie von der Frühgeschichte bis zur Neuzeit/ Astronomische Bezugssysteme#Der Löwe|'''Löwen''']] eine besondere Bedeutung zu.
* Der babylonische '''Ziegenfisch''' (wörtlich Karpfenziege) verwandelte sich in das Sternbild '''Steinbock''' (Capricornus). Das Winterviertel besteht somit aus drei Wasserzeichen, die Tel des astronomischen [[Astronomie von der Frühgeschichte bis zur Neuzeit/ Astronomische Bezugssysteme#Der Urozean|'''Urozeans''']] sind.
Durch die Präzession der Erdachse wandert der '''Frühlingspunkt''' im Laufe der Jahrtausende rückläufig (retrograd) durch den Zodiak. Heute befindet dieser sich im Sternbild Fische (Pisces). Der Planet '''Jupiter''' wandert wegen seiner siderischen Umlaufzeit von knapp zwölf Jahren Jahr für Jahr rechtläufig (prograd) in etwa ein Ekliptiksternbild weiter durch den Lebewesenkreis. Der '''Mond''' wandert innerhalb eines siderischen Monats einmal rechtläufig (prograd) durch den Lebewesenkreis. Ausgehend vom Frühlingspunkt um 2600 vor Christus im Sternbild Stier entsprechen die Sternbilder ungefähr den zwölf Himmelsregionen, in denen sich die rechtläufig (prograd) durch die Ekliptik ziehende Sonne innerhalb eines tropischen Jahres immer einen Monat lang aufhielt:
[[Datei:Babylonian_Celestial_Map.png|zentriert|mini|hochkant=3|Karte des babylonischen Himmels, bei der der Himmelsäquator (horizontale große Halbachse in der Mitte) in zwölf gleiche Teile unterteilt ist, die den idealen Monaten eines Sonnenjahres entsprechen (von rechts nach links abwechselnd weiß und blau gekennzeichnet). Die babylonischen Ekliptiksternbilder sind orangefarben hervorgehoben.]]
→ Zur Ermittlung der Lage des Frühlingspunkts und des Zeitpunkts der Tag-und-Nacht-Gleiche im Frühjahr um 2600 vor Christus in Mesopotamien siehe auch [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Die_Plejaden#Schaltregeln|'''Plejaden-Schaltregeln''']].
=== Die Mondhäuser ===
Die Einteilung der Ekliptiklinie in 27 oder 28 Mondhäuser war bereits im Altertum üblich.
* Der '''Mond '''wandert jeden '''Tag''' entlang der Ekliptiklinie linksläufig um ein Mondhaus weiter nach Osten.
* Der '''Saturn''' wandert jedes '''Jahr''' entlang der Ekliptiklinie linksläufig um ein Mondhaus weiter nach Osten.
* Der [[Astronomie von der Frühgeschichte bis zur Neuzeit/ Astronomische Bezugssysteme#Der Frühlingspunkt|'''Frühlingspunkt''']] der Sonne [[Astronomie von der Frühgeschichte bis zur Neuzeit/ Die Plejaden#Wanderung des Frühlingspunkts|wandert]] aufgrund der [[Astronomie von der Frühgeschichte bis zur Neuzeit/ Astronomische Bezugssysteme#Präzession|Präzession der Erdachse]] jedes '''Jahrtausend''' entlang der Ekliptiklinie rechtsläufig um ein Mondhaus weiter nach Westen.
Der Mond durchläuft auf seiner monatlichen Bahn alle ekliptikalen Längen linksläufig von 0 bis 360 Bogengrad. Diese Längen wurden schon im Altertum in [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Konjunktionen#Mondhäuser|'''Mondhäuser''']] (respektive '''Mondstationen''') eingeteilt, in denen sich der Mond jeweils genau einen Tag lang aufhält, bevor er in das nächste Mondhaus weiterwandert. Als Bezugspunkt diente auch schon im Altertum häufig der Frühlingspunkt. Um 700 vor Christi Geburt lag der Frühlingspunkt auf der Ekliptik bei der gleichen ekliptikalen Länge wie der Hauptstern Hamal (α Arietis) des heutigen Sternbilds Widder (Aries). Bei den Beduinen wurden 28 Mondhäuser verwendet, und Hamal lag im ersten Mondhaus ''Scheratan'' ("die beiden Zeichen") oder ''Alnath'' ("das Horn" des Lammes). Wenn sich der Mond in diesem Mondhaus befindet, ist er einen Tag später im zweiten Mondhaus ''Albotayn'' ("das Bäuchlein" des Lammes, dort befindet sich auch der Stern Nair al Butain, auch Bharani genannt) und noch einen Tag später '''im dritten Mondhaus ''Thuraya''''', das sind die Plejaden.
[[Datei:Mondhaeuser.Ekliptik.png|mini|links|hochkant=4|Die in die Ebene projizierten 28 Mondhäuser (von rechts nach links) des altarabischen ekliptikalen Systems '''Manzil al-Qamar''' (zu Deutsch: "Mondhäuser" oder "Mondstationen") mit den wichtigsten Sternen entlang der Ekliptik (rote gestrichelte Linie, ekliptikale Länge von 0 Bogengrad bis 360 Bogengrad '''zur Epoche J0000.0''' in horizontaler Richtung, senkrecht dazu die ekliptikale Breite). Die beiden seitlichen Ränder der Abbildung gehen im Kreisbogen der Ekliptik nahtlos ineinander über. Die Plejaden befinden sich im dritten Mondhaus. Durch die Wanderung des Frühlingspunktes entlang in Richtung niedrigerer ekliptikaler Längen (nach rechts) sind die heutigen ekliptikalen Längen (zur Epoche J2000.0) um knapp 28 Bogengrad größer. Alle Objekte zwischen den ekliptikalen Breiten -5 Bogengrad (unten) und +5 Bogengrad (oben) können vom Mond bedeckt werden.]]
[[Datei:Manazil al-Qamar.webm|mini|rechts|Animation mit den 28 Mondhäusern (von rechts nach links) und den wichtigsten Sternen entlang der Ekliptik.]]
<div style="clear:both"></div>
Bei den Indern gab es nur 27 Mondhäuser und Hamal lag ebenfalls im ersten Mondhaus ''Ashvini'' ("die beiden Rosseschirrenden"). Das zweite Mondhaus heißt ''Bharani'' ("der Wegtragende") und das '''dritte Mondhaus ''Krittika''''', was wiederum Siebengestirn bedeutet.
[[Datei:28_xiu.svg|mini|rechts|hochkant=1|Kreisförmige Darstellung der nördlichen Hemisphäre mit den 28 chinesischen Mondhäusern. Links der Frühling (Osten), unten der Sommer (Süden), rechts der Herbst (Westen) mit dem Asterismus '''Mǎo''' (昴 = haariger Kopf des Sternbilds "Weißer Tiger") in seiner Mitte sowie oben der Winter (Norden).]]
Die Chinesen haben die Ekliptik ebenfalls in 28 Mondhäuser eingeteilt. Das Mondhaus mit den Plejaden heißt dort Mǎo ("haariger Kopf"), liegt in der Mitte des Herbststernbilds "Weißer Tiger des Westens" und markiert dort den Herbstpunkt auf der Ekliptik, der dem Frühlingspunkt genau gegenüber liegt. Im Altertum gingen die Plejaden zur Tag-und-Nacht-Gleiche beim Herbstanfang während des Sonnenuntergangs genau im Osten auf.
→ Für die Konjunktionen zwischen dem Mond beziehungsweise dem Planeten Saturn und ekliptiknahen Sternen siehe: [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Konjunktionen#Mondhäuser|Wikibook-Abschnitt "Mondhäuser"]].
<div style="clear:both"></div>
== Langfristige Veränderungen ==
Im System des Himmelsäquators sind die Rektaszensionen und die Deklinationen aller Fixsterne einer stetigen Änderung unterworfen, die nicht nur auf der Eigenbewegung der Sterne im Weltraum beruht. Diese sind auch durch die '''Präzession der Erdrotationsachse''' bedingt. Das Zusammenwirken dieser Einflüsse hat beispielsweise dazu geführt, dass der Stern Pollux (β Gemini), der am Ende der Altsteinzeit bei einer nördlichen ekliptikalen Breite von 5,5 Bogengrad noch vom Mond bedeckt werden konnte, mit inzwischen über sechs Bogengrad eine dafür zu große nördliche ekliptikale Breite erreicht hat.
Insbesondere wegen der Präzessionsbewegung kann es nach mehreren Jahrtausenden plötzlich wieder zu säkularen Aufgängen kommen, oder diese bleiben ab einem bestimmten Zeitpunkt wieder aus.
→ Siehe hierzu auch: [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Die_Stele_vom_Rocher_des_Doms#Sterne_am_Horizont|'''Sterne am Horizont''']].
=== Präzession ===
[[Datei:Precission and gravitation.svg|rechts|mini|360px|Befindet sich am rechten Ende der gepunkteten schwarzen Linie eine große Masse, dann ist die Gravitationskraft (rote Pfeile) auf die dieser Masse zugewandten Hälfte größer als auf die dieser Masse abgewandten Hälfte. Ist die rotierende Erdachse gegenüber dieser Linie zudem geneigt, ergibt sich ein Drehmoment, das in Richtung auf den Betrachter (senkrecht aus der Bildebene hinaus) die Achse entgegen dem Uhrzeigersinn aufrichten möchte. Durch das Gesetz des Drehimpulssatzes erfolgt daraufhin jedoch nicht die Aufrichtung der Achse, sondern eine andauernde kreisförmige Präzessionsbewegung der Rotationsachse, bei der sich der Drehimpuls zeitlich stets in Richtung des jeweils wirkenden Drehmoments ändert.]]
[[Datei:Precession N.png|mini|rechts|hochkant=2|Kreisförmige Bewegung des Himmelsnordpols um den Ekliptiknordpol innerhalb von 26000 Jahren. Der Polarstern (Polaris oder α Ursae Minoris, oben in der Mitte) befindet sich zurzeit in der Nähe des Himmelsnordpols.]]
Alle großen Massen, insbesondere die der Sonne, aber auch die des Mondes und die der Planeten erzeugen auf der zugewandten Seite wegen der etwas größeren Nähe eine etwas größere Gravitationskraft als auf der abgewandten Seite. Falls die Rotationsachse der Masse in Bezug auf die Verbindungslinie von Mittelpunkt und anziehender Masse geneigt ist oder wenn die Masse inhomogen um den Mittelpunkt verteilt ist, resultiert senkrecht zur Rotationsachse ein Drehmoment, das in Verbindung mit dem durch die Drehung der Masse verursachten Drehimpuls der rotierenden Masse eine Präzessionsbewegung hervorruft.
Bei der Präzession der Erdachse kreist der Himmelspol innerhalb von knapp 26000 Jahren beziehungsweise innerhalb eines '''Platonischen Jahres''' einmal um den Pol der Ekliptik. Dieses Verhalten von sich drehenden rotationssymmetrischen Körpern kann beispielsweise auch bei Peitschenkreiseln beobachtet werden, deren Rotationsachse nicht lotrecht steht und die von Kindern gerne als Spielzeug benutzt werden.
Die Präzession bewirkt das rückläufige (retrograde) Wandern von Frühlingspunkt und Herbstpunkt entlang der Ekliptiklinie mit ihren 27 bis 28 Mondhäusern beziehungsweise den 12 Lebewesenkreiszeichen (Zodiak). Pro Sonnenjahr verschiebt sich der Frühlingspunkt um gut 50 Bogenminuten. Nach 72 Jahren hat sich der Betrag die Verschiebung der ekliptikalen Länge <math>\Delta \lambda</math> nach Westen (deswegen mit negativem Vorzeichen) auf ungefähr ein Bogengrad erhöht:
:<math>\Delta \lambda \approx -72 \text{ a} \cdot \frac {50^\shortparallel \,} {\text{a}} = -3600^\shortparallel \approx -1^\circ</math>
Ein voller Kreis wird demnach innerhalb eines Platonischen Jahres mit der Dauer <math>T_{PJ}</math> nach rund 26000 Jahren durchlaufen:
:<math>T_{PJ} \approx 360^\circ \cdot \frac {\text{72 a}} {1^\circ} \approx 26000 \text{ a}</math>
Durch die Beobachtung der '''[[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Astronomische_Bezugssysteme#Beobachtungen_in_der_Nähe_der_Ekliptik|Plejaden-Waage]]''' mit den beiden sehr auffälligen und markanten Sternen Antares und Aldebaran sowie den Mondphasen in den entsprechenden '''[[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Astronomische_Bezugssysteme#Die_Mondhäuser|Mondhäusern]]''' des Frühlingsmonats konnte die Lage des Frühlingspunkts der Sonne bereits in der Jungsteinzeit (Neolithikum) relativ zuverlässig bestimmt werden. Vor 5000 Jahren stand die Sonne zum Frühlingsbeginn zwischen den beiden Augensternen '''Aldebaran''' (α Tauri (alpha Tauri)) und '''Ain''' (ε Tauri (epsilon Tauri)) des Himmelsstieres. Es ist sei darauf hingewiesen, dass diese beiden Sterne mit dem ersten Buchstaben '''Aleph''' [[Datei:PhoenicianA-01.svg|30px]] mit der bildlichen Bedeutung "Stier" und dem letzten Buchstaben '''Ain''' [[Datei:PhoenicianO-01.svg|30px]] mit der bildlichen Bedeutung "Auge" des bereits im zweiten vorchristlichen Jahrtausend verwendeten phönizischen Alphabets in Zusammenhang gebracht werden können. Es ergibt sich also die Parallele zwischen dem ersten Buchstaben "Aleph" sowie dem letzten Buchstaben "Ain" im Alphabet und der ersten Position der Sonne zum Jahresbeginn zur Tag-und-Nacht-Gleiche beim Stern Aldebaran sowie der letzten Position der Sonne zum Jahresende vor der darauf folgenden Tag-und-Nacht-Gleiche beim Stern Ain, nachdem die Sonne die gesamte Ekliptiklinie einmal vollständig in Richtung Osten durchlaufen hat.<ref name="ErnstVonBunsen">Ernst von Bunsen: ''Die Plejaden und der Thierkreis oder: Das Geheimnis der Symbole'', Verlag von Mitscher und Röstell, Berlin, 1879</ref>
→ Siehe hierzu auch: [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Konjunktionen#Ochs_und_Esel|'''Ochs und Esel''']].
Die für die Synchronisation von Mond- und Sonnenjahr angewendeten [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Die_Plejaden#Schaltregeln|'''Plejaden-Schaltregeln''']] galten im 26. Jahrhundert vor Christus, als sich der Frühlingspunkt im Goldenen Tor der Ekliptik im Sternbild Stier (Taurus) befand.
→ Siehe hierzu auch: [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Astronomische_Bezugssysteme#Das_Goldene_Tor_der_Ekliptik|'''Das Goldene Tor der Ekliptik''']].
Die Plejaden-Schaltregeln wurden noch mindestens eintausend Jahre nach ihrer Anwendung in den zusammengestellten Keilschrifttexten der MUL-APIN-Tafeln überliefert, nachdem sich der Frühlingspunkt immer weiter nach Westen verschoben hatte, so dass die Plejaden-Schaltregeln längst nicht mehr angewendet werden konnten. Dennoch wurden sie noch immer tradiert, was einen klaren Hinweis darauf liefert, dass die Verschiebung des Frühlingspunkts den Mesopotamiern spätestens vor viertausend Jahren aufgefallen und als wichtiges astronomisches Wissen weitergegeben worden sein muss.
[[Datei:Fruehlingspunkte.png|mini|zentriert|hochkant=3|Wanderung des Frühlingspunktes entlang der Ekliptiklinie von den beiden Augensternen des Sternbilds Stier (Taurus) im Westen (links) durch das Goldene Tor der Ekliptik und das Sternbild Widder (Aries) bis in das Sternbild Fische (Pisces) im Osten (rechts) vom Ende des Neolithikums bis in die Antike. Die dargestellten Sternbildgrenzen entsprechen der Festlegung der Internationalen Astronomischen Union von 1928. Der Punkt -1567 markiert die Stelle, die der Frühlingspunkt 1000 Jahre nach dessen Lage im Goldenen Tor der Ekliptik erreicht hatte.]]
Der Mond durchläuft entlang der Ekliptiklinie innerhalb eines siderischen Monats <math>T_{sid}</math> mit gut 27 Tagen einen vollständigen Kreis mit 27 bis 28 Mondhäusern respektive Mondstationen. Daraus ergibt sich das folgende Verhältnis der Zeitdauern von knapp tausend Jahren, in denen der Frühlingspunkt jeweils von einem Mondhaus in das westlich benachbarte Mondhaus wandert, zu einem Tag, in dem der Mond jeweils von einem Mondhaus in das östlich benachbarte Mondhaus wandert:
:<math>\frac {T_{PJ}} {T_{sid}} \approx \frac {26000 \text { a}} {27 \text { d}} \approx 1000 \frac {\text { a}} {\text { d}}</math>
Dieses Verhältnis spiegelt sich in '''Psalm 90''' wider, der als einer der ältesten Psalmverse gilt. Er wird dem Propheten Mose zugeschrieben, und könnte somit in der Anfangszeit des Neuen Reiches verfasst worden sein. Die Epoche des Neuen Reiches begann mit der Regierungszeit des altägyptischen Pharaos Ahmose I. (um 1560–1525), der nach Herrschaft der altägyptischen Familie der Ahmosiden die 18. Dynastie begründete und die ausländischen Könige aus der Region des Nildeltas vertrieb. Die Plejaden-Schaltregeln galten im 26. Jahrhundert vor Christus, als der Frühlingspunkt im Goldenen Tor der Ekliptik zwischen den Plejaden und den Hyaden lag. Um 1500 vor Christus, zum möglichen Zeitpunkt der Formulierung des 90. Psalms, hatte sich der Frühlingspunkt um 15 Bogengrad weiter nach Westen verlagert, was in Bezug auf das Jahr 2600 dem 24. Teil eines Kreises entspricht:
:<math>\frac {2600 \text { a} - 1500 \text { a}} {\frac {1} {24}} = 1100 \text { a} \cdot 24 = 26400 \text { a} \approx T_{PJ}</math>
Jeden Tag wandert der Mond vor dem Hintergrund des Fixsternhimmels gut 13 Bogengrad nach Osten. Setzt man die Dauer eines siderischen Monats, in der der Mond den Fixsternhimmel einmal vollständig durchlaufen hat (360 Bogengrad), als Grundlage für die Berechnung der Dauer der Präzessionsperiode anhand dieses Vergleichs mit dem Fortschreiten des Mondes mit drei Nachkommastellen auf 27,322 Tage, ergibt sich für den Präzessionszyklus eine Dauer von 27322 Jahren:
:<math>\frac {1 \text { d}} {13,1762^\circ} \cdot 1000 \frac {\text {a}} {\text {d}} \approx \frac {27,322 \text { d}} {360^\circ} \cdot 1000 \frac {\text {a}} {\text {d}} = \frac {27322 \text { a}} {360^\circ} </math>
Die Verschiebung des Frühlingspunktes seit dessen historischer Bestimmung anhand der Plejaden-Schaltregel in Mesopotamien um 2600 vor Christus sowie die Größe eines Mondhauses (respektive dessen Winkelbreite) sind dem Verfasser des 90. Psalms offensichtlich dem Betrag nach bekannt gewesen, denn er schreibt:
<blockquote>
90,4 Denn tausend Jahre sind in deinen Augen wie der Tag, der gestern vergangen ist, wie eine Wache in der Nacht.
</blockquote>
Im Neuen Testament wird dieser Psalmvers im dritten Kapitel des zweiten Petrusbriefes zitiert:
<blockquote>
3,8 Dies eine aber, Geliebte, soll euch nicht verborgen bleiben, dass beim Herrn ein Tag wie tausend Jahre und tausend Jahre wie ein Tag sind.
</blockquote>
Eine genauere Bestimmung der Wandergeschwindigkeit der Frühlingspunktes gelang erst im Jahr 1815 dem deutschen Astronomen '''Friedrich Wilhelm Bessel''' (1784–1846), der die astronomischen Beobachtungen aus den Sternenkatalogen von '''James Bradley''' (1692–1762) von 1755 und von '''Giuseppe Piazzi''' (1746–1826) von 1814 und insbesondere diejenigen des '''Polarsterns''' (Polaris) durch seine Berechnungen vergleichbar machte. Für seine „Untersuchung der Größe und des Einflusses des Vorrückens der Nachtgleichen“ wurde er von der Preußischen Akademie in Berlin ausgezeichnet.
→ Siehe hierzu auch: [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Der_Fixsternhimmel#Der_Polarstern|'''Der Polarstern''']].
In der folgenden Tabelle sind diese historischen Bestimmungen denen der Internationalen Astronomischen Union (IAU) aus dem Jahr 2006, die sich auf die Julianische Epoche J2000 bezieht, gegenübergestellt:<ref>Chengli Huang, Jia-Cheng Liu: [https://www.aanda.org/articles/aa/full_html/2025/11/aa57665-25/aa57665-25.html ''The IAU 2006 precession quantities with an improved Earth’s ''J''<sub>2</sub> long-term variation''], International Astronomical Union, 2006</ref><ref>[https://www.iausofa.org/2023-10-11c SOFA Library Issue 2023-10-11 for ANSI C], Standards of Fundamental Astronomy, 2023-10-11</ref>
{| class="wikitable"
|+ Bestimmung der lunisolaren Präzession
|'''Quelle'''
|'''Bezugsepoche'''
|'''Präzession<br/>für das Jahr'''
|'''Präzession in<br/>Bogensekunden<br/>pro Jahr'''
|'''Entsprechende Dauer<br/>einer Präzessionsperiode<br/>in Jahren'''
|-
| align="right" | Psalm 90 || align="center" | -2600 || align="center" | ≈ -1500 || align="center" | ≈ 48 "/a || align="center" | ≈ 27000 a
|-
| align="right" | Hipparch || align="center" | ≈ -280 || align="center" | ≈ -120 || align="center" | > 36 "/a || align="center" | < 36000 a
|-
| align="right" | Ptolemäus || align="center" | ≈ -280 || align="center" | ≈ 160 || align="center" | ≈ 36 "/a || align="center" | ≈ 36000 a
|-
| align="right" | Zij-i Ilkhani || align="center" | ≈ 1000 || align="center" | 1272 || align="center" | ≈ 51 "/a || align="center" | ≈ 25400 a
|-
| align="right" | Bessel || align="center" | 1755 || align="center" | 1755 || align="center" | 50,340 "/a || align="center" | 25745 a
|-
| align="right" | Bessel (Polarstern) || align="center" | 1750 || align="center" | 1810 || align="center" | 50,420 "/a || align="center" | 25704 a
|-
| align="right" | IAU 2006 || align="center" | J2000 || align="center" | -2600 || align="center" | 49,803 "/a || align="center" | 26023 a
|-
| align="right" | IAU 2006 || align="center" | J2000 || align="center" | -1500 || align="center" | 49,912 "/a || align="center" | 25966 a
|-
| align="right" | IAU 2006 || align="center" | J2000 || align="center" | 0 || align="center" | 50,069 "/a || align="center" | 25884 a
|-
| align="right" | IAU 2006 || align="center" | J2000 || align="center" | 1000 || align="center" | 50,178 "/a || align="center" | 25828 a
|-
| align="right" | IAU 2006 || align="center" | J2000 || align="center" | 1750 || align="center" | 50,260 "/a || align="center" | 25786 a
|-
| align="right" | IAU 2006 || align="center" | J2000 || align="center" | 1800 || align="center" | 50,266 "/a || align="center" | 25783 a
|-
| align="right" | IAU 2006 || align="center" | J2000 || align="center" | 1850 || align="center" | 50,271 "/a || align="center" | 25780 a
|-
| align="right" | IAU 2006 || align="center" | J2000 || align="center" | 1900 || align="center" | 50,277 "/a || align="center" | 25777 a
|-
| align="right" | IAU 2006 || align="center" | J2000 || align="center" | 1950 || align="center" | 50,282 "/a || align="center" | 25774 a
|-
| align="right" | IAU 2006 || align="center" | J2000 || align="center" | 2000 || align="center" | 50,288 "/a || align="center" | 25772 a
|-
| align="right" | IAU 2006 || align="center" | J2000 || align="center" | 2050 || align="center" | 50,293 "/a || align="center" | 25769 a
|-
| align="right" | IAU 2006 || align="center" | J2000 || align="center" | 2100 || align="center" | 50,299 "/a || align="center" | 25766 a
|}
=== Nutation ===
[[Datei:ToupieCycloide.ogv|mini|rechts|hochkant=2|Ein auf einer horizontalen i,j-Ebene schnell rotierender Kreisel erfährt eine langsame Präzessionsbewegung um die senkrechte k-Achse. Stimmt die Hauptträgheitsachse des rotierenden Körpers nicht exakt mit dessen Rotationsachse überein, kommt es gleichzeitig zu einer Nutation, bei der die Rotationsachse des Kreises kleinere Pendelbewegungen ausführt (schwarze Linie).]]
Da das Trägheitsmoment der Erde wegen der inhomogenen Massenverteilung und der Verschiebungen der Massen im Innern der Erde zeitlich nicht konstant ist, kann die Präzession der Erdrotationsachse auch heute nur empirisch bestimmt werden. Der Hauptteil der jährlichen Lunisolarpräzession wird durch die Sonne und den Mond hervorgerufen, deren Abstände von der Erde wegen der elliptischen Umlaufbahnen jedoch ebenfalls nicht konstant sind. Da der Mond in Bezug auf die Ekliptik permanent seine ekliptikale Breite ändert und seine auf- und absteigenden Knoten dabei innerhalb des drakonitischen Zyklus von 18,6 Jahren einmal vollständig auf der Ekliptiklinie herumwandern, ergibt sich die am deutlichsten erkennbare Schwankung der Präzession mit exakt dieser Periode, die auch als '''astronomische Nutation''' bezeichnet wird. Weitere, aber kleinere Störeinflüsse beruhen auf den Gravitationskräften der Planeten.
Siehe auch [[Die_Himmelstafel_von_Tal-Qadi/_Mondzyklen#Der_drakonitische_Zyklus|Kapitel '''Mondzyklen''' / Abschnitt '''Der drakonitische Zyklus''']].
<div style="clear:both"></div>
=== Eigenbewegung ===
[[Datei:Eigenbewegung.Stern.png|mini|hochkant=1.5|Der Beobachter B sieht in der Entfernung <math>d</math> einen Stern S, der sich mit der Tangentialgeschwindigkeit <math>v</math> relativ zu ihm bewegt. Der dabei resultierende Winkel <math>\mu</math> gibt die Winkelgeschwindigkeit der beobachteten Eigenbewegung des Sterns an.]]
Die Eigenbewegung beschreibt die von der Erde aus beobachtete Winkelgeschwindigkeit eines Sterns in Bezug auf das unbewegte äquatoriale Koordinatensystem zu einer astronomischen Epoche mit den beiden Sternkoordinaten Rektaszension <math>\alpha_0</math> und Deklination <math>\delta_0</math>. Die Winkelgeschwindigkeit <math>\mu</math> wird üblicherweise in Bogensekunden pro Jahr oder in Millibogensekunden pro Jahr (mas = milli arc seconds = Millibogensekunde) angegeben. Die Winkelgeschwindigkeit für ein Zeitintervall von einem Jahr (1 a, a für annum = Jahr) kann wegen der großen Entfernung <math>d \gg v \cdot 1 \text { a} </math> von der Erde mit guter Genauigkeit vereinfacht approximiert werden:
:<math>\mu = \arctan {\frac {v} {d}}
\approx \frac {v} {d} \cdot \frac {\text {360}^\circ} {2 \pi} \cdot \frac {\text {3600}^\shortparallel \,} {\text {1}^\circ}
= \frac {v} {d} \cdot \frac {1,296 \cdot 10^9 \text { mas}} {2 \pi}
\approx \frac {v} {d} \cdot 206,265 \cdot 10^6 \text { mas} = \frac {v} {d} \cdot \frac {\text {kpc} \cdot \text {mas}} {AE}</math>
Ein Parsec (pc) entspricht einem Abstand von 206.265 Astronomischen Einheiten (AE) beziehungsweise von 3,26 Lichtjahren. Bei diesem Abstand erscheint eine senkrecht zum Abstand gemessene Astronomische Einheit unter einem Winkel von einer Bogensekunde. Ein Kiloparsec (kpc) steht entsprechend für einen Abstand von 206.265.000 Astronomischen Einheiten (AE) beziehungsweise für 3260 Lichtjahre. Bei diesem Abstand erscheint eine senkrecht zum Abstand gemessene Astronomische Einheit nur noh unter einem Winkel von einer Millibogensekunde (mas).
Um die Auswirkung einfach auf die Sternkoordinaten übertragen zu können, werden oft für beide Koordinaten die orthogonalen Winkelgeschwindigkeiten <math>\mu_{Rekt}</math> und <math>\mu_{Dekl}</math> angegeben. Der Sternort zur Zeit <math>t</math> ergibt sich dann aus den einfachen Beziehungen:
:<math>\alpha(t) = \alpha_0 + \mu_{Rekt} \cdot t</math>
:<math>\delta(t) = \delta_0 + \mu_{Dekl} \cdot t</math>
Die erste Entfernungsmessung zu einem Fixstern gelang Friedrich Wilhelm Bessel (1784–1846) in den Jahren 1837 und 1838 beim gut elf Lichtjahre entfernten Stern 61 Cygni, der eine große Eigenbewegung von fünf Bogensekunden pro Jahr aufweist.
[[Datei:Barnard Star 2001-2010.gif|mini|links|Bewegung von Barnards Pfeilstern. Die vier Einzelbilder wurden im zeitlichen Abstand von jeweils drei Jahren aufgenommen.]]
Der Stern mit der größten Eigenbewegung ist der nur sechs Lichtjahre entfernte Barnards Pfeilstern, der sich mit gut zehn Bogensekunden pro Jahr rund doppelt so schnell wie 61 Cygni bewegt.
<div style="clear:both"></div>
== Einzelnachweise ==
<references></references>
tp5p8quppk9m2buw5scl8qbovpo0lil
PCRT
0
119055
1093554
1090337
2026-11-09T10:13:06Z
Pelikam
111447
/* Skript (vollständig) */
1093554
wikitext
text/x-wiki
[[Regal:Chemie|Regal Chemie]]
= Reversible Thermodynamik für die Zusammenarbeit von Mathematik-, Physik-, Chemie-, Ingenieur-Wissenschaften - PCRT =
= Skript Reversible Thermodynamik/Physikalische Chemie (vollständig) =
*{{Stage short|100%}}[[PCRT/I| PCRT (Physikalische Chemie/Reversible Thermodynamik) : Grundlagen I, Zustandsgleichungen, Erhaltungssätze, Bilanzgleichungen, Kreisprozesse eine Phase ein Stoff - PCRT/I]]
= Formelsammlung (nicht vollständig) =
*{{Stage short|25%}}[[CPRT| CPRT (Chemische Physik/Reversible Thermodynamik) : - CPRT]]
= Beispiele (keine Inhalt) =
*{{Stage short|25%}}[[CGRT/III| CGRT (Chemische Génie/Reversible Thermodynamik) : - CGRT/III]]
bx66d4fuz8akxreyup1yii0ck0a8xzy
1093555
1093554
2026-11-09T10:13:38Z
Pelikam
111447
/* Formelsammlung (nicht vollständig) */
1093555
wikitext
text/x-wiki
[[Regal:Chemie|Regal Chemie]]
= Reversible Thermodynamik für die Zusammenarbeit von Mathematik-, Physik-, Chemie-, Ingenieur-Wissenschaften - PCRT =
= Skript Reversible Thermodynamik/Physikalische Chemie (vollständig) =
*{{Stage short|100%}}[[PCRT/I| PCRT (Physikalische Chemie/Reversible Thermodynamik) : Grundlagen I, Zustandsgleichungen, Erhaltungssätze, Bilanzgleichungen, Kreisprozesse eine Phase ein Stoff - PCRT/I]]
= Skript Reversible Thermodynamik/Chemische Physik (nicht vollständig) =
*{{Stage short|25%}}[[CPRT| CPRT (Chemische Physik/Reversible Thermodynamik) : - CPRT]]
= Beispiele (keine Inhalt) =
*{{Stage short|25%}}[[CGRT/III| CGRT (Chemische Génie/Reversible Thermodynamik) : - CGRT/III]]
e62uro0h9fef5lxuocluorsvesnnk1m
1093556
1093555
2026-11-09T10:18:41Z
Pelikam
111447
/* Beispiele (keine Inhalt) */
1093556
wikitext
text/x-wiki
[[Regal:Chemie|Regal Chemie]]
= Reversible Thermodynamik für die Zusammenarbeit von Mathematik-, Physik-, Chemie-, Ingenieur-Wissenschaften - PCRT =
= Skript Reversible Thermodynamik/Physikalische Chemie (vollständig) =
*{{Stage short|100%}}[[PCRT/I| PCRT (Physikalische Chemie/Reversible Thermodynamik) : Grundlagen I, Zustandsgleichungen, Erhaltungssätze, Bilanzgleichungen, Kreisprozesse eine Phase ein Stoff - PCRT/I]]
= Skript Reversible Thermodynamik/Chemische Physik (nicht vollständig) =
*{{Stage short|25%}}[[CPRT| CPRT (Chemische Physik/Reversible Thermodynamik) : - CPRT]]
= Skript Reversible Thermodynamik/Chemische Technik (keine Inhalt) =
*{{Stage short|25%}}[[CGRT/III| CGRT (Chemische Génie/Reversible Thermodynamik) : - CGRT/III]]
cr9vn29vy1s5nien8xcwzz52shhovzg
1093557
1093556
2026-11-09T10:21:16Z
Pelikam
111447
/* Skript Reversible Thermodynamik/Physikalische Chemie (vollständig) */
1093557
wikitext
text/x-wiki
[[Regal:Chemie|Regal Chemie]]
= Reversible Thermodynamik für die Zusammenarbeit von Mathematik-, Physik-, Chemie-, Ingenieur-Wissenschaften - PCRT =
= Skript Reversible Thermodynamik/Phys.Chem. (vollständig) =
*{{Stage short|100%}}[[PCRT/I| PCRT (Physikalische Chemie/Reversible Thermodynamik) : Grundlagen I, Zustandsgleichungen, Erhaltungssätze, Bilanzgleichungen, Kreisprozesse eine Phase ein Stoff - PCRT/I]]
= Skript Reversible Thermodynamik/Chemische Physik (nicht vollständig) =
*{{Stage short|25%}}[[CPRT| CPRT (Chemische Physik/Reversible Thermodynamik) : - CPRT]]
= Skript Reversible Thermodynamik/Chemische Technik (keine Inhalt) =
*{{Stage short|25%}}[[CGRT/III| CGRT (Chemische Génie/Reversible Thermodynamik) : - CGRT/III]]
r4k99ocr9idsn5gojrpkmos2flbebfj
1093558
1093557
2026-11-09T10:22:14Z
Pelikam
111447
/* Skript Reversible Thermodynamik/Phys.Chem. (vollständig) */
1093558
wikitext
text/x-wiki
[[Regal:Chemie|Regal Chemie]]
= Reversible Thermodynamik für die Zusammenarbeit von Mathematik-, Physik-, Chemie-, Ingenieur-Wissenschaften - PCRT =
= Skript Rev.Thermo./Phys.Chem. (vollständig) =
*{{Stage short|100%}}[[PCRT/I| PCRT (Physikalische Chemie/Reversible Thermodynamik) : Grundlagen I, Zustandsgleichungen, Erhaltungssätze, Bilanzgleichungen, Kreisprozesse eine Phase ein Stoff - PCRT/I]]
= Skript Reversible Thermodynamik/Chemische Physik (nicht vollständig) =
*{{Stage short|25%}}[[CPRT| CPRT (Chemische Physik/Reversible Thermodynamik) : - CPRT]]
= Skript Reversible Thermodynamik/Chemische Technik (keine Inhalt) =
*{{Stage short|25%}}[[CGRT/III| CGRT (Chemische Génie/Reversible Thermodynamik) : - CGRT/III]]
p2i4bcu87mak31jegmq6ekl04h7fedd
1093559
1093558
2026-11-09T10:23:45Z
Pelikam
111447
/* Skript Rev.Thermo./Phys.Chem. (vollständig) */
1093559
wikitext
text/x-wiki
[[Regal:Chemie|Regal Chemie]]
= Reversible Thermodynamik für die Zusammenarbeit von Mathematik-, Physik-, Chemie-, Ingenieur-Wissenschaften - PCRT =
= Skript RT-PC (vollständig) =
*{{Stage short|100%}}[[PCRT/I| PCRT (Physikalische Chemie/Reversible Thermodynamik) : Grundlagen I, Zustandsgleichungen, Erhaltungssätze, Bilanzgleichungen, Kreisprozesse eine Phase ein Stoff - PCRT/I]]
= Skript Reversible Thermodynamik/Chemische Physik (nicht vollständig) =
*{{Stage short|25%}}[[CPRT| CPRT (Chemische Physik/Reversible Thermodynamik) : - CPRT]]
= Skript Reversible Thermodynamik/Chemische Technik (keine Inhalt) =
*{{Stage short|25%}}[[CGRT/III| CGRT (Chemische Génie/Reversible Thermodynamik) : - CGRT/III]]
gqg7dq13q18ky4fguuzxv3nea6argsf
1093560
1093559
2026-11-09T10:24:14Z
Pelikam
111447
/* Skript Reversible Thermodynamik/Chemische Physik (nicht vollständig) */
1093560
wikitext
text/x-wiki
[[Regal:Chemie|Regal Chemie]]
= Reversible Thermodynamik für die Zusammenarbeit von Mathematik-, Physik-, Chemie-, Ingenieur-Wissenschaften - PCRT =
= Skript RT-PC (vollständig) =
*{{Stage short|100%}}[[PCRT/I| PCRT (Physikalische Chemie/Reversible Thermodynamik) : Grundlagen I, Zustandsgleichungen, Erhaltungssätze, Bilanzgleichungen, Kreisprozesse eine Phase ein Stoff - PCRT/I]]
= Skript RT-CP (nicht vollständig) =
*{{Stage short|25%}}[[CPRT| CPRT (Chemische Physik/Reversible Thermodynamik) : - CPRT]]
= Skript Reversible Thermodynamik/Chemische Technik (keine Inhalt) =
*{{Stage short|25%}}[[CGRT/III| CGRT (Chemische Génie/Reversible Thermodynamik) : - CGRT/III]]
7qule96tgubu5as1gvd1u7yc6on3f0h
1093561
1093560
2026-11-09T10:25:28Z
Pelikam
111447
/* Skript Reversible Thermodynamik/Chemische Technik (keine Inhalt) */
1093561
wikitext
text/x-wiki
[[Regal:Chemie|Regal Chemie]]
= Reversible Thermodynamik für die Zusammenarbeit von Mathematik-, Physik-, Chemie-, Ingenieur-Wissenschaften - PCRT =
= Skript RT-PC (vollständig) =
*{{Stage short|100%}}[[PCRT/I| PCRT (Physikalische Chemie/Reversible Thermodynamik) : Grundlagen I, Zustandsgleichungen, Erhaltungssätze, Bilanzgleichungen, Kreisprozesse eine Phase ein Stoff - PCRT/I]]
= Skript RT-CP (nicht vollständig) =
*{{Stage short|25%}}[[CPRT| CPRT (Chemische Physik/Reversible Thermodynamik) : - CPRT]]
= Skript RT-ChemTech (keine Inhalt) =
*{{Stage short|25%}}[[CGRT/III| CGRT (Chemische Génie/Reversible Thermodynamik) : - CGRT/III]]
gf3pxxsq9dsmmsp9zdmp521wxik37cf
1093562
1093561
2026-11-09T10:25:53Z
Pelikam
111447
/* Skript RT-CP (nicht vollständig) */
1093562
wikitext
text/x-wiki
[[Regal:Chemie|Regal Chemie]]
= Reversible Thermodynamik für die Zusammenarbeit von Mathematik-, Physik-, Chemie-, Ingenieur-Wissenschaften - PCRT =
= Skript RT-PC (vollständig) =
*{{Stage short|100%}}[[PCRT/I| PCRT (Physikalische Chemie/Reversible Thermodynamik) : Grundlagen I, Zustandsgleichungen, Erhaltungssätze, Bilanzgleichungen, Kreisprozesse eine Phase ein Stoff - PCRT/I]]
= Skript RT-ChemPhys (nicht vollständig) =
*{{Stage short|25%}}[[CPRT| CPRT (Chemische Physik/Reversible Thermodynamik) : - CPRT]]
= Skript RT-ChemTech (keine Inhalt) =
*{{Stage short|25%}}[[CGRT/III| CGRT (Chemische Génie/Reversible Thermodynamik) : - CGRT/III]]
06nb7d0qq68wqmqahh6b3ttu98p8aff
1093563
1093562
2026-11-09T10:26:42Z
Pelikam
111447
/* Skript RT-PC (vollständig) */
1093563
wikitext
text/x-wiki
[[Regal:Chemie|Regal Chemie]]
= Reversible Thermodynamik für die Zusammenarbeit von Mathematik-, Physik-, Chemie-, Ingenieur-Wissenschaften - PCRT =
= Skript RThermo-PhysChem (vollständig) =
*{{Stage short|100%}}[[PCRT/I| PCRT (Physikalische Chemie/Reversible Thermodynamik) : Grundlagen I, Zustandsgleichungen, Erhaltungssätze, Bilanzgleichungen, Kreisprozesse eine Phase ein Stoff - PCRT/I]]
= Skript RT-ChemPhys (nicht vollständig) =
*{{Stage short|25%}}[[CPRT| CPRT (Chemische Physik/Reversible Thermodynamik) : - CPRT]]
= Skript RT-ChemTech (keine Inhalt) =
*{{Stage short|25%}}[[CGRT/III| CGRT (Chemische Génie/Reversible Thermodynamik) : - CGRT/III]]
42ste9rq6hp1semwsyposwa0s61da59
1093564
1093563
2026-11-09T10:27:32Z
Pelikam
111447
/* Skript RThermo-PhysChem (vollständig) */
1093564
wikitext
text/x-wiki
[[Regal:Chemie|Regal Chemie]]
= Reversible Thermodynamik für die Zusammenarbeit von Mathematik-, Physik-, Chemie-, Ingenieur-Wissenschaften - PCRT =
= Skript RevThermo-PhysChem (vollständig) =
*{{Stage short|100%}}[[PCRT/I| PCRT (Physikalische Chemie/Reversible Thermodynamik) : Grundlagen I, Zustandsgleichungen, Erhaltungssätze, Bilanzgleichungen, Kreisprozesse eine Phase ein Stoff - PCRT/I]]
= Skript RT-ChemPhys (nicht vollständig) =
*{{Stage short|25%}}[[CPRT| CPRT (Chemische Physik/Reversible Thermodynamik) : - CPRT]]
= Skript RT-ChemTech (keine Inhalt) =
*{{Stage short|25%}}[[CGRT/III| CGRT (Chemische Génie/Reversible Thermodynamik) : - CGRT/III]]
mobtzdsxyp1vrkl4p6svpp2xpzs9w4v
1093565
1093564
2026-11-09T10:27:51Z
Pelikam
111447
/* Skript RT-ChemPhys (nicht vollständig) */
1093565
wikitext
text/x-wiki
[[Regal:Chemie|Regal Chemie]]
= Reversible Thermodynamik für die Zusammenarbeit von Mathematik-, Physik-, Chemie-, Ingenieur-Wissenschaften - PCRT =
= Skript RevThermo-PhysChem (vollständig) =
*{{Stage short|100%}}[[PCRT/I| PCRT (Physikalische Chemie/Reversible Thermodynamik) : Grundlagen I, Zustandsgleichungen, Erhaltungssätze, Bilanzgleichungen, Kreisprozesse eine Phase ein Stoff - PCRT/I]]
= Skript RevThermo-ChemPhys (nicht vollständig) =
*{{Stage short|25%}}[[CPRT| CPRT (Chemische Physik/Reversible Thermodynamik) : - CPRT]]
= Skript RT-ChemTech (keine Inhalt) =
*{{Stage short|25%}}[[CGRT/III| CGRT (Chemische Génie/Reversible Thermodynamik) : - CGRT/III]]
qj15soa5j04r9w4ynmdj0s4rdbf3mky
1093566
1093565
2026-11-09T10:28:26Z
Pelikam
111447
/* Skript RT-ChemTech (keine Inhalt) */
1093566
wikitext
text/x-wiki
[[Regal:Chemie|Regal Chemie]]
= Reversible Thermodynamik für die Zusammenarbeit von Mathematik-, Physik-, Chemie-, Ingenieur-Wissenschaften - PCRT =
= Skript RevThermo-PhysChem (vollständig) =
*{{Stage short|100%}}[[PCRT/I| PCRT (Physikalische Chemie/Reversible Thermodynamik) : Grundlagen I, Zustandsgleichungen, Erhaltungssätze, Bilanzgleichungen, Kreisprozesse eine Phase ein Stoff - PCRT/I]]
= Skript RevThermo-ChemPhys (nicht vollständig) =
*{{Stage short|25%}}[[CPRT| CPRT (Chemische Physik/Reversible Thermodynamik) : - CPRT]]
= Skript RevThermo-ChemTechGenie (keine Inhalt) =
*{{Stage short|25%}}[[CGRT/III| CGRT (Chemische Génie/Reversible Thermodynamik) : - CGRT/III]]
i9506dk2f9vj8llw5y2ioaq9gbxyhsn
1093567
1093566
2026-11-09T10:29:11Z
Pelikam
111447
/* Skript RevThermo-ChemTechGenie (keine Inhalt) */
1093567
wikitext
text/x-wiki
[[Regal:Chemie|Regal Chemie]]
= Reversible Thermodynamik für die Zusammenarbeit von Mathematik-, Physik-, Chemie-, Ingenieur-Wissenschaften - PCRT =
= Skript RevThermo-PhysChem (vollständig) =
*{{Stage short|100%}}[[PCRT/I| PCRT (Physikalische Chemie/Reversible Thermodynamik) : Grundlagen I, Zustandsgleichungen, Erhaltungssätze, Bilanzgleichungen, Kreisprozesse eine Phase ein Stoff - PCRT/I]]
= Skript RevThermo-ChemPhys (nicht vollständig) =
*{{Stage short|25%}}[[CPRT| CPRT (Chemische Physik/Reversible Thermodynamik) : - CPRT]]
= Skript RevThermo-ChemTechgenie (keine Inhalt) =
*{{Stage short|25%}}[[CGRT/III| CGRT (Chemische Génie/Reversible Thermodynamik) : - CGRT/III]]
0bp0he9ytvsj7taq5dwgeeh2jp23lpd
1093568
1093567
2026-11-09T10:29:36Z
Pelikam
111447
/* Skript RevThermo-ChemTechgenie (keine Inhalt) */
1093568
wikitext
text/x-wiki
[[Regal:Chemie|Regal Chemie]]
= Reversible Thermodynamik für die Zusammenarbeit von Mathematik-, Physik-, Chemie-, Ingenieur-Wissenschaften - PCRT =
= Skript RevThermo-PhysChem (vollständig) =
*{{Stage short|100%}}[[PCRT/I| PCRT (Physikalische Chemie/Reversible Thermodynamik) : Grundlagen I, Zustandsgleichungen, Erhaltungssätze, Bilanzgleichungen, Kreisprozesse eine Phase ein Stoff - PCRT/I]]
= Skript RevThermo-ChemPhys (nicht vollständig) =
*{{Stage short|25%}}[[CPRT| CPRT (Chemische Physik/Reversible Thermodynamik) : - CPRT]]
= Skript RevThermo-ChemTech (keine Inhalt) =
*{{Stage short|25%}}[[CGRT/III| CGRT (Chemische Génie/Reversible Thermodynamik) : - CGRT/III]]
2e5w9krrwtm4lc7vleo23cuqow24lsz
CPRT
0
119061
1093569
1093469
2026-11-09T10:30:10Z
Pelikam
111447
/* Formelsammlung - CPRT */
1093569
wikitext
text/x-wiki
[[PCRT|< Reversible Thermodynamik für die Zusammenarbeit von Mathematik-, Physik-, Chemie-, Ingenieur-Wissenschaften - PCRT]]
== 0. Ein Wort an evtl. Co-Autor:innen: ==
CPRT ist gerade in der Entstehung. Er hat ein bestimmtes Konzept. Dieses Konzept hat sich das Autorenkollektiv Pelikam
ausgedacht. Bitte lasst CPRT erstmal soweit wachsen, bis das Konzept fertig ist.
Das Konzept ist ab jetzt (09-2026) in ca. 9 Monaten (06-2027) fertig, bzw. CPRT ist nach den Vorstellungen von Autorenkollektiv Pelikam dann zu 80% fertig. SOLANGE BITTE NICHTS REINSCHREIBEN. ANREGUNGEN, GEWÜNSCHTE TEXTBAUSTEINE, FEHLER , GEWÜNSCHTE MITARBEIT, EIGENE ZIELSETZUNGEN etc. BITTE IN DISKUSSION (s.o.) EINTRAGEN. CPRT beruht im wesentlichen auf Formeln.
DANKE Autorenkollektiv Pelikam (CPRT sticht ca. Mitte 2027 in den See, dann können alle Autor:innen, die dazu etwas beitragen möchten hineinschreiben. Auch dann wäre Pelikam dankbar, wenn der Geist von CPRT, das Didaktikkonzept erst aufgenommen wird und dann die eigenen Beiträge hinzugefügt werden. Sollte eigentlich kein Problem sein.
Stand: 09-2026
= Skript - CPRT =
= Inhaltsverzeichnis =
*{{Stage short|25%}}[[CPRT/56cd| Einleitung zur 1. Auflage - CPRT/56cd]]
= Teil A: Zustandsfunktionen und Differentiale der Energie =
*{{Stage short|100%}}[[CPRT/cf51| Zustandsfunktionen und ihre Differentiale in ihren (eigenen) natürlichen Variablen - CPRT/cf51]]
*{{Stage short|100%}}[[CPRT/2276| Energien E, F, G, H, L, K, J, I im Koordinatensystem (N,S,V) - CPRT/2276]]
*{{Stage short|25%}}[[CPRT/ea92| Energien F, G, H, L, K, J, I, E im Koordinatensystem (N,t,V) - CPRT/ea92]]
*{{Stage short|25%}}[[CPRT/e631| Energien G, H, L, K, J, I, E, F im Koordinatensystem (N,t,p) - CPRT/e631]]
*{{Stage short|25%}}[[CPRT/d456| Energien H, L, K, J, I, E, F, G im Koordinatensystem (N,S,p) - CPRT/d456]]
*{{Stage short|25%}}[[CPRT/fb6d| Energien L, K, J, I, E, F, G, H im Koordinatensystem (<math>\mu</math>,S,p) - CPRT/fb6d]]
*{{Stage short|25%}}[[CPRT/f189| Energien K, L, J, I, E, F, G, H im Koordinatensystem (<math>\mu</math>,t,p) - CPRT/f189]]
*{{Stage short|25%}}[[CPRT/19f0| Energien J, I, E, F, G, H, L, K im Koordinatensystem (<math>\mu</math>,t,V) - CPRT/19f0]]
*{{Stage short|25%}}[[CPRT/6221| Energien I, E, F, G, H, L, K, J im Koordinatensystem (<math>\mu</math>,S,V) - CPRT/6221]]
= Teil B: Erhaltungssätze und Bilanzgleichungen =
*{{Stage short|25%}}[[CPRT/53b5| Stoffbezogene Grössen - CPRT/53b5]]
= Teil C: Kreisprozesse eines idealen Gases =
== Freie Unterverzeichnisse ==
*{{Stage short|25%}}[[CPRT/69db| - CPRT/69db]]
*{{Stage short|25%}}[[CPRT/20a9| - CPRT/20a9]]
*{{Stage short|25%}}[[CPRT/2a93| - CPRT/2a93]]
*{{Stage short|25%}}[[CPRT/2a1f| - CPRT/2a1f]]
*{{Stage short|25%}}[[CPRT/e6eb| - CPRT/e6eb]]
rb52p8a9w7kcm5p9119nbdo66i92wd1
CPRT/cef7
0
119065
1093571
1093488
2026-11-09T10:34:10Z
Pelikam
111447
/* Gleichgewicht */
1093571
wikitext
text/x-wiki
[[CPRT/2276|< Energien E, F, G, H, L, K, J, I im Koordinatensystem (N,S,V) - CPRT/2276]]
== Energie E (Bezugssystem) ==
== Gleichgewicht ==
{|
|-
|| <math> (01)\quad </math>
|| <math> dE(N,S,V) </math>||<math> = </math>
|| <math> +\,\mu\,dN </math>||<math> +\,t\,dS </math>||<math> +\,p\,dV </math>
|-
|| <math> (02)\quad </math>
|| <math> E(N,S,V) </math>||<math> = </math>
|| <math> +\,\mu\,N </math>||<math> +\,t\,S </math>||<math> +\,p\,V </math>
|-
|| <math> (02)\quad </math>
|| <math> dE(N,S,V) </math>||<math> = </math>
|| <math> +\,dN\frac{\partial E}{\partial N} </math>||<math> +\,dS\frac{\partial E}{\partial S} </math>
|| <math> +\,dV\frac{\partial E}{\partial V} </math>
|-
|| <math> (03)\quad </math>
|| <math> 0\,(N,S,V) </math>||<math> = </math>
|| <math> +\,N\frac{\partial \mu}{\partial N} </math>||<math> +\,S\frac{\partial \mu}{\partial S} </math>
|| <math> +\,V\frac{\partial \mu}{\partial V} </math>
|-
|| <math> (04)\quad </math>
|| <math> 0\,(N,S,V) </math>||<math> = </math>
|| <math> +\,N\,\frac{\partial t}{\partial N} </math>||<math> +\,S\,\frac{\partial t}{\partial S} </math>
|| <math> +\,V\,\frac{\partial t}{\partial V} </math>
|-
|| <math> (05)\quad </math>
|| <math> 0\,(N,S,V) </math>||<math> = </math>
|| <math> +\,N\frac{\partial p}{\partial N} </math>||<math> +\,S\frac{\partial p}{\partial S} </math>
|| <math> +\,V\frac{\partial p}{\partial V} </math>
|-
|| <math> (06)\quad </math>
|| <math> 0\,(N,S,V) </math>||<math> = </math>
|| <math> -\,N\,d\mu </math>||<math> -\,S\,dt </math>||<math> -\,V\,dp </math>
|-
|| <math> (07)\quad </math>
|| <math> 0\,(N,S,V) </math>||<math> = </math>
|| <math> +\,N\frac{\partial \,dE}{\partial N} </math>||<math> +\,S\frac{\partial \,dE}{\partial S} </math>
|| <math> +\,V\frac{\partial \,dE}{\partial V} \neq dE(N,S,V) </math>
|}
== Stabilität ==
{|
|-
|| <math> (08)\quad </math>
|| <math> d^2 E </math>||<math> = </math>
|| <math> +\frac{\partial \mu}{\partial N}\,(dN)^2 + \frac{\partial t}{\partial S}\,(dS)^2
+\frac{\partial (-p)}{\partial V}\,(dV)^2 </math>
|-
|| <math> \quad\quad </math>
|| <math> </math>||<math> </math>
|| <math> + \left(\frac{\partial \mu}{\partial S} + \frac{\partial t}{\partial N}\right)dN\,dS
+ \left(\frac{\partial \mu}{\partial V} + \frac{\partial (-p)}{\partial N}\right)dN\,dV
+ \left(\frac{\partial t}{\partial V} + \frac{\partial (-p)}{\partial S}\right)dS\,dV \ge 0 </math>
|}
{|
|-
|| <math> (09)\quad </math>
|| <math> \frac{\partial \mu}{\partial N} \ge 0\,,\quad \frac{\partial t}{\partial S} \ge 0\,,\quad
\frac{\partial (-p)}{\partial V} \ge 0\,,\quad
\left(\frac{\partial \mu}{\partial N}\right)\left(\frac{\partial t}{\partial S}\right)
- \left(\frac{\partial \mu}{\partial S}\right)\left(\frac{\partial t}{\partial N}\right) \ge 0 </math>
|-
|| <math> \quad\quad </math>
|| <math> \left(\frac{\partial \mu}{\partial N}\right)\left(\frac{\partial (-p)}{\partial V}\right)
- \left(\frac{\partial \mu}{\partial V}\right)\left(\frac{\partial (-p)}{\partial N}\right) \ge 0\,,\quad
\left(\frac{\partial t}{\partial S}\right)\left(\frac{\partial (-p)}{\partial V}\right)
- \left(\frac{\partial t}{\partial V}\right)\left(\frac{\partial (-p)}{\partial S}\right) \ge 0 </math>
|}
== Herleitungen Energie E ==
{|
|-
|| <math> (01)\quad </math>
|| <math> dE(N,S,V) </math>||<math> = </math>
|| <math> +\,\mu\,dN + t\,dS + p\,d(-V) </math>
|-
|| <math> \quad\quad </math>
|| <math> </math>||<math> = </math>
|| <math> +\,\frac{\partial E}{\partial N} dN
+ \frac{\partial E}{\partial S} dS
+ \frac{\partial E}{\partial V} dV </math>
|-
|| <math> \quad\quad </math>
|| <math> </math>||<math> = </math>
|| <math> +\,dN\frac{\partial E}{\partial N}
+ dS\frac{\partial E}{\partial S}
+ dV\frac{\partial E}{\partial V} </math>
|-
|| <math> \quad\quad </math>
|| <math> </math>||<math> = </math>
|| <math> +\,dN\,\mu + dS\,t + d(-V)\,p </math>
|-
|| <math> \quad\quad </math>
|| <math> \frac{\partial}{\partial N}\left(dN \frac{\partial E}{\partial N}\right)</math>||<math> = </math>
|| <math> dN\frac{\partial }{\partial N}\frac{\partial E}{\partial N},\quad
\frac{\partial}{\partial N}\left(dN\right) = d\frac{\partial N}{\partial N} = d(1) = 0\quad (N,S,V) </math>
|-
|| <math> \quad\quad </math>
|| <math> d\mu(N,S,V) </math>||<math> = </math>
|| <math> +\,d\frac{\partial E}{\partial N} \neq 0 </math>
|-
|| <math> \quad\quad </math>
|| <math> </math>||<math> = </math>
|| <math> +\,dN\frac{\partial}{\partial N}\frac{\partial E}{\partial N}
+ dS\frac{\partial}{\partial S}\frac{\partial E}{\partial N}
+ dV\frac{\partial}{\partial V}\frac{\partial E}{\partial N} </math>
|-
|| <math> \quad\quad </math>
|| <math> </math>||<math> = </math>
|| <math> +\,dN\frac{\partial}{\partial N}\frac{\partial E}{\partial N}
+ dS\frac{\partial}{\partial N}\frac{\partial E}{\partial S}
+ dV\frac{\partial}{\partial N}\frac{\partial E}{\partial V} </math>
|-
|| <math> \quad\quad </math>
|| <math> </math>||<math> = </math>
|| <math> +\,\frac{\partial}{\partial N}\left(dN\frac{\partial E}{\partial N}\right)
+ \frac{\partial}{\partial N}\left(dS\frac{\partial E}{\partial S}\right)
+ \frac{\partial}{\partial N}\left(dV\frac{\partial E}{\partial V}\right) </math>
|-
|| <math> \quad\quad </math>
|| <math> </math>||<math> = </math>
|| <math> +\,\frac{\partial}{\partial N} dE \neq 0 </math>
|-
|| <math> \quad\quad </math>
|| <math> \frac{\partial}{\partial S}\left(dS \frac{\partial E}{\partial S}\right)</math>||<math> = </math>
|| <math> dS\frac{\partial }{\partial S}\frac{\partial E}{\partial S},\quad
\frac{\partial}{\partial S}\left(dS\right) = d\frac{\partial S}{\partial S} = d(1) = 0\quad (N,S,V) </math>
|-
|| <math> \quad\quad </math>
|| <math> dt(N,S,V) </math>||<math> = </math>
|| <math> +\,d\frac{\partial E}{\partial S} \neq 0 </math>
|-
|| <math> \quad\quad </math>
|| <math> </math>||<math> = </math>
|| <math> +\,dN\frac{\partial}{\partial N}\frac{\partial E}{\partial S}
+ dS\frac{\partial}{\partial S}\frac{\partial E}{\partial S}
+ dV\frac{\partial}{\partial V}\frac{\partial E}{\partial S} </math>
|-
|| <math> \quad\quad </math>
|| <math> </math>||<math> = </math>
|| <math> +\,dN\frac{\partial}{\partial S}\frac{\partial E}{\partial N}
+ dS\frac{\partial}{\partial S}\frac{\partial E}{\partial S}
+ dV\frac{\partial}{\partial S}\frac{\partial E}{\partial V} </math>
|-
|| <math> \quad\quad </math>
|| <math> </math>||<math> = </math>
|| <math> +\,\frac{\partial}{\partial S}\left(dN\frac{\partial E}{\partial N}\right)
+ \frac{\partial}{\partial S}\left(dS\frac{\partial E}{\partial S}\right)
+ \frac{\partial}{\partial S}\left(dV\frac{\partial E}{\partial V}\right) </math>
|-
|| <math> \quad\quad </math>
|| <math> </math>||<math> = </math>
|| <math> +\,\frac{\partial}{\partial S} dE \neq 0 </math>
|-
|| <math> \quad\quad </math>
|| <math> \frac{\partial}{\partial V}\left(dV \frac{\partial E}{\partial V}\right)</math>||<math> = </math>
|| <math> dV\frac{\partial }{\partial V}\frac{\partial E}{\partial V},\quad
\frac{\partial}{\partial V}\left(dV\right) = d\frac{\partial V}{\partial V} = d(1) = 0\quad (N,S,V) </math>
|-
|| <math> \quad\quad </math>
|| <math> dp(N,S,V) </math>||<math> = </math>
|| <math> +\,d\frac{\partial E}{\partial (-V)} \neq 0 </math>
|-
|| <math> \quad\quad </math>
|| <math> </math>||<math> = </math>
|| <math> +\,dN\frac{\partial}{\partial N}\frac{\partial E}{\partial (-V)}
+ dS\frac{\partial}{\partial S}\frac{\partial E}{\partial (-V)}
+ dV\frac{\partial}{\partial V}\frac{\partial E}{\partial (-V)} </math>
|-
|| <math> \quad\quad </math>
|| <math> </math>||<math> = </math>
|| <math> -\,dN\frac{\partial}{\partial N}\frac{\partial E}{\partial V}
- dS\frac{\partial}{\partial S}\frac{\partial E}{\partial V}
- dV\frac{\partial}{\partial V}\frac{\partial E}{\partial V} </math>
|-
|| <math> \quad\quad </math>
|| <math> </math>||<math> = </math>
|| <math> -\,dN\frac{\partial}{\partial V}\frac{\partial E}{\partial N}
- dS\frac{\partial}{\partial V}\frac{\partial E}{\partial S}
- dV\frac{\partial}{\partial V}\frac{\partial E}{\partial V} </math>
|-
|| <math> \quad\quad </math>
|| <math> </math>||<math> = </math>
|| <math> -\,\frac{\partial}{\partial V}\left(dN\frac{\partial E}{\partial N}\right)
- \frac{\partial}{\partial V}\left(dS\frac{\partial E}{\partial S}\right)
- \frac{\partial}{\partial V}\left(dV\frac{\partial E}{\partial V}\right) </math>
|-
|| <math> \quad\quad </math>
|| <math> </math>||<math> = </math>
|| <math> -\,\frac{\partial}{\partial V} dE </math>
|-
|| <math> \quad\quad </math>
|| <math> </math>||<math> = </math>
|| <math> +\,\frac{\partial}{\partial (-V)} dE \neq 0 </math>
|-
|| <math> (02)\quad </math>
|| <math> E(N,S,V) </math>||<math> = </math>
|| <math> +\,\mu\,N + t\,S + p\,(-V) </math>
|-
|| <math> \quad\quad </math>
|| <math> </math>||<math> = </math>
|| <math> +\,\frac{\partial E}{\partial N}\,N
+ \frac{\partial E}{\partial S}\,S
+ \frac{\partial E}{\partial V}\,V </math>
|-
|| <math> \quad\quad </math>
|| <math> </math>||<math> = </math>
|| <math> +\,N\,\frac{\partial E}{\partial N}
+ S\,\frac{\partial E}{\partial S}
+ V\,\frac{\partial E}{\partial V} </math>
|-
|| <math> \quad\quad </math>
|| <math> </math>||<math> = </math>
|| <math> +\,N\,\mu + S\,t + (-V)\,p </math>
|-
|| <math> \quad\quad </math>
|| <math> \frac{\partial}{\partial N}\left(N \frac{\partial E}{\partial N}\right)</math>||<math> = </math>
|| <math> \frac{\partial E}{\partial N} + N\frac{\partial }{\partial N}\frac{\partial E}{\partial N}\quad (N,S,V) </math>
|-
|| <math> (03)\quad </math>
|| <math> 0\,(N,S,V) </math>||<math> = </math>
|| <math> +\,N\frac{\partial \mu}{\partial N}
+ S\frac{\partial \mu}{\partial S}
+ V\frac{\partial \mu}{\partial V} </math>
|-
|| <math> \quad\quad </math>
|| <math> </math>||<math> = </math>
|| <math> +\,N\frac{\partial}{\partial N}\frac{\partial E}{\partial N}
+ S\frac{\partial}{\partial S}\frac{\partial E}{\partial N}
+ V\frac{\partial}{\partial V}\frac{\partial E}{\partial N} </math>
|-
|| <math> \quad\quad </math>
|| <math> </math>||<math> = </math>
|| <math> +\,N\frac{\partial}{\partial N}\frac{\partial E}{\partial N}
+ S\frac{\partial}{\partial N}\frac{\partial E}{\partial S}
+ V\frac{\partial}{\partial N}\frac{\partial E}{\partial V} </math>
|-
|| <math> \quad\quad </math>
|| <math> </math>||<math> = </math>
|| <math> +\,\frac{\partial}{\partial N}\left(N\frac{\partial E}{\partial N}\right)
+ \frac{\partial}{\partial N}\left(S\frac{\partial E}{\partial S}\right)
+ \frac{\partial}{\partial N}\left(V\frac{\partial E}{\partial V}\right)
- \frac{\partial E}{\partial N} </math>
|-
|| <math> \quad\quad </math>
|| <math> </math>||<math> = </math>
|| <math> +\,\frac{\partial E}{\partial N}
- \frac{\partial E}{\partial N} </math>
|-
|| <math> \quad\quad </math>
|| <math> </math>||<math> = </math>
|| <math> +\,\mu - \mu = 0 </math>
|-
|| <math> \quad\quad </math>
|| <math> \frac{\partial}{\partial S}\left(S \frac{\partial E}{\partial S}\right)</math>||<math> = </math>
|| <math> \frac{\partial E}{\partial S} + S\frac{\partial }{\partial S}\frac{\partial E}{\partial S}\quad (N,S,V) </math>
|-
|| <math> (04)\quad </math>
|| <math> 0\,(N,S,V) </math>||<math> = </math>
|| <math> +\,N\,\frac{\partial t}{\partial N}
+ S\,\frac{\partial t}{\partial S}
+ V\,\frac{\partial t}{\partial V} </math>
|-
|| <math> \quad\quad </math>
|| <math> </math>||<math> = </math>
|| <math> +\,N\,\frac{\partial}{\partial N}\frac{\partial E}{\partial S}
+ S\,\frac{\partial}{\partial S}\frac{\partial E}{\partial S}
+ V\,\frac{\partial}{\partial V}\frac{\partial E}{\partial S} </math>
|-
|| <math> \quad\quad </math>
|| <math> </math>||<math> = </math>
|| <math> +\,N\,\frac{\partial}{\partial S}\frac{\partial E}{\partial N}
+ S\,\frac{\partial}{\partial S}\frac{\partial E}{\partial S}
+ V\,\frac{\partial}{\partial S}\frac{\partial E}{\partial V} </math>
|-
|| <math> \quad\quad </math>
|| <math> </math>||<math> = </math>
|| <math> +\,\frac{\partial}{\partial S}\left(N\frac{\partial E}{\partial N}\right)
+ \frac{\partial}{\partial S}\left(S\frac{\partial E}{\partial S}\right)
+ \frac{\partial}{\partial S}\left(V\frac{\partial E}{\partial V}\right)
- \frac{\partial E}{\partial S} </math>
|-
|| <math> \quad\quad </math>
|| <math> </math>||<math> = </math>
|| <math> +\,\frac{\partial E}{\partial S}
- \frac{\partial E}{\partial S} </math>
|-
|| <math> \quad\quad </math>
|| <math> </math>||<math> = </math>
|| <math> +\,t - t = 0 </math>
|-
|| <math> \quad\quad </math>
|| <math> \frac{\partial}{\partial V}\left(V \frac{\partial E}{\partial V}\right) </math>||<math> = </math>
|| <math> \frac{\partial E}{\partial V} + V\frac{\partial }{\partial V}\frac{\partial E}{\partial V}\quad (N,S,V) </math>
|-
|| <math> (05)\quad </math>
|| <math> 0\,(N,S,V) </math>||<math> = </math>
|| <math> +\,N\frac{\partial p}{\partial N}
+ S\frac{\partial p}{\partial S}
+ V\frac{\partial p}{\partial V} </math>
|-
|| <math> \quad\quad </math>
|| <math> </math>||<math> = </math>
|| <math> +\,N\frac{\partial}{\partial N}\frac{\partial E}{\partial (-V)}
+ S\frac{\partial}{\partial S}\frac{\partial E}{\partial (-V)}
+ V\frac{\partial}{\partial V}\frac{\partial E}{\partial (-V)} </math>
|-
|| <math> \quad\quad </math>
|| <math> </math>||<math> = </math>
|| <math> -\,N\frac{\partial}{\partial N}\frac{\partial E}{\partial V}
- S\frac{\partial}{\partial S}\frac{\partial E}{\partial V}
- V\frac{\partial}{\partial V}\frac{\partial E}{\partial V} </math>
|-
|| <math> \quad\quad </math>
|| <math> </math>||<math> = </math>
|| <math> -\,N\frac{\partial}{\partial V}\frac{\partial E}{\partial N}
- S\frac{\partial}{\partial V}\frac{\partial E}{\partial S}
- V\frac{\partial}{\partial V}\frac{\partial E}{\partial V} </math>
|-
|| <math> \quad\quad </math>
|| <math> </math>||<math> = </math>
|| <math> -\,\frac{\partial}{\partial V}\left(N\frac{\partial E}{\partial N}\right)
- \frac{\partial}{\partial V}\left(S\frac{\partial E}{\partial S}\right)
- \frac{\partial}{\partial V}\left(V\frac{\partial E}{\partial V}\right)
+ \frac{\partial E}{\partial V} </math>
|-
|| <math> \quad\quad </math>
|| <math> </math>||<math> = </math>
|| <math> -\,\frac{\partial E}{\partial V}
+ \frac{\partial E}{\partial V} </math>
|-
|| <math> \quad\quad </math>
|| <math> </math>||<math> = </math>
|| <math> +\,\frac{\partial E}{\partial (-V)}
- \frac{\partial E}{\partial (-V)} </math>
|-
|| <math> \quad\quad </math>
|| <math> </math>||<math> = </math>
|| <math> +\,p - p = 0 </math>
|-
|| <math> (06)\quad </math>
|| <math> 0\,(N,S,V) </math>||<math> = </math>
|| <math> -\,N\,d\mu - S\,dt - V\,d(-p) </math>
|-
|| <math> \quad\quad </math>
|| <math> </math>||<math> = </math>
|| <math> -\,N\,d\frac{\partial E}{\partial N}
- S\,d\frac{\partial E}{\partial S}
- V\,d\frac{\partial E}{\partial V} </math>
|-
|| <math> \quad\quad </math>
|| <math> </math>||<math> = </math>
|| <math> -\,d\left(N\frac{\partial E}{\partial N}\right)
- d\left(S\frac{\partial E}{\partial S}\right)
- d\left(V\frac{\partial E}{\partial V}\right) </math>
|-
|| <math> \quad\quad </math>
|| <math> </math>||<math> </math>
|| <math> +\,\frac{\partial E}{\partial N} dN
+ \frac{\partial E}{\partial S} dS
+ \frac{\partial E}{\partial V} dV </math>
|-
|| <math> \quad\quad </math>
|| <math> </math>||<math> = </math>
|| <math> -\,dE + dE = 0 </math>
|-
|| <math> (07)\quad </math>
|| <math> 0\,(N,S,V) </math>||<math> = </math>
|| <math> +\,N\frac{\partial \,dE}{\partial N}
+ S\frac{\partial \,dE}{\partial S}
+ V\frac{\partial \,dE}{\partial V} \neq dE(N,S,V) </math>
|-
|| <math> \quad\quad </math>
|| <math> </math>||<math> = </math>
|| <math> +\,N\,d\frac{\partial E}{\partial N}
+ S\,d\frac{\partial E}{\partial S}
+ V\,d\frac{\partial E}{\partial V} </math>
|-
|| <math> \quad\quad </math>
|| <math> </math>||<math> = </math>
|| <math> +\,N\,d\mu + S\,dt + V\,d(-p) = 0 </math>
|}
{|
|-
|| <math> (08)\quad </math>
|| <math> d^2 E </math>||<math> = </math>
|| <math> +\frac{\partial^2 E}{\partial N^2}\,(dN)^2 + \frac{\partial^2 E}{\partial S^2}\,(dS)^2
+\frac{\partial^2 E}{\partial V^2}\,(dV)^2 </math>
|-
|| <math> \quad\quad </math>
|| <math> </math>||<math> </math>
|| <math> + \left(\frac{\partial^2 E}{\partial N\partial S}+\frac{\partial^2 E}{\partial S\partial N}\right)dN\,dS
+ \left(\frac{\partial^2 E}{\partial N\partial V}+\frac{\partial^2 E}{\partial V\partial N}\right)dN\,dV
+ \left(\frac{\partial^2 E}{\partial S\partial V}+\frac{\partial^2 E}{\partial V\partial S}\right)dS\,dV \ge 0 </math>
|}
{|
|-
|| <math> (09)\quad </math>
|| <math> \frac{\partial^2 E}{\partial N^2} \ge 0\,,\quad \frac{\partial^2 E}{\partial S^2} \ge 0\,,\quad
\frac{\partial^2 E}{\partial V^2} \ge 0\,,\quad
\left(\frac{\partial^2 E}{\partial N^2}\right)\left(\frac{\partial^2 E}{\partial S^2}\right)
- \left(\frac{\partial^2 E}{\partial N\partial S}\right)\left(\frac{\partial^2 E}{\partial S\partial N}\right) \ge 0 </math>
|-
|| <math> \quad\quad </math>
|| <math> \left(\frac{\partial^2 E}{\partial N^2}\right)\left(\frac{\partial^2 E}{\partial V^2}\right)
- \left(\frac{\partial^2 E}{\partial N\partial V}\right)\left(\frac{\partial^2 E}{\partial V\partial N}\right) \ge 0\,,\quad
\left(\frac{\partial^2 E}{\partial S^2}\right)\left(\frac{\partial^2 E}{\partial V^2}\right)
- \left(\frac{\partial^2 E}{\partial S\partial V}\right)\left(\frac{\partial^2 E}{\partial V\partial S}\right) \ge 0 </math>
|}
7rby9b9l1vo9k6x5emg4shxbizy0uc0
1093572
1093571
2026-11-09T10:48:13Z
Pelikam
111447
/* Stabilität */
1093572
wikitext
text/x-wiki
[[CPRT/2276|< Energien E, F, G, H, L, K, J, I im Koordinatensystem (N,S,V) - CPRT/2276]]
== Energie E (Bezugssystem) ==
== Gleichgewicht ==
{|
|-
|| <math> (01)\quad </math>
|| <math> dE(N,S,V) </math>||<math> = </math>
|| <math> +\,\mu\,dN </math>||<math> +\,t\,dS </math>||<math> +\,p\,dV </math>
|-
|| <math> (02)\quad </math>
|| <math> E(N,S,V) </math>||<math> = </math>
|| <math> +\,\mu\,N </math>||<math> +\,t\,S </math>||<math> +\,p\,V </math>
|-
|| <math> (02)\quad </math>
|| <math> dE(N,S,V) </math>||<math> = </math>
|| <math> +\,dN\frac{\partial E}{\partial N} </math>||<math> +\,dS\frac{\partial E}{\partial S} </math>
|| <math> +\,dV\frac{\partial E}{\partial V} </math>
|-
|| <math> (03)\quad </math>
|| <math> 0\,(N,S,V) </math>||<math> = </math>
|| <math> +\,N\frac{\partial \mu}{\partial N} </math>||<math> +\,S\frac{\partial \mu}{\partial S} </math>
|| <math> +\,V\frac{\partial \mu}{\partial V} </math>
|-
|| <math> (04)\quad </math>
|| <math> 0\,(N,S,V) </math>||<math> = </math>
|| <math> +\,N\,\frac{\partial t}{\partial N} </math>||<math> +\,S\,\frac{\partial t}{\partial S} </math>
|| <math> +\,V\,\frac{\partial t}{\partial V} </math>
|-
|| <math> (05)\quad </math>
|| <math> 0\,(N,S,V) </math>||<math> = </math>
|| <math> +\,N\frac{\partial p}{\partial N} </math>||<math> +\,S\frac{\partial p}{\partial S} </math>
|| <math> +\,V\frac{\partial p}{\partial V} </math>
|-
|| <math> (06)\quad </math>
|| <math> 0\,(N,S,V) </math>||<math> = </math>
|| <math> -\,N\,d\mu </math>||<math> -\,S\,dt </math>||<math> -\,V\,dp </math>
|-
|| <math> (07)\quad </math>
|| <math> 0\,(N,S,V) </math>||<math> = </math>
|| <math> +\,N\frac{\partial \,dE}{\partial N} </math>||<math> +\,S\frac{\partial \,dE}{\partial S} </math>
|| <math> +\,V\frac{\partial \,dE}{\partial V} \neq dE(N,S,V) </math>
|}
== Stabilität ==
{|
|-
|| <math> (08)\quad </math>
|| <math> d^2 E </math>||<math> = </math>
|| <math> + \frac{\partial \mu}{\partial N}\,(dN)^2
+ \left(\frac{\partial \mu}{\partial S} + \frac{\partial t}{\partial N}\right)dN\,dS
+ \frac{\partial t}{\partial S}\,(dS)^2
+ \left(\frac{\partial t}{\partial V} + \frac{\partial p}{\partial S}\right)dS\,dV </math>
|-
|| <math> \quad\quad </math>
|| <math> </math>||<math> </math>
|| <math> +\frac{\partial p}{\partial V}\,(dV)^2
+ \left(\frac{\partial \mu}{\partial V} + \frac{\partial p}{\partial N}\right)dV\,dN </math>
|}
{|
|-
|| <math> (09)\quad </math>
|| <math> \frac{\partial \mu}{\partial N} \ge 0\,,\quad \frac{\partial t}{\partial S} \ge 0\,,\quad
\frac{\partial p}{\partial V} \ge 0\,,\quad
\left(\frac{\partial \mu}{\partial N}\right)\left(\frac{\partial t}{\partial S}\right)
- \left(\frac{\partial \mu}{\partial S}\right)\left(\frac{\partial t}{\partial N}\right) \ge 0 </math>
|-
|| <math> \quad\quad </math>
|| <math> \left(\frac{\partial t}{\partial S}\right)\left(\frac{\partial p}{\partial V}\right)
- \left(\frac{\partial t}{\partial V}\right)\left(\frac{\partial p}{\partial S}\right) \ge 0\,,\quad
\left(\frac{\partial \mu}{\partial N}\right)\left(\frac{\partial p}{\partial V}\right)
- \left(\frac{\partial \mu}{\partial V}\right)\left(\frac{\partial p}{\partial N}\right) \ge 0 </math>
|}
== Herleitungen Energie E ==
{|
|-
|| <math> (01)\quad </math>
|| <math> dE(N,S,V) </math>||<math> = </math>
|| <math> +\,\mu\,dN + t\,dS + p\,d(-V) </math>
|-
|| <math> \quad\quad </math>
|| <math> </math>||<math> = </math>
|| <math> +\,\frac{\partial E}{\partial N} dN
+ \frac{\partial E}{\partial S} dS
+ \frac{\partial E}{\partial V} dV </math>
|-
|| <math> \quad\quad </math>
|| <math> </math>||<math> = </math>
|| <math> +\,dN\frac{\partial E}{\partial N}
+ dS\frac{\partial E}{\partial S}
+ dV\frac{\partial E}{\partial V} </math>
|-
|| <math> \quad\quad </math>
|| <math> </math>||<math> = </math>
|| <math> +\,dN\,\mu + dS\,t + d(-V)\,p </math>
|-
|| <math> \quad\quad </math>
|| <math> \frac{\partial}{\partial N}\left(dN \frac{\partial E}{\partial N}\right)</math>||<math> = </math>
|| <math> dN\frac{\partial }{\partial N}\frac{\partial E}{\partial N},\quad
\frac{\partial}{\partial N}\left(dN\right) = d\frac{\partial N}{\partial N} = d(1) = 0\quad (N,S,V) </math>
|-
|| <math> \quad\quad </math>
|| <math> d\mu(N,S,V) </math>||<math> = </math>
|| <math> +\,d\frac{\partial E}{\partial N} \neq 0 </math>
|-
|| <math> \quad\quad </math>
|| <math> </math>||<math> = </math>
|| <math> +\,dN\frac{\partial}{\partial N}\frac{\partial E}{\partial N}
+ dS\frac{\partial}{\partial S}\frac{\partial E}{\partial N}
+ dV\frac{\partial}{\partial V}\frac{\partial E}{\partial N} </math>
|-
|| <math> \quad\quad </math>
|| <math> </math>||<math> = </math>
|| <math> +\,dN\frac{\partial}{\partial N}\frac{\partial E}{\partial N}
+ dS\frac{\partial}{\partial N}\frac{\partial E}{\partial S}
+ dV\frac{\partial}{\partial N}\frac{\partial E}{\partial V} </math>
|-
|| <math> \quad\quad </math>
|| <math> </math>||<math> = </math>
|| <math> +\,\frac{\partial}{\partial N}\left(dN\frac{\partial E}{\partial N}\right)
+ \frac{\partial}{\partial N}\left(dS\frac{\partial E}{\partial S}\right)
+ \frac{\partial}{\partial N}\left(dV\frac{\partial E}{\partial V}\right) </math>
|-
|| <math> \quad\quad </math>
|| <math> </math>||<math> = </math>
|| <math> +\,\frac{\partial}{\partial N} dE \neq 0 </math>
|-
|| <math> \quad\quad </math>
|| <math> \frac{\partial}{\partial S}\left(dS \frac{\partial E}{\partial S}\right)</math>||<math> = </math>
|| <math> dS\frac{\partial }{\partial S}\frac{\partial E}{\partial S},\quad
\frac{\partial}{\partial S}\left(dS\right) = d\frac{\partial S}{\partial S} = d(1) = 0\quad (N,S,V) </math>
|-
|| <math> \quad\quad </math>
|| <math> dt(N,S,V) </math>||<math> = </math>
|| <math> +\,d\frac{\partial E}{\partial S} \neq 0 </math>
|-
|| <math> \quad\quad </math>
|| <math> </math>||<math> = </math>
|| <math> +\,dN\frac{\partial}{\partial N}\frac{\partial E}{\partial S}
+ dS\frac{\partial}{\partial S}\frac{\partial E}{\partial S}
+ dV\frac{\partial}{\partial V}\frac{\partial E}{\partial S} </math>
|-
|| <math> \quad\quad </math>
|| <math> </math>||<math> = </math>
|| <math> +\,dN\frac{\partial}{\partial S}\frac{\partial E}{\partial N}
+ dS\frac{\partial}{\partial S}\frac{\partial E}{\partial S}
+ dV\frac{\partial}{\partial S}\frac{\partial E}{\partial V} </math>
|-
|| <math> \quad\quad </math>
|| <math> </math>||<math> = </math>
|| <math> +\,\frac{\partial}{\partial S}\left(dN\frac{\partial E}{\partial N}\right)
+ \frac{\partial}{\partial S}\left(dS\frac{\partial E}{\partial S}\right)
+ \frac{\partial}{\partial S}\left(dV\frac{\partial E}{\partial V}\right) </math>
|-
|| <math> \quad\quad </math>
|| <math> </math>||<math> = </math>
|| <math> +\,\frac{\partial}{\partial S} dE \neq 0 </math>
|-
|| <math> \quad\quad </math>
|| <math> \frac{\partial}{\partial V}\left(dV \frac{\partial E}{\partial V}\right)</math>||<math> = </math>
|| <math> dV\frac{\partial }{\partial V}\frac{\partial E}{\partial V},\quad
\frac{\partial}{\partial V}\left(dV\right) = d\frac{\partial V}{\partial V} = d(1) = 0\quad (N,S,V) </math>
|-
|| <math> \quad\quad </math>
|| <math> dp(N,S,V) </math>||<math> = </math>
|| <math> +\,d\frac{\partial E}{\partial (-V)} \neq 0 </math>
|-
|| <math> \quad\quad </math>
|| <math> </math>||<math> = </math>
|| <math> +\,dN\frac{\partial}{\partial N}\frac{\partial E}{\partial (-V)}
+ dS\frac{\partial}{\partial S}\frac{\partial E}{\partial (-V)}
+ dV\frac{\partial}{\partial V}\frac{\partial E}{\partial (-V)} </math>
|-
|| <math> \quad\quad </math>
|| <math> </math>||<math> = </math>
|| <math> -\,dN\frac{\partial}{\partial N}\frac{\partial E}{\partial V}
- dS\frac{\partial}{\partial S}\frac{\partial E}{\partial V}
- dV\frac{\partial}{\partial V}\frac{\partial E}{\partial V} </math>
|-
|| <math> \quad\quad </math>
|| <math> </math>||<math> = </math>
|| <math> -\,dN\frac{\partial}{\partial V}\frac{\partial E}{\partial N}
- dS\frac{\partial}{\partial V}\frac{\partial E}{\partial S}
- dV\frac{\partial}{\partial V}\frac{\partial E}{\partial V} </math>
|-
|| <math> \quad\quad </math>
|| <math> </math>||<math> = </math>
|| <math> -\,\frac{\partial}{\partial V}\left(dN\frac{\partial E}{\partial N}\right)
- \frac{\partial}{\partial V}\left(dS\frac{\partial E}{\partial S}\right)
- \frac{\partial}{\partial V}\left(dV\frac{\partial E}{\partial V}\right) </math>
|-
|| <math> \quad\quad </math>
|| <math> </math>||<math> = </math>
|| <math> -\,\frac{\partial}{\partial V} dE </math>
|-
|| <math> \quad\quad </math>
|| <math> </math>||<math> = </math>
|| <math> +\,\frac{\partial}{\partial (-V)} dE \neq 0 </math>
|-
|| <math> (02)\quad </math>
|| <math> E(N,S,V) </math>||<math> = </math>
|| <math> +\,\mu\,N + t\,S + p\,(-V) </math>
|-
|| <math> \quad\quad </math>
|| <math> </math>||<math> = </math>
|| <math> +\,\frac{\partial E}{\partial N}\,N
+ \frac{\partial E}{\partial S}\,S
+ \frac{\partial E}{\partial V}\,V </math>
|-
|| <math> \quad\quad </math>
|| <math> </math>||<math> = </math>
|| <math> +\,N\,\frac{\partial E}{\partial N}
+ S\,\frac{\partial E}{\partial S}
+ V\,\frac{\partial E}{\partial V} </math>
|-
|| <math> \quad\quad </math>
|| <math> </math>||<math> = </math>
|| <math> +\,N\,\mu + S\,t + (-V)\,p </math>
|-
|| <math> \quad\quad </math>
|| <math> \frac{\partial}{\partial N}\left(N \frac{\partial E}{\partial N}\right)</math>||<math> = </math>
|| <math> \frac{\partial E}{\partial N} + N\frac{\partial }{\partial N}\frac{\partial E}{\partial N}\quad (N,S,V) </math>
|-
|| <math> (03)\quad </math>
|| <math> 0\,(N,S,V) </math>||<math> = </math>
|| <math> +\,N\frac{\partial \mu}{\partial N}
+ S\frac{\partial \mu}{\partial S}
+ V\frac{\partial \mu}{\partial V} </math>
|-
|| <math> \quad\quad </math>
|| <math> </math>||<math> = </math>
|| <math> +\,N\frac{\partial}{\partial N}\frac{\partial E}{\partial N}
+ S\frac{\partial}{\partial S}\frac{\partial E}{\partial N}
+ V\frac{\partial}{\partial V}\frac{\partial E}{\partial N} </math>
|-
|| <math> \quad\quad </math>
|| <math> </math>||<math> = </math>
|| <math> +\,N\frac{\partial}{\partial N}\frac{\partial E}{\partial N}
+ S\frac{\partial}{\partial N}\frac{\partial E}{\partial S}
+ V\frac{\partial}{\partial N}\frac{\partial E}{\partial V} </math>
|-
|| <math> \quad\quad </math>
|| <math> </math>||<math> = </math>
|| <math> +\,\frac{\partial}{\partial N}\left(N\frac{\partial E}{\partial N}\right)
+ \frac{\partial}{\partial N}\left(S\frac{\partial E}{\partial S}\right)
+ \frac{\partial}{\partial N}\left(V\frac{\partial E}{\partial V}\right)
- \frac{\partial E}{\partial N} </math>
|-
|| <math> \quad\quad </math>
|| <math> </math>||<math> = </math>
|| <math> +\,\frac{\partial E}{\partial N}
- \frac{\partial E}{\partial N} </math>
|-
|| <math> \quad\quad </math>
|| <math> </math>||<math> = </math>
|| <math> +\,\mu - \mu = 0 </math>
|-
|| <math> \quad\quad </math>
|| <math> \frac{\partial}{\partial S}\left(S \frac{\partial E}{\partial S}\right)</math>||<math> = </math>
|| <math> \frac{\partial E}{\partial S} + S\frac{\partial }{\partial S}\frac{\partial E}{\partial S}\quad (N,S,V) </math>
|-
|| <math> (04)\quad </math>
|| <math> 0\,(N,S,V) </math>||<math> = </math>
|| <math> +\,N\,\frac{\partial t}{\partial N}
+ S\,\frac{\partial t}{\partial S}
+ V\,\frac{\partial t}{\partial V} </math>
|-
|| <math> \quad\quad </math>
|| <math> </math>||<math> = </math>
|| <math> +\,N\,\frac{\partial}{\partial N}\frac{\partial E}{\partial S}
+ S\,\frac{\partial}{\partial S}\frac{\partial E}{\partial S}
+ V\,\frac{\partial}{\partial V}\frac{\partial E}{\partial S} </math>
|-
|| <math> \quad\quad </math>
|| <math> </math>||<math> = </math>
|| <math> +\,N\,\frac{\partial}{\partial S}\frac{\partial E}{\partial N}
+ S\,\frac{\partial}{\partial S}\frac{\partial E}{\partial S}
+ V\,\frac{\partial}{\partial S}\frac{\partial E}{\partial V} </math>
|-
|| <math> \quad\quad </math>
|| <math> </math>||<math> = </math>
|| <math> +\,\frac{\partial}{\partial S}\left(N\frac{\partial E}{\partial N}\right)
+ \frac{\partial}{\partial S}\left(S\frac{\partial E}{\partial S}\right)
+ \frac{\partial}{\partial S}\left(V\frac{\partial E}{\partial V}\right)
- \frac{\partial E}{\partial S} </math>
|-
|| <math> \quad\quad </math>
|| <math> </math>||<math> = </math>
|| <math> +\,\frac{\partial E}{\partial S}
- \frac{\partial E}{\partial S} </math>
|-
|| <math> \quad\quad </math>
|| <math> </math>||<math> = </math>
|| <math> +\,t - t = 0 </math>
|-
|| <math> \quad\quad </math>
|| <math> \frac{\partial}{\partial V}\left(V \frac{\partial E}{\partial V}\right) </math>||<math> = </math>
|| <math> \frac{\partial E}{\partial V} + V\frac{\partial }{\partial V}\frac{\partial E}{\partial V}\quad (N,S,V) </math>
|-
|| <math> (05)\quad </math>
|| <math> 0\,(N,S,V) </math>||<math> = </math>
|| <math> +\,N\frac{\partial p}{\partial N}
+ S\frac{\partial p}{\partial S}
+ V\frac{\partial p}{\partial V} </math>
|-
|| <math> \quad\quad </math>
|| <math> </math>||<math> = </math>
|| <math> +\,N\frac{\partial}{\partial N}\frac{\partial E}{\partial (-V)}
+ S\frac{\partial}{\partial S}\frac{\partial E}{\partial (-V)}
+ V\frac{\partial}{\partial V}\frac{\partial E}{\partial (-V)} </math>
|-
|| <math> \quad\quad </math>
|| <math> </math>||<math> = </math>
|| <math> -\,N\frac{\partial}{\partial N}\frac{\partial E}{\partial V}
- S\frac{\partial}{\partial S}\frac{\partial E}{\partial V}
- V\frac{\partial}{\partial V}\frac{\partial E}{\partial V} </math>
|-
|| <math> \quad\quad </math>
|| <math> </math>||<math> = </math>
|| <math> -\,N\frac{\partial}{\partial V}\frac{\partial E}{\partial N}
- S\frac{\partial}{\partial V}\frac{\partial E}{\partial S}
- V\frac{\partial}{\partial V}\frac{\partial E}{\partial V} </math>
|-
|| <math> \quad\quad </math>
|| <math> </math>||<math> = </math>
|| <math> -\,\frac{\partial}{\partial V}\left(N\frac{\partial E}{\partial N}\right)
- \frac{\partial}{\partial V}\left(S\frac{\partial E}{\partial S}\right)
- \frac{\partial}{\partial V}\left(V\frac{\partial E}{\partial V}\right)
+ \frac{\partial E}{\partial V} </math>
|-
|| <math> \quad\quad </math>
|| <math> </math>||<math> = </math>
|| <math> -\,\frac{\partial E}{\partial V}
+ \frac{\partial E}{\partial V} </math>
|-
|| <math> \quad\quad </math>
|| <math> </math>||<math> = </math>
|| <math> +\,\frac{\partial E}{\partial (-V)}
- \frac{\partial E}{\partial (-V)} </math>
|-
|| <math> \quad\quad </math>
|| <math> </math>||<math> = </math>
|| <math> +\,p - p = 0 </math>
|-
|| <math> (06)\quad </math>
|| <math> 0\,(N,S,V) </math>||<math> = </math>
|| <math> -\,N\,d\mu - S\,dt - V\,d(-p) </math>
|-
|| <math> \quad\quad </math>
|| <math> </math>||<math> = </math>
|| <math> -\,N\,d\frac{\partial E}{\partial N}
- S\,d\frac{\partial E}{\partial S}
- V\,d\frac{\partial E}{\partial V} </math>
|-
|| <math> \quad\quad </math>
|| <math> </math>||<math> = </math>
|| <math> -\,d\left(N\frac{\partial E}{\partial N}\right)
- d\left(S\frac{\partial E}{\partial S}\right)
- d\left(V\frac{\partial E}{\partial V}\right) </math>
|-
|| <math> \quad\quad </math>
|| <math> </math>||<math> </math>
|| <math> +\,\frac{\partial E}{\partial N} dN
+ \frac{\partial E}{\partial S} dS
+ \frac{\partial E}{\partial V} dV </math>
|-
|| <math> \quad\quad </math>
|| <math> </math>||<math> = </math>
|| <math> -\,dE + dE = 0 </math>
|-
|| <math> (07)\quad </math>
|| <math> 0\,(N,S,V) </math>||<math> = </math>
|| <math> +\,N\frac{\partial \,dE}{\partial N}
+ S\frac{\partial \,dE}{\partial S}
+ V\frac{\partial \,dE}{\partial V} \neq dE(N,S,V) </math>
|-
|| <math> \quad\quad </math>
|| <math> </math>||<math> = </math>
|| <math> +\,N\,d\frac{\partial E}{\partial N}
+ S\,d\frac{\partial E}{\partial S}
+ V\,d\frac{\partial E}{\partial V} </math>
|-
|| <math> \quad\quad </math>
|| <math> </math>||<math> = </math>
|| <math> +\,N\,d\mu + S\,dt + V\,d(-p) = 0 </math>
|}
{|
|-
|| <math> (08)\quad </math>
|| <math> d^2 E </math>||<math> = </math>
|| <math> +\frac{\partial^2 E}{\partial N^2}\,(dN)^2 + \frac{\partial^2 E}{\partial S^2}\,(dS)^2
+\frac{\partial^2 E}{\partial V^2}\,(dV)^2 </math>
|-
|| <math> \quad\quad </math>
|| <math> </math>||<math> </math>
|| <math> + \left(\frac{\partial^2 E}{\partial N\partial S}+\frac{\partial^2 E}{\partial S\partial N}\right)dN\,dS
+ \left(\frac{\partial^2 E}{\partial N\partial V}+\frac{\partial^2 E}{\partial V\partial N}\right)dN\,dV
+ \left(\frac{\partial^2 E}{\partial S\partial V}+\frac{\partial^2 E}{\partial V\partial S}\right)dS\,dV \ge 0 </math>
|}
{|
|-
|| <math> (09)\quad </math>
|| <math> \frac{\partial^2 E}{\partial N^2} \ge 0\,,\quad \frac{\partial^2 E}{\partial S^2} \ge 0\,,\quad
\frac{\partial^2 E}{\partial V^2} \ge 0\,,\quad
\left(\frac{\partial^2 E}{\partial N^2}\right)\left(\frac{\partial^2 E}{\partial S^2}\right)
- \left(\frac{\partial^2 E}{\partial N\partial S}\right)\left(\frac{\partial^2 E}{\partial S\partial N}\right) \ge 0 </math>
|-
|| <math> \quad\quad </math>
|| <math> \left(\frac{\partial^2 E}{\partial N^2}\right)\left(\frac{\partial^2 E}{\partial V^2}\right)
- \left(\frac{\partial^2 E}{\partial N\partial V}\right)\left(\frac{\partial^2 E}{\partial V\partial N}\right) \ge 0\,,\quad
\left(\frac{\partial^2 E}{\partial S^2}\right)\left(\frac{\partial^2 E}{\partial V^2}\right)
- \left(\frac{\partial^2 E}{\partial S\partial V}\right)\left(\frac{\partial^2 E}{\partial V\partial S}\right) \ge 0 </math>
|}
q4l0u6ckekwyerlxi0fddc5nfmvfb6a
Astronomie von der Frühgeschichte bis zur Neuzeit/ Bedeutung in anderen Disziplinen
0
121622
1093541
1093196
2026-11-08T18:34:43Z
Bautsch
35687
/* Himmelspforte */ Sternenreihen
1093541
wikitext
text/x-wiki
Viele Bezeichnungen für verschiedene Lehren werden mit der aus dem Altgriechischen stammenden Endung "-logie" (altgriechisch λόγος ("logos"), zu Deutsch „Lehre“) gebildet. Die folgenden Disziplinen sind in diesem Kontext hervorzuheben, da sie insbesondere für die '''{{w|Archäoastronomie}}''' wertvolle wissenschaftliche Ergänzungen zur '''{{w|Astronomie}}''' (aus den altgriechischen Wörtern ἄστρον ("ástron", zu Deutsch „Stern“) und νόμος ("nómos, zu Deutsch „Gesetz“) zusammengesetzt also „Sterngesetz“) liefern:
* Die '''{{w|Archäologie}}''' (zusammengesetzt mit dem altgriechischen Wort ἀρχαῖος ("archaios"), zu Deutsch „Altertumslehre“) beschäftigt sich mit der kulturellen Entwicklung der Menschheit.
* Die '''{{w|Etymologie}}''' (zusammengesetzt mit dem altgriechischen Wort ἔτυμος ("etymos"), zu Deutsch „Wortherkunftslehre“) untersucht die geschichtliche Herkunft von Wörtern.
* Die '''{{w|Mythologie}}''' (zusammengesetzt mit dem altgriechischen Wort μῦθος ("mythos"), zu Deutsch „Erzählungslehre“), die sich wissenschaftlich mit der Sagenwelt beschäftigt.
* Die '''{{w|Theologie}}''' (zusammengesetzt mit dem altgriechischen Wort θεός ("theós"), zu Deutsch „Gotteslehre“) mit ihren Lehren zum religiösen Glauben und dessen Glaubensdokumenten.
* Die '''{{w|Kosmologie}}''' (zusammengesetzt mit dem altgriechischen Wort κόσμος ("kósmos"), zu Deutsch „Weltenlehre“) ist hingegen eine Lehre, die sich im Laufe der Jahrtausende deutlich verändert hat und sich auch heute noch erheblich weiterentwickelt, da es in der modernen Astronomie und Astrophysik mit zunehmend hohem technischem Aufwand immer wieder zu neuen Erkenntnissen kommt.
* Die '''{{w|Numerologie}}''' (zusammengesetzt mit dem lateinischen Wort numerus, zu Deutsch „Zahlenlehre“) mit ihren mystischen Lehren über die symbolische Zuweisung von Bedeutungen an Zahlen.
Von der Antike bis ins Mittelalter galt die Beherrschung der '''{{w|sieben freien Künste}}''' als Voraussetzung für das Betreiben von Philosophie. Zu den drei "trivialen" Künsten der {{w|Grammatik}}, der {{w|Rhetorik}} und der {{w|Dialektik}} des '''{{w|Trivium|Triviums}}''' wurden die vier Künste der {{w|Musiktheorie}}, der {{w|Arithmetik}}, der {{w|Geometrie}} und der {{w|Astronomie}} zu den Künsten des '''{{w|Quadrivium|Quadriviums}}''' gezählt → siehe hierzu auch [[Quadriviale_Kuriositäten|'''Wikibook ''Quadriviale Kuriositäten''''']].
== Zur Etymologie ==
Die Genesis aus dem Alten Testament greift die Thematik der Verwirrung der einheitlichen Sprache in ihrem elften Kapitel auf, und beschreibt, wie die bereits sternenkundigen Menschen im Norden Mesopotamiens übermütig geworden waren und in Babel einen Turm mit einer Spitze '''bis in den Himmel''' errichten wollten:<ref>[https://www.bibleserver.com/EU/1.Mose11 Genesis 11], Genesis, Kapitel 11, Einheitsübersetzung</ref>
<blockquote>
1 Die ganze Erde hatte eine Sprache und ein und dieselben Worte.<br/>
2 Als sie ostwärts aufbrachen, fanden sie eine Ebene im Land Schinar und siedelten sich dort an.<br/>
3 Sie sagten zueinander: Auf, formen wir Lehmziegel und brennen wir sie zu Backsteinen. So dienten ihnen gebrannte Ziegel als Steine und Erdpech als Mörtel.<br/>
4 Dann sagten sie: Auf, bauen wir uns eine Stadt und einen Turm mit einer Spitze '''bis in den Himmel'''! So wollen wir uns einen Namen machen, damit wir uns nicht über die ganze Erde zerstreuen.<br/>
5 Da stieg der HERR herab, um sich Stadt und Turm anzusehen, die die Menschenkinder bauten.<br/>
6 Und der HERR sprach: Siehe, ein Volk sind sie und eine Sprache haben sie alle. Und das ist erst der Anfang ihres Tuns. Jetzt wird ihnen nichts mehr unerreichbar sein, wenn sie es sich zu tun vornehmen.<br/>
7 Auf, steigen wir hinab und verwirren wir dort ihre Sprache, sodass keiner mehr die Sprache des anderen versteht.<br/>
8 Der HERR zerstreute sie von dort aus über die ganze Erde und sie hörten auf, an der Stadt zu bauen.<br/>
9 Darum gab man der Stadt den Namen Babel, Wirrsal, denn dort hat der HERR die Sprache der ganzen Erde verwirrt und von dort aus hat er die Menschen über die ganze Erde zerstreut.
</blockquote>
Es mag weniger verwunderlich sein, dass Schöpfungsmythen oder Berichte über Katastrophen nicht nur einen astronomischen Hintergrund haben, sondern in völlig verschiedenen Kulturen sehr ähnliche Merkmale zeigen, wenn man sich das Folgende bewusst macht: Einige Indizien deuten auf einen für viele Kulturen gemeinsamen Ursprung hin, der auf eine tiefsinnige Betrachtung und Beobachtung des Himmelsgeschehens hindeutet.
Bei bestimmten Wörtern sind die Ähnlichkeiten in vielen lebenden und toten Sprachen so auffällig, dass sie ein gemeinsames Ursprungswort (Etymon) haben und somit Kognaten sein dürften. In den folgenden Abschnitten sind einige verwandte Sprachversionen für die astronomisch relevanten Begriffe "Stern", Stier" sowie "Horn", "Sieben" und "Monat" angegeben.
=== "Stern" ===
Bei den Wörtern „Gestirn“ beziehungsweise „Stern“ sind die Ähnlichkeiten in vielen lebenden und toten Sprachen sehr auffällig, und diese Verwandtschaften mögen durch die Wörter für "Stern" in den folgenden Sprachen belegt werden:
* Akkadisch "istar"
* Indogermanisch "ster"
* Griechisch "astro" / "asteri"
* Lateinisch "astrum" / "stella"
* Althochdeutsch "stern(o)"
* Jiddisch "shtern"
* Katalanisch und Spanisch "estrella"
* Portugiesisch "estrela"
* Englisch "star"
* Niederländisch "ster"
* Gallisch "stera"
* Westfriesisch "stjer"
* Italienisch und Korsisch "stella"
* Rumänisch "stea"
* Sardisch "istedda"
* Maltesisch "stilla"
* Französisch "étoile" aus Altfranzösisch "estoile"
* Galicisch "estrela"
* Walisisch "seren"
* Dänisch und Norwegisch "stjerne"
* Schwedisch "stjärna"
* Isländisch "stjarna"
* Kurdisch "stêrk"
* Gujarati "Tārō"
* Hindi "तारा" (taara)
* Marathi "तारा" (Tārā)
* Nepalesisch "तारा" (Tārā)
* Punjabi "ਤਾਰਾ" (Tārā)
* Singhalesisch "තරුව" (taruva)
* Khmer "តារា" (tara)
* Armenisch "աստղ" (astgh)
* Tadschikisch "ситора" (sitora)
* Hausa "tauraro"
* Krio "sta"
=== "Stier" ===
Eine starke Ähnlichkeit gibt es in vielen Sprachen auch zwischen den Wörtern „Stern“ und „Stier“. Der Stier bezeichnet zudem auch ein bedeutendes und eines der ältesten Sternbilder überhaupt:
→ Siehe auch [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Astronomische_Bezugssysteme#Der_Himmelsstier|'''Himmelsstier''']].
* Akkadisch und Assyrisch "šūru"
* Aramäisch "tōra"
* Hebräisch "šǒr"
* Ugaritisch "twr"
* Arabisch "ثور" ("thawr")
* Griechisch "ταύρος" ("tauros")
* Lateinisch "taurus"
* Althochdeutsch "stior"
* Italienisch, Katalanisch und Spanisch "toro"
* Galicisch "touro"
* Gallisch "tarvos"
* Französisch "taureau"
* Schwedisch "tjur"
* Dänisch "tyr"
* Irisch und Gälisch "tarbh"
* Wallisisch "tarw"
==== "Horn" ====
Auch die Hörner des Stieres betreffend setzen sich die vielen Ähnlichkeiten fort:
* Akkadisch "carnu"
* Aramäisch "qeren"
* Gallisch "carnon"
* Griechisch "κόρνο" ("korno")
* Lateinisch "cornu"
* Maltesisch "qrun"*
* Arabisch "قرون" ("qurun")
* Französisch "corne"
* Italienisch "corne"
* Rumänisch "corn"
* Haitianisch "kòn"
=== "Sieben" ===
Die in vielen Kulturen als heilig angesehene Zahl Sieben taucht im Zusammenhang mit der Astronomie als Anzahl der mit bloßem Auge sichtbaren Wandelgestirne und als Zahl der Hauptsterne in vielen Asterismen auf:
* Sieben Wandelgestirne: Sonne Mond, Merkur, Venus, Mars, Jupiter, Saturn
* Siebengestirn im Himmelsstier: Alkione, Atlas, Electra, Maia, Merope, Taygeta, Pleione
* Sternbild Orion: Beteigeuze, Rigel, Bellatrix, Alnilam, Alnitak, Saiph, Mintaka
* Asterismus Großer Wagen: Alioth, Dubhe, Alkaid, Mizar, Merak, Phekda, Megrez
→ Siehe auch:
* [[Quadriviale_Kuriositäten/_Zahlen#Zur_Sieben|'''Zur Sieben''']].
* [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Der_Fixsternhimmel#Die_sieben_hellsten_Objekte_der_Ekliptik|'''Die sieben hellsten Objekte der Ekliptik''']].
* [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Kalenderführung#Die_Siebentagewoche|'''Die Siebentagewoche''']].
Wegen der hohen kulturellen, rituellen oder mythischen Bedeutung gibt es in vielen Kulturen und Sprachen etymologische Übereinstimmungen:
* Akkadisch "sebe"
* Proto-Indoeuropäisch "septḿ̥"
* Hetitisch "sipta"
* Proto-Germanisch "*sebun"
* Althochdeutsch "sibun"
* Hebräisch "sajin" (Buchstabe) oder "scheva" (Wort)
* Jiddisch "zibn"
* Etruskisch "semph"
* Maltesisch "sebgħa"
* Arabisch "sabʿa"
* Griechisch "επτά" ("(h)epta")
* Lateinisch "septem"
* Ungarisch "het"
* Proto-Balto-slawisch "septin"
* Proto-Indo-Iranisch "saptá"
* Katalanisch "set"
* Spanisch "siete"
* Galicisch "sete"
* Lettisch "septiņi"
* Italienisch "sette"
* Französisch "sept"
* Englisch "seven"
* Wallisisch "saith"
* Bosnisch / Kroatisch "sedam"
* Rumänisch "șapte"
* Irisch "seacht"
* Swahili "saba"
* Haitianisch "sèt"
=== "Monat" ===
Für die Dauer eines Monats ist ein vollständiger synodischer Mondzyklus das zeitgebende Maß.
→ Siehe auch: [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Mondzyklen|'''Mondzyklen''']].
Vor diesem Hintergrund wird in vielen Sprachen nur geringfügig oder manchmal sogar überhaupt nicht zwischen den Schreibweisen für die Begriffe "Mond" und "Monat" unterschieden. In der folgenden Liste sind die verwandten Wörter für das deutschsprachige Wort "Monat" aufgeführt:
* Proto-Indoeuropäisch "mehns"
* Proto-Germanisch "menoths"
* Althochdeutsch "manod"
* Avestisch "magha"
* Altpersisch "maha"
* Kurdisch "meh"
* Dänisch "måned"
* Schwedisch / Norwegisch "månad"
* Niederländisch "maand"
* Griechisch "µήνας" ("menas")
* Lateinisch "mensis"
* Lettisch / Litauisch "menesis"
* Französisch "mois"
* Englisch "month"
* Gallisch "mid"
* Irisch "mi"
* Wallisisch "mis"
* Bretonisch "miz"
* Sizilianisch "misi"
* Italienisch "mese"
* Spanisch / Galicisch / Katalanisch "mes"
* Portugiesisch "mês"
* Bulgarisch / Mazedonisch / Serbisch "месец" ("mesem")
* Slowenisch "mesec"
* Polnisch "miesiąc"
* Slowakisch "mesiac"
* Tschechisch "měsíc"
* Bosnisch / Kroatisch "mjesec"
* Swahili "mwezi"
* Haitianisch "mwa"
== Zur Mythologie ==
Seit Jahrtausenden blicken Menschen in den Nachthimmel und versuchen, die unzähligen Lichter am Firmament zu deuten. Schon früh begannen sie, die von ihnen erfundenen Sternbilder und die unablässig durch den Himmel ziehenden Wandelgestirne durch Geschichten über Götter, Helden oder andere Wesen zu interpretieren, zu erzählen und zum Teil über Jahrhunderte hinweg zu tradieren. Die '''Mythologie''' spielte dabei eine zentrale Rolle: Sie half nicht nur, eine symbolische Ordnung in den geheimnisvollen Kosmos zu bringen, sondern prägte auch viele der Bezeichnungen und Vorstellungen, die bis heute in der beschreibenden Astronomie überlebt haben.
Die Verbindung zwischen Mythologie und Astronomie ist tief verwurzelt und zeugt vom menschlichen Bedürfnis, das wahrgenommene, aber dennoch unfassbare Universum durch räumliche und zeitliche Vorstellungen sowie durch Erzählungen begreifbar zu machen. Das Geschehen am Himmel musste auf die Menschen vor der Erfindung der Bewegtbilder und des Films in der späten Neuzeit sowohl attraktiv als auch spektakulär gewirkt haben. So konnten verschiedene mythische Gestalten am Himmel durch ihre scheinbaren Handlungen wahrgenommen werden. Durch die Wiederholung solcher Deutungen konnten sich besonders beliebte Mythen im kulturellen Kontext über die Zeit verfestigen, und entsprechende Riten konnten sich etablieren.
Damit war auch eine wesentliche Voraussetzung für den Glauben der Menschen an eine höhere Macht oder mehrere höhere Mächte gegeben. Der Begriff '''Religion''' stammt vom lateinischen Inifiniv "relegere" ab. Dieses Verb bedeutet wörtlich übersetzt "wieder lesen" und meint im Sinne von "überdenken" das bewusste Wahrnehmen von Prophezeiungen oder Omen sowie das nachhaltige Beachten tradierter Vorschriften.
'''→ Siehe:'''
* [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Astronomische_Bezugssysteme#Der_Urozean|'''Der Urozean''']].
* [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Die_Plejaden#Sagenwelt|'''Die Plejaden / Sagenwelt''']].
* [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Astronomische_Bezugssysteme#Mythologie|'''Der Himmelsstier''']].
* [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Astronomische_Bezugssysteme#Babylonische_Himmelswege|'''Babylonische Himmelswege''']].
* [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Astronomische_Bezugssysteme#Mithraskult|'''Mithraskult und Tauroktonie''']].
* [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Die_Höhlenmalerei_in_der_Magura-Höhle|'''Die Höhlenmalerei in der Magura-Höhle''']].
== Zur Theologie ==
Die '''Theologie''' (vom Altgriechischen θεός = theós = Gott und λόγος = lógos = Lehre) ist die Lehre von einem Gott oder von mehreren Göttern. Sie lehrt einen ausgeprägten religiösen Glauben, begründet rituelle Traditionen und deutet die vorhandenen Glaubensdokumente.
[[Datei:Aristoteles.Theologie.png|mini|rechts|Wahrnehmbarkeit und Vergänglichkeit nach Aristoteles]]
Die Theologie des '''{{w|Aristoteles}}''' (384–322) postuliert drei mögliche Substanzen:<ref>Aristoteles: ''Metaphysik'', Kapitel XII (Λ), Philosophische Theologie, Seiten 1069a –1076a</ref>
{| class="wikitable"
|+ Mögliche Substanzen nach Aristoteles
! Nummer !! Substanz !! Erläuterung !! Interpretationsbeispiel
|-
| 1. || Die sinnlich wahrnehmbare und vergängliche Substanz || Konkrete Dinge, die nur eine begrenzte Teilhabe an der Ewigkeit haben. || Lebewesen
|-
| 2. || Die sinnlich wahrnehmbare und unvergängliche Substanz || Konkrete Dinge, die eine unbegrenzte Teilhabe an der Ewigkeit haben. || Die sieben Wandelgestirne und die Fixsterne
|-
| 3. || Die sinnlich nicht wahrnehmbare und unvergängliche Substanz || Lebendiger, unbewegter Beweger, der der Ursprung aller anderen Dinge ist. || Gott
|}
Dieses theologische Prinzip wurde später auch von '''{{w|Thomas van Aquin}}''' (1225-1274) in seinen ''Quinque viae ad Deum'' ("Fünf Wege zu Gott") aufgegriffen:
{| class="wikitable"
|+ Nach dem ''Quinque viae ad Deum'' ("Fünf Wege zu Gott") von Thomas von Aquin
! Weg !! Bezeichnung !! Voraussetzung !! Feststellung !! Folgerung
|-
| Via I || Bewegungsbeweis || In der Welt ist überall Bewegung. || Alles Bewegte muss von einem anderen in Bewegung gebracht worden sein. || Der Erstbeweger ist Gott.
|-
| Via II || Kausalitätsbeweis || In der Welt gibt es überall Ursachen und Wirkungen. || Jede Wirkung muss eine Ursache haben. || Die erste Ursache der Welt ist Gott.
|-
| Via III || Kontingenzbeweis || Alles Empirische in der Welt entsteht und vergeht wieder. || Jedes empirische Wesen muss das Sein von einem absoluten Wesen empfangen haben. || Das absolute Wesen ist Gott.
|-
| Via IV || Stufenbeweis || In der Welt gibt es abgestuft gute, wahre und schöne Dinge. || Das absolute Wesen muss die höchste Güte, Wahrheit und Schönheit haben. || Das höchste Gute, Wahre und Schöne ist Gott.
|-
| Via V || Finalitätsbeweis || In der Welt gibt es Ordnung und Gesetzmäßigkeit. || Ordnung und Gesetzmäßigkeit müssen auf einen denkenden Geist zurückgehen. || Dieser Geist kommt von Gott.
|}
Auch '''{{w|Gottfried Wilhelm Leibniz}}''' (1646-1717) lehnt sich in seiner Hypothese von „Gott als letztem und zureichendem Grund der Welt“ daran an.
Auch im 90. Psalm wird dieser Ansatz thematisiert:
<blockquote>
Das vierte Buch<br/>
Der '''ewige''' Gott – der '''vergängliche''' Mensch<br/><br/>
1 Ein Bittgebet des Mose, des Mannes Gottes. O Herr, du warst uns Wohnung '''von Geschlecht zu Geschlecht'''.<br/>
2 '''Ehe geboren wurden die Berge, ehe du unter Wehen hervorbrachtest Erde und Erdkreis''', bist du '''Gott von Ewigkeit zu Ewigkeit'''.<br/>
3 Zum Staub zurückkehren lässt du den Menschen, du sprichst: Ihr Menschenkinder, kehrt zurück!<br/>
4 Denn tausend Jahre sind in deinen Augen wie der Tag, der gestern vergangen ist, wie eine Wache in der Nacht.
</blockquote>
Darüber hinaus gibt der vierte Vers einen deutlichen Hinweis auf das Verhältnis zwischen der Länge des viele Jahrtausende dauernden Präzessionszyklus und der Länge eines siderischen Monats: der Mond wandert entlang der Ekliptiklinie an einem Tag genauso weit wie der Frühlingspunkt in tausend Jahren.
→ Siehe hierzu auch [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Astronomische_Bezugssysteme#Präzession|'''Präzession''']].
Der griechische Dichter '''{{w|Aratos von Soloi}}''' in Kilikien (≈310–245) hatte seine astronomischen Kenntnisse vom Astronomen und Mathematiker '''{{w|Eudoxos von Knidos}}''' (geboren nach 390, gestorben nach 338) erhalten. In dem in der Antike verbreiteten Lehrgedicht Φαινόμενα (Phainomena = „Himmelserscheinungen“) von Aratos wird der Sternenhimmel in zahlreichen Hexametern beschrieben. Sein monumentales sechseckiges Grab aus der antiken Stadt Pompeiopolis wurde 2020 in der türkischen Provinz Mersin wiederentdeckt.<ref>Patricia Claus: [https://greekreporter.com/2021/07/11/memorial-tomb-of-ancient-greek-astronomer-aratus-unearthed-in-turkey/ Memorial Tomb of Ancient Greek Astronomer Aratus Unearthed in Turkey], The Greek Reporter, 11. Juli 2021</ref>
Hier der Beginn des Prologs des Lehrgedichts:
<blockquote>
Εκ Διὸς ἀρχώμεσθα , τὸν οὐδέποτ᾽ ἄνδρες ἐῶμεν<br/>
῎Αῤῥητον . Μεσταὶ δὲ Διὸς πᾶσαι μὲν ἀγυιαὶ ,<br/>
Πᾶσαι δ᾽ ἀνθρώπων ἀγοραί · μεστὴ δὲ θάλασσα ,<br/>
Καὶ λιμένες. πάντη δὲ Διὸς κεχρήμεθα πάντες .<br/>
'''Τοῦ γὰρ καὶ γένος εἰμέν''' · ὁ δ᾽ ἤπιος ἀνθρώποισι<br/>
Δεξιὰ σημαίνει · λαοὺς δ᾽ ἐπὶ ἔργον ἐγείρει ,<br/>
Μιμνήσκων βιότοιο . λέγει δ᾽ , ὅτε βῶλος ἀρίστη<br/>
Βουσί τε καὶ μακέλῃσι · λέγει δ᾽ , ὅτε δεξιαὶ ὧραι ,<br/>
Καὶ φυτὰ γύρῶσαι , καὶ σπέρματα πάντα βαλέσθαι .<br/>
Αὐτὸς γὰρ τάγε σήματ᾽ ἐν '''οὐρανῷ''' ἐστήριξεν ,<br/>
'''Αστρα''' διακρίνας · ἐσκέψατο δ᾽ εἰς ἐνιαυτὸν<br/>
'''᾿Αστέρας''' , οἵ κε μάλιστα τετυγμένα σημαίνοιεν<br/>
᾿Ανδράσιν ὡράων , ὄφρ᾽ ἔμπεδα πάντα φύωνται .<br/>
Τῷ μιν ἀεὶ πρῶτόν τε καὶ ὕστατον ἱλάσκονται .<br/>
Χαῖρε , πάτερ , μέγα θαῦμα , μέγ᾽ ἀνθρώποισιν ὄνειαρ ,<br/>
Αὐτὸς καὶ προτέρη γενεή ! χαίροιτε δὲ , Μοῦσαι<br/>
Μειλίχιαι , μάλα πᾶσαι ! ἐμοί γε μὲν '''ἀστέρας''' εἰπεῖν ,<br/>
Ηἱ θέμις εὐχομένῳ , τεκμήρατε πᾶσαν ἀοιδήν .<br/>
Οἱ μὲν ὁμῶς πολέες τε , καὶ ἄλλυδις ἄλλοι ἐόντες ,<br/>
'''Οὐρανῷ''' ἕλκονται πάντ᾽ ἤματα συνεχὲς αἰεί.<br/>
Αὐτὰρ ὅγ᾽ οὐδ᾽ ὀλίγον μετανίσσεται · ἀλλὰ μάλ' αὕτως<br/>
'''῎Αξων''' οἱ ἐνάρηρεν · ἔχει δ᾽ ἀτάλαντον ἁπάντη<br/>
'''Μεσσηγὺς γαῖαν''' , περὶ δ᾽ '''οὐρανὸν''' αὐτὸν ἀγινεῖ.<br/>
Καί μιν πειραίνουσι δύω '''πόλοι''' ἀμφοτέρωθεν ·<br/>
᾿Αλλ᾽ ὁ μὲν οὐκ ἐπίοπτος · ὁ δ᾽ ἀντίος ἐκ '''Βορέαο''' ,<br/>
Ὑψόθεν Ὠκεανοῖο . Δύω δὲ μιν ἀμφὶς ἔχουσαι<br/>
'''Ἄρκτοι''' ἅμα τροχόωσι · τὸ δὴ καλέονται '''῞Αμαξαι''' .
</blockquote>
Übersetzung unter Beibehaltung der Hexameter nach dem deutschen Dichter, Übersetzer und Hochschullehrer Johann Heinrich Voss (1751–1826) von 1824:<ref>АРАТОΥ ΦΑΙΝΟΜΕΝΑ ΚΑΙ ΔΙΟΣΗΜΕΙΑ. Des Aratos Sternerscheinungen und Wetterzeichen. Übersetzt und erklärt von Johann Heinrich Voss. Heidelberg bei Christian Friedrich Winter. 1824.</ref>
<blockquote>
Zeus sei unser Beginn , und niemals bleib' er uns Männern<br/>
Ungelobt. Voll wahrlich des Zeus sind alle des Wandels<br/>
Weg' , und alle Versammlung der Welt ; voll jegliche Meerflut ,<br/>
Jeglicher Port ; ringsum ja des Zeus bedürfen wir alle .<br/>
'''Seines Geschlechts auch sind wir''' ; und Er , mildherzig den Menschen,<br/>
Zeichnet, was frommt, rechtsher ; und zu Tätigkeit weckt er die Völker,<br/>
Mahnend an Lebensbedarf : Er sagt , wann besser dem Pflugstier<br/>
Fuge die Scholl' , und dem Karst ; er sagt , wann schickliche Jahrszeit,<br/>
Dass man die Pflanze behäuf" , und einsenk' allerlei Anwachs .<br/>
Denn selbst hat er die Zeichen am oberen '''Himmel''' befestigt ,<br/>
Und '''Sternbilder''' verteilt ; er hat fürsehend dem Jahrlauf<br/>
'''Sterne''' bestimmt , die den Menschen zumeist annahende Wechsel<br/>
Deuteten jeglicher Zeit , dass in Völligkeit alles erwachse .<br/>
Drum ihn immer zuerst , und zulezt ihn , sühnen sie feiernd.<br/>
Heil , anstaunlicher Vater , den Sterblichen mächtiges Labsal ,<br/>
Du auch , selbst des Geschlechts Ursprung ! Heil , freundliche Musen,<br/>
Heil euch allen gesamt ! doch mir , der , die '''Sterne''' zu melden ,<br/>
Euch , wie geziemt , anfleht , bringt allen Gesang zur Vollendung.<br/>
Jene zugleich , so viele zerstreuete , andere anders ,<br/>
Ziehn mit dem '''Himmel''' einher in ewigem Zuge beständig .<br/>
Doch nie schwanket er selbst um ein weniges; sondern durchaus so<br/>
Bleibt ihm die '''Axe''' geheftet ; die hält gleichschwebend vom Umfang<br/>
Hier '''in der Mitte die Erd'''' , und umher dort dreht sie den '''Himmel''' .<br/>
Sie dann hat zween '''Pol'''' an jeglichem Ende gerichtet :<br/>
Unsichtbar ist jener; doch hier um den '''Boreas''' ragt er<br/>
Ob dem Okeanos hoch. Zwo dem zu den Seiten gestellte<br/>
'''Bärinnen''' rollen umher: drum auch '''Rollwagen''' benamet.
</blockquote>
'''''Hinweise:'''''
* Die "Axe" beschreibt die Erdachse.
* ''Mit dem "Boreas" ist der Himmelsnordpol gemeint. Der Himmelssüdpol ist der Unsichbare.''
* ''Bei den beiden Bärinnen handelt es sich um die Sternbilder des Großen Bären (Ursa Maior) und des Kleinen Bären (Ursa Minor).''
* ''Die beiden Rollwagen sind bei uns heute die Asterismen Großer Wagen und Kleiner Wagen.''
Der Apostel '''{{w|Paulus von Tarsus}}''' (geboren vor 10, gestorben nach 60) war der bedeutendste Missionar des Urchristentums und kannte diesen Text offensichtlich. Im 17. Kapitel der Apostelgeschichte des Lukas wird ihm ein Zitat aus dem Prolog des Lehrgedichts über die Abstammung der Menschen von Gott in den Mund gelegt.<ref>[https://www.die-bibel.de/bibel/NA28,EUE/ACT.17.28 Apostelgeschichte 17,28], Abschnitt: ''Paulus in Athen'', Novum Testamentum Graece und Einheitsübersetzung</ref>
<blockquote>
Apostelgeschichte 17,28: '''Τοῦ γὰρ καὶ γένος ἐσμέν.'''
</blockquote>
<blockquote>
Apostelgeschichte 17,28: '''Wir sind von seinem Geschlecht.'''
</blockquote>
=== Zahlen in Religionen ===
Die '''Zwei''' steht oft für Gegensätze, wie zum Beispiel Tag und Nacht, Aufgang und Untergang, Sommerhalbjahr und Winterhalbjahr, zunehmender und abnehmender Mond oder obere und untere Kulmination. Eine solche Zweiteilung findet sich oft auch in gegensätzliche Kategorien wieder, die in vielen Disziplinen, insbesondere auch in der Ethik und in Religionen verwendet werden, wie beispielsweise gut und böse, oben und unten, Leben und Tod, Licht und Schatten, Wärme und Kälte oder Himmel und Hölle.
Interessant ist auch die frühgeschichtliche astronomische Auffassung von '''zwei''' mächtigen Gegenspielern, die sich im Sternenhimmel an zwei gegenüberliegenden Seiten befinden, der [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Astronomische_Bezugssysteme#Der_Himmelsstier|der Himmelsstier]] und der [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Astronomische_Bezugssysteme#Der_Himmelsskorpion|der Himmelsskorpion]].
→ Siehe [[Quadriviale_Kuriositäten/_Zahlen#Zur_Zwei|'''Zur Zwei''']].
Die astronomischen Zahlen '''Sieben''' und '''Zwölf''' werden als heilige Zahlen angesehen. Sie werden in vielfältigen Kontexten in religiösen Texten erwähnt und für viele religiöse Symbole verwendet. Ferner spielt auch die astronomische Zahl '''Vier''' in Religionen eine bedeutende Rolle, wo sie deswegen manchmal ebenfalls als heilige Zahlen angesehen wird:
* '''Vier''' Hauptsterne (Königssterne, Cherubim, Evangelisten) respektive Hauptsternbilder mit den '''vier''' Himmelsrichtungen, den '''vier''' Tageszeiten, den '''vier''' Mondvierteln und den '''vier''' Jahreszeiten: → siehe [[Quadriviale_Kuriositäten/_Zahlen#Bedeutung_der_Vier_in_Religionen|'''Bedeutung der Vier in Religionen''']].
* '''Sieben''' Wandelgestirne mit den die '''sieben''' Tagen einer Woche beziehungsweise eines Mondviertels: → siehe [[Quadriviale_Kuriositäten/_Zahlen#Bedeutung_der_Sieben_in_Religionen|'''Bedeutung der Sieben in Religionen''']].
* '''Zwölf''' Ekliptiksternbilder des Lebewesenkreises, '''zwölf''' Monate pro Jahr, '''zwölf''' Jahre Umlaufzeit des Planeten Jupiter, jeweils '''zwölf''' Stunden Tag und Nacht: → siehe [[Quadriviale_Kuriositäten/_Zahlen#Bedeutung_der_Zwölf_in_Religionen|'''Bedeutung der Zwölf in Religionen''']].
=== Altes Testament ===
In der Bibel wird in der Regel nicht zwischen Fixsternen und Planeten unterschieden. Eine Ausnahme gibt es im 2. Buch der Könige, Kapitel 23, Vers 5 aus dem siebenten vorchristlichen Jahrhundert, wo in der deutschsprachigen Einheitsübersetzung von "den Wandelsternen" und in der Luther-Bibel von "den Planeten" die Rede ist. Die Vulgata schreibt hier allerdings von den "duodecim signis", womit sicherlich die zwölf Sternzeichen der Ekliptik gemeint sind, durch die die sieben Wandelgestirne ziehen. Die Septuaginta spricht noch allgemeiner von den "μαζουρωθ" nach dem Hebräischen Wort "מַזָּלָה" ("mazzaroth"), womit vermutlich Sternkonstellationen und im engeren Sinne ebenfalls die zwölf Sternzeichen des Zodiaks gemeint sind:
<blockquote>
'''Septuaginta '''<br/>
5 καὶ κατέπαυσεν τοὺς χωμαριμ, οὓς ἔδωκαν βασιλεῖς Ιουδα καὶ ἐθυμίων ἐν τοῖς ὑψηλοῖς καὶ ἐν ταῖς πόλεσιν Ιουδα καὶ τοῖς περικύκλῳ Ιερουσαλημ, καὶ τοὺς θυμιῶντας τῷ Βααλ καὶ τῷ ἡλίῳ καὶ τῇ σελήνῃ καὶ τοῖς '''μαζουρωθ''' καὶ πάσῃ τῇ δυνάμει τοῦ οὐρανοῦ.<br/>
<br/>
'''Vulgata'''<br/>
5 Et delevit aedituos, quos posuerant reges Iudae ad sacrificandum in excelsis per civitates Iudae et in circuitu Ierusalem, et eos, qui adolebant Baal et soli et lunae et '''duodecim signis''' et omni militiae caeli.<br/>
<br/>
'''Einheitsübersetzung (2016)'''<br/>
5 Auch setzte er die Götzenpriester ab, die von den Königen von Juda bestellt worden waren und die auf den Kulthöhen, in den Städten Judas und in der Umgebung Jerusalems Opfer verbrannt sowie dem Baal, der Sonne, dem Mond, den '''Wandelsternen''' und dem ganzen Heer des Himmels geopfert hatten.<br/>
<br/>
'''Luther-Bibel (2017)'''<br/>
5 Und er setzte die Götzenpriester ab, die die Könige von Juda eingesetzt hatten, um auf den Höhen zu opfern in den Städten Judas und um Jerusalem her; auch die dem Baal geräuchert hatten, der Sonne und dem Mond und den '''Planeten''' und allem Heer am Himmel.<br/>
</blockquote>
Der Prophet Habakuk erwähnt in seinem Psalm in Kapitel 3 aus dem siebenten vorchristlichen Jahrhundert das Konzept der Aufteilung der Ekliptik in Mondstationen respektive in Mondhäuser:
<blockquote>
10 Wenn sie dich sehen, erbeben die Berge,<br/>
das Tosen der Wasser rauscht vorüber; es erhebt die Urflut ihre Stimme,<br/>
hoch oben vergisst die Sonne ihre Strahlen.<br/>
11 '''Der Mond bleibt in der Behausung;'''<br/>
als Beleuchtung schwirren deine Pfeile,<br/>
als heller Schein das Blitzen deiner Lanze.
</blockquote>
In den folgenden Bibelstellen aus dem Alten Testament spiegeln sich astronomische Vorstellungen in Bezug auf Gott wider:
'''Genesis 1:'''
<blockquote>
1 Im Anfang erschuf Gott '''Himmel''' und Erde.<br/>
2 Die '''Erde''' war wüst und wirr und '''Finsternis''' lag über der '''Urflut''' und Gottes Geist schwebte über dem '''Wasser'''.<br/>
3 Gott sprach: Es werde '''Licht'''. Und es wurde '''Licht'''.
...<br/>
5 Und Gott nannte das Licht '''Tag''' und die Finsternis nannte er '''Nacht'''. Es wurde '''Abend''' und es wurde '''Morgen''': erster Tag.<br/>
...<br/>
14 Dann sprach Gott: Lichter sollen am '''Himmelsgewölbe''' sein, um '''Tag''' und '''Nacht''' zu scheiden. Sie sollen als Zeichen für '''Festzeiten''', für '''Tage''' und '''Jahre''' dienen.<br/>
15 Sie sollen Lichter am Himmelsgewölbe sein, um über die Erde hin zu leuchten. Und so geschah es.<br/>
16 Gott machte '''die beiden großen Lichter''', das große zur Herrschaft über den '''Tag''', das kleine zur Herrschaft über die '''Nacht''', und die '''Sterne'''.
</blockquote>
'''Psalm 8:'''
<blockquote>
4 Seh ich deine '''Himmel''', die Werke deiner Finger, '''Mond '''und '''Sterne''', die du befestigt.
</blockquote>
[[Datei:Johannes.Kepler.Coeli.enarrant.gloriam.Dei.png|mini|rechts|Portrait des jungen Johannes Keplers mit dem Motto "Coeli enarrant gloriam Dei." nach Psalm 19: "Die Himmel erzählen die Herrlichkeit Gottes."]]
'''Psalm 19:'''
<blockquote>
2 Die '''Himmel''' erzählen die Herrlichkeit Gottes und das '''Firmament''' kündet das Werk seiner Hände.
</blockquote>
'''Psalm 90:'''
<blockquote>
2 Ehe geboren wurden die Berge, ehe du unter Wehen hervorbrachtest '''Erde''' und '''Erdkreis''', bist du Gott von Ewigkeit zu Ewigkeit.
</blockquote>
'''Psalm 102:'''
<blockquote>
26 Vorzeiten hast du der Erde Grund gelegt, die '''Himmel''' sind das Werk deiner Hände.
</blockquote>
'''Psalm 103:'''
<blockquote>
19 Der HERR hat seinen Thron errichtet im '''Himmel''', seine königliche Macht beherrscht '''das All'''.
</blockquote>
'''Psalm 104:'''
<blockquote>
19 Du machst den '''Mond''' zum Maß für die Zeiten, die '''Sonne''' weiß, wann sie untergeht.
</blockquote>
'''Psalm 113:'''
<blockquote>
3 Vom '''Aufgang der Sonne''' bis zu ihrem '''Untergang''' sei gelobt der Name des HERRN.<br/>
4 Erhaben ist der HERR über alle Völker, über den '''Himmeln''' ist seine Herrlichkeit.
</blockquote>
'''Psalm 136:'''
<blockquote>
3 Dankt dem Herrn der Herren, denn seine Huld währt ewig!<br/>
4 Ihm, der allein große Wunder tut, denn seine Huld währt ewig,<br/>
5 der den '''Himmel''' gemacht hat in Weisheit, denn seine Huld währt ewig,<br/>
6 der die Erde gefestigt hat über den Wassern, denn seine Huld währt ewig,<br/>
7 der '''die großen Leuchten''' gemacht hat, denn seine Huld währt ewig,<br/>
8 die '''Sonne''' zur Herrschaft über den '''Tag''', denn seine Huld währt ewig,<br/>
9 den '''Mond''' und die '''Sterne''' zur Herrschaft über die '''Nacht''', denn seine Huld währt ewig.
</blockquote>
'''Psalm 147:'''
<blockquote>
4 Er bestimmt die Zahl der '''Sterne''' und ruft sie alle mit Namen.
</blockquote>
'''Psalm 148:'''
<blockquote>
'''Lobpreis auf den Herrn, den König des Kosmos'''<br/>
1 Halleluja! Lobt den HERRN vom '''Himmel''' her, lobt ihn in den Höhen:<br/>
2 Lobt ihn, all seine Engel, lobt ihn, all seine Heerscharen,<br/>
3 lobt ihn, '''Sonne''' und '''Mond''', lobt ihn, all ihr leuchtenden '''Sterne''',<br/>
4 lobt ihn, ihr '''Himmel der Himmel''', ihr Wasser über dem '''Himmel'''!
</blockquote>
Mit den "Wassern über dem Himmel" können nicht die Wolken unterhalb der Sternensphäre gemeint sein. Vielmehr dürfte es sich um eine Anspielung auf den Urozean beziehungsweise die Urflut handeln (siehe hierzu auch [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Astronomische_Bezugssysteme#Der_Urozean|'''Urozean''']]). Diese Urflut existierte bereits vor der Erschaffung des Lichts und der Gestirne. Man erinnere sich an den Beginn der Schöpfungsgeschichte in den ersten drei Versen der Bibel (siehe oben).
'''Buch der Weisheit (Weisheit Salomos):'''
<blockquote>
'''Salomos Gebet um Weisheit'''<br/>
9,1 Gott der Väter und Herr des Erbarmens, du hast '''das All''' durch dein Wort gemacht.
</blockquote>
'''Jesus Sirach 42:'''
<blockquote>
'''Lob Gottes in der Schöpfung'''<br/>
15 Nun will ich der Werke des Herrn gedenken, und was ich gesehen habe, werde ich erzählen: Durch die Worte des Herrn sind seine Werke und durch seinen Segen gab er ihnen ihre Bestimmung.<br/>
16 Die leuchtende '''Sonne''' blickt auf alles hernieder und von der Herrlichkeit des Herrn ist sein Werk erfüllt.<br/>
17 Der Herr gab es selbst den Heiligen nicht, all seine Wunder zu erzählen, der Herr der Herrscher über '''das All''', hat sie gegründet, sodass '''das All''' in seiner Herrlichkeit Bestand hat.<br/>
18 Abgrund und Herz hat er durchforscht und ihre Absichten hat er durchschaut; denn der Höchste kennt alles Wissen und er blickt auf die '''Zeichen der Zeiten'''.<br/>
19 Er tut das Vergangene und das Kommende kund und enthüllt die Spuren des Verborgenen.<br/>
20 Kein Gedanke entgeht ihm und kein einziges Wort bleibt ihm verborgen.<br/>
21 Die Großtaten seiner Weisheit hat er geordnet; wie er ist '''von Ewigkeit und in Ewigkeit'''. Ihm ist weder etwas hinzugefügt noch weggenommen worden und er hat keines Ratgebers bedurft.
</blockquote>
Auch im nachfolgenden Kapitel lobt Jesus Sirach die Sonne, den Mond und die Sterne in den höchsten Tönen:
'''Jesus Sirach 43:'''
<blockquote>
1 Der Stolz der Höhe ist ein '''Firmament''' von Reinheit, die Gestalt des '''Himmels''' beim Anblick der Herrlichkeit.<br/>
2 Die '''Sonne''' verkündet durch ihr Erscheinen beim Aufgang, ein wunderbares Geschöpf, ein Werk des Höchsten!<br/>
3 Zur '''Mittagszeit''' trocknet sie den Boden aus, wer wird bestehen vor ihrer Glut?<br/>
4 Wer in einen Ofen bläst bei Arbeiten mit Glut - dreimal so stark versengt die '''Sonne''' Berge; sie atmet Feuerdämpfe aus und blendet mit gleißenden Strahlen die Augen.<br/>
5 Groß ist der Herr, der sie gemacht hat, mit seinen Worten beschleunigt er ihren Lauf.<br/>
6 Auch der '''Mond''' hält sich in allem an seinen Zeitpunkt, zur '''Festsetzung der Zeiten''' und als Zeichen auf Dauer.<br/>
7 Vom '''Mond''' geht das Zeichen für einen Festtag aus, ein Gestirn, das abnimmt bis zur Vollendung.<br/>
8 Der Name '''Monat''' kommt vom '''Neumond''', der wunderbar zunimmt beim Wechsel, ein Geschöpf des Heeres in der Höhe, das am '''Himmelsgewölbe''' leuchtet.<br/>
9 Die Schönheit des '''Himmels''' ist der Glanz der '''Sterne''', ein strahlender Schmuck in den Höhen des Herrn.<br/>
10 Durch die Worte des Heiligen stehen sie gemäß ihrer Bestimmung und sie ermüden nie bei ihrer Wache.<br/>
...<br/>
27 Vieles werden wir sagen, aber wir kommen nie an ein Ziel und das Ende der Worte ist: Er ist '''das All'''.
</blockquote>
'''Jesaja 40:'''
<blockquote>
26 Hebt eure Augen in die Höhe und seht: Wer hat diese '''Gestirne''' erschaffen?<br/>
Der vollzählig herausführt ihr Heer, er ruft sie alle beim Namen.<br/>
Wegen seiner Fülle an Kraft und mächtiger Stärke fehlt kein einziges.
</blockquote>
Das Buch Baruch gehört zu den späten Schriften des Alten Testaments. Im dritten Kapitel werden das Licht und die Sterne in Bezug auf Gott thematisiert:
'''Baruch 3:'''
<blockquote>
33 Er entsendet das '''Licht''' und es eilt dahin; er ruft es zurück und zitternd gehorcht es ihm.<br/>
34 Froh leuchten die '''Sterne''' auf ihren Posten.<br/>
35 Ruft er sie, so antworten sie: Hier sind wir. Sie leuchten mit Freude für ihren Schöpfer.<br/>
36 Das ist unser Gott; kein anderer gilt neben ihm.
</blockquote>
Ein Lobpreis auf die Werke, Engel und Mächte Gottes am Gewölbe des Himmels findet sich im '''Buch Daniel''' im dritten Kapitel. Der Text macht inhaltlich eine ähnliche Aussage wie der Lobpreis auf den Herrn, den König des Kosmos in Psalm 148 (siehe oben):
'''Daniel 3:'''
<blockquote>
56 Gepriesen bist du am Gewölbe des '''Himmels''', gerühmt und verherrlicht in Ewigkeit.<br/>
57 Preist den HERRN, all ihr Werke des HERRN; lobt und rühmt ihn in Ewigkeit!<br/>
58 Preist den HERRN, ihr '''Himmel'''; lobt und rühmt ihn in Ewigkeit!<br/>
59 Preist den HERRN, ihr Engel des HERRN; lobt und rühmt ihn in Ewigkeit!<br/>
60 Preist den HERRN, all ihr '''Wasser über dem Himmel'''; lobt und rühmt ihn in Ewigkeit!<br/>
61 Preist den HERRN, all ihr Mächte des HERRN; lobt und rühmt ihn in Ewigkeit!<br/>
62 Preist den HERRN, '''Sonne und Mond'''; lobt und rühmt ihn in Ewigkeit!<br/>
63 Preist den HERRN, ihr '''Sterne am Himmel'''; lobt und rühmt ihn in Ewigkeit!
</blockquote>
=== Der Himmelsthron ===
Der '''Himmelsthron''' wir in vielen Texten des Alten Testaments als der Sitz Gottes genannt. Hier zunächst einige Erwähnungen in den Psalmen:
<blockquote>
11,4 Der HERR ist in seinem heiligen Tempel, der HERR hat seinen '''Thron im Himmel'''.<br/>
Seine Augen schauen herab, seine Blicke prüfen die Menschen.
</blockquote>
<blockquote>
33,13 Der HERR blickt herab vom '''Himmel''', er sieht alle Menschen.<br/>
33,14 Von seinem '''Thronsitz''' schaut er nieder auf alle Bewohner der Erde.
</blockquote>
<blockquote>
89,37 Sein Haus soll bleiben auf ewig, sein '''Thron''' habe Bestand vor mir wie die '''Sonne''';
</blockquote>
<blockquote>
103,19 Der HERR hat seinen '''Thron''' errichtet im '''Himmel''', seine königliche Macht beherrscht '''das All'''.
</blockquote>
Im Buch der Weisheit stehen die folgenden beiden Verse:
<blockquote>
9,9 Mit dir ist die Weisheit, die deine Werke kennt und die zugegen war, als du die Welt erschufst. Sie weiß, was wohlgefällig ist in deinen Augen und was recht ist nach deinen Geboten.<br/>
9,10 Sende sie vom heiligen '''Himmel''' und schick sie vom '''Thron''' deiner Herrlichkeit, damit sie bei mir sei und alle Mühe mit mir teile und ich erkenne, was wohlgefällig ist bei dir!
</blockquote>
Diese Bild von Gottes Thron im Himmel wir auch im Neuen Testament aufgegriffen, wie beispielsweise beim Evangelisten Matthäus (Kapitel 5, Vers 34) oder in der Offenbarung des Johannes, wo im vierten Kapitel die eröffnende Himmelsvision mit dem Abschnitt über "Die Huldigung vor dem Thron Gottes" beginnt:
<blockquote>
1 Danach sah ich und siehe, eine Tür war geöffnet am '''Himmel'''; und die erste Stimme, die ich gleich einer Posaune mit mir reden gehört hatte, sagte: Komm herauf und ich werde dir zeigen, was dann geschehen muss.<br/>
2 Sogleich wurde ich vom Geist ergriffen. Und siehe, '''ein Thron stand im Himmel'''; auf dem Thron saß einer,<br/>
3 der wie ein Jaspis und ein Karneol aussah. Und über dem '''Thron''' wölbte sich ein Regenbogen, der wie ein Smaragd aussah.<br/>
4 Und rings um den '''Thron standen vierundzwanzig Throne''' und auf den Thronen saßen vierundzwanzig Älteste, in weiße Gewänder gekleidet und mit goldenen Kränzen auf dem Haupt.<br/>
5 Von dem Thron gingen Blitze, Stimmen und Donner aus. Und '''sieben lodernde Fackeln brannten vor dem Thron; das sind die sieben Geister Gottes'''.<br/>
6 Und vor dem Thron war etwas wie ein gläsernes Meer, gleich Kristall. Und in der Mitte des Thrones und rings um den Thron waren '''vier Lebewesen''' voller Augen, vorn und hinten.<br/>
7 Das erste Lebewesen glich einem '''Löwen''', das zweite einem '''Stier''', das dritte sah aus wie ein '''Mensch''', das vierte glich einem '''fliegenden Adler'''.<br/>
</blockquote>
Der achtstrophige Adventshymnus ''Veni redemptor gentium'' (die deutschsprachige Kontrafaktur heißt "Nun komm, der Heiden Heiland") wird dem Kirchenvater Ambrosius von Mailand (339–397) zugeschrieben. In der fünften Strophe wird mit Bezug auf die Himmelfahrt des Messias der Sitz Gottes erwähnt:
<blockquote>
5,1 Egressus eius a Patre,<br/>
5,2 Regressus eius ad Patrem;<br/>
5,3 Excursus usque ad inferos,<br/>
5,4 Recursus ad '''sedem Dei'''.
</blockquote>
<blockquote>
5,1 Sein Ausgang ist vom Vater,<br/>
5,2 Seine Rückkehr ist beim Vater;<br/>
5,3 Hinausgelaufen bis zu den Toten,<br/>
5,4 Zurückgelaufen bis zum '''Sitz Gottes'''.
</blockquote>
Es ist nicht viel Phantasie erforderlich, um den Thron Gottes im '''Himmelsstier''' wiederzuerkennen. Die vierundzwanzig Throne, die sich entlang der '''Ekliptik''' um diesen Thron herum aufreihen, stehen für die vierundzwanzig Stunden eines Tages, und sie sind je zwei für jedes der zwölf Lebewesenkreiszeichen des '''Zodiaks'''. Die als sieben lodernde Fackeln vor dem Thron sind die sieben '''Wandelgestirne''', die als die '''sieben Geister Gottes''' immer wieder durch das '''Goldene Tor der Ekliptik''' in der Sitzfläche des Thrones ziehen. Die '''vier besonderen Lebewesen''' sind die vier Evangelistensymbole bei den vier zoroastrischen '''Königssternen'''.
→ Siehe [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Astronomische_Bezugssysteme#Der_Himmelsstier|'''Himmelsstier''']].
→ Siehe [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Astronomische_Bezugssysteme#Die_Ekliptik|'''Ekliptik''']].
→ Siehe [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Astronomische_Bezugssysteme#Der_Zodiak|'''Zodiak''']].
→ Siehe [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Astronomische_Bezugssysteme#Das_Goldene_Tor_der_Ekliptik|'''Goldenes Tor der Ekliptik''']].
→ Siehe [[Quadriviale_Kuriositäten/_Zahlen#Bedeutung_der_Vier_in_Religionen|'''Bedeutung der Vier in Religionen''']].
→ Siehe [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Die_Plejaden#Königssterne|'''Königssterne''']].
<gallery caption="Throne" widths=640 heights=480 perrow=3>
StatueOfEl.png|Rekonstruktion der 1988 in Ugarit ausgegrabenen und auf einem Thron sitzenden Statue aus Kalkstein, die vermutlich den höchsten ugaritischen Gott El zeigt, der als Erschaffer der Welt angebetet wurde. Das 25 Zentimeter hohe Original aus dem 13. Jahrhundert vor Christus befindet sich im Museum von Latakia an der syrischen Mittelmeerküste.<ref>[https://bodo.unifr.ch/bodo/id/34097 Skulptur, Kalkstein], in: ''Bibel & Orient Datenbank Online'', abgerufen am 6. September 2026</ref>
Aachen_Cathedral_Karlsthron_02.jpg|Thron Karls des Großen aus den 790er Jahren im Aachener Dom.
Himmelsthron.Taurus.Aries.png|Himmelsthron in den Sternbildern Stier (Taurus) und Widder (Aries) vor dem Untergang in Richtung Westen.
</gallery>
=== Das Lamm ===
Im ersten Kapitel des Evangeliums nach Johannes wird Jesus von Nazareth explizit als "Lamm Gottes" bezeichnet:<ref>[https://www.bibleserver.com/EU/Johannes1%2C29 Johannes 1,29], bibleserver.com, Einheitsübersetzung (2016)</ref>
<blockquote>
29b Seht, das '''Lamm Gottes''', das die Sünde der Welt hinwegnimmt!<br/>
...<br/>
36b Seht, das '''Lamm Gottes'''!
</blockquote>
Es handelt sich beim „Lamm Gottes“ (Kirchenlatein: „Agnus Dei“) um ein seit ältester Zeit verbreitetes Symbol für Jesus Christus. Es wird auch als das Osterlamm bezeichnet, das am Ostertag, also kurz nach der Tag-und-Nacht-Gleiche im Frühjahr auferstanden ist. Nach dem Evangelisten Markus wurde die Auferstehung „... am ersten Tag der Woche, früh am Morgen, als eben die Sonne aufging“, also am Ostersonntag während der Morgenröte im Osten entdeckt.<ref>[https://www.bibleserver.com/LUT/Markus16%2C2 Markus 16,2], Einheitsübersetzung, 2016</ref> Am 40. Tag ist Jesus Christus nach dem Zeugnis der Evangelisten Markus und Lukas in den Himmel aufgefahren. Zu Beginn der Apostelgeschichte wird dieses Ereignis folgendermaßen beschrieben:<ref>[https://www.bibleserver.com/EU/Apostelgeschichte1 Apostelgeschichte 1], Einheitsübersetzung, 2016</ref>
<blockquote>
7 Er sagte zu ihnen: Euch steht es nicht zu, Zeiten und Fristen zu erfahren, die der Vater in seiner Macht festgesetzt hat.<br/>
8 Aber ihr werdet Kraft empfangen, wenn der Heilige Geist auf euch herabkommen wird; und ihr werdet meine Zeugen sein in Jerusalem und in ganz Judäa und Samarien und bis an die Grenzen der Erde.<br/>
9 Als er das gesagt hatte, wurde er vor ihren Augen emporgehoben und eine Wolke nahm ihn auf und entzog ihn ihren Blicken.<br/>
</blockquote>
Im altrömischen Glaubensbekenntnis gibt es die Textstelle:
<blockquote>
„ascendit in caelis, sedet ad dexteram Patris“
</blockquote>
Zu Deutsch:
<blockquote>
„aufgefahren in den Himmel, er sitzt zur Rechten des Vaters“
</blockquote>
Das '''Lamm''' (astronomisch Widder) befindet sich am nördlichen Sternenhimmel '''zur Rechten''' des Stieres (Taurus). Sowohl der sumerische Himmelsstier, der der Gegenspieler des ebenfalls mächtigen Himmelsskorpions war und von Gilgamesch getötet und zerteilt worden sein soll, als auch das altarabische Sternbild Thuraya verbinden diese beiden neuzeitlichen Sternbilder zu einer Einheit. Der Hauptstern im Sternbild Widder (Aries) heißt Hamal, und das arabische Wort "hamal" steht für ein einjähriges Lamm.<ref name="Adams">Danielle Adams: [http://onesky.arizona.edu/arab-star-names/the-lamb/ The Lamb – A folkloric celestial complex], Two Deserts, one Sky – Arab Star Calendars</ref> Der fette Schwanz des Lammes wird durch die '''Plejaden (Siebengestirn)''' markiert.<ref name="Adams" /> Die Augen des Stieres sind die Sterne '''Aldebaran''' und '''Ain'''. Zwischen dem Kopf des Stieres und den '''Plejaden''' befindet sich das '''Goldene Tor der Ekliptik''', durch das alle Wandelgestirne regelmäßig hindurchziehen.
→ Siehe auch [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Die_Plejaden#Bibelstellen|'''Bibelstellen zum Siebengestirn''']].
→ Siehe auch [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Astronomische_Bezugssysteme#Das_Goldene_Tor_der_Ekliptik|'''Goldenes Tor der Ekliptik''']].
Der Frühlingspunkt der Sonne, also deren Ort auf der Ekliptiklinie zur Tag-und-Nacht-Gleiche im Frühjahr, ist von der monotheistischen Schöpfung bis zur Geburt des christlichen Gottessohns vom Kopf des Stiers (bei den Sternen '''Aldebaran''' und '''Ain''' im Goldenen Tor der Ekliptik) im heutigen Sternbild Stier (Taurus) bis zum Kopf des Lammes (beim Stern '''Hamal''') im heutigen Sternbild Widder (Aries) nach Westen gewandert. Heute befindet sich der Frühlingspunkt bereits am westlichen Ende des Sternbilds Fische (Pisces), das sich westlich an das Sternbild Widder anschließt.
==== Offenbarung des Johannes ====
In der Offenbarung des Johannes heißt es im 7. Kapitel:
<blockquote>
10b Die Rettung kommt von unserem '''Gott''', der auf dem '''Thron''' sitzt, und von dem '''Lamm'''.<br/>
17a Denn das Lamm in der Mitte vor dem Thron wird sie weiden und zu den Quellen führen, aus denen das '''Wasser des Lebens''' strömt.
</blockquote>
Wird der '''Thron Gottes''' mit dem Himmelsstier identifiziert (siehe oben), dann sitzt das '''Lamm''' (Aries, Sternbild Widder) westlich und somit rechts vor diesem Thron. Im weiteren Verlauf der Ekliptik nach Westen befinden sich die zusammenhängenden '''Wassersternbilder''' des Urozeans, dem Urquell des Lebens. Es handelt ich um die heutigen Sternbilder Fluss Eridanus, Walfisch (Cetus), Fische (Pisces), Wassermann (Aquarius), Südlicher Fisch (Piscis Austrinus) und Delphin (Delphinus) sowie Steinbock (Capricornus, früher Ziegenfisch).
→ Siehe auch [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Astronomische_Bezugssysteme#Der_Urozean|'''Urozean''']].
<gallery caption="Das Lamm zur Rechten des Stieres" mode=packed widths=800 heights=600>
Himmelsstier.P1117152.jpg|Astrophotographie vom Asterismus Himmelsstier
Himmelsstier.Sternbilder.P1117152.png|Beschriftete Astrophotographie vom Himmelsstier am winterlichen Abendhimmel in Richtung südlicher Meridian. Die Ekliptiklinie verläuft horizontal etwas unterhalb der Bildmitte.
Haende.der.Thuraya.Vollmond.Sterne.P1079912.jpg|Astrophotographie der Himmelsregion mit dem beduinischen Sternbild "Hände der Thuraya" (grüne durchgezogene Linien, Ekliptik rot gepunktete Linie) mit arabisch bezeichneten Sternen. Der Vollmond befindet sich zwischen den Sternbildern Taurus, Aries und Cetus.
Urozean.Wassersternbilder.png|Die zusammenhängenden Wassersternbilder des Urozeans am Sternenhimmel: Fluss Eridanus, Walfisch (Cetus), Fische (Pisces), Wassermann (Aquarius), Südlicher Fisch (Piscis Austrinus), Delphin (Delphinus) sowie Ziegenfisch (Steinbock, Capricornus).
</gallery>
Interpretiert man das Sternbild "Lamm" (Widder / Aries) als Mittler auf dem ekliptischen Weg vom finsteren kosmischen Urozean im Westen (rechts) zum strahlenden majestätischen Sternbild Stier (Taurus) im Osten (links), ergeben auch andere Bibelstellen in Bezug auf den Sternenhimmel einen tiefen symbolischen Sinn, die in den folgenden Abschnitten aufgeführt sind.
==== Evangelium nach Johannes ====
Die Rede von Jesus an den Jünger Thomas aus dem 14. Kapitel des Evangeliums nach Johannes ist in diesem Zusammenhang interessant:
<blockquote>
6 Jesus sagte zu ihm: Ich bin der Weg und die Wahrheit und das Leben; niemand kommt zum Vater außer durch mich.<br/>
7 Wenn ihr mich erkannt habt, werdet ihr auch meinen Vater erkennen. Schon jetzt kennt ihr ihn und habt ihn gesehen.
</blockquote>
Alle Wandelgestirne bewegen sich entlang der Ekliptiklinie (Weg) durch das heutige Sternbild Widder (das altarabische Sternbild "Lamm") im Westen zum [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Astronomische_Bezugssysteme#Das_Goldene_Tor_der-Ekliptik|Goldenen Tor der Ekliptik]] nach Osten im großen Himmelsstier (Vater / Thron).
==== Evangelium nach Markus ====
Im Evangelium nach Markus heißt es:
<blockquote>
14,62 Jesus sagte: Ich bin es. Und ihr werdet den Menschensohn '''zur Rechten der Macht''' sitzen und mit den Wolken des '''Himmels''' kommen sehen.
</blockquote>
<blockquote>
16,19 Nachdem Jesus, der Herr, dies zu ihnen gesagt hatte, wurde er in den '''Himmel''' aufgenommen und setzte sich '''zur Rechten Gottes'''.
</blockquote>
==== Evangelium nach Lukas ====
Im Evangelium nach Lukas ist es folgendermaßen formuliert:
<blockquote>
22,69 Von nun an wird der Menschensohn '''zur Rechten der Macht Gottes''' sitzen.
</blockquote>
==== Evangelium nach Matthäus ====
Auch im Evangelium nach Matthäus findet sich eine entsprechende Stelle:
<blockquote>
26,64 Jesus antwortete: Du hast es gesagt. Doch ich erkläre euch: Von nun an werdet ihr den Menschensohn '''zur Rechten der Macht''' sitzen und auf den Wolken des '''Himmels''' kommen sehen.
</blockquote>
==== Brief an die Hebräer ====
Im Brief an die Hebräer, dessen Autor unbekannt ist, gibt es etliche entsprechende Stellen:
<blockquote>
'''Gottes Rede in seinem Sohn'''<br/>
1,3 er ist der Abglanz seiner Herrlichkeit und das Abbild seines Wesens; er trägt '''das All''' durch sein machtvolles Wort, hat die Reinigung von den Sünden bewirkt und sich dann '''zur Rechten der Majestät in der Höhe''' gesetzt;<br/>
1,10 Und: Du, Herr, hast vorzeiten der Erde Grund gelegt, die '''Himmel''' sind das Werk deiner Hände.<br/>
1,11 Sie werden vergehen, '''du aber bleibst'''; sie alle veralten wie ein Gewand;<br/>
1,12 du rollst sie zusammen wie einen Mantel und wie ein Gewand werden sie gewechselt. Du aber bleibst, der du bist, und '''deine Jahre enden nie'''.<br/>
1,13 Zu welchem Engel hat er jemals gesagt: Setze dich mir '''zur Rechten''' und ich lege dir deine Feinde als Schemel unter die Füße?
</blockquote>
<blockquote>
'''Die Liturgie des neuen Bundes'''<br/>
8,1 Die Hauptsache bei dem Gesagten aber ist: Wir haben einen solchen Hohepriester, der sich '''zur Rechten des Thrones der Majestät im Himmel''' gesetzt hat,<br/>
8,2 als Diener des Heiligtums und des '''wahren Zeltes''', das der Herr selbst aufgeschlagen hat, nicht ein Mensch.
</blockquote>
<blockquote>
'''Christus als Mittler des neuen Bundes'''<br/>
9,24 Denn Christus ist nicht in ein von Menschenhand gemachtes Heiligtum hineingegangen, in ein Abbild des wirklichen, sondern '''in den Himmel selbst''', um jetzt '''vor Gottes Angesicht''' zu erscheinen für uns;
</blockquote>
<blockquote>
'''Das Opfer Jesu Christi als endgültige Versöhnung mit Gott'''<br/>
10,12 Dieser aber hat nur ein einziges Opfer für die Sünden dargebracht und sich dann '''für immer zur Rechten Gottes''' gesetzt;
</blockquote>
<blockquote>
'''Das Beispiel Jesu Christi'''<br/>
12,2 und dabei auf Jesus blicken, den Urheber und Vollender des Glaubens; er hat angesichts der vor ihm liegenden Freude das Kreuz auf sich genommen, ohne auf die Schande zu achten, und sich '''zur Rechten von Gottes Thron''' gesetzt.
</blockquote>
==== Erster Brief des Petrus ====
Der erste Brief des Petrus zählt zu den katholischen Briefen des Neuen Testaments. Dort heißt es im letzten Satz über Jesus Christus:
<blockquote>
22 der in den '''Himmel''' gegangen ist; dort ist er '''zur Rechten''' Gottes und Engel, Gewalten und Mächte sind ihm unterworfen.
</blockquote>
==== Apostelgeschichte ====
Die Apostelgeschichte schließt an das Evangelium nach Lukas an und wird ebenfalls diesem zugeschrieben. Hier kommen der erste bekennende sowie erste berufene Apostel Petrus und der erste christliche Märtyrer Stephanus zu Wort:
<blockquote>
'''Die Pfingstpredigt des Petrus'''<br/>
2,33 '''Zur Rechten Gottes''' erhöht, hat er vom Vater den verheißenen Heiligen Geist empfangen und ihn ausgegossen, wie ihr seht und hört.
</blockquote>
<blockquote>
'''Steinigung des Stephanus'''<br/>
7,55 Er aber, erfüllt vom Heiligen Geist, blickte zum '''Himmel''' empor, sah die Herrlichkeit Gottes und Jesus '''zur Rechten Gottes''' stehen<br/>
7,56 und rief: Siehe, ich sehe den Himmel offen und den Menschensohn '''zur Rechten Gottes''' stehen.
</blockquote>
=== Himmelspforte ===
Das Sternbild Widder (Aries) repräsentiert das Lamm Gottes. Der fette Schwanz des Lammes ist nach altarabischer Tradition durch das Siebengestirn (Plejaden) abgebildet, das heute zum Sternbild '''Stier''' (Taurus) gezählt wird. Der obere Teil des nördlichen Pfeilers des Goldenen Tors der Ekliptik wird durch das Siebengestirn und der obere Teil von dessen südlichem Pfeiler durch die Hyaden markiert. Zwischen diesen beiden Sternhaufen verläuft der Sturz des Goldenen Tores. Zusammen mit den beiden Sternen λ und ο Tauri sowie dem Stern Menkar im Sternbild Walfisch (Cetus) südlich der Ekliptik und der Sternenreihe Bharani-Hamal-Sheratan-Mesarthim im Widder/Lamm nördlich der Ekliptik ergibt sich die Form eines Tores. Das Goldene Tor der Ekliptik stellt mit diesen beiden Pfeilern somit eine '''Himmelspforte''' dar, durch die alle Wandelgestirne regelmäßig von Westen aus dem dunklen Urozean der winterlichen Wassersternbilder in der Richtung des Sonnenuntergangs nach Osten in das helle Gebiet des Sternenhimmels mit den Frühlings- und Sommersternbildern in der Richtung des Sonnenaufgangs treten.
[[Datei:Mars.im.Goldenen.Tor.der.Ekliptik.P1091607.jpg|mini|hochkant=3|zentriert|Der am nordwestlichen Horizont in der Nähe der Ekliptiklinie und im Goldenen Tor der Ekliptik untergehende Mars (rote Scheibe unten halb rechts) drei Tage vor dem Durchqueren der '''Himmelspforte''' zwischen dem Kopf des Himmelsstieres mit dem Sternhaufen der Hyaden (unten links) und den Plejaden nördlich der Ekliptik (rechts unten).]]
Die Genesis berichtet im 28. Kapitel unter der Überschrift "Jakob in Bet-El" (hebräisch בֵּית אֵל „Haus des El“ oder „Haus Gottes“) über einen Traum von Jakob, in dem er eine Treppe zum Himmel (die Himmelsleiter oder Jakobsleiter) sieht, an dessen oberen Ende sich das Tor des Himmels (die Himmelspforte) befindet:
<blockquote>
10 Jakob zog aus Beerscheba weg und ging nach Haran.<br/>
11 Er kam an einen bestimmten Ort und übernachtete dort, denn die Sonne war untergegangen. Er nahm einen von den Steinen dieses Ortes, legte ihn unter seinen Kopf und schlief dort ein.<br/>
12 Da hatte er einen Traum: Siehe, eine Treppe stand auf der Erde, ihre Spitze reichte bis zum '''Himmel'''. Und siehe: Auf ihr stiegen Engel Gottes auf und nieder.<br/>
13 Und siehe, der HERR stand vor ihm und sprach: Ich bin der HERR, der Gott deines Vaters Abraham und der Gott Isaaks. Das Land, auf dem du liegst, will ich dir und deinen Nachkommen geben.<br/>
14 Deine Nachkommen werden zahlreich sein wie der Staub auf der Erde. Du wirst dich '''nach Westen und Osten, nach Norden und Süden''' ausbreiten und durch dich und deine Nachkommen werden alle Sippen der Erde Segen erlangen.<br/>
15 Siehe, ich bin mit dir, ich behüte dich, wohin du auch gehst, und bringe dich zurück in dieses Land. Denn ich verlasse dich nicht, bis ich vollbringe, was ich dir versprochen habe.<br/>
16 Jakob erwachte aus seinem Schlaf und sagte: Wirklich, der HERR ist an diesem Ort und ich wusste es nicht.<br/>
17 Er fürchtete sich und sagte: Wie Ehrfurcht gebietend ist doch dieser Ort! Er ist nichts anderes als das Haus Gottes und das '''Tor des Himmels'''.<br/>
</blockquote>
El war für die semitischen Ugariter im zweiten vorchristlichen Jahrtausend der Name ihres höchsten Gottes. Ihm wurden die Beinamen „König“, „Freundlicher“ und „'''Stier'''“ verliehen. Diese Symbolik weist auf den Himmelsstier hin. Der Name El wurde von den Israeliten übernommen, und dieser Gott wurde von ihnen mit ihrem einzigen Gott gleichgesetzt. Der Gott El wurde vom Gott Baal verdrängt, der ebenfalls mit Stierhörnern konnotiert war. Er wurde auch als donnernder und Blitze schleudernder Gott dargestellt, was sich in den Mythen des antiken Griechenlands in der Figur des höchsten griechischen Gottes Zeus (Jupiter) widerspiegelt. In diesem Zusammenhang sei auf noch weitere Parallelitäten den verschiedenen Götterkulturen hingewiesen, die sich zum ugaritischen Baal-Zyklus ergeben, der in den keilalphabetischen Texten aus Ugarit (KTU) zu finden ist. Am Schluss dieses Werkes wird die kanaanitische Sonnengöttin Šapšu, die Zweitfrau von El, für die Wiederherstellung und Bewahrung der kosmischen Ordnung zu einem Opfermahl eingeladen, bei der ihr '''Brot und Wein''' dargeboten werden.<ref>Herbert Niehr: ''Der Ba‘al-Zyklus (KTU 1.1-6 + 1.8)'', Gütersloh 2015, S. 236.</ref> In Psalm 65 mit dem Titel "Lobpreis auf den Retter und Schöpfer" werden dem Gott der Israeliten ganz ähnliche Wohltaten zugeschrieben, wie dem Gott Baal in der ugaritischen Religion. Im 10. Psalmvers heißt es beispielsweise:
<blockquote>
10 Du hast für das Land gesorgt, es getränkt, es überschüttet mit Reichtum. Der Bach Gottes ist voller Wasser, gedeihen lässt du ihnen das Korn, so lässt du das Land gedeihen.
</blockquote>
Jakob war der der erste der drei Erzväter des Volkes Israel und der älteste Sohn des ältesten Sohnes Isaak von Abraham. Abraham war aus dem mesopotamischen Ur über Haran nach Bet-El gezogen, und Jakob ging in dieser Schilderung aus Beerscheba in der Nähe des Ortes Bet-El nach Haran zurück.
Der Apostel Paulus schreibt in seinem zweiten Brief an die Bewohner der griechischen Hafenstadt Korinth zu Beginn des 5. Kapitels mit der Überschrift "Die Hoffnung des Apostels" über das Gebäude hinter der Pforte zum Himmel:
<blockquote>
1 Wir wissen: Wenn unser irdisches Zelt abgebrochen wird, dann haben wir eine Wohnung von Gott, ein nicht von Menschenhand errichtetes '''ewiges Haus im Himmel'''.
</blockquote>
=== Gedanken zur wundersamen Brotvermehrung ===
==== Evangelien ====
[[Datei:Face de chapiteau figurant la Multiplication des pains, choeur de l'église de Saint-Nectaire, Puy-de-Dôme.jpg|mini|rechts|hochkant=2|Jesus mit vier seiner Jünger mit fünf Broten und zwei Fischen an einem Säulenkapitell in der romanischen Wallfahrtskirche Saint Nectaire auf dem Mont Cornadore in Saint-Nectaire in Frankreich (Département Puy-de-Dôme in der Region Auvergne-Rhône-Alpes).]]
Die wundersame Speisung der mehreren Tausend mit wenigen Broten und Fischen wird in aller vier Evangelien der Bibel erwähnt. Das Ereignis fand auf einem Berg am Ufer des Sees von Galiläa (auch als "See von Tiberias", "See Genezareth" oder "Galiläisches Meer" bekannt) statt. In der abgelegenen Gegend gab es damals sehr wenig künstliche Lichtquellen, so dass ein ungestörter Anblick des Sternenhimmels möglich war.
===== Evangelium nach Johannes =====
Im sechsten Kapitel des Evangeliums nach '''Johannes''' tauchen bei der Beschreibung der Brotvermehrung durch Jesus zum jüdischen Pessachfest neben einigen weiteren Symbolen mit astronomischer Deutungsmöglichkeit auch die expliziten Zahlen Zwei, Fünf und Zwölf auf:
<blockquote>
9 Hier ist ein kleiner Junge, der hat '''fünf Gerstenbrote''' und '''zwei Fische'''; doch was ist das für so viele?<br/>
10 Jesus sagte: Lasst die Leute sich setzen! Es gab dort nämlich viel Gras. Da setzten sie sich; es waren etwa '''fünftausend''' Männer.<br/>
11 Dann nahm Jesus die '''Brote''', sprach das Dankgebet und teilte an die Leute aus, so viel sie wollten; ebenso machte er es mit den '''Fischen'''.<br/>
12 Als die Menge satt geworden war, sagte er zu seinen Jüngern: Sammelt die übrig gebliebenen Brocken, damit nichts verdirbt!<br/>
13 Sie sammelten und füllten '''zwölf Körbe''' mit den Brocken, die von den '''fünf Gerstenbroten''' nach dem Essen übrig waren.<br/>
...<br/>
31 Unsere Väter haben das '''Manna''' in der Wüste gegessen, wie es in der Schrift heißt: '''Brot vom Himmel''' gab er ihnen zu essen.<br/>
32 Jesus sagte zu ihnen: Amen, amen, ich sage euch: Nicht Mose hat euch das '''Brot vom Himmel''' gegeben, sondern mein Vater gibt euch das wahre '''Brot vom Himmel'''.<br/>
33 Denn das '''Brot''', das Gott gibt, kommt vom '''Himmel''' herab und gibt der Welt das Leben.<br/>
34 Da baten sie ihn: Herr, gib uns immer dieses '''Brot'''!<br/>
35 Jesus antwortete ihnen: Ich bin das '''Brot des Lebens'''; wer zu mir kommt, wird nie mehr hungern, und wer an mich glaubt, wird nie mehr Durst haben.<br/>
...<br/>
48 Ich bin das '''Brot des Lebens'''.<br/>
49 Eure Väter haben in der Wüste das '''Manna''' gegessen und sind gestorben.<br/>
50 So aber ist es mit dem '''Brot''', das vom '''Himmel''' herabkommt: Wenn jemand davon isst, wird er nicht sterben.<br/>
51 Ich bin das '''lebendige Brot''', das vom '''Himmel''' herabgekommen ist. Wer von diesem '''Brot''' isst, wird in Ewigkeit leben. Das '''Brot''', das ich geben werde, ist mein Fleisch für das Leben der Welt.
</blockquote>
===== Evangelium nach Markus =====
Eine ähnliche Schilderung befindet sich im sechsten Kapitel des Evangeliums nach '''Markus''', wo das Ereignis an einem abgelegenen und einsamen Ort stattgefunden hat:
<blockquote>
38 Er sagte zu ihnen: Wie viele '''Brote''' habt ihr? Geht und seht nach! Sie sahen nach und berichteten: '''Fünf Brote''' und außerdem '''zwei Fische'''.<br/>
39 Dann befahl er ihnen, sie sollten sich in Mahlgemeinschaften im grünen Gras lagern.<br/>
40 Und sie ließen sich in Gruppen zu hundert und zu fünfzig nieder.<br/>
41 Darauf nahm er die '''fünf Brote''' und die '''zwei Fische''', blickte zum '''Himmel''' auf, sprach den Lobpreis, brach die '''Brote''' und gab sie den Jüngern, damit sie diese an die Leute austeilten. Auch die '''zwei Fische''' ließ er unter allen verteilen.<br/>
42 Und alle aßen und wurden satt.<br/>
43 Und sie hoben Brocken auf, '''zwölf Körbe''' voll, und Reste von den '''Fischen'''.<br/>
44 Es waren '''fünftausend''' Männer, die von den '''Broten''' gegessen hatten.
</blockquote>
Die Brotvermehrung auch ein weiteres Mal im achten Kapitel des Evangeliums nach '''Markus''' erwähnt:
<blockquote>
5 Er fragte sie: Wie viele '''Brote''' habt ihr? Sie antworteten: '''Sieben'''.<br/>
6 Da forderte er die Leute auf, sich auf den Boden zu setzen. Dann nahm er die sieben '''Brote''', sprach das Dankgebet, brach die '''Brote''' und gab sie seinen Jüngern zum Verteilen; und die Jünger teilten sie an die Leute aus.<br/>
7 Sie hatten auch noch ein paar '''Fische''' bei sich. Jesus segnete sie und ließ auch sie austeilen.<br/>
8 Die Leute aßen und wurden satt. Und sie hoben die Überreste der '''Brotstücke''' auf, '''sieben Körbe''' voll.<br/>
9 Es waren etwa '''viertausend''' Menschen beisammen. Danach schickte er sie nach Hause.<br/>
...<br/>
19 Als ich die '''fünf Brote''' für die '''Fünftausend''' brach, wie viele '''Körbe voll Brotstücke''' habt ihr da aufgehoben? Sie antworteten ihm: '''Zwölf'''.<br/>
20 Und als ich die '''sieben Brote''' für die '''Viertausend''' brach, wie viele '''Körbe''' voll habt ihr da aufgehoben? Sie antworteten: '''Sieben'''.<br/>
21 Da sagte er zu ihnen: Versteht ihr immer noch nicht?
</blockquote>
===== Evangelium nach Lukas =====
Ebenso verhält es sich im neunten Kapitel des Evangeliums nach '''Lukas''', wo das Ereignis dem Ort Betsaida (zu Deutsch: „Haus des Fisches“) am See Genezareth zugeordnet ist:
<blockquote>
12 Als der Tag zur Neige ging, kamen '''die Zwölf''' und sagten zu ihm: Schick die Leute weg, damit sie in die umliegenden Dörfer und Gehöfte gehen, dort Unterkunft finden und etwas zu essen bekommen; denn wir sind hier an einem abgelegenen Ort.<br/>
13 Er antwortete ihnen: Gebt ihr ihnen zu essen! Sie sagten: Wir haben nicht mehr als '''fünf Brote''' und '''zwei Fische'''; wir müssten erst weggehen und für dieses ganze Volk etwas zu essen kaufen.<br/>
14 Es waren nämlich etwa '''fünftausend''' Männer. Er aber sagte zu seinen Jüngern: Lasst sie sich in Gruppen zu ungefähr fünfzig lagern!<br/>
15 Die Jünger taten so und veranlassten, dass sich alle lagerten.<br/>
16 Jesus aber nahm die '''fünf Brote''' und die '''zwei Fische''', blickte zum '''Himmel''' auf, sprach den Lobpreis und brach sie; dann gab er sie den Jüngern, damit sie diese an die Leute austeilten.<br/>
17 Und alle aßen und wurden satt. Als man die übrig gebliebenen Brotstücke einsammelte, waren es '''zwölf Körbe''' voll.
</blockquote>
===== Evangelium nach Matthäus =====
Auch im vierzehnten Kapitel des Evangeliums nach '''Matthäus''' ist von einem abgelegenen Ort in einer einsamen Gegend die Rede:
<blockquote>
17 Sie sagten zu ihm: Wir haben nur '''fünf Brote''' und '''zwei Fische''' hier.<br/>
18 Er antwortete: Bringt sie mir her!<br/>
19 Dann ordnete er an, die Leute sollten sich ins Gras setzen. Und er nahm die '''fünf Brote''' und die '''zwei Fische''', blickte zum '''Himmel''' auf, sprach den Lobpreis, brach die Brote und gab sie den Jüngern; die Jünger aber gaben sie den Leuten<br/>
20 und alle aßen und wurden satt. Und sie sammelten die übrig gebliebenen Brotstücke ein, '''zwölf Körbe''' voll.<br/>
21 Es waren etwa '''fünftausend''' Männer, die gegessen hatten, dazu noch Frauen und Kinder.
</blockquote>
Etwas abgewandelt taucht die Brotvermehrung mit '''sieben Körben''' auch im fünfzehnten Kapitel des Evangeliums nach '''Matthäus''' auf:
<blockquote>
34 Jesus sagte zu ihnen: Wie viele '''Brote''' habt ihr? Sie antworteten: '''Sieben''' - und ein paar '''Fische'''.<br/>
35 Da forderte er die Leute auf, sich auf den Boden zu setzen.<br/>
36 Und er nahm die '''sieben Brote''' und die '''Fische''', sprach das Dankgebet, brach sie und gab sie den Jüngern und die Jünger gaben sie den Menschen.<br/>
37 Und alle aßen und wurden satt. Und sie sammelten die übrig gebliebenen Stücke ein, '''sieben Körbe''' voll.<br/>
38 Es waren '''viertausend''' Männer, die gegessen hatten, dazu noch Frauen und Kinder.<br/>
39 Danach schickte er die Menge nach Hause, stieg ins Boot und fuhr in die Gegend von Magadan.
</blockquote>
Der Ort Magadan ist möglicherweise mit dem heutigen Ort Migdal (aramäisch: Magdala) am westlichen Ufer des Sees Genezareth gleichzusetzen.
==== Astronomische Bezüge ====
[[Datei:Sternenhimmel.Pessach.25.3.23.png|mini|rechts|hochkant=2|Sternenhimmel am jüdischen Pessachfest im Jahr 25 nach Christus. Der Vollmond stand hoch über dem Horizont im Süden im Herbstpunkt beim Stern Spica (= "Kornähre") im Sternbild Jungfrau (Virgo). Gleichzeitig befand sich die Sonne tief unter dem Horizont im Norden in der Nähe des Frühlingspunktes im Sternbild Fische (Pisces).]]
[[Datei:Dendera.09.Jungfrau.Loewe.jpg|mini|rechts|hochkant=2|Das Sternbild Jungfrau (links) mit der Kornähre in der Hand und das Sternbild Löwe (rechts) im ägyptischen Zodiak von Dendera aus der Zeit kurz vor Christi Geburt.]]
[[Datei:Dendera.03.Fische.Wassermann.jpg|mini|rechts|hochkant=2|Das Sternbild Fische (links) und das Sternbild Wassermann (rechts unten) im ägyptischen Zodiak von Dendera aus der Zeit kurz vor Christi Geburt.]]
Zu diesen Bibelstellen sind im Folgenden einige Hinweise mit astronomischen Bezügen aufgeführt. Die [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Astronomische_Bezugssysteme#Beobachtungen_in_der_Nähe_der_Ekliptik|Bezugspunkte]] liegen hierbei in der Nähe der [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Astronomische_Bezugssysteme#Die_Ekliptik|Ekliptik]]:
* In den Versen im Evangelium nach Johannes ist mehrfach vom '''Brot, das vom Himmel herabkommt''' die Rede.
* Das zur Herstellung von Brot erforderliche Getreide kann durch eine '''Kornähre''' symbolisiert werden. Am Sternenhimmel wird die Kornähre durch den hellen, ekliptiknahen Stern '''Spica''' (α Virginis) im Sternbild '''Jungfrau''' (Virgo) repräsentiert. Der Vollmond stand zum jüdischen Pessachfest beim Stern Spica.
* Alle Pflanzen benötigen für das Gedeihen '''Wasser'''. Das '''Wasser''' wird am Himmel durch die drei Wassersternbilder der Ekliptik '''Fische''' (Pisces), '''Wassermann''' (Aquarius), und '''Ziegenfisch''' (Steinbock, Capricornus) westlich des [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Astronomische_Bezugssysteme#Der_Frühlingspunkt|Frühlingspunktes]] repräsentiert. Diese Sternbilder bilden mit einigen weiteren angrenzenden Wassersternbildern den [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Astronomische_Bezugssysteme#Der_Urozean|Urozean am Himmel]] (siehe hierzu auch [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Astronomische_Bezugssysteme#Der_Trichter_der_Thuraya|Der Trichter der Thuraya]]). Die Wassersternbilder waren zum Pessachfest in den drei Monaten unmittelbar zuvor von der Sonne durchlaufen worden und befanden sich beim Sonnenuntergang deshalb bereits unterhalb des westlichen Horizonts.
* Das Sternbild '''Fische''' (Pisces) besteht seit der Antike aus '''zwei Fischen'''.
* Zu Lebzeiten von Jesus von Nazareth war der '''Frühlingspunkt''' vom Sternbild Widder (Aries, ursprünglich das Hinterteil des großen Sternbilds [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Astronomische_Bezugssysteme#Der_Himmelsstier|Himmelsstier (Taurus caeli)]]) in das Sternbild '''Fische''' (Pisces) gewandert. Inzwischen ist er innerhalb dieses Sternbilds noch weiter nach Westen gewandert. Die Sonne und der Neumond standen zu Beginn des jüdischen Monats Nisan, also dem Monat des jüdischen Pessachfestes, im Sternbild '''Fische'''. Der erste Monat des Jahres, Nisan, hieß bereits in der mesopotamischen Tradition, als sich der Frühlingspunkt noch im Sternbild Widder (Aries) befand, auf Akkadisch "nisannu" (siehe hierzu auch [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Die_Plejaden#Schaltregeln|Plejaden-Schaltregeln]]). In der alten jüdischen Tradition war der Nisan deswegen mit dem Sternbild Widder verbunden. Ferner wurde der Widder dem israelitischen Stamm Juda zugeordnet.
* Zu Lebzeiten von Jesus von Nazareth war der '''Herbstpunkt''' vom Sternbild Waage (Libra, ursprünglich die Scheren des großen Sternbilds [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Astronomische_Bezugssysteme#Der_Himmelsskorpion|Himmelsskorpion (Scorpio caeli)]]) in das Sternbild Jungfrau (Virgo) gewandert. Inzwischen ist er innerhalb dieses Sternbilds noch weiter nach Westen gewandert. Um 285 nach Christi erreichte der '''Herbstpunkt''' dann die ekliptikale Länge des Sterns '''Spica''' (α Virginis).
* Der '''Frühlingspunkt''' – damals im Sternbild Fische – und der '''Herbstpunkt''' – damals im Sternbild Jungfrau (Virgo) beim Stern Spica – befinden sich immer in genau gegenüber liegenden Punkten auf der Ekliptik. Auf diese Weise umfassen diese beiden ausgezeichneten Punkte den Lebewesenkreis (Zodiak) mit seinen '''zwölf''' Sternbildern sowie die Bahnen aller '''sieben''' Wandelgestirne. Diese beiden Punkte teilten die Ekliptik in '''zwei''' gleichgroße Teile, das Sommerhalbjahr und das Winterhalbjahr. Siehe hierzu auch "[[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Astronomische_Bezugssysteme#Beobachtungen_in_der_Nähe_der_Ekliptik|Beobachtungen in der Nähe der Ekliptik]]".
** Die '''fünf Brote''' können mit den fünf mit bloßem Auge sichtbaren Wandelgestirnen (Planeten) '''Merkur''', '''Venus''', '''Mars''', '''Jupiter '''und '''Saturn''' gleichgesetzt werden.<br/>'''''Anmerkung''': In den deutschsprachigen Bibelübersetzungen wird in der Regel nicht zwischen Fixsternen und Planeten unterschieden. Für eine Ausnahme siehe 2. Buch der Könige, Kapitel 23, Vers 5 aus dem siebenten vorchristlichen Jahrhundert, wo in der Einheitsübersetzung explizit von "den Wandelsternen" und in der Luther-Bibel von "den Planeten" die Rede ist.<ref>[https://www.bibleserver.com/EU/2.K%C3%B6nige23%2C5 2. Buch der Könige, Kapitel 23, Vers 5], bibleserver.com, Einheitsübersetzung 2016</ref> Die Vulgata schreibt hier allerdings von den "duodecim signis" (zu Deutsch: "'''zwölf''' Zeichen"), womit die '''zwölf''' Sternzeichen der Ekliptik gemeint sind, durch die die '''sieben''' Wandelgestirne ziehen. Die Septuaginta spricht noch allgemeiner von den "μαζουρωθ" ("mazuroth") nach dem Hebräischen Wort "מַזָּלָה" ("mazzaroth"), womit allgemein eher Sternkonstellationen und nur im engeren Sinne die Sternzeichen des Zodiaks gemeint sind.''
** Die '''zwei Fische''' können also mit den beiden flächenhaft wahrnehmbaren Wandelgestirnen '''Sonne''' und '''Mond '''gleichgesetzt werden.
** Die Summe der '''fünf Brote''' und der '''zwei Fische''' respektive die '''sieben Brote''' (oder die '''sieben Körbe''') entsprechen der Anzahl der freiäugig sichtbaren '''sieben Wandelgestirne''', die sich entlang der Ekliptiklinie stetig gegenüber dem Fixsternhimmel bewegen. Siehe hierzu auch "[[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Die_Plejaden#Zusammenhang_mit_dem_Stier|Zu den Etyma und den Kognaten von "Sieben", "Stier", "Gestirn" und "Stern"]]".
** Die ausgeteilten '''Brote''' und '''Fische''' durchmaßen die gesamte versammelte Menschenmenge, die durch den vollständigen [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Astronomische_Bezugssysteme#Der_Zodiak|Lebewesenkreis (Zodiak)]] mit den '''zwölf Lebewesenkreiszeichen''' beziehungsweise durch die '''zwölf Körbe''' symbolisiert wird. Der Planet Jupiter, der den Zodiak in zwölf Jahren einmal durchläuft, wurde in Babylonien mit dem babylonischen Hauptgott Marduk gleichgesetzt.
* Insgesamt gibt es am Fixsternhimmel gut 2800 Sterne bis zur scheinbaren Helligkeit 5,5<sup>m</sup> und um die 9000 Sterne bis zur scheinbaren Helligkeit 6,5<sup>m</sup>, die ohne Lichtverschmutzung mit bloßem Auge als einzelne Lichtpunkte gesehen werden können. Diese verteilen sich allerdings in der gesamten Himmelssphäre, so dass von einem Punkt auf der Erdoberfläche aus zu jedem Zeitpunkt immer nur ungefähr die Hälfte davon über dem Horizont steht. An den beiden Polen sind stets nur die Sterne der entsprechenden nördlichen beziehungsweise südlichen Hemisphäre zu sehen, und vom Äquator aus können im Laufe eines Jahres alle Sterne gesehen werden. Je nach Breitengrad können in den wolkenlosen Nächten eines vollständigen Jahres bei Abwesenheit von Streulicht, wie zum Beispiel verursacht durch den Mond, mindestens viereinhalbtausend Sterne beobachtet werden.<ref>Bob King: [https://skyandtelescope.org/astronomy-blogs/how-many-stars-night-sky-09172014/ 9,096 Stars in the Sky—Is that all? How many stars in the sky can you see?], skyandtelescope.org - The essential Guide to Astronomy, 17. September 2014</ref> Diese Anzahl entspricht dem Mittelwert der Spanne der bei der Brotvermehrung versammelten Menschen, deren Anzahl in den Evangelien mit '''viertausend''' beziehungsweise '''fünftausend''' angegeben ist.
** Im ersten Buch des Alten Testaments ('''Genesis''') wird Abram aus Ur in Mesopotamien bereits das Folgende prophezeit:
<blockquote>
15,5 ''Sieh doch zum Himmel hinauf und zähl die Sterne, wenn du sie zählen kannst! Und er sprach zu ihm: So zahlreich werden deine Nachkommen sein''<br/>
...<br/>
17,5 ''Man wird dich nicht mehr Abram nennen. Abraham, Vater der Menge, wird dein Name sein; denn zum Stammvater einer Menge von Völkern habe ich dich bestimmt.''
</blockquote>
* Die Gruppen von (ungefähr) '''fünfzig''' oder '''hundert Männern''' entsprechen den Sternbildern, die über den gesamten Himmel verteilt sind. Nach der Festlegung der Internationalen Astronomischen Union (IAU) von 1930 gibt es heute 88 Sternbilder, die den Himmel vollständig abdecken. Mit den maximal ungefähr 8800 freiäugig sichtbaren Sternen entspricht dies im Mittel also 100 Sternen pro Sternbild. Bei 4400 freiäugig sichtbaren Sternen wären es 50 Sterne pro Sternbild. Diese Abschätzung entspricht genau der Spanne der Gruppenstärken, die im Neuen Testament angegeben sind.
* Das '''Brot''' und der '''Wein''' werden nach der christlichen Lehre bei der Transsubstantiation in den Leib und das Blut des vom '''Himmel''' herabgekommenen "Brot des Lebens" (vergleiche die Rede über das Himmelsbrot von Jesus in der Synagoge von Kafarnaum in Evangelium nach Johannes 6,48–58) gewandelt, das die kosmische Ewigkeit verheißt.
Die Zahlen '''Zwei''', '''Fünf''', '''Sieben''' und '''Zwölf''' stehen in einem einfachen arithmetischen Zusammenhang, bei dem die beiden jeweils vorhergehenden Zahlen der Folge addiert werden:
{| class="wikitable"
|+
|'''Zahl'''
|'''Summe'''
|'''Anmerkung'''
|-
|'''2'''
|
|Anzahl der freiäugig als '''flächenhaft wahrnehmbaren Wandelgestirne''' ('''Sonne''' und '''Mond'''), siehe [[Quadriviale_Kuriositäten/_Zahlen#Zur_Zwei|"Zur Zwei"]]
|-
|'''5'''
|
|Anzahl der freiäugig als '''punktförmig wahrnehmbaren Wandelgestirne''' '''Merkur''', '''Venus''', '''Mars''', '''Jupiter''', '''Saturn'''
|-
|'''7'''
|= 2 + 5
|Anzahl der freiäugig wahrnehmbaren '''Wandelgestirne''' sowie der '''Tage in der Woche''', siehe [[Quadriviale_Kuriositäten/_Zahlen#Zur_Sieben|"Zur Sieben"]]
|-
|'''12'''
|= 5 + 7
|Anzahl der '''Monate im Jahr''', der '''Lebewesenkreiszeichen des Zodiaks''' sowie der '''Erdenjahre pro Jupiterjahr''', siehe [[Quadriviale_Kuriositäten/_Zahlen#Zur_Zwölf|"Zur Zwölf"]], vergleiche hierzu auch [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Astronomische_Bezugssysteme#Der_Zodiak|"Der Zodiak"]]
|-
|'''19'''
|= 7 + 12
|Anzahl der '''Jahre''' mit '''zwölf Monaten''' und '''sieben Schaltmonaten''' einer '''Meton-Periode''', siehe [[Quadriviale_Kuriositäten/_Zahlen#Zur_Neunzehn|"Zur Neunzehn"]], vergleiche hierzu auch [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Die_Plejaden#Schaltregeln|"Die Plejaden-Schaltregeln"]] und [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Mondzyklen#Der_Meton-Zyklus|"Der Meton-Zyklus"]]
|}
=== Weitere Bezüge ===
Weitere Bezüge von der Astronomie zur Theologie ergeben sich bei den folgenden Sachverhalten:
→ Siehe [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Konjunktionen#Biblische_Erwähnungen|'''biblische Erwähnungen von Konstellationen''']].
→ Siehe [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Konjunktionen#Der_Stern_von_Bethlehem|'''Der Stern von Bethlehem''']].
→ Siehe [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Konjunktionen#Ochs_und_Esel|'''Ochs und Esel / Krippe / „Ich bin das Alpha und das Omega“''']].
→ Siehe [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Konjunktionen#Biblische_Bezüge|'''Biblische Bezüge zu den Mondhäusern / Mondstationen''']].
== Zur Kosmologie ==
[[Datei:Kosmologisches.Modell.Schwarze.Schale.Rotverschiebung.png|mini|rechts|hochkant=2.5|Ein kosmologisches Modell unseres im Zentrum isotropen und inhomogenen Universums, das von einer undurchsichtigen und massereichen schwarzen Kugelschale umgeben ist. Von der äußeren Region aus betrachtet, ist unser Universum ein gigantisches Schwarzes Loch. Zwischen dem inneren und dem äußeren Bereich der schwarzen Kugelschale ist kein Informationsaustausch möglich. Jegliche Materie, die von innen oder außen in die schwarze Kugelschale gelangt, ist von innen und von außen nicht mehr sichtbar. Sowohl die innere als auch die äußere Grenze der schwarzen Kugelschale stellen demzufolge einen Ereignishorizont dar.]]
Die '''Kosmologie''' beschäftigt sich mit der Struktur, dem Ursprung und der Entwicklung des Universums. Dadurch ergeben sich zahlreiche Bezüge zur beobachtenden '''Astronomie''' und zur '''Astrophysik''', aber auch zur '''Quantenphysik'''.
In der Antike gingen die Menschen noch davon aus, dass sich die Erde im Mittelpunkt der Welt und somit auch in der Mitte des sichtbaren Universums befindet. Dieses geozentrische Weltbild wurde seit dem 16. Jahrhundert, ausgelöst durch die kopernikanische Wende, zunehmend verworfen und durch ein heliozentrisches Weltbild ersetzt. Durch die Erfindung und Verwendung von Fernrohren konnten seit dem Beginn des 17. Jahrhunderts immer mehr Details im Sternenhimmel entdeckt werden. Durch astronomische Beobachtungen ergaben sich immer mehr Indizien für die Tatsache, dass die Erde einmal pro Jahr auf einer Ellipsenbahn die Sonne umrundet und nicht die Sonne die Erde umkreist. Der Philosoph Immanuel Kant (1724–1804) erkannte bereits 1755 in seiner Allgemeinen Naturgeschichte und Theorie des Himmels das innere Wesen unserer Milchstraße. Mit der ersten zuverlässigen Messung der Parallaxe von unserer Erde zum benachbarten Fixstern 61 Cygni ("Bessel's Stern") durch Friedrich Wilhelm Bessel (1784–1846) in Königsberg und der daraus folgenden Berechnung von dessen Entfernung von gut zehn Lichtjahren im Jahr 1838 war die Tatsache, dass die Erde um die Sonne läuft, endgültig bewiesen.
Die Auswertung der astronomischen Beobachtungen hat zu der heute allgemein geteilten Auffassung geführt, dass unser Universum bei einem Urknall entstanden ist und seitdem expandiert. Die Berücksichtigung des Äquivalenzprinzips zwischen schwerer und träger Masse, das zu der von '''Albert Einstein''' (1879–1955) formulierten Allgemeinen Relativitätstheorie führt, brachte '''Alexander Friedmann''' (1888–1925) 1922 zu der theoretischen Vorhersage eines dynamischen Universums. Fünf Jahre später schlussfolgerte der belgische Astronom '''Georges Lemaître''' (1894–1966) aus den von '''Vesto Slipher''' (1875–1969) beobachteten Rotverschiebungen von fernen Galaxien und den von '''Edwin Hubble''' (1889–1953) ermittelten Entfernungen dieser Galaxien, dass das Universum expandiert. Aufgrund dieser Erkenntnis ergibt sich, dass das Universum einen Ursprung mit sehr kleinem Radius gehabt haben muss. Diesen Zustand nannte er "primordiales Atom" beziehungsweise "Uratom". In der Folgezeit etablierte sich für diesen initialen Vorgang der Begriff "'''Urknall'''" (im Englischen: "'''Big Bang'''").<ref>Markus Bautsch: ''[https://en.wikibooks.org/wiki/Moving_objects_in_retarded_gravitational_potentials_of_an_expanding_spherical_shell/Brief_historical_review Moving objects in retarded gravitational potentials of an expanding spherical shell / Brief historical review], Wikibook (englisch), 2024, abgerufen am 28. Februar 2026</ref>
Viele Astrophysiker versuchen heute mit dem sogenannten '''Standardmodell der Kosmologie''' (auch '''ΛCDM-Modell''' beziehungsweise Lambda-CDM-Modell, wobei "CDM" für "cold dark matter" steht, also für "kalte, dunkle Materie") die Entwicklung des Universums nachzubilden. Hierfür wenden sie das kosmologische Prinzip an, das von zwei grundlegenden Annahmen ausgeht:<ref>Markus Bautsch: ''[https://en.wikibooks.org/wiki/Moving_objects_in_retarded_gravitational_potentials_of_an_expanding_spherical_shell/Preface Moving objects in retarded gravitational potentials of an expanding spherical shell / Preface], Wikibook (englisch), 2024, abgerufen am 28. Februar 2026</ref>
# Das Weltall sei '''homogen''', was bedeutet, dass es in groben Zügen von jedem Punkt aus gleich aussieht.
# Das Weltall sei '''isotrop''', was besagt, dass es in groben Zügen in jede Richtung gleich aussieht.
Mit diesen Annahmen kann das Modell berechnet werden, und mit diversen zusätzlichen Annahmen stimmt es in vielerlei Hinsicht mit den astronomischen Beobachtungen überein. Zu den zusätzlichen Annahmen gehören die folgenden beiden hypothetischen Größen:
* '''Kalte, dunkle Materie''', die zwar der Gravitation unterläge, aber keine Wechselwirkung mit elektromagnetischer Strahlung zeigt.
* Eine '''kosmologische Konstante''' Λ, die eine '''dunkle Energie''' beschreibt und für die beschleunigte Expansion des Universums verantwortlich sei.
Weder für die Homogenität noch für die Isotropie des Kosmos konnten bislang Belege gefunden werden, und auch für die kalte dunkle Materie und die dunkle Energie konnte bislang keine physikalische Interpretation geliefert werden.
Ferner ist auch die Annahme, dass die Naturkonstanten unveränderliche Werte haben, nicht begründbar. Auf kosmischen Zeitskalen kann es durchaus Änderungen geben, die wir derzeit nicht messen können. Die gilt insbesondere für die Hubble-Konstante, die die Expansionsrate des Universums beschreibt, für die Gravitationskonstante, die die Anziehung zweier Massen beschreibt, oder für die kosmologische Konstante, die die beschleunigte Expansion des Universums beschreibt. In diesem Kontext sei darauf hingewiesen, dass unser Universum genauso groß ist wie ein Schwarzes Loch mit der Masse unseres Universums. Deshalb gehen einige Kosmologen davon aus, dass wir innerhalb eines Schwarzen Loches der Größe und Masse unseres Universums leben könnten.
Siehe hierzu auch: [[:en:Moving_objects_in_retarded_gravitational_potentials_of_an_expanding_spherical_shell|'''Moving objects in retarded gravitational potentials of an expanding spherical shell''']].
Darüber hinaus mehren sich Anzeichen und Hinweise, die gegen die Ergebnisse des Standardmodells der Kosmologie sprechen, beziehungsweise durch weitere Hypothesen, die physikalisch nicht begründet werden können, im Standardmodell berücksichtigt werden müssen. Die folgende unvollständige Liste soll hierzu einige Anhaltspunkte liefern:
* Präzise astronomische Beobachtungen zeigen, dass das Weltall auch auf großen Längenskalen '''nicht homogen''' ist, sondern Strukturen zeigt.
* Präzise astronomische Beobachtungen zeigen, dass das Weltall auch auf großen Längenskalen '''nicht isotrop''' ist (Asymmetrie der kosmischen Hintergrundstrahlung).
* Die Hubble-Konstante hat heute einen anderen Wert als früher ("'''Hubble tension'''"), was mit dem Standardmodell nicht im Einklang steht.
* Das beobachtete Vorkommen des am häufigsten auftretenden stabilen Isotops des dritten Elements im Periodensystem, des Alkalimetalls '''<math>{}^{7}_{3}\mathrm{Lithium}</math>''', ist mindestens dreimal geringer als vom Standardmodell vorhergesagt.
* Die '''Rotverschiebung von fernen Galaxien''' ist deutlich größer als es nach dem Standardmodell möglich wäre.
* Die beobachteten '''Rotationskurven von Spiralgalaxien''' stehen im Widerspruch zu den Ergebnissen des Standardmodells.
* Das Standardmodell ist nicht in der Lage, die Abwesenheit von '''Antimaterie''' im sichtbaren Teil des Universums zu erklären.
* Die im frühen Universum beobachteten '''primordialen Schwarzen Löcher und Galaxien''' mit explodierende '''Supernovae''' sowie dem Vorkommen von '''Sauerstoff''' stehen im Widerspruch zu den Ergebnissen des Standardmodells.
== Zur Astrologie ==
Eine Sonderstellung nimmt die '''{{w|Astrologie}}''' (zusammengesetzt mit dem altgriechischen ἄστρον ("astron"), zu Deutsch „Sternenlehre“) ein. Sie ist ein weiteres Beispiel für eine Disziplin, bei der grundlegende Kenntnisse über die Astronomie eine Voraussetzung sind. Sie versucht, Zusammenhänge zwischen den Konstellationen der Wandelgestirne oder astronomischen Ereignissen am Sternenhimmel mit irdischen Geschehnissen oder Veränderungen herzustellen, insbesondere was bestimmte Konjunktionen und daraus abgeleitete Prophezeiungen betrifft. Sie wurde bereits in Mesopotamien und in anderen alten Kulturkreisen von Astronomen ausgeübt. Noch der Astronom '''{{w|Johannes Kepler}}''' (1571–1630) hat als einer der letzten Astronomen einen wesentlichen Teil seiner Einkünfte durch die Erstellung von Horoskopen bestritten. Aber schon Aristoteles hatte festgestellt und beschrieben, dass die bei bestimmten Konstellationen am Himmel vorhergesagten Ereignisse nicht eingetreten waren.
Vor der Aufklärung haben astrologische Prophezeiungen noch eine große und weitreichende gesellschaftliche Bedeutung gehabt. Als Beispiel seien die Behauptungen des ersten im Kurfürstentum Brandenburg tätigen Astrologen '''{{w|Johannes Carion}}''' (1499–1537) genannt, der für 1524 eine Sintflut vorhersagte, die nicht eingetroffen ist.<ref>{{Literatur |Autor=Markus Bautsch, Friedhelm Pedde |Titel=Vor 500 Jahren: Die Sintflut von 1524 die nicht stattfand |Online=https://wfs.berlin/wp-content/uploads/2024/05/A19-BROplanetA4_40s-feb2024ff_www-rz.pdf |Sammelwerk=Dem Himmel nahe. |WerkErg=Mitteilungen der Wilhelm-Foerster-Sternwarte e.V.|Nummer=19 |Hrsg=Wilhelm-Foerster-Sternwarte e.V. / Zeiss-Planetarium am Insulaner |Ort=Berlin |Datum=2024-02 |Seiten=16–19 |Sprache=de |Abruf=2025-08-03|ISSN=2940-9330}}</ref> Der Wiener Hofastronom '''{{w|Georg Tannstetter}}''' (1482–1535) sah sich 1523 bemüßigt, die schon lange im Voraus erhitzten und besorgten Gemüter zu beruhigen:<ref>Georg Tannstetter: ''Libellus consolatorius contra opiniones de diluvio et aliis horrendis periculis anni 1523''</ref>
<blockquote>
Nun hat sich überall, in allen Köpfen, in allen Seelen das Gerücht eingeschlichen:<br/>
die Gelehrten und Weisen sind in ständigem Streitgespräch, andere hingegen sind derart verstört, dass sie ihren Geschäften nicht mehr nachgehen können; sie verkaufen ihre Anwesen, ihre Felder und Besitztümer oder lassen davon ab, Güter zu kaufen, in der Hoffnung, ihr Geld leichter in die sicheren Berge transportieren zu können. Andere wiederum verschieben ihr Heiratsversprechen, kündigen ohne scheinbaren Grund Verträge auf, entziehen sich ihren christlichen Gelübden, arbeiten faul und missmutig auf dem Land und fragen sich, was es denn nütze, Geld und Gut anzuhäufen, wenn doch in kürzester Zeit niemand mehr davon Nutzen ziehen könne.
</blockquote>
'''→ Siehe auch:'''
* [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Konjunktionen#Definition|'''Konjunktionen''', Abschnitt '''Definition''']].
* [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Konjunktionen#Historische_Konjunktionen|'''Historische Konjunktionen''']].
* [[Astronomie_von_der_Frühgeschichte_bis_zur_Neuzeit/_Astronomische_Bezugssysteme#Beobachtungen_in_der_Nähe_der_Ekliptik|'''Beobachtungen in der Nähe der Ekliptik''']].
<div style="clear:both"></div>
== Einzelnachweise ==
<references></references>
kbvyi2bwsysvsukkvqrrs0fgbzem1p4
OpenSCAD Benutzerhandbuch/ BOSL2-2D
0
123349
1093525
1093523
2026-11-08T12:20:39Z
Jowi-ammerbuch
115360
/* Sterne (Stars) */
1093525
wikitext
text/x-wiki
{{MyNavi
|zurück = [[OpenSCAD Benutzerhandbuch/_BOSL2-Distributoren|Zurück]]
|buch = [[OpenSCAD Benutzerhandbuch/_BOSL2|BOSL2-Inhalt]]
|weiter = [[OpenSCAD Benutzerhandbuch/_BOSL2-3D|Weiter]]
}}
== 2D Grundformen (2D Primitive) ==
OpenSCAD bietet zwei eingebaute 2D-Grundformen: <code>square()</code> und <code>circle()</code>. Du kannst sie weiterhin auf die gewohnte Weise verwenden:
<pre class="openscad">include <BOSL2/std.scad>
square([60,40], center=true);</pre>
<pre class="openscad">include <BOSL2/std.scad>
circle(r=50);</pre>
<pre class="openscad">include <BOSL2/std.scad>
circle(d=100, $fn=8);</pre>
Diese Module wurden in der BOSL2-Bibliothek in drei Bereichen erweitert: Verankerung (Anchoring), Drehung (Spin) und Anhängbarkeit (Attachability).
<span id="verankerung-anchoring"></span>
=== Verankerung (Anchoring): ===
Wenn du ein <code>square()</code> erstellst, kannst du angeben, welche Ecke oder Seite am Ursprung verankert werden soll. Dies ersetzt das <code>center=</code>-Argument und ist flexibler. Das <code>anchor=</code>-Argument nimmt einen Vektor als Wert entgegen, der in grober Richtung der Seite oder Ecke zeigt, die du am Ursprung ausrichten möchtest.
=== anchor=[0,1] oder anchor=BACK ===
[[Datei:BOSL2-anchor-0-1.png|mini|zentriert|alternativtext=anchor=[0,1]);|square([60,40], '''anchor=[0,1]''');<br>
Oder: square([60,40], '''anchor=BACK''');]]
Um beispielsweise das '''Zentrum der hinteren Kante am Ursprung''' auszurichten, setzt du den Anker auf <code>[0,1]</code>:
<pre class="openscad">
include <BOSL2/std.scad>
square([60,40], anchor=[0,1]);
</pre>
Mit den leichter verständlichen vordefinierten '''Vektor-Konstanten''':
<pre class="openscad">
include <BOSL2/std.scad>
square([60,40], anchor=BACK+CENTER);
</pre>
=== anchor=[1,-1] oder anchor=RIGHT+FRONT ===
Um die '''vordere rechte Ecke am Ursprung''' auszurichten:
[[Datei:BOSL2-anchor-1 -1.png|mini|zentriert|alternativtext=anchor=RIGHT+FRONT);|square([60,40], '''anchor=[1,-1]''');<br>
Oder: square([60,40], '''anchor=RIGHT+FRONT''');]]
<pre class="openscad">
include <BOSL2/std.scad>
square([60,40], anchor=[1,-1]);
</pre>
'''Mit Vektor-Konstanten:'''
<pre class="openscad">
include <BOSL2/std.scad>
square([60,40], anchor=RIGHT+FRONT);
</pre>
=== anchor=[0,0] oder anchor=CENTER '''Fetter Text'''===
Um es zu '''zentrieren''':
<pre class="openscad">
include <BOSL2/std.scad>
square([60,40], anchor=[0,0]);
</pre>
'''Mit Vektor-Konstanten:'''
<pre class="openscad">
include <BOSL2/std.scad>
square([60,40], anchor=CENTER);
</pre>
=== Vektor-Konstanten am Rechteck ===
Um die Angabe von Vektoren übersichtlicher zu gestalten, sind mehrere Standard-Vektorkonstanten definiert:
[[Datei:BOSL2-anchor-Konstanten-Rechteck.png|gerahmt|zentriert|alternativtext=BOSL2 vordefinierte anchor-Konstanten|Die in BOSL2 vordefinierten anchor-Konstanten]]
{| class="wikitable"
|-
! Konstante
! Richtung
! Wert
|-
| LEFT
| X-
| [-1, 0, 0]
|-
| RIGHT
| X+
| [ 1, 0, 0]
|-
| FRONT / FORWARD / FWD
| Y-
| [ 0,-1, 0]
|-
| BACK
| Y+
| [ 0, 1, 0]
|-
| BOTTOM / BOT / BTM / DOWN
| Z-
| [ 0, 0,-1] (nur 3D)
|-
| TOP / UP
| Z+
| [ 0, 0, 1] (nur 3D)
|-
| CENTER / CTR
| Zentriert
| [ 0, 0, 0]
|}
Beachte, dass du die meisten dieser Konstanten (außer <code>UP</code>/<code>DOWN</code> natürlich) auch für Anker bei 2D-Formen verwenden kannst, obwohl es sich um 3D-Vektoren handelt:
<pre class="openscad">include <BOSL2/std.scad>
square([60,40], anchor=BACK);</pre>
<pre class="openscad">include <BOSL2/std.scad>
square([60,40], anchor=CENTER);</pre>
Du kannst Vektoren addieren, um auf Ecken zu zeigen:
<pre class="openscad">include <BOSL2/std.scad>
square([60,40], anchor=FRONT+RIGHT);</pre>
=== anchor = polar_to_xy ===
Für <code>circle()</code> kann der Ankervektor auf jeden beliebigen '''Punkt des Kreisumfangs''' zeigen:
[[Datei:BOSL2-anchor-polar to xy-circle.png|gerahmt|zentriert|alternativtext=anchor = polar_to_xy|anchor = polar_to_xy(1,Alpha), für Alpha = 0, 45, 90, ...]]
==== Beispiel: anchor=polar_to_xy(1,45) =====
[[Datei:BOSL2-anchor-polar to 1-45-octagon.png|mini|zentriert|alternativtext=circle(d=50, anchor=polar_to_xy(1,45), $fn = 8);|circle(d=50, anchor=polar_to_xy(1,45), $fn = 8);]]
<pre class="openscad">
include <BOSL2/std.scad>
circle(d=50, anchor=polar_to_xy(1,45), $fn = 8);
</pre>
Beachte, dass der Radius für den Anker keine Rolle spielt, da nur die Richtung des Ankers das Ergebnis beeinflusst.
=== show_anchors() ===
[[Datei:BOSL2-show anchor.png|mini|zentriert|show_anchors]]
Du kannst die typischen Ankerpunkte sehen, indem du <code>show_anchors()</code> als Kind der Form übergibst:
<pre class="openscad">include <BOSL2/std.scad>
square([60,40], center=true)
show_anchors();</pre>
<pre class="openscad">include <BOSL2/std.scad>
circle(d=50)
show_anchors();</pre>
<span id="drehung-spin"></span>
=== Drehung (Spin): ===
Die zweite Erweiterung von <code>square()</code> und <code>circle()</code> ist die Drehung (Spin). Wenn du die Form erstellst, kannst du sie mit dem <code>spin=</code>-Argument an Ort und Stelle drehen. Du übergibst einfach die Anzahl der Grad, um die sie im Uhrzeigersinn gedreht werden soll:
<pre class="openscad">include <BOSL2/std.scad>
square([60,40], anchor=CENTER, spin=30);</pre>
Die Verankerung oder Zentrierung erfolgt vor der Drehung:
<pre class="openscad">include <BOSL2/std.scad>
square([60,40], anchor=BACK, spin=30);</pre>
Bei Kreisen kann Spin nützlich sein, wenn auch <code>$fn=</code> angegeben wird:
<pre class="openscad">include <BOSL2/std.scad>
circle(d=50, $fn=6, spin=15);</pre>
Da die Verankerung vor der Drehung erfolgt, kannst du beides zusammen verwenden, um um den Anker herum zu drehen:
<pre class="openscad">include <BOSL2/std.scad>
circle(d=50, $fn=6, anchor=LEFT, spin=15);</pre>
<span id="anhängbarkeit-attachability"></span>
=== Anhängbarkeit (Attachability): ===
Die dritte Erweiterung von <code>square()</code> und <code>circle()</code> ist, dass du sie auf verschiedene Weise an Ankerpunkten zusammenhängen kannst. Dies geschieht, indem du eine Form zum Kind der Form machst, an die du sie anhängen möchtest.
==== Standard (ohne Spez. für anchor oder position) ====
Standardmäßig wird das Kind beim einfachen Untereinanderstellen im Zentrum der Elternform angehängt.
[[Datei:BOSL2-attach-standard-normal.png|mini|zentriert|alternativtext=square(50) #square(50);|square(50) #square(50);<br>
Kind-Objekt (rot) wird ans Zentrum des Elternobjekts angehängt]]
<pre class="openscad">
include <BOSL2/std.scad>
square(50) #square(50);
</pre>
==== anchor für child spezifiziert ====
[[Datei:BOSL2-attach-anchor-LEFTplusFWD.png|mini|zentriert|alternativtext=square(50, center=true) #square([20,40], anchor=LEFT+FWD);|square(50, center=true)#square([20,40], '''anchor=LEFT+FWD''');]]
<pre class="openscad">include <BOSL2/std.scad>
square(50, center=true)
#square([20,40], anchor=LEFT+FWD);</pre>
==== position() ====
[[Datei:BOSL2-attach-position.png|mini|zentriert|alternativtext=position(RIGHT)|square(50) '''position(RIGHT)''' #square(25) '''position(BACK)''' #square(25);]]
Durch Hinzufügen des <code>position()</code>-Moduls kannst du das Kind an jedem Ankerpunkt '''des Elternteils''' positionieren, das "Kindes-Kind wird am Ankerpunkt des übergeordneten Objekts positioniert:
<pre class="openscad">
include <BOSL2/std.scad>
square(50) position(RIGHT) #square(25)
position(BACK) #square(25);
</pre>
==== orient() ====
Ankerpunkte sind jedoch nicht nur Positionen auf dem Elternteil. Sie haben auch eine Ausrichtung. In den meisten Fällen zeigt die Ausrichtung eines Ankerpunkts nach außen, weg von der Fläche der Wand, also im Allgemeinen vom Zentrum der Form weg.
[[Datei:BOSL2-show anchor.png|mini|zentriert|show_anchors]]
Wenn du das Kind so ausrichten möchtest, dass es der Ausrichtung eines Ankerpunkts entspricht, kannst du das <code>orient()</code>-Modul verwenden. Es positioniert das Kind nicht, es dreht es nur:
[[Datei:BOSL2-attach-orient anchor.png|mini|zentriert|alternativtext= orient(anchor=LEFT+BOTTOM)|square(50) '''orient(anchor=LEFT+BOTTOM)''' #square([10,40]);]]
<pre class="openscad">include <BOSL2/std.scad>
square(50)
orient(anchor=LEFT+BOTTOM) #square([10,40]);</pre>
Das geht auch beim '''Kreis (circle)''' mit '''polar_to_xy''':
[[Datei:BOSL2-attach-orient polar to xy circle.png|mini|zentriert|alternativtext=orient(polar_to_xy(1,30))|circle(d=50) ''' orient(polar_to_xy(1,30))''' #square([10,40], anchor=FWD);]]
<pre class="openscad">include <BOSL2/std.scad>
circle(d=50)
orient(polar_to_xy(1,30))
#square([10,40], anchor=FWD);</pre>
==== position() + orient() ====
Du kannst <code>position()</code> und <code>orient()</code> zusammen verwenden, um sowohl zu positionieren als auch an einem Ankerpunkt auszurichten:
[[Datei:BOSL2-attach-position pluss orient polar to xy circle.png|mini|zentriert|alternativtext=position(polar_to_xy(1,30)) orient(polar_to_xy(1,30))|circle(d=50) '''position(polar_to_xy(1,30)) orient(polar_to_xy(1,30))''' #square([10,40], anchor=FWD);]]
<pre class="openscad">include <BOSL2/std.scad>
circle(d=50)
position(polar_to_xy(1,30))
orient(polar_to_xy(1,30))
#square([10,40], anchor=FWD);</pre>
=== attach () mit einem Argument ===
Aber es ist einfacher das <code>attach()</code>-Modul zu verwenden, um beides auf einmal zu erledigen:
[[Datei:BOSL2-attach-position pluss orient polar to xy circle.png|mini|zentriert|alternativtext=attach(polar_to_xy(1,30))|circle(d=50) '''attach(polar_to_xy(1,30))''' #square([10,40], anchor=FWD); ]]
Gleiches Ergebnis, aber übersichtlicherer Code.
<pre class="openscad">include <BOSL2/std.scad>
square(50, center=true)
attach(LEFT+BACK)
#square([10,40], anchor=FWD);</pre>
=== attach () mit zwei Argumenten ===
Anstatt den <code>anchor=</code> im Kind anzugeben, kannst du ein '''zweites Argument''' an <code>attach()</code> übergeben, das ihm sagt, welche Seite des Kindes mit dem Elternteil verbunden werden soll:
<pre class="openscad">
include <BOSL2/std.scad>
circle(d=50) attach(polar_to_xy(1,30), FWD) #square([10,40]);
</pre>
Damit lässt sich der Code noch mehr straffen.
[[Datei:BOSL2-attach-position pluss orient polar to xy circle.png|mini|zentriert|alternativtext=attach(polar_to_xy(1,30), FWD)|circle(d=50) '''attach(polar_to_xy(1,30), FWD)''' #square([10,40]); ]]
<span id="rechtecke-rectangles"></span>
== Rechtecke (Rectangles) ==
=== rect() ===
Die BOSL2-Bibliothek bietet eine Alternative zu <code>square()</code>, die mehr Funktionen unterstützt. Sie heißt <code>rect()</code>. Du kannst sie genauso verwenden wie <code>square()</code>, aber sie bietet auch erweiterte Funktionalität.
=== rect() mit rounding ===
[[Datei:BOSL2-rect rounding.png|mini|zentriert|alternativtext=rounding=10|rect([60,40], '''rounding=10''');]]
rect() erlaubt dir, die Ecken des Rechtecks abzurunden:
<pre class="openscad">include <BOSL2/std.scad>
rect([60,40], rounding=10);</pre>
=== rect() mit chamfer ===
[[Datei:BOSL2-rect chamfer.png|mini|zentriert|alternativtext=rect([60,40], chamfer=10);|rect([60,40], '''chamfer=10''');]]
Du kannst die Ecken des Rechtecks auch abfasen:
<pre class="openscad">include <BOSL2/std.scad>
rect([60,40], chamfer=10);</pre>
=== Unterschiedliche Abrundungen und Fasen an einem Rechteck ===
Du kannst sogar angeben, welche Ecken abgerundet oder abgefast werden. Wenn du eine Liste mit vier Größenwerten an die <code>rounding=</code>- oder <code>chamfer=</code>-Argumente übergibst, erhält jede Ecke ihre eigene Größe. Der Reihe nach geht es von der hinteren rechten Ecke (Quadrant I) gegen den Uhrzeigersinn zur hinteren linken Ecke (Quadrant II), zur vorderen linken Ecke (Quadrant III) und zur vorderen rechten Ecke (Quadrant IV):
Wenn eine Größe als <code>0</code> angegeben wird, gibt es keine Rundung und/oder Fase für die Ecke dieses Quadranten:
<pre class="openscad">include <BOSL2/std.scad>
rect([60,40], rounding=[0,5,10,15]);</pre>
<pre class="openscad">include <BOSL2/std.scad>
rect([60,40], chamfer=[0,5,10,15]);</pre>
Du kannst sowohl <code>rounding=</code>- als auch <code>chamfer=</code>-Argumente angeben, um Rundung und Fase zu mischen, aber nur, wenn du es pro Ecke angibst. Wenn du eine Rundung in einer Ecke möchtest, gib eine Fase von 0 für diese Ecke an und umgekehrt:
[[Datei:BOSL2-rect chamfer-rounding-mixed.png|mini|zentriert|alternativtext=ounding=[5,0,10,0], chamfer=[0,5,0,15]|rect([60,40], '''rounding=[5,0,10,0], chamfer=[0,5,0,15]''');]]
<pre class="openscad">include <BOSL2/std.scad>
rect([60,40], rounding=[5,0,10,0], chamfer=[0,5,0,15]);</pre>
<span id="ellipsen-ellipses"></span>
== Ellipsen (Ellipses) ==
Die BOSL2-Bibliothek bietet auch eine erweiterte Entsprechung von <code>circle()</code>, die <code>ellipse()</code> heißt. Du kannst sie genauso verwenden wie <code>circle()</code>, aber sie bietet auch erweiterte Funktionalität. Zum Beispiel erlaubt sie mehr Kontrolle über ihre Größe.
Da ein Kreis in OpenSCAD nur durch ein regelmäßiges Polygon mit einer Anzahl gerader Seiten angenähert werden kann, kann dies zu Ungenauigkeiten in Größe und Form führen. Um dem entgegenzuwirken, werden auch die Argumente <code>realign=</code> und <code>circum=</code> bereitgestellt.
=== realign= (ellipse-Argument) ===
Das <code>realign=</code>-Argument rotiert, wenn es auf <code>true</code> gesetzt wird, die <code>ellipse()</code> um den halben Winkel zwischen den Polygonseiten:
[[Datei:BOSL2-ellipse-realign.png|mini|zentriert|alternativtext=realign=true|#ellipse(d=100, $fn=8); color("lime") ellipse(d=100, $fn=8, '''realign=true''');]]
<pre class="openscad">
include <BOSL2/std.scad>
#ellipse(d=100, $fn=8);
color("lime") ellipse(d=100, $fn=8, realign=true);
</pre>
=== circum= (ellipse-Argument) ===
[[Datei:BOSL2-ellipse-circum.png|mini|zentriert|alternativtext=circum=true|Vergleich: rot (außen) mit circum=true und blau (innen) ohne circum. Referenz: idealer Kreis in gelb.]]
<pre class="openscad">
include <BOSL2/std.scad>
color("red") ellipse(d=100, $fn=6, circum=true);
color("yellow") ellipse(d=100, $fn=360);
color("blue") ellipse(d=100, $fn=6);
</pre>
Das <code>circum=</code>-Argument bewirkt, wenn es auf true gesetzt wird, dass das Polygon, das die <code>ellipse()</code> bildet, den idealen Kreis '''umschreibt''', anstatt ihn einzuschreiben.
Den idealen Kreis ''einschreiben'':
<pre class="openscad">include <BOSL2/std.scad>
color("green") ellipse(d=100, $fn=360);
ellipse(d=100, $fn=6);</pre>
Den idealen Kreis ''umschreiben'':
<pre class="openscad">include <BOSL2/std.scad>
ellipse(d=100, $fn=6, circum=true);
color("green") ellipse(d=100, $fn=360);</pre>
=== Ellipse mit 2 Radien ===
Das <code>ellipse()</code>-Modul kann, wie der Name schon sagt, mit separaten X- und Y-Radien oder -Durchmessern angegeben werden. Dazu gibst du einfach <code>r=</code> oder <code>d=</code> mit einer Liste von zwei Radien oder Durchmessern an:
[[Datei:BOSL2-ellipse-2Radien.png|mini|zentriert|alternativtext=2 Radien|ellipse('''r=[30,20]''');]]
==== r=[r1,r2] ====
<pre class="openscad">include <BOSL2/std.scad>
ellipse(r=[30,20]);</pre>
==== d=[d1,d2]====
<pre class="openscad">include <BOSL2/std.scad>
ellipse(d=[60,40]);</pre>
==== ellipse mit anchor ====
Wie bei <code>circle()</code> kannst du <code>ellipse()</code>-Formen verankern, drehen und anhängen:
[[Datei:BOSL2-ellipse-anchor.png|mini|zentriert|alternativtext=ellipse mit anchor|ellipse(d=[50,20], '''anchor=BACK'''); #ellipse(d=[50,20], '''anchor=FRONT''');]]
<pre class="openscad">
include <BOSL2/std.scad>
ellipse(d=[50,20], anchor=BACK);
#ellipse(d=[50,20], anchor=FRONT);
</pre>
==== ellipse mit attach ====
[[Datei:BOSL2-ellipse-attach.png|mini|zentriert|alternativtext=ellipse mit attach|ellipse(d=50) '''attach(BACK+RIGHT, FRONT+LEFT)''' #ellipse(d=[40,20]);]]
<pre class="openscad">
include <BOSL2/std.scad>
ellipse(d=50)
attach(BACK+RIGHT, FRONT+LEFT)
ellipse(d=30);
</pre>
<span id="rechtwinklige-dreiecke-right-triangles"></span>
==== ellipse mit spin ====
[[Datei:BOSL2-ellipse-attach-spin-anchor.png|mini|zentriert|alternativtext=spin = 90 bei ellipse|ellipse(d=50) attach(BACK) #ellipse(d=[40,20], '''spin=90''', anchor=LEFT);]]
<pre class="openscad">
include <BOSL2/std.scad>
ellipse(d=50)
attach(BACK)
#ellipse(d=[40,20], spin=90, anchor=LEFT);
</pre>
== Rechtwinklige Dreiecke (Right Triangles) ==
Die BOSL2-Bibliothek bietet eine einfache Möglichkeit, ein 2D-rechtwinkliges Dreieck mit dem <code>right_triangle()</code>-Modul zu erstellen:
[[Datei:BOSL2-right triangle.png|mini|zentriert|alternativtext=right_triangle([40,30])|right_triangle([40,30]);]]
<pre class="openscad">include <BOSL2/std.scad>
right_triangle([40,30]);</pre>
=== xflip() bei right_triangle ===
Du kannst <code>xflip()</code> und <code>yflip()</code> verwenden, um zu ändern, in welchem Quadranten das Dreieck gebildet wird:
[[Datei:BOSL2-right triangle xflip.png|mini|zentriert|alternativtext=right_triange mit xflip()|right_triangle([40,30]); '''xflip()''' #right_triangle([40,30]);]]
<pre class="openscad">include <BOSL2/std.scad>
xflip() right_triangle([40,30]);</pre>
=== yflip() bei right_triangle ===
[[Datei:BOSL2-right triangle yflip.png|mini|zentriert|alternativtext=right_triangle([40,30]) mit yflip()|right_triangle([40,30]); '''yflip()''' #right_triangle([40,30]);]]
<pre class="openscad">include <BOSL2/std.scad>
yflip() right_triangle([40,30]);</pre>
=== xflip() & yflip() bei right_triangle ===
[[Datei:BOSL2-right triangle xflip yflip.png|mini|zentriert|alternativtext=xflip() yflip()|right_triangle([40,30]); xflip() yflip() #right_triangle([40,30]);]]
<pre class="openscad">include <BOSL2/std.scad>
xflip() yflip() right_triangle([40,30]);</pre>
=== spin= bei right_triangle ===
Oder alternativ einfach mit <code>spin=</code> in den richtigen Quadranten drehen:
[[Datei:BOSL2-right triangle spin.png|mini|zentriert|alternativtext=right_triangle([40,30]) mit spin=90)|right_triangle([40,30]);
#right_triangle([40,30], '''spin=90''');]]
<pre class="openscad">include <BOSL2/std.scad>
right_triangle([40,30], spin=90);</pre>
<pre class="openscad">include <BOSL2/std.scad>
right_triangle([40,30], spin=-90);</pre>
Du kannst bei rechtwinkligen Dreiecken auch Verankerung verwenden:
<pre class="openscad">include <BOSL2/std.scad>
right_triangle([40,30], anchor=FWD+RIGHT);</pre>
<span id="trapeze-trapezoids"></span>
== Trapeze (Trapezoids) ==
OpenSCAD bietet keine einfache Möglichkeit, allgemeine 2D-Dreiecke, Trapeze oder Parallelogramme zu erstellen. Die BOSL2-Bibliothek kann all diese Formen mit dem <code>trapezoid()</code>-Modul bereitstellen.
=== Dreieck ===
Um ein gleichseitiges Dreieck zu erstellen, setze einfach eine der Breiten auf null:
[[Datei:BOSL2-trapezoid dreieck.png|mini|zentriert|alternativtext=Dreieck|trapezoid(w1=50, w2=0, h=40);<br>
Dreieck mit Seitenlänge = 50]]
<pre class="openscad">include <BOSL2/std.scad>
trapezoid(w1=50, w2=0, h=40);</pre>
Um ein rechtwinkliges Dreieck zu erstellen, musst du das <code>shift=</code>-Argument verwenden, um die Rückseite des Trapezes entlang der X-Achse zu verschieben:
[[Datei:BOSL2-trapezoid dreieck-rechtwinklig.png|mini|zentriert|alternativtext=Rechtwinkliges Dreieck|trapezoid(w1=50, w2=0, h=50, shift=-25);]]
<pre class="openscad">include <BOSL2/std.scad>
trapezoid(w1=50, w2=0, h=50, shift=-25);</pre>
<pre class="openscad">include <BOSL2/std.scad>
trapezoid(w1=50, w2=0, h=50, shift=25);</pre>
<pre class="openscad">include <BOSL2/std.scad>
trapezoid(w1=0, w2=50, h=50, shift=-25);</pre>
<pre class="openscad">include <BOSL2/std.scad>
trapezoid(w1=0, w2=50, h=50, shift=25);</pre>
=== Trapez ===
Du kannst ein Trapez erstellen, indem du für vorne (<code>w1=</code>) und hinten (<code>w2=</code>) von null verschiedene Breiten angibst:
[[Datei:BOSL2-trapezoid trapez.png|mini|zentriert|alternativtext=Trapez|trapezoid(w1=30, w2=50, h=50);]]
<pre class="openscad">include <BOSL2/std.scad>
trapezoid(w1=30, w2=50, h=50);</pre>
=== Parallelogramm ===
Ein Parallelogramm ist nur eine Frage der Verwendung der gleichen Breite für vorne und hinten, mit einer Verschiebung entlang der X-Achse:
[[Datei:BOSL2-trapezoid parallelogram.png|mini|zentriert|alternativtext=Parallelogramm|trapezoid(w1=50, w2=50, shift=20, h=50);]]
<pre class="openscad">include <BOSL2/std.scad>
trapezoid(w1=50, w2=50, shift=20, h=50);</pre>
=== Viereck ===
Ein Viereck kann erstellt werden, indem ungleiche, von null verschiedene Breiten für vorne (<code>w1=</code>) und hinten (<code>w2=</code>) verwendet werden, wobei die Rückseite entlang der X-Achse verschoben wird:
[[Datei:BOSL2-trapezoid viereck.png|mini|zentriert|alternativtext=Viereck|trapezoid(w1=50, w2=30, shift=20, h=50);]]
<pre class="openscad">include <BOSL2/std.scad>
trapezoid(w1=50, w2=30, shift=20, h=50);</pre>
Du kannst <code>anchor=</code> und <code>spin=</code> verwenden, genau wie bei anderen anhängbaren Formen. Die Ausrichtungen der Ankerpunkte basieren jedoch auf den Seitenwinkeln der Flächen und sind möglicherweise nicht das, was du erwartest:
<pre class="openscad">include <BOSL2/std.scad>
trapezoid(w1=30, w2=50, h=50)
show_anchors();</pre>
<span id="regelmäßige-n-ecke-regular-n-gons"></span>
== Regelmäßige n-Ecke (Regular N-Gons) ==
OpenSCAD ermöglicht es dir, regelmäßige n-Ecke (Fünfeck, Sechseck usw.) zu erstellen, indem du <code>circle()</code> mit <code>$fn</code> verwendest. Obwohl dies prägnant ist, mag es auf den ersten Blick weniger offensichtlich sein:
<pre class="openscad">include <BOSL2/std.scad>
circle(d=50, $fn=5);</pre>
Die BOSL2-Bibliothek hat Module, die für gängige n-Ecke klarer benannt sind:
=== Pentagon (d=<Durchmesser>) ===
[[Datei:BOSL2-Pentagon.png|mini|zentriert|alternativtext=Pentagon|pentagon(d=50);]]
<pre class="openscad">include <BOSL2/std.scad>
pentagon(d=50);</pre>
=== Hexagon (d=<Durchmesser>) ===
[[Datei:BOSL2-Hexagon.png|mini|zentriert|alternativtext=Hexagon| hexagon(d=50);]]
<pre class="openscad">include <BOSL2/std.scad>
hexagon(d=50);</pre>
=== Octagon (d= <Durchmesser>) ===
[[Datei:BOSL2-Octagon.png|mini|zentriert|alternativtext=octagon(d=50);|octagon(d=50);]]
<pre class="openscad">include <BOSL2/std.scad>
octagon(d=50);</pre>
=== regular_ngon (n=<Seitenanzahl>, d=<Durchmesser>) ===
[[Datei:BOSL2-regular ngon.png|mini|zentriert|alternativtext=regular_ngon|regular_ngon(n=7, d=50);]]
<pre class="openscad">include <BOSL2/std.scad>
regular_ngon(n=7, d=50);</pre>
=== side=<Seitenlänge> ===
Diese Module bieten dir auch zusätzliche Funktionalität. Sie können nach Seitenlänge dimensioniert werden:
[[Datei:BOSL2-Hexagon side50.png|mini|zentriert|alternativtext=hexagon(side=50);|hexagon(side=50);]]
<pre class="openscad">include <BOSL2/std.scad>
pentagon(side=50);</pre>
=== ir = <Innenradius> / id = <Innendurchmesser> ===
Sie können nach dem Radius/Durchmesser des umschriebenen Kreises (Innenkreis) dimensioniert werden:
[[Datei:BOSL2-Pentagon Innenradius.png|mini|zentriert|alternativtext=Innenradius|color("red") pentagon('''ir=25'''); color("yellow") circle(r=25,$fn=100);]]
<pre class="openscad">include <BOSL2/std.scad>
pentagon(ir=25);
pentagon(id=50);</pre>
=== realign=true/false ===
Die Polygone können um eine halbe Seite gedreht werden:
[[Datei:BOSL2-Pentagon realign.png|mini|zentriert|alternativtext=realign|pentagon(d=50, '''realign=false'''); #pentagon(d=50, '''realign=true''');]]
<pre class="openscad">include <BOSL2/std.scad>
left(30) pentagon(d=50, realign=true);
right(30) pentagon(d=50, realign=false);</pre>
=== rounding = <Rundung> ===
Die BOSL2-Polygone können abgerundet werden:
[[Datei:BOSL2-Polygon-rounding.png|mini|zentriert|alternativtext=rounding|pentagon(d=50, '''rounding=5''');]]
<pre class="openscad">include <BOSL2/std.scad>
pentagon(d=50, rounding=5);</pre>
=== show_anchors() ===
Die BOSL2-Polygone haben auch ein etwas anderes Anhangsverhalten als die regulären Polygone, die über $fn=<Seitenanzahl> erzeugt werden.
Ein Kreis mit einem kleinen <code>$fn=</code> hängt Dinge am idealen Kreis an, nicht entlang des erstellten Polygons:
[[Datei:BOSL2-polygon-outcircle-anchors.png|mini|zentriert|alternativtext=anchors Außenkreis|color("green") stroke(circle(d=50), closed=true); circle(d=50,$fn=6) show_anchors();]]
<pre class="openscad">include <BOSL2/std.scad>
color("green") stroke(circle(d=50), closed=true);
circle(d=50,$fn=6)
show_anchors();</pre>
Während ein BOSL2-n-Eck entlang des Polygons selbst (direkt) anhängt:
[[Datei:BOSL2-polygon-direct-anchors.png|mini|zentriert|alternativtext=anchors BOSL2 Polygone direkt|color("green") stroke(circle(d=50), closed=true); circle(d=50,$fn=6) show_anchors();]]
<pre class="openscad">include <BOSL2/std.scad>
hexagon(d=50)
show_anchors(custom=false);</pre>
Du kannst <code>anchor=</code> und <code>spin=</code> verwenden, genau wie bei anderen anhängbaren Formen. Die Ankerpunkte basieren jedoch darauf, wo der Ankervektor die Seite des n-Ecks schneiden würde, und sind möglicherweise nicht dort, wo du sie erwartest:
[[Datei:BOSL2-Pentagon-anchor.png|mini|zentriert|alternativtext=n-Polygon anchor|pentagon(d=50, '''anchor=FRONT+LEFT''') show_anchors(custom=false);]]
<pre class="openscad">include <BOSL2/std.scad>
pentagon(d=50, anchor=FRONT+LEFT)
show_anchors(custom=false);</pre>
=== Ankerpunkte für Seiten und Spitzen ===
n-Ecke haben auch benannte Ankerpunkte für ihre Seiten und Spitzen:
[[Datei:BOSL2-anchor-Spitzen-Seiten.png|mini|zentriert|alternativtext=Anker für Seiten und Spitzen|Spezielle Anker für die Spitzen und Seiten eines Pentagons (mit TikZ unter LaTeX erstellt)]]
Beachte, dass die Ankernamen in "" gesetzt werden müssen.
Zum Beispiel:
[[Datei:BOSL2-Pentagon anchor tip1.png|mini|zentriert|alternativtext=anchor="tip1"|pentagon(d=30, '''anchor="tip1" ''');]]
<pre class="openscad">include <BOSL2/std.scad>
pentagon(d=30, anchor="tip1");</pre>
<span id="sterne-stars"></span>
Beispiel mit attach():
[[Datei:BOSL2-anchor-Spitzen-Seiten attach.png|mini|zentriert|alternativtext=anchor="side2"|pentagon(d=30, anchor="side2") '''attach("tip0")''' circle(r=3,$fn=36);]]
<pre class="openscad">
include <BOSL2/std.scad>
pentagon(d=30, anchor="side2") attach("tip0") circle(r=3,$fn=36);
</pre>
== Sterne (Stars) ==
=== star() mit n, ir/id und or/od ===
Die BOSL2-Bibliothek hat Sterne als grundlegend unterstützte Form. Sie können eine beliebige Anzahl '''n''' von '''Spitzen''' haben. Du kannst die Form eines Sterns durch Spitzenanzahl, '''innere und äußere Scheitelpunkt-Radius/-Durchmesser''' angeben:
[[Datei:BOSL2-star n5 ir15 dr30-Veranschaulichung.png|mini|zentriert|alternativtext=Innerer und äußerer Radius bei star()|Veranschaulichung von den Parameter '''ir''' (oder id) und '''or''' (oder od). ''ir'' gibt den inneren Radius und or den äußeren Radius an. Die Anzahl der Zacken ist hier n=5. Siehe Code unten.]]
Begonnen wird der Stern mit einem Zacken nach rechts auf der X-Achse.
<pre class="openscad">
include <BOSL2/std.scad>
#circle(30, $fn=60);
color("blue") star(n=5, ir=15, or=30);
#circle(15, $fn=60);
color("darkblue") fwd(35) text("or=30", halign = "center", size=3);
color("yellow") text("ir=15",halign = "center", size=3, valign="center");
</pre>
=== star() mit Spannweite d ===
Statt '''od''' kann auch einfach '''d''' als Parameter verwendet werden.
[[Datei:BOSL2-star n3 id10 d50.png|mini|zentriert|alternativtext=star(n=3, id=10, d=50);|star(n=3, id=10, d=50);]]
<pre class="openscad">include <BOSL2/std.scad>
star(n=3, id=10, d=50);</pre>
[[Datei:BOSL2-star n5 id15 r25.png|mini|zentriert|alternativtext=star(n=5, id=15, r=25);|star(n=5, id=15, r=25);]]
<pre class="openscad">include <BOSL2/std.scad>
star(n=5, id=15, r=25);</pre>
[[Datei:BOSL2-star n10 id30 d50.png|mini|zentriert|alternativtext=star(n=10, id=30, d=50);|star(n=10, id=30, d=50);]]
<pre class="openscad">include <BOSL2/std.scad>
star(n=10, id=30, d=50);</pre>
=== star (n = <Spitzenanzahl>, step = <Anzahl zu überspringender Punkte>) ===
Oder du kannst die Sternform durch Spitzenanzahl '''n''' und Anzahl '''step''' der zu überspringenden Punkte angeben:
[[Datei:BOSL2-star n7 step2 d50.png|mini|zentriert|alternativtext=step|star(n=7, step=2, d=50);]]
<pre class="openscad">include <BOSL2/std.scad>
star(n=7, step=2, d=50);</pre>
[[Datei:BOSL2-star n7 step3 d50.png|mini|zentriert|alternativtext=step=3|star(n=7, step=3, d=50);]]
<pre class="openscad">include <BOSL2/std.scad>
star(n=7, step=3, d=50);</pre>
=== star() mit realign ===
Wenn dem <code>realign=</code>-Argument ein true-Wert übergeben wird, wird der Stern um einen halben Spitzenwinkel gedreht:
<pre class="openscad">include <BOSL2/std.scad>
left(30) star(n=5, step=2, d=50);
right(30) star(n=5, step=2, d=50, realign=true);</pre>
=== star() mit align_tip=<Anker> ===
Das <code>align_tip=</code>-Argument kann mit einem Vektor angegeben werden, damit du die erste Spitze in eine bestimmte Richtung ausrichten kannst:
<pre class="openscad">include <BOSL2/std.scad>
star(n=5, ir=15, or=30, align_tip=BACK)
attach("tip0") color("blue") anchor_arrow2d();</pre>
<pre class="openscad">include <BOSL2/std.scad>
star(n=5, ir=15, or=30, align_tip=BACK+RIGHT)
attach("tip0") color("blue") anchor_arrow2d();</pre>
Ebenso kann die erste Einkerbung oder Einbuchtung mit <code>align_pit=</code> in Richtung eines bestimmten Vektors ausgerichtet werden:
<pre class="openscad">include <BOSL2/std.scad>
star(n=5, ir=15, or=30, align_pit=BACK)
attach("pit0") color("blue") anchor_arrow2d();</pre>
<pre class="openscad">include <BOSL2/std.scad>
star(n=5, ir=15, or=30, align_pit=BACK+RIGHT)
attach("pit0") color("blue") anchor_arrow2d();</pre>
Du kannst <code>anchor=</code> und <code>spin=</code> verwenden, genau wie bei anderen anhängbaren Formen. Die Ankerpunkte basieren jedoch auf den äußersten Ausmaßen der Form und sind möglicherweise nicht dort, wo du sie erwartest:
<pre class="openscad">include <BOSL2/std.scad>
star(n=5, step=2, d=50)
show_anchors(custom=false);</pre>
Sterne haben auch benannte Ankerpunkte für ihre Gruben, Spitzen und Mittelpunkte zwischen den Spitzen:
<pre class="openscad">include <BOSL2/std.scad>
star(n=5, step=2, d=40)
show_anchors(std=false);</pre>
<span id="tropfenform-2d-teardrop2d"></span>
== Tropfenform 2D (Teardrop2D) ==
Beim 3D-Druck möchtest du oft ein kreisförmiges Loch in eine vertikale Wand machen. Wenn das Loch jedoch zu groß ist, kann der Überhang an der Oberseite des Lochs Probleme beim Drucken auf einem FDM/FFF-Drucker verursachen. Wenn du kein Stützmaterial verwenden möchtest, kannst du einfach die Tropfenform verwenden. Das <code>teardrop2d()</code>-Modul ermöglicht es dir, eine 2D-Version der Tropfenform zu erstellen, damit du sie später extrudieren kannst:
<pre class="openscad">include <BOSL2/std.scad>
teardrop2d(r=20);</pre>
<pre class="openscad">include <BOSL2/std.scad>
teardrop2d(d=50);</pre>
Der Standard-Überhangwinkel beträgt 45 Grad, aber du kannst ihn mit dem <code>ang=</code>-Argument anpassen:
<pre class="openscad">include <BOSL2/std.scad>
teardrop2d(d=50, ang=30);</pre>
Wenn du es vorziehst, die Oberseite des Tropfens abzuflachen, um das Bridging zu fördern, kannst du das <code>cap_h=</code>-Argument verwenden:
<pre class="openscad">include <BOSL2/std.scad>
teardrop2d(d=50, cap_h=25);</pre>
<pre class="openscad">include <BOSL2/std.scad>
teardrop2d(d=50, ang=30, cap_h=30);</pre>
Du kannst <code>anchor=</code> und <code>spin=</code> verwenden, genau wie bei anderen anhängbaren Formen. Die Ankerpunkte basieren jedoch auf den äußersten Ausmaßen der Form und sind möglicherweise nicht dort, wo du sie erwartest:
<pre class="openscad">include <BOSL2/std.scad>
teardrop2d(d=50, ang=30, cap_h=30)
show_anchors();</pre>
<span id="verklebte-kreise-glued-circles"></span>
== Verklebte Kreise (Glued Circles) ==
Eine ungewöhnlichere Form, die BOSL2 bietet, sind verklebte Kreise (Glued Circles). Es handelt sich im Grunde um ein Paar von Kreisen, die durch etwas verbunden sind, das wie ein klebriger Meniskus aussieht:
<pre class="openscad">include <BOSL2/std.scad>
glued_circles(d=30, spread=40);</pre>
Die <code>r=</code>/<code>d=</code>-Argumente können den Radius oder Durchmesser der beiden Kreise angeben:
<pre class="openscad">include <BOSL2/std.scad>
glued_circles(r=20, spread=45);</pre>
<pre class="openscad">include <BOSL2/std.scad>
glued_circles(d=40, spread=45);</pre>
Das <code>spread=</code>-Argument gibt den Abstand zwischen den Mittelpunkten der beiden Kreise an:
<pre class="openscad">include <BOSL2/std.scad>
glued_circles(d=30, spread=30);</pre>
<pre class="openscad">include <BOSL2/std.scad>
glued_circles(d=30, spread=40);</pre>
Das <code>tangent=</code>-Argument gibt den Winkel der Tangente des Meniskus an den beiden Kreisen an:
<pre class="openscad">include <BOSL2/std.scad>
glued_circles(d=30, spread=30, tangent=45);</pre>
<pre class="openscad">include <BOSL2/std.scad>
glued_circles(d=30, spread=30, tangent=20);</pre>
<pre class="openscad">include <BOSL2/std.scad>
glued_circles(d=30, spread=30, tangent=-20);</pre>
Eine nützliche Sache, die du tun kannst, ist, einige <code>glued_circle()</code>s in einer Linie anzuordnen und sie dann zu extrudieren, um eine gerippte Wand zu erstellen:
<pre class="openscad">include <BOSL2/std.scad>
$fn=36; s=10;
linear_extrude(height=50,convexity=16,center=true)
xcopies(s*sqrt(2),n=3)
glued_circles(d=s, spread=s*sqrt(2), tangent=45);</pre>
Du kannst <code>anchor=</code> und <code>spin=</code> verwenden, genau wie bei anderen anhängbaren Formen. Die Ankerpunkte basieren jedoch auf den äußersten Ausmaßen der Form und sind möglicherweise nicht dort, wo du sie erwartest:
<pre class="openscad">include <BOSL2/std.scad>
glued_circles(d=40, spread=40, tangent=45)
show_anchors();</pre>
4e6vloqps36c8mh0148bjo6kgcy9355
1093528
1093525
2026-11-08T15:35:47Z
Jowi-ammerbuch
115360
/* star() mit align_tip= */
1093528
wikitext
text/x-wiki
{{MyNavi
|zurück = [[OpenSCAD Benutzerhandbuch/_BOSL2-Distributoren|Zurück]]
|buch = [[OpenSCAD Benutzerhandbuch/_BOSL2|BOSL2-Inhalt]]
|weiter = [[OpenSCAD Benutzerhandbuch/_BOSL2-3D|Weiter]]
}}
== 2D Grundformen (2D Primitive) ==
OpenSCAD bietet zwei eingebaute 2D-Grundformen: <code>square()</code> und <code>circle()</code>. Du kannst sie weiterhin auf die gewohnte Weise verwenden:
<pre class="openscad">include <BOSL2/std.scad>
square([60,40], center=true);</pre>
<pre class="openscad">include <BOSL2/std.scad>
circle(r=50);</pre>
<pre class="openscad">include <BOSL2/std.scad>
circle(d=100, $fn=8);</pre>
Diese Module wurden in der BOSL2-Bibliothek in drei Bereichen erweitert: Verankerung (Anchoring), Drehung (Spin) und Anhängbarkeit (Attachability).
<span id="verankerung-anchoring"></span>
=== Verankerung (Anchoring): ===
Wenn du ein <code>square()</code> erstellst, kannst du angeben, welche Ecke oder Seite am Ursprung verankert werden soll. Dies ersetzt das <code>center=</code>-Argument und ist flexibler. Das <code>anchor=</code>-Argument nimmt einen Vektor als Wert entgegen, der in grober Richtung der Seite oder Ecke zeigt, die du am Ursprung ausrichten möchtest.
=== anchor=[0,1] oder anchor=BACK ===
[[Datei:BOSL2-anchor-0-1.png|mini|zentriert|alternativtext=anchor=[0,1]);|square([60,40], '''anchor=[0,1]''');<br>
Oder: square([60,40], '''anchor=BACK''');]]
Um beispielsweise das '''Zentrum der hinteren Kante am Ursprung''' auszurichten, setzt du den Anker auf <code>[0,1]</code>:
<pre class="openscad">
include <BOSL2/std.scad>
square([60,40], anchor=[0,1]);
</pre>
Mit den leichter verständlichen vordefinierten '''Vektor-Konstanten''':
<pre class="openscad">
include <BOSL2/std.scad>
square([60,40], anchor=BACK+CENTER);
</pre>
=== anchor=[1,-1] oder anchor=RIGHT+FRONT ===
Um die '''vordere rechte Ecke am Ursprung''' auszurichten:
[[Datei:BOSL2-anchor-1 -1.png|mini|zentriert|alternativtext=anchor=RIGHT+FRONT);|square([60,40], '''anchor=[1,-1]''');<br>
Oder: square([60,40], '''anchor=RIGHT+FRONT''');]]
<pre class="openscad">
include <BOSL2/std.scad>
square([60,40], anchor=[1,-1]);
</pre>
'''Mit Vektor-Konstanten:'''
<pre class="openscad">
include <BOSL2/std.scad>
square([60,40], anchor=RIGHT+FRONT);
</pre>
=== anchor=[0,0] oder anchor=CENTER '''Fetter Text'''===
Um es zu '''zentrieren''':
<pre class="openscad">
include <BOSL2/std.scad>
square([60,40], anchor=[0,0]);
</pre>
'''Mit Vektor-Konstanten:'''
<pre class="openscad">
include <BOSL2/std.scad>
square([60,40], anchor=CENTER);
</pre>
=== Vektor-Konstanten am Rechteck ===
Um die Angabe von Vektoren übersichtlicher zu gestalten, sind mehrere Standard-Vektorkonstanten definiert:
[[Datei:BOSL2-anchor-Konstanten-Rechteck.png|gerahmt|zentriert|alternativtext=BOSL2 vordefinierte anchor-Konstanten|Die in BOSL2 vordefinierten anchor-Konstanten]]
{| class="wikitable"
|-
! Konstante
! Richtung
! Wert
|-
| LEFT
| X-
| [-1, 0, 0]
|-
| RIGHT
| X+
| [ 1, 0, 0]
|-
| FRONT / FORWARD / FWD
| Y-
| [ 0,-1, 0]
|-
| BACK
| Y+
| [ 0, 1, 0]
|-
| BOTTOM / BOT / BTM / DOWN
| Z-
| [ 0, 0,-1] (nur 3D)
|-
| TOP / UP
| Z+
| [ 0, 0, 1] (nur 3D)
|-
| CENTER / CTR
| Zentriert
| [ 0, 0, 0]
|}
Beachte, dass du die meisten dieser Konstanten (außer <code>UP</code>/<code>DOWN</code> natürlich) auch für Anker bei 2D-Formen verwenden kannst, obwohl es sich um 3D-Vektoren handelt:
<pre class="openscad">include <BOSL2/std.scad>
square([60,40], anchor=BACK);</pre>
<pre class="openscad">include <BOSL2/std.scad>
square([60,40], anchor=CENTER);</pre>
Du kannst Vektoren addieren, um auf Ecken zu zeigen:
<pre class="openscad">include <BOSL2/std.scad>
square([60,40], anchor=FRONT+RIGHT);</pre>
=== anchor = polar_to_xy ===
Für <code>circle()</code> kann der Ankervektor auf jeden beliebigen '''Punkt des Kreisumfangs''' zeigen:
[[Datei:BOSL2-anchor-polar to xy-circle.png|gerahmt|zentriert|alternativtext=anchor = polar_to_xy|anchor = polar_to_xy(1,Alpha), für Alpha = 0, 45, 90, ...]]
==== Beispiel: anchor=polar_to_xy(1,45) =====
[[Datei:BOSL2-anchor-polar to 1-45-octagon.png|mini|zentriert|alternativtext=circle(d=50, anchor=polar_to_xy(1,45), $fn = 8);|circle(d=50, anchor=polar_to_xy(1,45), $fn = 8);]]
<pre class="openscad">
include <BOSL2/std.scad>
circle(d=50, anchor=polar_to_xy(1,45), $fn = 8);
</pre>
Beachte, dass der Radius für den Anker keine Rolle spielt, da nur die Richtung des Ankers das Ergebnis beeinflusst.
=== show_anchors() ===
[[Datei:BOSL2-show anchor.png|mini|zentriert|show_anchors]]
Du kannst die typischen Ankerpunkte sehen, indem du <code>show_anchors()</code> als Kind der Form übergibst:
<pre class="openscad">include <BOSL2/std.scad>
square([60,40], center=true)
show_anchors();</pre>
<pre class="openscad">include <BOSL2/std.scad>
circle(d=50)
show_anchors();</pre>
<span id="drehung-spin"></span>
=== Drehung (Spin): ===
Die zweite Erweiterung von <code>square()</code> und <code>circle()</code> ist die Drehung (Spin). Wenn du die Form erstellst, kannst du sie mit dem <code>spin=</code>-Argument an Ort und Stelle drehen. Du übergibst einfach die Anzahl der Grad, um die sie im Uhrzeigersinn gedreht werden soll:
<pre class="openscad">include <BOSL2/std.scad>
square([60,40], anchor=CENTER, spin=30);</pre>
Die Verankerung oder Zentrierung erfolgt vor der Drehung:
<pre class="openscad">include <BOSL2/std.scad>
square([60,40], anchor=BACK, spin=30);</pre>
Bei Kreisen kann Spin nützlich sein, wenn auch <code>$fn=</code> angegeben wird:
<pre class="openscad">include <BOSL2/std.scad>
circle(d=50, $fn=6, spin=15);</pre>
Da die Verankerung vor der Drehung erfolgt, kannst du beides zusammen verwenden, um um den Anker herum zu drehen:
<pre class="openscad">include <BOSL2/std.scad>
circle(d=50, $fn=6, anchor=LEFT, spin=15);</pre>
<span id="anhängbarkeit-attachability"></span>
=== Anhängbarkeit (Attachability): ===
Die dritte Erweiterung von <code>square()</code> und <code>circle()</code> ist, dass du sie auf verschiedene Weise an Ankerpunkten zusammenhängen kannst. Dies geschieht, indem du eine Form zum Kind der Form machst, an die du sie anhängen möchtest.
==== Standard (ohne Spez. für anchor oder position) ====
Standardmäßig wird das Kind beim einfachen Untereinanderstellen im Zentrum der Elternform angehängt.
[[Datei:BOSL2-attach-standard-normal.png|mini|zentriert|alternativtext=square(50) #square(50);|square(50) #square(50);<br>
Kind-Objekt (rot) wird ans Zentrum des Elternobjekts angehängt]]
<pre class="openscad">
include <BOSL2/std.scad>
square(50) #square(50);
</pre>
==== anchor für child spezifiziert ====
[[Datei:BOSL2-attach-anchor-LEFTplusFWD.png|mini|zentriert|alternativtext=square(50, center=true) #square([20,40], anchor=LEFT+FWD);|square(50, center=true)#square([20,40], '''anchor=LEFT+FWD''');]]
<pre class="openscad">include <BOSL2/std.scad>
square(50, center=true)
#square([20,40], anchor=LEFT+FWD);</pre>
==== position() ====
[[Datei:BOSL2-attach-position.png|mini|zentriert|alternativtext=position(RIGHT)|square(50) '''position(RIGHT)''' #square(25) '''position(BACK)''' #square(25);]]
Durch Hinzufügen des <code>position()</code>-Moduls kannst du das Kind an jedem Ankerpunkt '''des Elternteils''' positionieren, das "Kindes-Kind wird am Ankerpunkt des übergeordneten Objekts positioniert:
<pre class="openscad">
include <BOSL2/std.scad>
square(50) position(RIGHT) #square(25)
position(BACK) #square(25);
</pre>
==== orient() ====
Ankerpunkte sind jedoch nicht nur Positionen auf dem Elternteil. Sie haben auch eine Ausrichtung. In den meisten Fällen zeigt die Ausrichtung eines Ankerpunkts nach außen, weg von der Fläche der Wand, also im Allgemeinen vom Zentrum der Form weg.
[[Datei:BOSL2-show anchor.png|mini|zentriert|show_anchors]]
Wenn du das Kind so ausrichten möchtest, dass es der Ausrichtung eines Ankerpunkts entspricht, kannst du das <code>orient()</code>-Modul verwenden. Es positioniert das Kind nicht, es dreht es nur:
[[Datei:BOSL2-attach-orient anchor.png|mini|zentriert|alternativtext= orient(anchor=LEFT+BOTTOM)|square(50) '''orient(anchor=LEFT+BOTTOM)''' #square([10,40]);]]
<pre class="openscad">include <BOSL2/std.scad>
square(50)
orient(anchor=LEFT+BOTTOM) #square([10,40]);</pre>
Das geht auch beim '''Kreis (circle)''' mit '''polar_to_xy''':
[[Datei:BOSL2-attach-orient polar to xy circle.png|mini|zentriert|alternativtext=orient(polar_to_xy(1,30))|circle(d=50) ''' orient(polar_to_xy(1,30))''' #square([10,40], anchor=FWD);]]
<pre class="openscad">include <BOSL2/std.scad>
circle(d=50)
orient(polar_to_xy(1,30))
#square([10,40], anchor=FWD);</pre>
==== position() + orient() ====
Du kannst <code>position()</code> und <code>orient()</code> zusammen verwenden, um sowohl zu positionieren als auch an einem Ankerpunkt auszurichten:
[[Datei:BOSL2-attach-position pluss orient polar to xy circle.png|mini|zentriert|alternativtext=position(polar_to_xy(1,30)) orient(polar_to_xy(1,30))|circle(d=50) '''position(polar_to_xy(1,30)) orient(polar_to_xy(1,30))''' #square([10,40], anchor=FWD);]]
<pre class="openscad">include <BOSL2/std.scad>
circle(d=50)
position(polar_to_xy(1,30))
orient(polar_to_xy(1,30))
#square([10,40], anchor=FWD);</pre>
=== attach () mit einem Argument ===
Aber es ist einfacher das <code>attach()</code>-Modul zu verwenden, um beides auf einmal zu erledigen:
[[Datei:BOSL2-attach-position pluss orient polar to xy circle.png|mini|zentriert|alternativtext=attach(polar_to_xy(1,30))|circle(d=50) '''attach(polar_to_xy(1,30))''' #square([10,40], anchor=FWD); ]]
Gleiches Ergebnis, aber übersichtlicherer Code.
<pre class="openscad">include <BOSL2/std.scad>
square(50, center=true)
attach(LEFT+BACK)
#square([10,40], anchor=FWD);</pre>
=== attach () mit zwei Argumenten ===
Anstatt den <code>anchor=</code> im Kind anzugeben, kannst du ein '''zweites Argument''' an <code>attach()</code> übergeben, das ihm sagt, welche Seite des Kindes mit dem Elternteil verbunden werden soll:
<pre class="openscad">
include <BOSL2/std.scad>
circle(d=50) attach(polar_to_xy(1,30), FWD) #square([10,40]);
</pre>
Damit lässt sich der Code noch mehr straffen.
[[Datei:BOSL2-attach-position pluss orient polar to xy circle.png|mini|zentriert|alternativtext=attach(polar_to_xy(1,30), FWD)|circle(d=50) '''attach(polar_to_xy(1,30), FWD)''' #square([10,40]); ]]
<span id="rechtecke-rectangles"></span>
== Rechtecke (Rectangles) ==
=== rect() ===
Die BOSL2-Bibliothek bietet eine Alternative zu <code>square()</code>, die mehr Funktionen unterstützt. Sie heißt <code>rect()</code>. Du kannst sie genauso verwenden wie <code>square()</code>, aber sie bietet auch erweiterte Funktionalität.
=== rect() mit rounding ===
[[Datei:BOSL2-rect rounding.png|mini|zentriert|alternativtext=rounding=10|rect([60,40], '''rounding=10''');]]
rect() erlaubt dir, die Ecken des Rechtecks abzurunden:
<pre class="openscad">include <BOSL2/std.scad>
rect([60,40], rounding=10);</pre>
=== rect() mit chamfer ===
[[Datei:BOSL2-rect chamfer.png|mini|zentriert|alternativtext=rect([60,40], chamfer=10);|rect([60,40], '''chamfer=10''');]]
Du kannst die Ecken des Rechtecks auch abfasen:
<pre class="openscad">include <BOSL2/std.scad>
rect([60,40], chamfer=10);</pre>
=== Unterschiedliche Abrundungen und Fasen an einem Rechteck ===
Du kannst sogar angeben, welche Ecken abgerundet oder abgefast werden. Wenn du eine Liste mit vier Größenwerten an die <code>rounding=</code>- oder <code>chamfer=</code>-Argumente übergibst, erhält jede Ecke ihre eigene Größe. Der Reihe nach geht es von der hinteren rechten Ecke (Quadrant I) gegen den Uhrzeigersinn zur hinteren linken Ecke (Quadrant II), zur vorderen linken Ecke (Quadrant III) und zur vorderen rechten Ecke (Quadrant IV):
Wenn eine Größe als <code>0</code> angegeben wird, gibt es keine Rundung und/oder Fase für die Ecke dieses Quadranten:
<pre class="openscad">include <BOSL2/std.scad>
rect([60,40], rounding=[0,5,10,15]);</pre>
<pre class="openscad">include <BOSL2/std.scad>
rect([60,40], chamfer=[0,5,10,15]);</pre>
Du kannst sowohl <code>rounding=</code>- als auch <code>chamfer=</code>-Argumente angeben, um Rundung und Fase zu mischen, aber nur, wenn du es pro Ecke angibst. Wenn du eine Rundung in einer Ecke möchtest, gib eine Fase von 0 für diese Ecke an und umgekehrt:
[[Datei:BOSL2-rect chamfer-rounding-mixed.png|mini|zentriert|alternativtext=ounding=[5,0,10,0], chamfer=[0,5,0,15]|rect([60,40], '''rounding=[5,0,10,0], chamfer=[0,5,0,15]''');]]
<pre class="openscad">include <BOSL2/std.scad>
rect([60,40], rounding=[5,0,10,0], chamfer=[0,5,0,15]);</pre>
<span id="ellipsen-ellipses"></span>
== Ellipsen (Ellipses) ==
Die BOSL2-Bibliothek bietet auch eine erweiterte Entsprechung von <code>circle()</code>, die <code>ellipse()</code> heißt. Du kannst sie genauso verwenden wie <code>circle()</code>, aber sie bietet auch erweiterte Funktionalität. Zum Beispiel erlaubt sie mehr Kontrolle über ihre Größe.
Da ein Kreis in OpenSCAD nur durch ein regelmäßiges Polygon mit einer Anzahl gerader Seiten angenähert werden kann, kann dies zu Ungenauigkeiten in Größe und Form führen. Um dem entgegenzuwirken, werden auch die Argumente <code>realign=</code> und <code>circum=</code> bereitgestellt.
=== realign= (ellipse-Argument) ===
Das <code>realign=</code>-Argument rotiert, wenn es auf <code>true</code> gesetzt wird, die <code>ellipse()</code> um den halben Winkel zwischen den Polygonseiten:
[[Datei:BOSL2-ellipse-realign.png|mini|zentriert|alternativtext=realign=true|#ellipse(d=100, $fn=8); color("lime") ellipse(d=100, $fn=8, '''realign=true''');]]
<pre class="openscad">
include <BOSL2/std.scad>
#ellipse(d=100, $fn=8);
color("lime") ellipse(d=100, $fn=8, realign=true);
</pre>
=== circum= (ellipse-Argument) ===
[[Datei:BOSL2-ellipse-circum.png|mini|zentriert|alternativtext=circum=true|Vergleich: rot (außen) mit circum=true und blau (innen) ohne circum. Referenz: idealer Kreis in gelb.]]
<pre class="openscad">
include <BOSL2/std.scad>
color("red") ellipse(d=100, $fn=6, circum=true);
color("yellow") ellipse(d=100, $fn=360);
color("blue") ellipse(d=100, $fn=6);
</pre>
Das <code>circum=</code>-Argument bewirkt, wenn es auf true gesetzt wird, dass das Polygon, das die <code>ellipse()</code> bildet, den idealen Kreis '''umschreibt''', anstatt ihn einzuschreiben.
Den idealen Kreis ''einschreiben'':
<pre class="openscad">include <BOSL2/std.scad>
color("green") ellipse(d=100, $fn=360);
ellipse(d=100, $fn=6);</pre>
Den idealen Kreis ''umschreiben'':
<pre class="openscad">include <BOSL2/std.scad>
ellipse(d=100, $fn=6, circum=true);
color("green") ellipse(d=100, $fn=360);</pre>
=== Ellipse mit 2 Radien ===
Das <code>ellipse()</code>-Modul kann, wie der Name schon sagt, mit separaten X- und Y-Radien oder -Durchmessern angegeben werden. Dazu gibst du einfach <code>r=</code> oder <code>d=</code> mit einer Liste von zwei Radien oder Durchmessern an:
[[Datei:BOSL2-ellipse-2Radien.png|mini|zentriert|alternativtext=2 Radien|ellipse('''r=[30,20]''');]]
==== r=[r1,r2] ====
<pre class="openscad">include <BOSL2/std.scad>
ellipse(r=[30,20]);</pre>
==== d=[d1,d2]====
<pre class="openscad">include <BOSL2/std.scad>
ellipse(d=[60,40]);</pre>
==== ellipse mit anchor ====
Wie bei <code>circle()</code> kannst du <code>ellipse()</code>-Formen verankern, drehen und anhängen:
[[Datei:BOSL2-ellipse-anchor.png|mini|zentriert|alternativtext=ellipse mit anchor|ellipse(d=[50,20], '''anchor=BACK'''); #ellipse(d=[50,20], '''anchor=FRONT''');]]
<pre class="openscad">
include <BOSL2/std.scad>
ellipse(d=[50,20], anchor=BACK);
#ellipse(d=[50,20], anchor=FRONT);
</pre>
==== ellipse mit attach ====
[[Datei:BOSL2-ellipse-attach.png|mini|zentriert|alternativtext=ellipse mit attach|ellipse(d=50) '''attach(BACK+RIGHT, FRONT+LEFT)''' #ellipse(d=[40,20]);]]
<pre class="openscad">
include <BOSL2/std.scad>
ellipse(d=50)
attach(BACK+RIGHT, FRONT+LEFT)
ellipse(d=30);
</pre>
<span id="rechtwinklige-dreiecke-right-triangles"></span>
==== ellipse mit spin ====
[[Datei:BOSL2-ellipse-attach-spin-anchor.png|mini|zentriert|alternativtext=spin = 90 bei ellipse|ellipse(d=50) attach(BACK) #ellipse(d=[40,20], '''spin=90''', anchor=LEFT);]]
<pre class="openscad">
include <BOSL2/std.scad>
ellipse(d=50)
attach(BACK)
#ellipse(d=[40,20], spin=90, anchor=LEFT);
</pre>
== Rechtwinklige Dreiecke (Right Triangles) ==
Die BOSL2-Bibliothek bietet eine einfache Möglichkeit, ein 2D-rechtwinkliges Dreieck mit dem <code>right_triangle()</code>-Modul zu erstellen:
[[Datei:BOSL2-right triangle.png|mini|zentriert|alternativtext=right_triangle([40,30])|right_triangle([40,30]);]]
<pre class="openscad">include <BOSL2/std.scad>
right_triangle([40,30]);</pre>
=== xflip() bei right_triangle ===
Du kannst <code>xflip()</code> und <code>yflip()</code> verwenden, um zu ändern, in welchem Quadranten das Dreieck gebildet wird:
[[Datei:BOSL2-right triangle xflip.png|mini|zentriert|alternativtext=right_triange mit xflip()|right_triangle([40,30]); '''xflip()''' #right_triangle([40,30]);]]
<pre class="openscad">include <BOSL2/std.scad>
xflip() right_triangle([40,30]);</pre>
=== yflip() bei right_triangle ===
[[Datei:BOSL2-right triangle yflip.png|mini|zentriert|alternativtext=right_triangle([40,30]) mit yflip()|right_triangle([40,30]); '''yflip()''' #right_triangle([40,30]);]]
<pre class="openscad">include <BOSL2/std.scad>
yflip() right_triangle([40,30]);</pre>
=== xflip() & yflip() bei right_triangle ===
[[Datei:BOSL2-right triangle xflip yflip.png|mini|zentriert|alternativtext=xflip() yflip()|right_triangle([40,30]); xflip() yflip() #right_triangle([40,30]);]]
<pre class="openscad">include <BOSL2/std.scad>
xflip() yflip() right_triangle([40,30]);</pre>
=== spin= bei right_triangle ===
Oder alternativ einfach mit <code>spin=</code> in den richtigen Quadranten drehen:
[[Datei:BOSL2-right triangle spin.png|mini|zentriert|alternativtext=right_triangle([40,30]) mit spin=90)|right_triangle([40,30]);
#right_triangle([40,30], '''spin=90''');]]
<pre class="openscad">include <BOSL2/std.scad>
right_triangle([40,30], spin=90);</pre>
<pre class="openscad">include <BOSL2/std.scad>
right_triangle([40,30], spin=-90);</pre>
Du kannst bei rechtwinkligen Dreiecken auch Verankerung verwenden:
<pre class="openscad">include <BOSL2/std.scad>
right_triangle([40,30], anchor=FWD+RIGHT);</pre>
<span id="trapeze-trapezoids"></span>
== Trapeze (Trapezoids) ==
OpenSCAD bietet keine einfache Möglichkeit, allgemeine 2D-Dreiecke, Trapeze oder Parallelogramme zu erstellen. Die BOSL2-Bibliothek kann all diese Formen mit dem <code>trapezoid()</code>-Modul bereitstellen.
=== Dreieck ===
Um ein gleichseitiges Dreieck zu erstellen, setze einfach eine der Breiten auf null:
[[Datei:BOSL2-trapezoid dreieck.png|mini|zentriert|alternativtext=Dreieck|trapezoid(w1=50, w2=0, h=40);<br>
Dreieck mit Seitenlänge = 50]]
<pre class="openscad">include <BOSL2/std.scad>
trapezoid(w1=50, w2=0, h=40);</pre>
Um ein rechtwinkliges Dreieck zu erstellen, musst du das <code>shift=</code>-Argument verwenden, um die Rückseite des Trapezes entlang der X-Achse zu verschieben:
[[Datei:BOSL2-trapezoid dreieck-rechtwinklig.png|mini|zentriert|alternativtext=Rechtwinkliges Dreieck|trapezoid(w1=50, w2=0, h=50, shift=-25);]]
<pre class="openscad">include <BOSL2/std.scad>
trapezoid(w1=50, w2=0, h=50, shift=-25);</pre>
<pre class="openscad">include <BOSL2/std.scad>
trapezoid(w1=50, w2=0, h=50, shift=25);</pre>
<pre class="openscad">include <BOSL2/std.scad>
trapezoid(w1=0, w2=50, h=50, shift=-25);</pre>
<pre class="openscad">include <BOSL2/std.scad>
trapezoid(w1=0, w2=50, h=50, shift=25);</pre>
=== Trapez ===
Du kannst ein Trapez erstellen, indem du für vorne (<code>w1=</code>) und hinten (<code>w2=</code>) von null verschiedene Breiten angibst:
[[Datei:BOSL2-trapezoid trapez.png|mini|zentriert|alternativtext=Trapez|trapezoid(w1=30, w2=50, h=50);]]
<pre class="openscad">include <BOSL2/std.scad>
trapezoid(w1=30, w2=50, h=50);</pre>
=== Parallelogramm ===
Ein Parallelogramm ist nur eine Frage der Verwendung der gleichen Breite für vorne und hinten, mit einer Verschiebung entlang der X-Achse:
[[Datei:BOSL2-trapezoid parallelogram.png|mini|zentriert|alternativtext=Parallelogramm|trapezoid(w1=50, w2=50, shift=20, h=50);]]
<pre class="openscad">include <BOSL2/std.scad>
trapezoid(w1=50, w2=50, shift=20, h=50);</pre>
=== Viereck ===
Ein Viereck kann erstellt werden, indem ungleiche, von null verschiedene Breiten für vorne (<code>w1=</code>) und hinten (<code>w2=</code>) verwendet werden, wobei die Rückseite entlang der X-Achse verschoben wird:
[[Datei:BOSL2-trapezoid viereck.png|mini|zentriert|alternativtext=Viereck|trapezoid(w1=50, w2=30, shift=20, h=50);]]
<pre class="openscad">include <BOSL2/std.scad>
trapezoid(w1=50, w2=30, shift=20, h=50);</pre>
Du kannst <code>anchor=</code> und <code>spin=</code> verwenden, genau wie bei anderen anhängbaren Formen. Die Ausrichtungen der Ankerpunkte basieren jedoch auf den Seitenwinkeln der Flächen und sind möglicherweise nicht das, was du erwartest:
<pre class="openscad">include <BOSL2/std.scad>
trapezoid(w1=30, w2=50, h=50)
show_anchors();</pre>
<span id="regelmäßige-n-ecke-regular-n-gons"></span>
== Regelmäßige n-Ecke (Regular N-Gons) ==
OpenSCAD ermöglicht es dir, regelmäßige n-Ecke (Fünfeck, Sechseck usw.) zu erstellen, indem du <code>circle()</code> mit <code>$fn</code> verwendest. Obwohl dies prägnant ist, mag es auf den ersten Blick weniger offensichtlich sein:
<pre class="openscad">include <BOSL2/std.scad>
circle(d=50, $fn=5);</pre>
Die BOSL2-Bibliothek hat Module, die für gängige n-Ecke klarer benannt sind:
=== Pentagon (d=<Durchmesser>) ===
[[Datei:BOSL2-Pentagon.png|mini|zentriert|alternativtext=Pentagon|pentagon(d=50);]]
<pre class="openscad">include <BOSL2/std.scad>
pentagon(d=50);</pre>
=== Hexagon (d=<Durchmesser>) ===
[[Datei:BOSL2-Hexagon.png|mini|zentriert|alternativtext=Hexagon| hexagon(d=50);]]
<pre class="openscad">include <BOSL2/std.scad>
hexagon(d=50);</pre>
=== Octagon (d= <Durchmesser>) ===
[[Datei:BOSL2-Octagon.png|mini|zentriert|alternativtext=octagon(d=50);|octagon(d=50);]]
<pre class="openscad">include <BOSL2/std.scad>
octagon(d=50);</pre>
=== regular_ngon (n=<Seitenanzahl>, d=<Durchmesser>) ===
[[Datei:BOSL2-regular ngon.png|mini|zentriert|alternativtext=regular_ngon|regular_ngon(n=7, d=50);]]
<pre class="openscad">include <BOSL2/std.scad>
regular_ngon(n=7, d=50);</pre>
=== side=<Seitenlänge> ===
Diese Module bieten dir auch zusätzliche Funktionalität. Sie können nach Seitenlänge dimensioniert werden:
[[Datei:BOSL2-Hexagon side50.png|mini|zentriert|alternativtext=hexagon(side=50);|hexagon(side=50);]]
<pre class="openscad">include <BOSL2/std.scad>
pentagon(side=50);</pre>
=== ir = <Innenradius> / id = <Innendurchmesser> ===
Sie können nach dem Radius/Durchmesser des umschriebenen Kreises (Innenkreis) dimensioniert werden:
[[Datei:BOSL2-Pentagon Innenradius.png|mini|zentriert|alternativtext=Innenradius|color("red") pentagon('''ir=25'''); color("yellow") circle(r=25,$fn=100);]]
<pre class="openscad">include <BOSL2/std.scad>
pentagon(ir=25);
pentagon(id=50);</pre>
=== realign=true/false ===
Die Polygone können um eine halbe Seite gedreht werden:
[[Datei:BOSL2-Pentagon realign.png|mini|zentriert|alternativtext=realign|pentagon(d=50, '''realign=false'''); #pentagon(d=50, '''realign=true''');]]
<pre class="openscad">include <BOSL2/std.scad>
left(30) pentagon(d=50, realign=true);
right(30) pentagon(d=50, realign=false);</pre>
=== rounding = <Rundung> ===
Die BOSL2-Polygone können abgerundet werden:
[[Datei:BOSL2-Polygon-rounding.png|mini|zentriert|alternativtext=rounding|pentagon(d=50, '''rounding=5''');]]
<pre class="openscad">include <BOSL2/std.scad>
pentagon(d=50, rounding=5);</pre>
=== show_anchors() ===
Die BOSL2-Polygone haben auch ein etwas anderes Anhangsverhalten als die regulären Polygone, die über $fn=<Seitenanzahl> erzeugt werden.
Ein Kreis mit einem kleinen <code>$fn=</code> hängt Dinge am idealen Kreis an, nicht entlang des erstellten Polygons:
[[Datei:BOSL2-polygon-outcircle-anchors.png|mini|zentriert|alternativtext=anchors Außenkreis|color("green") stroke(circle(d=50), closed=true); circle(d=50,$fn=6) show_anchors();]]
<pre class="openscad">include <BOSL2/std.scad>
color("green") stroke(circle(d=50), closed=true);
circle(d=50,$fn=6)
show_anchors();</pre>
Während ein BOSL2-n-Eck entlang des Polygons selbst (direkt) anhängt:
[[Datei:BOSL2-polygon-direct-anchors.png|mini|zentriert|alternativtext=anchors BOSL2 Polygone direkt|color("green") stroke(circle(d=50), closed=true); circle(d=50,$fn=6) show_anchors();]]
<pre class="openscad">include <BOSL2/std.scad>
hexagon(d=50)
show_anchors(custom=false);</pre>
Du kannst <code>anchor=</code> und <code>spin=</code> verwenden, genau wie bei anderen anhängbaren Formen. Die Ankerpunkte basieren jedoch darauf, wo der Ankervektor die Seite des n-Ecks schneiden würde, und sind möglicherweise nicht dort, wo du sie erwartest:
[[Datei:BOSL2-Pentagon-anchor.png|mini|zentriert|alternativtext=n-Polygon anchor|pentagon(d=50, '''anchor=FRONT+LEFT''') show_anchors(custom=false);]]
<pre class="openscad">include <BOSL2/std.scad>
pentagon(d=50, anchor=FRONT+LEFT)
show_anchors(custom=false);</pre>
=== Ankerpunkte für Seiten und Spitzen ===
n-Ecke haben auch benannte Ankerpunkte für ihre Seiten und Spitzen:
[[Datei:BOSL2-anchor-Spitzen-Seiten.png|mini|zentriert|alternativtext=Anker für Seiten und Spitzen|Spezielle Anker für die Spitzen und Seiten eines Pentagons (mit TikZ unter LaTeX erstellt)]]
Beachte, dass die Ankernamen in "" gesetzt werden müssen.
Zum Beispiel:
[[Datei:BOSL2-Pentagon anchor tip1.png|mini|zentriert|alternativtext=anchor="tip1"|pentagon(d=30, '''anchor="tip1" ''');]]
<pre class="openscad">include <BOSL2/std.scad>
pentagon(d=30, anchor="tip1");</pre>
<span id="sterne-stars"></span>
Beispiel mit attach():
[[Datei:BOSL2-anchor-Spitzen-Seiten attach.png|mini|zentriert|alternativtext=anchor="side2"|pentagon(d=30, anchor="side2") '''attach("tip0")''' circle(r=3,$fn=36);]]
<pre class="openscad">
include <BOSL2/std.scad>
pentagon(d=30, anchor="side2") attach("tip0") circle(r=3,$fn=36);
</pre>
== Sterne (Stars) ==
=== star() mit n, ir/id und or/od ===
Die BOSL2-Bibliothek hat Sterne als grundlegend unterstützte Form. Sie können eine beliebige Anzahl '''n''' von '''Spitzen''' haben. Du kannst die Form eines Sterns durch Spitzenanzahl, '''innere und äußere Scheitelpunkt-Radius/-Durchmesser''' angeben:
[[Datei:BOSL2-star n5 ir15 dr30-Veranschaulichung.png|mini|zentriert|alternativtext=Innerer und äußerer Radius bei star()|Veranschaulichung von den Parameter '''ir''' (oder id) und '''or''' (oder od). ''ir'' gibt den inneren Radius und or den äußeren Radius an. Die Anzahl der Zacken ist hier n=5. Siehe Code unten.]]
Begonnen wird der Stern mit einem Zacken nach rechts auf der X-Achse.
<pre class="openscad">
include <BOSL2/std.scad>
#circle(30, $fn=60);
color("blue") star(n=5, ir=15, or=30);
#circle(15, $fn=60);
color("darkblue") fwd(35) text("or=30", halign = "center", size=3);
color("yellow") text("ir=15",halign = "center", size=3, valign="center");
</pre>
=== star() mit Spannweite d ===
Statt '''od''' kann auch einfach '''d''' als Parameter verwendet werden.
[[Datei:BOSL2-star n3 id10 d50.png|mini|zentriert|alternativtext=star(n=3, id=10, d=50);|star(n=3, id=10, d=50);]]
<pre class="openscad">include <BOSL2/std.scad>
star(n=3, id=10, d=50);</pre>
[[Datei:BOSL2-star n5 id15 r25.png|mini|zentriert|alternativtext=star(n=5, id=15, r=25);|star(n=5, id=15, r=25);]]
<pre class="openscad">include <BOSL2/std.scad>
star(n=5, id=15, r=25);</pre>
[[Datei:BOSL2-star n10 id30 d50.png|mini|zentriert|alternativtext=star(n=10, id=30, d=50);|star(n=10, id=30, d=50);]]
<pre class="openscad">include <BOSL2/std.scad>
star(n=10, id=30, d=50);</pre>
=== star (n = <Spitzenanzahl>, step = <Anzahl zu überspringender Punkte>) ===
Oder du kannst die Sternform durch Spitzenanzahl '''n''' und Anzahl '''step''' der zu überspringenden Punkte angeben:
[[Datei:BOSL2-star n7 step2 d50.png|mini|zentriert|alternativtext=step|star(n=7, step=2, d=50);]]
<pre class="openscad">include <BOSL2/std.scad>
star(n=7, step=2, d=50);</pre>
[[Datei:BOSL2-star n7 step3 d50.png|mini|zentriert|alternativtext=step=3|star(n=7, step=3, d=50);]]
<pre class="openscad">include <BOSL2/std.scad>
star(n=7, step=3, d=50);</pre>
=== star() mit realign ===
Wenn dem <code>realign=</code>-Argument ein true-Wert übergeben wird, wird der Stern um einen halben Spitzenwinkel gedreht:
<pre class="openscad">include <BOSL2/std.scad>
left(30) star(n=5, step=2, d=50);
right(30) star(n=5, step=2, d=50, realign=true);</pre>
=== star() mit align_tip=<Anker> ===
Das <code>align_tip=</code>-Argument kann mit einem Vektor angegeben werden, damit du die erste Spitze in eine bestimmte Richtung ausrichten kannst:
<pre class="openscad">include <BOSL2/std.scad>
star(n=5, ir=15, or=30, align_tip=BACK)
attach("tip0") color("blue") anchor_arrow2d();</pre>
<pre class="openscad">include <BOSL2/std.scad>
star(n=5, ir=15, or=30, align_tip=BACK+RIGHT)
attach("tip0") color("blue") anchor_arrow2d();</pre>
=== star() mit align_pit=<Anker> ===
Ebenso kann die erste Einkerbung oder Einbuchtung mit <code>align_pit=</code> in Richtung eines bestimmten Vektors ausgerichtet werden:
<pre class="openscad">include <BOSL2/std.scad>
star(n=5, ir=15, or=30, align_pit=BACK)
attach("pit0") color("blue") anchor_arrow2d();</pre>
<pre class="openscad">include <BOSL2/std.scad>
star(n=5, ir=15, or=30, align_pit=BACK+RIGHT)
attach("pit0") color("blue") anchor_arrow2d();</pre>
Du kannst <code>anchor=</code> und <code>spin=</code> verwenden, genau wie bei anderen anhängbaren Formen. Die Ankerpunkte basieren jedoch auf den äußersten Ausmaßen der Form und sind möglicherweise nicht dort, wo du sie erwartest:
<pre class="openscad">include <BOSL2/std.scad>
star(n=5, step=2, d=50)
show_anchors(custom=false);</pre>
=== Benannte Ankerpunkte bei star() ===
Sterne haben auch benannte Ankerpunkte für ihre Gruben, Spitzen und Mittelpunkte zwischen den Spitzen:
[[Datei:BOSL2-star n5 benannteAnker.png|gerahmt|zentriert|alternativtext=benannten Ankerpunkte in star()|Zuordnung der benannten Ankerpunkte in star(). Spitzen beginnen mit "tipt0", Einkerbungen mit pit0.]]
==== Beispiel 1: anchor="tip0" attach("pit0") ====
[[Datei:BOSL2-star-n5 ir=15 or30 anchor tip0 pit0.png|mini|zentriert|alternativtext=anchor="tip0"|star(n=5, ir=15, or=30, anchor="tip0") attach("pit0") #circle(3);]]
<pre class="openscad">
include <BOSL2/std.scad>
star(n=5, ir=15, or=30, anchor="tip0") attach("pit0") #circle(3);
</pre>
==== Beispiel 2: anchor="pit0" attach("tip0") ====
[[Datei:BOSL2-star n5 anchor pit0 attach tip0.png|mini|zentriert|alternativtext=anchor="pit0" attach("tip0")|star(n=5, ir=15, or=30, anchor="pit0") attach("tip0") #circle(3);]]
<pre class="openscad">
include <BOSL2/std.scad>
star(n=5, ir=15, or=30, anchor="pit0") attach("tip0") #circle(3);
</pre>
<span id="tropfenform-2d-teardrop2d"></span>
== Tropfenform 2D (Teardrop2D) ==
Beim 3D-Druck möchtest du oft ein kreisförmiges Loch in eine vertikale Wand machen. Wenn das Loch jedoch zu groß ist, kann der Überhang an der Oberseite des Lochs Probleme beim Drucken auf einem FDM/FFF-Drucker verursachen. Wenn du kein Stützmaterial verwenden möchtest, kannst du einfach die Tropfenform verwenden. Das <code>teardrop2d()</code>-Modul ermöglicht es dir, eine 2D-Version der Tropfenform zu erstellen, damit du sie später extrudieren kannst:
<pre class="openscad">include <BOSL2/std.scad>
teardrop2d(r=20);</pre>
<pre class="openscad">include <BOSL2/std.scad>
teardrop2d(d=50);</pre>
Der Standard-Überhangwinkel beträgt 45 Grad, aber du kannst ihn mit dem <code>ang=</code>-Argument anpassen:
<pre class="openscad">include <BOSL2/std.scad>
teardrop2d(d=50, ang=30);</pre>
Wenn du es vorziehst, die Oberseite des Tropfens abzuflachen, um das Bridging zu fördern, kannst du das <code>cap_h=</code>-Argument verwenden:
<pre class="openscad">include <BOSL2/std.scad>
teardrop2d(d=50, cap_h=25);</pre>
<pre class="openscad">include <BOSL2/std.scad>
teardrop2d(d=50, ang=30, cap_h=30);</pre>
Du kannst <code>anchor=</code> und <code>spin=</code> verwenden, genau wie bei anderen anhängbaren Formen. Die Ankerpunkte basieren jedoch auf den äußersten Ausmaßen der Form und sind möglicherweise nicht dort, wo du sie erwartest:
<pre class="openscad">include <BOSL2/std.scad>
teardrop2d(d=50, ang=30, cap_h=30)
show_anchors();</pre>
<span id="verklebte-kreise-glued-circles"></span>
== Verklebte Kreise (Glued Circles) ==
Eine ungewöhnlichere Form, die BOSL2 bietet, sind verklebte Kreise (Glued Circles). Es handelt sich im Grunde um ein Paar von Kreisen, die durch etwas verbunden sind, das wie ein klebriger Meniskus aussieht:
<pre class="openscad">include <BOSL2/std.scad>
glued_circles(d=30, spread=40);</pre>
Die <code>r=</code>/<code>d=</code>-Argumente können den Radius oder Durchmesser der beiden Kreise angeben:
<pre class="openscad">include <BOSL2/std.scad>
glued_circles(r=20, spread=45);</pre>
<pre class="openscad">include <BOSL2/std.scad>
glued_circles(d=40, spread=45);</pre>
Das <code>spread=</code>-Argument gibt den Abstand zwischen den Mittelpunkten der beiden Kreise an:
<pre class="openscad">include <BOSL2/std.scad>
glued_circles(d=30, spread=30);</pre>
<pre class="openscad">include <BOSL2/std.scad>
glued_circles(d=30, spread=40);</pre>
Das <code>tangent=</code>-Argument gibt den Winkel der Tangente des Meniskus an den beiden Kreisen an:
<pre class="openscad">include <BOSL2/std.scad>
glued_circles(d=30, spread=30, tangent=45);</pre>
<pre class="openscad">include <BOSL2/std.scad>
glued_circles(d=30, spread=30, tangent=20);</pre>
<pre class="openscad">include <BOSL2/std.scad>
glued_circles(d=30, spread=30, tangent=-20);</pre>
Eine nützliche Sache, die du tun kannst, ist, einige <code>glued_circle()</code>s in einer Linie anzuordnen und sie dann zu extrudieren, um eine gerippte Wand zu erstellen:
<pre class="openscad">include <BOSL2/std.scad>
$fn=36; s=10;
linear_extrude(height=50,convexity=16,center=true)
xcopies(s*sqrt(2),n=3)
glued_circles(d=s, spread=s*sqrt(2), tangent=45);</pre>
Du kannst <code>anchor=</code> und <code>spin=</code> verwenden, genau wie bei anderen anhängbaren Formen. Die Ankerpunkte basieren jedoch auf den äußersten Ausmaßen der Form und sind möglicherweise nicht dort, wo du sie erwartest:
<pre class="openscad">include <BOSL2/std.scad>
glued_circles(d=40, spread=40, tangent=45)
show_anchors();</pre>
e060x6x7fl3a98tre5mfq1ov0q7n2b1
1093529
1093528
2026-11-08T15:37:08Z
Jowi-ammerbuch
115360
/* Benannte Ankerpunkte bei star() */
1093529
wikitext
text/x-wiki
{{MyNavi
|zurück = [[OpenSCAD Benutzerhandbuch/_BOSL2-Distributoren|Zurück]]
|buch = [[OpenSCAD Benutzerhandbuch/_BOSL2|BOSL2-Inhalt]]
|weiter = [[OpenSCAD Benutzerhandbuch/_BOSL2-3D|Weiter]]
}}
== 2D Grundformen (2D Primitive) ==
OpenSCAD bietet zwei eingebaute 2D-Grundformen: <code>square()</code> und <code>circle()</code>. Du kannst sie weiterhin auf die gewohnte Weise verwenden:
<pre class="openscad">include <BOSL2/std.scad>
square([60,40], center=true);</pre>
<pre class="openscad">include <BOSL2/std.scad>
circle(r=50);</pre>
<pre class="openscad">include <BOSL2/std.scad>
circle(d=100, $fn=8);</pre>
Diese Module wurden in der BOSL2-Bibliothek in drei Bereichen erweitert: Verankerung (Anchoring), Drehung (Spin) und Anhängbarkeit (Attachability).
<span id="verankerung-anchoring"></span>
=== Verankerung (Anchoring): ===
Wenn du ein <code>square()</code> erstellst, kannst du angeben, welche Ecke oder Seite am Ursprung verankert werden soll. Dies ersetzt das <code>center=</code>-Argument und ist flexibler. Das <code>anchor=</code>-Argument nimmt einen Vektor als Wert entgegen, der in grober Richtung der Seite oder Ecke zeigt, die du am Ursprung ausrichten möchtest.
=== anchor=[0,1] oder anchor=BACK ===
[[Datei:BOSL2-anchor-0-1.png|mini|zentriert|alternativtext=anchor=[0,1]);|square([60,40], '''anchor=[0,1]''');<br>
Oder: square([60,40], '''anchor=BACK''');]]
Um beispielsweise das '''Zentrum der hinteren Kante am Ursprung''' auszurichten, setzt du den Anker auf <code>[0,1]</code>:
<pre class="openscad">
include <BOSL2/std.scad>
square([60,40], anchor=[0,1]);
</pre>
Mit den leichter verständlichen vordefinierten '''Vektor-Konstanten''':
<pre class="openscad">
include <BOSL2/std.scad>
square([60,40], anchor=BACK+CENTER);
</pre>
=== anchor=[1,-1] oder anchor=RIGHT+FRONT ===
Um die '''vordere rechte Ecke am Ursprung''' auszurichten:
[[Datei:BOSL2-anchor-1 -1.png|mini|zentriert|alternativtext=anchor=RIGHT+FRONT);|square([60,40], '''anchor=[1,-1]''');<br>
Oder: square([60,40], '''anchor=RIGHT+FRONT''');]]
<pre class="openscad">
include <BOSL2/std.scad>
square([60,40], anchor=[1,-1]);
</pre>
'''Mit Vektor-Konstanten:'''
<pre class="openscad">
include <BOSL2/std.scad>
square([60,40], anchor=RIGHT+FRONT);
</pre>
=== anchor=[0,0] oder anchor=CENTER '''Fetter Text'''===
Um es zu '''zentrieren''':
<pre class="openscad">
include <BOSL2/std.scad>
square([60,40], anchor=[0,0]);
</pre>
'''Mit Vektor-Konstanten:'''
<pre class="openscad">
include <BOSL2/std.scad>
square([60,40], anchor=CENTER);
</pre>
=== Vektor-Konstanten am Rechteck ===
Um die Angabe von Vektoren übersichtlicher zu gestalten, sind mehrere Standard-Vektorkonstanten definiert:
[[Datei:BOSL2-anchor-Konstanten-Rechteck.png|gerahmt|zentriert|alternativtext=BOSL2 vordefinierte anchor-Konstanten|Die in BOSL2 vordefinierten anchor-Konstanten]]
{| class="wikitable"
|-
! Konstante
! Richtung
! Wert
|-
| LEFT
| X-
| [-1, 0, 0]
|-
| RIGHT
| X+
| [ 1, 0, 0]
|-
| FRONT / FORWARD / FWD
| Y-
| [ 0,-1, 0]
|-
| BACK
| Y+
| [ 0, 1, 0]
|-
| BOTTOM / BOT / BTM / DOWN
| Z-
| [ 0, 0,-1] (nur 3D)
|-
| TOP / UP
| Z+
| [ 0, 0, 1] (nur 3D)
|-
| CENTER / CTR
| Zentriert
| [ 0, 0, 0]
|}
Beachte, dass du die meisten dieser Konstanten (außer <code>UP</code>/<code>DOWN</code> natürlich) auch für Anker bei 2D-Formen verwenden kannst, obwohl es sich um 3D-Vektoren handelt:
<pre class="openscad">include <BOSL2/std.scad>
square([60,40], anchor=BACK);</pre>
<pre class="openscad">include <BOSL2/std.scad>
square([60,40], anchor=CENTER);</pre>
Du kannst Vektoren addieren, um auf Ecken zu zeigen:
<pre class="openscad">include <BOSL2/std.scad>
square([60,40], anchor=FRONT+RIGHT);</pre>
=== anchor = polar_to_xy ===
Für <code>circle()</code> kann der Ankervektor auf jeden beliebigen '''Punkt des Kreisumfangs''' zeigen:
[[Datei:BOSL2-anchor-polar to xy-circle.png|gerahmt|zentriert|alternativtext=anchor = polar_to_xy|anchor = polar_to_xy(1,Alpha), für Alpha = 0, 45, 90, ...]]
==== Beispiel: anchor=polar_to_xy(1,45) =====
[[Datei:BOSL2-anchor-polar to 1-45-octagon.png|mini|zentriert|alternativtext=circle(d=50, anchor=polar_to_xy(1,45), $fn = 8);|circle(d=50, anchor=polar_to_xy(1,45), $fn = 8);]]
<pre class="openscad">
include <BOSL2/std.scad>
circle(d=50, anchor=polar_to_xy(1,45), $fn = 8);
</pre>
Beachte, dass der Radius für den Anker keine Rolle spielt, da nur die Richtung des Ankers das Ergebnis beeinflusst.
=== show_anchors() ===
[[Datei:BOSL2-show anchor.png|mini|zentriert|show_anchors]]
Du kannst die typischen Ankerpunkte sehen, indem du <code>show_anchors()</code> als Kind der Form übergibst:
<pre class="openscad">include <BOSL2/std.scad>
square([60,40], center=true)
show_anchors();</pre>
<pre class="openscad">include <BOSL2/std.scad>
circle(d=50)
show_anchors();</pre>
<span id="drehung-spin"></span>
=== Drehung (Spin): ===
Die zweite Erweiterung von <code>square()</code> und <code>circle()</code> ist die Drehung (Spin). Wenn du die Form erstellst, kannst du sie mit dem <code>spin=</code>-Argument an Ort und Stelle drehen. Du übergibst einfach die Anzahl der Grad, um die sie im Uhrzeigersinn gedreht werden soll:
<pre class="openscad">include <BOSL2/std.scad>
square([60,40], anchor=CENTER, spin=30);</pre>
Die Verankerung oder Zentrierung erfolgt vor der Drehung:
<pre class="openscad">include <BOSL2/std.scad>
square([60,40], anchor=BACK, spin=30);</pre>
Bei Kreisen kann Spin nützlich sein, wenn auch <code>$fn=</code> angegeben wird:
<pre class="openscad">include <BOSL2/std.scad>
circle(d=50, $fn=6, spin=15);</pre>
Da die Verankerung vor der Drehung erfolgt, kannst du beides zusammen verwenden, um um den Anker herum zu drehen:
<pre class="openscad">include <BOSL2/std.scad>
circle(d=50, $fn=6, anchor=LEFT, spin=15);</pre>
<span id="anhängbarkeit-attachability"></span>
=== Anhängbarkeit (Attachability): ===
Die dritte Erweiterung von <code>square()</code> und <code>circle()</code> ist, dass du sie auf verschiedene Weise an Ankerpunkten zusammenhängen kannst. Dies geschieht, indem du eine Form zum Kind der Form machst, an die du sie anhängen möchtest.
==== Standard (ohne Spez. für anchor oder position) ====
Standardmäßig wird das Kind beim einfachen Untereinanderstellen im Zentrum der Elternform angehängt.
[[Datei:BOSL2-attach-standard-normal.png|mini|zentriert|alternativtext=square(50) #square(50);|square(50) #square(50);<br>
Kind-Objekt (rot) wird ans Zentrum des Elternobjekts angehängt]]
<pre class="openscad">
include <BOSL2/std.scad>
square(50) #square(50);
</pre>
==== anchor für child spezifiziert ====
[[Datei:BOSL2-attach-anchor-LEFTplusFWD.png|mini|zentriert|alternativtext=square(50, center=true) #square([20,40], anchor=LEFT+FWD);|square(50, center=true)#square([20,40], '''anchor=LEFT+FWD''');]]
<pre class="openscad">include <BOSL2/std.scad>
square(50, center=true)
#square([20,40], anchor=LEFT+FWD);</pre>
==== position() ====
[[Datei:BOSL2-attach-position.png|mini|zentriert|alternativtext=position(RIGHT)|square(50) '''position(RIGHT)''' #square(25) '''position(BACK)''' #square(25);]]
Durch Hinzufügen des <code>position()</code>-Moduls kannst du das Kind an jedem Ankerpunkt '''des Elternteils''' positionieren, das "Kindes-Kind wird am Ankerpunkt des übergeordneten Objekts positioniert:
<pre class="openscad">
include <BOSL2/std.scad>
square(50) position(RIGHT) #square(25)
position(BACK) #square(25);
</pre>
==== orient() ====
Ankerpunkte sind jedoch nicht nur Positionen auf dem Elternteil. Sie haben auch eine Ausrichtung. In den meisten Fällen zeigt die Ausrichtung eines Ankerpunkts nach außen, weg von der Fläche der Wand, also im Allgemeinen vom Zentrum der Form weg.
[[Datei:BOSL2-show anchor.png|mini|zentriert|show_anchors]]
Wenn du das Kind so ausrichten möchtest, dass es der Ausrichtung eines Ankerpunkts entspricht, kannst du das <code>orient()</code>-Modul verwenden. Es positioniert das Kind nicht, es dreht es nur:
[[Datei:BOSL2-attach-orient anchor.png|mini|zentriert|alternativtext= orient(anchor=LEFT+BOTTOM)|square(50) '''orient(anchor=LEFT+BOTTOM)''' #square([10,40]);]]
<pre class="openscad">include <BOSL2/std.scad>
square(50)
orient(anchor=LEFT+BOTTOM) #square([10,40]);</pre>
Das geht auch beim '''Kreis (circle)''' mit '''polar_to_xy''':
[[Datei:BOSL2-attach-orient polar to xy circle.png|mini|zentriert|alternativtext=orient(polar_to_xy(1,30))|circle(d=50) ''' orient(polar_to_xy(1,30))''' #square([10,40], anchor=FWD);]]
<pre class="openscad">include <BOSL2/std.scad>
circle(d=50)
orient(polar_to_xy(1,30))
#square([10,40], anchor=FWD);</pre>
==== position() + orient() ====
Du kannst <code>position()</code> und <code>orient()</code> zusammen verwenden, um sowohl zu positionieren als auch an einem Ankerpunkt auszurichten:
[[Datei:BOSL2-attach-position pluss orient polar to xy circle.png|mini|zentriert|alternativtext=position(polar_to_xy(1,30)) orient(polar_to_xy(1,30))|circle(d=50) '''position(polar_to_xy(1,30)) orient(polar_to_xy(1,30))''' #square([10,40], anchor=FWD);]]
<pre class="openscad">include <BOSL2/std.scad>
circle(d=50)
position(polar_to_xy(1,30))
orient(polar_to_xy(1,30))
#square([10,40], anchor=FWD);</pre>
=== attach () mit einem Argument ===
Aber es ist einfacher das <code>attach()</code>-Modul zu verwenden, um beides auf einmal zu erledigen:
[[Datei:BOSL2-attach-position pluss orient polar to xy circle.png|mini|zentriert|alternativtext=attach(polar_to_xy(1,30))|circle(d=50) '''attach(polar_to_xy(1,30))''' #square([10,40], anchor=FWD); ]]
Gleiches Ergebnis, aber übersichtlicherer Code.
<pre class="openscad">include <BOSL2/std.scad>
square(50, center=true)
attach(LEFT+BACK)
#square([10,40], anchor=FWD);</pre>
=== attach () mit zwei Argumenten ===
Anstatt den <code>anchor=</code> im Kind anzugeben, kannst du ein '''zweites Argument''' an <code>attach()</code> übergeben, das ihm sagt, welche Seite des Kindes mit dem Elternteil verbunden werden soll:
<pre class="openscad">
include <BOSL2/std.scad>
circle(d=50) attach(polar_to_xy(1,30), FWD) #square([10,40]);
</pre>
Damit lässt sich der Code noch mehr straffen.
[[Datei:BOSL2-attach-position pluss orient polar to xy circle.png|mini|zentriert|alternativtext=attach(polar_to_xy(1,30), FWD)|circle(d=50) '''attach(polar_to_xy(1,30), FWD)''' #square([10,40]); ]]
<span id="rechtecke-rectangles"></span>
== Rechtecke (Rectangles) ==
=== rect() ===
Die BOSL2-Bibliothek bietet eine Alternative zu <code>square()</code>, die mehr Funktionen unterstützt. Sie heißt <code>rect()</code>. Du kannst sie genauso verwenden wie <code>square()</code>, aber sie bietet auch erweiterte Funktionalität.
=== rect() mit rounding ===
[[Datei:BOSL2-rect rounding.png|mini|zentriert|alternativtext=rounding=10|rect([60,40], '''rounding=10''');]]
rect() erlaubt dir, die Ecken des Rechtecks abzurunden:
<pre class="openscad">include <BOSL2/std.scad>
rect([60,40], rounding=10);</pre>
=== rect() mit chamfer ===
[[Datei:BOSL2-rect chamfer.png|mini|zentriert|alternativtext=rect([60,40], chamfer=10);|rect([60,40], '''chamfer=10''');]]
Du kannst die Ecken des Rechtecks auch abfasen:
<pre class="openscad">include <BOSL2/std.scad>
rect([60,40], chamfer=10);</pre>
=== Unterschiedliche Abrundungen und Fasen an einem Rechteck ===
Du kannst sogar angeben, welche Ecken abgerundet oder abgefast werden. Wenn du eine Liste mit vier Größenwerten an die <code>rounding=</code>- oder <code>chamfer=</code>-Argumente übergibst, erhält jede Ecke ihre eigene Größe. Der Reihe nach geht es von der hinteren rechten Ecke (Quadrant I) gegen den Uhrzeigersinn zur hinteren linken Ecke (Quadrant II), zur vorderen linken Ecke (Quadrant III) und zur vorderen rechten Ecke (Quadrant IV):
Wenn eine Größe als <code>0</code> angegeben wird, gibt es keine Rundung und/oder Fase für die Ecke dieses Quadranten:
<pre class="openscad">include <BOSL2/std.scad>
rect([60,40], rounding=[0,5,10,15]);</pre>
<pre class="openscad">include <BOSL2/std.scad>
rect([60,40], chamfer=[0,5,10,15]);</pre>
Du kannst sowohl <code>rounding=</code>- als auch <code>chamfer=</code>-Argumente angeben, um Rundung und Fase zu mischen, aber nur, wenn du es pro Ecke angibst. Wenn du eine Rundung in einer Ecke möchtest, gib eine Fase von 0 für diese Ecke an und umgekehrt:
[[Datei:BOSL2-rect chamfer-rounding-mixed.png|mini|zentriert|alternativtext=ounding=[5,0,10,0], chamfer=[0,5,0,15]|rect([60,40], '''rounding=[5,0,10,0], chamfer=[0,5,0,15]''');]]
<pre class="openscad">include <BOSL2/std.scad>
rect([60,40], rounding=[5,0,10,0], chamfer=[0,5,0,15]);</pre>
<span id="ellipsen-ellipses"></span>
== Ellipsen (Ellipses) ==
Die BOSL2-Bibliothek bietet auch eine erweiterte Entsprechung von <code>circle()</code>, die <code>ellipse()</code> heißt. Du kannst sie genauso verwenden wie <code>circle()</code>, aber sie bietet auch erweiterte Funktionalität. Zum Beispiel erlaubt sie mehr Kontrolle über ihre Größe.
Da ein Kreis in OpenSCAD nur durch ein regelmäßiges Polygon mit einer Anzahl gerader Seiten angenähert werden kann, kann dies zu Ungenauigkeiten in Größe und Form führen. Um dem entgegenzuwirken, werden auch die Argumente <code>realign=</code> und <code>circum=</code> bereitgestellt.
=== realign= (ellipse-Argument) ===
Das <code>realign=</code>-Argument rotiert, wenn es auf <code>true</code> gesetzt wird, die <code>ellipse()</code> um den halben Winkel zwischen den Polygonseiten:
[[Datei:BOSL2-ellipse-realign.png|mini|zentriert|alternativtext=realign=true|#ellipse(d=100, $fn=8); color("lime") ellipse(d=100, $fn=8, '''realign=true''');]]
<pre class="openscad">
include <BOSL2/std.scad>
#ellipse(d=100, $fn=8);
color("lime") ellipse(d=100, $fn=8, realign=true);
</pre>
=== circum= (ellipse-Argument) ===
[[Datei:BOSL2-ellipse-circum.png|mini|zentriert|alternativtext=circum=true|Vergleich: rot (außen) mit circum=true und blau (innen) ohne circum. Referenz: idealer Kreis in gelb.]]
<pre class="openscad">
include <BOSL2/std.scad>
color("red") ellipse(d=100, $fn=6, circum=true);
color("yellow") ellipse(d=100, $fn=360);
color("blue") ellipse(d=100, $fn=6);
</pre>
Das <code>circum=</code>-Argument bewirkt, wenn es auf true gesetzt wird, dass das Polygon, das die <code>ellipse()</code> bildet, den idealen Kreis '''umschreibt''', anstatt ihn einzuschreiben.
Den idealen Kreis ''einschreiben'':
<pre class="openscad">include <BOSL2/std.scad>
color("green") ellipse(d=100, $fn=360);
ellipse(d=100, $fn=6);</pre>
Den idealen Kreis ''umschreiben'':
<pre class="openscad">include <BOSL2/std.scad>
ellipse(d=100, $fn=6, circum=true);
color("green") ellipse(d=100, $fn=360);</pre>
=== Ellipse mit 2 Radien ===
Das <code>ellipse()</code>-Modul kann, wie der Name schon sagt, mit separaten X- und Y-Radien oder -Durchmessern angegeben werden. Dazu gibst du einfach <code>r=</code> oder <code>d=</code> mit einer Liste von zwei Radien oder Durchmessern an:
[[Datei:BOSL2-ellipse-2Radien.png|mini|zentriert|alternativtext=2 Radien|ellipse('''r=[30,20]''');]]
==== r=[r1,r2] ====
<pre class="openscad">include <BOSL2/std.scad>
ellipse(r=[30,20]);</pre>
==== d=[d1,d2]====
<pre class="openscad">include <BOSL2/std.scad>
ellipse(d=[60,40]);</pre>
==== ellipse mit anchor ====
Wie bei <code>circle()</code> kannst du <code>ellipse()</code>-Formen verankern, drehen und anhängen:
[[Datei:BOSL2-ellipse-anchor.png|mini|zentriert|alternativtext=ellipse mit anchor|ellipse(d=[50,20], '''anchor=BACK'''); #ellipse(d=[50,20], '''anchor=FRONT''');]]
<pre class="openscad">
include <BOSL2/std.scad>
ellipse(d=[50,20], anchor=BACK);
#ellipse(d=[50,20], anchor=FRONT);
</pre>
==== ellipse mit attach ====
[[Datei:BOSL2-ellipse-attach.png|mini|zentriert|alternativtext=ellipse mit attach|ellipse(d=50) '''attach(BACK+RIGHT, FRONT+LEFT)''' #ellipse(d=[40,20]);]]
<pre class="openscad">
include <BOSL2/std.scad>
ellipse(d=50)
attach(BACK+RIGHT, FRONT+LEFT)
ellipse(d=30);
</pre>
<span id="rechtwinklige-dreiecke-right-triangles"></span>
==== ellipse mit spin ====
[[Datei:BOSL2-ellipse-attach-spin-anchor.png|mini|zentriert|alternativtext=spin = 90 bei ellipse|ellipse(d=50) attach(BACK) #ellipse(d=[40,20], '''spin=90''', anchor=LEFT);]]
<pre class="openscad">
include <BOSL2/std.scad>
ellipse(d=50)
attach(BACK)
#ellipse(d=[40,20], spin=90, anchor=LEFT);
</pre>
== Rechtwinklige Dreiecke (Right Triangles) ==
Die BOSL2-Bibliothek bietet eine einfache Möglichkeit, ein 2D-rechtwinkliges Dreieck mit dem <code>right_triangle()</code>-Modul zu erstellen:
[[Datei:BOSL2-right triangle.png|mini|zentriert|alternativtext=right_triangle([40,30])|right_triangle([40,30]);]]
<pre class="openscad">include <BOSL2/std.scad>
right_triangle([40,30]);</pre>
=== xflip() bei right_triangle ===
Du kannst <code>xflip()</code> und <code>yflip()</code> verwenden, um zu ändern, in welchem Quadranten das Dreieck gebildet wird:
[[Datei:BOSL2-right triangle xflip.png|mini|zentriert|alternativtext=right_triange mit xflip()|right_triangle([40,30]); '''xflip()''' #right_triangle([40,30]);]]
<pre class="openscad">include <BOSL2/std.scad>
xflip() right_triangle([40,30]);</pre>
=== yflip() bei right_triangle ===
[[Datei:BOSL2-right triangle yflip.png|mini|zentriert|alternativtext=right_triangle([40,30]) mit yflip()|right_triangle([40,30]); '''yflip()''' #right_triangle([40,30]);]]
<pre class="openscad">include <BOSL2/std.scad>
yflip() right_triangle([40,30]);</pre>
=== xflip() & yflip() bei right_triangle ===
[[Datei:BOSL2-right triangle xflip yflip.png|mini|zentriert|alternativtext=xflip() yflip()|right_triangle([40,30]); xflip() yflip() #right_triangle([40,30]);]]
<pre class="openscad">include <BOSL2/std.scad>
xflip() yflip() right_triangle([40,30]);</pre>
=== spin= bei right_triangle ===
Oder alternativ einfach mit <code>spin=</code> in den richtigen Quadranten drehen:
[[Datei:BOSL2-right triangle spin.png|mini|zentriert|alternativtext=right_triangle([40,30]) mit spin=90)|right_triangle([40,30]);
#right_triangle([40,30], '''spin=90''');]]
<pre class="openscad">include <BOSL2/std.scad>
right_triangle([40,30], spin=90);</pre>
<pre class="openscad">include <BOSL2/std.scad>
right_triangle([40,30], spin=-90);</pre>
Du kannst bei rechtwinkligen Dreiecken auch Verankerung verwenden:
<pre class="openscad">include <BOSL2/std.scad>
right_triangle([40,30], anchor=FWD+RIGHT);</pre>
<span id="trapeze-trapezoids"></span>
== Trapeze (Trapezoids) ==
OpenSCAD bietet keine einfache Möglichkeit, allgemeine 2D-Dreiecke, Trapeze oder Parallelogramme zu erstellen. Die BOSL2-Bibliothek kann all diese Formen mit dem <code>trapezoid()</code>-Modul bereitstellen.
=== Dreieck ===
Um ein gleichseitiges Dreieck zu erstellen, setze einfach eine der Breiten auf null:
[[Datei:BOSL2-trapezoid dreieck.png|mini|zentriert|alternativtext=Dreieck|trapezoid(w1=50, w2=0, h=40);<br>
Dreieck mit Seitenlänge = 50]]
<pre class="openscad">include <BOSL2/std.scad>
trapezoid(w1=50, w2=0, h=40);</pre>
Um ein rechtwinkliges Dreieck zu erstellen, musst du das <code>shift=</code>-Argument verwenden, um die Rückseite des Trapezes entlang der X-Achse zu verschieben:
[[Datei:BOSL2-trapezoid dreieck-rechtwinklig.png|mini|zentriert|alternativtext=Rechtwinkliges Dreieck|trapezoid(w1=50, w2=0, h=50, shift=-25);]]
<pre class="openscad">include <BOSL2/std.scad>
trapezoid(w1=50, w2=0, h=50, shift=-25);</pre>
<pre class="openscad">include <BOSL2/std.scad>
trapezoid(w1=50, w2=0, h=50, shift=25);</pre>
<pre class="openscad">include <BOSL2/std.scad>
trapezoid(w1=0, w2=50, h=50, shift=-25);</pre>
<pre class="openscad">include <BOSL2/std.scad>
trapezoid(w1=0, w2=50, h=50, shift=25);</pre>
=== Trapez ===
Du kannst ein Trapez erstellen, indem du für vorne (<code>w1=</code>) und hinten (<code>w2=</code>) von null verschiedene Breiten angibst:
[[Datei:BOSL2-trapezoid trapez.png|mini|zentriert|alternativtext=Trapez|trapezoid(w1=30, w2=50, h=50);]]
<pre class="openscad">include <BOSL2/std.scad>
trapezoid(w1=30, w2=50, h=50);</pre>
=== Parallelogramm ===
Ein Parallelogramm ist nur eine Frage der Verwendung der gleichen Breite für vorne und hinten, mit einer Verschiebung entlang der X-Achse:
[[Datei:BOSL2-trapezoid parallelogram.png|mini|zentriert|alternativtext=Parallelogramm|trapezoid(w1=50, w2=50, shift=20, h=50);]]
<pre class="openscad">include <BOSL2/std.scad>
trapezoid(w1=50, w2=50, shift=20, h=50);</pre>
=== Viereck ===
Ein Viereck kann erstellt werden, indem ungleiche, von null verschiedene Breiten für vorne (<code>w1=</code>) und hinten (<code>w2=</code>) verwendet werden, wobei die Rückseite entlang der X-Achse verschoben wird:
[[Datei:BOSL2-trapezoid viereck.png|mini|zentriert|alternativtext=Viereck|trapezoid(w1=50, w2=30, shift=20, h=50);]]
<pre class="openscad">include <BOSL2/std.scad>
trapezoid(w1=50, w2=30, shift=20, h=50);</pre>
Du kannst <code>anchor=</code> und <code>spin=</code> verwenden, genau wie bei anderen anhängbaren Formen. Die Ausrichtungen der Ankerpunkte basieren jedoch auf den Seitenwinkeln der Flächen und sind möglicherweise nicht das, was du erwartest:
<pre class="openscad">include <BOSL2/std.scad>
trapezoid(w1=30, w2=50, h=50)
show_anchors();</pre>
<span id="regelmäßige-n-ecke-regular-n-gons"></span>
== Regelmäßige n-Ecke (Regular N-Gons) ==
OpenSCAD ermöglicht es dir, regelmäßige n-Ecke (Fünfeck, Sechseck usw.) zu erstellen, indem du <code>circle()</code> mit <code>$fn</code> verwendest. Obwohl dies prägnant ist, mag es auf den ersten Blick weniger offensichtlich sein:
<pre class="openscad">include <BOSL2/std.scad>
circle(d=50, $fn=5);</pre>
Die BOSL2-Bibliothek hat Module, die für gängige n-Ecke klarer benannt sind:
=== Pentagon (d=<Durchmesser>) ===
[[Datei:BOSL2-Pentagon.png|mini|zentriert|alternativtext=Pentagon|pentagon(d=50);]]
<pre class="openscad">include <BOSL2/std.scad>
pentagon(d=50);</pre>
=== Hexagon (d=<Durchmesser>) ===
[[Datei:BOSL2-Hexagon.png|mini|zentriert|alternativtext=Hexagon| hexagon(d=50);]]
<pre class="openscad">include <BOSL2/std.scad>
hexagon(d=50);</pre>
=== Octagon (d= <Durchmesser>) ===
[[Datei:BOSL2-Octagon.png|mini|zentriert|alternativtext=octagon(d=50);|octagon(d=50);]]
<pre class="openscad">include <BOSL2/std.scad>
octagon(d=50);</pre>
=== regular_ngon (n=<Seitenanzahl>, d=<Durchmesser>) ===
[[Datei:BOSL2-regular ngon.png|mini|zentriert|alternativtext=regular_ngon|regular_ngon(n=7, d=50);]]
<pre class="openscad">include <BOSL2/std.scad>
regular_ngon(n=7, d=50);</pre>
=== side=<Seitenlänge> ===
Diese Module bieten dir auch zusätzliche Funktionalität. Sie können nach Seitenlänge dimensioniert werden:
[[Datei:BOSL2-Hexagon side50.png|mini|zentriert|alternativtext=hexagon(side=50);|hexagon(side=50);]]
<pre class="openscad">include <BOSL2/std.scad>
pentagon(side=50);</pre>
=== ir = <Innenradius> / id = <Innendurchmesser> ===
Sie können nach dem Radius/Durchmesser des umschriebenen Kreises (Innenkreis) dimensioniert werden:
[[Datei:BOSL2-Pentagon Innenradius.png|mini|zentriert|alternativtext=Innenradius|color("red") pentagon('''ir=25'''); color("yellow") circle(r=25,$fn=100);]]
<pre class="openscad">include <BOSL2/std.scad>
pentagon(ir=25);
pentagon(id=50);</pre>
=== realign=true/false ===
Die Polygone können um eine halbe Seite gedreht werden:
[[Datei:BOSL2-Pentagon realign.png|mini|zentriert|alternativtext=realign|pentagon(d=50, '''realign=false'''); #pentagon(d=50, '''realign=true''');]]
<pre class="openscad">include <BOSL2/std.scad>
left(30) pentagon(d=50, realign=true);
right(30) pentagon(d=50, realign=false);</pre>
=== rounding = <Rundung> ===
Die BOSL2-Polygone können abgerundet werden:
[[Datei:BOSL2-Polygon-rounding.png|mini|zentriert|alternativtext=rounding|pentagon(d=50, '''rounding=5''');]]
<pre class="openscad">include <BOSL2/std.scad>
pentagon(d=50, rounding=5);</pre>
=== show_anchors() ===
Die BOSL2-Polygone haben auch ein etwas anderes Anhangsverhalten als die regulären Polygone, die über $fn=<Seitenanzahl> erzeugt werden.
Ein Kreis mit einem kleinen <code>$fn=</code> hängt Dinge am idealen Kreis an, nicht entlang des erstellten Polygons:
[[Datei:BOSL2-polygon-outcircle-anchors.png|mini|zentriert|alternativtext=anchors Außenkreis|color("green") stroke(circle(d=50), closed=true); circle(d=50,$fn=6) show_anchors();]]
<pre class="openscad">include <BOSL2/std.scad>
color("green") stroke(circle(d=50), closed=true);
circle(d=50,$fn=6)
show_anchors();</pre>
Während ein BOSL2-n-Eck entlang des Polygons selbst (direkt) anhängt:
[[Datei:BOSL2-polygon-direct-anchors.png|mini|zentriert|alternativtext=anchors BOSL2 Polygone direkt|color("green") stroke(circle(d=50), closed=true); circle(d=50,$fn=6) show_anchors();]]
<pre class="openscad">include <BOSL2/std.scad>
hexagon(d=50)
show_anchors(custom=false);</pre>
Du kannst <code>anchor=</code> und <code>spin=</code> verwenden, genau wie bei anderen anhängbaren Formen. Die Ankerpunkte basieren jedoch darauf, wo der Ankervektor die Seite des n-Ecks schneiden würde, und sind möglicherweise nicht dort, wo du sie erwartest:
[[Datei:BOSL2-Pentagon-anchor.png|mini|zentriert|alternativtext=n-Polygon anchor|pentagon(d=50, '''anchor=FRONT+LEFT''') show_anchors(custom=false);]]
<pre class="openscad">include <BOSL2/std.scad>
pentagon(d=50, anchor=FRONT+LEFT)
show_anchors(custom=false);</pre>
=== Ankerpunkte für Seiten und Spitzen ===
n-Ecke haben auch benannte Ankerpunkte für ihre Seiten und Spitzen:
[[Datei:BOSL2-anchor-Spitzen-Seiten.png|mini|zentriert|alternativtext=Anker für Seiten und Spitzen|Spezielle Anker für die Spitzen und Seiten eines Pentagons (mit TikZ unter LaTeX erstellt)]]
Beachte, dass die Ankernamen in "" gesetzt werden müssen.
Zum Beispiel:
[[Datei:BOSL2-Pentagon anchor tip1.png|mini|zentriert|alternativtext=anchor="tip1"|pentagon(d=30, '''anchor="tip1" ''');]]
<pre class="openscad">include <BOSL2/std.scad>
pentagon(d=30, anchor="tip1");</pre>
<span id="sterne-stars"></span>
Beispiel mit attach():
[[Datei:BOSL2-anchor-Spitzen-Seiten attach.png|mini|zentriert|alternativtext=anchor="side2"|pentagon(d=30, anchor="side2") '''attach("tip0")''' circle(r=3,$fn=36);]]
<pre class="openscad">
include <BOSL2/std.scad>
pentagon(d=30, anchor="side2") attach("tip0") circle(r=3,$fn=36);
</pre>
== Sterne (Stars) ==
=== star() mit n, ir/id und or/od ===
Die BOSL2-Bibliothek hat Sterne als grundlegend unterstützte Form. Sie können eine beliebige Anzahl '''n''' von '''Spitzen''' haben. Du kannst die Form eines Sterns durch Spitzenanzahl, '''innere und äußere Scheitelpunkt-Radius/-Durchmesser''' angeben:
[[Datei:BOSL2-star n5 ir15 dr30-Veranschaulichung.png|mini|zentriert|alternativtext=Innerer und äußerer Radius bei star()|Veranschaulichung von den Parameter '''ir''' (oder id) und '''or''' (oder od). ''ir'' gibt den inneren Radius und or den äußeren Radius an. Die Anzahl der Zacken ist hier n=5. Siehe Code unten.]]
Begonnen wird der Stern mit einem Zacken nach rechts auf der X-Achse.
<pre class="openscad">
include <BOSL2/std.scad>
#circle(30, $fn=60);
color("blue") star(n=5, ir=15, or=30);
#circle(15, $fn=60);
color("darkblue") fwd(35) text("or=30", halign = "center", size=3);
color("yellow") text("ir=15",halign = "center", size=3, valign="center");
</pre>
=== star() mit Spannweite d ===
Statt '''od''' kann auch einfach '''d''' als Parameter verwendet werden.
[[Datei:BOSL2-star n3 id10 d50.png|mini|zentriert|alternativtext=star(n=3, id=10, d=50);|star(n=3, id=10, d=50);]]
<pre class="openscad">include <BOSL2/std.scad>
star(n=3, id=10, d=50);</pre>
[[Datei:BOSL2-star n5 id15 r25.png|mini|zentriert|alternativtext=star(n=5, id=15, r=25);|star(n=5, id=15, r=25);]]
<pre class="openscad">include <BOSL2/std.scad>
star(n=5, id=15, r=25);</pre>
[[Datei:BOSL2-star n10 id30 d50.png|mini|zentriert|alternativtext=star(n=10, id=30, d=50);|star(n=10, id=30, d=50);]]
<pre class="openscad">include <BOSL2/std.scad>
star(n=10, id=30, d=50);</pre>
=== star (n = <Spitzenanzahl>, step = <Anzahl zu überspringender Punkte>) ===
Oder du kannst die Sternform durch Spitzenanzahl '''n''' und Anzahl '''step''' der zu überspringenden Punkte angeben:
[[Datei:BOSL2-star n7 step2 d50.png|mini|zentriert|alternativtext=step|star(n=7, step=2, d=50);]]
<pre class="openscad">include <BOSL2/std.scad>
star(n=7, step=2, d=50);</pre>
[[Datei:BOSL2-star n7 step3 d50.png|mini|zentriert|alternativtext=step=3|star(n=7, step=3, d=50);]]
<pre class="openscad">include <BOSL2/std.scad>
star(n=7, step=3, d=50);</pre>
=== star() mit realign ===
Wenn dem <code>realign=</code>-Argument ein true-Wert übergeben wird, wird der Stern um einen halben Spitzenwinkel gedreht:
<pre class="openscad">include <BOSL2/std.scad>
left(30) star(n=5, step=2, d=50);
right(30) star(n=5, step=2, d=50, realign=true);</pre>
=== star() mit align_tip=<Anker> ===
Das <code>align_tip=</code>-Argument kann mit einem Vektor angegeben werden, damit du die erste Spitze in eine bestimmte Richtung ausrichten kannst:
<pre class="openscad">include <BOSL2/std.scad>
star(n=5, ir=15, or=30, align_tip=BACK)
attach("tip0") color("blue") anchor_arrow2d();</pre>
<pre class="openscad">include <BOSL2/std.scad>
star(n=5, ir=15, or=30, align_tip=BACK+RIGHT)
attach("tip0") color("blue") anchor_arrow2d();</pre>
=== star() mit align_pit=<Anker> ===
Ebenso kann die erste Einkerbung oder Einbuchtung mit <code>align_pit=</code> in Richtung eines bestimmten Vektors ausgerichtet werden:
<pre class="openscad">include <BOSL2/std.scad>
star(n=5, ir=15, or=30, align_pit=BACK)
attach("pit0") color("blue") anchor_arrow2d();</pre>
<pre class="openscad">include <BOSL2/std.scad>
star(n=5, ir=15, or=30, align_pit=BACK+RIGHT)
attach("pit0") color("blue") anchor_arrow2d();</pre>
Du kannst <code>anchor=</code> und <code>spin=</code> verwenden, genau wie bei anderen anhängbaren Formen. Die Ankerpunkte basieren jedoch auf den äußersten Ausmaßen der Form und sind möglicherweise nicht dort, wo du sie erwartest:
<pre class="openscad">include <BOSL2/std.scad>
star(n=5, step=2, d=50)
show_anchors(custom=false);</pre>
=== Benannte Ankerpunkte bei star() ===
Sterne haben auch benannte Ankerpunkte für ihre Gruben, Spitzen und Mittelpunkte zwischen den Spitzen:
[[Datei:BOSL2-star n5 benannteAnker.png|mini|zentriert|alternativtext=benannten Ankerpunkte in star()|Zuordnung der benannten Ankerpunkte in star(). Spitzen beginnen mit "tipt0", Einkerbungen mit pit0.]]
==== Beispiel 1: anchor="tip0" attach("pit0") ====
[[Datei:BOSL2-star-n5 ir=15 or30 anchor tip0 pit0.png|mini|zentriert|alternativtext=anchor="tip0"|star(n=5, ir=15, or=30, anchor="tip0") attach("pit0") #circle(3);]]
<pre class="openscad">
include <BOSL2/std.scad>
star(n=5, ir=15, or=30, anchor="tip0") attach("pit0") #circle(3);
</pre>
==== Beispiel 2: anchor="pit0" attach("tip0") ====
[[Datei:BOSL2-star n5 anchor pit0 attach tip0.png|mini|zentriert|alternativtext=anchor="pit0" attach("tip0")|star(n=5, ir=15, or=30, anchor="pit0") attach("tip0") #circle(3);]]
<pre class="openscad">
include <BOSL2/std.scad>
star(n=5, ir=15, or=30, anchor="pit0") attach("tip0") #circle(3);
</pre>
<span id="tropfenform-2d-teardrop2d"></span>
== Tropfenform 2D (Teardrop2D) ==
Beim 3D-Druck möchtest du oft ein kreisförmiges Loch in eine vertikale Wand machen. Wenn das Loch jedoch zu groß ist, kann der Überhang an der Oberseite des Lochs Probleme beim Drucken auf einem FDM/FFF-Drucker verursachen. Wenn du kein Stützmaterial verwenden möchtest, kannst du einfach die Tropfenform verwenden. Das <code>teardrop2d()</code>-Modul ermöglicht es dir, eine 2D-Version der Tropfenform zu erstellen, damit du sie später extrudieren kannst:
<pre class="openscad">include <BOSL2/std.scad>
teardrop2d(r=20);</pre>
<pre class="openscad">include <BOSL2/std.scad>
teardrop2d(d=50);</pre>
Der Standard-Überhangwinkel beträgt 45 Grad, aber du kannst ihn mit dem <code>ang=</code>-Argument anpassen:
<pre class="openscad">include <BOSL2/std.scad>
teardrop2d(d=50, ang=30);</pre>
Wenn du es vorziehst, die Oberseite des Tropfens abzuflachen, um das Bridging zu fördern, kannst du das <code>cap_h=</code>-Argument verwenden:
<pre class="openscad">include <BOSL2/std.scad>
teardrop2d(d=50, cap_h=25);</pre>
<pre class="openscad">include <BOSL2/std.scad>
teardrop2d(d=50, ang=30, cap_h=30);</pre>
Du kannst <code>anchor=</code> und <code>spin=</code> verwenden, genau wie bei anderen anhängbaren Formen. Die Ankerpunkte basieren jedoch auf den äußersten Ausmaßen der Form und sind möglicherweise nicht dort, wo du sie erwartest:
<pre class="openscad">include <BOSL2/std.scad>
teardrop2d(d=50, ang=30, cap_h=30)
show_anchors();</pre>
<span id="verklebte-kreise-glued-circles"></span>
== Verklebte Kreise (Glued Circles) ==
Eine ungewöhnlichere Form, die BOSL2 bietet, sind verklebte Kreise (Glued Circles). Es handelt sich im Grunde um ein Paar von Kreisen, die durch etwas verbunden sind, das wie ein klebriger Meniskus aussieht:
<pre class="openscad">include <BOSL2/std.scad>
glued_circles(d=30, spread=40);</pre>
Die <code>r=</code>/<code>d=</code>-Argumente können den Radius oder Durchmesser der beiden Kreise angeben:
<pre class="openscad">include <BOSL2/std.scad>
glued_circles(r=20, spread=45);</pre>
<pre class="openscad">include <BOSL2/std.scad>
glued_circles(d=40, spread=45);</pre>
Das <code>spread=</code>-Argument gibt den Abstand zwischen den Mittelpunkten der beiden Kreise an:
<pre class="openscad">include <BOSL2/std.scad>
glued_circles(d=30, spread=30);</pre>
<pre class="openscad">include <BOSL2/std.scad>
glued_circles(d=30, spread=40);</pre>
Das <code>tangent=</code>-Argument gibt den Winkel der Tangente des Meniskus an den beiden Kreisen an:
<pre class="openscad">include <BOSL2/std.scad>
glued_circles(d=30, spread=30, tangent=45);</pre>
<pre class="openscad">include <BOSL2/std.scad>
glued_circles(d=30, spread=30, tangent=20);</pre>
<pre class="openscad">include <BOSL2/std.scad>
glued_circles(d=30, spread=30, tangent=-20);</pre>
Eine nützliche Sache, die du tun kannst, ist, einige <code>glued_circle()</code>s in einer Linie anzuordnen und sie dann zu extrudieren, um eine gerippte Wand zu erstellen:
<pre class="openscad">include <BOSL2/std.scad>
$fn=36; s=10;
linear_extrude(height=50,convexity=16,center=true)
xcopies(s*sqrt(2),n=3)
glued_circles(d=s, spread=s*sqrt(2), tangent=45);</pre>
Du kannst <code>anchor=</code> und <code>spin=</code> verwenden, genau wie bei anderen anhängbaren Formen. Die Ankerpunkte basieren jedoch auf den äußersten Ausmaßen der Form und sind möglicherweise nicht dort, wo du sie erwartest:
<pre class="openscad">include <BOSL2/std.scad>
glued_circles(d=40, spread=40, tangent=45)
show_anchors();</pre>
gk7w2gjh4tmrmuhki6tyt4pypirffca
1093530
1093529
2026-11-08T15:40:10Z
Jowi-ammerbuch
115360
/* star() mit align_tip= */
1093530
wikitext
text/x-wiki
{{MyNavi
|zurück = [[OpenSCAD Benutzerhandbuch/_BOSL2-Distributoren|Zurück]]
|buch = [[OpenSCAD Benutzerhandbuch/_BOSL2|BOSL2-Inhalt]]
|weiter = [[OpenSCAD Benutzerhandbuch/_BOSL2-3D|Weiter]]
}}
== 2D Grundformen (2D Primitive) ==
OpenSCAD bietet zwei eingebaute 2D-Grundformen: <code>square()</code> und <code>circle()</code>. Du kannst sie weiterhin auf die gewohnte Weise verwenden:
<pre class="openscad">include <BOSL2/std.scad>
square([60,40], center=true);</pre>
<pre class="openscad">include <BOSL2/std.scad>
circle(r=50);</pre>
<pre class="openscad">include <BOSL2/std.scad>
circle(d=100, $fn=8);</pre>
Diese Module wurden in der BOSL2-Bibliothek in drei Bereichen erweitert: Verankerung (Anchoring), Drehung (Spin) und Anhängbarkeit (Attachability).
<span id="verankerung-anchoring"></span>
=== Verankerung (Anchoring): ===
Wenn du ein <code>square()</code> erstellst, kannst du angeben, welche Ecke oder Seite am Ursprung verankert werden soll. Dies ersetzt das <code>center=</code>-Argument und ist flexibler. Das <code>anchor=</code>-Argument nimmt einen Vektor als Wert entgegen, der in grober Richtung der Seite oder Ecke zeigt, die du am Ursprung ausrichten möchtest.
=== anchor=[0,1] oder anchor=BACK ===
[[Datei:BOSL2-anchor-0-1.png|mini|zentriert|alternativtext=anchor=[0,1]);|square([60,40], '''anchor=[0,1]''');<br>
Oder: square([60,40], '''anchor=BACK''');]]
Um beispielsweise das '''Zentrum der hinteren Kante am Ursprung''' auszurichten, setzt du den Anker auf <code>[0,1]</code>:
<pre class="openscad">
include <BOSL2/std.scad>
square([60,40], anchor=[0,1]);
</pre>
Mit den leichter verständlichen vordefinierten '''Vektor-Konstanten''':
<pre class="openscad">
include <BOSL2/std.scad>
square([60,40], anchor=BACK+CENTER);
</pre>
=== anchor=[1,-1] oder anchor=RIGHT+FRONT ===
Um die '''vordere rechte Ecke am Ursprung''' auszurichten:
[[Datei:BOSL2-anchor-1 -1.png|mini|zentriert|alternativtext=anchor=RIGHT+FRONT);|square([60,40], '''anchor=[1,-1]''');<br>
Oder: square([60,40], '''anchor=RIGHT+FRONT''');]]
<pre class="openscad">
include <BOSL2/std.scad>
square([60,40], anchor=[1,-1]);
</pre>
'''Mit Vektor-Konstanten:'''
<pre class="openscad">
include <BOSL2/std.scad>
square([60,40], anchor=RIGHT+FRONT);
</pre>
=== anchor=[0,0] oder anchor=CENTER '''Fetter Text'''===
Um es zu '''zentrieren''':
<pre class="openscad">
include <BOSL2/std.scad>
square([60,40], anchor=[0,0]);
</pre>
'''Mit Vektor-Konstanten:'''
<pre class="openscad">
include <BOSL2/std.scad>
square([60,40], anchor=CENTER);
</pre>
=== Vektor-Konstanten am Rechteck ===
Um die Angabe von Vektoren übersichtlicher zu gestalten, sind mehrere Standard-Vektorkonstanten definiert:
[[Datei:BOSL2-anchor-Konstanten-Rechteck.png|gerahmt|zentriert|alternativtext=BOSL2 vordefinierte anchor-Konstanten|Die in BOSL2 vordefinierten anchor-Konstanten]]
{| class="wikitable"
|-
! Konstante
! Richtung
! Wert
|-
| LEFT
| X-
| [-1, 0, 0]
|-
| RIGHT
| X+
| [ 1, 0, 0]
|-
| FRONT / FORWARD / FWD
| Y-
| [ 0,-1, 0]
|-
| BACK
| Y+
| [ 0, 1, 0]
|-
| BOTTOM / BOT / BTM / DOWN
| Z-
| [ 0, 0,-1] (nur 3D)
|-
| TOP / UP
| Z+
| [ 0, 0, 1] (nur 3D)
|-
| CENTER / CTR
| Zentriert
| [ 0, 0, 0]
|}
Beachte, dass du die meisten dieser Konstanten (außer <code>UP</code>/<code>DOWN</code> natürlich) auch für Anker bei 2D-Formen verwenden kannst, obwohl es sich um 3D-Vektoren handelt:
<pre class="openscad">include <BOSL2/std.scad>
square([60,40], anchor=BACK);</pre>
<pre class="openscad">include <BOSL2/std.scad>
square([60,40], anchor=CENTER);</pre>
Du kannst Vektoren addieren, um auf Ecken zu zeigen:
<pre class="openscad">include <BOSL2/std.scad>
square([60,40], anchor=FRONT+RIGHT);</pre>
=== anchor = polar_to_xy ===
Für <code>circle()</code> kann der Ankervektor auf jeden beliebigen '''Punkt des Kreisumfangs''' zeigen:
[[Datei:BOSL2-anchor-polar to xy-circle.png|gerahmt|zentriert|alternativtext=anchor = polar_to_xy|anchor = polar_to_xy(1,Alpha), für Alpha = 0, 45, 90, ...]]
==== Beispiel: anchor=polar_to_xy(1,45) =====
[[Datei:BOSL2-anchor-polar to 1-45-octagon.png|mini|zentriert|alternativtext=circle(d=50, anchor=polar_to_xy(1,45), $fn = 8);|circle(d=50, anchor=polar_to_xy(1,45), $fn = 8);]]
<pre class="openscad">
include <BOSL2/std.scad>
circle(d=50, anchor=polar_to_xy(1,45), $fn = 8);
</pre>
Beachte, dass der Radius für den Anker keine Rolle spielt, da nur die Richtung des Ankers das Ergebnis beeinflusst.
=== show_anchors() ===
[[Datei:BOSL2-show anchor.png|mini|zentriert|show_anchors]]
Du kannst die typischen Ankerpunkte sehen, indem du <code>show_anchors()</code> als Kind der Form übergibst:
<pre class="openscad">include <BOSL2/std.scad>
square([60,40], center=true)
show_anchors();</pre>
<pre class="openscad">include <BOSL2/std.scad>
circle(d=50)
show_anchors();</pre>
<span id="drehung-spin"></span>
=== Drehung (Spin): ===
Die zweite Erweiterung von <code>square()</code> und <code>circle()</code> ist die Drehung (Spin). Wenn du die Form erstellst, kannst du sie mit dem <code>spin=</code>-Argument an Ort und Stelle drehen. Du übergibst einfach die Anzahl der Grad, um die sie im Uhrzeigersinn gedreht werden soll:
<pre class="openscad">include <BOSL2/std.scad>
square([60,40], anchor=CENTER, spin=30);</pre>
Die Verankerung oder Zentrierung erfolgt vor der Drehung:
<pre class="openscad">include <BOSL2/std.scad>
square([60,40], anchor=BACK, spin=30);</pre>
Bei Kreisen kann Spin nützlich sein, wenn auch <code>$fn=</code> angegeben wird:
<pre class="openscad">include <BOSL2/std.scad>
circle(d=50, $fn=6, spin=15);</pre>
Da die Verankerung vor der Drehung erfolgt, kannst du beides zusammen verwenden, um um den Anker herum zu drehen:
<pre class="openscad">include <BOSL2/std.scad>
circle(d=50, $fn=6, anchor=LEFT, spin=15);</pre>
<span id="anhängbarkeit-attachability"></span>
=== Anhängbarkeit (Attachability): ===
Die dritte Erweiterung von <code>square()</code> und <code>circle()</code> ist, dass du sie auf verschiedene Weise an Ankerpunkten zusammenhängen kannst. Dies geschieht, indem du eine Form zum Kind der Form machst, an die du sie anhängen möchtest.
==== Standard (ohne Spez. für anchor oder position) ====
Standardmäßig wird das Kind beim einfachen Untereinanderstellen im Zentrum der Elternform angehängt.
[[Datei:BOSL2-attach-standard-normal.png|mini|zentriert|alternativtext=square(50) #square(50);|square(50) #square(50);<br>
Kind-Objekt (rot) wird ans Zentrum des Elternobjekts angehängt]]
<pre class="openscad">
include <BOSL2/std.scad>
square(50) #square(50);
</pre>
==== anchor für child spezifiziert ====
[[Datei:BOSL2-attach-anchor-LEFTplusFWD.png|mini|zentriert|alternativtext=square(50, center=true) #square([20,40], anchor=LEFT+FWD);|square(50, center=true)#square([20,40], '''anchor=LEFT+FWD''');]]
<pre class="openscad">include <BOSL2/std.scad>
square(50, center=true)
#square([20,40], anchor=LEFT+FWD);</pre>
==== position() ====
[[Datei:BOSL2-attach-position.png|mini|zentriert|alternativtext=position(RIGHT)|square(50) '''position(RIGHT)''' #square(25) '''position(BACK)''' #square(25);]]
Durch Hinzufügen des <code>position()</code>-Moduls kannst du das Kind an jedem Ankerpunkt '''des Elternteils''' positionieren, das "Kindes-Kind wird am Ankerpunkt des übergeordneten Objekts positioniert:
<pre class="openscad">
include <BOSL2/std.scad>
square(50) position(RIGHT) #square(25)
position(BACK) #square(25);
</pre>
==== orient() ====
Ankerpunkte sind jedoch nicht nur Positionen auf dem Elternteil. Sie haben auch eine Ausrichtung. In den meisten Fällen zeigt die Ausrichtung eines Ankerpunkts nach außen, weg von der Fläche der Wand, also im Allgemeinen vom Zentrum der Form weg.
[[Datei:BOSL2-show anchor.png|mini|zentriert|show_anchors]]
Wenn du das Kind so ausrichten möchtest, dass es der Ausrichtung eines Ankerpunkts entspricht, kannst du das <code>orient()</code>-Modul verwenden. Es positioniert das Kind nicht, es dreht es nur:
[[Datei:BOSL2-attach-orient anchor.png|mini|zentriert|alternativtext= orient(anchor=LEFT+BOTTOM)|square(50) '''orient(anchor=LEFT+BOTTOM)''' #square([10,40]);]]
<pre class="openscad">include <BOSL2/std.scad>
square(50)
orient(anchor=LEFT+BOTTOM) #square([10,40]);</pre>
Das geht auch beim '''Kreis (circle)''' mit '''polar_to_xy''':
[[Datei:BOSL2-attach-orient polar to xy circle.png|mini|zentriert|alternativtext=orient(polar_to_xy(1,30))|circle(d=50) ''' orient(polar_to_xy(1,30))''' #square([10,40], anchor=FWD);]]
<pre class="openscad">include <BOSL2/std.scad>
circle(d=50)
orient(polar_to_xy(1,30))
#square([10,40], anchor=FWD);</pre>
==== position() + orient() ====
Du kannst <code>position()</code> und <code>orient()</code> zusammen verwenden, um sowohl zu positionieren als auch an einem Ankerpunkt auszurichten:
[[Datei:BOSL2-attach-position pluss orient polar to xy circle.png|mini|zentriert|alternativtext=position(polar_to_xy(1,30)) orient(polar_to_xy(1,30))|circle(d=50) '''position(polar_to_xy(1,30)) orient(polar_to_xy(1,30))''' #square([10,40], anchor=FWD);]]
<pre class="openscad">include <BOSL2/std.scad>
circle(d=50)
position(polar_to_xy(1,30))
orient(polar_to_xy(1,30))
#square([10,40], anchor=FWD);</pre>
=== attach () mit einem Argument ===
Aber es ist einfacher das <code>attach()</code>-Modul zu verwenden, um beides auf einmal zu erledigen:
[[Datei:BOSL2-attach-position pluss orient polar to xy circle.png|mini|zentriert|alternativtext=attach(polar_to_xy(1,30))|circle(d=50) '''attach(polar_to_xy(1,30))''' #square([10,40], anchor=FWD); ]]
Gleiches Ergebnis, aber übersichtlicherer Code.
<pre class="openscad">include <BOSL2/std.scad>
square(50, center=true)
attach(LEFT+BACK)
#square([10,40], anchor=FWD);</pre>
=== attach () mit zwei Argumenten ===
Anstatt den <code>anchor=</code> im Kind anzugeben, kannst du ein '''zweites Argument''' an <code>attach()</code> übergeben, das ihm sagt, welche Seite des Kindes mit dem Elternteil verbunden werden soll:
<pre class="openscad">
include <BOSL2/std.scad>
circle(d=50) attach(polar_to_xy(1,30), FWD) #square([10,40]);
</pre>
Damit lässt sich der Code noch mehr straffen.
[[Datei:BOSL2-attach-position pluss orient polar to xy circle.png|mini|zentriert|alternativtext=attach(polar_to_xy(1,30), FWD)|circle(d=50) '''attach(polar_to_xy(1,30), FWD)''' #square([10,40]); ]]
<span id="rechtecke-rectangles"></span>
== Rechtecke (Rectangles) ==
=== rect() ===
Die BOSL2-Bibliothek bietet eine Alternative zu <code>square()</code>, die mehr Funktionen unterstützt. Sie heißt <code>rect()</code>. Du kannst sie genauso verwenden wie <code>square()</code>, aber sie bietet auch erweiterte Funktionalität.
=== rect() mit rounding ===
[[Datei:BOSL2-rect rounding.png|mini|zentriert|alternativtext=rounding=10|rect([60,40], '''rounding=10''');]]
rect() erlaubt dir, die Ecken des Rechtecks abzurunden:
<pre class="openscad">include <BOSL2/std.scad>
rect([60,40], rounding=10);</pre>
=== rect() mit chamfer ===
[[Datei:BOSL2-rect chamfer.png|mini|zentriert|alternativtext=rect([60,40], chamfer=10);|rect([60,40], '''chamfer=10''');]]
Du kannst die Ecken des Rechtecks auch abfasen:
<pre class="openscad">include <BOSL2/std.scad>
rect([60,40], chamfer=10);</pre>
=== Unterschiedliche Abrundungen und Fasen an einem Rechteck ===
Du kannst sogar angeben, welche Ecken abgerundet oder abgefast werden. Wenn du eine Liste mit vier Größenwerten an die <code>rounding=</code>- oder <code>chamfer=</code>-Argumente übergibst, erhält jede Ecke ihre eigene Größe. Der Reihe nach geht es von der hinteren rechten Ecke (Quadrant I) gegen den Uhrzeigersinn zur hinteren linken Ecke (Quadrant II), zur vorderen linken Ecke (Quadrant III) und zur vorderen rechten Ecke (Quadrant IV):
Wenn eine Größe als <code>0</code> angegeben wird, gibt es keine Rundung und/oder Fase für die Ecke dieses Quadranten:
<pre class="openscad">include <BOSL2/std.scad>
rect([60,40], rounding=[0,5,10,15]);</pre>
<pre class="openscad">include <BOSL2/std.scad>
rect([60,40], chamfer=[0,5,10,15]);</pre>
Du kannst sowohl <code>rounding=</code>- als auch <code>chamfer=</code>-Argumente angeben, um Rundung und Fase zu mischen, aber nur, wenn du es pro Ecke angibst. Wenn du eine Rundung in einer Ecke möchtest, gib eine Fase von 0 für diese Ecke an und umgekehrt:
[[Datei:BOSL2-rect chamfer-rounding-mixed.png|mini|zentriert|alternativtext=ounding=[5,0,10,0], chamfer=[0,5,0,15]|rect([60,40], '''rounding=[5,0,10,0], chamfer=[0,5,0,15]''');]]
<pre class="openscad">include <BOSL2/std.scad>
rect([60,40], rounding=[5,0,10,0], chamfer=[0,5,0,15]);</pre>
<span id="ellipsen-ellipses"></span>
== Ellipsen (Ellipses) ==
Die BOSL2-Bibliothek bietet auch eine erweiterte Entsprechung von <code>circle()</code>, die <code>ellipse()</code> heißt. Du kannst sie genauso verwenden wie <code>circle()</code>, aber sie bietet auch erweiterte Funktionalität. Zum Beispiel erlaubt sie mehr Kontrolle über ihre Größe.
Da ein Kreis in OpenSCAD nur durch ein regelmäßiges Polygon mit einer Anzahl gerader Seiten angenähert werden kann, kann dies zu Ungenauigkeiten in Größe und Form führen. Um dem entgegenzuwirken, werden auch die Argumente <code>realign=</code> und <code>circum=</code> bereitgestellt.
=== realign= (ellipse-Argument) ===
Das <code>realign=</code>-Argument rotiert, wenn es auf <code>true</code> gesetzt wird, die <code>ellipse()</code> um den halben Winkel zwischen den Polygonseiten:
[[Datei:BOSL2-ellipse-realign.png|mini|zentriert|alternativtext=realign=true|#ellipse(d=100, $fn=8); color("lime") ellipse(d=100, $fn=8, '''realign=true''');]]
<pre class="openscad">
include <BOSL2/std.scad>
#ellipse(d=100, $fn=8);
color("lime") ellipse(d=100, $fn=8, realign=true);
</pre>
=== circum= (ellipse-Argument) ===
[[Datei:BOSL2-ellipse-circum.png|mini|zentriert|alternativtext=circum=true|Vergleich: rot (außen) mit circum=true und blau (innen) ohne circum. Referenz: idealer Kreis in gelb.]]
<pre class="openscad">
include <BOSL2/std.scad>
color("red") ellipse(d=100, $fn=6, circum=true);
color("yellow") ellipse(d=100, $fn=360);
color("blue") ellipse(d=100, $fn=6);
</pre>
Das <code>circum=</code>-Argument bewirkt, wenn es auf true gesetzt wird, dass das Polygon, das die <code>ellipse()</code> bildet, den idealen Kreis '''umschreibt''', anstatt ihn einzuschreiben.
Den idealen Kreis ''einschreiben'':
<pre class="openscad">include <BOSL2/std.scad>
color("green") ellipse(d=100, $fn=360);
ellipse(d=100, $fn=6);</pre>
Den idealen Kreis ''umschreiben'':
<pre class="openscad">include <BOSL2/std.scad>
ellipse(d=100, $fn=6, circum=true);
color("green") ellipse(d=100, $fn=360);</pre>
=== Ellipse mit 2 Radien ===
Das <code>ellipse()</code>-Modul kann, wie der Name schon sagt, mit separaten X- und Y-Radien oder -Durchmessern angegeben werden. Dazu gibst du einfach <code>r=</code> oder <code>d=</code> mit einer Liste von zwei Radien oder Durchmessern an:
[[Datei:BOSL2-ellipse-2Radien.png|mini|zentriert|alternativtext=2 Radien|ellipse('''r=[30,20]''');]]
==== r=[r1,r2] ====
<pre class="openscad">include <BOSL2/std.scad>
ellipse(r=[30,20]);</pre>
==== d=[d1,d2]====
<pre class="openscad">include <BOSL2/std.scad>
ellipse(d=[60,40]);</pre>
==== ellipse mit anchor ====
Wie bei <code>circle()</code> kannst du <code>ellipse()</code>-Formen verankern, drehen und anhängen:
[[Datei:BOSL2-ellipse-anchor.png|mini|zentriert|alternativtext=ellipse mit anchor|ellipse(d=[50,20], '''anchor=BACK'''); #ellipse(d=[50,20], '''anchor=FRONT''');]]
<pre class="openscad">
include <BOSL2/std.scad>
ellipse(d=[50,20], anchor=BACK);
#ellipse(d=[50,20], anchor=FRONT);
</pre>
==== ellipse mit attach ====
[[Datei:BOSL2-ellipse-attach.png|mini|zentriert|alternativtext=ellipse mit attach|ellipse(d=50) '''attach(BACK+RIGHT, FRONT+LEFT)''' #ellipse(d=[40,20]);]]
<pre class="openscad">
include <BOSL2/std.scad>
ellipse(d=50)
attach(BACK+RIGHT, FRONT+LEFT)
ellipse(d=30);
</pre>
<span id="rechtwinklige-dreiecke-right-triangles"></span>
==== ellipse mit spin ====
[[Datei:BOSL2-ellipse-attach-spin-anchor.png|mini|zentriert|alternativtext=spin = 90 bei ellipse|ellipse(d=50) attach(BACK) #ellipse(d=[40,20], '''spin=90''', anchor=LEFT);]]
<pre class="openscad">
include <BOSL2/std.scad>
ellipse(d=50)
attach(BACK)
#ellipse(d=[40,20], spin=90, anchor=LEFT);
</pre>
== Rechtwinklige Dreiecke (Right Triangles) ==
Die BOSL2-Bibliothek bietet eine einfache Möglichkeit, ein 2D-rechtwinkliges Dreieck mit dem <code>right_triangle()</code>-Modul zu erstellen:
[[Datei:BOSL2-right triangle.png|mini|zentriert|alternativtext=right_triangle([40,30])|right_triangle([40,30]);]]
<pre class="openscad">include <BOSL2/std.scad>
right_triangle([40,30]);</pre>
=== xflip() bei right_triangle ===
Du kannst <code>xflip()</code> und <code>yflip()</code> verwenden, um zu ändern, in welchem Quadranten das Dreieck gebildet wird:
[[Datei:BOSL2-right triangle xflip.png|mini|zentriert|alternativtext=right_triange mit xflip()|right_triangle([40,30]); '''xflip()''' #right_triangle([40,30]);]]
<pre class="openscad">include <BOSL2/std.scad>
xflip() right_triangle([40,30]);</pre>
=== yflip() bei right_triangle ===
[[Datei:BOSL2-right triangle yflip.png|mini|zentriert|alternativtext=right_triangle([40,30]) mit yflip()|right_triangle([40,30]); '''yflip()''' #right_triangle([40,30]);]]
<pre class="openscad">include <BOSL2/std.scad>
yflip() right_triangle([40,30]);</pre>
=== xflip() & yflip() bei right_triangle ===
[[Datei:BOSL2-right triangle xflip yflip.png|mini|zentriert|alternativtext=xflip() yflip()|right_triangle([40,30]); xflip() yflip() #right_triangle([40,30]);]]
<pre class="openscad">include <BOSL2/std.scad>
xflip() yflip() right_triangle([40,30]);</pre>
=== spin= bei right_triangle ===
Oder alternativ einfach mit <code>spin=</code> in den richtigen Quadranten drehen:
[[Datei:BOSL2-right triangle spin.png|mini|zentriert|alternativtext=right_triangle([40,30]) mit spin=90)|right_triangle([40,30]);
#right_triangle([40,30], '''spin=90''');]]
<pre class="openscad">include <BOSL2/std.scad>
right_triangle([40,30], spin=90);</pre>
<pre class="openscad">include <BOSL2/std.scad>
right_triangle([40,30], spin=-90);</pre>
Du kannst bei rechtwinkligen Dreiecken auch Verankerung verwenden:
<pre class="openscad">include <BOSL2/std.scad>
right_triangle([40,30], anchor=FWD+RIGHT);</pre>
<span id="trapeze-trapezoids"></span>
== Trapeze (Trapezoids) ==
OpenSCAD bietet keine einfache Möglichkeit, allgemeine 2D-Dreiecke, Trapeze oder Parallelogramme zu erstellen. Die BOSL2-Bibliothek kann all diese Formen mit dem <code>trapezoid()</code>-Modul bereitstellen.
=== Dreieck ===
Um ein gleichseitiges Dreieck zu erstellen, setze einfach eine der Breiten auf null:
[[Datei:BOSL2-trapezoid dreieck.png|mini|zentriert|alternativtext=Dreieck|trapezoid(w1=50, w2=0, h=40);<br>
Dreieck mit Seitenlänge = 50]]
<pre class="openscad">include <BOSL2/std.scad>
trapezoid(w1=50, w2=0, h=40);</pre>
Um ein rechtwinkliges Dreieck zu erstellen, musst du das <code>shift=</code>-Argument verwenden, um die Rückseite des Trapezes entlang der X-Achse zu verschieben:
[[Datei:BOSL2-trapezoid dreieck-rechtwinklig.png|mini|zentriert|alternativtext=Rechtwinkliges Dreieck|trapezoid(w1=50, w2=0, h=50, shift=-25);]]
<pre class="openscad">include <BOSL2/std.scad>
trapezoid(w1=50, w2=0, h=50, shift=-25);</pre>
<pre class="openscad">include <BOSL2/std.scad>
trapezoid(w1=50, w2=0, h=50, shift=25);</pre>
<pre class="openscad">include <BOSL2/std.scad>
trapezoid(w1=0, w2=50, h=50, shift=-25);</pre>
<pre class="openscad">include <BOSL2/std.scad>
trapezoid(w1=0, w2=50, h=50, shift=25);</pre>
=== Trapez ===
Du kannst ein Trapez erstellen, indem du für vorne (<code>w1=</code>) und hinten (<code>w2=</code>) von null verschiedene Breiten angibst:
[[Datei:BOSL2-trapezoid trapez.png|mini|zentriert|alternativtext=Trapez|trapezoid(w1=30, w2=50, h=50);]]
<pre class="openscad">include <BOSL2/std.scad>
trapezoid(w1=30, w2=50, h=50);</pre>
=== Parallelogramm ===
Ein Parallelogramm ist nur eine Frage der Verwendung der gleichen Breite für vorne und hinten, mit einer Verschiebung entlang der X-Achse:
[[Datei:BOSL2-trapezoid parallelogram.png|mini|zentriert|alternativtext=Parallelogramm|trapezoid(w1=50, w2=50, shift=20, h=50);]]
<pre class="openscad">include <BOSL2/std.scad>
trapezoid(w1=50, w2=50, shift=20, h=50);</pre>
=== Viereck ===
Ein Viereck kann erstellt werden, indem ungleiche, von null verschiedene Breiten für vorne (<code>w1=</code>) und hinten (<code>w2=</code>) verwendet werden, wobei die Rückseite entlang der X-Achse verschoben wird:
[[Datei:BOSL2-trapezoid viereck.png|mini|zentriert|alternativtext=Viereck|trapezoid(w1=50, w2=30, shift=20, h=50);]]
<pre class="openscad">include <BOSL2/std.scad>
trapezoid(w1=50, w2=30, shift=20, h=50);</pre>
Du kannst <code>anchor=</code> und <code>spin=</code> verwenden, genau wie bei anderen anhängbaren Formen. Die Ausrichtungen der Ankerpunkte basieren jedoch auf den Seitenwinkeln der Flächen und sind möglicherweise nicht das, was du erwartest:
<pre class="openscad">include <BOSL2/std.scad>
trapezoid(w1=30, w2=50, h=50)
show_anchors();</pre>
<span id="regelmäßige-n-ecke-regular-n-gons"></span>
== Regelmäßige n-Ecke (Regular N-Gons) ==
OpenSCAD ermöglicht es dir, regelmäßige n-Ecke (Fünfeck, Sechseck usw.) zu erstellen, indem du <code>circle()</code> mit <code>$fn</code> verwendest. Obwohl dies prägnant ist, mag es auf den ersten Blick weniger offensichtlich sein:
<pre class="openscad">include <BOSL2/std.scad>
circle(d=50, $fn=5);</pre>
Die BOSL2-Bibliothek hat Module, die für gängige n-Ecke klarer benannt sind:
=== Pentagon (d=<Durchmesser>) ===
[[Datei:BOSL2-Pentagon.png|mini|zentriert|alternativtext=Pentagon|pentagon(d=50);]]
<pre class="openscad">include <BOSL2/std.scad>
pentagon(d=50);</pre>
=== Hexagon (d=<Durchmesser>) ===
[[Datei:BOSL2-Hexagon.png|mini|zentriert|alternativtext=Hexagon| hexagon(d=50);]]
<pre class="openscad">include <BOSL2/std.scad>
hexagon(d=50);</pre>
=== Octagon (d= <Durchmesser>) ===
[[Datei:BOSL2-Octagon.png|mini|zentriert|alternativtext=octagon(d=50);|octagon(d=50);]]
<pre class="openscad">include <BOSL2/std.scad>
octagon(d=50);</pre>
=== regular_ngon (n=<Seitenanzahl>, d=<Durchmesser>) ===
[[Datei:BOSL2-regular ngon.png|mini|zentriert|alternativtext=regular_ngon|regular_ngon(n=7, d=50);]]
<pre class="openscad">include <BOSL2/std.scad>
regular_ngon(n=7, d=50);</pre>
=== side=<Seitenlänge> ===
Diese Module bieten dir auch zusätzliche Funktionalität. Sie können nach Seitenlänge dimensioniert werden:
[[Datei:BOSL2-Hexagon side50.png|mini|zentriert|alternativtext=hexagon(side=50);|hexagon(side=50);]]
<pre class="openscad">include <BOSL2/std.scad>
pentagon(side=50);</pre>
=== ir = <Innenradius> / id = <Innendurchmesser> ===
Sie können nach dem Radius/Durchmesser des umschriebenen Kreises (Innenkreis) dimensioniert werden:
[[Datei:BOSL2-Pentagon Innenradius.png|mini|zentriert|alternativtext=Innenradius|color("red") pentagon('''ir=25'''); color("yellow") circle(r=25,$fn=100);]]
<pre class="openscad">include <BOSL2/std.scad>
pentagon(ir=25);
pentagon(id=50);</pre>
=== realign=true/false ===
Die Polygone können um eine halbe Seite gedreht werden:
[[Datei:BOSL2-Pentagon realign.png|mini|zentriert|alternativtext=realign|pentagon(d=50, '''realign=false'''); #pentagon(d=50, '''realign=true''');]]
<pre class="openscad">include <BOSL2/std.scad>
left(30) pentagon(d=50, realign=true);
right(30) pentagon(d=50, realign=false);</pre>
=== rounding = <Rundung> ===
Die BOSL2-Polygone können abgerundet werden:
[[Datei:BOSL2-Polygon-rounding.png|mini|zentriert|alternativtext=rounding|pentagon(d=50, '''rounding=5''');]]
<pre class="openscad">include <BOSL2/std.scad>
pentagon(d=50, rounding=5);</pre>
=== show_anchors() ===
Die BOSL2-Polygone haben auch ein etwas anderes Anhangsverhalten als die regulären Polygone, die über $fn=<Seitenanzahl> erzeugt werden.
Ein Kreis mit einem kleinen <code>$fn=</code> hängt Dinge am idealen Kreis an, nicht entlang des erstellten Polygons:
[[Datei:BOSL2-polygon-outcircle-anchors.png|mini|zentriert|alternativtext=anchors Außenkreis|color("green") stroke(circle(d=50), closed=true); circle(d=50,$fn=6) show_anchors();]]
<pre class="openscad">include <BOSL2/std.scad>
color("green") stroke(circle(d=50), closed=true);
circle(d=50,$fn=6)
show_anchors();</pre>
Während ein BOSL2-n-Eck entlang des Polygons selbst (direkt) anhängt:
[[Datei:BOSL2-polygon-direct-anchors.png|mini|zentriert|alternativtext=anchors BOSL2 Polygone direkt|color("green") stroke(circle(d=50), closed=true); circle(d=50,$fn=6) show_anchors();]]
<pre class="openscad">include <BOSL2/std.scad>
hexagon(d=50)
show_anchors(custom=false);</pre>
Du kannst <code>anchor=</code> und <code>spin=</code> verwenden, genau wie bei anderen anhängbaren Formen. Die Ankerpunkte basieren jedoch darauf, wo der Ankervektor die Seite des n-Ecks schneiden würde, und sind möglicherweise nicht dort, wo du sie erwartest:
[[Datei:BOSL2-Pentagon-anchor.png|mini|zentriert|alternativtext=n-Polygon anchor|pentagon(d=50, '''anchor=FRONT+LEFT''') show_anchors(custom=false);]]
<pre class="openscad">include <BOSL2/std.scad>
pentagon(d=50, anchor=FRONT+LEFT)
show_anchors(custom=false);</pre>
=== Ankerpunkte für Seiten und Spitzen ===
n-Ecke haben auch benannte Ankerpunkte für ihre Seiten und Spitzen:
[[Datei:BOSL2-anchor-Spitzen-Seiten.png|mini|zentriert|alternativtext=Anker für Seiten und Spitzen|Spezielle Anker für die Spitzen und Seiten eines Pentagons (mit TikZ unter LaTeX erstellt)]]
Beachte, dass die Ankernamen in "" gesetzt werden müssen.
Zum Beispiel:
[[Datei:BOSL2-Pentagon anchor tip1.png|mini|zentriert|alternativtext=anchor="tip1"|pentagon(d=30, '''anchor="tip1" ''');]]
<pre class="openscad">include <BOSL2/std.scad>
pentagon(d=30, anchor="tip1");</pre>
<span id="sterne-stars"></span>
Beispiel mit attach():
[[Datei:BOSL2-anchor-Spitzen-Seiten attach.png|mini|zentriert|alternativtext=anchor="side2"|pentagon(d=30, anchor="side2") '''attach("tip0")''' circle(r=3,$fn=36);]]
<pre class="openscad">
include <BOSL2/std.scad>
pentagon(d=30, anchor="side2") attach("tip0") circle(r=3,$fn=36);
</pre>
== Sterne (Stars) ==
=== star() mit n, ir/id und or/od ===
Die BOSL2-Bibliothek hat Sterne als grundlegend unterstützte Form. Sie können eine beliebige Anzahl '''n''' von '''Spitzen''' haben. Du kannst die Form eines Sterns durch Spitzenanzahl, '''innere und äußere Scheitelpunkt-Radius/-Durchmesser''' angeben:
[[Datei:BOSL2-star n5 ir15 dr30-Veranschaulichung.png|mini|zentriert|alternativtext=Innerer und äußerer Radius bei star()|Veranschaulichung von den Parameter '''ir''' (oder id) und '''or''' (oder od). ''ir'' gibt den inneren Radius und or den äußeren Radius an. Die Anzahl der Zacken ist hier n=5. Siehe Code unten.]]
Begonnen wird der Stern mit einem Zacken nach rechts auf der X-Achse.
<pre class="openscad">
include <BOSL2/std.scad>
#circle(30, $fn=60);
color("blue") star(n=5, ir=15, or=30);
#circle(15, $fn=60);
color("darkblue") fwd(35) text("or=30", halign = "center", size=3);
color("yellow") text("ir=15",halign = "center", size=3, valign="center");
</pre>
=== star() mit Spannweite d ===
Statt '''od''' kann auch einfach '''d''' als Parameter verwendet werden.
[[Datei:BOSL2-star n3 id10 d50.png|mini|zentriert|alternativtext=star(n=3, id=10, d=50);|star(n=3, id=10, d=50);]]
<pre class="openscad">include <BOSL2/std.scad>
star(n=3, id=10, d=50);</pre>
[[Datei:BOSL2-star n5 id15 r25.png|mini|zentriert|alternativtext=star(n=5, id=15, r=25);|star(n=5, id=15, r=25);]]
<pre class="openscad">include <BOSL2/std.scad>
star(n=5, id=15, r=25);</pre>
[[Datei:BOSL2-star n10 id30 d50.png|mini|zentriert|alternativtext=star(n=10, id=30, d=50);|star(n=10, id=30, d=50);]]
<pre class="openscad">include <BOSL2/std.scad>
star(n=10, id=30, d=50);</pre>
=== star (n = <Spitzenanzahl>, step = <Anzahl zu überspringender Punkte>) ===
Oder du kannst die Sternform durch Spitzenanzahl '''n''' und Anzahl '''step''' der zu überspringenden Punkte angeben:
[[Datei:BOSL2-star n7 step2 d50.png|mini|zentriert|alternativtext=step|star(n=7, step=2, d=50);]]
<pre class="openscad">include <BOSL2/std.scad>
star(n=7, step=2, d=50);</pre>
[[Datei:BOSL2-star n7 step3 d50.png|mini|zentriert|alternativtext=step=3|star(n=7, step=3, d=50);]]
<pre class="openscad">include <BOSL2/std.scad>
star(n=7, step=3, d=50);</pre>
=== star() mit realign ===
Wenn dem <code>realign=</code>-Argument ein true-Wert übergeben wird, wird der Stern um einen halben Spitzenwinkel gedreht:
<pre class="openscad">include <BOSL2/std.scad>
left(30) star(n=5, step=2, d=50);
right(30) star(n=5, step=2, d=50, realign=true);</pre>
=== star() mit align_tip=<Anker> ===
Das <code>align_tip=</code>-Argument kann mit einem Vektor angegeben werden, damit du die erste Spitze in eine bestimmte Richtung ausrichten kannst:
[[Datei:BOSL2-star n5 align tip anchor tip0.png|mini|zentriert|alternativtext=align_tip=BACK|star(n=5, ir=15, or=30, align_tip=BACK) attach("tip0") color("blue") anchor_arrow2d();]]
<pre class="openscad">include <BOSL2/std.scad>
star(n=5, ir=15, or=30, align_tip=BACK)
attach("tip0") color("blue") anchor_arrow2d();</pre>
=== star() mit align_pit=<Anker> ===
Ebenso kann die erste Einkerbung oder Einbuchtung mit <code>align_pit=</code> in Richtung eines bestimmten Vektors ausgerichtet werden:
<pre class="openscad">include <BOSL2/std.scad>
star(n=5, ir=15, or=30, align_pit=BACK)
attach("pit0") color("blue") anchor_arrow2d();</pre>
<pre class="openscad">include <BOSL2/std.scad>
star(n=5, ir=15, or=30, align_pit=BACK+RIGHT)
attach("pit0") color("blue") anchor_arrow2d();</pre>
Du kannst <code>anchor=</code> und <code>spin=</code> verwenden, genau wie bei anderen anhängbaren Formen. Die Ankerpunkte basieren jedoch auf den äußersten Ausmaßen der Form und sind möglicherweise nicht dort, wo du sie erwartest:
<pre class="openscad">include <BOSL2/std.scad>
star(n=5, step=2, d=50)
show_anchors(custom=false);</pre>
=== Benannte Ankerpunkte bei star() ===
Sterne haben auch benannte Ankerpunkte für ihre Gruben, Spitzen und Mittelpunkte zwischen den Spitzen:
[[Datei:BOSL2-star n5 benannteAnker.png|mini|zentriert|alternativtext=benannten Ankerpunkte in star()|Zuordnung der benannten Ankerpunkte in star(). Spitzen beginnen mit "tipt0", Einkerbungen mit pit0.]]
==== Beispiel 1: anchor="tip0" attach("pit0") ====
[[Datei:BOSL2-star-n5 ir=15 or30 anchor tip0 pit0.png|mini|zentriert|alternativtext=anchor="tip0"|star(n=5, ir=15, or=30, anchor="tip0") attach("pit0") #circle(3);]]
<pre class="openscad">
include <BOSL2/std.scad>
star(n=5, ir=15, or=30, anchor="tip0") attach("pit0") #circle(3);
</pre>
==== Beispiel 2: anchor="pit0" attach("tip0") ====
[[Datei:BOSL2-star n5 anchor pit0 attach tip0.png|mini|zentriert|alternativtext=anchor="pit0" attach("tip0")|star(n=5, ir=15, or=30, anchor="pit0") attach("tip0") #circle(3);]]
<pre class="openscad">
include <BOSL2/std.scad>
star(n=5, ir=15, or=30, anchor="pit0") attach("tip0") #circle(3);
</pre>
<span id="tropfenform-2d-teardrop2d"></span>
== Tropfenform 2D (Teardrop2D) ==
Beim 3D-Druck möchtest du oft ein kreisförmiges Loch in eine vertikale Wand machen. Wenn das Loch jedoch zu groß ist, kann der Überhang an der Oberseite des Lochs Probleme beim Drucken auf einem FDM/FFF-Drucker verursachen. Wenn du kein Stützmaterial verwenden möchtest, kannst du einfach die Tropfenform verwenden. Das <code>teardrop2d()</code>-Modul ermöglicht es dir, eine 2D-Version der Tropfenform zu erstellen, damit du sie später extrudieren kannst:
<pre class="openscad">include <BOSL2/std.scad>
teardrop2d(r=20);</pre>
<pre class="openscad">include <BOSL2/std.scad>
teardrop2d(d=50);</pre>
Der Standard-Überhangwinkel beträgt 45 Grad, aber du kannst ihn mit dem <code>ang=</code>-Argument anpassen:
<pre class="openscad">include <BOSL2/std.scad>
teardrop2d(d=50, ang=30);</pre>
Wenn du es vorziehst, die Oberseite des Tropfens abzuflachen, um das Bridging zu fördern, kannst du das <code>cap_h=</code>-Argument verwenden:
<pre class="openscad">include <BOSL2/std.scad>
teardrop2d(d=50, cap_h=25);</pre>
<pre class="openscad">include <BOSL2/std.scad>
teardrop2d(d=50, ang=30, cap_h=30);</pre>
Du kannst <code>anchor=</code> und <code>spin=</code> verwenden, genau wie bei anderen anhängbaren Formen. Die Ankerpunkte basieren jedoch auf den äußersten Ausmaßen der Form und sind möglicherweise nicht dort, wo du sie erwartest:
<pre class="openscad">include <BOSL2/std.scad>
teardrop2d(d=50, ang=30, cap_h=30)
show_anchors();</pre>
<span id="verklebte-kreise-glued-circles"></span>
== Verklebte Kreise (Glued Circles) ==
Eine ungewöhnlichere Form, die BOSL2 bietet, sind verklebte Kreise (Glued Circles). Es handelt sich im Grunde um ein Paar von Kreisen, die durch etwas verbunden sind, das wie ein klebriger Meniskus aussieht:
<pre class="openscad">include <BOSL2/std.scad>
glued_circles(d=30, spread=40);</pre>
Die <code>r=</code>/<code>d=</code>-Argumente können den Radius oder Durchmesser der beiden Kreise angeben:
<pre class="openscad">include <BOSL2/std.scad>
glued_circles(r=20, spread=45);</pre>
<pre class="openscad">include <BOSL2/std.scad>
glued_circles(d=40, spread=45);</pre>
Das <code>spread=</code>-Argument gibt den Abstand zwischen den Mittelpunkten der beiden Kreise an:
<pre class="openscad">include <BOSL2/std.scad>
glued_circles(d=30, spread=30);</pre>
<pre class="openscad">include <BOSL2/std.scad>
glued_circles(d=30, spread=40);</pre>
Das <code>tangent=</code>-Argument gibt den Winkel der Tangente des Meniskus an den beiden Kreisen an:
<pre class="openscad">include <BOSL2/std.scad>
glued_circles(d=30, spread=30, tangent=45);</pre>
<pre class="openscad">include <BOSL2/std.scad>
glued_circles(d=30, spread=30, tangent=20);</pre>
<pre class="openscad">include <BOSL2/std.scad>
glued_circles(d=30, spread=30, tangent=-20);</pre>
Eine nützliche Sache, die du tun kannst, ist, einige <code>glued_circle()</code>s in einer Linie anzuordnen und sie dann zu extrudieren, um eine gerippte Wand zu erstellen:
<pre class="openscad">include <BOSL2/std.scad>
$fn=36; s=10;
linear_extrude(height=50,convexity=16,center=true)
xcopies(s*sqrt(2),n=3)
glued_circles(d=s, spread=s*sqrt(2), tangent=45);</pre>
Du kannst <code>anchor=</code> und <code>spin=</code> verwenden, genau wie bei anderen anhängbaren Formen. Die Ankerpunkte basieren jedoch auf den äußersten Ausmaßen der Form und sind möglicherweise nicht dort, wo du sie erwartest:
<pre class="openscad">include <BOSL2/std.scad>
glued_circles(d=40, spread=40, tangent=45)
show_anchors();</pre>
5p51sms7xh5twl56h9fnrtdw3mkbi4v
1093531
1093530
2026-11-08T15:49:13Z
Jowi-ammerbuch
115360
/* star() mit align_pit= */
1093531
wikitext
text/x-wiki
{{MyNavi
|zurück = [[OpenSCAD Benutzerhandbuch/_BOSL2-Distributoren|Zurück]]
|buch = [[OpenSCAD Benutzerhandbuch/_BOSL2|BOSL2-Inhalt]]
|weiter = [[OpenSCAD Benutzerhandbuch/_BOSL2-3D|Weiter]]
}}
== 2D Grundformen (2D Primitive) ==
OpenSCAD bietet zwei eingebaute 2D-Grundformen: <code>square()</code> und <code>circle()</code>. Du kannst sie weiterhin auf die gewohnte Weise verwenden:
<pre class="openscad">include <BOSL2/std.scad>
square([60,40], center=true);</pre>
<pre class="openscad">include <BOSL2/std.scad>
circle(r=50);</pre>
<pre class="openscad">include <BOSL2/std.scad>
circle(d=100, $fn=8);</pre>
Diese Module wurden in der BOSL2-Bibliothek in drei Bereichen erweitert: Verankerung (Anchoring), Drehung (Spin) und Anhängbarkeit (Attachability).
<span id="verankerung-anchoring"></span>
=== Verankerung (Anchoring): ===
Wenn du ein <code>square()</code> erstellst, kannst du angeben, welche Ecke oder Seite am Ursprung verankert werden soll. Dies ersetzt das <code>center=</code>-Argument und ist flexibler. Das <code>anchor=</code>-Argument nimmt einen Vektor als Wert entgegen, der in grober Richtung der Seite oder Ecke zeigt, die du am Ursprung ausrichten möchtest.
=== anchor=[0,1] oder anchor=BACK ===
[[Datei:BOSL2-anchor-0-1.png|mini|zentriert|alternativtext=anchor=[0,1]);|square([60,40], '''anchor=[0,1]''');<br>
Oder: square([60,40], '''anchor=BACK''');]]
Um beispielsweise das '''Zentrum der hinteren Kante am Ursprung''' auszurichten, setzt du den Anker auf <code>[0,1]</code>:
<pre class="openscad">
include <BOSL2/std.scad>
square([60,40], anchor=[0,1]);
</pre>
Mit den leichter verständlichen vordefinierten '''Vektor-Konstanten''':
<pre class="openscad">
include <BOSL2/std.scad>
square([60,40], anchor=BACK+CENTER);
</pre>
=== anchor=[1,-1] oder anchor=RIGHT+FRONT ===
Um die '''vordere rechte Ecke am Ursprung''' auszurichten:
[[Datei:BOSL2-anchor-1 -1.png|mini|zentriert|alternativtext=anchor=RIGHT+FRONT);|square([60,40], '''anchor=[1,-1]''');<br>
Oder: square([60,40], '''anchor=RIGHT+FRONT''');]]
<pre class="openscad">
include <BOSL2/std.scad>
square([60,40], anchor=[1,-1]);
</pre>
'''Mit Vektor-Konstanten:'''
<pre class="openscad">
include <BOSL2/std.scad>
square([60,40], anchor=RIGHT+FRONT);
</pre>
=== anchor=[0,0] oder anchor=CENTER '''Fetter Text'''===
Um es zu '''zentrieren''':
<pre class="openscad">
include <BOSL2/std.scad>
square([60,40], anchor=[0,0]);
</pre>
'''Mit Vektor-Konstanten:'''
<pre class="openscad">
include <BOSL2/std.scad>
square([60,40], anchor=CENTER);
</pre>
=== Vektor-Konstanten am Rechteck ===
Um die Angabe von Vektoren übersichtlicher zu gestalten, sind mehrere Standard-Vektorkonstanten definiert:
[[Datei:BOSL2-anchor-Konstanten-Rechteck.png|gerahmt|zentriert|alternativtext=BOSL2 vordefinierte anchor-Konstanten|Die in BOSL2 vordefinierten anchor-Konstanten]]
{| class="wikitable"
|-
! Konstante
! Richtung
! Wert
|-
| LEFT
| X-
| [-1, 0, 0]
|-
| RIGHT
| X+
| [ 1, 0, 0]
|-
| FRONT / FORWARD / FWD
| Y-
| [ 0,-1, 0]
|-
| BACK
| Y+
| [ 0, 1, 0]
|-
| BOTTOM / BOT / BTM / DOWN
| Z-
| [ 0, 0,-1] (nur 3D)
|-
| TOP / UP
| Z+
| [ 0, 0, 1] (nur 3D)
|-
| CENTER / CTR
| Zentriert
| [ 0, 0, 0]
|}
Beachte, dass du die meisten dieser Konstanten (außer <code>UP</code>/<code>DOWN</code> natürlich) auch für Anker bei 2D-Formen verwenden kannst, obwohl es sich um 3D-Vektoren handelt:
<pre class="openscad">include <BOSL2/std.scad>
square([60,40], anchor=BACK);</pre>
<pre class="openscad">include <BOSL2/std.scad>
square([60,40], anchor=CENTER);</pre>
Du kannst Vektoren addieren, um auf Ecken zu zeigen:
<pre class="openscad">include <BOSL2/std.scad>
square([60,40], anchor=FRONT+RIGHT);</pre>
=== anchor = polar_to_xy ===
Für <code>circle()</code> kann der Ankervektor auf jeden beliebigen '''Punkt des Kreisumfangs''' zeigen:
[[Datei:BOSL2-anchor-polar to xy-circle.png|gerahmt|zentriert|alternativtext=anchor = polar_to_xy|anchor = polar_to_xy(1,Alpha), für Alpha = 0, 45, 90, ...]]
==== Beispiel: anchor=polar_to_xy(1,45) =====
[[Datei:BOSL2-anchor-polar to 1-45-octagon.png|mini|zentriert|alternativtext=circle(d=50, anchor=polar_to_xy(1,45), $fn = 8);|circle(d=50, anchor=polar_to_xy(1,45), $fn = 8);]]
<pre class="openscad">
include <BOSL2/std.scad>
circle(d=50, anchor=polar_to_xy(1,45), $fn = 8);
</pre>
Beachte, dass der Radius für den Anker keine Rolle spielt, da nur die Richtung des Ankers das Ergebnis beeinflusst.
=== show_anchors() ===
[[Datei:BOSL2-show anchor.png|mini|zentriert|show_anchors]]
Du kannst die typischen Ankerpunkte sehen, indem du <code>show_anchors()</code> als Kind der Form übergibst:
<pre class="openscad">include <BOSL2/std.scad>
square([60,40], center=true)
show_anchors();</pre>
<pre class="openscad">include <BOSL2/std.scad>
circle(d=50)
show_anchors();</pre>
<span id="drehung-spin"></span>
=== Drehung (Spin): ===
Die zweite Erweiterung von <code>square()</code> und <code>circle()</code> ist die Drehung (Spin). Wenn du die Form erstellst, kannst du sie mit dem <code>spin=</code>-Argument an Ort und Stelle drehen. Du übergibst einfach die Anzahl der Grad, um die sie im Uhrzeigersinn gedreht werden soll:
<pre class="openscad">include <BOSL2/std.scad>
square([60,40], anchor=CENTER, spin=30);</pre>
Die Verankerung oder Zentrierung erfolgt vor der Drehung:
<pre class="openscad">include <BOSL2/std.scad>
square([60,40], anchor=BACK, spin=30);</pre>
Bei Kreisen kann Spin nützlich sein, wenn auch <code>$fn=</code> angegeben wird:
<pre class="openscad">include <BOSL2/std.scad>
circle(d=50, $fn=6, spin=15);</pre>
Da die Verankerung vor der Drehung erfolgt, kannst du beides zusammen verwenden, um um den Anker herum zu drehen:
<pre class="openscad">include <BOSL2/std.scad>
circle(d=50, $fn=6, anchor=LEFT, spin=15);</pre>
<span id="anhängbarkeit-attachability"></span>
=== Anhängbarkeit (Attachability): ===
Die dritte Erweiterung von <code>square()</code> und <code>circle()</code> ist, dass du sie auf verschiedene Weise an Ankerpunkten zusammenhängen kannst. Dies geschieht, indem du eine Form zum Kind der Form machst, an die du sie anhängen möchtest.
==== Standard (ohne Spez. für anchor oder position) ====
Standardmäßig wird das Kind beim einfachen Untereinanderstellen im Zentrum der Elternform angehängt.
[[Datei:BOSL2-attach-standard-normal.png|mini|zentriert|alternativtext=square(50) #square(50);|square(50) #square(50);<br>
Kind-Objekt (rot) wird ans Zentrum des Elternobjekts angehängt]]
<pre class="openscad">
include <BOSL2/std.scad>
square(50) #square(50);
</pre>
==== anchor für child spezifiziert ====
[[Datei:BOSL2-attach-anchor-LEFTplusFWD.png|mini|zentriert|alternativtext=square(50, center=true) #square([20,40], anchor=LEFT+FWD);|square(50, center=true)#square([20,40], '''anchor=LEFT+FWD''');]]
<pre class="openscad">include <BOSL2/std.scad>
square(50, center=true)
#square([20,40], anchor=LEFT+FWD);</pre>
==== position() ====
[[Datei:BOSL2-attach-position.png|mini|zentriert|alternativtext=position(RIGHT)|square(50) '''position(RIGHT)''' #square(25) '''position(BACK)''' #square(25);]]
Durch Hinzufügen des <code>position()</code>-Moduls kannst du das Kind an jedem Ankerpunkt '''des Elternteils''' positionieren, das "Kindes-Kind wird am Ankerpunkt des übergeordneten Objekts positioniert:
<pre class="openscad">
include <BOSL2/std.scad>
square(50) position(RIGHT) #square(25)
position(BACK) #square(25);
</pre>
==== orient() ====
Ankerpunkte sind jedoch nicht nur Positionen auf dem Elternteil. Sie haben auch eine Ausrichtung. In den meisten Fällen zeigt die Ausrichtung eines Ankerpunkts nach außen, weg von der Fläche der Wand, also im Allgemeinen vom Zentrum der Form weg.
[[Datei:BOSL2-show anchor.png|mini|zentriert|show_anchors]]
Wenn du das Kind so ausrichten möchtest, dass es der Ausrichtung eines Ankerpunkts entspricht, kannst du das <code>orient()</code>-Modul verwenden. Es positioniert das Kind nicht, es dreht es nur:
[[Datei:BOSL2-attach-orient anchor.png|mini|zentriert|alternativtext= orient(anchor=LEFT+BOTTOM)|square(50) '''orient(anchor=LEFT+BOTTOM)''' #square([10,40]);]]
<pre class="openscad">include <BOSL2/std.scad>
square(50)
orient(anchor=LEFT+BOTTOM) #square([10,40]);</pre>
Das geht auch beim '''Kreis (circle)''' mit '''polar_to_xy''':
[[Datei:BOSL2-attach-orient polar to xy circle.png|mini|zentriert|alternativtext=orient(polar_to_xy(1,30))|circle(d=50) ''' orient(polar_to_xy(1,30))''' #square([10,40], anchor=FWD);]]
<pre class="openscad">include <BOSL2/std.scad>
circle(d=50)
orient(polar_to_xy(1,30))
#square([10,40], anchor=FWD);</pre>
==== position() + orient() ====
Du kannst <code>position()</code> und <code>orient()</code> zusammen verwenden, um sowohl zu positionieren als auch an einem Ankerpunkt auszurichten:
[[Datei:BOSL2-attach-position pluss orient polar to xy circle.png|mini|zentriert|alternativtext=position(polar_to_xy(1,30)) orient(polar_to_xy(1,30))|circle(d=50) '''position(polar_to_xy(1,30)) orient(polar_to_xy(1,30))''' #square([10,40], anchor=FWD);]]
<pre class="openscad">include <BOSL2/std.scad>
circle(d=50)
position(polar_to_xy(1,30))
orient(polar_to_xy(1,30))
#square([10,40], anchor=FWD);</pre>
=== attach () mit einem Argument ===
Aber es ist einfacher das <code>attach()</code>-Modul zu verwenden, um beides auf einmal zu erledigen:
[[Datei:BOSL2-attach-position pluss orient polar to xy circle.png|mini|zentriert|alternativtext=attach(polar_to_xy(1,30))|circle(d=50) '''attach(polar_to_xy(1,30))''' #square([10,40], anchor=FWD); ]]
Gleiches Ergebnis, aber übersichtlicherer Code.
<pre class="openscad">include <BOSL2/std.scad>
square(50, center=true)
attach(LEFT+BACK)
#square([10,40], anchor=FWD);</pre>
=== attach () mit zwei Argumenten ===
Anstatt den <code>anchor=</code> im Kind anzugeben, kannst du ein '''zweites Argument''' an <code>attach()</code> übergeben, das ihm sagt, welche Seite des Kindes mit dem Elternteil verbunden werden soll:
<pre class="openscad">
include <BOSL2/std.scad>
circle(d=50) attach(polar_to_xy(1,30), FWD) #square([10,40]);
</pre>
Damit lässt sich der Code noch mehr straffen.
[[Datei:BOSL2-attach-position pluss orient polar to xy circle.png|mini|zentriert|alternativtext=attach(polar_to_xy(1,30), FWD)|circle(d=50) '''attach(polar_to_xy(1,30), FWD)''' #square([10,40]); ]]
<span id="rechtecke-rectangles"></span>
== Rechtecke (Rectangles) ==
=== rect() ===
Die BOSL2-Bibliothek bietet eine Alternative zu <code>square()</code>, die mehr Funktionen unterstützt. Sie heißt <code>rect()</code>. Du kannst sie genauso verwenden wie <code>square()</code>, aber sie bietet auch erweiterte Funktionalität.
=== rect() mit rounding ===
[[Datei:BOSL2-rect rounding.png|mini|zentriert|alternativtext=rounding=10|rect([60,40], '''rounding=10''');]]
rect() erlaubt dir, die Ecken des Rechtecks abzurunden:
<pre class="openscad">include <BOSL2/std.scad>
rect([60,40], rounding=10);</pre>
=== rect() mit chamfer ===
[[Datei:BOSL2-rect chamfer.png|mini|zentriert|alternativtext=rect([60,40], chamfer=10);|rect([60,40], '''chamfer=10''');]]
Du kannst die Ecken des Rechtecks auch abfasen:
<pre class="openscad">include <BOSL2/std.scad>
rect([60,40], chamfer=10);</pre>
=== Unterschiedliche Abrundungen und Fasen an einem Rechteck ===
Du kannst sogar angeben, welche Ecken abgerundet oder abgefast werden. Wenn du eine Liste mit vier Größenwerten an die <code>rounding=</code>- oder <code>chamfer=</code>-Argumente übergibst, erhält jede Ecke ihre eigene Größe. Der Reihe nach geht es von der hinteren rechten Ecke (Quadrant I) gegen den Uhrzeigersinn zur hinteren linken Ecke (Quadrant II), zur vorderen linken Ecke (Quadrant III) und zur vorderen rechten Ecke (Quadrant IV):
Wenn eine Größe als <code>0</code> angegeben wird, gibt es keine Rundung und/oder Fase für die Ecke dieses Quadranten:
<pre class="openscad">include <BOSL2/std.scad>
rect([60,40], rounding=[0,5,10,15]);</pre>
<pre class="openscad">include <BOSL2/std.scad>
rect([60,40], chamfer=[0,5,10,15]);</pre>
Du kannst sowohl <code>rounding=</code>- als auch <code>chamfer=</code>-Argumente angeben, um Rundung und Fase zu mischen, aber nur, wenn du es pro Ecke angibst. Wenn du eine Rundung in einer Ecke möchtest, gib eine Fase von 0 für diese Ecke an und umgekehrt:
[[Datei:BOSL2-rect chamfer-rounding-mixed.png|mini|zentriert|alternativtext=ounding=[5,0,10,0], chamfer=[0,5,0,15]|rect([60,40], '''rounding=[5,0,10,0], chamfer=[0,5,0,15]''');]]
<pre class="openscad">include <BOSL2/std.scad>
rect([60,40], rounding=[5,0,10,0], chamfer=[0,5,0,15]);</pre>
<span id="ellipsen-ellipses"></span>
== Ellipsen (Ellipses) ==
Die BOSL2-Bibliothek bietet auch eine erweiterte Entsprechung von <code>circle()</code>, die <code>ellipse()</code> heißt. Du kannst sie genauso verwenden wie <code>circle()</code>, aber sie bietet auch erweiterte Funktionalität. Zum Beispiel erlaubt sie mehr Kontrolle über ihre Größe.
Da ein Kreis in OpenSCAD nur durch ein regelmäßiges Polygon mit einer Anzahl gerader Seiten angenähert werden kann, kann dies zu Ungenauigkeiten in Größe und Form führen. Um dem entgegenzuwirken, werden auch die Argumente <code>realign=</code> und <code>circum=</code> bereitgestellt.
=== realign= (ellipse-Argument) ===
Das <code>realign=</code>-Argument rotiert, wenn es auf <code>true</code> gesetzt wird, die <code>ellipse()</code> um den halben Winkel zwischen den Polygonseiten:
[[Datei:BOSL2-ellipse-realign.png|mini|zentriert|alternativtext=realign=true|#ellipse(d=100, $fn=8); color("lime") ellipse(d=100, $fn=8, '''realign=true''');]]
<pre class="openscad">
include <BOSL2/std.scad>
#ellipse(d=100, $fn=8);
color("lime") ellipse(d=100, $fn=8, realign=true);
</pre>
=== circum= (ellipse-Argument) ===
[[Datei:BOSL2-ellipse-circum.png|mini|zentriert|alternativtext=circum=true|Vergleich: rot (außen) mit circum=true und blau (innen) ohne circum. Referenz: idealer Kreis in gelb.]]
<pre class="openscad">
include <BOSL2/std.scad>
color("red") ellipse(d=100, $fn=6, circum=true);
color("yellow") ellipse(d=100, $fn=360);
color("blue") ellipse(d=100, $fn=6);
</pre>
Das <code>circum=</code>-Argument bewirkt, wenn es auf true gesetzt wird, dass das Polygon, das die <code>ellipse()</code> bildet, den idealen Kreis '''umschreibt''', anstatt ihn einzuschreiben.
Den idealen Kreis ''einschreiben'':
<pre class="openscad">include <BOSL2/std.scad>
color("green") ellipse(d=100, $fn=360);
ellipse(d=100, $fn=6);</pre>
Den idealen Kreis ''umschreiben'':
<pre class="openscad">include <BOSL2/std.scad>
ellipse(d=100, $fn=6, circum=true);
color("green") ellipse(d=100, $fn=360);</pre>
=== Ellipse mit 2 Radien ===
Das <code>ellipse()</code>-Modul kann, wie der Name schon sagt, mit separaten X- und Y-Radien oder -Durchmessern angegeben werden. Dazu gibst du einfach <code>r=</code> oder <code>d=</code> mit einer Liste von zwei Radien oder Durchmessern an:
[[Datei:BOSL2-ellipse-2Radien.png|mini|zentriert|alternativtext=2 Radien|ellipse('''r=[30,20]''');]]
==== r=[r1,r2] ====
<pre class="openscad">include <BOSL2/std.scad>
ellipse(r=[30,20]);</pre>
==== d=[d1,d2]====
<pre class="openscad">include <BOSL2/std.scad>
ellipse(d=[60,40]);</pre>
==== ellipse mit anchor ====
Wie bei <code>circle()</code> kannst du <code>ellipse()</code>-Formen verankern, drehen und anhängen:
[[Datei:BOSL2-ellipse-anchor.png|mini|zentriert|alternativtext=ellipse mit anchor|ellipse(d=[50,20], '''anchor=BACK'''); #ellipse(d=[50,20], '''anchor=FRONT''');]]
<pre class="openscad">
include <BOSL2/std.scad>
ellipse(d=[50,20], anchor=BACK);
#ellipse(d=[50,20], anchor=FRONT);
</pre>
==== ellipse mit attach ====
[[Datei:BOSL2-ellipse-attach.png|mini|zentriert|alternativtext=ellipse mit attach|ellipse(d=50) '''attach(BACK+RIGHT, FRONT+LEFT)''' #ellipse(d=[40,20]);]]
<pre class="openscad">
include <BOSL2/std.scad>
ellipse(d=50)
attach(BACK+RIGHT, FRONT+LEFT)
ellipse(d=30);
</pre>
<span id="rechtwinklige-dreiecke-right-triangles"></span>
==== ellipse mit spin ====
[[Datei:BOSL2-ellipse-attach-spin-anchor.png|mini|zentriert|alternativtext=spin = 90 bei ellipse|ellipse(d=50) attach(BACK) #ellipse(d=[40,20], '''spin=90''', anchor=LEFT);]]
<pre class="openscad">
include <BOSL2/std.scad>
ellipse(d=50)
attach(BACK)
#ellipse(d=[40,20], spin=90, anchor=LEFT);
</pre>
== Rechtwinklige Dreiecke (Right Triangles) ==
Die BOSL2-Bibliothek bietet eine einfache Möglichkeit, ein 2D-rechtwinkliges Dreieck mit dem <code>right_triangle()</code>-Modul zu erstellen:
[[Datei:BOSL2-right triangle.png|mini|zentriert|alternativtext=right_triangle([40,30])|right_triangle([40,30]);]]
<pre class="openscad">include <BOSL2/std.scad>
right_triangle([40,30]);</pre>
=== xflip() bei right_triangle ===
Du kannst <code>xflip()</code> und <code>yflip()</code> verwenden, um zu ändern, in welchem Quadranten das Dreieck gebildet wird:
[[Datei:BOSL2-right triangle xflip.png|mini|zentriert|alternativtext=right_triange mit xflip()|right_triangle([40,30]); '''xflip()''' #right_triangle([40,30]);]]
<pre class="openscad">include <BOSL2/std.scad>
xflip() right_triangle([40,30]);</pre>
=== yflip() bei right_triangle ===
[[Datei:BOSL2-right triangle yflip.png|mini|zentriert|alternativtext=right_triangle([40,30]) mit yflip()|right_triangle([40,30]); '''yflip()''' #right_triangle([40,30]);]]
<pre class="openscad">include <BOSL2/std.scad>
yflip() right_triangle([40,30]);</pre>
=== xflip() & yflip() bei right_triangle ===
[[Datei:BOSL2-right triangle xflip yflip.png|mini|zentriert|alternativtext=xflip() yflip()|right_triangle([40,30]); xflip() yflip() #right_triangle([40,30]);]]
<pre class="openscad">include <BOSL2/std.scad>
xflip() yflip() right_triangle([40,30]);</pre>
=== spin= bei right_triangle ===
Oder alternativ einfach mit <code>spin=</code> in den richtigen Quadranten drehen:
[[Datei:BOSL2-right triangle spin.png|mini|zentriert|alternativtext=right_triangle([40,30]) mit spin=90)|right_triangle([40,30]);
#right_triangle([40,30], '''spin=90''');]]
<pre class="openscad">include <BOSL2/std.scad>
right_triangle([40,30], spin=90);</pre>
<pre class="openscad">include <BOSL2/std.scad>
right_triangle([40,30], spin=-90);</pre>
Du kannst bei rechtwinkligen Dreiecken auch Verankerung verwenden:
<pre class="openscad">include <BOSL2/std.scad>
right_triangle([40,30], anchor=FWD+RIGHT);</pre>
<span id="trapeze-trapezoids"></span>
== Trapeze (Trapezoids) ==
OpenSCAD bietet keine einfache Möglichkeit, allgemeine 2D-Dreiecke, Trapeze oder Parallelogramme zu erstellen. Die BOSL2-Bibliothek kann all diese Formen mit dem <code>trapezoid()</code>-Modul bereitstellen.
=== Dreieck ===
Um ein gleichseitiges Dreieck zu erstellen, setze einfach eine der Breiten auf null:
[[Datei:BOSL2-trapezoid dreieck.png|mini|zentriert|alternativtext=Dreieck|trapezoid(w1=50, w2=0, h=40);<br>
Dreieck mit Seitenlänge = 50]]
<pre class="openscad">include <BOSL2/std.scad>
trapezoid(w1=50, w2=0, h=40);</pre>
Um ein rechtwinkliges Dreieck zu erstellen, musst du das <code>shift=</code>-Argument verwenden, um die Rückseite des Trapezes entlang der X-Achse zu verschieben:
[[Datei:BOSL2-trapezoid dreieck-rechtwinklig.png|mini|zentriert|alternativtext=Rechtwinkliges Dreieck|trapezoid(w1=50, w2=0, h=50, shift=-25);]]
<pre class="openscad">include <BOSL2/std.scad>
trapezoid(w1=50, w2=0, h=50, shift=-25);</pre>
<pre class="openscad">include <BOSL2/std.scad>
trapezoid(w1=50, w2=0, h=50, shift=25);</pre>
<pre class="openscad">include <BOSL2/std.scad>
trapezoid(w1=0, w2=50, h=50, shift=-25);</pre>
<pre class="openscad">include <BOSL2/std.scad>
trapezoid(w1=0, w2=50, h=50, shift=25);</pre>
=== Trapez ===
Du kannst ein Trapez erstellen, indem du für vorne (<code>w1=</code>) und hinten (<code>w2=</code>) von null verschiedene Breiten angibst:
[[Datei:BOSL2-trapezoid trapez.png|mini|zentriert|alternativtext=Trapez|trapezoid(w1=30, w2=50, h=50);]]
<pre class="openscad">include <BOSL2/std.scad>
trapezoid(w1=30, w2=50, h=50);</pre>
=== Parallelogramm ===
Ein Parallelogramm ist nur eine Frage der Verwendung der gleichen Breite für vorne und hinten, mit einer Verschiebung entlang der X-Achse:
[[Datei:BOSL2-trapezoid parallelogram.png|mini|zentriert|alternativtext=Parallelogramm|trapezoid(w1=50, w2=50, shift=20, h=50);]]
<pre class="openscad">include <BOSL2/std.scad>
trapezoid(w1=50, w2=50, shift=20, h=50);</pre>
=== Viereck ===
Ein Viereck kann erstellt werden, indem ungleiche, von null verschiedene Breiten für vorne (<code>w1=</code>) und hinten (<code>w2=</code>) verwendet werden, wobei die Rückseite entlang der X-Achse verschoben wird:
[[Datei:BOSL2-trapezoid viereck.png|mini|zentriert|alternativtext=Viereck|trapezoid(w1=50, w2=30, shift=20, h=50);]]
<pre class="openscad">include <BOSL2/std.scad>
trapezoid(w1=50, w2=30, shift=20, h=50);</pre>
Du kannst <code>anchor=</code> und <code>spin=</code> verwenden, genau wie bei anderen anhängbaren Formen. Die Ausrichtungen der Ankerpunkte basieren jedoch auf den Seitenwinkeln der Flächen und sind möglicherweise nicht das, was du erwartest:
<pre class="openscad">include <BOSL2/std.scad>
trapezoid(w1=30, w2=50, h=50)
show_anchors();</pre>
<span id="regelmäßige-n-ecke-regular-n-gons"></span>
== Regelmäßige n-Ecke (Regular N-Gons) ==
OpenSCAD ermöglicht es dir, regelmäßige n-Ecke (Fünfeck, Sechseck usw.) zu erstellen, indem du <code>circle()</code> mit <code>$fn</code> verwendest. Obwohl dies prägnant ist, mag es auf den ersten Blick weniger offensichtlich sein:
<pre class="openscad">include <BOSL2/std.scad>
circle(d=50, $fn=5);</pre>
Die BOSL2-Bibliothek hat Module, die für gängige n-Ecke klarer benannt sind:
=== Pentagon (d=<Durchmesser>) ===
[[Datei:BOSL2-Pentagon.png|mini|zentriert|alternativtext=Pentagon|pentagon(d=50);]]
<pre class="openscad">include <BOSL2/std.scad>
pentagon(d=50);</pre>
=== Hexagon (d=<Durchmesser>) ===
[[Datei:BOSL2-Hexagon.png|mini|zentriert|alternativtext=Hexagon| hexagon(d=50);]]
<pre class="openscad">include <BOSL2/std.scad>
hexagon(d=50);</pre>
=== Octagon (d= <Durchmesser>) ===
[[Datei:BOSL2-Octagon.png|mini|zentriert|alternativtext=octagon(d=50);|octagon(d=50);]]
<pre class="openscad">include <BOSL2/std.scad>
octagon(d=50);</pre>
=== regular_ngon (n=<Seitenanzahl>, d=<Durchmesser>) ===
[[Datei:BOSL2-regular ngon.png|mini|zentriert|alternativtext=regular_ngon|regular_ngon(n=7, d=50);]]
<pre class="openscad">include <BOSL2/std.scad>
regular_ngon(n=7, d=50);</pre>
=== side=<Seitenlänge> ===
Diese Module bieten dir auch zusätzliche Funktionalität. Sie können nach Seitenlänge dimensioniert werden:
[[Datei:BOSL2-Hexagon side50.png|mini|zentriert|alternativtext=hexagon(side=50);|hexagon(side=50);]]
<pre class="openscad">include <BOSL2/std.scad>
pentagon(side=50);</pre>
=== ir = <Innenradius> / id = <Innendurchmesser> ===
Sie können nach dem Radius/Durchmesser des umschriebenen Kreises (Innenkreis) dimensioniert werden:
[[Datei:BOSL2-Pentagon Innenradius.png|mini|zentriert|alternativtext=Innenradius|color("red") pentagon('''ir=25'''); color("yellow") circle(r=25,$fn=100);]]
<pre class="openscad">include <BOSL2/std.scad>
pentagon(ir=25);
pentagon(id=50);</pre>
=== realign=true/false ===
Die Polygone können um eine halbe Seite gedreht werden:
[[Datei:BOSL2-Pentagon realign.png|mini|zentriert|alternativtext=realign|pentagon(d=50, '''realign=false'''); #pentagon(d=50, '''realign=true''');]]
<pre class="openscad">include <BOSL2/std.scad>
left(30) pentagon(d=50, realign=true);
right(30) pentagon(d=50, realign=false);</pre>
=== rounding = <Rundung> ===
Die BOSL2-Polygone können abgerundet werden:
[[Datei:BOSL2-Polygon-rounding.png|mini|zentriert|alternativtext=rounding|pentagon(d=50, '''rounding=5''');]]
<pre class="openscad">include <BOSL2/std.scad>
pentagon(d=50, rounding=5);</pre>
=== show_anchors() ===
Die BOSL2-Polygone haben auch ein etwas anderes Anhangsverhalten als die regulären Polygone, die über $fn=<Seitenanzahl> erzeugt werden.
Ein Kreis mit einem kleinen <code>$fn=</code> hängt Dinge am idealen Kreis an, nicht entlang des erstellten Polygons:
[[Datei:BOSL2-polygon-outcircle-anchors.png|mini|zentriert|alternativtext=anchors Außenkreis|color("green") stroke(circle(d=50), closed=true); circle(d=50,$fn=6) show_anchors();]]
<pre class="openscad">include <BOSL2/std.scad>
color("green") stroke(circle(d=50), closed=true);
circle(d=50,$fn=6)
show_anchors();</pre>
Während ein BOSL2-n-Eck entlang des Polygons selbst (direkt) anhängt:
[[Datei:BOSL2-polygon-direct-anchors.png|mini|zentriert|alternativtext=anchors BOSL2 Polygone direkt|color("green") stroke(circle(d=50), closed=true); circle(d=50,$fn=6) show_anchors();]]
<pre class="openscad">include <BOSL2/std.scad>
hexagon(d=50)
show_anchors(custom=false);</pre>
Du kannst <code>anchor=</code> und <code>spin=</code> verwenden, genau wie bei anderen anhängbaren Formen. Die Ankerpunkte basieren jedoch darauf, wo der Ankervektor die Seite des n-Ecks schneiden würde, und sind möglicherweise nicht dort, wo du sie erwartest:
[[Datei:BOSL2-Pentagon-anchor.png|mini|zentriert|alternativtext=n-Polygon anchor|pentagon(d=50, '''anchor=FRONT+LEFT''') show_anchors(custom=false);]]
<pre class="openscad">include <BOSL2/std.scad>
pentagon(d=50, anchor=FRONT+LEFT)
show_anchors(custom=false);</pre>
=== Ankerpunkte für Seiten und Spitzen ===
n-Ecke haben auch benannte Ankerpunkte für ihre Seiten und Spitzen:
[[Datei:BOSL2-anchor-Spitzen-Seiten.png|mini|zentriert|alternativtext=Anker für Seiten und Spitzen|Spezielle Anker für die Spitzen und Seiten eines Pentagons (mit TikZ unter LaTeX erstellt)]]
Beachte, dass die Ankernamen in "" gesetzt werden müssen.
Zum Beispiel:
[[Datei:BOSL2-Pentagon anchor tip1.png|mini|zentriert|alternativtext=anchor="tip1"|pentagon(d=30, '''anchor="tip1" ''');]]
<pre class="openscad">include <BOSL2/std.scad>
pentagon(d=30, anchor="tip1");</pre>
<span id="sterne-stars"></span>
Beispiel mit attach():
[[Datei:BOSL2-anchor-Spitzen-Seiten attach.png|mini|zentriert|alternativtext=anchor="side2"|pentagon(d=30, anchor="side2") '''attach("tip0")''' circle(r=3,$fn=36);]]
<pre class="openscad">
include <BOSL2/std.scad>
pentagon(d=30, anchor="side2") attach("tip0") circle(r=3,$fn=36);
</pre>
== Sterne (Stars) ==
=== star() mit n, ir/id und or/od ===
Die BOSL2-Bibliothek hat Sterne als grundlegend unterstützte Form. Sie können eine beliebige Anzahl '''n''' von '''Spitzen''' haben. Du kannst die Form eines Sterns durch Spitzenanzahl, '''innere und äußere Scheitelpunkt-Radius/-Durchmesser''' angeben:
[[Datei:BOSL2-star n5 ir15 dr30-Veranschaulichung.png|mini|zentriert|alternativtext=Innerer und äußerer Radius bei star()|Veranschaulichung von den Parameter '''ir''' (oder id) und '''or''' (oder od). ''ir'' gibt den inneren Radius und or den äußeren Radius an. Die Anzahl der Zacken ist hier n=5. Siehe Code unten.]]
Begonnen wird der Stern mit einem Zacken nach rechts auf der X-Achse.
<pre class="openscad">
include <BOSL2/std.scad>
#circle(30, $fn=60);
color("blue") star(n=5, ir=15, or=30);
#circle(15, $fn=60);
color("darkblue") fwd(35) text("or=30", halign = "center", size=3);
color("yellow") text("ir=15",halign = "center", size=3, valign="center");
</pre>
=== star() mit Spannweite d ===
Statt '''od''' kann auch einfach '''d''' als Parameter verwendet werden.
[[Datei:BOSL2-star n3 id10 d50.png|mini|zentriert|alternativtext=star(n=3, id=10, d=50);|star(n=3, id=10, d=50);]]
<pre class="openscad">include <BOSL2/std.scad>
star(n=3, id=10, d=50);</pre>
[[Datei:BOSL2-star n5 id15 r25.png|mini|zentriert|alternativtext=star(n=5, id=15, r=25);|star(n=5, id=15, r=25);]]
<pre class="openscad">include <BOSL2/std.scad>
star(n=5, id=15, r=25);</pre>
[[Datei:BOSL2-star n10 id30 d50.png|mini|zentriert|alternativtext=star(n=10, id=30, d=50);|star(n=10, id=30, d=50);]]
<pre class="openscad">include <BOSL2/std.scad>
star(n=10, id=30, d=50);</pre>
=== star (n = <Spitzenanzahl>, step = <Anzahl zu überspringender Punkte>) ===
Oder du kannst die Sternform durch Spitzenanzahl '''n''' und Anzahl '''step''' der zu überspringenden Punkte angeben:
[[Datei:BOSL2-star n7 step2 d50.png|mini|zentriert|alternativtext=step|star(n=7, step=2, d=50);]]
<pre class="openscad">include <BOSL2/std.scad>
star(n=7, step=2, d=50);</pre>
[[Datei:BOSL2-star n7 step3 d50.png|mini|zentriert|alternativtext=step=3|star(n=7, step=3, d=50);]]
<pre class="openscad">include <BOSL2/std.scad>
star(n=7, step=3, d=50);</pre>
=== star() mit realign ===
Wenn dem <code>realign=</code>-Argument ein true-Wert übergeben wird, wird der Stern um einen halben Spitzenwinkel gedreht:
<pre class="openscad">include <BOSL2/std.scad>
left(30) star(n=5, step=2, d=50);
right(30) star(n=5, step=2, d=50, realign=true);</pre>
=== star() mit align_tip=<Anker> ===
Das <code>align_tip=</code>-Argument kann mit einem Vektor angegeben werden, damit du die erste Spitze in eine bestimmte Richtung ausrichten kannst:
[[Datei:BOSL2-star n5 align tip anchor tip0.png|mini|zentriert|alternativtext=align_tip=BACK|star(n=5, ir=15, or=30, align_tip=BACK) attach("tip0") color("blue") anchor_arrow2d();]]
<pre class="openscad">include <BOSL2/std.scad>
star(n=5, ir=15, or=30, align_tip=BACK)
attach("tip0") color("blue") anchor_arrow2d();</pre>
=== star() mit align_pit=<Anker> ===
Ebenso kann die erste Einkerbung oder Einbuchtung mit <code>align_pit=</code> in Richtung eines bestimmten Vektors ausgerichtet werden:
[[Datei:BOSL2-star n5 align pit BACK attach tip0.png|mini|zentriert|alternativtext=align_pit=BACK|star(n=5, ir=15, or=30, align_pit=BACK) attach("tip0") color("blue") anchor_arrow2d();]]
<pre class="openscad">include <BOSL2/std.scad>
star(n=5, ir=15, or=30, align_pit=BACK)
attach("pit0") color("blue") anchor_arrow2d();</pre>
Du kannst <code>anchor=</code> und <code>spin=</code> verwenden, genau wie bei anderen anhängbaren Formen. Die Ankerpunkte basieren jedoch auf den äußersten Ausmaßen der Form und sind möglicherweise nicht dort, wo du sie erwartest:
[[Datei:BOSL2-star n5 anchor LEFT-show anchers.png|mini|zentriert|alternativtext=anchor=LEFT|star(n=5, step=2, d=50,'''anchor=LEFT''') '''show_anchors(custom=false)''';]]
<pre class="openscad">include <BOSL2/std.scad>
star(n=5, step=2, d=50)
show_anchors(custom=false);</pre>
=== Benannte Ankerpunkte bei star() ===
Sterne haben auch benannte Ankerpunkte für ihre Gruben, Spitzen und Mittelpunkte zwischen den Spitzen:
[[Datei:BOSL2-star n5 benannteAnker.png|mini|zentriert|alternativtext=benannten Ankerpunkte in star()|Zuordnung der benannten Ankerpunkte in star(). Spitzen beginnen mit "tipt0", Einkerbungen mit pit0.]]
==== Beispiel 1: anchor="tip0" attach("pit0") ====
[[Datei:BOSL2-star-n5 ir=15 or30 anchor tip0 pit0.png|mini|zentriert|alternativtext=anchor="tip0"|star(n=5, ir=15, or=30, anchor="tip0") attach("pit0") #circle(3);]]
<pre class="openscad">
include <BOSL2/std.scad>
star(n=5, ir=15, or=30, anchor="tip0") attach("pit0") #circle(3);
</pre>
==== Beispiel 2: anchor="pit0" attach("tip0") ====
[[Datei:BOSL2-star n5 anchor pit0 attach tip0.png|mini|zentriert|alternativtext=anchor="pit0" attach("tip0")|star(n=5, ir=15, or=30, anchor="pit0") attach("tip0") #circle(3);]]
<pre class="openscad">
include <BOSL2/std.scad>
star(n=5, ir=15, or=30, anchor="pit0") attach("tip0") #circle(3);
</pre>
<span id="tropfenform-2d-teardrop2d"></span>
== Tropfenform 2D (Teardrop2D) ==
Beim 3D-Druck möchtest du oft ein kreisförmiges Loch in eine vertikale Wand machen. Wenn das Loch jedoch zu groß ist, kann der Überhang an der Oberseite des Lochs Probleme beim Drucken auf einem FDM/FFF-Drucker verursachen. Wenn du kein Stützmaterial verwenden möchtest, kannst du einfach die Tropfenform verwenden. Das <code>teardrop2d()</code>-Modul ermöglicht es dir, eine 2D-Version der Tropfenform zu erstellen, damit du sie später extrudieren kannst:
<pre class="openscad">include <BOSL2/std.scad>
teardrop2d(r=20);</pre>
<pre class="openscad">include <BOSL2/std.scad>
teardrop2d(d=50);</pre>
Der Standard-Überhangwinkel beträgt 45 Grad, aber du kannst ihn mit dem <code>ang=</code>-Argument anpassen:
<pre class="openscad">include <BOSL2/std.scad>
teardrop2d(d=50, ang=30);</pre>
Wenn du es vorziehst, die Oberseite des Tropfens abzuflachen, um das Bridging zu fördern, kannst du das <code>cap_h=</code>-Argument verwenden:
<pre class="openscad">include <BOSL2/std.scad>
teardrop2d(d=50, cap_h=25);</pre>
<pre class="openscad">include <BOSL2/std.scad>
teardrop2d(d=50, ang=30, cap_h=30);</pre>
Du kannst <code>anchor=</code> und <code>spin=</code> verwenden, genau wie bei anderen anhängbaren Formen. Die Ankerpunkte basieren jedoch auf den äußersten Ausmaßen der Form und sind möglicherweise nicht dort, wo du sie erwartest:
<pre class="openscad">include <BOSL2/std.scad>
teardrop2d(d=50, ang=30, cap_h=30)
show_anchors();</pre>
<span id="verklebte-kreise-glued-circles"></span>
== Verklebte Kreise (Glued Circles) ==
Eine ungewöhnlichere Form, die BOSL2 bietet, sind verklebte Kreise (Glued Circles). Es handelt sich im Grunde um ein Paar von Kreisen, die durch etwas verbunden sind, das wie ein klebriger Meniskus aussieht:
<pre class="openscad">include <BOSL2/std.scad>
glued_circles(d=30, spread=40);</pre>
Die <code>r=</code>/<code>d=</code>-Argumente können den Radius oder Durchmesser der beiden Kreise angeben:
<pre class="openscad">include <BOSL2/std.scad>
glued_circles(r=20, spread=45);</pre>
<pre class="openscad">include <BOSL2/std.scad>
glued_circles(d=40, spread=45);</pre>
Das <code>spread=</code>-Argument gibt den Abstand zwischen den Mittelpunkten der beiden Kreise an:
<pre class="openscad">include <BOSL2/std.scad>
glued_circles(d=30, spread=30);</pre>
<pre class="openscad">include <BOSL2/std.scad>
glued_circles(d=30, spread=40);</pre>
Das <code>tangent=</code>-Argument gibt den Winkel der Tangente des Meniskus an den beiden Kreisen an:
<pre class="openscad">include <BOSL2/std.scad>
glued_circles(d=30, spread=30, tangent=45);</pre>
<pre class="openscad">include <BOSL2/std.scad>
glued_circles(d=30, spread=30, tangent=20);</pre>
<pre class="openscad">include <BOSL2/std.scad>
glued_circles(d=30, spread=30, tangent=-20);</pre>
Eine nützliche Sache, die du tun kannst, ist, einige <code>glued_circle()</code>s in einer Linie anzuordnen und sie dann zu extrudieren, um eine gerippte Wand zu erstellen:
<pre class="openscad">include <BOSL2/std.scad>
$fn=36; s=10;
linear_extrude(height=50,convexity=16,center=true)
xcopies(s*sqrt(2),n=3)
glued_circles(d=s, spread=s*sqrt(2), tangent=45);</pre>
Du kannst <code>anchor=</code> und <code>spin=</code> verwenden, genau wie bei anderen anhängbaren Formen. Die Ankerpunkte basieren jedoch auf den äußersten Ausmaßen der Form und sind möglicherweise nicht dort, wo du sie erwartest:
<pre class="openscad">include <BOSL2/std.scad>
glued_circles(d=40, spread=40, tangent=45)
show_anchors();</pre>
gdl9eqsyxn0uqg2fv7i0lridigwf3g8
1093532
1093531
2026-11-08T15:50:28Z
Jowi-ammerbuch
115360
/* star() mit align_pit= */
1093532
wikitext
text/x-wiki
{{MyNavi
|zurück = [[OpenSCAD Benutzerhandbuch/_BOSL2-Distributoren|Zurück]]
|buch = [[OpenSCAD Benutzerhandbuch/_BOSL2|BOSL2-Inhalt]]
|weiter = [[OpenSCAD Benutzerhandbuch/_BOSL2-3D|Weiter]]
}}
== 2D Grundformen (2D Primitive) ==
OpenSCAD bietet zwei eingebaute 2D-Grundformen: <code>square()</code> und <code>circle()</code>. Du kannst sie weiterhin auf die gewohnte Weise verwenden:
<pre class="openscad">include <BOSL2/std.scad>
square([60,40], center=true);</pre>
<pre class="openscad">include <BOSL2/std.scad>
circle(r=50);</pre>
<pre class="openscad">include <BOSL2/std.scad>
circle(d=100, $fn=8);</pre>
Diese Module wurden in der BOSL2-Bibliothek in drei Bereichen erweitert: Verankerung (Anchoring), Drehung (Spin) und Anhängbarkeit (Attachability).
<span id="verankerung-anchoring"></span>
=== Verankerung (Anchoring): ===
Wenn du ein <code>square()</code> erstellst, kannst du angeben, welche Ecke oder Seite am Ursprung verankert werden soll. Dies ersetzt das <code>center=</code>-Argument und ist flexibler. Das <code>anchor=</code>-Argument nimmt einen Vektor als Wert entgegen, der in grober Richtung der Seite oder Ecke zeigt, die du am Ursprung ausrichten möchtest.
=== anchor=[0,1] oder anchor=BACK ===
[[Datei:BOSL2-anchor-0-1.png|mini|zentriert|alternativtext=anchor=[0,1]);|square([60,40], '''anchor=[0,1]''');<br>
Oder: square([60,40], '''anchor=BACK''');]]
Um beispielsweise das '''Zentrum der hinteren Kante am Ursprung''' auszurichten, setzt du den Anker auf <code>[0,1]</code>:
<pre class="openscad">
include <BOSL2/std.scad>
square([60,40], anchor=[0,1]);
</pre>
Mit den leichter verständlichen vordefinierten '''Vektor-Konstanten''':
<pre class="openscad">
include <BOSL2/std.scad>
square([60,40], anchor=BACK+CENTER);
</pre>
=== anchor=[1,-1] oder anchor=RIGHT+FRONT ===
Um die '''vordere rechte Ecke am Ursprung''' auszurichten:
[[Datei:BOSL2-anchor-1 -1.png|mini|zentriert|alternativtext=anchor=RIGHT+FRONT);|square([60,40], '''anchor=[1,-1]''');<br>
Oder: square([60,40], '''anchor=RIGHT+FRONT''');]]
<pre class="openscad">
include <BOSL2/std.scad>
square([60,40], anchor=[1,-1]);
</pre>
'''Mit Vektor-Konstanten:'''
<pre class="openscad">
include <BOSL2/std.scad>
square([60,40], anchor=RIGHT+FRONT);
</pre>
=== anchor=[0,0] oder anchor=CENTER '''Fetter Text'''===
Um es zu '''zentrieren''':
<pre class="openscad">
include <BOSL2/std.scad>
square([60,40], anchor=[0,0]);
</pre>
'''Mit Vektor-Konstanten:'''
<pre class="openscad">
include <BOSL2/std.scad>
square([60,40], anchor=CENTER);
</pre>
=== Vektor-Konstanten am Rechteck ===
Um die Angabe von Vektoren übersichtlicher zu gestalten, sind mehrere Standard-Vektorkonstanten definiert:
[[Datei:BOSL2-anchor-Konstanten-Rechteck.png|gerahmt|zentriert|alternativtext=BOSL2 vordefinierte anchor-Konstanten|Die in BOSL2 vordefinierten anchor-Konstanten]]
{| class="wikitable"
|-
! Konstante
! Richtung
! Wert
|-
| LEFT
| X-
| [-1, 0, 0]
|-
| RIGHT
| X+
| [ 1, 0, 0]
|-
| FRONT / FORWARD / FWD
| Y-
| [ 0,-1, 0]
|-
| BACK
| Y+
| [ 0, 1, 0]
|-
| BOTTOM / BOT / BTM / DOWN
| Z-
| [ 0, 0,-1] (nur 3D)
|-
| TOP / UP
| Z+
| [ 0, 0, 1] (nur 3D)
|-
| CENTER / CTR
| Zentriert
| [ 0, 0, 0]
|}
Beachte, dass du die meisten dieser Konstanten (außer <code>UP</code>/<code>DOWN</code> natürlich) auch für Anker bei 2D-Formen verwenden kannst, obwohl es sich um 3D-Vektoren handelt:
<pre class="openscad">include <BOSL2/std.scad>
square([60,40], anchor=BACK);</pre>
<pre class="openscad">include <BOSL2/std.scad>
square([60,40], anchor=CENTER);</pre>
Du kannst Vektoren addieren, um auf Ecken zu zeigen:
<pre class="openscad">include <BOSL2/std.scad>
square([60,40], anchor=FRONT+RIGHT);</pre>
=== anchor = polar_to_xy ===
Für <code>circle()</code> kann der Ankervektor auf jeden beliebigen '''Punkt des Kreisumfangs''' zeigen:
[[Datei:BOSL2-anchor-polar to xy-circle.png|gerahmt|zentriert|alternativtext=anchor = polar_to_xy|anchor = polar_to_xy(1,Alpha), für Alpha = 0, 45, 90, ...]]
==== Beispiel: anchor=polar_to_xy(1,45) =====
[[Datei:BOSL2-anchor-polar to 1-45-octagon.png|mini|zentriert|alternativtext=circle(d=50, anchor=polar_to_xy(1,45), $fn = 8);|circle(d=50, anchor=polar_to_xy(1,45), $fn = 8);]]
<pre class="openscad">
include <BOSL2/std.scad>
circle(d=50, anchor=polar_to_xy(1,45), $fn = 8);
</pre>
Beachte, dass der Radius für den Anker keine Rolle spielt, da nur die Richtung des Ankers das Ergebnis beeinflusst.
=== show_anchors() ===
[[Datei:BOSL2-show anchor.png|mini|zentriert|show_anchors]]
Du kannst die typischen Ankerpunkte sehen, indem du <code>show_anchors()</code> als Kind der Form übergibst:
<pre class="openscad">include <BOSL2/std.scad>
square([60,40], center=true)
show_anchors();</pre>
<pre class="openscad">include <BOSL2/std.scad>
circle(d=50)
show_anchors();</pre>
<span id="drehung-spin"></span>
=== Drehung (Spin): ===
Die zweite Erweiterung von <code>square()</code> und <code>circle()</code> ist die Drehung (Spin). Wenn du die Form erstellst, kannst du sie mit dem <code>spin=</code>-Argument an Ort und Stelle drehen. Du übergibst einfach die Anzahl der Grad, um die sie im Uhrzeigersinn gedreht werden soll:
<pre class="openscad">include <BOSL2/std.scad>
square([60,40], anchor=CENTER, spin=30);</pre>
Die Verankerung oder Zentrierung erfolgt vor der Drehung:
<pre class="openscad">include <BOSL2/std.scad>
square([60,40], anchor=BACK, spin=30);</pre>
Bei Kreisen kann Spin nützlich sein, wenn auch <code>$fn=</code> angegeben wird:
<pre class="openscad">include <BOSL2/std.scad>
circle(d=50, $fn=6, spin=15);</pre>
Da die Verankerung vor der Drehung erfolgt, kannst du beides zusammen verwenden, um um den Anker herum zu drehen:
<pre class="openscad">include <BOSL2/std.scad>
circle(d=50, $fn=6, anchor=LEFT, spin=15);</pre>
<span id="anhängbarkeit-attachability"></span>
=== Anhängbarkeit (Attachability): ===
Die dritte Erweiterung von <code>square()</code> und <code>circle()</code> ist, dass du sie auf verschiedene Weise an Ankerpunkten zusammenhängen kannst. Dies geschieht, indem du eine Form zum Kind der Form machst, an die du sie anhängen möchtest.
==== Standard (ohne Spez. für anchor oder position) ====
Standardmäßig wird das Kind beim einfachen Untereinanderstellen im Zentrum der Elternform angehängt.
[[Datei:BOSL2-attach-standard-normal.png|mini|zentriert|alternativtext=square(50) #square(50);|square(50) #square(50);<br>
Kind-Objekt (rot) wird ans Zentrum des Elternobjekts angehängt]]
<pre class="openscad">
include <BOSL2/std.scad>
square(50) #square(50);
</pre>
==== anchor für child spezifiziert ====
[[Datei:BOSL2-attach-anchor-LEFTplusFWD.png|mini|zentriert|alternativtext=square(50, center=true) #square([20,40], anchor=LEFT+FWD);|square(50, center=true)#square([20,40], '''anchor=LEFT+FWD''');]]
<pre class="openscad">include <BOSL2/std.scad>
square(50, center=true)
#square([20,40], anchor=LEFT+FWD);</pre>
==== position() ====
[[Datei:BOSL2-attach-position.png|mini|zentriert|alternativtext=position(RIGHT)|square(50) '''position(RIGHT)''' #square(25) '''position(BACK)''' #square(25);]]
Durch Hinzufügen des <code>position()</code>-Moduls kannst du das Kind an jedem Ankerpunkt '''des Elternteils''' positionieren, das "Kindes-Kind wird am Ankerpunkt des übergeordneten Objekts positioniert:
<pre class="openscad">
include <BOSL2/std.scad>
square(50) position(RIGHT) #square(25)
position(BACK) #square(25);
</pre>
==== orient() ====
Ankerpunkte sind jedoch nicht nur Positionen auf dem Elternteil. Sie haben auch eine Ausrichtung. In den meisten Fällen zeigt die Ausrichtung eines Ankerpunkts nach außen, weg von der Fläche der Wand, also im Allgemeinen vom Zentrum der Form weg.
[[Datei:BOSL2-show anchor.png|mini|zentriert|show_anchors]]
Wenn du das Kind so ausrichten möchtest, dass es der Ausrichtung eines Ankerpunkts entspricht, kannst du das <code>orient()</code>-Modul verwenden. Es positioniert das Kind nicht, es dreht es nur:
[[Datei:BOSL2-attach-orient anchor.png|mini|zentriert|alternativtext= orient(anchor=LEFT+BOTTOM)|square(50) '''orient(anchor=LEFT+BOTTOM)''' #square([10,40]);]]
<pre class="openscad">include <BOSL2/std.scad>
square(50)
orient(anchor=LEFT+BOTTOM) #square([10,40]);</pre>
Das geht auch beim '''Kreis (circle)''' mit '''polar_to_xy''':
[[Datei:BOSL2-attach-orient polar to xy circle.png|mini|zentriert|alternativtext=orient(polar_to_xy(1,30))|circle(d=50) ''' orient(polar_to_xy(1,30))''' #square([10,40], anchor=FWD);]]
<pre class="openscad">include <BOSL2/std.scad>
circle(d=50)
orient(polar_to_xy(1,30))
#square([10,40], anchor=FWD);</pre>
==== position() + orient() ====
Du kannst <code>position()</code> und <code>orient()</code> zusammen verwenden, um sowohl zu positionieren als auch an einem Ankerpunkt auszurichten:
[[Datei:BOSL2-attach-position pluss orient polar to xy circle.png|mini|zentriert|alternativtext=position(polar_to_xy(1,30)) orient(polar_to_xy(1,30))|circle(d=50) '''position(polar_to_xy(1,30)) orient(polar_to_xy(1,30))''' #square([10,40], anchor=FWD);]]
<pre class="openscad">include <BOSL2/std.scad>
circle(d=50)
position(polar_to_xy(1,30))
orient(polar_to_xy(1,30))
#square([10,40], anchor=FWD);</pre>
=== attach () mit einem Argument ===
Aber es ist einfacher das <code>attach()</code>-Modul zu verwenden, um beides auf einmal zu erledigen:
[[Datei:BOSL2-attach-position pluss orient polar to xy circle.png|mini|zentriert|alternativtext=attach(polar_to_xy(1,30))|circle(d=50) '''attach(polar_to_xy(1,30))''' #square([10,40], anchor=FWD); ]]
Gleiches Ergebnis, aber übersichtlicherer Code.
<pre class="openscad">include <BOSL2/std.scad>
square(50, center=true)
attach(LEFT+BACK)
#square([10,40], anchor=FWD);</pre>
=== attach () mit zwei Argumenten ===
Anstatt den <code>anchor=</code> im Kind anzugeben, kannst du ein '''zweites Argument''' an <code>attach()</code> übergeben, das ihm sagt, welche Seite des Kindes mit dem Elternteil verbunden werden soll:
<pre class="openscad">
include <BOSL2/std.scad>
circle(d=50) attach(polar_to_xy(1,30), FWD) #square([10,40]);
</pre>
Damit lässt sich der Code noch mehr straffen.
[[Datei:BOSL2-attach-position pluss orient polar to xy circle.png|mini|zentriert|alternativtext=attach(polar_to_xy(1,30), FWD)|circle(d=50) '''attach(polar_to_xy(1,30), FWD)''' #square([10,40]); ]]
<span id="rechtecke-rectangles"></span>
== Rechtecke (Rectangles) ==
=== rect() ===
Die BOSL2-Bibliothek bietet eine Alternative zu <code>square()</code>, die mehr Funktionen unterstützt. Sie heißt <code>rect()</code>. Du kannst sie genauso verwenden wie <code>square()</code>, aber sie bietet auch erweiterte Funktionalität.
=== rect() mit rounding ===
[[Datei:BOSL2-rect rounding.png|mini|zentriert|alternativtext=rounding=10|rect([60,40], '''rounding=10''');]]
rect() erlaubt dir, die Ecken des Rechtecks abzurunden:
<pre class="openscad">include <BOSL2/std.scad>
rect([60,40], rounding=10);</pre>
=== rect() mit chamfer ===
[[Datei:BOSL2-rect chamfer.png|mini|zentriert|alternativtext=rect([60,40], chamfer=10);|rect([60,40], '''chamfer=10''');]]
Du kannst die Ecken des Rechtecks auch abfasen:
<pre class="openscad">include <BOSL2/std.scad>
rect([60,40], chamfer=10);</pre>
=== Unterschiedliche Abrundungen und Fasen an einem Rechteck ===
Du kannst sogar angeben, welche Ecken abgerundet oder abgefast werden. Wenn du eine Liste mit vier Größenwerten an die <code>rounding=</code>- oder <code>chamfer=</code>-Argumente übergibst, erhält jede Ecke ihre eigene Größe. Der Reihe nach geht es von der hinteren rechten Ecke (Quadrant I) gegen den Uhrzeigersinn zur hinteren linken Ecke (Quadrant II), zur vorderen linken Ecke (Quadrant III) und zur vorderen rechten Ecke (Quadrant IV):
Wenn eine Größe als <code>0</code> angegeben wird, gibt es keine Rundung und/oder Fase für die Ecke dieses Quadranten:
<pre class="openscad">include <BOSL2/std.scad>
rect([60,40], rounding=[0,5,10,15]);</pre>
<pre class="openscad">include <BOSL2/std.scad>
rect([60,40], chamfer=[0,5,10,15]);</pre>
Du kannst sowohl <code>rounding=</code>- als auch <code>chamfer=</code>-Argumente angeben, um Rundung und Fase zu mischen, aber nur, wenn du es pro Ecke angibst. Wenn du eine Rundung in einer Ecke möchtest, gib eine Fase von 0 für diese Ecke an und umgekehrt:
[[Datei:BOSL2-rect chamfer-rounding-mixed.png|mini|zentriert|alternativtext=ounding=[5,0,10,0], chamfer=[0,5,0,15]|rect([60,40], '''rounding=[5,0,10,0], chamfer=[0,5,0,15]''');]]
<pre class="openscad">include <BOSL2/std.scad>
rect([60,40], rounding=[5,0,10,0], chamfer=[0,5,0,15]);</pre>
<span id="ellipsen-ellipses"></span>
== Ellipsen (Ellipses) ==
Die BOSL2-Bibliothek bietet auch eine erweiterte Entsprechung von <code>circle()</code>, die <code>ellipse()</code> heißt. Du kannst sie genauso verwenden wie <code>circle()</code>, aber sie bietet auch erweiterte Funktionalität. Zum Beispiel erlaubt sie mehr Kontrolle über ihre Größe.
Da ein Kreis in OpenSCAD nur durch ein regelmäßiges Polygon mit einer Anzahl gerader Seiten angenähert werden kann, kann dies zu Ungenauigkeiten in Größe und Form führen. Um dem entgegenzuwirken, werden auch die Argumente <code>realign=</code> und <code>circum=</code> bereitgestellt.
=== realign= (ellipse-Argument) ===
Das <code>realign=</code>-Argument rotiert, wenn es auf <code>true</code> gesetzt wird, die <code>ellipse()</code> um den halben Winkel zwischen den Polygonseiten:
[[Datei:BOSL2-ellipse-realign.png|mini|zentriert|alternativtext=realign=true|#ellipse(d=100, $fn=8); color("lime") ellipse(d=100, $fn=8, '''realign=true''');]]
<pre class="openscad">
include <BOSL2/std.scad>
#ellipse(d=100, $fn=8);
color("lime") ellipse(d=100, $fn=8, realign=true);
</pre>
=== circum= (ellipse-Argument) ===
[[Datei:BOSL2-ellipse-circum.png|mini|zentriert|alternativtext=circum=true|Vergleich: rot (außen) mit circum=true und blau (innen) ohne circum. Referenz: idealer Kreis in gelb.]]
<pre class="openscad">
include <BOSL2/std.scad>
color("red") ellipse(d=100, $fn=6, circum=true);
color("yellow") ellipse(d=100, $fn=360);
color("blue") ellipse(d=100, $fn=6);
</pre>
Das <code>circum=</code>-Argument bewirkt, wenn es auf true gesetzt wird, dass das Polygon, das die <code>ellipse()</code> bildet, den idealen Kreis '''umschreibt''', anstatt ihn einzuschreiben.
Den idealen Kreis ''einschreiben'':
<pre class="openscad">include <BOSL2/std.scad>
color("green") ellipse(d=100, $fn=360);
ellipse(d=100, $fn=6);</pre>
Den idealen Kreis ''umschreiben'':
<pre class="openscad">include <BOSL2/std.scad>
ellipse(d=100, $fn=6, circum=true);
color("green") ellipse(d=100, $fn=360);</pre>
=== Ellipse mit 2 Radien ===
Das <code>ellipse()</code>-Modul kann, wie der Name schon sagt, mit separaten X- und Y-Radien oder -Durchmessern angegeben werden. Dazu gibst du einfach <code>r=</code> oder <code>d=</code> mit einer Liste von zwei Radien oder Durchmessern an:
[[Datei:BOSL2-ellipse-2Radien.png|mini|zentriert|alternativtext=2 Radien|ellipse('''r=[30,20]''');]]
==== r=[r1,r2] ====
<pre class="openscad">include <BOSL2/std.scad>
ellipse(r=[30,20]);</pre>
==== d=[d1,d2]====
<pre class="openscad">include <BOSL2/std.scad>
ellipse(d=[60,40]);</pre>
==== ellipse mit anchor ====
Wie bei <code>circle()</code> kannst du <code>ellipse()</code>-Formen verankern, drehen und anhängen:
[[Datei:BOSL2-ellipse-anchor.png|mini|zentriert|alternativtext=ellipse mit anchor|ellipse(d=[50,20], '''anchor=BACK'''); #ellipse(d=[50,20], '''anchor=FRONT''');]]
<pre class="openscad">
include <BOSL2/std.scad>
ellipse(d=[50,20], anchor=BACK);
#ellipse(d=[50,20], anchor=FRONT);
</pre>
==== ellipse mit attach ====
[[Datei:BOSL2-ellipse-attach.png|mini|zentriert|alternativtext=ellipse mit attach|ellipse(d=50) '''attach(BACK+RIGHT, FRONT+LEFT)''' #ellipse(d=[40,20]);]]
<pre class="openscad">
include <BOSL2/std.scad>
ellipse(d=50)
attach(BACK+RIGHT, FRONT+LEFT)
ellipse(d=30);
</pre>
<span id="rechtwinklige-dreiecke-right-triangles"></span>
==== ellipse mit spin ====
[[Datei:BOSL2-ellipse-attach-spin-anchor.png|mini|zentriert|alternativtext=spin = 90 bei ellipse|ellipse(d=50) attach(BACK) #ellipse(d=[40,20], '''spin=90''', anchor=LEFT);]]
<pre class="openscad">
include <BOSL2/std.scad>
ellipse(d=50)
attach(BACK)
#ellipse(d=[40,20], spin=90, anchor=LEFT);
</pre>
== Rechtwinklige Dreiecke (Right Triangles) ==
Die BOSL2-Bibliothek bietet eine einfache Möglichkeit, ein 2D-rechtwinkliges Dreieck mit dem <code>right_triangle()</code>-Modul zu erstellen:
[[Datei:BOSL2-right triangle.png|mini|zentriert|alternativtext=right_triangle([40,30])|right_triangle([40,30]);]]
<pre class="openscad">include <BOSL2/std.scad>
right_triangle([40,30]);</pre>
=== xflip() bei right_triangle ===
Du kannst <code>xflip()</code> und <code>yflip()</code> verwenden, um zu ändern, in welchem Quadranten das Dreieck gebildet wird:
[[Datei:BOSL2-right triangle xflip.png|mini|zentriert|alternativtext=right_triange mit xflip()|right_triangle([40,30]); '''xflip()''' #right_triangle([40,30]);]]
<pre class="openscad">include <BOSL2/std.scad>
xflip() right_triangle([40,30]);</pre>
=== yflip() bei right_triangle ===
[[Datei:BOSL2-right triangle yflip.png|mini|zentriert|alternativtext=right_triangle([40,30]) mit yflip()|right_triangle([40,30]); '''yflip()''' #right_triangle([40,30]);]]
<pre class="openscad">include <BOSL2/std.scad>
yflip() right_triangle([40,30]);</pre>
=== xflip() & yflip() bei right_triangle ===
[[Datei:BOSL2-right triangle xflip yflip.png|mini|zentriert|alternativtext=xflip() yflip()|right_triangle([40,30]); xflip() yflip() #right_triangle([40,30]);]]
<pre class="openscad">include <BOSL2/std.scad>
xflip() yflip() right_triangle([40,30]);</pre>
=== spin= bei right_triangle ===
Oder alternativ einfach mit <code>spin=</code> in den richtigen Quadranten drehen:
[[Datei:BOSL2-right triangle spin.png|mini|zentriert|alternativtext=right_triangle([40,30]) mit spin=90)|right_triangle([40,30]);
#right_triangle([40,30], '''spin=90''');]]
<pre class="openscad">include <BOSL2/std.scad>
right_triangle([40,30], spin=90);</pre>
<pre class="openscad">include <BOSL2/std.scad>
right_triangle([40,30], spin=-90);</pre>
Du kannst bei rechtwinkligen Dreiecken auch Verankerung verwenden:
<pre class="openscad">include <BOSL2/std.scad>
right_triangle([40,30], anchor=FWD+RIGHT);</pre>
<span id="trapeze-trapezoids"></span>
== Trapeze (Trapezoids) ==
OpenSCAD bietet keine einfache Möglichkeit, allgemeine 2D-Dreiecke, Trapeze oder Parallelogramme zu erstellen. Die BOSL2-Bibliothek kann all diese Formen mit dem <code>trapezoid()</code>-Modul bereitstellen.
=== Dreieck ===
Um ein gleichseitiges Dreieck zu erstellen, setze einfach eine der Breiten auf null:
[[Datei:BOSL2-trapezoid dreieck.png|mini|zentriert|alternativtext=Dreieck|trapezoid(w1=50, w2=0, h=40);<br>
Dreieck mit Seitenlänge = 50]]
<pre class="openscad">include <BOSL2/std.scad>
trapezoid(w1=50, w2=0, h=40);</pre>
Um ein rechtwinkliges Dreieck zu erstellen, musst du das <code>shift=</code>-Argument verwenden, um die Rückseite des Trapezes entlang der X-Achse zu verschieben:
[[Datei:BOSL2-trapezoid dreieck-rechtwinklig.png|mini|zentriert|alternativtext=Rechtwinkliges Dreieck|trapezoid(w1=50, w2=0, h=50, shift=-25);]]
<pre class="openscad">include <BOSL2/std.scad>
trapezoid(w1=50, w2=0, h=50, shift=-25);</pre>
<pre class="openscad">include <BOSL2/std.scad>
trapezoid(w1=50, w2=0, h=50, shift=25);</pre>
<pre class="openscad">include <BOSL2/std.scad>
trapezoid(w1=0, w2=50, h=50, shift=-25);</pre>
<pre class="openscad">include <BOSL2/std.scad>
trapezoid(w1=0, w2=50, h=50, shift=25);</pre>
=== Trapez ===
Du kannst ein Trapez erstellen, indem du für vorne (<code>w1=</code>) und hinten (<code>w2=</code>) von null verschiedene Breiten angibst:
[[Datei:BOSL2-trapezoid trapez.png|mini|zentriert|alternativtext=Trapez|trapezoid(w1=30, w2=50, h=50);]]
<pre class="openscad">include <BOSL2/std.scad>
trapezoid(w1=30, w2=50, h=50);</pre>
=== Parallelogramm ===
Ein Parallelogramm ist nur eine Frage der Verwendung der gleichen Breite für vorne und hinten, mit einer Verschiebung entlang der X-Achse:
[[Datei:BOSL2-trapezoid parallelogram.png|mini|zentriert|alternativtext=Parallelogramm|trapezoid(w1=50, w2=50, shift=20, h=50);]]
<pre class="openscad">include <BOSL2/std.scad>
trapezoid(w1=50, w2=50, shift=20, h=50);</pre>
=== Viereck ===
Ein Viereck kann erstellt werden, indem ungleiche, von null verschiedene Breiten für vorne (<code>w1=</code>) und hinten (<code>w2=</code>) verwendet werden, wobei die Rückseite entlang der X-Achse verschoben wird:
[[Datei:BOSL2-trapezoid viereck.png|mini|zentriert|alternativtext=Viereck|trapezoid(w1=50, w2=30, shift=20, h=50);]]
<pre class="openscad">include <BOSL2/std.scad>
trapezoid(w1=50, w2=30, shift=20, h=50);</pre>
Du kannst <code>anchor=</code> und <code>spin=</code> verwenden, genau wie bei anderen anhängbaren Formen. Die Ausrichtungen der Ankerpunkte basieren jedoch auf den Seitenwinkeln der Flächen und sind möglicherweise nicht das, was du erwartest:
<pre class="openscad">include <BOSL2/std.scad>
trapezoid(w1=30, w2=50, h=50)
show_anchors();</pre>
<span id="regelmäßige-n-ecke-regular-n-gons"></span>
== Regelmäßige n-Ecke (Regular N-Gons) ==
OpenSCAD ermöglicht es dir, regelmäßige n-Ecke (Fünfeck, Sechseck usw.) zu erstellen, indem du <code>circle()</code> mit <code>$fn</code> verwendest. Obwohl dies prägnant ist, mag es auf den ersten Blick weniger offensichtlich sein:
<pre class="openscad">include <BOSL2/std.scad>
circle(d=50, $fn=5);</pre>
Die BOSL2-Bibliothek hat Module, die für gängige n-Ecke klarer benannt sind:
=== Pentagon (d=<Durchmesser>) ===
[[Datei:BOSL2-Pentagon.png|mini|zentriert|alternativtext=Pentagon|pentagon(d=50);]]
<pre class="openscad">include <BOSL2/std.scad>
pentagon(d=50);</pre>
=== Hexagon (d=<Durchmesser>) ===
[[Datei:BOSL2-Hexagon.png|mini|zentriert|alternativtext=Hexagon| hexagon(d=50);]]
<pre class="openscad">include <BOSL2/std.scad>
hexagon(d=50);</pre>
=== Octagon (d= <Durchmesser>) ===
[[Datei:BOSL2-Octagon.png|mini|zentriert|alternativtext=octagon(d=50);|octagon(d=50);]]
<pre class="openscad">include <BOSL2/std.scad>
octagon(d=50);</pre>
=== regular_ngon (n=<Seitenanzahl>, d=<Durchmesser>) ===
[[Datei:BOSL2-regular ngon.png|mini|zentriert|alternativtext=regular_ngon|regular_ngon(n=7, d=50);]]
<pre class="openscad">include <BOSL2/std.scad>
regular_ngon(n=7, d=50);</pre>
=== side=<Seitenlänge> ===
Diese Module bieten dir auch zusätzliche Funktionalität. Sie können nach Seitenlänge dimensioniert werden:
[[Datei:BOSL2-Hexagon side50.png|mini|zentriert|alternativtext=hexagon(side=50);|hexagon(side=50);]]
<pre class="openscad">include <BOSL2/std.scad>
pentagon(side=50);</pre>
=== ir = <Innenradius> / id = <Innendurchmesser> ===
Sie können nach dem Radius/Durchmesser des umschriebenen Kreises (Innenkreis) dimensioniert werden:
[[Datei:BOSL2-Pentagon Innenradius.png|mini|zentriert|alternativtext=Innenradius|color("red") pentagon('''ir=25'''); color("yellow") circle(r=25,$fn=100);]]
<pre class="openscad">include <BOSL2/std.scad>
pentagon(ir=25);
pentagon(id=50);</pre>
=== realign=true/false ===
Die Polygone können um eine halbe Seite gedreht werden:
[[Datei:BOSL2-Pentagon realign.png|mini|zentriert|alternativtext=realign|pentagon(d=50, '''realign=false'''); #pentagon(d=50, '''realign=true''');]]
<pre class="openscad">include <BOSL2/std.scad>
left(30) pentagon(d=50, realign=true);
right(30) pentagon(d=50, realign=false);</pre>
=== rounding = <Rundung> ===
Die BOSL2-Polygone können abgerundet werden:
[[Datei:BOSL2-Polygon-rounding.png|mini|zentriert|alternativtext=rounding|pentagon(d=50, '''rounding=5''');]]
<pre class="openscad">include <BOSL2/std.scad>
pentagon(d=50, rounding=5);</pre>
=== show_anchors() ===
Die BOSL2-Polygone haben auch ein etwas anderes Anhangsverhalten als die regulären Polygone, die über $fn=<Seitenanzahl> erzeugt werden.
Ein Kreis mit einem kleinen <code>$fn=</code> hängt Dinge am idealen Kreis an, nicht entlang des erstellten Polygons:
[[Datei:BOSL2-polygon-outcircle-anchors.png|mini|zentriert|alternativtext=anchors Außenkreis|color("green") stroke(circle(d=50), closed=true); circle(d=50,$fn=6) show_anchors();]]
<pre class="openscad">include <BOSL2/std.scad>
color("green") stroke(circle(d=50), closed=true);
circle(d=50,$fn=6)
show_anchors();</pre>
Während ein BOSL2-n-Eck entlang des Polygons selbst (direkt) anhängt:
[[Datei:BOSL2-polygon-direct-anchors.png|mini|zentriert|alternativtext=anchors BOSL2 Polygone direkt|color("green") stroke(circle(d=50), closed=true); circle(d=50,$fn=6) show_anchors();]]
<pre class="openscad">include <BOSL2/std.scad>
hexagon(d=50)
show_anchors(custom=false);</pre>
Du kannst <code>anchor=</code> und <code>spin=</code> verwenden, genau wie bei anderen anhängbaren Formen. Die Ankerpunkte basieren jedoch darauf, wo der Ankervektor die Seite des n-Ecks schneiden würde, und sind möglicherweise nicht dort, wo du sie erwartest:
[[Datei:BOSL2-Pentagon-anchor.png|mini|zentriert|alternativtext=n-Polygon anchor|pentagon(d=50, '''anchor=FRONT+LEFT''') show_anchors(custom=false);]]
<pre class="openscad">include <BOSL2/std.scad>
pentagon(d=50, anchor=FRONT+LEFT)
show_anchors(custom=false);</pre>
=== Ankerpunkte für Seiten und Spitzen ===
n-Ecke haben auch benannte Ankerpunkte für ihre Seiten und Spitzen:
[[Datei:BOSL2-anchor-Spitzen-Seiten.png|mini|zentriert|alternativtext=Anker für Seiten und Spitzen|Spezielle Anker für die Spitzen und Seiten eines Pentagons (mit TikZ unter LaTeX erstellt)]]
Beachte, dass die Ankernamen in "" gesetzt werden müssen.
Zum Beispiel:
[[Datei:BOSL2-Pentagon anchor tip1.png|mini|zentriert|alternativtext=anchor="tip1"|pentagon(d=30, '''anchor="tip1" ''');]]
<pre class="openscad">include <BOSL2/std.scad>
pentagon(d=30, anchor="tip1");</pre>
<span id="sterne-stars"></span>
Beispiel mit attach():
[[Datei:BOSL2-anchor-Spitzen-Seiten attach.png|mini|zentriert|alternativtext=anchor="side2"|pentagon(d=30, anchor="side2") '''attach("tip0")''' circle(r=3,$fn=36);]]
<pre class="openscad">
include <BOSL2/std.scad>
pentagon(d=30, anchor="side2") attach("tip0") circle(r=3,$fn=36);
</pre>
== Sterne (Stars) ==
=== star() mit n, ir/id und or/od ===
Die BOSL2-Bibliothek hat Sterne als grundlegend unterstützte Form. Sie können eine beliebige Anzahl '''n''' von '''Spitzen''' haben. Du kannst die Form eines Sterns durch Spitzenanzahl, '''innere und äußere Scheitelpunkt-Radius/-Durchmesser''' angeben:
[[Datei:BOSL2-star n5 ir15 dr30-Veranschaulichung.png|mini|zentriert|alternativtext=Innerer und äußerer Radius bei star()|Veranschaulichung von den Parameter '''ir''' (oder id) und '''or''' (oder od). ''ir'' gibt den inneren Radius und or den äußeren Radius an. Die Anzahl der Zacken ist hier n=5. Siehe Code unten.]]
Begonnen wird der Stern mit einem Zacken nach rechts auf der X-Achse.
<pre class="openscad">
include <BOSL2/std.scad>
#circle(30, $fn=60);
color("blue") star(n=5, ir=15, or=30);
#circle(15, $fn=60);
color("darkblue") fwd(35) text("or=30", halign = "center", size=3);
color("yellow") text("ir=15",halign = "center", size=3, valign="center");
</pre>
=== star() mit Spannweite d ===
Statt '''od''' kann auch einfach '''d''' als Parameter verwendet werden.
[[Datei:BOSL2-star n3 id10 d50.png|mini|zentriert|alternativtext=star(n=3, id=10, d=50);|star(n=3, id=10, d=50);]]
<pre class="openscad">include <BOSL2/std.scad>
star(n=3, id=10, d=50);</pre>
[[Datei:BOSL2-star n5 id15 r25.png|mini|zentriert|alternativtext=star(n=5, id=15, r=25);|star(n=5, id=15, r=25);]]
<pre class="openscad">include <BOSL2/std.scad>
star(n=5, id=15, r=25);</pre>
[[Datei:BOSL2-star n10 id30 d50.png|mini|zentriert|alternativtext=star(n=10, id=30, d=50);|star(n=10, id=30, d=50);]]
<pre class="openscad">include <BOSL2/std.scad>
star(n=10, id=30, d=50);</pre>
=== star (n = <Spitzenanzahl>, step = <Anzahl zu überspringender Punkte>) ===
Oder du kannst die Sternform durch Spitzenanzahl '''n''' und Anzahl '''step''' der zu überspringenden Punkte angeben:
[[Datei:BOSL2-star n7 step2 d50.png|mini|zentriert|alternativtext=step|star(n=7, step=2, d=50);]]
<pre class="openscad">include <BOSL2/std.scad>
star(n=7, step=2, d=50);</pre>
[[Datei:BOSL2-star n7 step3 d50.png|mini|zentriert|alternativtext=step=3|star(n=7, step=3, d=50);]]
<pre class="openscad">include <BOSL2/std.scad>
star(n=7, step=3, d=50);</pre>
=== star() mit realign ===
Wenn dem <code>realign=</code>-Argument ein true-Wert übergeben wird, wird der Stern um einen halben Spitzenwinkel gedreht:
<pre class="openscad">include <BOSL2/std.scad>
left(30) star(n=5, step=2, d=50);
right(30) star(n=5, step=2, d=50, realign=true);</pre>
=== star() mit align_tip=<Anker> ===
Das <code>align_tip=</code>-Argument kann mit einem Vektor angegeben werden, damit du die erste Spitze in eine bestimmte Richtung ausrichten kannst:
[[Datei:BOSL2-star n5 align tip anchor tip0.png|mini|zentriert|alternativtext=align_tip=BACK|star(n=5, ir=15, or=30, align_tip=BACK) attach("tip0") color("blue") anchor_arrow2d();]]
<pre class="openscad">include <BOSL2/std.scad>
star(n=5, ir=15, or=30, align_tip=BACK)
attach("tip0") color("blue") anchor_arrow2d();</pre>
=== star() mit align_pit=<Anker> ===
Ebenso kann die erste Einkerbung oder Einbuchtung mit <code>align_pit=</code> in Richtung eines bestimmten Vektors ausgerichtet werden:
[[Datei:BOSL2-star n5 align pit BACK attach tip0.png|mini|zentriert|alternativtext=align_pit=BACK|star(n=5, ir=15, or=30, '''align_pit=BACK''') '''attach("tip0")''' color("blue") anchor_arrow2d();]]
<pre class="openscad">include <BOSL2/std.scad>
star(n=5, ir=15, or=30, align_pit=BACK)
attach("pit0") color("blue") anchor_arrow2d();</pre>
Du kannst <code>anchor=</code> und <code>spin=</code> verwenden, genau wie bei anderen anhängbaren Formen. Die Ankerpunkte basieren jedoch auf den äußersten Ausmaßen der Form und sind möglicherweise nicht dort, wo du sie erwartest:
[[Datei:BOSL2-star n5 anchor LEFT-show anchers.png|mini|zentriert|alternativtext=anchor=LEFT|star(n=5, step=2, d=50,'''anchor=LEFT''') '''show_anchors(custom=false)''';]]
<pre class="openscad">include <BOSL2/std.scad>
star(n=5, step=2, d=50)
show_anchors(custom=false);</pre>
=== Benannte Ankerpunkte bei star() ===
Sterne haben auch benannte Ankerpunkte für ihre Gruben, Spitzen und Mittelpunkte zwischen den Spitzen:
[[Datei:BOSL2-star n5 benannteAnker.png|mini|zentriert|alternativtext=benannten Ankerpunkte in star()|Zuordnung der benannten Ankerpunkte in star(). Spitzen beginnen mit "tipt0", Einkerbungen mit pit0.]]
==== Beispiel 1: anchor="tip0" attach("pit0") ====
[[Datei:BOSL2-star-n5 ir=15 or30 anchor tip0 pit0.png|mini|zentriert|alternativtext=anchor="tip0"|star(n=5, ir=15, or=30, anchor="tip0") attach("pit0") #circle(3);]]
<pre class="openscad">
include <BOSL2/std.scad>
star(n=5, ir=15, or=30, anchor="tip0") attach("pit0") #circle(3);
</pre>
==== Beispiel 2: anchor="pit0" attach("tip0") ====
[[Datei:BOSL2-star n5 anchor pit0 attach tip0.png|mini|zentriert|alternativtext=anchor="pit0" attach("tip0")|star(n=5, ir=15, or=30, anchor="pit0") attach("tip0") #circle(3);]]
<pre class="openscad">
include <BOSL2/std.scad>
star(n=5, ir=15, or=30, anchor="pit0") attach("tip0") #circle(3);
</pre>
<span id="tropfenform-2d-teardrop2d"></span>
== Tropfenform 2D (Teardrop2D) ==
Beim 3D-Druck möchtest du oft ein kreisförmiges Loch in eine vertikale Wand machen. Wenn das Loch jedoch zu groß ist, kann der Überhang an der Oberseite des Lochs Probleme beim Drucken auf einem FDM/FFF-Drucker verursachen. Wenn du kein Stützmaterial verwenden möchtest, kannst du einfach die Tropfenform verwenden. Das <code>teardrop2d()</code>-Modul ermöglicht es dir, eine 2D-Version der Tropfenform zu erstellen, damit du sie später extrudieren kannst:
<pre class="openscad">include <BOSL2/std.scad>
teardrop2d(r=20);</pre>
<pre class="openscad">include <BOSL2/std.scad>
teardrop2d(d=50);</pre>
Der Standard-Überhangwinkel beträgt 45 Grad, aber du kannst ihn mit dem <code>ang=</code>-Argument anpassen:
<pre class="openscad">include <BOSL2/std.scad>
teardrop2d(d=50, ang=30);</pre>
Wenn du es vorziehst, die Oberseite des Tropfens abzuflachen, um das Bridging zu fördern, kannst du das <code>cap_h=</code>-Argument verwenden:
<pre class="openscad">include <BOSL2/std.scad>
teardrop2d(d=50, cap_h=25);</pre>
<pre class="openscad">include <BOSL2/std.scad>
teardrop2d(d=50, ang=30, cap_h=30);</pre>
Du kannst <code>anchor=</code> und <code>spin=</code> verwenden, genau wie bei anderen anhängbaren Formen. Die Ankerpunkte basieren jedoch auf den äußersten Ausmaßen der Form und sind möglicherweise nicht dort, wo du sie erwartest:
<pre class="openscad">include <BOSL2/std.scad>
teardrop2d(d=50, ang=30, cap_h=30)
show_anchors();</pre>
<span id="verklebte-kreise-glued-circles"></span>
== Verklebte Kreise (Glued Circles) ==
Eine ungewöhnlichere Form, die BOSL2 bietet, sind verklebte Kreise (Glued Circles). Es handelt sich im Grunde um ein Paar von Kreisen, die durch etwas verbunden sind, das wie ein klebriger Meniskus aussieht:
<pre class="openscad">include <BOSL2/std.scad>
glued_circles(d=30, spread=40);</pre>
Die <code>r=</code>/<code>d=</code>-Argumente können den Radius oder Durchmesser der beiden Kreise angeben:
<pre class="openscad">include <BOSL2/std.scad>
glued_circles(r=20, spread=45);</pre>
<pre class="openscad">include <BOSL2/std.scad>
glued_circles(d=40, spread=45);</pre>
Das <code>spread=</code>-Argument gibt den Abstand zwischen den Mittelpunkten der beiden Kreise an:
<pre class="openscad">include <BOSL2/std.scad>
glued_circles(d=30, spread=30);</pre>
<pre class="openscad">include <BOSL2/std.scad>
glued_circles(d=30, spread=40);</pre>
Das <code>tangent=</code>-Argument gibt den Winkel der Tangente des Meniskus an den beiden Kreisen an:
<pre class="openscad">include <BOSL2/std.scad>
glued_circles(d=30, spread=30, tangent=45);</pre>
<pre class="openscad">include <BOSL2/std.scad>
glued_circles(d=30, spread=30, tangent=20);</pre>
<pre class="openscad">include <BOSL2/std.scad>
glued_circles(d=30, spread=30, tangent=-20);</pre>
Eine nützliche Sache, die du tun kannst, ist, einige <code>glued_circle()</code>s in einer Linie anzuordnen und sie dann zu extrudieren, um eine gerippte Wand zu erstellen:
<pre class="openscad">include <BOSL2/std.scad>
$fn=36; s=10;
linear_extrude(height=50,convexity=16,center=true)
xcopies(s*sqrt(2),n=3)
glued_circles(d=s, spread=s*sqrt(2), tangent=45);</pre>
Du kannst <code>anchor=</code> und <code>spin=</code> verwenden, genau wie bei anderen anhängbaren Formen. Die Ankerpunkte basieren jedoch auf den äußersten Ausmaßen der Form und sind möglicherweise nicht dort, wo du sie erwartest:
<pre class="openscad">include <BOSL2/std.scad>
glued_circles(d=40, spread=40, tangent=45)
show_anchors();</pre>
6vxabm5yshjgzkmbgyfnb4f8aan5wop
1093534
1093532
2026-11-08T16:31:16Z
Jowi-ammerbuch
115360
/* Tropfenform 2D (Teardrop2D) */
1093534
wikitext
text/x-wiki
{{MyNavi
|zurück = [[OpenSCAD Benutzerhandbuch/_BOSL2-Distributoren|Zurück]]
|buch = [[OpenSCAD Benutzerhandbuch/_BOSL2|BOSL2-Inhalt]]
|weiter = [[OpenSCAD Benutzerhandbuch/_BOSL2-3D|Weiter]]
}}
== 2D Grundformen (2D Primitive) ==
OpenSCAD bietet zwei eingebaute 2D-Grundformen: <code>square()</code> und <code>circle()</code>. Du kannst sie weiterhin auf die gewohnte Weise verwenden:
<pre class="openscad">include <BOSL2/std.scad>
square([60,40], center=true);</pre>
<pre class="openscad">include <BOSL2/std.scad>
circle(r=50);</pre>
<pre class="openscad">include <BOSL2/std.scad>
circle(d=100, $fn=8);</pre>
Diese Module wurden in der BOSL2-Bibliothek in drei Bereichen erweitert: Verankerung (Anchoring), Drehung (Spin) und Anhängbarkeit (Attachability).
<span id="verankerung-anchoring"></span>
=== Verankerung (Anchoring): ===
Wenn du ein <code>square()</code> erstellst, kannst du angeben, welche Ecke oder Seite am Ursprung verankert werden soll. Dies ersetzt das <code>center=</code>-Argument und ist flexibler. Das <code>anchor=</code>-Argument nimmt einen Vektor als Wert entgegen, der in grober Richtung der Seite oder Ecke zeigt, die du am Ursprung ausrichten möchtest.
=== anchor=[0,1] oder anchor=BACK ===
[[Datei:BOSL2-anchor-0-1.png|mini|zentriert|alternativtext=anchor=[0,1]);|square([60,40], '''anchor=[0,1]''');<br>
Oder: square([60,40], '''anchor=BACK''');]]
Um beispielsweise das '''Zentrum der hinteren Kante am Ursprung''' auszurichten, setzt du den Anker auf <code>[0,1]</code>:
<pre class="openscad">
include <BOSL2/std.scad>
square([60,40], anchor=[0,1]);
</pre>
Mit den leichter verständlichen vordefinierten '''Vektor-Konstanten''':
<pre class="openscad">
include <BOSL2/std.scad>
square([60,40], anchor=BACK+CENTER);
</pre>
=== anchor=[1,-1] oder anchor=RIGHT+FRONT ===
Um die '''vordere rechte Ecke am Ursprung''' auszurichten:
[[Datei:BOSL2-anchor-1 -1.png|mini|zentriert|alternativtext=anchor=RIGHT+FRONT);|square([60,40], '''anchor=[1,-1]''');<br>
Oder: square([60,40], '''anchor=RIGHT+FRONT''');]]
<pre class="openscad">
include <BOSL2/std.scad>
square([60,40], anchor=[1,-1]);
</pre>
'''Mit Vektor-Konstanten:'''
<pre class="openscad">
include <BOSL2/std.scad>
square([60,40], anchor=RIGHT+FRONT);
</pre>
=== anchor=[0,0] oder anchor=CENTER '''Fetter Text'''===
Um es zu '''zentrieren''':
<pre class="openscad">
include <BOSL2/std.scad>
square([60,40], anchor=[0,0]);
</pre>
'''Mit Vektor-Konstanten:'''
<pre class="openscad">
include <BOSL2/std.scad>
square([60,40], anchor=CENTER);
</pre>
=== Vektor-Konstanten am Rechteck ===
Um die Angabe von Vektoren übersichtlicher zu gestalten, sind mehrere Standard-Vektorkonstanten definiert:
[[Datei:BOSL2-anchor-Konstanten-Rechteck.png|gerahmt|zentriert|alternativtext=BOSL2 vordefinierte anchor-Konstanten|Die in BOSL2 vordefinierten anchor-Konstanten]]
{| class="wikitable"
|-
! Konstante
! Richtung
! Wert
|-
| LEFT
| X-
| [-1, 0, 0]
|-
| RIGHT
| X+
| [ 1, 0, 0]
|-
| FRONT / FORWARD / FWD
| Y-
| [ 0,-1, 0]
|-
| BACK
| Y+
| [ 0, 1, 0]
|-
| BOTTOM / BOT / BTM / DOWN
| Z-
| [ 0, 0,-1] (nur 3D)
|-
| TOP / UP
| Z+
| [ 0, 0, 1] (nur 3D)
|-
| CENTER / CTR
| Zentriert
| [ 0, 0, 0]
|}
Beachte, dass du die meisten dieser Konstanten (außer <code>UP</code>/<code>DOWN</code> natürlich) auch für Anker bei 2D-Formen verwenden kannst, obwohl es sich um 3D-Vektoren handelt:
<pre class="openscad">include <BOSL2/std.scad>
square([60,40], anchor=BACK);</pre>
<pre class="openscad">include <BOSL2/std.scad>
square([60,40], anchor=CENTER);</pre>
Du kannst Vektoren addieren, um auf Ecken zu zeigen:
<pre class="openscad">include <BOSL2/std.scad>
square([60,40], anchor=FRONT+RIGHT);</pre>
=== anchor = polar_to_xy ===
Für <code>circle()</code> kann der Ankervektor auf jeden beliebigen '''Punkt des Kreisumfangs''' zeigen:
[[Datei:BOSL2-anchor-polar to xy-circle.png|gerahmt|zentriert|alternativtext=anchor = polar_to_xy|anchor = polar_to_xy(1,Alpha), für Alpha = 0, 45, 90, ...]]
==== Beispiel: anchor=polar_to_xy(1,45) =====
[[Datei:BOSL2-anchor-polar to 1-45-octagon.png|mini|zentriert|alternativtext=circle(d=50, anchor=polar_to_xy(1,45), $fn = 8);|circle(d=50, anchor=polar_to_xy(1,45), $fn = 8);]]
<pre class="openscad">
include <BOSL2/std.scad>
circle(d=50, anchor=polar_to_xy(1,45), $fn = 8);
</pre>
Beachte, dass der Radius für den Anker keine Rolle spielt, da nur die Richtung des Ankers das Ergebnis beeinflusst.
=== show_anchors() ===
[[Datei:BOSL2-show anchor.png|mini|zentriert|show_anchors]]
Du kannst die typischen Ankerpunkte sehen, indem du <code>show_anchors()</code> als Kind der Form übergibst:
<pre class="openscad">include <BOSL2/std.scad>
square([60,40], center=true)
show_anchors();</pre>
<pre class="openscad">include <BOSL2/std.scad>
circle(d=50)
show_anchors();</pre>
<span id="drehung-spin"></span>
=== Drehung (Spin): ===
Die zweite Erweiterung von <code>square()</code> und <code>circle()</code> ist die Drehung (Spin). Wenn du die Form erstellst, kannst du sie mit dem <code>spin=</code>-Argument an Ort und Stelle drehen. Du übergibst einfach die Anzahl der Grad, um die sie im Uhrzeigersinn gedreht werden soll:
<pre class="openscad">include <BOSL2/std.scad>
square([60,40], anchor=CENTER, spin=30);</pre>
Die Verankerung oder Zentrierung erfolgt vor der Drehung:
<pre class="openscad">include <BOSL2/std.scad>
square([60,40], anchor=BACK, spin=30);</pre>
Bei Kreisen kann Spin nützlich sein, wenn auch <code>$fn=</code> angegeben wird:
<pre class="openscad">include <BOSL2/std.scad>
circle(d=50, $fn=6, spin=15);</pre>
Da die Verankerung vor der Drehung erfolgt, kannst du beides zusammen verwenden, um um den Anker herum zu drehen:
<pre class="openscad">include <BOSL2/std.scad>
circle(d=50, $fn=6, anchor=LEFT, spin=15);</pre>
<span id="anhängbarkeit-attachability"></span>
=== Anhängbarkeit (Attachability): ===
Die dritte Erweiterung von <code>square()</code> und <code>circle()</code> ist, dass du sie auf verschiedene Weise an Ankerpunkten zusammenhängen kannst. Dies geschieht, indem du eine Form zum Kind der Form machst, an die du sie anhängen möchtest.
==== Standard (ohne Spez. für anchor oder position) ====
Standardmäßig wird das Kind beim einfachen Untereinanderstellen im Zentrum der Elternform angehängt.
[[Datei:BOSL2-attach-standard-normal.png|mini|zentriert|alternativtext=square(50) #square(50);|square(50) #square(50);<br>
Kind-Objekt (rot) wird ans Zentrum des Elternobjekts angehängt]]
<pre class="openscad">
include <BOSL2/std.scad>
square(50) #square(50);
</pre>
==== anchor für child spezifiziert ====
[[Datei:BOSL2-attach-anchor-LEFTplusFWD.png|mini|zentriert|alternativtext=square(50, center=true) #square([20,40], anchor=LEFT+FWD);|square(50, center=true)#square([20,40], '''anchor=LEFT+FWD''');]]
<pre class="openscad">include <BOSL2/std.scad>
square(50, center=true)
#square([20,40], anchor=LEFT+FWD);</pre>
==== position() ====
[[Datei:BOSL2-attach-position.png|mini|zentriert|alternativtext=position(RIGHT)|square(50) '''position(RIGHT)''' #square(25) '''position(BACK)''' #square(25);]]
Durch Hinzufügen des <code>position()</code>-Moduls kannst du das Kind an jedem Ankerpunkt '''des Elternteils''' positionieren, das "Kindes-Kind wird am Ankerpunkt des übergeordneten Objekts positioniert:
<pre class="openscad">
include <BOSL2/std.scad>
square(50) position(RIGHT) #square(25)
position(BACK) #square(25);
</pre>
==== orient() ====
Ankerpunkte sind jedoch nicht nur Positionen auf dem Elternteil. Sie haben auch eine Ausrichtung. In den meisten Fällen zeigt die Ausrichtung eines Ankerpunkts nach außen, weg von der Fläche der Wand, also im Allgemeinen vom Zentrum der Form weg.
[[Datei:BOSL2-show anchor.png|mini|zentriert|show_anchors]]
Wenn du das Kind so ausrichten möchtest, dass es der Ausrichtung eines Ankerpunkts entspricht, kannst du das <code>orient()</code>-Modul verwenden. Es positioniert das Kind nicht, es dreht es nur:
[[Datei:BOSL2-attach-orient anchor.png|mini|zentriert|alternativtext= orient(anchor=LEFT+BOTTOM)|square(50) '''orient(anchor=LEFT+BOTTOM)''' #square([10,40]);]]
<pre class="openscad">include <BOSL2/std.scad>
square(50)
orient(anchor=LEFT+BOTTOM) #square([10,40]);</pre>
Das geht auch beim '''Kreis (circle)''' mit '''polar_to_xy''':
[[Datei:BOSL2-attach-orient polar to xy circle.png|mini|zentriert|alternativtext=orient(polar_to_xy(1,30))|circle(d=50) ''' orient(polar_to_xy(1,30))''' #square([10,40], anchor=FWD);]]
<pre class="openscad">include <BOSL2/std.scad>
circle(d=50)
orient(polar_to_xy(1,30))
#square([10,40], anchor=FWD);</pre>
==== position() + orient() ====
Du kannst <code>position()</code> und <code>orient()</code> zusammen verwenden, um sowohl zu positionieren als auch an einem Ankerpunkt auszurichten:
[[Datei:BOSL2-attach-position pluss orient polar to xy circle.png|mini|zentriert|alternativtext=position(polar_to_xy(1,30)) orient(polar_to_xy(1,30))|circle(d=50) '''position(polar_to_xy(1,30)) orient(polar_to_xy(1,30))''' #square([10,40], anchor=FWD);]]
<pre class="openscad">include <BOSL2/std.scad>
circle(d=50)
position(polar_to_xy(1,30))
orient(polar_to_xy(1,30))
#square([10,40], anchor=FWD);</pre>
=== attach () mit einem Argument ===
Aber es ist einfacher das <code>attach()</code>-Modul zu verwenden, um beides auf einmal zu erledigen:
[[Datei:BOSL2-attach-position pluss orient polar to xy circle.png|mini|zentriert|alternativtext=attach(polar_to_xy(1,30))|circle(d=50) '''attach(polar_to_xy(1,30))''' #square([10,40], anchor=FWD); ]]
Gleiches Ergebnis, aber übersichtlicherer Code.
<pre class="openscad">include <BOSL2/std.scad>
square(50, center=true)
attach(LEFT+BACK)
#square([10,40], anchor=FWD);</pre>
=== attach () mit zwei Argumenten ===
Anstatt den <code>anchor=</code> im Kind anzugeben, kannst du ein '''zweites Argument''' an <code>attach()</code> übergeben, das ihm sagt, welche Seite des Kindes mit dem Elternteil verbunden werden soll:
<pre class="openscad">
include <BOSL2/std.scad>
circle(d=50) attach(polar_to_xy(1,30), FWD) #square([10,40]);
</pre>
Damit lässt sich der Code noch mehr straffen.
[[Datei:BOSL2-attach-position pluss orient polar to xy circle.png|mini|zentriert|alternativtext=attach(polar_to_xy(1,30), FWD)|circle(d=50) '''attach(polar_to_xy(1,30), FWD)''' #square([10,40]); ]]
<span id="rechtecke-rectangles"></span>
== Rechtecke (Rectangles) ==
=== rect() ===
Die BOSL2-Bibliothek bietet eine Alternative zu <code>square()</code>, die mehr Funktionen unterstützt. Sie heißt <code>rect()</code>. Du kannst sie genauso verwenden wie <code>square()</code>, aber sie bietet auch erweiterte Funktionalität.
=== rect() mit rounding ===
[[Datei:BOSL2-rect rounding.png|mini|zentriert|alternativtext=rounding=10|rect([60,40], '''rounding=10''');]]
rect() erlaubt dir, die Ecken des Rechtecks abzurunden:
<pre class="openscad">include <BOSL2/std.scad>
rect([60,40], rounding=10);</pre>
=== rect() mit chamfer ===
[[Datei:BOSL2-rect chamfer.png|mini|zentriert|alternativtext=rect([60,40], chamfer=10);|rect([60,40], '''chamfer=10''');]]
Du kannst die Ecken des Rechtecks auch abfasen:
<pre class="openscad">include <BOSL2/std.scad>
rect([60,40], chamfer=10);</pre>
=== Unterschiedliche Abrundungen und Fasen an einem Rechteck ===
Du kannst sogar angeben, welche Ecken abgerundet oder abgefast werden. Wenn du eine Liste mit vier Größenwerten an die <code>rounding=</code>- oder <code>chamfer=</code>-Argumente übergibst, erhält jede Ecke ihre eigene Größe. Der Reihe nach geht es von der hinteren rechten Ecke (Quadrant I) gegen den Uhrzeigersinn zur hinteren linken Ecke (Quadrant II), zur vorderen linken Ecke (Quadrant III) und zur vorderen rechten Ecke (Quadrant IV):
Wenn eine Größe als <code>0</code> angegeben wird, gibt es keine Rundung und/oder Fase für die Ecke dieses Quadranten:
<pre class="openscad">include <BOSL2/std.scad>
rect([60,40], rounding=[0,5,10,15]);</pre>
<pre class="openscad">include <BOSL2/std.scad>
rect([60,40], chamfer=[0,5,10,15]);</pre>
Du kannst sowohl <code>rounding=</code>- als auch <code>chamfer=</code>-Argumente angeben, um Rundung und Fase zu mischen, aber nur, wenn du es pro Ecke angibst. Wenn du eine Rundung in einer Ecke möchtest, gib eine Fase von 0 für diese Ecke an und umgekehrt:
[[Datei:BOSL2-rect chamfer-rounding-mixed.png|mini|zentriert|alternativtext=ounding=[5,0,10,0], chamfer=[0,5,0,15]|rect([60,40], '''rounding=[5,0,10,0], chamfer=[0,5,0,15]''');]]
<pre class="openscad">include <BOSL2/std.scad>
rect([60,40], rounding=[5,0,10,0], chamfer=[0,5,0,15]);</pre>
<span id="ellipsen-ellipses"></span>
== Ellipsen (Ellipses) ==
Die BOSL2-Bibliothek bietet auch eine erweiterte Entsprechung von <code>circle()</code>, die <code>ellipse()</code> heißt. Du kannst sie genauso verwenden wie <code>circle()</code>, aber sie bietet auch erweiterte Funktionalität. Zum Beispiel erlaubt sie mehr Kontrolle über ihre Größe.
Da ein Kreis in OpenSCAD nur durch ein regelmäßiges Polygon mit einer Anzahl gerader Seiten angenähert werden kann, kann dies zu Ungenauigkeiten in Größe und Form führen. Um dem entgegenzuwirken, werden auch die Argumente <code>realign=</code> und <code>circum=</code> bereitgestellt.
=== realign= (ellipse-Argument) ===
Das <code>realign=</code>-Argument rotiert, wenn es auf <code>true</code> gesetzt wird, die <code>ellipse()</code> um den halben Winkel zwischen den Polygonseiten:
[[Datei:BOSL2-ellipse-realign.png|mini|zentriert|alternativtext=realign=true|#ellipse(d=100, $fn=8); color("lime") ellipse(d=100, $fn=8, '''realign=true''');]]
<pre class="openscad">
include <BOSL2/std.scad>
#ellipse(d=100, $fn=8);
color("lime") ellipse(d=100, $fn=8, realign=true);
</pre>
=== circum= (ellipse-Argument) ===
[[Datei:BOSL2-ellipse-circum.png|mini|zentriert|alternativtext=circum=true|Vergleich: rot (außen) mit circum=true und blau (innen) ohne circum. Referenz: idealer Kreis in gelb.]]
<pre class="openscad">
include <BOSL2/std.scad>
color("red") ellipse(d=100, $fn=6, circum=true);
color("yellow") ellipse(d=100, $fn=360);
color("blue") ellipse(d=100, $fn=6);
</pre>
Das <code>circum=</code>-Argument bewirkt, wenn es auf true gesetzt wird, dass das Polygon, das die <code>ellipse()</code> bildet, den idealen Kreis '''umschreibt''', anstatt ihn einzuschreiben.
Den idealen Kreis ''einschreiben'':
<pre class="openscad">include <BOSL2/std.scad>
color("green") ellipse(d=100, $fn=360);
ellipse(d=100, $fn=6);</pre>
Den idealen Kreis ''umschreiben'':
<pre class="openscad">include <BOSL2/std.scad>
ellipse(d=100, $fn=6, circum=true);
color("green") ellipse(d=100, $fn=360);</pre>
=== Ellipse mit 2 Radien ===
Das <code>ellipse()</code>-Modul kann, wie der Name schon sagt, mit separaten X- und Y-Radien oder -Durchmessern angegeben werden. Dazu gibst du einfach <code>r=</code> oder <code>d=</code> mit einer Liste von zwei Radien oder Durchmessern an:
[[Datei:BOSL2-ellipse-2Radien.png|mini|zentriert|alternativtext=2 Radien|ellipse('''r=[30,20]''');]]
==== r=[r1,r2] ====
<pre class="openscad">include <BOSL2/std.scad>
ellipse(r=[30,20]);</pre>
==== d=[d1,d2]====
<pre class="openscad">include <BOSL2/std.scad>
ellipse(d=[60,40]);</pre>
==== ellipse mit anchor ====
Wie bei <code>circle()</code> kannst du <code>ellipse()</code>-Formen verankern, drehen und anhängen:
[[Datei:BOSL2-ellipse-anchor.png|mini|zentriert|alternativtext=ellipse mit anchor|ellipse(d=[50,20], '''anchor=BACK'''); #ellipse(d=[50,20], '''anchor=FRONT''');]]
<pre class="openscad">
include <BOSL2/std.scad>
ellipse(d=[50,20], anchor=BACK);
#ellipse(d=[50,20], anchor=FRONT);
</pre>
==== ellipse mit attach ====
[[Datei:BOSL2-ellipse-attach.png|mini|zentriert|alternativtext=ellipse mit attach|ellipse(d=50) '''attach(BACK+RIGHT, FRONT+LEFT)''' #ellipse(d=[40,20]);]]
<pre class="openscad">
include <BOSL2/std.scad>
ellipse(d=50)
attach(BACK+RIGHT, FRONT+LEFT)
ellipse(d=30);
</pre>
<span id="rechtwinklige-dreiecke-right-triangles"></span>
==== ellipse mit spin ====
[[Datei:BOSL2-ellipse-attach-spin-anchor.png|mini|zentriert|alternativtext=spin = 90 bei ellipse|ellipse(d=50) attach(BACK) #ellipse(d=[40,20], '''spin=90''', anchor=LEFT);]]
<pre class="openscad">
include <BOSL2/std.scad>
ellipse(d=50)
attach(BACK)
#ellipse(d=[40,20], spin=90, anchor=LEFT);
</pre>
== Rechtwinklige Dreiecke (Right Triangles) ==
Die BOSL2-Bibliothek bietet eine einfache Möglichkeit, ein 2D-rechtwinkliges Dreieck mit dem <code>right_triangle()</code>-Modul zu erstellen:
[[Datei:BOSL2-right triangle.png|mini|zentriert|alternativtext=right_triangle([40,30])|right_triangle([40,30]);]]
<pre class="openscad">include <BOSL2/std.scad>
right_triangle([40,30]);</pre>
=== xflip() bei right_triangle ===
Du kannst <code>xflip()</code> und <code>yflip()</code> verwenden, um zu ändern, in welchem Quadranten das Dreieck gebildet wird:
[[Datei:BOSL2-right triangle xflip.png|mini|zentriert|alternativtext=right_triange mit xflip()|right_triangle([40,30]); '''xflip()''' #right_triangle([40,30]);]]
<pre class="openscad">include <BOSL2/std.scad>
xflip() right_triangle([40,30]);</pre>
=== yflip() bei right_triangle ===
[[Datei:BOSL2-right triangle yflip.png|mini|zentriert|alternativtext=right_triangle([40,30]) mit yflip()|right_triangle([40,30]); '''yflip()''' #right_triangle([40,30]);]]
<pre class="openscad">include <BOSL2/std.scad>
yflip() right_triangle([40,30]);</pre>
=== xflip() & yflip() bei right_triangle ===
[[Datei:BOSL2-right triangle xflip yflip.png|mini|zentriert|alternativtext=xflip() yflip()|right_triangle([40,30]); xflip() yflip() #right_triangle([40,30]);]]
<pre class="openscad">include <BOSL2/std.scad>
xflip() yflip() right_triangle([40,30]);</pre>
=== spin= bei right_triangle ===
Oder alternativ einfach mit <code>spin=</code> in den richtigen Quadranten drehen:
[[Datei:BOSL2-right triangle spin.png|mini|zentriert|alternativtext=right_triangle([40,30]) mit spin=90)|right_triangle([40,30]);
#right_triangle([40,30], '''spin=90''');]]
<pre class="openscad">include <BOSL2/std.scad>
right_triangle([40,30], spin=90);</pre>
<pre class="openscad">include <BOSL2/std.scad>
right_triangle([40,30], spin=-90);</pre>
Du kannst bei rechtwinkligen Dreiecken auch Verankerung verwenden:
<pre class="openscad">include <BOSL2/std.scad>
right_triangle([40,30], anchor=FWD+RIGHT);</pre>
<span id="trapeze-trapezoids"></span>
== Trapeze (Trapezoids) ==
OpenSCAD bietet keine einfache Möglichkeit, allgemeine 2D-Dreiecke, Trapeze oder Parallelogramme zu erstellen. Die BOSL2-Bibliothek kann all diese Formen mit dem <code>trapezoid()</code>-Modul bereitstellen.
=== Dreieck ===
Um ein gleichseitiges Dreieck zu erstellen, setze einfach eine der Breiten auf null:
[[Datei:BOSL2-trapezoid dreieck.png|mini|zentriert|alternativtext=Dreieck|trapezoid(w1=50, w2=0, h=40);<br>
Dreieck mit Seitenlänge = 50]]
<pre class="openscad">include <BOSL2/std.scad>
trapezoid(w1=50, w2=0, h=40);</pre>
Um ein rechtwinkliges Dreieck zu erstellen, musst du das <code>shift=</code>-Argument verwenden, um die Rückseite des Trapezes entlang der X-Achse zu verschieben:
[[Datei:BOSL2-trapezoid dreieck-rechtwinklig.png|mini|zentriert|alternativtext=Rechtwinkliges Dreieck|trapezoid(w1=50, w2=0, h=50, shift=-25);]]
<pre class="openscad">include <BOSL2/std.scad>
trapezoid(w1=50, w2=0, h=50, shift=-25);</pre>
<pre class="openscad">include <BOSL2/std.scad>
trapezoid(w1=50, w2=0, h=50, shift=25);</pre>
<pre class="openscad">include <BOSL2/std.scad>
trapezoid(w1=0, w2=50, h=50, shift=-25);</pre>
<pre class="openscad">include <BOSL2/std.scad>
trapezoid(w1=0, w2=50, h=50, shift=25);</pre>
=== Trapez ===
Du kannst ein Trapez erstellen, indem du für vorne (<code>w1=</code>) und hinten (<code>w2=</code>) von null verschiedene Breiten angibst:
[[Datei:BOSL2-trapezoid trapez.png|mini|zentriert|alternativtext=Trapez|trapezoid(w1=30, w2=50, h=50);]]
<pre class="openscad">include <BOSL2/std.scad>
trapezoid(w1=30, w2=50, h=50);</pre>
=== Parallelogramm ===
Ein Parallelogramm ist nur eine Frage der Verwendung der gleichen Breite für vorne und hinten, mit einer Verschiebung entlang der X-Achse:
[[Datei:BOSL2-trapezoid parallelogram.png|mini|zentriert|alternativtext=Parallelogramm|trapezoid(w1=50, w2=50, shift=20, h=50);]]
<pre class="openscad">include <BOSL2/std.scad>
trapezoid(w1=50, w2=50, shift=20, h=50);</pre>
=== Viereck ===
Ein Viereck kann erstellt werden, indem ungleiche, von null verschiedene Breiten für vorne (<code>w1=</code>) und hinten (<code>w2=</code>) verwendet werden, wobei die Rückseite entlang der X-Achse verschoben wird:
[[Datei:BOSL2-trapezoid viereck.png|mini|zentriert|alternativtext=Viereck|trapezoid(w1=50, w2=30, shift=20, h=50);]]
<pre class="openscad">include <BOSL2/std.scad>
trapezoid(w1=50, w2=30, shift=20, h=50);</pre>
Du kannst <code>anchor=</code> und <code>spin=</code> verwenden, genau wie bei anderen anhängbaren Formen. Die Ausrichtungen der Ankerpunkte basieren jedoch auf den Seitenwinkeln der Flächen und sind möglicherweise nicht das, was du erwartest:
<pre class="openscad">include <BOSL2/std.scad>
trapezoid(w1=30, w2=50, h=50)
show_anchors();</pre>
<span id="regelmäßige-n-ecke-regular-n-gons"></span>
== Regelmäßige n-Ecke (Regular N-Gons) ==
OpenSCAD ermöglicht es dir, regelmäßige n-Ecke (Fünfeck, Sechseck usw.) zu erstellen, indem du <code>circle()</code> mit <code>$fn</code> verwendest. Obwohl dies prägnant ist, mag es auf den ersten Blick weniger offensichtlich sein:
<pre class="openscad">include <BOSL2/std.scad>
circle(d=50, $fn=5);</pre>
Die BOSL2-Bibliothek hat Module, die für gängige n-Ecke klarer benannt sind:
=== Pentagon (d=<Durchmesser>) ===
[[Datei:BOSL2-Pentagon.png|mini|zentriert|alternativtext=Pentagon|pentagon(d=50);]]
<pre class="openscad">include <BOSL2/std.scad>
pentagon(d=50);</pre>
=== Hexagon (d=<Durchmesser>) ===
[[Datei:BOSL2-Hexagon.png|mini|zentriert|alternativtext=Hexagon| hexagon(d=50);]]
<pre class="openscad">include <BOSL2/std.scad>
hexagon(d=50);</pre>
=== Octagon (d= <Durchmesser>) ===
[[Datei:BOSL2-Octagon.png|mini|zentriert|alternativtext=octagon(d=50);|octagon(d=50);]]
<pre class="openscad">include <BOSL2/std.scad>
octagon(d=50);</pre>
=== regular_ngon (n=<Seitenanzahl>, d=<Durchmesser>) ===
[[Datei:BOSL2-regular ngon.png|mini|zentriert|alternativtext=regular_ngon|regular_ngon(n=7, d=50);]]
<pre class="openscad">include <BOSL2/std.scad>
regular_ngon(n=7, d=50);</pre>
=== side=<Seitenlänge> ===
Diese Module bieten dir auch zusätzliche Funktionalität. Sie können nach Seitenlänge dimensioniert werden:
[[Datei:BOSL2-Hexagon side50.png|mini|zentriert|alternativtext=hexagon(side=50);|hexagon(side=50);]]
<pre class="openscad">include <BOSL2/std.scad>
pentagon(side=50);</pre>
=== ir = <Innenradius> / id = <Innendurchmesser> ===
Sie können nach dem Radius/Durchmesser des umschriebenen Kreises (Innenkreis) dimensioniert werden:
[[Datei:BOSL2-Pentagon Innenradius.png|mini|zentriert|alternativtext=Innenradius|color("red") pentagon('''ir=25'''); color("yellow") circle(r=25,$fn=100);]]
<pre class="openscad">include <BOSL2/std.scad>
pentagon(ir=25);
pentagon(id=50);</pre>
=== realign=true/false ===
Die Polygone können um eine halbe Seite gedreht werden:
[[Datei:BOSL2-Pentagon realign.png|mini|zentriert|alternativtext=realign|pentagon(d=50, '''realign=false'''); #pentagon(d=50, '''realign=true''');]]
<pre class="openscad">include <BOSL2/std.scad>
left(30) pentagon(d=50, realign=true);
right(30) pentagon(d=50, realign=false);</pre>
=== rounding = <Rundung> ===
Die BOSL2-Polygone können abgerundet werden:
[[Datei:BOSL2-Polygon-rounding.png|mini|zentriert|alternativtext=rounding|pentagon(d=50, '''rounding=5''');]]
<pre class="openscad">include <BOSL2/std.scad>
pentagon(d=50, rounding=5);</pre>
=== show_anchors() ===
Die BOSL2-Polygone haben auch ein etwas anderes Anhangsverhalten als die regulären Polygone, die über $fn=<Seitenanzahl> erzeugt werden.
Ein Kreis mit einem kleinen <code>$fn=</code> hängt Dinge am idealen Kreis an, nicht entlang des erstellten Polygons:
[[Datei:BOSL2-polygon-outcircle-anchors.png|mini|zentriert|alternativtext=anchors Außenkreis|color("green") stroke(circle(d=50), closed=true); circle(d=50,$fn=6) show_anchors();]]
<pre class="openscad">include <BOSL2/std.scad>
color("green") stroke(circle(d=50), closed=true);
circle(d=50,$fn=6)
show_anchors();</pre>
Während ein BOSL2-n-Eck entlang des Polygons selbst (direkt) anhängt:
[[Datei:BOSL2-polygon-direct-anchors.png|mini|zentriert|alternativtext=anchors BOSL2 Polygone direkt|color("green") stroke(circle(d=50), closed=true); circle(d=50,$fn=6) show_anchors();]]
<pre class="openscad">include <BOSL2/std.scad>
hexagon(d=50)
show_anchors(custom=false);</pre>
Du kannst <code>anchor=</code> und <code>spin=</code> verwenden, genau wie bei anderen anhängbaren Formen. Die Ankerpunkte basieren jedoch darauf, wo der Ankervektor die Seite des n-Ecks schneiden würde, und sind möglicherweise nicht dort, wo du sie erwartest:
[[Datei:BOSL2-Pentagon-anchor.png|mini|zentriert|alternativtext=n-Polygon anchor|pentagon(d=50, '''anchor=FRONT+LEFT''') show_anchors(custom=false);]]
<pre class="openscad">include <BOSL2/std.scad>
pentagon(d=50, anchor=FRONT+LEFT)
show_anchors(custom=false);</pre>
=== Ankerpunkte für Seiten und Spitzen ===
n-Ecke haben auch benannte Ankerpunkte für ihre Seiten und Spitzen:
[[Datei:BOSL2-anchor-Spitzen-Seiten.png|mini|zentriert|alternativtext=Anker für Seiten und Spitzen|Spezielle Anker für die Spitzen und Seiten eines Pentagons (mit TikZ unter LaTeX erstellt)]]
Beachte, dass die Ankernamen in "" gesetzt werden müssen.
Zum Beispiel:
[[Datei:BOSL2-Pentagon anchor tip1.png|mini|zentriert|alternativtext=anchor="tip1"|pentagon(d=30, '''anchor="tip1" ''');]]
<pre class="openscad">include <BOSL2/std.scad>
pentagon(d=30, anchor="tip1");</pre>
<span id="sterne-stars"></span>
Beispiel mit attach():
[[Datei:BOSL2-anchor-Spitzen-Seiten attach.png|mini|zentriert|alternativtext=anchor="side2"|pentagon(d=30, anchor="side2") '''attach("tip0")''' circle(r=3,$fn=36);]]
<pre class="openscad">
include <BOSL2/std.scad>
pentagon(d=30, anchor="side2") attach("tip0") circle(r=3,$fn=36);
</pre>
== Sterne (Stars) ==
=== star() mit n, ir/id und or/od ===
Die BOSL2-Bibliothek hat Sterne als grundlegend unterstützte Form. Sie können eine beliebige Anzahl '''n''' von '''Spitzen''' haben. Du kannst die Form eines Sterns durch Spitzenanzahl, '''innere und äußere Scheitelpunkt-Radius/-Durchmesser''' angeben:
[[Datei:BOSL2-star n5 ir15 dr30-Veranschaulichung.png|mini|zentriert|alternativtext=Innerer und äußerer Radius bei star()|Veranschaulichung von den Parameter '''ir''' (oder id) und '''or''' (oder od). ''ir'' gibt den inneren Radius und or den äußeren Radius an. Die Anzahl der Zacken ist hier n=5. Siehe Code unten.]]
Begonnen wird der Stern mit einem Zacken nach rechts auf der X-Achse.
<pre class="openscad">
include <BOSL2/std.scad>
#circle(30, $fn=60);
color("blue") star(n=5, ir=15, or=30);
#circle(15, $fn=60);
color("darkblue") fwd(35) text("or=30", halign = "center", size=3);
color("yellow") text("ir=15",halign = "center", size=3, valign="center");
</pre>
=== star() mit Spannweite d ===
Statt '''od''' kann auch einfach '''d''' als Parameter verwendet werden.
[[Datei:BOSL2-star n3 id10 d50.png|mini|zentriert|alternativtext=star(n=3, id=10, d=50);|star(n=3, id=10, d=50);]]
<pre class="openscad">include <BOSL2/std.scad>
star(n=3, id=10, d=50);</pre>
[[Datei:BOSL2-star n5 id15 r25.png|mini|zentriert|alternativtext=star(n=5, id=15, r=25);|star(n=5, id=15, r=25);]]
<pre class="openscad">include <BOSL2/std.scad>
star(n=5, id=15, r=25);</pre>
[[Datei:BOSL2-star n10 id30 d50.png|mini|zentriert|alternativtext=star(n=10, id=30, d=50);|star(n=10, id=30, d=50);]]
<pre class="openscad">include <BOSL2/std.scad>
star(n=10, id=30, d=50);</pre>
=== star (n = <Spitzenanzahl>, step = <Anzahl zu überspringender Punkte>) ===
Oder du kannst die Sternform durch Spitzenanzahl '''n''' und Anzahl '''step''' der zu überspringenden Punkte angeben:
[[Datei:BOSL2-star n7 step2 d50.png|mini|zentriert|alternativtext=step|star(n=7, step=2, d=50);]]
<pre class="openscad">include <BOSL2/std.scad>
star(n=7, step=2, d=50);</pre>
[[Datei:BOSL2-star n7 step3 d50.png|mini|zentriert|alternativtext=step=3|star(n=7, step=3, d=50);]]
<pre class="openscad">include <BOSL2/std.scad>
star(n=7, step=3, d=50);</pre>
=== star() mit realign ===
Wenn dem <code>realign=</code>-Argument ein true-Wert übergeben wird, wird der Stern um einen halben Spitzenwinkel gedreht:
<pre class="openscad">include <BOSL2/std.scad>
left(30) star(n=5, step=2, d=50);
right(30) star(n=5, step=2, d=50, realign=true);</pre>
=== star() mit align_tip=<Anker> ===
Das <code>align_tip=</code>-Argument kann mit einem Vektor angegeben werden, damit du die erste Spitze in eine bestimmte Richtung ausrichten kannst:
[[Datei:BOSL2-star n5 align tip anchor tip0.png|mini|zentriert|alternativtext=align_tip=BACK|star(n=5, ir=15, or=30, align_tip=BACK) attach("tip0") color("blue") anchor_arrow2d();]]
<pre class="openscad">include <BOSL2/std.scad>
star(n=5, ir=15, or=30, align_tip=BACK)
attach("tip0") color("blue") anchor_arrow2d();</pre>
=== star() mit align_pit=<Anker> ===
Ebenso kann die erste Einkerbung oder Einbuchtung mit <code>align_pit=</code> in Richtung eines bestimmten Vektors ausgerichtet werden:
[[Datei:BOSL2-star n5 align pit BACK attach tip0.png|mini|zentriert|alternativtext=align_pit=BACK|star(n=5, ir=15, or=30, '''align_pit=BACK''') '''attach("tip0")''' color("blue") anchor_arrow2d();]]
<pre class="openscad">include <BOSL2/std.scad>
star(n=5, ir=15, or=30, align_pit=BACK)
attach("pit0") color("blue") anchor_arrow2d();</pre>
Du kannst <code>anchor=</code> und <code>spin=</code> verwenden, genau wie bei anderen anhängbaren Formen. Die Ankerpunkte basieren jedoch auf den äußersten Ausmaßen der Form und sind möglicherweise nicht dort, wo du sie erwartest:
[[Datei:BOSL2-star n5 anchor LEFT-show anchers.png|mini|zentriert|alternativtext=anchor=LEFT|star(n=5, step=2, d=50,'''anchor=LEFT''') '''show_anchors(custom=false)''';]]
<pre class="openscad">include <BOSL2/std.scad>
star(n=5, step=2, d=50)
show_anchors(custom=false);</pre>
=== Benannte Ankerpunkte bei star() ===
Sterne haben auch benannte Ankerpunkte für ihre Gruben, Spitzen und Mittelpunkte zwischen den Spitzen:
[[Datei:BOSL2-star n5 benannteAnker.png|mini|zentriert|alternativtext=benannten Ankerpunkte in star()|Zuordnung der benannten Ankerpunkte in star(). Spitzen beginnen mit "tipt0", Einkerbungen mit pit0.]]
==== Beispiel 1: anchor="tip0" attach("pit0") ====
[[Datei:BOSL2-star-n5 ir=15 or30 anchor tip0 pit0.png|mini|zentriert|alternativtext=anchor="tip0"|star(n=5, ir=15, or=30, anchor="tip0") attach("pit0") #circle(3);]]
<pre class="openscad">
include <BOSL2/std.scad>
star(n=5, ir=15, or=30, anchor="tip0") attach("pit0") #circle(3);
</pre>
==== Beispiel 2: anchor="pit0" attach("tip0") ====
[[Datei:BOSL2-star n5 anchor pit0 attach tip0.png|mini|zentriert|alternativtext=anchor="pit0" attach("tip0")|star(n=5, ir=15, or=30, anchor="pit0") attach("tip0") #circle(3);]]
<pre class="openscad">
include <BOSL2/std.scad>
star(n=5, ir=15, or=30, anchor="pit0") attach("tip0") #circle(3);
</pre>
<span id="tropfenform-2d-teardrop2d"></span>
== Tropfenform 2D (Teardrop2D) ==
Beim 3D-Druck möchtest du oft ein kreisförmiges Loch in eine vertikale Wand machen. Wenn das Loch jedoch zu groß ist, kann der Überhang an der Oberseite des Lochs Probleme beim Drucken auf einem FDM/FFF-Drucker verursachen. Wenn du kein Stützmaterial verwenden möchtest, kannst du einfach die Tropfenform verwenden. Das <code>teardrop2d()</code>-Modul ermöglicht es dir, eine 2D-Version der Tropfenform zu erstellen, damit du sie später extrudieren kannst:
[[Datei:BOSL2-teardrop2d r20.png|mini|zentriert|alternativtext=teardrop2d(r=20);|teardrop2d(r=20);]]
<pre class="openscad">include <BOSL2/std.scad>
teardrop2d(r=20);</pre>
=== Extrudiert als tropfenförmige Aussparung:
[[Datei:BOSL2-teardrop2d Loch linear extrudiert.png|mini|zentriert|alternativtext=Lineares Extrudieren eines Quadrats mit zentrierter Tropfenform|linear_extrude(5) { diff() { rect(50) attach(CTR,CTR, inside=true) teardrop2d(d=20); }}]]
<pre class="openscad">
include <BOSL2/std.scad>
linear_extrude(5) {
diff() {
rect(50)
attach(CTR,CTR, inside=true)
teardrop2d(d=20);
}}</pre>
=== ang=<Überhangwinkel> ===
Der Standard-Überhangwinkel beträgt 45 Grad, aber du kannst ihn mit dem <code>ang=</code>-Argument anpassen:
[[Datei:BOSL2-teardrop2d ang20.png|mini|zentriert|alternativtext=teardrop2d(d=50, ang=20);|teardrop2d(d=50, ang=20);]]
<pre class="openscad">include <BOSL2/std.scad>
teardrop2d(d=50, ang=20);</pre>
=== cap_h=<Kapphöhe> ===
Wenn du es vorziehst, die Oberseite des Tropfens abzuflachen, um das Bridging zu fördern, kannst du das <code>cap_h=</code>-Argument verwenden:
[[Datei:BOSL2-teardrop2d ang20 cap h38c.png|mini|zentriert|alternativtext=teardrop2d(d=50, ang=20, cap_h=38);|teardrop2d(d=50, ang=20, '''cap_h=38''');]]
<pre class="openscad">include <BOSL2/std.scad>
teardrop2d(d=50, ang=20, cap_h=38);</pre>
=== show_anchors() bei teardrop2d ===
Du kannst <code>anchor=</code> und <code>spin=</code> verwenden, genau wie bei anderen anhängbaren Formen. Die Ankerpunkte basieren jedoch auf den äußersten Ausmaßen der Form und sind möglicherweise nicht dort, wo du sie erwartest:
[[Datei:BOSL2-teardrop2d anchorBACK show anchors.png|mini|zentriert|alternativtext=teardrop2d(d=50, anchor=BACK) show_anchors();|teardrop2d(d=50, anchor=BACK) show_anchors();]]
<pre class="openscad">
include <BOSL2/std.scad>
teardrop2d(d=50, anchor=BACK)
show_anchors();
</pre>
<span id="verklebte-kreise-glued-circles"></span>
== Verklebte Kreise (Glued Circles) ==
Eine ungewöhnlichere Form, die BOSL2 bietet, sind verklebte Kreise (Glued Circles). Es handelt sich im Grunde um ein Paar von Kreisen, die durch etwas verbunden sind, das wie ein klebriger Meniskus aussieht:
<pre class="openscad">include <BOSL2/std.scad>
glued_circles(d=30, spread=40);</pre>
Die <code>r=</code>/<code>d=</code>-Argumente können den Radius oder Durchmesser der beiden Kreise angeben:
<pre class="openscad">include <BOSL2/std.scad>
glued_circles(r=20, spread=45);</pre>
<pre class="openscad">include <BOSL2/std.scad>
glued_circles(d=40, spread=45);</pre>
Das <code>spread=</code>-Argument gibt den Abstand zwischen den Mittelpunkten der beiden Kreise an:
<pre class="openscad">include <BOSL2/std.scad>
glued_circles(d=30, spread=30);</pre>
<pre class="openscad">include <BOSL2/std.scad>
glued_circles(d=30, spread=40);</pre>
Das <code>tangent=</code>-Argument gibt den Winkel der Tangente des Meniskus an den beiden Kreisen an:
<pre class="openscad">include <BOSL2/std.scad>
glued_circles(d=30, spread=30, tangent=45);</pre>
<pre class="openscad">include <BOSL2/std.scad>
glued_circles(d=30, spread=30, tangent=20);</pre>
<pre class="openscad">include <BOSL2/std.scad>
glued_circles(d=30, spread=30, tangent=-20);</pre>
Eine nützliche Sache, die du tun kannst, ist, einige <code>glued_circle()</code>s in einer Linie anzuordnen und sie dann zu extrudieren, um eine gerippte Wand zu erstellen:
<pre class="openscad">include <BOSL2/std.scad>
$fn=36; s=10;
linear_extrude(height=50,convexity=16,center=true)
xcopies(s*sqrt(2),n=3)
glued_circles(d=s, spread=s*sqrt(2), tangent=45);</pre>
Du kannst <code>anchor=</code> und <code>spin=</code> verwenden, genau wie bei anderen anhängbaren Formen. Die Ankerpunkte basieren jedoch auf den äußersten Ausmaßen der Form und sind möglicherweise nicht dort, wo du sie erwartest:
<pre class="openscad">include <BOSL2/std.scad>
glued_circles(d=40, spread=40, tangent=45)
show_anchors();</pre>
s168vyyqpoj3of59ngn01008wyp9fu5
1093535
1093534
2026-11-08T17:08:00Z
Jowi-ammerbuch
115360
/* Verklebte Kreise (Glued Circles) */
1093535
wikitext
text/x-wiki
{{MyNavi
|zurück = [[OpenSCAD Benutzerhandbuch/_BOSL2-Distributoren|Zurück]]
|buch = [[OpenSCAD Benutzerhandbuch/_BOSL2|BOSL2-Inhalt]]
|weiter = [[OpenSCAD Benutzerhandbuch/_BOSL2-3D|Weiter]]
}}
== 2D Grundformen (2D Primitive) ==
OpenSCAD bietet zwei eingebaute 2D-Grundformen: <code>square()</code> und <code>circle()</code>. Du kannst sie weiterhin auf die gewohnte Weise verwenden:
<pre class="openscad">include <BOSL2/std.scad>
square([60,40], center=true);</pre>
<pre class="openscad">include <BOSL2/std.scad>
circle(r=50);</pre>
<pre class="openscad">include <BOSL2/std.scad>
circle(d=100, $fn=8);</pre>
Diese Module wurden in der BOSL2-Bibliothek in drei Bereichen erweitert: Verankerung (Anchoring), Drehung (Spin) und Anhängbarkeit (Attachability).
<span id="verankerung-anchoring"></span>
=== Verankerung (Anchoring): ===
Wenn du ein <code>square()</code> erstellst, kannst du angeben, welche Ecke oder Seite am Ursprung verankert werden soll. Dies ersetzt das <code>center=</code>-Argument und ist flexibler. Das <code>anchor=</code>-Argument nimmt einen Vektor als Wert entgegen, der in grober Richtung der Seite oder Ecke zeigt, die du am Ursprung ausrichten möchtest.
=== anchor=[0,1] oder anchor=BACK ===
[[Datei:BOSL2-anchor-0-1.png|mini|zentriert|alternativtext=anchor=[0,1]);|square([60,40], '''anchor=[0,1]''');<br>
Oder: square([60,40], '''anchor=BACK''');]]
Um beispielsweise das '''Zentrum der hinteren Kante am Ursprung''' auszurichten, setzt du den Anker auf <code>[0,1]</code>:
<pre class="openscad">
include <BOSL2/std.scad>
square([60,40], anchor=[0,1]);
</pre>
Mit den leichter verständlichen vordefinierten '''Vektor-Konstanten''':
<pre class="openscad">
include <BOSL2/std.scad>
square([60,40], anchor=BACK+CENTER);
</pre>
=== anchor=[1,-1] oder anchor=RIGHT+FRONT ===
Um die '''vordere rechte Ecke am Ursprung''' auszurichten:
[[Datei:BOSL2-anchor-1 -1.png|mini|zentriert|alternativtext=anchor=RIGHT+FRONT);|square([60,40], '''anchor=[1,-1]''');<br>
Oder: square([60,40], '''anchor=RIGHT+FRONT''');]]
<pre class="openscad">
include <BOSL2/std.scad>
square([60,40], anchor=[1,-1]);
</pre>
'''Mit Vektor-Konstanten:'''
<pre class="openscad">
include <BOSL2/std.scad>
square([60,40], anchor=RIGHT+FRONT);
</pre>
=== anchor=[0,0] oder anchor=CENTER '''Fetter Text'''===
Um es zu '''zentrieren''':
<pre class="openscad">
include <BOSL2/std.scad>
square([60,40], anchor=[0,0]);
</pre>
'''Mit Vektor-Konstanten:'''
<pre class="openscad">
include <BOSL2/std.scad>
square([60,40], anchor=CENTER);
</pre>
=== Vektor-Konstanten am Rechteck ===
Um die Angabe von Vektoren übersichtlicher zu gestalten, sind mehrere Standard-Vektorkonstanten definiert:
[[Datei:BOSL2-anchor-Konstanten-Rechteck.png|gerahmt|zentriert|alternativtext=BOSL2 vordefinierte anchor-Konstanten|Die in BOSL2 vordefinierten anchor-Konstanten]]
{| class="wikitable"
|-
! Konstante
! Richtung
! Wert
|-
| LEFT
| X-
| [-1, 0, 0]
|-
| RIGHT
| X+
| [ 1, 0, 0]
|-
| FRONT / FORWARD / FWD
| Y-
| [ 0,-1, 0]
|-
| BACK
| Y+
| [ 0, 1, 0]
|-
| BOTTOM / BOT / BTM / DOWN
| Z-
| [ 0, 0,-1] (nur 3D)
|-
| TOP / UP
| Z+
| [ 0, 0, 1] (nur 3D)
|-
| CENTER / CTR
| Zentriert
| [ 0, 0, 0]
|}
Beachte, dass du die meisten dieser Konstanten (außer <code>UP</code>/<code>DOWN</code> natürlich) auch für Anker bei 2D-Formen verwenden kannst, obwohl es sich um 3D-Vektoren handelt:
<pre class="openscad">include <BOSL2/std.scad>
square([60,40], anchor=BACK);</pre>
<pre class="openscad">include <BOSL2/std.scad>
square([60,40], anchor=CENTER);</pre>
Du kannst Vektoren addieren, um auf Ecken zu zeigen:
<pre class="openscad">include <BOSL2/std.scad>
square([60,40], anchor=FRONT+RIGHT);</pre>
=== anchor = polar_to_xy ===
Für <code>circle()</code> kann der Ankervektor auf jeden beliebigen '''Punkt des Kreisumfangs''' zeigen:
[[Datei:BOSL2-anchor-polar to xy-circle.png|gerahmt|zentriert|alternativtext=anchor = polar_to_xy|anchor = polar_to_xy(1,Alpha), für Alpha = 0, 45, 90, ...]]
==== Beispiel: anchor=polar_to_xy(1,45) =====
[[Datei:BOSL2-anchor-polar to 1-45-octagon.png|mini|zentriert|alternativtext=circle(d=50, anchor=polar_to_xy(1,45), $fn = 8);|circle(d=50, anchor=polar_to_xy(1,45), $fn = 8);]]
<pre class="openscad">
include <BOSL2/std.scad>
circle(d=50, anchor=polar_to_xy(1,45), $fn = 8);
</pre>
Beachte, dass der Radius für den Anker keine Rolle spielt, da nur die Richtung des Ankers das Ergebnis beeinflusst.
=== show_anchors() ===
[[Datei:BOSL2-show anchor.png|mini|zentriert|show_anchors]]
Du kannst die typischen Ankerpunkte sehen, indem du <code>show_anchors()</code> als Kind der Form übergibst:
<pre class="openscad">include <BOSL2/std.scad>
square([60,40], center=true)
show_anchors();</pre>
<pre class="openscad">include <BOSL2/std.scad>
circle(d=50)
show_anchors();</pre>
<span id="drehung-spin"></span>
=== Drehung (Spin): ===
Die zweite Erweiterung von <code>square()</code> und <code>circle()</code> ist die Drehung (Spin). Wenn du die Form erstellst, kannst du sie mit dem <code>spin=</code>-Argument an Ort und Stelle drehen. Du übergibst einfach die Anzahl der Grad, um die sie im Uhrzeigersinn gedreht werden soll:
<pre class="openscad">include <BOSL2/std.scad>
square([60,40], anchor=CENTER, spin=30);</pre>
Die Verankerung oder Zentrierung erfolgt vor der Drehung:
<pre class="openscad">include <BOSL2/std.scad>
square([60,40], anchor=BACK, spin=30);</pre>
Bei Kreisen kann Spin nützlich sein, wenn auch <code>$fn=</code> angegeben wird:
<pre class="openscad">include <BOSL2/std.scad>
circle(d=50, $fn=6, spin=15);</pre>
Da die Verankerung vor der Drehung erfolgt, kannst du beides zusammen verwenden, um um den Anker herum zu drehen:
<pre class="openscad">include <BOSL2/std.scad>
circle(d=50, $fn=6, anchor=LEFT, spin=15);</pre>
<span id="anhängbarkeit-attachability"></span>
=== Anhängbarkeit (Attachability): ===
Die dritte Erweiterung von <code>square()</code> und <code>circle()</code> ist, dass du sie auf verschiedene Weise an Ankerpunkten zusammenhängen kannst. Dies geschieht, indem du eine Form zum Kind der Form machst, an die du sie anhängen möchtest.
==== Standard (ohne Spez. für anchor oder position) ====
Standardmäßig wird das Kind beim einfachen Untereinanderstellen im Zentrum der Elternform angehängt.
[[Datei:BOSL2-attach-standard-normal.png|mini|zentriert|alternativtext=square(50) #square(50);|square(50) #square(50);<br>
Kind-Objekt (rot) wird ans Zentrum des Elternobjekts angehängt]]
<pre class="openscad">
include <BOSL2/std.scad>
square(50) #square(50);
</pre>
==== anchor für child spezifiziert ====
[[Datei:BOSL2-attach-anchor-LEFTplusFWD.png|mini|zentriert|alternativtext=square(50, center=true) #square([20,40], anchor=LEFT+FWD);|square(50, center=true)#square([20,40], '''anchor=LEFT+FWD''');]]
<pre class="openscad">include <BOSL2/std.scad>
square(50, center=true)
#square([20,40], anchor=LEFT+FWD);</pre>
==== position() ====
[[Datei:BOSL2-attach-position.png|mini|zentriert|alternativtext=position(RIGHT)|square(50) '''position(RIGHT)''' #square(25) '''position(BACK)''' #square(25);]]
Durch Hinzufügen des <code>position()</code>-Moduls kannst du das Kind an jedem Ankerpunkt '''des Elternteils''' positionieren, das "Kindes-Kind wird am Ankerpunkt des übergeordneten Objekts positioniert:
<pre class="openscad">
include <BOSL2/std.scad>
square(50) position(RIGHT) #square(25)
position(BACK) #square(25);
</pre>
==== orient() ====
Ankerpunkte sind jedoch nicht nur Positionen auf dem Elternteil. Sie haben auch eine Ausrichtung. In den meisten Fällen zeigt die Ausrichtung eines Ankerpunkts nach außen, weg von der Fläche der Wand, also im Allgemeinen vom Zentrum der Form weg.
[[Datei:BOSL2-show anchor.png|mini|zentriert|show_anchors]]
Wenn du das Kind so ausrichten möchtest, dass es der Ausrichtung eines Ankerpunkts entspricht, kannst du das <code>orient()</code>-Modul verwenden. Es positioniert das Kind nicht, es dreht es nur:
[[Datei:BOSL2-attach-orient anchor.png|mini|zentriert|alternativtext= orient(anchor=LEFT+BOTTOM)|square(50) '''orient(anchor=LEFT+BOTTOM)''' #square([10,40]);]]
<pre class="openscad">include <BOSL2/std.scad>
square(50)
orient(anchor=LEFT+BOTTOM) #square([10,40]);</pre>
Das geht auch beim '''Kreis (circle)''' mit '''polar_to_xy''':
[[Datei:BOSL2-attach-orient polar to xy circle.png|mini|zentriert|alternativtext=orient(polar_to_xy(1,30))|circle(d=50) ''' orient(polar_to_xy(1,30))''' #square([10,40], anchor=FWD);]]
<pre class="openscad">include <BOSL2/std.scad>
circle(d=50)
orient(polar_to_xy(1,30))
#square([10,40], anchor=FWD);</pre>
==== position() + orient() ====
Du kannst <code>position()</code> und <code>orient()</code> zusammen verwenden, um sowohl zu positionieren als auch an einem Ankerpunkt auszurichten:
[[Datei:BOSL2-attach-position pluss orient polar to xy circle.png|mini|zentriert|alternativtext=position(polar_to_xy(1,30)) orient(polar_to_xy(1,30))|circle(d=50) '''position(polar_to_xy(1,30)) orient(polar_to_xy(1,30))''' #square([10,40], anchor=FWD);]]
<pre class="openscad">include <BOSL2/std.scad>
circle(d=50)
position(polar_to_xy(1,30))
orient(polar_to_xy(1,30))
#square([10,40], anchor=FWD);</pre>
=== attach () mit einem Argument ===
Aber es ist einfacher das <code>attach()</code>-Modul zu verwenden, um beides auf einmal zu erledigen:
[[Datei:BOSL2-attach-position pluss orient polar to xy circle.png|mini|zentriert|alternativtext=attach(polar_to_xy(1,30))|circle(d=50) '''attach(polar_to_xy(1,30))''' #square([10,40], anchor=FWD); ]]
Gleiches Ergebnis, aber übersichtlicherer Code.
<pre class="openscad">include <BOSL2/std.scad>
square(50, center=true)
attach(LEFT+BACK)
#square([10,40], anchor=FWD);</pre>
=== attach () mit zwei Argumenten ===
Anstatt den <code>anchor=</code> im Kind anzugeben, kannst du ein '''zweites Argument''' an <code>attach()</code> übergeben, das ihm sagt, welche Seite des Kindes mit dem Elternteil verbunden werden soll:
<pre class="openscad">
include <BOSL2/std.scad>
circle(d=50) attach(polar_to_xy(1,30), FWD) #square([10,40]);
</pre>
Damit lässt sich der Code noch mehr straffen.
[[Datei:BOSL2-attach-position pluss orient polar to xy circle.png|mini|zentriert|alternativtext=attach(polar_to_xy(1,30), FWD)|circle(d=50) '''attach(polar_to_xy(1,30), FWD)''' #square([10,40]); ]]
<span id="rechtecke-rectangles"></span>
== Rechtecke (Rectangles) ==
=== rect() ===
Die BOSL2-Bibliothek bietet eine Alternative zu <code>square()</code>, die mehr Funktionen unterstützt. Sie heißt <code>rect()</code>. Du kannst sie genauso verwenden wie <code>square()</code>, aber sie bietet auch erweiterte Funktionalität.
=== rect() mit rounding ===
[[Datei:BOSL2-rect rounding.png|mini|zentriert|alternativtext=rounding=10|rect([60,40], '''rounding=10''');]]
rect() erlaubt dir, die Ecken des Rechtecks abzurunden:
<pre class="openscad">include <BOSL2/std.scad>
rect([60,40], rounding=10);</pre>
=== rect() mit chamfer ===
[[Datei:BOSL2-rect chamfer.png|mini|zentriert|alternativtext=rect([60,40], chamfer=10);|rect([60,40], '''chamfer=10''');]]
Du kannst die Ecken des Rechtecks auch abfasen:
<pre class="openscad">include <BOSL2/std.scad>
rect([60,40], chamfer=10);</pre>
=== Unterschiedliche Abrundungen und Fasen an einem Rechteck ===
Du kannst sogar angeben, welche Ecken abgerundet oder abgefast werden. Wenn du eine Liste mit vier Größenwerten an die <code>rounding=</code>- oder <code>chamfer=</code>-Argumente übergibst, erhält jede Ecke ihre eigene Größe. Der Reihe nach geht es von der hinteren rechten Ecke (Quadrant I) gegen den Uhrzeigersinn zur hinteren linken Ecke (Quadrant II), zur vorderen linken Ecke (Quadrant III) und zur vorderen rechten Ecke (Quadrant IV):
Wenn eine Größe als <code>0</code> angegeben wird, gibt es keine Rundung und/oder Fase für die Ecke dieses Quadranten:
<pre class="openscad">include <BOSL2/std.scad>
rect([60,40], rounding=[0,5,10,15]);</pre>
<pre class="openscad">include <BOSL2/std.scad>
rect([60,40], chamfer=[0,5,10,15]);</pre>
Du kannst sowohl <code>rounding=</code>- als auch <code>chamfer=</code>-Argumente angeben, um Rundung und Fase zu mischen, aber nur, wenn du es pro Ecke angibst. Wenn du eine Rundung in einer Ecke möchtest, gib eine Fase von 0 für diese Ecke an und umgekehrt:
[[Datei:BOSL2-rect chamfer-rounding-mixed.png|mini|zentriert|alternativtext=ounding=[5,0,10,0], chamfer=[0,5,0,15]|rect([60,40], '''rounding=[5,0,10,0], chamfer=[0,5,0,15]''');]]
<pre class="openscad">include <BOSL2/std.scad>
rect([60,40], rounding=[5,0,10,0], chamfer=[0,5,0,15]);</pre>
<span id="ellipsen-ellipses"></span>
== Ellipsen (Ellipses) ==
Die BOSL2-Bibliothek bietet auch eine erweiterte Entsprechung von <code>circle()</code>, die <code>ellipse()</code> heißt. Du kannst sie genauso verwenden wie <code>circle()</code>, aber sie bietet auch erweiterte Funktionalität. Zum Beispiel erlaubt sie mehr Kontrolle über ihre Größe.
Da ein Kreis in OpenSCAD nur durch ein regelmäßiges Polygon mit einer Anzahl gerader Seiten angenähert werden kann, kann dies zu Ungenauigkeiten in Größe und Form führen. Um dem entgegenzuwirken, werden auch die Argumente <code>realign=</code> und <code>circum=</code> bereitgestellt.
=== realign= (ellipse-Argument) ===
Das <code>realign=</code>-Argument rotiert, wenn es auf <code>true</code> gesetzt wird, die <code>ellipse()</code> um den halben Winkel zwischen den Polygonseiten:
[[Datei:BOSL2-ellipse-realign.png|mini|zentriert|alternativtext=realign=true|#ellipse(d=100, $fn=8); color("lime") ellipse(d=100, $fn=8, '''realign=true''');]]
<pre class="openscad">
include <BOSL2/std.scad>
#ellipse(d=100, $fn=8);
color("lime") ellipse(d=100, $fn=8, realign=true);
</pre>
=== circum= (ellipse-Argument) ===
[[Datei:BOSL2-ellipse-circum.png|mini|zentriert|alternativtext=circum=true|Vergleich: rot (außen) mit circum=true und blau (innen) ohne circum. Referenz: idealer Kreis in gelb.]]
<pre class="openscad">
include <BOSL2/std.scad>
color("red") ellipse(d=100, $fn=6, circum=true);
color("yellow") ellipse(d=100, $fn=360);
color("blue") ellipse(d=100, $fn=6);
</pre>
Das <code>circum=</code>-Argument bewirkt, wenn es auf true gesetzt wird, dass das Polygon, das die <code>ellipse()</code> bildet, den idealen Kreis '''umschreibt''', anstatt ihn einzuschreiben.
Den idealen Kreis ''einschreiben'':
<pre class="openscad">include <BOSL2/std.scad>
color("green") ellipse(d=100, $fn=360);
ellipse(d=100, $fn=6);</pre>
Den idealen Kreis ''umschreiben'':
<pre class="openscad">include <BOSL2/std.scad>
ellipse(d=100, $fn=6, circum=true);
color("green") ellipse(d=100, $fn=360);</pre>
=== Ellipse mit 2 Radien ===
Das <code>ellipse()</code>-Modul kann, wie der Name schon sagt, mit separaten X- und Y-Radien oder -Durchmessern angegeben werden. Dazu gibst du einfach <code>r=</code> oder <code>d=</code> mit einer Liste von zwei Radien oder Durchmessern an:
[[Datei:BOSL2-ellipse-2Radien.png|mini|zentriert|alternativtext=2 Radien|ellipse('''r=[30,20]''');]]
==== r=[r1,r2] ====
<pre class="openscad">include <BOSL2/std.scad>
ellipse(r=[30,20]);</pre>
==== d=[d1,d2]====
<pre class="openscad">include <BOSL2/std.scad>
ellipse(d=[60,40]);</pre>
==== ellipse mit anchor ====
Wie bei <code>circle()</code> kannst du <code>ellipse()</code>-Formen verankern, drehen und anhängen:
[[Datei:BOSL2-ellipse-anchor.png|mini|zentriert|alternativtext=ellipse mit anchor|ellipse(d=[50,20], '''anchor=BACK'''); #ellipse(d=[50,20], '''anchor=FRONT''');]]
<pre class="openscad">
include <BOSL2/std.scad>
ellipse(d=[50,20], anchor=BACK);
#ellipse(d=[50,20], anchor=FRONT);
</pre>
==== ellipse mit attach ====
[[Datei:BOSL2-ellipse-attach.png|mini|zentriert|alternativtext=ellipse mit attach|ellipse(d=50) '''attach(BACK+RIGHT, FRONT+LEFT)''' #ellipse(d=[40,20]);]]
<pre class="openscad">
include <BOSL2/std.scad>
ellipse(d=50)
attach(BACK+RIGHT, FRONT+LEFT)
ellipse(d=30);
</pre>
<span id="rechtwinklige-dreiecke-right-triangles"></span>
==== ellipse mit spin ====
[[Datei:BOSL2-ellipse-attach-spin-anchor.png|mini|zentriert|alternativtext=spin = 90 bei ellipse|ellipse(d=50) attach(BACK) #ellipse(d=[40,20], '''spin=90''', anchor=LEFT);]]
<pre class="openscad">
include <BOSL2/std.scad>
ellipse(d=50)
attach(BACK)
#ellipse(d=[40,20], spin=90, anchor=LEFT);
</pre>
== Rechtwinklige Dreiecke (Right Triangles) ==
Die BOSL2-Bibliothek bietet eine einfache Möglichkeit, ein 2D-rechtwinkliges Dreieck mit dem <code>right_triangle()</code>-Modul zu erstellen:
[[Datei:BOSL2-right triangle.png|mini|zentriert|alternativtext=right_triangle([40,30])|right_triangle([40,30]);]]
<pre class="openscad">include <BOSL2/std.scad>
right_triangle([40,30]);</pre>
=== xflip() bei right_triangle ===
Du kannst <code>xflip()</code> und <code>yflip()</code> verwenden, um zu ändern, in welchem Quadranten das Dreieck gebildet wird:
[[Datei:BOSL2-right triangle xflip.png|mini|zentriert|alternativtext=right_triange mit xflip()|right_triangle([40,30]); '''xflip()''' #right_triangle([40,30]);]]
<pre class="openscad">include <BOSL2/std.scad>
xflip() right_triangle([40,30]);</pre>
=== yflip() bei right_triangle ===
[[Datei:BOSL2-right triangle yflip.png|mini|zentriert|alternativtext=right_triangle([40,30]) mit yflip()|right_triangle([40,30]); '''yflip()''' #right_triangle([40,30]);]]
<pre class="openscad">include <BOSL2/std.scad>
yflip() right_triangle([40,30]);</pre>
=== xflip() & yflip() bei right_triangle ===
[[Datei:BOSL2-right triangle xflip yflip.png|mini|zentriert|alternativtext=xflip() yflip()|right_triangle([40,30]); xflip() yflip() #right_triangle([40,30]);]]
<pre class="openscad">include <BOSL2/std.scad>
xflip() yflip() right_triangle([40,30]);</pre>
=== spin= bei right_triangle ===
Oder alternativ einfach mit <code>spin=</code> in den richtigen Quadranten drehen:
[[Datei:BOSL2-right triangle spin.png|mini|zentriert|alternativtext=right_triangle([40,30]) mit spin=90)|right_triangle([40,30]);
#right_triangle([40,30], '''spin=90''');]]
<pre class="openscad">include <BOSL2/std.scad>
right_triangle([40,30], spin=90);</pre>
<pre class="openscad">include <BOSL2/std.scad>
right_triangle([40,30], spin=-90);</pre>
Du kannst bei rechtwinkligen Dreiecken auch Verankerung verwenden:
<pre class="openscad">include <BOSL2/std.scad>
right_triangle([40,30], anchor=FWD+RIGHT);</pre>
<span id="trapeze-trapezoids"></span>
== Trapeze (Trapezoids) ==
OpenSCAD bietet keine einfache Möglichkeit, allgemeine 2D-Dreiecke, Trapeze oder Parallelogramme zu erstellen. Die BOSL2-Bibliothek kann all diese Formen mit dem <code>trapezoid()</code>-Modul bereitstellen.
=== Dreieck ===
Um ein gleichseitiges Dreieck zu erstellen, setze einfach eine der Breiten auf null:
[[Datei:BOSL2-trapezoid dreieck.png|mini|zentriert|alternativtext=Dreieck|trapezoid(w1=50, w2=0, h=40);<br>
Dreieck mit Seitenlänge = 50]]
<pre class="openscad">include <BOSL2/std.scad>
trapezoid(w1=50, w2=0, h=40);</pre>
Um ein rechtwinkliges Dreieck zu erstellen, musst du das <code>shift=</code>-Argument verwenden, um die Rückseite des Trapezes entlang der X-Achse zu verschieben:
[[Datei:BOSL2-trapezoid dreieck-rechtwinklig.png|mini|zentriert|alternativtext=Rechtwinkliges Dreieck|trapezoid(w1=50, w2=0, h=50, shift=-25);]]
<pre class="openscad">include <BOSL2/std.scad>
trapezoid(w1=50, w2=0, h=50, shift=-25);</pre>
<pre class="openscad">include <BOSL2/std.scad>
trapezoid(w1=50, w2=0, h=50, shift=25);</pre>
<pre class="openscad">include <BOSL2/std.scad>
trapezoid(w1=0, w2=50, h=50, shift=-25);</pre>
<pre class="openscad">include <BOSL2/std.scad>
trapezoid(w1=0, w2=50, h=50, shift=25);</pre>
=== Trapez ===
Du kannst ein Trapez erstellen, indem du für vorne (<code>w1=</code>) und hinten (<code>w2=</code>) von null verschiedene Breiten angibst:
[[Datei:BOSL2-trapezoid trapez.png|mini|zentriert|alternativtext=Trapez|trapezoid(w1=30, w2=50, h=50);]]
<pre class="openscad">include <BOSL2/std.scad>
trapezoid(w1=30, w2=50, h=50);</pre>
=== Parallelogramm ===
Ein Parallelogramm ist nur eine Frage der Verwendung der gleichen Breite für vorne und hinten, mit einer Verschiebung entlang der X-Achse:
[[Datei:BOSL2-trapezoid parallelogram.png|mini|zentriert|alternativtext=Parallelogramm|trapezoid(w1=50, w2=50, shift=20, h=50);]]
<pre class="openscad">include <BOSL2/std.scad>
trapezoid(w1=50, w2=50, shift=20, h=50);</pre>
=== Viereck ===
Ein Viereck kann erstellt werden, indem ungleiche, von null verschiedene Breiten für vorne (<code>w1=</code>) und hinten (<code>w2=</code>) verwendet werden, wobei die Rückseite entlang der X-Achse verschoben wird:
[[Datei:BOSL2-trapezoid viereck.png|mini|zentriert|alternativtext=Viereck|trapezoid(w1=50, w2=30, shift=20, h=50);]]
<pre class="openscad">include <BOSL2/std.scad>
trapezoid(w1=50, w2=30, shift=20, h=50);</pre>
Du kannst <code>anchor=</code> und <code>spin=</code> verwenden, genau wie bei anderen anhängbaren Formen. Die Ausrichtungen der Ankerpunkte basieren jedoch auf den Seitenwinkeln der Flächen und sind möglicherweise nicht das, was du erwartest:
<pre class="openscad">include <BOSL2/std.scad>
trapezoid(w1=30, w2=50, h=50)
show_anchors();</pre>
<span id="regelmäßige-n-ecke-regular-n-gons"></span>
== Regelmäßige n-Ecke (Regular N-Gons) ==
OpenSCAD ermöglicht es dir, regelmäßige n-Ecke (Fünfeck, Sechseck usw.) zu erstellen, indem du <code>circle()</code> mit <code>$fn</code> verwendest. Obwohl dies prägnant ist, mag es auf den ersten Blick weniger offensichtlich sein:
<pre class="openscad">include <BOSL2/std.scad>
circle(d=50, $fn=5);</pre>
Die BOSL2-Bibliothek hat Module, die für gängige n-Ecke klarer benannt sind:
=== Pentagon (d=<Durchmesser>) ===
[[Datei:BOSL2-Pentagon.png|mini|zentriert|alternativtext=Pentagon|pentagon(d=50);]]
<pre class="openscad">include <BOSL2/std.scad>
pentagon(d=50);</pre>
=== Hexagon (d=<Durchmesser>) ===
[[Datei:BOSL2-Hexagon.png|mini|zentriert|alternativtext=Hexagon| hexagon(d=50);]]
<pre class="openscad">include <BOSL2/std.scad>
hexagon(d=50);</pre>
=== Octagon (d= <Durchmesser>) ===
[[Datei:BOSL2-Octagon.png|mini|zentriert|alternativtext=octagon(d=50);|octagon(d=50);]]
<pre class="openscad">include <BOSL2/std.scad>
octagon(d=50);</pre>
=== regular_ngon (n=<Seitenanzahl>, d=<Durchmesser>) ===
[[Datei:BOSL2-regular ngon.png|mini|zentriert|alternativtext=regular_ngon|regular_ngon(n=7, d=50);]]
<pre class="openscad">include <BOSL2/std.scad>
regular_ngon(n=7, d=50);</pre>
=== side=<Seitenlänge> ===
Diese Module bieten dir auch zusätzliche Funktionalität. Sie können nach Seitenlänge dimensioniert werden:
[[Datei:BOSL2-Hexagon side50.png|mini|zentriert|alternativtext=hexagon(side=50);|hexagon(side=50);]]
<pre class="openscad">include <BOSL2/std.scad>
pentagon(side=50);</pre>
=== ir = <Innenradius> / id = <Innendurchmesser> ===
Sie können nach dem Radius/Durchmesser des umschriebenen Kreises (Innenkreis) dimensioniert werden:
[[Datei:BOSL2-Pentagon Innenradius.png|mini|zentriert|alternativtext=Innenradius|color("red") pentagon('''ir=25'''); color("yellow") circle(r=25,$fn=100);]]
<pre class="openscad">include <BOSL2/std.scad>
pentagon(ir=25);
pentagon(id=50);</pre>
=== realign=true/false ===
Die Polygone können um eine halbe Seite gedreht werden:
[[Datei:BOSL2-Pentagon realign.png|mini|zentriert|alternativtext=realign|pentagon(d=50, '''realign=false'''); #pentagon(d=50, '''realign=true''');]]
<pre class="openscad">include <BOSL2/std.scad>
left(30) pentagon(d=50, realign=true);
right(30) pentagon(d=50, realign=false);</pre>
=== rounding = <Rundung> ===
Die BOSL2-Polygone können abgerundet werden:
[[Datei:BOSL2-Polygon-rounding.png|mini|zentriert|alternativtext=rounding|pentagon(d=50, '''rounding=5''');]]
<pre class="openscad">include <BOSL2/std.scad>
pentagon(d=50, rounding=5);</pre>
=== show_anchors() ===
Die BOSL2-Polygone haben auch ein etwas anderes Anhangsverhalten als die regulären Polygone, die über $fn=<Seitenanzahl> erzeugt werden.
Ein Kreis mit einem kleinen <code>$fn=</code> hängt Dinge am idealen Kreis an, nicht entlang des erstellten Polygons:
[[Datei:BOSL2-polygon-outcircle-anchors.png|mini|zentriert|alternativtext=anchors Außenkreis|color("green") stroke(circle(d=50), closed=true); circle(d=50,$fn=6) show_anchors();]]
<pre class="openscad">include <BOSL2/std.scad>
color("green") stroke(circle(d=50), closed=true);
circle(d=50,$fn=6)
show_anchors();</pre>
Während ein BOSL2-n-Eck entlang des Polygons selbst (direkt) anhängt:
[[Datei:BOSL2-polygon-direct-anchors.png|mini|zentriert|alternativtext=anchors BOSL2 Polygone direkt|color("green") stroke(circle(d=50), closed=true); circle(d=50,$fn=6) show_anchors();]]
<pre class="openscad">include <BOSL2/std.scad>
hexagon(d=50)
show_anchors(custom=false);</pre>
Du kannst <code>anchor=</code> und <code>spin=</code> verwenden, genau wie bei anderen anhängbaren Formen. Die Ankerpunkte basieren jedoch darauf, wo der Ankervektor die Seite des n-Ecks schneiden würde, und sind möglicherweise nicht dort, wo du sie erwartest:
[[Datei:BOSL2-Pentagon-anchor.png|mini|zentriert|alternativtext=n-Polygon anchor|pentagon(d=50, '''anchor=FRONT+LEFT''') show_anchors(custom=false);]]
<pre class="openscad">include <BOSL2/std.scad>
pentagon(d=50, anchor=FRONT+LEFT)
show_anchors(custom=false);</pre>
=== Ankerpunkte für Seiten und Spitzen ===
n-Ecke haben auch benannte Ankerpunkte für ihre Seiten und Spitzen:
[[Datei:BOSL2-anchor-Spitzen-Seiten.png|mini|zentriert|alternativtext=Anker für Seiten und Spitzen|Spezielle Anker für die Spitzen und Seiten eines Pentagons (mit TikZ unter LaTeX erstellt)]]
Beachte, dass die Ankernamen in "" gesetzt werden müssen.
Zum Beispiel:
[[Datei:BOSL2-Pentagon anchor tip1.png|mini|zentriert|alternativtext=anchor="tip1"|pentagon(d=30, '''anchor="tip1" ''');]]
<pre class="openscad">include <BOSL2/std.scad>
pentagon(d=30, anchor="tip1");</pre>
<span id="sterne-stars"></span>
Beispiel mit attach():
[[Datei:BOSL2-anchor-Spitzen-Seiten attach.png|mini|zentriert|alternativtext=anchor="side2"|pentagon(d=30, anchor="side2") '''attach("tip0")''' circle(r=3,$fn=36);]]
<pre class="openscad">
include <BOSL2/std.scad>
pentagon(d=30, anchor="side2") attach("tip0") circle(r=3,$fn=36);
</pre>
== Sterne (Stars) ==
=== star() mit n, ir/id und or/od ===
Die BOSL2-Bibliothek hat Sterne als grundlegend unterstützte Form. Sie können eine beliebige Anzahl '''n''' von '''Spitzen''' haben. Du kannst die Form eines Sterns durch Spitzenanzahl, '''innere und äußere Scheitelpunkt-Radius/-Durchmesser''' angeben:
[[Datei:BOSL2-star n5 ir15 dr30-Veranschaulichung.png|mini|zentriert|alternativtext=Innerer und äußerer Radius bei star()|Veranschaulichung von den Parameter '''ir''' (oder id) und '''or''' (oder od). ''ir'' gibt den inneren Radius und or den äußeren Radius an. Die Anzahl der Zacken ist hier n=5. Siehe Code unten.]]
Begonnen wird der Stern mit einem Zacken nach rechts auf der X-Achse.
<pre class="openscad">
include <BOSL2/std.scad>
#circle(30, $fn=60);
color("blue") star(n=5, ir=15, or=30);
#circle(15, $fn=60);
color("darkblue") fwd(35) text("or=30", halign = "center", size=3);
color("yellow") text("ir=15",halign = "center", size=3, valign="center");
</pre>
=== star() mit Spannweite d ===
Statt '''od''' kann auch einfach '''d''' als Parameter verwendet werden.
[[Datei:BOSL2-star n3 id10 d50.png|mini|zentriert|alternativtext=star(n=3, id=10, d=50);|star(n=3, id=10, d=50);]]
<pre class="openscad">include <BOSL2/std.scad>
star(n=3, id=10, d=50);</pre>
[[Datei:BOSL2-star n5 id15 r25.png|mini|zentriert|alternativtext=star(n=5, id=15, r=25);|star(n=5, id=15, r=25);]]
<pre class="openscad">include <BOSL2/std.scad>
star(n=5, id=15, r=25);</pre>
[[Datei:BOSL2-star n10 id30 d50.png|mini|zentriert|alternativtext=star(n=10, id=30, d=50);|star(n=10, id=30, d=50);]]
<pre class="openscad">include <BOSL2/std.scad>
star(n=10, id=30, d=50);</pre>
=== star (n = <Spitzenanzahl>, step = <Anzahl zu überspringender Punkte>) ===
Oder du kannst die Sternform durch Spitzenanzahl '''n''' und Anzahl '''step''' der zu überspringenden Punkte angeben:
[[Datei:BOSL2-star n7 step2 d50.png|mini|zentriert|alternativtext=step|star(n=7, step=2, d=50);]]
<pre class="openscad">include <BOSL2/std.scad>
star(n=7, step=2, d=50);</pre>
[[Datei:BOSL2-star n7 step3 d50.png|mini|zentriert|alternativtext=step=3|star(n=7, step=3, d=50);]]
<pre class="openscad">include <BOSL2/std.scad>
star(n=7, step=3, d=50);</pre>
=== star() mit realign ===
Wenn dem <code>realign=</code>-Argument ein true-Wert übergeben wird, wird der Stern um einen halben Spitzenwinkel gedreht:
<pre class="openscad">include <BOSL2/std.scad>
left(30) star(n=5, step=2, d=50);
right(30) star(n=5, step=2, d=50, realign=true);</pre>
=== star() mit align_tip=<Anker> ===
Das <code>align_tip=</code>-Argument kann mit einem Vektor angegeben werden, damit du die erste Spitze in eine bestimmte Richtung ausrichten kannst:
[[Datei:BOSL2-star n5 align tip anchor tip0.png|mini|zentriert|alternativtext=align_tip=BACK|star(n=5, ir=15, or=30, align_tip=BACK) attach("tip0") color("blue") anchor_arrow2d();]]
<pre class="openscad">include <BOSL2/std.scad>
star(n=5, ir=15, or=30, align_tip=BACK)
attach("tip0") color("blue") anchor_arrow2d();</pre>
=== star() mit align_pit=<Anker> ===
Ebenso kann die erste Einkerbung oder Einbuchtung mit <code>align_pit=</code> in Richtung eines bestimmten Vektors ausgerichtet werden:
[[Datei:BOSL2-star n5 align pit BACK attach tip0.png|mini|zentriert|alternativtext=align_pit=BACK|star(n=5, ir=15, or=30, '''align_pit=BACK''') '''attach("tip0")''' color("blue") anchor_arrow2d();]]
<pre class="openscad">include <BOSL2/std.scad>
star(n=5, ir=15, or=30, align_pit=BACK)
attach("pit0") color("blue") anchor_arrow2d();</pre>
Du kannst <code>anchor=</code> und <code>spin=</code> verwenden, genau wie bei anderen anhängbaren Formen. Die Ankerpunkte basieren jedoch auf den äußersten Ausmaßen der Form und sind möglicherweise nicht dort, wo du sie erwartest:
[[Datei:BOSL2-star n5 anchor LEFT-show anchers.png|mini|zentriert|alternativtext=anchor=LEFT|star(n=5, step=2, d=50,'''anchor=LEFT''') '''show_anchors(custom=false)''';]]
<pre class="openscad">include <BOSL2/std.scad>
star(n=5, step=2, d=50)
show_anchors(custom=false);</pre>
=== Benannte Ankerpunkte bei star() ===
Sterne haben auch benannte Ankerpunkte für ihre Gruben, Spitzen und Mittelpunkte zwischen den Spitzen:
[[Datei:BOSL2-star n5 benannteAnker.png|mini|zentriert|alternativtext=benannten Ankerpunkte in star()|Zuordnung der benannten Ankerpunkte in star(). Spitzen beginnen mit "tipt0", Einkerbungen mit pit0.]]
==== Beispiel 1: anchor="tip0" attach("pit0") ====
[[Datei:BOSL2-star-n5 ir=15 or30 anchor tip0 pit0.png|mini|zentriert|alternativtext=anchor="tip0"|star(n=5, ir=15, or=30, anchor="tip0") attach("pit0") #circle(3);]]
<pre class="openscad">
include <BOSL2/std.scad>
star(n=5, ir=15, or=30, anchor="tip0") attach("pit0") #circle(3);
</pre>
==== Beispiel 2: anchor="pit0" attach("tip0") ====
[[Datei:BOSL2-star n5 anchor pit0 attach tip0.png|mini|zentriert|alternativtext=anchor="pit0" attach("tip0")|star(n=5, ir=15, or=30, anchor="pit0") attach("tip0") #circle(3);]]
<pre class="openscad">
include <BOSL2/std.scad>
star(n=5, ir=15, or=30, anchor="pit0") attach("tip0") #circle(3);
</pre>
<span id="tropfenform-2d-teardrop2d"></span>
== Tropfenform 2D (Teardrop2D) ==
Beim 3D-Druck möchtest du oft ein kreisförmiges Loch in eine vertikale Wand machen. Wenn das Loch jedoch zu groß ist, kann der Überhang an der Oberseite des Lochs Probleme beim Drucken auf einem FDM/FFF-Drucker verursachen. Wenn du kein Stützmaterial verwenden möchtest, kannst du einfach die Tropfenform verwenden. Das <code>teardrop2d()</code>-Modul ermöglicht es dir, eine 2D-Version der Tropfenform zu erstellen, damit du sie später extrudieren kannst:
[[Datei:BOSL2-teardrop2d r20.png|mini|zentriert|alternativtext=teardrop2d(r=20);|teardrop2d(r=20);]]
<pre class="openscad">include <BOSL2/std.scad>
teardrop2d(r=20);</pre>
=== Extrudiert als tropfenförmige Aussparung:
[[Datei:BOSL2-teardrop2d Loch linear extrudiert.png|mini|zentriert|alternativtext=Lineares Extrudieren eines Quadrats mit zentrierter Tropfenform|linear_extrude(5) { diff() { rect(50) attach(CTR,CTR, inside=true) teardrop2d(d=20); }}]]
<pre class="openscad">
include <BOSL2/std.scad>
linear_extrude(5) {
diff() {
rect(50)
attach(CTR,CTR, inside=true)
teardrop2d(d=20);
}}</pre>
=== ang=<Überhangwinkel> ===
Der Standard-Überhangwinkel beträgt 45 Grad, aber du kannst ihn mit dem <code>ang=</code>-Argument anpassen:
[[Datei:BOSL2-teardrop2d ang20.png|mini|zentriert|alternativtext=teardrop2d(d=50, ang=20);|teardrop2d(d=50, ang=20);]]
<pre class="openscad">include <BOSL2/std.scad>
teardrop2d(d=50, ang=20);</pre>
=== cap_h=<Kapphöhe> ===
Wenn du es vorziehst, die Oberseite des Tropfens abzuflachen, um das Bridging zu fördern, kannst du das <code>cap_h=</code>-Argument verwenden:
[[Datei:BOSL2-teardrop2d ang20 cap h38c.png|mini|zentriert|alternativtext=teardrop2d(d=50, ang=20, cap_h=38);|teardrop2d(d=50, ang=20, '''cap_h=38''');]]
<pre class="openscad">include <BOSL2/std.scad>
teardrop2d(d=50, ang=20, cap_h=38);</pre>
=== show_anchors() bei teardrop2d ===
Du kannst <code>anchor=</code> und <code>spin=</code> verwenden, genau wie bei anderen anhängbaren Formen. Die Ankerpunkte basieren jedoch auf den äußersten Ausmaßen der Form und sind möglicherweise nicht dort, wo du sie erwartest:
[[Datei:BOSL2-teardrop2d anchorBACK show anchors.png|mini|zentriert|alternativtext=teardrop2d(d=50, anchor=BACK) show_anchors();|teardrop2d(d=50, anchor=BACK) show_anchors();]]
<pre class="openscad">
include <BOSL2/std.scad>
teardrop2d(d=50, anchor=BACK)
show_anchors();
</pre>
<span id="verklebte-kreise-glued-circles"></span>
== Verklebte Kreise (Glued Circles) ==
Eine ungewöhnlichere Form, die BOSL2 bietet, sind verklebte Kreise (Glued Circles). Es handelt sich im Grunde um ein Paar von Kreisen, die durch etwas verbunden sind, das wie ein klebriger Meniskus aussieht:
[[Datei:BOSL2-glued circles d30 spread40.png|mini|zentriert|alternativtext=glued_circles(d=30, spread=40);|glued_circles(d=30, spread=40);]]
<pre class="openscad">include <BOSL2/std.scad>
glued_circles(d=30, spread=40);</pre>
=== d/r=<Kreisdurchmesser/Kreisradius>, spread=<Abstand Kreismittelpunkte> ===
Die <code>r=</code>/<code>d=</code>-Argumente können den Radius oder Durchmesser der beiden Kreise angeben:
<pre class="openscad">include <BOSL2/std.scad>
glued_circles(r=20, spread=45);</pre>
<pre class="openscad">include <BOSL2/std.scad>
glued_circles(d=40, spread=45);</pre>
Das <code>spread=</code>-Argument gibt den Abstand zwischen den Mittelpunkten der beiden Kreise an:
<pre class="openscad">include <BOSL2/std.scad>
glued_circles(d=30, spread=30);</pre>
=== tangent = <Tangentenwinkel-Miniskus> ===
Das <code>tangent=</code>-Argument gibt den Winkel der Tangente des Meniskus an den beiden Kreisen an:
[[Datei:BOSL2-glued circles d30 spread40 tangent=45.png|mini|zentriert|alternativtext=glued_circles(d=30, spread=30, tangent=45);|glued_circles(d=30, spread=30, tangent=45);]]
Auch negative Werte sind für den Tangentenwinkel möglich, so wird aus der Einbuchtung eine Ausbuchtung:
[[Datei:BOSL2-glued circles d30 spread40 tangent=-45.png|mini|zentriert|alternativtext= tangent=-40|glued_circles(d=30, spread=30, tangent=-40);]]
<pre class="openscad">include <BOSL2/std.scad>
glued_circles(d=30, spread=30, tangent=-45);</pre>
=== Langloch mit tangent=0 ===
Mit einem Tangentenwinkel von 0 erhält man eine Form, die sehr nützlich sein kann, um Langlöcher zu konstruieren.
[[Datei:BOSL2-glued circles Langlochform tangent0.png|mini|zentriert|alternativtext=Langlochform mit glued_circles|Langlochform mit glued_circles(d=30, spread=30, tangent=0);]]
<pre class="openscad">
include <BOSL2/std.scad>
glued_circles(d=30, spread=30, tangent=0);
</pre>
==== 3D-Anwendungsbeispiel ====
[[Datei:BOSL2-glued circles Langlochform tangent0 3D.png|mini|zentriert|alternativtext=3D-Langloch glued_circlesh |Langloch (3D) durch lineares Extrudieren von glued_circles]]
<pre class="openscad">
include <BOSL2/std.scad>
difference() {
cube([80, 80, 10], center = false);
translate([40, 40, -1])
linear_extrude(height = 12) {
glued_circles(d = 30, spread = 30, tangent = 0);
}
}
</pre>
=== Gerippte Wand ===
Eine nützliche Sache, die du tun kannst, ist, einige <code>glued_circle()</code>s in einer Linie anzuordnen und sie dann zu extrudieren, um eine gerippte Wand zu erstellen:
[[Datei:BOSL2-glued circles gerippte Wand=-45.png|mini|zentriert|alternativtext=Gerippte Wand mit extrudierten glued_circles|$fn=64; s=10; linear_extrude(height=50,convexity=16,center=true) xcopies(s*sqrt(2),n=3) glued_circles(d=s, spread=s*sqrt(2), tangent=45);]]
<pre class="openscad">include <BOSL2/std.scad>
$fn=36; s=10;
linear_extrude(height=50,convexity=16,center=true)
xcopies(s*sqrt(2),n=3)
glued_circles(d=s, spread=s*sqrt(2), tangent=45);</pre>
Du kannst <code>anchor=</code> und <code>spin=</code> verwenden, genau wie bei anderen anhängbaren Formen. Die Ankerpunkte basieren jedoch auf den äußersten Ausmaßen der Form und sind möglicherweise nicht dort, wo du sie erwartest:
<pre class="openscad">include <BOSL2/std.scad>
glued_circles(d=40, spread=40, tangent=45)
show_anchors();</pre>
94yx21rzj22y51zt5cjvedrhplayew1
1093536
1093535
2026-11-08T17:08:30Z
Jowi-ammerbuch
115360
/* Langloch mit tangent=0 */
1093536
wikitext
text/x-wiki
{{MyNavi
|zurück = [[OpenSCAD Benutzerhandbuch/_BOSL2-Distributoren|Zurück]]
|buch = [[OpenSCAD Benutzerhandbuch/_BOSL2|BOSL2-Inhalt]]
|weiter = [[OpenSCAD Benutzerhandbuch/_BOSL2-3D|Weiter]]
}}
== 2D Grundformen (2D Primitive) ==
OpenSCAD bietet zwei eingebaute 2D-Grundformen: <code>square()</code> und <code>circle()</code>. Du kannst sie weiterhin auf die gewohnte Weise verwenden:
<pre class="openscad">include <BOSL2/std.scad>
square([60,40], center=true);</pre>
<pre class="openscad">include <BOSL2/std.scad>
circle(r=50);</pre>
<pre class="openscad">include <BOSL2/std.scad>
circle(d=100, $fn=8);</pre>
Diese Module wurden in der BOSL2-Bibliothek in drei Bereichen erweitert: Verankerung (Anchoring), Drehung (Spin) und Anhängbarkeit (Attachability).
<span id="verankerung-anchoring"></span>
=== Verankerung (Anchoring): ===
Wenn du ein <code>square()</code> erstellst, kannst du angeben, welche Ecke oder Seite am Ursprung verankert werden soll. Dies ersetzt das <code>center=</code>-Argument und ist flexibler. Das <code>anchor=</code>-Argument nimmt einen Vektor als Wert entgegen, der in grober Richtung der Seite oder Ecke zeigt, die du am Ursprung ausrichten möchtest.
=== anchor=[0,1] oder anchor=BACK ===
[[Datei:BOSL2-anchor-0-1.png|mini|zentriert|alternativtext=anchor=[0,1]);|square([60,40], '''anchor=[0,1]''');<br>
Oder: square([60,40], '''anchor=BACK''');]]
Um beispielsweise das '''Zentrum der hinteren Kante am Ursprung''' auszurichten, setzt du den Anker auf <code>[0,1]</code>:
<pre class="openscad">
include <BOSL2/std.scad>
square([60,40], anchor=[0,1]);
</pre>
Mit den leichter verständlichen vordefinierten '''Vektor-Konstanten''':
<pre class="openscad">
include <BOSL2/std.scad>
square([60,40], anchor=BACK+CENTER);
</pre>
=== anchor=[1,-1] oder anchor=RIGHT+FRONT ===
Um die '''vordere rechte Ecke am Ursprung''' auszurichten:
[[Datei:BOSL2-anchor-1 -1.png|mini|zentriert|alternativtext=anchor=RIGHT+FRONT);|square([60,40], '''anchor=[1,-1]''');<br>
Oder: square([60,40], '''anchor=RIGHT+FRONT''');]]
<pre class="openscad">
include <BOSL2/std.scad>
square([60,40], anchor=[1,-1]);
</pre>
'''Mit Vektor-Konstanten:'''
<pre class="openscad">
include <BOSL2/std.scad>
square([60,40], anchor=RIGHT+FRONT);
</pre>
=== anchor=[0,0] oder anchor=CENTER '''Fetter Text'''===
Um es zu '''zentrieren''':
<pre class="openscad">
include <BOSL2/std.scad>
square([60,40], anchor=[0,0]);
</pre>
'''Mit Vektor-Konstanten:'''
<pre class="openscad">
include <BOSL2/std.scad>
square([60,40], anchor=CENTER);
</pre>
=== Vektor-Konstanten am Rechteck ===
Um die Angabe von Vektoren übersichtlicher zu gestalten, sind mehrere Standard-Vektorkonstanten definiert:
[[Datei:BOSL2-anchor-Konstanten-Rechteck.png|gerahmt|zentriert|alternativtext=BOSL2 vordefinierte anchor-Konstanten|Die in BOSL2 vordefinierten anchor-Konstanten]]
{| class="wikitable"
|-
! Konstante
! Richtung
! Wert
|-
| LEFT
| X-
| [-1, 0, 0]
|-
| RIGHT
| X+
| [ 1, 0, 0]
|-
| FRONT / FORWARD / FWD
| Y-
| [ 0,-1, 0]
|-
| BACK
| Y+
| [ 0, 1, 0]
|-
| BOTTOM / BOT / BTM / DOWN
| Z-
| [ 0, 0,-1] (nur 3D)
|-
| TOP / UP
| Z+
| [ 0, 0, 1] (nur 3D)
|-
| CENTER / CTR
| Zentriert
| [ 0, 0, 0]
|}
Beachte, dass du die meisten dieser Konstanten (außer <code>UP</code>/<code>DOWN</code> natürlich) auch für Anker bei 2D-Formen verwenden kannst, obwohl es sich um 3D-Vektoren handelt:
<pre class="openscad">include <BOSL2/std.scad>
square([60,40], anchor=BACK);</pre>
<pre class="openscad">include <BOSL2/std.scad>
square([60,40], anchor=CENTER);</pre>
Du kannst Vektoren addieren, um auf Ecken zu zeigen:
<pre class="openscad">include <BOSL2/std.scad>
square([60,40], anchor=FRONT+RIGHT);</pre>
=== anchor = polar_to_xy ===
Für <code>circle()</code> kann der Ankervektor auf jeden beliebigen '''Punkt des Kreisumfangs''' zeigen:
[[Datei:BOSL2-anchor-polar to xy-circle.png|gerahmt|zentriert|alternativtext=anchor = polar_to_xy|anchor = polar_to_xy(1,Alpha), für Alpha = 0, 45, 90, ...]]
==== Beispiel: anchor=polar_to_xy(1,45) =====
[[Datei:BOSL2-anchor-polar to 1-45-octagon.png|mini|zentriert|alternativtext=circle(d=50, anchor=polar_to_xy(1,45), $fn = 8);|circle(d=50, anchor=polar_to_xy(1,45), $fn = 8);]]
<pre class="openscad">
include <BOSL2/std.scad>
circle(d=50, anchor=polar_to_xy(1,45), $fn = 8);
</pre>
Beachte, dass der Radius für den Anker keine Rolle spielt, da nur die Richtung des Ankers das Ergebnis beeinflusst.
=== show_anchors() ===
[[Datei:BOSL2-show anchor.png|mini|zentriert|show_anchors]]
Du kannst die typischen Ankerpunkte sehen, indem du <code>show_anchors()</code> als Kind der Form übergibst:
<pre class="openscad">include <BOSL2/std.scad>
square([60,40], center=true)
show_anchors();</pre>
<pre class="openscad">include <BOSL2/std.scad>
circle(d=50)
show_anchors();</pre>
<span id="drehung-spin"></span>
=== Drehung (Spin): ===
Die zweite Erweiterung von <code>square()</code> und <code>circle()</code> ist die Drehung (Spin). Wenn du die Form erstellst, kannst du sie mit dem <code>spin=</code>-Argument an Ort und Stelle drehen. Du übergibst einfach die Anzahl der Grad, um die sie im Uhrzeigersinn gedreht werden soll:
<pre class="openscad">include <BOSL2/std.scad>
square([60,40], anchor=CENTER, spin=30);</pre>
Die Verankerung oder Zentrierung erfolgt vor der Drehung:
<pre class="openscad">include <BOSL2/std.scad>
square([60,40], anchor=BACK, spin=30);</pre>
Bei Kreisen kann Spin nützlich sein, wenn auch <code>$fn=</code> angegeben wird:
<pre class="openscad">include <BOSL2/std.scad>
circle(d=50, $fn=6, spin=15);</pre>
Da die Verankerung vor der Drehung erfolgt, kannst du beides zusammen verwenden, um um den Anker herum zu drehen:
<pre class="openscad">include <BOSL2/std.scad>
circle(d=50, $fn=6, anchor=LEFT, spin=15);</pre>
<span id="anhängbarkeit-attachability"></span>
=== Anhängbarkeit (Attachability): ===
Die dritte Erweiterung von <code>square()</code> und <code>circle()</code> ist, dass du sie auf verschiedene Weise an Ankerpunkten zusammenhängen kannst. Dies geschieht, indem du eine Form zum Kind der Form machst, an die du sie anhängen möchtest.
==== Standard (ohne Spez. für anchor oder position) ====
Standardmäßig wird das Kind beim einfachen Untereinanderstellen im Zentrum der Elternform angehängt.
[[Datei:BOSL2-attach-standard-normal.png|mini|zentriert|alternativtext=square(50) #square(50);|square(50) #square(50);<br>
Kind-Objekt (rot) wird ans Zentrum des Elternobjekts angehängt]]
<pre class="openscad">
include <BOSL2/std.scad>
square(50) #square(50);
</pre>
==== anchor für child spezifiziert ====
[[Datei:BOSL2-attach-anchor-LEFTplusFWD.png|mini|zentriert|alternativtext=square(50, center=true) #square([20,40], anchor=LEFT+FWD);|square(50, center=true)#square([20,40], '''anchor=LEFT+FWD''');]]
<pre class="openscad">include <BOSL2/std.scad>
square(50, center=true)
#square([20,40], anchor=LEFT+FWD);</pre>
==== position() ====
[[Datei:BOSL2-attach-position.png|mini|zentriert|alternativtext=position(RIGHT)|square(50) '''position(RIGHT)''' #square(25) '''position(BACK)''' #square(25);]]
Durch Hinzufügen des <code>position()</code>-Moduls kannst du das Kind an jedem Ankerpunkt '''des Elternteils''' positionieren, das "Kindes-Kind wird am Ankerpunkt des übergeordneten Objekts positioniert:
<pre class="openscad">
include <BOSL2/std.scad>
square(50) position(RIGHT) #square(25)
position(BACK) #square(25);
</pre>
==== orient() ====
Ankerpunkte sind jedoch nicht nur Positionen auf dem Elternteil. Sie haben auch eine Ausrichtung. In den meisten Fällen zeigt die Ausrichtung eines Ankerpunkts nach außen, weg von der Fläche der Wand, also im Allgemeinen vom Zentrum der Form weg.
[[Datei:BOSL2-show anchor.png|mini|zentriert|show_anchors]]
Wenn du das Kind so ausrichten möchtest, dass es der Ausrichtung eines Ankerpunkts entspricht, kannst du das <code>orient()</code>-Modul verwenden. Es positioniert das Kind nicht, es dreht es nur:
[[Datei:BOSL2-attach-orient anchor.png|mini|zentriert|alternativtext= orient(anchor=LEFT+BOTTOM)|square(50) '''orient(anchor=LEFT+BOTTOM)''' #square([10,40]);]]
<pre class="openscad">include <BOSL2/std.scad>
square(50)
orient(anchor=LEFT+BOTTOM) #square([10,40]);</pre>
Das geht auch beim '''Kreis (circle)''' mit '''polar_to_xy''':
[[Datei:BOSL2-attach-orient polar to xy circle.png|mini|zentriert|alternativtext=orient(polar_to_xy(1,30))|circle(d=50) ''' orient(polar_to_xy(1,30))''' #square([10,40], anchor=FWD);]]
<pre class="openscad">include <BOSL2/std.scad>
circle(d=50)
orient(polar_to_xy(1,30))
#square([10,40], anchor=FWD);</pre>
==== position() + orient() ====
Du kannst <code>position()</code> und <code>orient()</code> zusammen verwenden, um sowohl zu positionieren als auch an einem Ankerpunkt auszurichten:
[[Datei:BOSL2-attach-position pluss orient polar to xy circle.png|mini|zentriert|alternativtext=position(polar_to_xy(1,30)) orient(polar_to_xy(1,30))|circle(d=50) '''position(polar_to_xy(1,30)) orient(polar_to_xy(1,30))''' #square([10,40], anchor=FWD);]]
<pre class="openscad">include <BOSL2/std.scad>
circle(d=50)
position(polar_to_xy(1,30))
orient(polar_to_xy(1,30))
#square([10,40], anchor=FWD);</pre>
=== attach () mit einem Argument ===
Aber es ist einfacher das <code>attach()</code>-Modul zu verwenden, um beides auf einmal zu erledigen:
[[Datei:BOSL2-attach-position pluss orient polar to xy circle.png|mini|zentriert|alternativtext=attach(polar_to_xy(1,30))|circle(d=50) '''attach(polar_to_xy(1,30))''' #square([10,40], anchor=FWD); ]]
Gleiches Ergebnis, aber übersichtlicherer Code.
<pre class="openscad">include <BOSL2/std.scad>
square(50, center=true)
attach(LEFT+BACK)
#square([10,40], anchor=FWD);</pre>
=== attach () mit zwei Argumenten ===
Anstatt den <code>anchor=</code> im Kind anzugeben, kannst du ein '''zweites Argument''' an <code>attach()</code> übergeben, das ihm sagt, welche Seite des Kindes mit dem Elternteil verbunden werden soll:
<pre class="openscad">
include <BOSL2/std.scad>
circle(d=50) attach(polar_to_xy(1,30), FWD) #square([10,40]);
</pre>
Damit lässt sich der Code noch mehr straffen.
[[Datei:BOSL2-attach-position pluss orient polar to xy circle.png|mini|zentriert|alternativtext=attach(polar_to_xy(1,30), FWD)|circle(d=50) '''attach(polar_to_xy(1,30), FWD)''' #square([10,40]); ]]
<span id="rechtecke-rectangles"></span>
== Rechtecke (Rectangles) ==
=== rect() ===
Die BOSL2-Bibliothek bietet eine Alternative zu <code>square()</code>, die mehr Funktionen unterstützt. Sie heißt <code>rect()</code>. Du kannst sie genauso verwenden wie <code>square()</code>, aber sie bietet auch erweiterte Funktionalität.
=== rect() mit rounding ===
[[Datei:BOSL2-rect rounding.png|mini|zentriert|alternativtext=rounding=10|rect([60,40], '''rounding=10''');]]
rect() erlaubt dir, die Ecken des Rechtecks abzurunden:
<pre class="openscad">include <BOSL2/std.scad>
rect([60,40], rounding=10);</pre>
=== rect() mit chamfer ===
[[Datei:BOSL2-rect chamfer.png|mini|zentriert|alternativtext=rect([60,40], chamfer=10);|rect([60,40], '''chamfer=10''');]]
Du kannst die Ecken des Rechtecks auch abfasen:
<pre class="openscad">include <BOSL2/std.scad>
rect([60,40], chamfer=10);</pre>
=== Unterschiedliche Abrundungen und Fasen an einem Rechteck ===
Du kannst sogar angeben, welche Ecken abgerundet oder abgefast werden. Wenn du eine Liste mit vier Größenwerten an die <code>rounding=</code>- oder <code>chamfer=</code>-Argumente übergibst, erhält jede Ecke ihre eigene Größe. Der Reihe nach geht es von der hinteren rechten Ecke (Quadrant I) gegen den Uhrzeigersinn zur hinteren linken Ecke (Quadrant II), zur vorderen linken Ecke (Quadrant III) und zur vorderen rechten Ecke (Quadrant IV):
Wenn eine Größe als <code>0</code> angegeben wird, gibt es keine Rundung und/oder Fase für die Ecke dieses Quadranten:
<pre class="openscad">include <BOSL2/std.scad>
rect([60,40], rounding=[0,5,10,15]);</pre>
<pre class="openscad">include <BOSL2/std.scad>
rect([60,40], chamfer=[0,5,10,15]);</pre>
Du kannst sowohl <code>rounding=</code>- als auch <code>chamfer=</code>-Argumente angeben, um Rundung und Fase zu mischen, aber nur, wenn du es pro Ecke angibst. Wenn du eine Rundung in einer Ecke möchtest, gib eine Fase von 0 für diese Ecke an und umgekehrt:
[[Datei:BOSL2-rect chamfer-rounding-mixed.png|mini|zentriert|alternativtext=ounding=[5,0,10,0], chamfer=[0,5,0,15]|rect([60,40], '''rounding=[5,0,10,0], chamfer=[0,5,0,15]''');]]
<pre class="openscad">include <BOSL2/std.scad>
rect([60,40], rounding=[5,0,10,0], chamfer=[0,5,0,15]);</pre>
<span id="ellipsen-ellipses"></span>
== Ellipsen (Ellipses) ==
Die BOSL2-Bibliothek bietet auch eine erweiterte Entsprechung von <code>circle()</code>, die <code>ellipse()</code> heißt. Du kannst sie genauso verwenden wie <code>circle()</code>, aber sie bietet auch erweiterte Funktionalität. Zum Beispiel erlaubt sie mehr Kontrolle über ihre Größe.
Da ein Kreis in OpenSCAD nur durch ein regelmäßiges Polygon mit einer Anzahl gerader Seiten angenähert werden kann, kann dies zu Ungenauigkeiten in Größe und Form führen. Um dem entgegenzuwirken, werden auch die Argumente <code>realign=</code> und <code>circum=</code> bereitgestellt.
=== realign= (ellipse-Argument) ===
Das <code>realign=</code>-Argument rotiert, wenn es auf <code>true</code> gesetzt wird, die <code>ellipse()</code> um den halben Winkel zwischen den Polygonseiten:
[[Datei:BOSL2-ellipse-realign.png|mini|zentriert|alternativtext=realign=true|#ellipse(d=100, $fn=8); color("lime") ellipse(d=100, $fn=8, '''realign=true''');]]
<pre class="openscad">
include <BOSL2/std.scad>
#ellipse(d=100, $fn=8);
color("lime") ellipse(d=100, $fn=8, realign=true);
</pre>
=== circum= (ellipse-Argument) ===
[[Datei:BOSL2-ellipse-circum.png|mini|zentriert|alternativtext=circum=true|Vergleich: rot (außen) mit circum=true und blau (innen) ohne circum. Referenz: idealer Kreis in gelb.]]
<pre class="openscad">
include <BOSL2/std.scad>
color("red") ellipse(d=100, $fn=6, circum=true);
color("yellow") ellipse(d=100, $fn=360);
color("blue") ellipse(d=100, $fn=6);
</pre>
Das <code>circum=</code>-Argument bewirkt, wenn es auf true gesetzt wird, dass das Polygon, das die <code>ellipse()</code> bildet, den idealen Kreis '''umschreibt''', anstatt ihn einzuschreiben.
Den idealen Kreis ''einschreiben'':
<pre class="openscad">include <BOSL2/std.scad>
color("green") ellipse(d=100, $fn=360);
ellipse(d=100, $fn=6);</pre>
Den idealen Kreis ''umschreiben'':
<pre class="openscad">include <BOSL2/std.scad>
ellipse(d=100, $fn=6, circum=true);
color("green") ellipse(d=100, $fn=360);</pre>
=== Ellipse mit 2 Radien ===
Das <code>ellipse()</code>-Modul kann, wie der Name schon sagt, mit separaten X- und Y-Radien oder -Durchmessern angegeben werden. Dazu gibst du einfach <code>r=</code> oder <code>d=</code> mit einer Liste von zwei Radien oder Durchmessern an:
[[Datei:BOSL2-ellipse-2Radien.png|mini|zentriert|alternativtext=2 Radien|ellipse('''r=[30,20]''');]]
==== r=[r1,r2] ====
<pre class="openscad">include <BOSL2/std.scad>
ellipse(r=[30,20]);</pre>
==== d=[d1,d2]====
<pre class="openscad">include <BOSL2/std.scad>
ellipse(d=[60,40]);</pre>
==== ellipse mit anchor ====
Wie bei <code>circle()</code> kannst du <code>ellipse()</code>-Formen verankern, drehen und anhängen:
[[Datei:BOSL2-ellipse-anchor.png|mini|zentriert|alternativtext=ellipse mit anchor|ellipse(d=[50,20], '''anchor=BACK'''); #ellipse(d=[50,20], '''anchor=FRONT''');]]
<pre class="openscad">
include <BOSL2/std.scad>
ellipse(d=[50,20], anchor=BACK);
#ellipse(d=[50,20], anchor=FRONT);
</pre>
==== ellipse mit attach ====
[[Datei:BOSL2-ellipse-attach.png|mini|zentriert|alternativtext=ellipse mit attach|ellipse(d=50) '''attach(BACK+RIGHT, FRONT+LEFT)''' #ellipse(d=[40,20]);]]
<pre class="openscad">
include <BOSL2/std.scad>
ellipse(d=50)
attach(BACK+RIGHT, FRONT+LEFT)
ellipse(d=30);
</pre>
<span id="rechtwinklige-dreiecke-right-triangles"></span>
==== ellipse mit spin ====
[[Datei:BOSL2-ellipse-attach-spin-anchor.png|mini|zentriert|alternativtext=spin = 90 bei ellipse|ellipse(d=50) attach(BACK) #ellipse(d=[40,20], '''spin=90''', anchor=LEFT);]]
<pre class="openscad">
include <BOSL2/std.scad>
ellipse(d=50)
attach(BACK)
#ellipse(d=[40,20], spin=90, anchor=LEFT);
</pre>
== Rechtwinklige Dreiecke (Right Triangles) ==
Die BOSL2-Bibliothek bietet eine einfache Möglichkeit, ein 2D-rechtwinkliges Dreieck mit dem <code>right_triangle()</code>-Modul zu erstellen:
[[Datei:BOSL2-right triangle.png|mini|zentriert|alternativtext=right_triangle([40,30])|right_triangle([40,30]);]]
<pre class="openscad">include <BOSL2/std.scad>
right_triangle([40,30]);</pre>
=== xflip() bei right_triangle ===
Du kannst <code>xflip()</code> und <code>yflip()</code> verwenden, um zu ändern, in welchem Quadranten das Dreieck gebildet wird:
[[Datei:BOSL2-right triangle xflip.png|mini|zentriert|alternativtext=right_triange mit xflip()|right_triangle([40,30]); '''xflip()''' #right_triangle([40,30]);]]
<pre class="openscad">include <BOSL2/std.scad>
xflip() right_triangle([40,30]);</pre>
=== yflip() bei right_triangle ===
[[Datei:BOSL2-right triangle yflip.png|mini|zentriert|alternativtext=right_triangle([40,30]) mit yflip()|right_triangle([40,30]); '''yflip()''' #right_triangle([40,30]);]]
<pre class="openscad">include <BOSL2/std.scad>
yflip() right_triangle([40,30]);</pre>
=== xflip() & yflip() bei right_triangle ===
[[Datei:BOSL2-right triangle xflip yflip.png|mini|zentriert|alternativtext=xflip() yflip()|right_triangle([40,30]); xflip() yflip() #right_triangle([40,30]);]]
<pre class="openscad">include <BOSL2/std.scad>
xflip() yflip() right_triangle([40,30]);</pre>
=== spin= bei right_triangle ===
Oder alternativ einfach mit <code>spin=</code> in den richtigen Quadranten drehen:
[[Datei:BOSL2-right triangle spin.png|mini|zentriert|alternativtext=right_triangle([40,30]) mit spin=90)|right_triangle([40,30]);
#right_triangle([40,30], '''spin=90''');]]
<pre class="openscad">include <BOSL2/std.scad>
right_triangle([40,30], spin=90);</pre>
<pre class="openscad">include <BOSL2/std.scad>
right_triangle([40,30], spin=-90);</pre>
Du kannst bei rechtwinkligen Dreiecken auch Verankerung verwenden:
<pre class="openscad">include <BOSL2/std.scad>
right_triangle([40,30], anchor=FWD+RIGHT);</pre>
<span id="trapeze-trapezoids"></span>
== Trapeze (Trapezoids) ==
OpenSCAD bietet keine einfache Möglichkeit, allgemeine 2D-Dreiecke, Trapeze oder Parallelogramme zu erstellen. Die BOSL2-Bibliothek kann all diese Formen mit dem <code>trapezoid()</code>-Modul bereitstellen.
=== Dreieck ===
Um ein gleichseitiges Dreieck zu erstellen, setze einfach eine der Breiten auf null:
[[Datei:BOSL2-trapezoid dreieck.png|mini|zentriert|alternativtext=Dreieck|trapezoid(w1=50, w2=0, h=40);<br>
Dreieck mit Seitenlänge = 50]]
<pre class="openscad">include <BOSL2/std.scad>
trapezoid(w1=50, w2=0, h=40);</pre>
Um ein rechtwinkliges Dreieck zu erstellen, musst du das <code>shift=</code>-Argument verwenden, um die Rückseite des Trapezes entlang der X-Achse zu verschieben:
[[Datei:BOSL2-trapezoid dreieck-rechtwinklig.png|mini|zentriert|alternativtext=Rechtwinkliges Dreieck|trapezoid(w1=50, w2=0, h=50, shift=-25);]]
<pre class="openscad">include <BOSL2/std.scad>
trapezoid(w1=50, w2=0, h=50, shift=-25);</pre>
<pre class="openscad">include <BOSL2/std.scad>
trapezoid(w1=50, w2=0, h=50, shift=25);</pre>
<pre class="openscad">include <BOSL2/std.scad>
trapezoid(w1=0, w2=50, h=50, shift=-25);</pre>
<pre class="openscad">include <BOSL2/std.scad>
trapezoid(w1=0, w2=50, h=50, shift=25);</pre>
=== Trapez ===
Du kannst ein Trapez erstellen, indem du für vorne (<code>w1=</code>) und hinten (<code>w2=</code>) von null verschiedene Breiten angibst:
[[Datei:BOSL2-trapezoid trapez.png|mini|zentriert|alternativtext=Trapez|trapezoid(w1=30, w2=50, h=50);]]
<pre class="openscad">include <BOSL2/std.scad>
trapezoid(w1=30, w2=50, h=50);</pre>
=== Parallelogramm ===
Ein Parallelogramm ist nur eine Frage der Verwendung der gleichen Breite für vorne und hinten, mit einer Verschiebung entlang der X-Achse:
[[Datei:BOSL2-trapezoid parallelogram.png|mini|zentriert|alternativtext=Parallelogramm|trapezoid(w1=50, w2=50, shift=20, h=50);]]
<pre class="openscad">include <BOSL2/std.scad>
trapezoid(w1=50, w2=50, shift=20, h=50);</pre>
=== Viereck ===
Ein Viereck kann erstellt werden, indem ungleiche, von null verschiedene Breiten für vorne (<code>w1=</code>) und hinten (<code>w2=</code>) verwendet werden, wobei die Rückseite entlang der X-Achse verschoben wird:
[[Datei:BOSL2-trapezoid viereck.png|mini|zentriert|alternativtext=Viereck|trapezoid(w1=50, w2=30, shift=20, h=50);]]
<pre class="openscad">include <BOSL2/std.scad>
trapezoid(w1=50, w2=30, shift=20, h=50);</pre>
Du kannst <code>anchor=</code> und <code>spin=</code> verwenden, genau wie bei anderen anhängbaren Formen. Die Ausrichtungen der Ankerpunkte basieren jedoch auf den Seitenwinkeln der Flächen und sind möglicherweise nicht das, was du erwartest:
<pre class="openscad">include <BOSL2/std.scad>
trapezoid(w1=30, w2=50, h=50)
show_anchors();</pre>
<span id="regelmäßige-n-ecke-regular-n-gons"></span>
== Regelmäßige n-Ecke (Regular N-Gons) ==
OpenSCAD ermöglicht es dir, regelmäßige n-Ecke (Fünfeck, Sechseck usw.) zu erstellen, indem du <code>circle()</code> mit <code>$fn</code> verwendest. Obwohl dies prägnant ist, mag es auf den ersten Blick weniger offensichtlich sein:
<pre class="openscad">include <BOSL2/std.scad>
circle(d=50, $fn=5);</pre>
Die BOSL2-Bibliothek hat Module, die für gängige n-Ecke klarer benannt sind:
=== Pentagon (d=<Durchmesser>) ===
[[Datei:BOSL2-Pentagon.png|mini|zentriert|alternativtext=Pentagon|pentagon(d=50);]]
<pre class="openscad">include <BOSL2/std.scad>
pentagon(d=50);</pre>
=== Hexagon (d=<Durchmesser>) ===
[[Datei:BOSL2-Hexagon.png|mini|zentriert|alternativtext=Hexagon| hexagon(d=50);]]
<pre class="openscad">include <BOSL2/std.scad>
hexagon(d=50);</pre>
=== Octagon (d= <Durchmesser>) ===
[[Datei:BOSL2-Octagon.png|mini|zentriert|alternativtext=octagon(d=50);|octagon(d=50);]]
<pre class="openscad">include <BOSL2/std.scad>
octagon(d=50);</pre>
=== regular_ngon (n=<Seitenanzahl>, d=<Durchmesser>) ===
[[Datei:BOSL2-regular ngon.png|mini|zentriert|alternativtext=regular_ngon|regular_ngon(n=7, d=50);]]
<pre class="openscad">include <BOSL2/std.scad>
regular_ngon(n=7, d=50);</pre>
=== side=<Seitenlänge> ===
Diese Module bieten dir auch zusätzliche Funktionalität. Sie können nach Seitenlänge dimensioniert werden:
[[Datei:BOSL2-Hexagon side50.png|mini|zentriert|alternativtext=hexagon(side=50);|hexagon(side=50);]]
<pre class="openscad">include <BOSL2/std.scad>
pentagon(side=50);</pre>
=== ir = <Innenradius> / id = <Innendurchmesser> ===
Sie können nach dem Radius/Durchmesser des umschriebenen Kreises (Innenkreis) dimensioniert werden:
[[Datei:BOSL2-Pentagon Innenradius.png|mini|zentriert|alternativtext=Innenradius|color("red") pentagon('''ir=25'''); color("yellow") circle(r=25,$fn=100);]]
<pre class="openscad">include <BOSL2/std.scad>
pentagon(ir=25);
pentagon(id=50);</pre>
=== realign=true/false ===
Die Polygone können um eine halbe Seite gedreht werden:
[[Datei:BOSL2-Pentagon realign.png|mini|zentriert|alternativtext=realign|pentagon(d=50, '''realign=false'''); #pentagon(d=50, '''realign=true''');]]
<pre class="openscad">include <BOSL2/std.scad>
left(30) pentagon(d=50, realign=true);
right(30) pentagon(d=50, realign=false);</pre>
=== rounding = <Rundung> ===
Die BOSL2-Polygone können abgerundet werden:
[[Datei:BOSL2-Polygon-rounding.png|mini|zentriert|alternativtext=rounding|pentagon(d=50, '''rounding=5''');]]
<pre class="openscad">include <BOSL2/std.scad>
pentagon(d=50, rounding=5);</pre>
=== show_anchors() ===
Die BOSL2-Polygone haben auch ein etwas anderes Anhangsverhalten als die regulären Polygone, die über $fn=<Seitenanzahl> erzeugt werden.
Ein Kreis mit einem kleinen <code>$fn=</code> hängt Dinge am idealen Kreis an, nicht entlang des erstellten Polygons:
[[Datei:BOSL2-polygon-outcircle-anchors.png|mini|zentriert|alternativtext=anchors Außenkreis|color("green") stroke(circle(d=50), closed=true); circle(d=50,$fn=6) show_anchors();]]
<pre class="openscad">include <BOSL2/std.scad>
color("green") stroke(circle(d=50), closed=true);
circle(d=50,$fn=6)
show_anchors();</pre>
Während ein BOSL2-n-Eck entlang des Polygons selbst (direkt) anhängt:
[[Datei:BOSL2-polygon-direct-anchors.png|mini|zentriert|alternativtext=anchors BOSL2 Polygone direkt|color("green") stroke(circle(d=50), closed=true); circle(d=50,$fn=6) show_anchors();]]
<pre class="openscad">include <BOSL2/std.scad>
hexagon(d=50)
show_anchors(custom=false);</pre>
Du kannst <code>anchor=</code> und <code>spin=</code> verwenden, genau wie bei anderen anhängbaren Formen. Die Ankerpunkte basieren jedoch darauf, wo der Ankervektor die Seite des n-Ecks schneiden würde, und sind möglicherweise nicht dort, wo du sie erwartest:
[[Datei:BOSL2-Pentagon-anchor.png|mini|zentriert|alternativtext=n-Polygon anchor|pentagon(d=50, '''anchor=FRONT+LEFT''') show_anchors(custom=false);]]
<pre class="openscad">include <BOSL2/std.scad>
pentagon(d=50, anchor=FRONT+LEFT)
show_anchors(custom=false);</pre>
=== Ankerpunkte für Seiten und Spitzen ===
n-Ecke haben auch benannte Ankerpunkte für ihre Seiten und Spitzen:
[[Datei:BOSL2-anchor-Spitzen-Seiten.png|mini|zentriert|alternativtext=Anker für Seiten und Spitzen|Spezielle Anker für die Spitzen und Seiten eines Pentagons (mit TikZ unter LaTeX erstellt)]]
Beachte, dass die Ankernamen in "" gesetzt werden müssen.
Zum Beispiel:
[[Datei:BOSL2-Pentagon anchor tip1.png|mini|zentriert|alternativtext=anchor="tip1"|pentagon(d=30, '''anchor="tip1" ''');]]
<pre class="openscad">include <BOSL2/std.scad>
pentagon(d=30, anchor="tip1");</pre>
<span id="sterne-stars"></span>
Beispiel mit attach():
[[Datei:BOSL2-anchor-Spitzen-Seiten attach.png|mini|zentriert|alternativtext=anchor="side2"|pentagon(d=30, anchor="side2") '''attach("tip0")''' circle(r=3,$fn=36);]]
<pre class="openscad">
include <BOSL2/std.scad>
pentagon(d=30, anchor="side2") attach("tip0") circle(r=3,$fn=36);
</pre>
== Sterne (Stars) ==
=== star() mit n, ir/id und or/od ===
Die BOSL2-Bibliothek hat Sterne als grundlegend unterstützte Form. Sie können eine beliebige Anzahl '''n''' von '''Spitzen''' haben. Du kannst die Form eines Sterns durch Spitzenanzahl, '''innere und äußere Scheitelpunkt-Radius/-Durchmesser''' angeben:
[[Datei:BOSL2-star n5 ir15 dr30-Veranschaulichung.png|mini|zentriert|alternativtext=Innerer und äußerer Radius bei star()|Veranschaulichung von den Parameter '''ir''' (oder id) und '''or''' (oder od). ''ir'' gibt den inneren Radius und or den äußeren Radius an. Die Anzahl der Zacken ist hier n=5. Siehe Code unten.]]
Begonnen wird der Stern mit einem Zacken nach rechts auf der X-Achse.
<pre class="openscad">
include <BOSL2/std.scad>
#circle(30, $fn=60);
color("blue") star(n=5, ir=15, or=30);
#circle(15, $fn=60);
color("darkblue") fwd(35) text("or=30", halign = "center", size=3);
color("yellow") text("ir=15",halign = "center", size=3, valign="center");
</pre>
=== star() mit Spannweite d ===
Statt '''od''' kann auch einfach '''d''' als Parameter verwendet werden.
[[Datei:BOSL2-star n3 id10 d50.png|mini|zentriert|alternativtext=star(n=3, id=10, d=50);|star(n=3, id=10, d=50);]]
<pre class="openscad">include <BOSL2/std.scad>
star(n=3, id=10, d=50);</pre>
[[Datei:BOSL2-star n5 id15 r25.png|mini|zentriert|alternativtext=star(n=5, id=15, r=25);|star(n=5, id=15, r=25);]]
<pre class="openscad">include <BOSL2/std.scad>
star(n=5, id=15, r=25);</pre>
[[Datei:BOSL2-star n10 id30 d50.png|mini|zentriert|alternativtext=star(n=10, id=30, d=50);|star(n=10, id=30, d=50);]]
<pre class="openscad">include <BOSL2/std.scad>
star(n=10, id=30, d=50);</pre>
=== star (n = <Spitzenanzahl>, step = <Anzahl zu überspringender Punkte>) ===
Oder du kannst die Sternform durch Spitzenanzahl '''n''' und Anzahl '''step''' der zu überspringenden Punkte angeben:
[[Datei:BOSL2-star n7 step2 d50.png|mini|zentriert|alternativtext=step|star(n=7, step=2, d=50);]]
<pre class="openscad">include <BOSL2/std.scad>
star(n=7, step=2, d=50);</pre>
[[Datei:BOSL2-star n7 step3 d50.png|mini|zentriert|alternativtext=step=3|star(n=7, step=3, d=50);]]
<pre class="openscad">include <BOSL2/std.scad>
star(n=7, step=3, d=50);</pre>
=== star() mit realign ===
Wenn dem <code>realign=</code>-Argument ein true-Wert übergeben wird, wird der Stern um einen halben Spitzenwinkel gedreht:
<pre class="openscad">include <BOSL2/std.scad>
left(30) star(n=5, step=2, d=50);
right(30) star(n=5, step=2, d=50, realign=true);</pre>
=== star() mit align_tip=<Anker> ===
Das <code>align_tip=</code>-Argument kann mit einem Vektor angegeben werden, damit du die erste Spitze in eine bestimmte Richtung ausrichten kannst:
[[Datei:BOSL2-star n5 align tip anchor tip0.png|mini|zentriert|alternativtext=align_tip=BACK|star(n=5, ir=15, or=30, align_tip=BACK) attach("tip0") color("blue") anchor_arrow2d();]]
<pre class="openscad">include <BOSL2/std.scad>
star(n=5, ir=15, or=30, align_tip=BACK)
attach("tip0") color("blue") anchor_arrow2d();</pre>
=== star() mit align_pit=<Anker> ===
Ebenso kann die erste Einkerbung oder Einbuchtung mit <code>align_pit=</code> in Richtung eines bestimmten Vektors ausgerichtet werden:
[[Datei:BOSL2-star n5 align pit BACK attach tip0.png|mini|zentriert|alternativtext=align_pit=BACK|star(n=5, ir=15, or=30, '''align_pit=BACK''') '''attach("tip0")''' color("blue") anchor_arrow2d();]]
<pre class="openscad">include <BOSL2/std.scad>
star(n=5, ir=15, or=30, align_pit=BACK)
attach("pit0") color("blue") anchor_arrow2d();</pre>
Du kannst <code>anchor=</code> und <code>spin=</code> verwenden, genau wie bei anderen anhängbaren Formen. Die Ankerpunkte basieren jedoch auf den äußersten Ausmaßen der Form und sind möglicherweise nicht dort, wo du sie erwartest:
[[Datei:BOSL2-star n5 anchor LEFT-show anchers.png|mini|zentriert|alternativtext=anchor=LEFT|star(n=5, step=2, d=50,'''anchor=LEFT''') '''show_anchors(custom=false)''';]]
<pre class="openscad">include <BOSL2/std.scad>
star(n=5, step=2, d=50)
show_anchors(custom=false);</pre>
=== Benannte Ankerpunkte bei star() ===
Sterne haben auch benannte Ankerpunkte für ihre Gruben, Spitzen und Mittelpunkte zwischen den Spitzen:
[[Datei:BOSL2-star n5 benannteAnker.png|mini|zentriert|alternativtext=benannten Ankerpunkte in star()|Zuordnung der benannten Ankerpunkte in star(). Spitzen beginnen mit "tipt0", Einkerbungen mit pit0.]]
==== Beispiel 1: anchor="tip0" attach("pit0") ====
[[Datei:BOSL2-star-n5 ir=15 or30 anchor tip0 pit0.png|mini|zentriert|alternativtext=anchor="tip0"|star(n=5, ir=15, or=30, anchor="tip0") attach("pit0") #circle(3);]]
<pre class="openscad">
include <BOSL2/std.scad>
star(n=5, ir=15, or=30, anchor="tip0") attach("pit0") #circle(3);
</pre>
==== Beispiel 2: anchor="pit0" attach("tip0") ====
[[Datei:BOSL2-star n5 anchor pit0 attach tip0.png|mini|zentriert|alternativtext=anchor="pit0" attach("tip0")|star(n=5, ir=15, or=30, anchor="pit0") attach("tip0") #circle(3);]]
<pre class="openscad">
include <BOSL2/std.scad>
star(n=5, ir=15, or=30, anchor="pit0") attach("tip0") #circle(3);
</pre>
<span id="tropfenform-2d-teardrop2d"></span>
== Tropfenform 2D (Teardrop2D) ==
Beim 3D-Druck möchtest du oft ein kreisförmiges Loch in eine vertikale Wand machen. Wenn das Loch jedoch zu groß ist, kann der Überhang an der Oberseite des Lochs Probleme beim Drucken auf einem FDM/FFF-Drucker verursachen. Wenn du kein Stützmaterial verwenden möchtest, kannst du einfach die Tropfenform verwenden. Das <code>teardrop2d()</code>-Modul ermöglicht es dir, eine 2D-Version der Tropfenform zu erstellen, damit du sie später extrudieren kannst:
[[Datei:BOSL2-teardrop2d r20.png|mini|zentriert|alternativtext=teardrop2d(r=20);|teardrop2d(r=20);]]
<pre class="openscad">include <BOSL2/std.scad>
teardrop2d(r=20);</pre>
=== Extrudiert als tropfenförmige Aussparung:
[[Datei:BOSL2-teardrop2d Loch linear extrudiert.png|mini|zentriert|alternativtext=Lineares Extrudieren eines Quadrats mit zentrierter Tropfenform|linear_extrude(5) { diff() { rect(50) attach(CTR,CTR, inside=true) teardrop2d(d=20); }}]]
<pre class="openscad">
include <BOSL2/std.scad>
linear_extrude(5) {
diff() {
rect(50)
attach(CTR,CTR, inside=true)
teardrop2d(d=20);
}}</pre>
=== ang=<Überhangwinkel> ===
Der Standard-Überhangwinkel beträgt 45 Grad, aber du kannst ihn mit dem <code>ang=</code>-Argument anpassen:
[[Datei:BOSL2-teardrop2d ang20.png|mini|zentriert|alternativtext=teardrop2d(d=50, ang=20);|teardrop2d(d=50, ang=20);]]
<pre class="openscad">include <BOSL2/std.scad>
teardrop2d(d=50, ang=20);</pre>
=== cap_h=<Kapphöhe> ===
Wenn du es vorziehst, die Oberseite des Tropfens abzuflachen, um das Bridging zu fördern, kannst du das <code>cap_h=</code>-Argument verwenden:
[[Datei:BOSL2-teardrop2d ang20 cap h38c.png|mini|zentriert|alternativtext=teardrop2d(d=50, ang=20, cap_h=38);|teardrop2d(d=50, ang=20, '''cap_h=38''');]]
<pre class="openscad">include <BOSL2/std.scad>
teardrop2d(d=50, ang=20, cap_h=38);</pre>
=== show_anchors() bei teardrop2d ===
Du kannst <code>anchor=</code> und <code>spin=</code> verwenden, genau wie bei anderen anhängbaren Formen. Die Ankerpunkte basieren jedoch auf den äußersten Ausmaßen der Form und sind möglicherweise nicht dort, wo du sie erwartest:
[[Datei:BOSL2-teardrop2d anchorBACK show anchors.png|mini|zentriert|alternativtext=teardrop2d(d=50, anchor=BACK) show_anchors();|teardrop2d(d=50, anchor=BACK) show_anchors();]]
<pre class="openscad">
include <BOSL2/std.scad>
teardrop2d(d=50, anchor=BACK)
show_anchors();
</pre>
<span id="verklebte-kreise-glued-circles"></span>
== Verklebte Kreise (Glued Circles) ==
Eine ungewöhnlichere Form, die BOSL2 bietet, sind verklebte Kreise (Glued Circles). Es handelt sich im Grunde um ein Paar von Kreisen, die durch etwas verbunden sind, das wie ein klebriger Meniskus aussieht:
[[Datei:BOSL2-glued circles d30 spread40.png|mini|zentriert|alternativtext=glued_circles(d=30, spread=40);|glued_circles(d=30, spread=40);]]
<pre class="openscad">include <BOSL2/std.scad>
glued_circles(d=30, spread=40);</pre>
=== d/r=<Kreisdurchmesser/Kreisradius>, spread=<Abstand Kreismittelpunkte> ===
Die <code>r=</code>/<code>d=</code>-Argumente können den Radius oder Durchmesser der beiden Kreise angeben:
<pre class="openscad">include <BOSL2/std.scad>
glued_circles(r=20, spread=45);</pre>
<pre class="openscad">include <BOSL2/std.scad>
glued_circles(d=40, spread=45);</pre>
Das <code>spread=</code>-Argument gibt den Abstand zwischen den Mittelpunkten der beiden Kreise an:
<pre class="openscad">include <BOSL2/std.scad>
glued_circles(d=30, spread=30);</pre>
=== tangent = <Tangentenwinkel-Miniskus> ===
Das <code>tangent=</code>-Argument gibt den Winkel der Tangente des Meniskus an den beiden Kreisen an:
[[Datei:BOSL2-glued circles d30 spread40 tangent=45.png|mini|zentriert|alternativtext=glued_circles(d=30, spread=30, tangent=45);|glued_circles(d=30, spread=30, tangent=45);]]
Auch negative Werte sind für den Tangentenwinkel möglich, so wird aus der Einbuchtung eine Ausbuchtung:
[[Datei:BOSL2-glued circles d30 spread40 tangent=-45.png|mini|zentriert|alternativtext= tangent=-40|glued_circles(d=30, spread=30, tangent=-40);]]
<pre class="openscad">include <BOSL2/std.scad>
glued_circles(d=30, spread=30, tangent=-45);</pre>
=== Langloch mit tangent=0 ===
Mit einem Tangentenwinkel von 0 erhält man eine Form, die sehr nützlich sein kann, um Langlöcher zu konstruieren.
[[Datei:BOSL2-glued circles Langlochform tangent0.png|mini|zentriert|alternativtext=Langlochform mit glued_circles|Langlochform mit glued_circles(d=30, spread=30, tangent=0);]]
<pre class="openscad">
include <BOSL2/std.scad>
glued_circles(d=30, spread=30, tangent=0);
</pre>
==== 3D-Langloch in Platte ====
[[Datei:BOSL2-glued circles Langlochform tangent0 3D.png|mini|zentriert|alternativtext=3D-Langloch glued_circlesh |Langloch (3D) durch lineares Extrudieren von glued_circles]]
<pre class="openscad">
include <BOSL2/std.scad>
difference() {
cube([80, 80, 10], center = false);
translate([40, 40, -1])
linear_extrude(height = 12) {
glued_circles(d = 30, spread = 30, tangent = 0);
}
}
</pre>
=== Gerippte Wand ===
Eine nützliche Sache, die du tun kannst, ist, einige <code>glued_circle()</code>s in einer Linie anzuordnen und sie dann zu extrudieren, um eine gerippte Wand zu erstellen:
[[Datei:BOSL2-glued circles gerippte Wand=-45.png|mini|zentriert|alternativtext=Gerippte Wand mit extrudierten glued_circles|$fn=64; s=10; linear_extrude(height=50,convexity=16,center=true) xcopies(s*sqrt(2),n=3) glued_circles(d=s, spread=s*sqrt(2), tangent=45);]]
<pre class="openscad">include <BOSL2/std.scad>
$fn=36; s=10;
linear_extrude(height=50,convexity=16,center=true)
xcopies(s*sqrt(2),n=3)
glued_circles(d=s, spread=s*sqrt(2), tangent=45);</pre>
Du kannst <code>anchor=</code> und <code>spin=</code> verwenden, genau wie bei anderen anhängbaren Formen. Die Ankerpunkte basieren jedoch auf den äußersten Ausmaßen der Form und sind möglicherweise nicht dort, wo du sie erwartest:
<pre class="openscad">include <BOSL2/std.scad>
glued_circles(d=40, spread=40, tangent=45)
show_anchors();</pre>
2gilibmky8msrerncqtm1k2mdfxmfis
1093537
1093536
2026-11-08T17:16:55Z
Jowi-ammerbuch
115360
/* 3D-Langloch in Platte */
1093537
wikitext
text/x-wiki
{{MyNavi
|zurück = [[OpenSCAD Benutzerhandbuch/_BOSL2-Distributoren|Zurück]]
|buch = [[OpenSCAD Benutzerhandbuch/_BOSL2|BOSL2-Inhalt]]
|weiter = [[OpenSCAD Benutzerhandbuch/_BOSL2-3D|Weiter]]
}}
== 2D Grundformen (2D Primitive) ==
OpenSCAD bietet zwei eingebaute 2D-Grundformen: <code>square()</code> und <code>circle()</code>. Du kannst sie weiterhin auf die gewohnte Weise verwenden:
<pre class="openscad">include <BOSL2/std.scad>
square([60,40], center=true);</pre>
<pre class="openscad">include <BOSL2/std.scad>
circle(r=50);</pre>
<pre class="openscad">include <BOSL2/std.scad>
circle(d=100, $fn=8);</pre>
Diese Module wurden in der BOSL2-Bibliothek in drei Bereichen erweitert: Verankerung (Anchoring), Drehung (Spin) und Anhängbarkeit (Attachability).
<span id="verankerung-anchoring"></span>
=== Verankerung (Anchoring): ===
Wenn du ein <code>square()</code> erstellst, kannst du angeben, welche Ecke oder Seite am Ursprung verankert werden soll. Dies ersetzt das <code>center=</code>-Argument und ist flexibler. Das <code>anchor=</code>-Argument nimmt einen Vektor als Wert entgegen, der in grober Richtung der Seite oder Ecke zeigt, die du am Ursprung ausrichten möchtest.
=== anchor=[0,1] oder anchor=BACK ===
[[Datei:BOSL2-anchor-0-1.png|mini|zentriert|alternativtext=anchor=[0,1]);|square([60,40], '''anchor=[0,1]''');<br>
Oder: square([60,40], '''anchor=BACK''');]]
Um beispielsweise das '''Zentrum der hinteren Kante am Ursprung''' auszurichten, setzt du den Anker auf <code>[0,1]</code>:
<pre class="openscad">
include <BOSL2/std.scad>
square([60,40], anchor=[0,1]);
</pre>
Mit den leichter verständlichen vordefinierten '''Vektor-Konstanten''':
<pre class="openscad">
include <BOSL2/std.scad>
square([60,40], anchor=BACK+CENTER);
</pre>
=== anchor=[1,-1] oder anchor=RIGHT+FRONT ===
Um die '''vordere rechte Ecke am Ursprung''' auszurichten:
[[Datei:BOSL2-anchor-1 -1.png|mini|zentriert|alternativtext=anchor=RIGHT+FRONT);|square([60,40], '''anchor=[1,-1]''');<br>
Oder: square([60,40], '''anchor=RIGHT+FRONT''');]]
<pre class="openscad">
include <BOSL2/std.scad>
square([60,40], anchor=[1,-1]);
</pre>
'''Mit Vektor-Konstanten:'''
<pre class="openscad">
include <BOSL2/std.scad>
square([60,40], anchor=RIGHT+FRONT);
</pre>
=== anchor=[0,0] oder anchor=CENTER '''Fetter Text'''===
Um es zu '''zentrieren''':
<pre class="openscad">
include <BOSL2/std.scad>
square([60,40], anchor=[0,0]);
</pre>
'''Mit Vektor-Konstanten:'''
<pre class="openscad">
include <BOSL2/std.scad>
square([60,40], anchor=CENTER);
</pre>
=== Vektor-Konstanten am Rechteck ===
Um die Angabe von Vektoren übersichtlicher zu gestalten, sind mehrere Standard-Vektorkonstanten definiert:
[[Datei:BOSL2-anchor-Konstanten-Rechteck.png|gerahmt|zentriert|alternativtext=BOSL2 vordefinierte anchor-Konstanten|Die in BOSL2 vordefinierten anchor-Konstanten]]
{| class="wikitable"
|-
! Konstante
! Richtung
! Wert
|-
| LEFT
| X-
| [-1, 0, 0]
|-
| RIGHT
| X+
| [ 1, 0, 0]
|-
| FRONT / FORWARD / FWD
| Y-
| [ 0,-1, 0]
|-
| BACK
| Y+
| [ 0, 1, 0]
|-
| BOTTOM / BOT / BTM / DOWN
| Z-
| [ 0, 0,-1] (nur 3D)
|-
| TOP / UP
| Z+
| [ 0, 0, 1] (nur 3D)
|-
| CENTER / CTR
| Zentriert
| [ 0, 0, 0]
|}
Beachte, dass du die meisten dieser Konstanten (außer <code>UP</code>/<code>DOWN</code> natürlich) auch für Anker bei 2D-Formen verwenden kannst, obwohl es sich um 3D-Vektoren handelt:
<pre class="openscad">include <BOSL2/std.scad>
square([60,40], anchor=BACK);</pre>
<pre class="openscad">include <BOSL2/std.scad>
square([60,40], anchor=CENTER);</pre>
Du kannst Vektoren addieren, um auf Ecken zu zeigen:
<pre class="openscad">include <BOSL2/std.scad>
square([60,40], anchor=FRONT+RIGHT);</pre>
=== anchor = polar_to_xy ===
Für <code>circle()</code> kann der Ankervektor auf jeden beliebigen '''Punkt des Kreisumfangs''' zeigen:
[[Datei:BOSL2-anchor-polar to xy-circle.png|gerahmt|zentriert|alternativtext=anchor = polar_to_xy|anchor = polar_to_xy(1,Alpha), für Alpha = 0, 45, 90, ...]]
==== Beispiel: anchor=polar_to_xy(1,45) =====
[[Datei:BOSL2-anchor-polar to 1-45-octagon.png|mini|zentriert|alternativtext=circle(d=50, anchor=polar_to_xy(1,45), $fn = 8);|circle(d=50, anchor=polar_to_xy(1,45), $fn = 8);]]
<pre class="openscad">
include <BOSL2/std.scad>
circle(d=50, anchor=polar_to_xy(1,45), $fn = 8);
</pre>
Beachte, dass der Radius für den Anker keine Rolle spielt, da nur die Richtung des Ankers das Ergebnis beeinflusst.
=== show_anchors() ===
[[Datei:BOSL2-show anchor.png|mini|zentriert|show_anchors]]
Du kannst die typischen Ankerpunkte sehen, indem du <code>show_anchors()</code> als Kind der Form übergibst:
<pre class="openscad">include <BOSL2/std.scad>
square([60,40], center=true)
show_anchors();</pre>
<pre class="openscad">include <BOSL2/std.scad>
circle(d=50)
show_anchors();</pre>
<span id="drehung-spin"></span>
=== Drehung (Spin): ===
Die zweite Erweiterung von <code>square()</code> und <code>circle()</code> ist die Drehung (Spin). Wenn du die Form erstellst, kannst du sie mit dem <code>spin=</code>-Argument an Ort und Stelle drehen. Du übergibst einfach die Anzahl der Grad, um die sie im Uhrzeigersinn gedreht werden soll:
<pre class="openscad">include <BOSL2/std.scad>
square([60,40], anchor=CENTER, spin=30);</pre>
Die Verankerung oder Zentrierung erfolgt vor der Drehung:
<pre class="openscad">include <BOSL2/std.scad>
square([60,40], anchor=BACK, spin=30);</pre>
Bei Kreisen kann Spin nützlich sein, wenn auch <code>$fn=</code> angegeben wird:
<pre class="openscad">include <BOSL2/std.scad>
circle(d=50, $fn=6, spin=15);</pre>
Da die Verankerung vor der Drehung erfolgt, kannst du beides zusammen verwenden, um um den Anker herum zu drehen:
<pre class="openscad">include <BOSL2/std.scad>
circle(d=50, $fn=6, anchor=LEFT, spin=15);</pre>
<span id="anhängbarkeit-attachability"></span>
=== Anhängbarkeit (Attachability): ===
Die dritte Erweiterung von <code>square()</code> und <code>circle()</code> ist, dass du sie auf verschiedene Weise an Ankerpunkten zusammenhängen kannst. Dies geschieht, indem du eine Form zum Kind der Form machst, an die du sie anhängen möchtest.
==== Standard (ohne Spez. für anchor oder position) ====
Standardmäßig wird das Kind beim einfachen Untereinanderstellen im Zentrum der Elternform angehängt.
[[Datei:BOSL2-attach-standard-normal.png|mini|zentriert|alternativtext=square(50) #square(50);|square(50) #square(50);<br>
Kind-Objekt (rot) wird ans Zentrum des Elternobjekts angehängt]]
<pre class="openscad">
include <BOSL2/std.scad>
square(50) #square(50);
</pre>
==== anchor für child spezifiziert ====
[[Datei:BOSL2-attach-anchor-LEFTplusFWD.png|mini|zentriert|alternativtext=square(50, center=true) #square([20,40], anchor=LEFT+FWD);|square(50, center=true)#square([20,40], '''anchor=LEFT+FWD''');]]
<pre class="openscad">include <BOSL2/std.scad>
square(50, center=true)
#square([20,40], anchor=LEFT+FWD);</pre>
==== position() ====
[[Datei:BOSL2-attach-position.png|mini|zentriert|alternativtext=position(RIGHT)|square(50) '''position(RIGHT)''' #square(25) '''position(BACK)''' #square(25);]]
Durch Hinzufügen des <code>position()</code>-Moduls kannst du das Kind an jedem Ankerpunkt '''des Elternteils''' positionieren, das "Kindes-Kind wird am Ankerpunkt des übergeordneten Objekts positioniert:
<pre class="openscad">
include <BOSL2/std.scad>
square(50) position(RIGHT) #square(25)
position(BACK) #square(25);
</pre>
==== orient() ====
Ankerpunkte sind jedoch nicht nur Positionen auf dem Elternteil. Sie haben auch eine Ausrichtung. In den meisten Fällen zeigt die Ausrichtung eines Ankerpunkts nach außen, weg von der Fläche der Wand, also im Allgemeinen vom Zentrum der Form weg.
[[Datei:BOSL2-show anchor.png|mini|zentriert|show_anchors]]
Wenn du das Kind so ausrichten möchtest, dass es der Ausrichtung eines Ankerpunkts entspricht, kannst du das <code>orient()</code>-Modul verwenden. Es positioniert das Kind nicht, es dreht es nur:
[[Datei:BOSL2-attach-orient anchor.png|mini|zentriert|alternativtext= orient(anchor=LEFT+BOTTOM)|square(50) '''orient(anchor=LEFT+BOTTOM)''' #square([10,40]);]]
<pre class="openscad">include <BOSL2/std.scad>
square(50)
orient(anchor=LEFT+BOTTOM) #square([10,40]);</pre>
Das geht auch beim '''Kreis (circle)''' mit '''polar_to_xy''':
[[Datei:BOSL2-attach-orient polar to xy circle.png|mini|zentriert|alternativtext=orient(polar_to_xy(1,30))|circle(d=50) ''' orient(polar_to_xy(1,30))''' #square([10,40], anchor=FWD);]]
<pre class="openscad">include <BOSL2/std.scad>
circle(d=50)
orient(polar_to_xy(1,30))
#square([10,40], anchor=FWD);</pre>
==== position() + orient() ====
Du kannst <code>position()</code> und <code>orient()</code> zusammen verwenden, um sowohl zu positionieren als auch an einem Ankerpunkt auszurichten:
[[Datei:BOSL2-attach-position pluss orient polar to xy circle.png|mini|zentriert|alternativtext=position(polar_to_xy(1,30)) orient(polar_to_xy(1,30))|circle(d=50) '''position(polar_to_xy(1,30)) orient(polar_to_xy(1,30))''' #square([10,40], anchor=FWD);]]
<pre class="openscad">include <BOSL2/std.scad>
circle(d=50)
position(polar_to_xy(1,30))
orient(polar_to_xy(1,30))
#square([10,40], anchor=FWD);</pre>
=== attach () mit einem Argument ===
Aber es ist einfacher das <code>attach()</code>-Modul zu verwenden, um beides auf einmal zu erledigen:
[[Datei:BOSL2-attach-position pluss orient polar to xy circle.png|mini|zentriert|alternativtext=attach(polar_to_xy(1,30))|circle(d=50) '''attach(polar_to_xy(1,30))''' #square([10,40], anchor=FWD); ]]
Gleiches Ergebnis, aber übersichtlicherer Code.
<pre class="openscad">include <BOSL2/std.scad>
square(50, center=true)
attach(LEFT+BACK)
#square([10,40], anchor=FWD);</pre>
=== attach () mit zwei Argumenten ===
Anstatt den <code>anchor=</code> im Kind anzugeben, kannst du ein '''zweites Argument''' an <code>attach()</code> übergeben, das ihm sagt, welche Seite des Kindes mit dem Elternteil verbunden werden soll:
<pre class="openscad">
include <BOSL2/std.scad>
circle(d=50) attach(polar_to_xy(1,30), FWD) #square([10,40]);
</pre>
Damit lässt sich der Code noch mehr straffen.
[[Datei:BOSL2-attach-position pluss orient polar to xy circle.png|mini|zentriert|alternativtext=attach(polar_to_xy(1,30), FWD)|circle(d=50) '''attach(polar_to_xy(1,30), FWD)''' #square([10,40]); ]]
<span id="rechtecke-rectangles"></span>
== Rechtecke (Rectangles) ==
=== rect() ===
Die BOSL2-Bibliothek bietet eine Alternative zu <code>square()</code>, die mehr Funktionen unterstützt. Sie heißt <code>rect()</code>. Du kannst sie genauso verwenden wie <code>square()</code>, aber sie bietet auch erweiterte Funktionalität.
=== rect() mit rounding ===
[[Datei:BOSL2-rect rounding.png|mini|zentriert|alternativtext=rounding=10|rect([60,40], '''rounding=10''');]]
rect() erlaubt dir, die Ecken des Rechtecks abzurunden:
<pre class="openscad">include <BOSL2/std.scad>
rect([60,40], rounding=10);</pre>
=== rect() mit chamfer ===
[[Datei:BOSL2-rect chamfer.png|mini|zentriert|alternativtext=rect([60,40], chamfer=10);|rect([60,40], '''chamfer=10''');]]
Du kannst die Ecken des Rechtecks auch abfasen:
<pre class="openscad">include <BOSL2/std.scad>
rect([60,40], chamfer=10);</pre>
=== Unterschiedliche Abrundungen und Fasen an einem Rechteck ===
Du kannst sogar angeben, welche Ecken abgerundet oder abgefast werden. Wenn du eine Liste mit vier Größenwerten an die <code>rounding=</code>- oder <code>chamfer=</code>-Argumente übergibst, erhält jede Ecke ihre eigene Größe. Der Reihe nach geht es von der hinteren rechten Ecke (Quadrant I) gegen den Uhrzeigersinn zur hinteren linken Ecke (Quadrant II), zur vorderen linken Ecke (Quadrant III) und zur vorderen rechten Ecke (Quadrant IV):
Wenn eine Größe als <code>0</code> angegeben wird, gibt es keine Rundung und/oder Fase für die Ecke dieses Quadranten:
<pre class="openscad">include <BOSL2/std.scad>
rect([60,40], rounding=[0,5,10,15]);</pre>
<pre class="openscad">include <BOSL2/std.scad>
rect([60,40], chamfer=[0,5,10,15]);</pre>
Du kannst sowohl <code>rounding=</code>- als auch <code>chamfer=</code>-Argumente angeben, um Rundung und Fase zu mischen, aber nur, wenn du es pro Ecke angibst. Wenn du eine Rundung in einer Ecke möchtest, gib eine Fase von 0 für diese Ecke an und umgekehrt:
[[Datei:BOSL2-rect chamfer-rounding-mixed.png|mini|zentriert|alternativtext=ounding=[5,0,10,0], chamfer=[0,5,0,15]|rect([60,40], '''rounding=[5,0,10,0], chamfer=[0,5,0,15]''');]]
<pre class="openscad">include <BOSL2/std.scad>
rect([60,40], rounding=[5,0,10,0], chamfer=[0,5,0,15]);</pre>
<span id="ellipsen-ellipses"></span>
== Ellipsen (Ellipses) ==
Die BOSL2-Bibliothek bietet auch eine erweiterte Entsprechung von <code>circle()</code>, die <code>ellipse()</code> heißt. Du kannst sie genauso verwenden wie <code>circle()</code>, aber sie bietet auch erweiterte Funktionalität. Zum Beispiel erlaubt sie mehr Kontrolle über ihre Größe.
Da ein Kreis in OpenSCAD nur durch ein regelmäßiges Polygon mit einer Anzahl gerader Seiten angenähert werden kann, kann dies zu Ungenauigkeiten in Größe und Form führen. Um dem entgegenzuwirken, werden auch die Argumente <code>realign=</code> und <code>circum=</code> bereitgestellt.
=== realign= (ellipse-Argument) ===
Das <code>realign=</code>-Argument rotiert, wenn es auf <code>true</code> gesetzt wird, die <code>ellipse()</code> um den halben Winkel zwischen den Polygonseiten:
[[Datei:BOSL2-ellipse-realign.png|mini|zentriert|alternativtext=realign=true|#ellipse(d=100, $fn=8); color("lime") ellipse(d=100, $fn=8, '''realign=true''');]]
<pre class="openscad">
include <BOSL2/std.scad>
#ellipse(d=100, $fn=8);
color("lime") ellipse(d=100, $fn=8, realign=true);
</pre>
=== circum= (ellipse-Argument) ===
[[Datei:BOSL2-ellipse-circum.png|mini|zentriert|alternativtext=circum=true|Vergleich: rot (außen) mit circum=true und blau (innen) ohne circum. Referenz: idealer Kreis in gelb.]]
<pre class="openscad">
include <BOSL2/std.scad>
color("red") ellipse(d=100, $fn=6, circum=true);
color("yellow") ellipse(d=100, $fn=360);
color("blue") ellipse(d=100, $fn=6);
</pre>
Das <code>circum=</code>-Argument bewirkt, wenn es auf true gesetzt wird, dass das Polygon, das die <code>ellipse()</code> bildet, den idealen Kreis '''umschreibt''', anstatt ihn einzuschreiben.
Den idealen Kreis ''einschreiben'':
<pre class="openscad">include <BOSL2/std.scad>
color("green") ellipse(d=100, $fn=360);
ellipse(d=100, $fn=6);</pre>
Den idealen Kreis ''umschreiben'':
<pre class="openscad">include <BOSL2/std.scad>
ellipse(d=100, $fn=6, circum=true);
color("green") ellipse(d=100, $fn=360);</pre>
=== Ellipse mit 2 Radien ===
Das <code>ellipse()</code>-Modul kann, wie der Name schon sagt, mit separaten X- und Y-Radien oder -Durchmessern angegeben werden. Dazu gibst du einfach <code>r=</code> oder <code>d=</code> mit einer Liste von zwei Radien oder Durchmessern an:
[[Datei:BOSL2-ellipse-2Radien.png|mini|zentriert|alternativtext=2 Radien|ellipse('''r=[30,20]''');]]
==== r=[r1,r2] ====
<pre class="openscad">include <BOSL2/std.scad>
ellipse(r=[30,20]);</pre>
==== d=[d1,d2]====
<pre class="openscad">include <BOSL2/std.scad>
ellipse(d=[60,40]);</pre>
==== ellipse mit anchor ====
Wie bei <code>circle()</code> kannst du <code>ellipse()</code>-Formen verankern, drehen und anhängen:
[[Datei:BOSL2-ellipse-anchor.png|mini|zentriert|alternativtext=ellipse mit anchor|ellipse(d=[50,20], '''anchor=BACK'''); #ellipse(d=[50,20], '''anchor=FRONT''');]]
<pre class="openscad">
include <BOSL2/std.scad>
ellipse(d=[50,20], anchor=BACK);
#ellipse(d=[50,20], anchor=FRONT);
</pre>
==== ellipse mit attach ====
[[Datei:BOSL2-ellipse-attach.png|mini|zentriert|alternativtext=ellipse mit attach|ellipse(d=50) '''attach(BACK+RIGHT, FRONT+LEFT)''' #ellipse(d=[40,20]);]]
<pre class="openscad">
include <BOSL2/std.scad>
ellipse(d=50)
attach(BACK+RIGHT, FRONT+LEFT)
ellipse(d=30);
</pre>
<span id="rechtwinklige-dreiecke-right-triangles"></span>
==== ellipse mit spin ====
[[Datei:BOSL2-ellipse-attach-spin-anchor.png|mini|zentriert|alternativtext=spin = 90 bei ellipse|ellipse(d=50) attach(BACK) #ellipse(d=[40,20], '''spin=90''', anchor=LEFT);]]
<pre class="openscad">
include <BOSL2/std.scad>
ellipse(d=50)
attach(BACK)
#ellipse(d=[40,20], spin=90, anchor=LEFT);
</pre>
== Rechtwinklige Dreiecke (Right Triangles) ==
Die BOSL2-Bibliothek bietet eine einfache Möglichkeit, ein 2D-rechtwinkliges Dreieck mit dem <code>right_triangle()</code>-Modul zu erstellen:
[[Datei:BOSL2-right triangle.png|mini|zentriert|alternativtext=right_triangle([40,30])|right_triangle([40,30]);]]
<pre class="openscad">include <BOSL2/std.scad>
right_triangle([40,30]);</pre>
=== xflip() bei right_triangle ===
Du kannst <code>xflip()</code> und <code>yflip()</code> verwenden, um zu ändern, in welchem Quadranten das Dreieck gebildet wird:
[[Datei:BOSL2-right triangle xflip.png|mini|zentriert|alternativtext=right_triange mit xflip()|right_triangle([40,30]); '''xflip()''' #right_triangle([40,30]);]]
<pre class="openscad">include <BOSL2/std.scad>
xflip() right_triangle([40,30]);</pre>
=== yflip() bei right_triangle ===
[[Datei:BOSL2-right triangle yflip.png|mini|zentriert|alternativtext=right_triangle([40,30]) mit yflip()|right_triangle([40,30]); '''yflip()''' #right_triangle([40,30]);]]
<pre class="openscad">include <BOSL2/std.scad>
yflip() right_triangle([40,30]);</pre>
=== xflip() & yflip() bei right_triangle ===
[[Datei:BOSL2-right triangle xflip yflip.png|mini|zentriert|alternativtext=xflip() yflip()|right_triangle([40,30]); xflip() yflip() #right_triangle([40,30]);]]
<pre class="openscad">include <BOSL2/std.scad>
xflip() yflip() right_triangle([40,30]);</pre>
=== spin= bei right_triangle ===
Oder alternativ einfach mit <code>spin=</code> in den richtigen Quadranten drehen:
[[Datei:BOSL2-right triangle spin.png|mini|zentriert|alternativtext=right_triangle([40,30]) mit spin=90)|right_triangle([40,30]);
#right_triangle([40,30], '''spin=90''');]]
<pre class="openscad">include <BOSL2/std.scad>
right_triangle([40,30], spin=90);</pre>
<pre class="openscad">include <BOSL2/std.scad>
right_triangle([40,30], spin=-90);</pre>
Du kannst bei rechtwinkligen Dreiecken auch Verankerung verwenden:
<pre class="openscad">include <BOSL2/std.scad>
right_triangle([40,30], anchor=FWD+RIGHT);</pre>
<span id="trapeze-trapezoids"></span>
== Trapeze (Trapezoids) ==
OpenSCAD bietet keine einfache Möglichkeit, allgemeine 2D-Dreiecke, Trapeze oder Parallelogramme zu erstellen. Die BOSL2-Bibliothek kann all diese Formen mit dem <code>trapezoid()</code>-Modul bereitstellen.
=== Dreieck ===
Um ein gleichseitiges Dreieck zu erstellen, setze einfach eine der Breiten auf null:
[[Datei:BOSL2-trapezoid dreieck.png|mini|zentriert|alternativtext=Dreieck|trapezoid(w1=50, w2=0, h=40);<br>
Dreieck mit Seitenlänge = 50]]
<pre class="openscad">include <BOSL2/std.scad>
trapezoid(w1=50, w2=0, h=40);</pre>
Um ein rechtwinkliges Dreieck zu erstellen, musst du das <code>shift=</code>-Argument verwenden, um die Rückseite des Trapezes entlang der X-Achse zu verschieben:
[[Datei:BOSL2-trapezoid dreieck-rechtwinklig.png|mini|zentriert|alternativtext=Rechtwinkliges Dreieck|trapezoid(w1=50, w2=0, h=50, shift=-25);]]
<pre class="openscad">include <BOSL2/std.scad>
trapezoid(w1=50, w2=0, h=50, shift=-25);</pre>
<pre class="openscad">include <BOSL2/std.scad>
trapezoid(w1=50, w2=0, h=50, shift=25);</pre>
<pre class="openscad">include <BOSL2/std.scad>
trapezoid(w1=0, w2=50, h=50, shift=-25);</pre>
<pre class="openscad">include <BOSL2/std.scad>
trapezoid(w1=0, w2=50, h=50, shift=25);</pre>
=== Trapez ===
Du kannst ein Trapez erstellen, indem du für vorne (<code>w1=</code>) und hinten (<code>w2=</code>) von null verschiedene Breiten angibst:
[[Datei:BOSL2-trapezoid trapez.png|mini|zentriert|alternativtext=Trapez|trapezoid(w1=30, w2=50, h=50);]]
<pre class="openscad">include <BOSL2/std.scad>
trapezoid(w1=30, w2=50, h=50);</pre>
=== Parallelogramm ===
Ein Parallelogramm ist nur eine Frage der Verwendung der gleichen Breite für vorne und hinten, mit einer Verschiebung entlang der X-Achse:
[[Datei:BOSL2-trapezoid parallelogram.png|mini|zentriert|alternativtext=Parallelogramm|trapezoid(w1=50, w2=50, shift=20, h=50);]]
<pre class="openscad">include <BOSL2/std.scad>
trapezoid(w1=50, w2=50, shift=20, h=50);</pre>
=== Viereck ===
Ein Viereck kann erstellt werden, indem ungleiche, von null verschiedene Breiten für vorne (<code>w1=</code>) und hinten (<code>w2=</code>) verwendet werden, wobei die Rückseite entlang der X-Achse verschoben wird:
[[Datei:BOSL2-trapezoid viereck.png|mini|zentriert|alternativtext=Viereck|trapezoid(w1=50, w2=30, shift=20, h=50);]]
<pre class="openscad">include <BOSL2/std.scad>
trapezoid(w1=50, w2=30, shift=20, h=50);</pre>
Du kannst <code>anchor=</code> und <code>spin=</code> verwenden, genau wie bei anderen anhängbaren Formen. Die Ausrichtungen der Ankerpunkte basieren jedoch auf den Seitenwinkeln der Flächen und sind möglicherweise nicht das, was du erwartest:
<pre class="openscad">include <BOSL2/std.scad>
trapezoid(w1=30, w2=50, h=50)
show_anchors();</pre>
<span id="regelmäßige-n-ecke-regular-n-gons"></span>
== Regelmäßige n-Ecke (Regular N-Gons) ==
OpenSCAD ermöglicht es dir, regelmäßige n-Ecke (Fünfeck, Sechseck usw.) zu erstellen, indem du <code>circle()</code> mit <code>$fn</code> verwendest. Obwohl dies prägnant ist, mag es auf den ersten Blick weniger offensichtlich sein:
<pre class="openscad">include <BOSL2/std.scad>
circle(d=50, $fn=5);</pre>
Die BOSL2-Bibliothek hat Module, die für gängige n-Ecke klarer benannt sind:
=== Pentagon (d=<Durchmesser>) ===
[[Datei:BOSL2-Pentagon.png|mini|zentriert|alternativtext=Pentagon|pentagon(d=50);]]
<pre class="openscad">include <BOSL2/std.scad>
pentagon(d=50);</pre>
=== Hexagon (d=<Durchmesser>) ===
[[Datei:BOSL2-Hexagon.png|mini|zentriert|alternativtext=Hexagon| hexagon(d=50);]]
<pre class="openscad">include <BOSL2/std.scad>
hexagon(d=50);</pre>
=== Octagon (d= <Durchmesser>) ===
[[Datei:BOSL2-Octagon.png|mini|zentriert|alternativtext=octagon(d=50);|octagon(d=50);]]
<pre class="openscad">include <BOSL2/std.scad>
octagon(d=50);</pre>
=== regular_ngon (n=<Seitenanzahl>, d=<Durchmesser>) ===
[[Datei:BOSL2-regular ngon.png|mini|zentriert|alternativtext=regular_ngon|regular_ngon(n=7, d=50);]]
<pre class="openscad">include <BOSL2/std.scad>
regular_ngon(n=7, d=50);</pre>
=== side=<Seitenlänge> ===
Diese Module bieten dir auch zusätzliche Funktionalität. Sie können nach Seitenlänge dimensioniert werden:
[[Datei:BOSL2-Hexagon side50.png|mini|zentriert|alternativtext=hexagon(side=50);|hexagon(side=50);]]
<pre class="openscad">include <BOSL2/std.scad>
pentagon(side=50);</pre>
=== ir = <Innenradius> / id = <Innendurchmesser> ===
Sie können nach dem Radius/Durchmesser des umschriebenen Kreises (Innenkreis) dimensioniert werden:
[[Datei:BOSL2-Pentagon Innenradius.png|mini|zentriert|alternativtext=Innenradius|color("red") pentagon('''ir=25'''); color("yellow") circle(r=25,$fn=100);]]
<pre class="openscad">include <BOSL2/std.scad>
pentagon(ir=25);
pentagon(id=50);</pre>
=== realign=true/false ===
Die Polygone können um eine halbe Seite gedreht werden:
[[Datei:BOSL2-Pentagon realign.png|mini|zentriert|alternativtext=realign|pentagon(d=50, '''realign=false'''); #pentagon(d=50, '''realign=true''');]]
<pre class="openscad">include <BOSL2/std.scad>
left(30) pentagon(d=50, realign=true);
right(30) pentagon(d=50, realign=false);</pre>
=== rounding = <Rundung> ===
Die BOSL2-Polygone können abgerundet werden:
[[Datei:BOSL2-Polygon-rounding.png|mini|zentriert|alternativtext=rounding|pentagon(d=50, '''rounding=5''');]]
<pre class="openscad">include <BOSL2/std.scad>
pentagon(d=50, rounding=5);</pre>
=== show_anchors() ===
Die BOSL2-Polygone haben auch ein etwas anderes Anhangsverhalten als die regulären Polygone, die über $fn=<Seitenanzahl> erzeugt werden.
Ein Kreis mit einem kleinen <code>$fn=</code> hängt Dinge am idealen Kreis an, nicht entlang des erstellten Polygons:
[[Datei:BOSL2-polygon-outcircle-anchors.png|mini|zentriert|alternativtext=anchors Außenkreis|color("green") stroke(circle(d=50), closed=true); circle(d=50,$fn=6) show_anchors();]]
<pre class="openscad">include <BOSL2/std.scad>
color("green") stroke(circle(d=50), closed=true);
circle(d=50,$fn=6)
show_anchors();</pre>
Während ein BOSL2-n-Eck entlang des Polygons selbst (direkt) anhängt:
[[Datei:BOSL2-polygon-direct-anchors.png|mini|zentriert|alternativtext=anchors BOSL2 Polygone direkt|color("green") stroke(circle(d=50), closed=true); circle(d=50,$fn=6) show_anchors();]]
<pre class="openscad">include <BOSL2/std.scad>
hexagon(d=50)
show_anchors(custom=false);</pre>
Du kannst <code>anchor=</code> und <code>spin=</code> verwenden, genau wie bei anderen anhängbaren Formen. Die Ankerpunkte basieren jedoch darauf, wo der Ankervektor die Seite des n-Ecks schneiden würde, und sind möglicherweise nicht dort, wo du sie erwartest:
[[Datei:BOSL2-Pentagon-anchor.png|mini|zentriert|alternativtext=n-Polygon anchor|pentagon(d=50, '''anchor=FRONT+LEFT''') show_anchors(custom=false);]]
<pre class="openscad">include <BOSL2/std.scad>
pentagon(d=50, anchor=FRONT+LEFT)
show_anchors(custom=false);</pre>
=== Ankerpunkte für Seiten und Spitzen ===
n-Ecke haben auch benannte Ankerpunkte für ihre Seiten und Spitzen:
[[Datei:BOSL2-anchor-Spitzen-Seiten.png|mini|zentriert|alternativtext=Anker für Seiten und Spitzen|Spezielle Anker für die Spitzen und Seiten eines Pentagons (mit TikZ unter LaTeX erstellt)]]
Beachte, dass die Ankernamen in "" gesetzt werden müssen.
Zum Beispiel:
[[Datei:BOSL2-Pentagon anchor tip1.png|mini|zentriert|alternativtext=anchor="tip1"|pentagon(d=30, '''anchor="tip1" ''');]]
<pre class="openscad">include <BOSL2/std.scad>
pentagon(d=30, anchor="tip1");</pre>
<span id="sterne-stars"></span>
Beispiel mit attach():
[[Datei:BOSL2-anchor-Spitzen-Seiten attach.png|mini|zentriert|alternativtext=anchor="side2"|pentagon(d=30, anchor="side2") '''attach("tip0")''' circle(r=3,$fn=36);]]
<pre class="openscad">
include <BOSL2/std.scad>
pentagon(d=30, anchor="side2") attach("tip0") circle(r=3,$fn=36);
</pre>
== Sterne (Stars) ==
=== star() mit n, ir/id und or/od ===
Die BOSL2-Bibliothek hat Sterne als grundlegend unterstützte Form. Sie können eine beliebige Anzahl '''n''' von '''Spitzen''' haben. Du kannst die Form eines Sterns durch Spitzenanzahl, '''innere und äußere Scheitelpunkt-Radius/-Durchmesser''' angeben:
[[Datei:BOSL2-star n5 ir15 dr30-Veranschaulichung.png|mini|zentriert|alternativtext=Innerer und äußerer Radius bei star()|Veranschaulichung von den Parameter '''ir''' (oder id) und '''or''' (oder od). ''ir'' gibt den inneren Radius und or den äußeren Radius an. Die Anzahl der Zacken ist hier n=5. Siehe Code unten.]]
Begonnen wird der Stern mit einem Zacken nach rechts auf der X-Achse.
<pre class="openscad">
include <BOSL2/std.scad>
#circle(30, $fn=60);
color("blue") star(n=5, ir=15, or=30);
#circle(15, $fn=60);
color("darkblue") fwd(35) text("or=30", halign = "center", size=3);
color("yellow") text("ir=15",halign = "center", size=3, valign="center");
</pre>
=== star() mit Spannweite d ===
Statt '''od''' kann auch einfach '''d''' als Parameter verwendet werden.
[[Datei:BOSL2-star n3 id10 d50.png|mini|zentriert|alternativtext=star(n=3, id=10, d=50);|star(n=3, id=10, d=50);]]
<pre class="openscad">include <BOSL2/std.scad>
star(n=3, id=10, d=50);</pre>
[[Datei:BOSL2-star n5 id15 r25.png|mini|zentriert|alternativtext=star(n=5, id=15, r=25);|star(n=5, id=15, r=25);]]
<pre class="openscad">include <BOSL2/std.scad>
star(n=5, id=15, r=25);</pre>
[[Datei:BOSL2-star n10 id30 d50.png|mini|zentriert|alternativtext=star(n=10, id=30, d=50);|star(n=10, id=30, d=50);]]
<pre class="openscad">include <BOSL2/std.scad>
star(n=10, id=30, d=50);</pre>
=== star (n = <Spitzenanzahl>, step = <Anzahl zu überspringender Punkte>) ===
Oder du kannst die Sternform durch Spitzenanzahl '''n''' und Anzahl '''step''' der zu überspringenden Punkte angeben:
[[Datei:BOSL2-star n7 step2 d50.png|mini|zentriert|alternativtext=step|star(n=7, step=2, d=50);]]
<pre class="openscad">include <BOSL2/std.scad>
star(n=7, step=2, d=50);</pre>
[[Datei:BOSL2-star n7 step3 d50.png|mini|zentriert|alternativtext=step=3|star(n=7, step=3, d=50);]]
<pre class="openscad">include <BOSL2/std.scad>
star(n=7, step=3, d=50);</pre>
=== star() mit realign ===
Wenn dem <code>realign=</code>-Argument ein true-Wert übergeben wird, wird der Stern um einen halben Spitzenwinkel gedreht:
<pre class="openscad">include <BOSL2/std.scad>
left(30) star(n=5, step=2, d=50);
right(30) star(n=5, step=2, d=50, realign=true);</pre>
=== star() mit align_tip=<Anker> ===
Das <code>align_tip=</code>-Argument kann mit einem Vektor angegeben werden, damit du die erste Spitze in eine bestimmte Richtung ausrichten kannst:
[[Datei:BOSL2-star n5 align tip anchor tip0.png|mini|zentriert|alternativtext=align_tip=BACK|star(n=5, ir=15, or=30, align_tip=BACK) attach("tip0") color("blue") anchor_arrow2d();]]
<pre class="openscad">include <BOSL2/std.scad>
star(n=5, ir=15, or=30, align_tip=BACK)
attach("tip0") color("blue") anchor_arrow2d();</pre>
=== star() mit align_pit=<Anker> ===
Ebenso kann die erste Einkerbung oder Einbuchtung mit <code>align_pit=</code> in Richtung eines bestimmten Vektors ausgerichtet werden:
[[Datei:BOSL2-star n5 align pit BACK attach tip0.png|mini|zentriert|alternativtext=align_pit=BACK|star(n=5, ir=15, or=30, '''align_pit=BACK''') '''attach("tip0")''' color("blue") anchor_arrow2d();]]
<pre class="openscad">include <BOSL2/std.scad>
star(n=5, ir=15, or=30, align_pit=BACK)
attach("pit0") color("blue") anchor_arrow2d();</pre>
Du kannst <code>anchor=</code> und <code>spin=</code> verwenden, genau wie bei anderen anhängbaren Formen. Die Ankerpunkte basieren jedoch auf den äußersten Ausmaßen der Form und sind möglicherweise nicht dort, wo du sie erwartest:
[[Datei:BOSL2-star n5 anchor LEFT-show anchers.png|mini|zentriert|alternativtext=anchor=LEFT|star(n=5, step=2, d=50,'''anchor=LEFT''') '''show_anchors(custom=false)''';]]
<pre class="openscad">include <BOSL2/std.scad>
star(n=5, step=2, d=50)
show_anchors(custom=false);</pre>
=== Benannte Ankerpunkte bei star() ===
Sterne haben auch benannte Ankerpunkte für ihre Gruben, Spitzen und Mittelpunkte zwischen den Spitzen:
[[Datei:BOSL2-star n5 benannteAnker.png|mini|zentriert|alternativtext=benannten Ankerpunkte in star()|Zuordnung der benannten Ankerpunkte in star(). Spitzen beginnen mit "tipt0", Einkerbungen mit pit0.]]
==== Beispiel 1: anchor="tip0" attach("pit0") ====
[[Datei:BOSL2-star-n5 ir=15 or30 anchor tip0 pit0.png|mini|zentriert|alternativtext=anchor="tip0"|star(n=5, ir=15, or=30, anchor="tip0") attach("pit0") #circle(3);]]
<pre class="openscad">
include <BOSL2/std.scad>
star(n=5, ir=15, or=30, anchor="tip0") attach("pit0") #circle(3);
</pre>
==== Beispiel 2: anchor="pit0" attach("tip0") ====
[[Datei:BOSL2-star n5 anchor pit0 attach tip0.png|mini|zentriert|alternativtext=anchor="pit0" attach("tip0")|star(n=5, ir=15, or=30, anchor="pit0") attach("tip0") #circle(3);]]
<pre class="openscad">
include <BOSL2/std.scad>
star(n=5, ir=15, or=30, anchor="pit0") attach("tip0") #circle(3);
</pre>
<span id="tropfenform-2d-teardrop2d"></span>
== Tropfenform 2D (Teardrop2D) ==
Beim 3D-Druck möchtest du oft ein kreisförmiges Loch in eine vertikale Wand machen. Wenn das Loch jedoch zu groß ist, kann der Überhang an der Oberseite des Lochs Probleme beim Drucken auf einem FDM/FFF-Drucker verursachen. Wenn du kein Stützmaterial verwenden möchtest, kannst du einfach die Tropfenform verwenden. Das <code>teardrop2d()</code>-Modul ermöglicht es dir, eine 2D-Version der Tropfenform zu erstellen, damit du sie später extrudieren kannst:
[[Datei:BOSL2-teardrop2d r20.png|mini|zentriert|alternativtext=teardrop2d(r=20);|teardrop2d(r=20);]]
<pre class="openscad">include <BOSL2/std.scad>
teardrop2d(r=20);</pre>
=== Extrudiert als tropfenförmige Aussparung:
[[Datei:BOSL2-teardrop2d Loch linear extrudiert.png|mini|zentriert|alternativtext=Lineares Extrudieren eines Quadrats mit zentrierter Tropfenform|linear_extrude(5) { diff() { rect(50) attach(CTR,CTR, inside=true) teardrop2d(d=20); }}]]
<pre class="openscad">
include <BOSL2/std.scad>
linear_extrude(5) {
diff() {
rect(50)
attach(CTR,CTR, inside=true)
teardrop2d(d=20);
}}</pre>
=== ang=<Überhangwinkel> ===
Der Standard-Überhangwinkel beträgt 45 Grad, aber du kannst ihn mit dem <code>ang=</code>-Argument anpassen:
[[Datei:BOSL2-teardrop2d ang20.png|mini|zentriert|alternativtext=teardrop2d(d=50, ang=20);|teardrop2d(d=50, ang=20);]]
<pre class="openscad">include <BOSL2/std.scad>
teardrop2d(d=50, ang=20);</pre>
=== cap_h=<Kapphöhe> ===
Wenn du es vorziehst, die Oberseite des Tropfens abzuflachen, um das Bridging zu fördern, kannst du das <code>cap_h=</code>-Argument verwenden:
[[Datei:BOSL2-teardrop2d ang20 cap h38c.png|mini|zentriert|alternativtext=teardrop2d(d=50, ang=20, cap_h=38);|teardrop2d(d=50, ang=20, '''cap_h=38''');]]
<pre class="openscad">include <BOSL2/std.scad>
teardrop2d(d=50, ang=20, cap_h=38);</pre>
=== show_anchors() bei teardrop2d ===
Du kannst <code>anchor=</code> und <code>spin=</code> verwenden, genau wie bei anderen anhängbaren Formen. Die Ankerpunkte basieren jedoch auf den äußersten Ausmaßen der Form und sind möglicherweise nicht dort, wo du sie erwartest:
[[Datei:BOSL2-teardrop2d anchorBACK show anchors.png|mini|zentriert|alternativtext=teardrop2d(d=50, anchor=BACK) show_anchors();|teardrop2d(d=50, anchor=BACK) show_anchors();]]
<pre class="openscad">
include <BOSL2/std.scad>
teardrop2d(d=50, anchor=BACK)
show_anchors();
</pre>
<span id="verklebte-kreise-glued-circles"></span>
== Verklebte Kreise (Glued Circles) ==
Eine ungewöhnlichere Form, die BOSL2 bietet, sind verklebte Kreise (Glued Circles). Es handelt sich im Grunde um ein Paar von Kreisen, die durch etwas verbunden sind, das wie ein klebriger Meniskus aussieht:
[[Datei:BOSL2-glued circles d30 spread40.png|mini|zentriert|alternativtext=glued_circles(d=30, spread=40);|glued_circles(d=30, spread=40);]]
<pre class="openscad">include <BOSL2/std.scad>
glued_circles(d=30, spread=40);</pre>
=== d/r=<Kreisdurchmesser/Kreisradius>, spread=<Abstand Kreismittelpunkte> ===
Die <code>r=</code>/<code>d=</code>-Argumente können den Radius oder Durchmesser der beiden Kreise angeben:
<pre class="openscad">include <BOSL2/std.scad>
glued_circles(r=20, spread=45);</pre>
<pre class="openscad">include <BOSL2/std.scad>
glued_circles(d=40, spread=45);</pre>
Das <code>spread=</code>-Argument gibt den Abstand zwischen den Mittelpunkten der beiden Kreise an:
<pre class="openscad">include <BOSL2/std.scad>
glued_circles(d=30, spread=30);</pre>
=== tangent = <Tangentenwinkel-Miniskus> ===
Das <code>tangent=</code>-Argument gibt den Winkel der Tangente des Meniskus an den beiden Kreisen an:
[[Datei:BOSL2-glued circles d30 spread40 tangent=45.png|mini|zentriert|alternativtext=glued_circles(d=30, spread=30, tangent=45);|glued_circles(d=30, spread=30, tangent=45);]]
Auch negative Werte sind für den Tangentenwinkel möglich, so wird aus der Einbuchtung eine Ausbuchtung:
[[Datei:BOSL2-glued circles d30 spread40 tangent=-45.png|mini|zentriert|alternativtext= tangent=-40|glued_circles(d=30, spread=30, tangent=-40);]]
<pre class="openscad">include <BOSL2/std.scad>
glued_circles(d=30, spread=30, tangent=-45);</pre>
=== Langloch mit tangent=0 ===
Mit einem Tangentenwinkel von 0 erhält man eine Form, die sehr nützlich sein kann, um Langlöcher zu konstruieren.
[[Datei:BOSL2-glued circles Langlochform tangent0.png|mini|zentriert|alternativtext=Langlochform mit glued_circles|Langlochform mit glued_circles(d=30, spread=30, tangent=0);]]
<pre class="openscad">
include <BOSL2/std.scad>
glued_circles(d=30, spread=30, tangent=0);
</pre>
==== 3D-Langloch in Platte ====
[[Datei:BOSL2-glued circles Langlochform tangent0 3D.png|mini|zentriert|alternativtext=3D-Langloch glued_circlesh |Langloch (3D) durch lineares Extrudieren von glued_circles]]
<pre class="openscad">
include <BOSL2/std.scad>
difference() {
cube([80, 80, 10], center = false);
right(40) back(40) down(2)
linear_extrude(height = 14) {
glued_circles(d = 30, spread = 30, tangent = 0);
}
}
</pre>
=== Gerippte Wand ===
Eine nützliche Sache, die du tun kannst, ist, einige <code>glued_circle()</code>s in einer Linie anzuordnen und sie dann zu extrudieren, um eine gerippte Wand zu erstellen:
[[Datei:BOSL2-glued circles gerippte Wand=-45.png|mini|zentriert|alternativtext=Gerippte Wand mit extrudierten glued_circles|$fn=64; s=10; linear_extrude(height=50,convexity=16,center=true) xcopies(s*sqrt(2),n=3) glued_circles(d=s, spread=s*sqrt(2), tangent=45);]]
<pre class="openscad">include <BOSL2/std.scad>
$fn=36; s=10;
linear_extrude(height=50,convexity=16,center=true)
xcopies(s*sqrt(2),n=3)
glued_circles(d=s, spread=s*sqrt(2), tangent=45);</pre>
Du kannst <code>anchor=</code> und <code>spin=</code> verwenden, genau wie bei anderen anhängbaren Formen. Die Ankerpunkte basieren jedoch auf den äußersten Ausmaßen der Form und sind möglicherweise nicht dort, wo du sie erwartest:
<pre class="openscad">include <BOSL2/std.scad>
glued_circles(d=40, spread=40, tangent=45)
show_anchors();</pre>
t17os9rq9z49f3hyyj1ur74pn59txtt
1093538
1093537
2026-11-08T18:10:32Z
Jowi-ammerbuch
115360
/* 3D-Langloch in Platte */
1093538
wikitext
text/x-wiki
{{MyNavi
|zurück = [[OpenSCAD Benutzerhandbuch/_BOSL2-Distributoren|Zurück]]
|buch = [[OpenSCAD Benutzerhandbuch/_BOSL2|BOSL2-Inhalt]]
|weiter = [[OpenSCAD Benutzerhandbuch/_BOSL2-3D|Weiter]]
}}
== 2D Grundformen (2D Primitive) ==
OpenSCAD bietet zwei eingebaute 2D-Grundformen: <code>square()</code> und <code>circle()</code>. Du kannst sie weiterhin auf die gewohnte Weise verwenden:
<pre class="openscad">include <BOSL2/std.scad>
square([60,40], center=true);</pre>
<pre class="openscad">include <BOSL2/std.scad>
circle(r=50);</pre>
<pre class="openscad">include <BOSL2/std.scad>
circle(d=100, $fn=8);</pre>
Diese Module wurden in der BOSL2-Bibliothek in drei Bereichen erweitert: Verankerung (Anchoring), Drehung (Spin) und Anhängbarkeit (Attachability).
<span id="verankerung-anchoring"></span>
=== Verankerung (Anchoring): ===
Wenn du ein <code>square()</code> erstellst, kannst du angeben, welche Ecke oder Seite am Ursprung verankert werden soll. Dies ersetzt das <code>center=</code>-Argument und ist flexibler. Das <code>anchor=</code>-Argument nimmt einen Vektor als Wert entgegen, der in grober Richtung der Seite oder Ecke zeigt, die du am Ursprung ausrichten möchtest.
=== anchor=[0,1] oder anchor=BACK ===
[[Datei:BOSL2-anchor-0-1.png|mini|zentriert|alternativtext=anchor=[0,1]);|square([60,40], '''anchor=[0,1]''');<br>
Oder: square([60,40], '''anchor=BACK''');]]
Um beispielsweise das '''Zentrum der hinteren Kante am Ursprung''' auszurichten, setzt du den Anker auf <code>[0,1]</code>:
<pre class="openscad">
include <BOSL2/std.scad>
square([60,40], anchor=[0,1]);
</pre>
Mit den leichter verständlichen vordefinierten '''Vektor-Konstanten''':
<pre class="openscad">
include <BOSL2/std.scad>
square([60,40], anchor=BACK+CENTER);
</pre>
=== anchor=[1,-1] oder anchor=RIGHT+FRONT ===
Um die '''vordere rechte Ecke am Ursprung''' auszurichten:
[[Datei:BOSL2-anchor-1 -1.png|mini|zentriert|alternativtext=anchor=RIGHT+FRONT);|square([60,40], '''anchor=[1,-1]''');<br>
Oder: square([60,40], '''anchor=RIGHT+FRONT''');]]
<pre class="openscad">
include <BOSL2/std.scad>
square([60,40], anchor=[1,-1]);
</pre>
'''Mit Vektor-Konstanten:'''
<pre class="openscad">
include <BOSL2/std.scad>
square([60,40], anchor=RIGHT+FRONT);
</pre>
=== anchor=[0,0] oder anchor=CENTER '''Fetter Text'''===
Um es zu '''zentrieren''':
<pre class="openscad">
include <BOSL2/std.scad>
square([60,40], anchor=[0,0]);
</pre>
'''Mit Vektor-Konstanten:'''
<pre class="openscad">
include <BOSL2/std.scad>
square([60,40], anchor=CENTER);
</pre>
=== Vektor-Konstanten am Rechteck ===
Um die Angabe von Vektoren übersichtlicher zu gestalten, sind mehrere Standard-Vektorkonstanten definiert:
[[Datei:BOSL2-anchor-Konstanten-Rechteck.png|gerahmt|zentriert|alternativtext=BOSL2 vordefinierte anchor-Konstanten|Die in BOSL2 vordefinierten anchor-Konstanten]]
{| class="wikitable"
|-
! Konstante
! Richtung
! Wert
|-
| LEFT
| X-
| [-1, 0, 0]
|-
| RIGHT
| X+
| [ 1, 0, 0]
|-
| FRONT / FORWARD / FWD
| Y-
| [ 0,-1, 0]
|-
| BACK
| Y+
| [ 0, 1, 0]
|-
| BOTTOM / BOT / BTM / DOWN
| Z-
| [ 0, 0,-1] (nur 3D)
|-
| TOP / UP
| Z+
| [ 0, 0, 1] (nur 3D)
|-
| CENTER / CTR
| Zentriert
| [ 0, 0, 0]
|}
Beachte, dass du die meisten dieser Konstanten (außer <code>UP</code>/<code>DOWN</code> natürlich) auch für Anker bei 2D-Formen verwenden kannst, obwohl es sich um 3D-Vektoren handelt:
<pre class="openscad">include <BOSL2/std.scad>
square([60,40], anchor=BACK);</pre>
<pre class="openscad">include <BOSL2/std.scad>
square([60,40], anchor=CENTER);</pre>
Du kannst Vektoren addieren, um auf Ecken zu zeigen:
<pre class="openscad">include <BOSL2/std.scad>
square([60,40], anchor=FRONT+RIGHT);</pre>
=== anchor = polar_to_xy ===
Für <code>circle()</code> kann der Ankervektor auf jeden beliebigen '''Punkt des Kreisumfangs''' zeigen:
[[Datei:BOSL2-anchor-polar to xy-circle.png|gerahmt|zentriert|alternativtext=anchor = polar_to_xy|anchor = polar_to_xy(1,Alpha), für Alpha = 0, 45, 90, ...]]
==== Beispiel: anchor=polar_to_xy(1,45) =====
[[Datei:BOSL2-anchor-polar to 1-45-octagon.png|mini|zentriert|alternativtext=circle(d=50, anchor=polar_to_xy(1,45), $fn = 8);|circle(d=50, anchor=polar_to_xy(1,45), $fn = 8);]]
<pre class="openscad">
include <BOSL2/std.scad>
circle(d=50, anchor=polar_to_xy(1,45), $fn = 8);
</pre>
Beachte, dass der Radius für den Anker keine Rolle spielt, da nur die Richtung des Ankers das Ergebnis beeinflusst.
=== show_anchors() ===
[[Datei:BOSL2-show anchor.png|mini|zentriert|show_anchors]]
Du kannst die typischen Ankerpunkte sehen, indem du <code>show_anchors()</code> als Kind der Form übergibst:
<pre class="openscad">include <BOSL2/std.scad>
square([60,40], center=true)
show_anchors();</pre>
<pre class="openscad">include <BOSL2/std.scad>
circle(d=50)
show_anchors();</pre>
<span id="drehung-spin"></span>
=== Drehung (Spin): ===
Die zweite Erweiterung von <code>square()</code> und <code>circle()</code> ist die Drehung (Spin). Wenn du die Form erstellst, kannst du sie mit dem <code>spin=</code>-Argument an Ort und Stelle drehen. Du übergibst einfach die Anzahl der Grad, um die sie im Uhrzeigersinn gedreht werden soll:
<pre class="openscad">include <BOSL2/std.scad>
square([60,40], anchor=CENTER, spin=30);</pre>
Die Verankerung oder Zentrierung erfolgt vor der Drehung:
<pre class="openscad">include <BOSL2/std.scad>
square([60,40], anchor=BACK, spin=30);</pre>
Bei Kreisen kann Spin nützlich sein, wenn auch <code>$fn=</code> angegeben wird:
<pre class="openscad">include <BOSL2/std.scad>
circle(d=50, $fn=6, spin=15);</pre>
Da die Verankerung vor der Drehung erfolgt, kannst du beides zusammen verwenden, um um den Anker herum zu drehen:
<pre class="openscad">include <BOSL2/std.scad>
circle(d=50, $fn=6, anchor=LEFT, spin=15);</pre>
<span id="anhängbarkeit-attachability"></span>
=== Anhängbarkeit (Attachability): ===
Die dritte Erweiterung von <code>square()</code> und <code>circle()</code> ist, dass du sie auf verschiedene Weise an Ankerpunkten zusammenhängen kannst. Dies geschieht, indem du eine Form zum Kind der Form machst, an die du sie anhängen möchtest.
==== Standard (ohne Spez. für anchor oder position) ====
Standardmäßig wird das Kind beim einfachen Untereinanderstellen im Zentrum der Elternform angehängt.
[[Datei:BOSL2-attach-standard-normal.png|mini|zentriert|alternativtext=square(50) #square(50);|square(50) #square(50);<br>
Kind-Objekt (rot) wird ans Zentrum des Elternobjekts angehängt]]
<pre class="openscad">
include <BOSL2/std.scad>
square(50) #square(50);
</pre>
==== anchor für child spezifiziert ====
[[Datei:BOSL2-attach-anchor-LEFTplusFWD.png|mini|zentriert|alternativtext=square(50, center=true) #square([20,40], anchor=LEFT+FWD);|square(50, center=true)#square([20,40], '''anchor=LEFT+FWD''');]]
<pre class="openscad">include <BOSL2/std.scad>
square(50, center=true)
#square([20,40], anchor=LEFT+FWD);</pre>
==== position() ====
[[Datei:BOSL2-attach-position.png|mini|zentriert|alternativtext=position(RIGHT)|square(50) '''position(RIGHT)''' #square(25) '''position(BACK)''' #square(25);]]
Durch Hinzufügen des <code>position()</code>-Moduls kannst du das Kind an jedem Ankerpunkt '''des Elternteils''' positionieren, das "Kindes-Kind wird am Ankerpunkt des übergeordneten Objekts positioniert:
<pre class="openscad">
include <BOSL2/std.scad>
square(50) position(RIGHT) #square(25)
position(BACK) #square(25);
</pre>
==== orient() ====
Ankerpunkte sind jedoch nicht nur Positionen auf dem Elternteil. Sie haben auch eine Ausrichtung. In den meisten Fällen zeigt die Ausrichtung eines Ankerpunkts nach außen, weg von der Fläche der Wand, also im Allgemeinen vom Zentrum der Form weg.
[[Datei:BOSL2-show anchor.png|mini|zentriert|show_anchors]]
Wenn du das Kind so ausrichten möchtest, dass es der Ausrichtung eines Ankerpunkts entspricht, kannst du das <code>orient()</code>-Modul verwenden. Es positioniert das Kind nicht, es dreht es nur:
[[Datei:BOSL2-attach-orient anchor.png|mini|zentriert|alternativtext= orient(anchor=LEFT+BOTTOM)|square(50) '''orient(anchor=LEFT+BOTTOM)''' #square([10,40]);]]
<pre class="openscad">include <BOSL2/std.scad>
square(50)
orient(anchor=LEFT+BOTTOM) #square([10,40]);</pre>
Das geht auch beim '''Kreis (circle)''' mit '''polar_to_xy''':
[[Datei:BOSL2-attach-orient polar to xy circle.png|mini|zentriert|alternativtext=orient(polar_to_xy(1,30))|circle(d=50) ''' orient(polar_to_xy(1,30))''' #square([10,40], anchor=FWD);]]
<pre class="openscad">include <BOSL2/std.scad>
circle(d=50)
orient(polar_to_xy(1,30))
#square([10,40], anchor=FWD);</pre>
==== position() + orient() ====
Du kannst <code>position()</code> und <code>orient()</code> zusammen verwenden, um sowohl zu positionieren als auch an einem Ankerpunkt auszurichten:
[[Datei:BOSL2-attach-position pluss orient polar to xy circle.png|mini|zentriert|alternativtext=position(polar_to_xy(1,30)) orient(polar_to_xy(1,30))|circle(d=50) '''position(polar_to_xy(1,30)) orient(polar_to_xy(1,30))''' #square([10,40], anchor=FWD);]]
<pre class="openscad">include <BOSL2/std.scad>
circle(d=50)
position(polar_to_xy(1,30))
orient(polar_to_xy(1,30))
#square([10,40], anchor=FWD);</pre>
=== attach () mit einem Argument ===
Aber es ist einfacher das <code>attach()</code>-Modul zu verwenden, um beides auf einmal zu erledigen:
[[Datei:BOSL2-attach-position pluss orient polar to xy circle.png|mini|zentriert|alternativtext=attach(polar_to_xy(1,30))|circle(d=50) '''attach(polar_to_xy(1,30))''' #square([10,40], anchor=FWD); ]]
Gleiches Ergebnis, aber übersichtlicherer Code.
<pre class="openscad">include <BOSL2/std.scad>
square(50, center=true)
attach(LEFT+BACK)
#square([10,40], anchor=FWD);</pre>
=== attach () mit zwei Argumenten ===
Anstatt den <code>anchor=</code> im Kind anzugeben, kannst du ein '''zweites Argument''' an <code>attach()</code> übergeben, das ihm sagt, welche Seite des Kindes mit dem Elternteil verbunden werden soll:
<pre class="openscad">
include <BOSL2/std.scad>
circle(d=50) attach(polar_to_xy(1,30), FWD) #square([10,40]);
</pre>
Damit lässt sich der Code noch mehr straffen.
[[Datei:BOSL2-attach-position pluss orient polar to xy circle.png|mini|zentriert|alternativtext=attach(polar_to_xy(1,30), FWD)|circle(d=50) '''attach(polar_to_xy(1,30), FWD)''' #square([10,40]); ]]
<span id="rechtecke-rectangles"></span>
== Rechtecke (Rectangles) ==
=== rect() ===
Die BOSL2-Bibliothek bietet eine Alternative zu <code>square()</code>, die mehr Funktionen unterstützt. Sie heißt <code>rect()</code>. Du kannst sie genauso verwenden wie <code>square()</code>, aber sie bietet auch erweiterte Funktionalität.
=== rect() mit rounding ===
[[Datei:BOSL2-rect rounding.png|mini|zentriert|alternativtext=rounding=10|rect([60,40], '''rounding=10''');]]
rect() erlaubt dir, die Ecken des Rechtecks abzurunden:
<pre class="openscad">include <BOSL2/std.scad>
rect([60,40], rounding=10);</pre>
=== rect() mit chamfer ===
[[Datei:BOSL2-rect chamfer.png|mini|zentriert|alternativtext=rect([60,40], chamfer=10);|rect([60,40], '''chamfer=10''');]]
Du kannst die Ecken des Rechtecks auch abfasen:
<pre class="openscad">include <BOSL2/std.scad>
rect([60,40], chamfer=10);</pre>
=== Unterschiedliche Abrundungen und Fasen an einem Rechteck ===
Du kannst sogar angeben, welche Ecken abgerundet oder abgefast werden. Wenn du eine Liste mit vier Größenwerten an die <code>rounding=</code>- oder <code>chamfer=</code>-Argumente übergibst, erhält jede Ecke ihre eigene Größe. Der Reihe nach geht es von der hinteren rechten Ecke (Quadrant I) gegen den Uhrzeigersinn zur hinteren linken Ecke (Quadrant II), zur vorderen linken Ecke (Quadrant III) und zur vorderen rechten Ecke (Quadrant IV):
Wenn eine Größe als <code>0</code> angegeben wird, gibt es keine Rundung und/oder Fase für die Ecke dieses Quadranten:
<pre class="openscad">include <BOSL2/std.scad>
rect([60,40], rounding=[0,5,10,15]);</pre>
<pre class="openscad">include <BOSL2/std.scad>
rect([60,40], chamfer=[0,5,10,15]);</pre>
Du kannst sowohl <code>rounding=</code>- als auch <code>chamfer=</code>-Argumente angeben, um Rundung und Fase zu mischen, aber nur, wenn du es pro Ecke angibst. Wenn du eine Rundung in einer Ecke möchtest, gib eine Fase von 0 für diese Ecke an und umgekehrt:
[[Datei:BOSL2-rect chamfer-rounding-mixed.png|mini|zentriert|alternativtext=ounding=[5,0,10,0], chamfer=[0,5,0,15]|rect([60,40], '''rounding=[5,0,10,0], chamfer=[0,5,0,15]''');]]
<pre class="openscad">include <BOSL2/std.scad>
rect([60,40], rounding=[5,0,10,0], chamfer=[0,5,0,15]);</pre>
<span id="ellipsen-ellipses"></span>
== Ellipsen (Ellipses) ==
Die BOSL2-Bibliothek bietet auch eine erweiterte Entsprechung von <code>circle()</code>, die <code>ellipse()</code> heißt. Du kannst sie genauso verwenden wie <code>circle()</code>, aber sie bietet auch erweiterte Funktionalität. Zum Beispiel erlaubt sie mehr Kontrolle über ihre Größe.
Da ein Kreis in OpenSCAD nur durch ein regelmäßiges Polygon mit einer Anzahl gerader Seiten angenähert werden kann, kann dies zu Ungenauigkeiten in Größe und Form führen. Um dem entgegenzuwirken, werden auch die Argumente <code>realign=</code> und <code>circum=</code> bereitgestellt.
=== realign= (ellipse-Argument) ===
Das <code>realign=</code>-Argument rotiert, wenn es auf <code>true</code> gesetzt wird, die <code>ellipse()</code> um den halben Winkel zwischen den Polygonseiten:
[[Datei:BOSL2-ellipse-realign.png|mini|zentriert|alternativtext=realign=true|#ellipse(d=100, $fn=8); color("lime") ellipse(d=100, $fn=8, '''realign=true''');]]
<pre class="openscad">
include <BOSL2/std.scad>
#ellipse(d=100, $fn=8);
color("lime") ellipse(d=100, $fn=8, realign=true);
</pre>
=== circum= (ellipse-Argument) ===
[[Datei:BOSL2-ellipse-circum.png|mini|zentriert|alternativtext=circum=true|Vergleich: rot (außen) mit circum=true und blau (innen) ohne circum. Referenz: idealer Kreis in gelb.]]
<pre class="openscad">
include <BOSL2/std.scad>
color("red") ellipse(d=100, $fn=6, circum=true);
color("yellow") ellipse(d=100, $fn=360);
color("blue") ellipse(d=100, $fn=6);
</pre>
Das <code>circum=</code>-Argument bewirkt, wenn es auf true gesetzt wird, dass das Polygon, das die <code>ellipse()</code> bildet, den idealen Kreis '''umschreibt''', anstatt ihn einzuschreiben.
Den idealen Kreis ''einschreiben'':
<pre class="openscad">include <BOSL2/std.scad>
color("green") ellipse(d=100, $fn=360);
ellipse(d=100, $fn=6);</pre>
Den idealen Kreis ''umschreiben'':
<pre class="openscad">include <BOSL2/std.scad>
ellipse(d=100, $fn=6, circum=true);
color("green") ellipse(d=100, $fn=360);</pre>
=== Ellipse mit 2 Radien ===
Das <code>ellipse()</code>-Modul kann, wie der Name schon sagt, mit separaten X- und Y-Radien oder -Durchmessern angegeben werden. Dazu gibst du einfach <code>r=</code> oder <code>d=</code> mit einer Liste von zwei Radien oder Durchmessern an:
[[Datei:BOSL2-ellipse-2Radien.png|mini|zentriert|alternativtext=2 Radien|ellipse('''r=[30,20]''');]]
==== r=[r1,r2] ====
<pre class="openscad">include <BOSL2/std.scad>
ellipse(r=[30,20]);</pre>
==== d=[d1,d2]====
<pre class="openscad">include <BOSL2/std.scad>
ellipse(d=[60,40]);</pre>
==== ellipse mit anchor ====
Wie bei <code>circle()</code> kannst du <code>ellipse()</code>-Formen verankern, drehen und anhängen:
[[Datei:BOSL2-ellipse-anchor.png|mini|zentriert|alternativtext=ellipse mit anchor|ellipse(d=[50,20], '''anchor=BACK'''); #ellipse(d=[50,20], '''anchor=FRONT''');]]
<pre class="openscad">
include <BOSL2/std.scad>
ellipse(d=[50,20], anchor=BACK);
#ellipse(d=[50,20], anchor=FRONT);
</pre>
==== ellipse mit attach ====
[[Datei:BOSL2-ellipse-attach.png|mini|zentriert|alternativtext=ellipse mit attach|ellipse(d=50) '''attach(BACK+RIGHT, FRONT+LEFT)''' #ellipse(d=[40,20]);]]
<pre class="openscad">
include <BOSL2/std.scad>
ellipse(d=50)
attach(BACK+RIGHT, FRONT+LEFT)
ellipse(d=30);
</pre>
<span id="rechtwinklige-dreiecke-right-triangles"></span>
==== ellipse mit spin ====
[[Datei:BOSL2-ellipse-attach-spin-anchor.png|mini|zentriert|alternativtext=spin = 90 bei ellipse|ellipse(d=50) attach(BACK) #ellipse(d=[40,20], '''spin=90''', anchor=LEFT);]]
<pre class="openscad">
include <BOSL2/std.scad>
ellipse(d=50)
attach(BACK)
#ellipse(d=[40,20], spin=90, anchor=LEFT);
</pre>
== Rechtwinklige Dreiecke (Right Triangles) ==
Die BOSL2-Bibliothek bietet eine einfache Möglichkeit, ein 2D-rechtwinkliges Dreieck mit dem <code>right_triangle()</code>-Modul zu erstellen:
[[Datei:BOSL2-right triangle.png|mini|zentriert|alternativtext=right_triangle([40,30])|right_triangle([40,30]);]]
<pre class="openscad">include <BOSL2/std.scad>
right_triangle([40,30]);</pre>
=== xflip() bei right_triangle ===
Du kannst <code>xflip()</code> und <code>yflip()</code> verwenden, um zu ändern, in welchem Quadranten das Dreieck gebildet wird:
[[Datei:BOSL2-right triangle xflip.png|mini|zentriert|alternativtext=right_triange mit xflip()|right_triangle([40,30]); '''xflip()''' #right_triangle([40,30]);]]
<pre class="openscad">include <BOSL2/std.scad>
xflip() right_triangle([40,30]);</pre>
=== yflip() bei right_triangle ===
[[Datei:BOSL2-right triangle yflip.png|mini|zentriert|alternativtext=right_triangle([40,30]) mit yflip()|right_triangle([40,30]); '''yflip()''' #right_triangle([40,30]);]]
<pre class="openscad">include <BOSL2/std.scad>
yflip() right_triangle([40,30]);</pre>
=== xflip() & yflip() bei right_triangle ===
[[Datei:BOSL2-right triangle xflip yflip.png|mini|zentriert|alternativtext=xflip() yflip()|right_triangle([40,30]); xflip() yflip() #right_triangle([40,30]);]]
<pre class="openscad">include <BOSL2/std.scad>
xflip() yflip() right_triangle([40,30]);</pre>
=== spin= bei right_triangle ===
Oder alternativ einfach mit <code>spin=</code> in den richtigen Quadranten drehen:
[[Datei:BOSL2-right triangle spin.png|mini|zentriert|alternativtext=right_triangle([40,30]) mit spin=90)|right_triangle([40,30]);
#right_triangle([40,30], '''spin=90''');]]
<pre class="openscad">include <BOSL2/std.scad>
right_triangle([40,30], spin=90);</pre>
<pre class="openscad">include <BOSL2/std.scad>
right_triangle([40,30], spin=-90);</pre>
Du kannst bei rechtwinkligen Dreiecken auch Verankerung verwenden:
<pre class="openscad">include <BOSL2/std.scad>
right_triangle([40,30], anchor=FWD+RIGHT);</pre>
<span id="trapeze-trapezoids"></span>
== Trapeze (Trapezoids) ==
OpenSCAD bietet keine einfache Möglichkeit, allgemeine 2D-Dreiecke, Trapeze oder Parallelogramme zu erstellen. Die BOSL2-Bibliothek kann all diese Formen mit dem <code>trapezoid()</code>-Modul bereitstellen.
=== Dreieck ===
Um ein gleichseitiges Dreieck zu erstellen, setze einfach eine der Breiten auf null:
[[Datei:BOSL2-trapezoid dreieck.png|mini|zentriert|alternativtext=Dreieck|trapezoid(w1=50, w2=0, h=40);<br>
Dreieck mit Seitenlänge = 50]]
<pre class="openscad">include <BOSL2/std.scad>
trapezoid(w1=50, w2=0, h=40);</pre>
Um ein rechtwinkliges Dreieck zu erstellen, musst du das <code>shift=</code>-Argument verwenden, um die Rückseite des Trapezes entlang der X-Achse zu verschieben:
[[Datei:BOSL2-trapezoid dreieck-rechtwinklig.png|mini|zentriert|alternativtext=Rechtwinkliges Dreieck|trapezoid(w1=50, w2=0, h=50, shift=-25);]]
<pre class="openscad">include <BOSL2/std.scad>
trapezoid(w1=50, w2=0, h=50, shift=-25);</pre>
<pre class="openscad">include <BOSL2/std.scad>
trapezoid(w1=50, w2=0, h=50, shift=25);</pre>
<pre class="openscad">include <BOSL2/std.scad>
trapezoid(w1=0, w2=50, h=50, shift=-25);</pre>
<pre class="openscad">include <BOSL2/std.scad>
trapezoid(w1=0, w2=50, h=50, shift=25);</pre>
=== Trapez ===
Du kannst ein Trapez erstellen, indem du für vorne (<code>w1=</code>) und hinten (<code>w2=</code>) von null verschiedene Breiten angibst:
[[Datei:BOSL2-trapezoid trapez.png|mini|zentriert|alternativtext=Trapez|trapezoid(w1=30, w2=50, h=50);]]
<pre class="openscad">include <BOSL2/std.scad>
trapezoid(w1=30, w2=50, h=50);</pre>
=== Parallelogramm ===
Ein Parallelogramm ist nur eine Frage der Verwendung der gleichen Breite für vorne und hinten, mit einer Verschiebung entlang der X-Achse:
[[Datei:BOSL2-trapezoid parallelogram.png|mini|zentriert|alternativtext=Parallelogramm|trapezoid(w1=50, w2=50, shift=20, h=50);]]
<pre class="openscad">include <BOSL2/std.scad>
trapezoid(w1=50, w2=50, shift=20, h=50);</pre>
=== Viereck ===
Ein Viereck kann erstellt werden, indem ungleiche, von null verschiedene Breiten für vorne (<code>w1=</code>) und hinten (<code>w2=</code>) verwendet werden, wobei die Rückseite entlang der X-Achse verschoben wird:
[[Datei:BOSL2-trapezoid viereck.png|mini|zentriert|alternativtext=Viereck|trapezoid(w1=50, w2=30, shift=20, h=50);]]
<pre class="openscad">include <BOSL2/std.scad>
trapezoid(w1=50, w2=30, shift=20, h=50);</pre>
Du kannst <code>anchor=</code> und <code>spin=</code> verwenden, genau wie bei anderen anhängbaren Formen. Die Ausrichtungen der Ankerpunkte basieren jedoch auf den Seitenwinkeln der Flächen und sind möglicherweise nicht das, was du erwartest:
<pre class="openscad">include <BOSL2/std.scad>
trapezoid(w1=30, w2=50, h=50)
show_anchors();</pre>
<span id="regelmäßige-n-ecke-regular-n-gons"></span>
== Regelmäßige n-Ecke (Regular N-Gons) ==
OpenSCAD ermöglicht es dir, regelmäßige n-Ecke (Fünfeck, Sechseck usw.) zu erstellen, indem du <code>circle()</code> mit <code>$fn</code> verwendest. Obwohl dies prägnant ist, mag es auf den ersten Blick weniger offensichtlich sein:
<pre class="openscad">include <BOSL2/std.scad>
circle(d=50, $fn=5);</pre>
Die BOSL2-Bibliothek hat Module, die für gängige n-Ecke klarer benannt sind:
=== Pentagon (d=<Durchmesser>) ===
[[Datei:BOSL2-Pentagon.png|mini|zentriert|alternativtext=Pentagon|pentagon(d=50);]]
<pre class="openscad">include <BOSL2/std.scad>
pentagon(d=50);</pre>
=== Hexagon (d=<Durchmesser>) ===
[[Datei:BOSL2-Hexagon.png|mini|zentriert|alternativtext=Hexagon| hexagon(d=50);]]
<pre class="openscad">include <BOSL2/std.scad>
hexagon(d=50);</pre>
=== Octagon (d= <Durchmesser>) ===
[[Datei:BOSL2-Octagon.png|mini|zentriert|alternativtext=octagon(d=50);|octagon(d=50);]]
<pre class="openscad">include <BOSL2/std.scad>
octagon(d=50);</pre>
=== regular_ngon (n=<Seitenanzahl>, d=<Durchmesser>) ===
[[Datei:BOSL2-regular ngon.png|mini|zentriert|alternativtext=regular_ngon|regular_ngon(n=7, d=50);]]
<pre class="openscad">include <BOSL2/std.scad>
regular_ngon(n=7, d=50);</pre>
=== side=<Seitenlänge> ===
Diese Module bieten dir auch zusätzliche Funktionalität. Sie können nach Seitenlänge dimensioniert werden:
[[Datei:BOSL2-Hexagon side50.png|mini|zentriert|alternativtext=hexagon(side=50);|hexagon(side=50);]]
<pre class="openscad">include <BOSL2/std.scad>
pentagon(side=50);</pre>
=== ir = <Innenradius> / id = <Innendurchmesser> ===
Sie können nach dem Radius/Durchmesser des umschriebenen Kreises (Innenkreis) dimensioniert werden:
[[Datei:BOSL2-Pentagon Innenradius.png|mini|zentriert|alternativtext=Innenradius|color("red") pentagon('''ir=25'''); color("yellow") circle(r=25,$fn=100);]]
<pre class="openscad">include <BOSL2/std.scad>
pentagon(ir=25);
pentagon(id=50);</pre>
=== realign=true/false ===
Die Polygone können um eine halbe Seite gedreht werden:
[[Datei:BOSL2-Pentagon realign.png|mini|zentriert|alternativtext=realign|pentagon(d=50, '''realign=false'''); #pentagon(d=50, '''realign=true''');]]
<pre class="openscad">include <BOSL2/std.scad>
left(30) pentagon(d=50, realign=true);
right(30) pentagon(d=50, realign=false);</pre>
=== rounding = <Rundung> ===
Die BOSL2-Polygone können abgerundet werden:
[[Datei:BOSL2-Polygon-rounding.png|mini|zentriert|alternativtext=rounding|pentagon(d=50, '''rounding=5''');]]
<pre class="openscad">include <BOSL2/std.scad>
pentagon(d=50, rounding=5);</pre>
=== show_anchors() ===
Die BOSL2-Polygone haben auch ein etwas anderes Anhangsverhalten als die regulären Polygone, die über $fn=<Seitenanzahl> erzeugt werden.
Ein Kreis mit einem kleinen <code>$fn=</code> hängt Dinge am idealen Kreis an, nicht entlang des erstellten Polygons:
[[Datei:BOSL2-polygon-outcircle-anchors.png|mini|zentriert|alternativtext=anchors Außenkreis|color("green") stroke(circle(d=50), closed=true); circle(d=50,$fn=6) show_anchors();]]
<pre class="openscad">include <BOSL2/std.scad>
color("green") stroke(circle(d=50), closed=true);
circle(d=50,$fn=6)
show_anchors();</pre>
Während ein BOSL2-n-Eck entlang des Polygons selbst (direkt) anhängt:
[[Datei:BOSL2-polygon-direct-anchors.png|mini|zentriert|alternativtext=anchors BOSL2 Polygone direkt|color("green") stroke(circle(d=50), closed=true); circle(d=50,$fn=6) show_anchors();]]
<pre class="openscad">include <BOSL2/std.scad>
hexagon(d=50)
show_anchors(custom=false);</pre>
Du kannst <code>anchor=</code> und <code>spin=</code> verwenden, genau wie bei anderen anhängbaren Formen. Die Ankerpunkte basieren jedoch darauf, wo der Ankervektor die Seite des n-Ecks schneiden würde, und sind möglicherweise nicht dort, wo du sie erwartest:
[[Datei:BOSL2-Pentagon-anchor.png|mini|zentriert|alternativtext=n-Polygon anchor|pentagon(d=50, '''anchor=FRONT+LEFT''') show_anchors(custom=false);]]
<pre class="openscad">include <BOSL2/std.scad>
pentagon(d=50, anchor=FRONT+LEFT)
show_anchors(custom=false);</pre>
=== Ankerpunkte für Seiten und Spitzen ===
n-Ecke haben auch benannte Ankerpunkte für ihre Seiten und Spitzen:
[[Datei:BOSL2-anchor-Spitzen-Seiten.png|mini|zentriert|alternativtext=Anker für Seiten und Spitzen|Spezielle Anker für die Spitzen und Seiten eines Pentagons (mit TikZ unter LaTeX erstellt)]]
Beachte, dass die Ankernamen in "" gesetzt werden müssen.
Zum Beispiel:
[[Datei:BOSL2-Pentagon anchor tip1.png|mini|zentriert|alternativtext=anchor="tip1"|pentagon(d=30, '''anchor="tip1" ''');]]
<pre class="openscad">include <BOSL2/std.scad>
pentagon(d=30, anchor="tip1");</pre>
<span id="sterne-stars"></span>
Beispiel mit attach():
[[Datei:BOSL2-anchor-Spitzen-Seiten attach.png|mini|zentriert|alternativtext=anchor="side2"|pentagon(d=30, anchor="side2") '''attach("tip0")''' circle(r=3,$fn=36);]]
<pre class="openscad">
include <BOSL2/std.scad>
pentagon(d=30, anchor="side2") attach("tip0") circle(r=3,$fn=36);
</pre>
== Sterne (Stars) ==
=== star() mit n, ir/id und or/od ===
Die BOSL2-Bibliothek hat Sterne als grundlegend unterstützte Form. Sie können eine beliebige Anzahl '''n''' von '''Spitzen''' haben. Du kannst die Form eines Sterns durch Spitzenanzahl, '''innere und äußere Scheitelpunkt-Radius/-Durchmesser''' angeben:
[[Datei:BOSL2-star n5 ir15 dr30-Veranschaulichung.png|mini|zentriert|alternativtext=Innerer und äußerer Radius bei star()|Veranschaulichung von den Parameter '''ir''' (oder id) und '''or''' (oder od). ''ir'' gibt den inneren Radius und or den äußeren Radius an. Die Anzahl der Zacken ist hier n=5. Siehe Code unten.]]
Begonnen wird der Stern mit einem Zacken nach rechts auf der X-Achse.
<pre class="openscad">
include <BOSL2/std.scad>
#circle(30, $fn=60);
color("blue") star(n=5, ir=15, or=30);
#circle(15, $fn=60);
color("darkblue") fwd(35) text("or=30", halign = "center", size=3);
color("yellow") text("ir=15",halign = "center", size=3, valign="center");
</pre>
=== star() mit Spannweite d ===
Statt '''od''' kann auch einfach '''d''' als Parameter verwendet werden.
[[Datei:BOSL2-star n3 id10 d50.png|mini|zentriert|alternativtext=star(n=3, id=10, d=50);|star(n=3, id=10, d=50);]]
<pre class="openscad">include <BOSL2/std.scad>
star(n=3, id=10, d=50);</pre>
[[Datei:BOSL2-star n5 id15 r25.png|mini|zentriert|alternativtext=star(n=5, id=15, r=25);|star(n=5, id=15, r=25);]]
<pre class="openscad">include <BOSL2/std.scad>
star(n=5, id=15, r=25);</pre>
[[Datei:BOSL2-star n10 id30 d50.png|mini|zentriert|alternativtext=star(n=10, id=30, d=50);|star(n=10, id=30, d=50);]]
<pre class="openscad">include <BOSL2/std.scad>
star(n=10, id=30, d=50);</pre>
=== star (n = <Spitzenanzahl>, step = <Anzahl zu überspringender Punkte>) ===
Oder du kannst die Sternform durch Spitzenanzahl '''n''' und Anzahl '''step''' der zu überspringenden Punkte angeben:
[[Datei:BOSL2-star n7 step2 d50.png|mini|zentriert|alternativtext=step|star(n=7, step=2, d=50);]]
<pre class="openscad">include <BOSL2/std.scad>
star(n=7, step=2, d=50);</pre>
[[Datei:BOSL2-star n7 step3 d50.png|mini|zentriert|alternativtext=step=3|star(n=7, step=3, d=50);]]
<pre class="openscad">include <BOSL2/std.scad>
star(n=7, step=3, d=50);</pre>
=== star() mit realign ===
Wenn dem <code>realign=</code>-Argument ein true-Wert übergeben wird, wird der Stern um einen halben Spitzenwinkel gedreht:
<pre class="openscad">include <BOSL2/std.scad>
left(30) star(n=5, step=2, d=50);
right(30) star(n=5, step=2, d=50, realign=true);</pre>
=== star() mit align_tip=<Anker> ===
Das <code>align_tip=</code>-Argument kann mit einem Vektor angegeben werden, damit du die erste Spitze in eine bestimmte Richtung ausrichten kannst:
[[Datei:BOSL2-star n5 align tip anchor tip0.png|mini|zentriert|alternativtext=align_tip=BACK|star(n=5, ir=15, or=30, align_tip=BACK) attach("tip0") color("blue") anchor_arrow2d();]]
<pre class="openscad">include <BOSL2/std.scad>
star(n=5, ir=15, or=30, align_tip=BACK)
attach("tip0") color("blue") anchor_arrow2d();</pre>
=== star() mit align_pit=<Anker> ===
Ebenso kann die erste Einkerbung oder Einbuchtung mit <code>align_pit=</code> in Richtung eines bestimmten Vektors ausgerichtet werden:
[[Datei:BOSL2-star n5 align pit BACK attach tip0.png|mini|zentriert|alternativtext=align_pit=BACK|star(n=5, ir=15, or=30, '''align_pit=BACK''') '''attach("tip0")''' color("blue") anchor_arrow2d();]]
<pre class="openscad">include <BOSL2/std.scad>
star(n=5, ir=15, or=30, align_pit=BACK)
attach("pit0") color("blue") anchor_arrow2d();</pre>
Du kannst <code>anchor=</code> und <code>spin=</code> verwenden, genau wie bei anderen anhängbaren Formen. Die Ankerpunkte basieren jedoch auf den äußersten Ausmaßen der Form und sind möglicherweise nicht dort, wo du sie erwartest:
[[Datei:BOSL2-star n5 anchor LEFT-show anchers.png|mini|zentriert|alternativtext=anchor=LEFT|star(n=5, step=2, d=50,'''anchor=LEFT''') '''show_anchors(custom=false)''';]]
<pre class="openscad">include <BOSL2/std.scad>
star(n=5, step=2, d=50)
show_anchors(custom=false);</pre>
=== Benannte Ankerpunkte bei star() ===
Sterne haben auch benannte Ankerpunkte für ihre Gruben, Spitzen und Mittelpunkte zwischen den Spitzen:
[[Datei:BOSL2-star n5 benannteAnker.png|mini|zentriert|alternativtext=benannten Ankerpunkte in star()|Zuordnung der benannten Ankerpunkte in star(). Spitzen beginnen mit "tipt0", Einkerbungen mit pit0.]]
==== Beispiel 1: anchor="tip0" attach("pit0") ====
[[Datei:BOSL2-star-n5 ir=15 or30 anchor tip0 pit0.png|mini|zentriert|alternativtext=anchor="tip0"|star(n=5, ir=15, or=30, anchor="tip0") attach("pit0") #circle(3);]]
<pre class="openscad">
include <BOSL2/std.scad>
star(n=5, ir=15, or=30, anchor="tip0") attach("pit0") #circle(3);
</pre>
==== Beispiel 2: anchor="pit0" attach("tip0") ====
[[Datei:BOSL2-star n5 anchor pit0 attach tip0.png|mini|zentriert|alternativtext=anchor="pit0" attach("tip0")|star(n=5, ir=15, or=30, anchor="pit0") attach("tip0") #circle(3);]]
<pre class="openscad">
include <BOSL2/std.scad>
star(n=5, ir=15, or=30, anchor="pit0") attach("tip0") #circle(3);
</pre>
<span id="tropfenform-2d-teardrop2d"></span>
== Tropfenform 2D (Teardrop2D) ==
Beim 3D-Druck möchtest du oft ein kreisförmiges Loch in eine vertikale Wand machen. Wenn das Loch jedoch zu groß ist, kann der Überhang an der Oberseite des Lochs Probleme beim Drucken auf einem FDM/FFF-Drucker verursachen. Wenn du kein Stützmaterial verwenden möchtest, kannst du einfach die Tropfenform verwenden. Das <code>teardrop2d()</code>-Modul ermöglicht es dir, eine 2D-Version der Tropfenform zu erstellen, damit du sie später extrudieren kannst:
[[Datei:BOSL2-teardrop2d r20.png|mini|zentriert|alternativtext=teardrop2d(r=20);|teardrop2d(r=20);]]
<pre class="openscad">include <BOSL2/std.scad>
teardrop2d(r=20);</pre>
=== Extrudiert als tropfenförmige Aussparung:
[[Datei:BOSL2-teardrop2d Loch linear extrudiert.png|mini|zentriert|alternativtext=Lineares Extrudieren eines Quadrats mit zentrierter Tropfenform|linear_extrude(5) { diff() { rect(50) attach(CTR,CTR, inside=true) teardrop2d(d=20); }}]]
<pre class="openscad">
include <BOSL2/std.scad>
linear_extrude(5) {
diff() {
rect(50)
attach(CTR,CTR, inside=true)
teardrop2d(d=20);
}}</pre>
=== ang=<Überhangwinkel> ===
Der Standard-Überhangwinkel beträgt 45 Grad, aber du kannst ihn mit dem <code>ang=</code>-Argument anpassen:
[[Datei:BOSL2-teardrop2d ang20.png|mini|zentriert|alternativtext=teardrop2d(d=50, ang=20);|teardrop2d(d=50, ang=20);]]
<pre class="openscad">include <BOSL2/std.scad>
teardrop2d(d=50, ang=20);</pre>
=== cap_h=<Kapphöhe> ===
Wenn du es vorziehst, die Oberseite des Tropfens abzuflachen, um das Bridging zu fördern, kannst du das <code>cap_h=</code>-Argument verwenden:
[[Datei:BOSL2-teardrop2d ang20 cap h38c.png|mini|zentriert|alternativtext=teardrop2d(d=50, ang=20, cap_h=38);|teardrop2d(d=50, ang=20, '''cap_h=38''');]]
<pre class="openscad">include <BOSL2/std.scad>
teardrop2d(d=50, ang=20, cap_h=38);</pre>
=== show_anchors() bei teardrop2d ===
Du kannst <code>anchor=</code> und <code>spin=</code> verwenden, genau wie bei anderen anhängbaren Formen. Die Ankerpunkte basieren jedoch auf den äußersten Ausmaßen der Form und sind möglicherweise nicht dort, wo du sie erwartest:
[[Datei:BOSL2-teardrop2d anchorBACK show anchors.png|mini|zentriert|alternativtext=teardrop2d(d=50, anchor=BACK) show_anchors();|teardrop2d(d=50, anchor=BACK) show_anchors();]]
<pre class="openscad">
include <BOSL2/std.scad>
teardrop2d(d=50, anchor=BACK)
show_anchors();
</pre>
<span id="verklebte-kreise-glued-circles"></span>
== Verklebte Kreise (Glued Circles) ==
Eine ungewöhnlichere Form, die BOSL2 bietet, sind verklebte Kreise (Glued Circles). Es handelt sich im Grunde um ein Paar von Kreisen, die durch etwas verbunden sind, das wie ein klebriger Meniskus aussieht:
[[Datei:BOSL2-glued circles d30 spread40.png|mini|zentriert|alternativtext=glued_circles(d=30, spread=40);|glued_circles(d=30, spread=40);]]
<pre class="openscad">include <BOSL2/std.scad>
glued_circles(d=30, spread=40);</pre>
=== d/r=<Kreisdurchmesser/Kreisradius>, spread=<Abstand Kreismittelpunkte> ===
Die <code>r=</code>/<code>d=</code>-Argumente können den Radius oder Durchmesser der beiden Kreise angeben:
<pre class="openscad">include <BOSL2/std.scad>
glued_circles(r=20, spread=45);</pre>
<pre class="openscad">include <BOSL2/std.scad>
glued_circles(d=40, spread=45);</pre>
Das <code>spread=</code>-Argument gibt den Abstand zwischen den Mittelpunkten der beiden Kreise an:
<pre class="openscad">include <BOSL2/std.scad>
glued_circles(d=30, spread=30);</pre>
=== tangent = <Tangentenwinkel-Miniskus> ===
Das <code>tangent=</code>-Argument gibt den Winkel der Tangente des Meniskus an den beiden Kreisen an:
[[Datei:BOSL2-glued circles d30 spread40 tangent=45.png|mini|zentriert|alternativtext=glued_circles(d=30, spread=30, tangent=45);|glued_circles(d=30, spread=30, tangent=45);]]
Auch negative Werte sind für den Tangentenwinkel möglich, so wird aus der Einbuchtung eine Ausbuchtung:
[[Datei:BOSL2-glued circles d30 spread40 tangent=-45.png|mini|zentriert|alternativtext= tangent=-40|glued_circles(d=30, spread=30, tangent=-40);]]
<pre class="openscad">include <BOSL2/std.scad>
glued_circles(d=30, spread=30, tangent=-45);</pre>
=== Langloch mit tangent=0 ===
Mit einem Tangentenwinkel von 0 erhält man eine Form, die sehr nützlich sein kann, um Langlöcher zu konstruieren.
[[Datei:BOSL2-glued circles Langlochform tangent0.png|mini|zentriert|alternativtext=Langlochform mit glued_circles|Langlochform mit glued_circles(d=30, spread=30, tangent=0);]]
<pre class="openscad">
include <BOSL2/std.scad>
glued_circles(d=30, spread=30, tangent=0);
</pre>
==== 3D-Langloch in Platte ====
[[Datei:BOSL2-glued circles Langlochform tangent0 3D.png|mini|zentriert|alternativtext=3D-Langloch glued_circlesh |Langloch (3D) durch lineares Extrudieren von glued_circles]]
<pre class="openscad">
include <BOSL2/std.scad>
difference() {
cube([80, 80, 10], center = false);
right(40) back(40) down(2)
linear_extrude(height = 14) {
glued_circles(d = 30, spread = 30, tangent = 0);
}
}
</pre>
Oder mit einem tieferen Griff in die BOSL2-Trickkiste:
<pre class="openscad">
include <BOSL2/std.scad>
linear_extrude(10)
diff("Langloch")
rect([80, 80], anchor=LEFT+FRONT)
tag("Langloch")
glued_circles(d = 25, spread = 30, tangent = 0);
</pre>
=== Gerippte Wand ===
Eine nützliche Sache, die du tun kannst, ist, einige <code>glued_circle()</code>s in einer Linie anzuordnen und sie dann zu extrudieren, um eine gerippte Wand zu erstellen:
[[Datei:BOSL2-glued circles gerippte Wand=-45.png|mini|zentriert|alternativtext=Gerippte Wand mit extrudierten glued_circles|$fn=64; s=10; linear_extrude(height=50,convexity=16,center=true) xcopies(s*sqrt(2),n=3) glued_circles(d=s, spread=s*sqrt(2), tangent=45);]]
<pre class="openscad">include <BOSL2/std.scad>
$fn=36; s=10;
linear_extrude(height=50,convexity=16,center=true)
xcopies(s*sqrt(2),n=3)
glued_circles(d=s, spread=s*sqrt(2), tangent=45);</pre>
Du kannst <code>anchor=</code> und <code>spin=</code> verwenden, genau wie bei anderen anhängbaren Formen. Die Ankerpunkte basieren jedoch auf den äußersten Ausmaßen der Form und sind möglicherweise nicht dort, wo du sie erwartest:
<pre class="openscad">include <BOSL2/std.scad>
glued_circles(d=40, spread=40, tangent=45)
show_anchors();</pre>
dxmqyemfwpv5ef6yo6vydwyd012u9jd
1093539
1093538
2026-11-08T18:17:48Z
Jowi-ammerbuch
115360
/* 3D-Langloch in Platte */
1093539
wikitext
text/x-wiki
{{MyNavi
|zurück = [[OpenSCAD Benutzerhandbuch/_BOSL2-Distributoren|Zurück]]
|buch = [[OpenSCAD Benutzerhandbuch/_BOSL2|BOSL2-Inhalt]]
|weiter = [[OpenSCAD Benutzerhandbuch/_BOSL2-3D|Weiter]]
}}
== 2D Grundformen (2D Primitive) ==
OpenSCAD bietet zwei eingebaute 2D-Grundformen: <code>square()</code> und <code>circle()</code>. Du kannst sie weiterhin auf die gewohnte Weise verwenden:
<pre class="openscad">include <BOSL2/std.scad>
square([60,40], center=true);</pre>
<pre class="openscad">include <BOSL2/std.scad>
circle(r=50);</pre>
<pre class="openscad">include <BOSL2/std.scad>
circle(d=100, $fn=8);</pre>
Diese Module wurden in der BOSL2-Bibliothek in drei Bereichen erweitert: Verankerung (Anchoring), Drehung (Spin) und Anhängbarkeit (Attachability).
<span id="verankerung-anchoring"></span>
=== Verankerung (Anchoring): ===
Wenn du ein <code>square()</code> erstellst, kannst du angeben, welche Ecke oder Seite am Ursprung verankert werden soll. Dies ersetzt das <code>center=</code>-Argument und ist flexibler. Das <code>anchor=</code>-Argument nimmt einen Vektor als Wert entgegen, der in grober Richtung der Seite oder Ecke zeigt, die du am Ursprung ausrichten möchtest.
=== anchor=[0,1] oder anchor=BACK ===
[[Datei:BOSL2-anchor-0-1.png|mini|zentriert|alternativtext=anchor=[0,1]);|square([60,40], '''anchor=[0,1]''');<br>
Oder: square([60,40], '''anchor=BACK''');]]
Um beispielsweise das '''Zentrum der hinteren Kante am Ursprung''' auszurichten, setzt du den Anker auf <code>[0,1]</code>:
<pre class="openscad">
include <BOSL2/std.scad>
square([60,40], anchor=[0,1]);
</pre>
Mit den leichter verständlichen vordefinierten '''Vektor-Konstanten''':
<pre class="openscad">
include <BOSL2/std.scad>
square([60,40], anchor=BACK+CENTER);
</pre>
=== anchor=[1,-1] oder anchor=RIGHT+FRONT ===
Um die '''vordere rechte Ecke am Ursprung''' auszurichten:
[[Datei:BOSL2-anchor-1 -1.png|mini|zentriert|alternativtext=anchor=RIGHT+FRONT);|square([60,40], '''anchor=[1,-1]''');<br>
Oder: square([60,40], '''anchor=RIGHT+FRONT''');]]
<pre class="openscad">
include <BOSL2/std.scad>
square([60,40], anchor=[1,-1]);
</pre>
'''Mit Vektor-Konstanten:'''
<pre class="openscad">
include <BOSL2/std.scad>
square([60,40], anchor=RIGHT+FRONT);
</pre>
=== anchor=[0,0] oder anchor=CENTER '''Fetter Text'''===
Um es zu '''zentrieren''':
<pre class="openscad">
include <BOSL2/std.scad>
square([60,40], anchor=[0,0]);
</pre>
'''Mit Vektor-Konstanten:'''
<pre class="openscad">
include <BOSL2/std.scad>
square([60,40], anchor=CENTER);
</pre>
=== Vektor-Konstanten am Rechteck ===
Um die Angabe von Vektoren übersichtlicher zu gestalten, sind mehrere Standard-Vektorkonstanten definiert:
[[Datei:BOSL2-anchor-Konstanten-Rechteck.png|gerahmt|zentriert|alternativtext=BOSL2 vordefinierte anchor-Konstanten|Die in BOSL2 vordefinierten anchor-Konstanten]]
{| class="wikitable"
|-
! Konstante
! Richtung
! Wert
|-
| LEFT
| X-
| [-1, 0, 0]
|-
| RIGHT
| X+
| [ 1, 0, 0]
|-
| FRONT / FORWARD / FWD
| Y-
| [ 0,-1, 0]
|-
| BACK
| Y+
| [ 0, 1, 0]
|-
| BOTTOM / BOT / BTM / DOWN
| Z-
| [ 0, 0,-1] (nur 3D)
|-
| TOP / UP
| Z+
| [ 0, 0, 1] (nur 3D)
|-
| CENTER / CTR
| Zentriert
| [ 0, 0, 0]
|}
Beachte, dass du die meisten dieser Konstanten (außer <code>UP</code>/<code>DOWN</code> natürlich) auch für Anker bei 2D-Formen verwenden kannst, obwohl es sich um 3D-Vektoren handelt:
<pre class="openscad">include <BOSL2/std.scad>
square([60,40], anchor=BACK);</pre>
<pre class="openscad">include <BOSL2/std.scad>
square([60,40], anchor=CENTER);</pre>
Du kannst Vektoren addieren, um auf Ecken zu zeigen:
<pre class="openscad">include <BOSL2/std.scad>
square([60,40], anchor=FRONT+RIGHT);</pre>
=== anchor = polar_to_xy ===
Für <code>circle()</code> kann der Ankervektor auf jeden beliebigen '''Punkt des Kreisumfangs''' zeigen:
[[Datei:BOSL2-anchor-polar to xy-circle.png|gerahmt|zentriert|alternativtext=anchor = polar_to_xy|anchor = polar_to_xy(1,Alpha), für Alpha = 0, 45, 90, ...]]
==== Beispiel: anchor=polar_to_xy(1,45) =====
[[Datei:BOSL2-anchor-polar to 1-45-octagon.png|mini|zentriert|alternativtext=circle(d=50, anchor=polar_to_xy(1,45), $fn = 8);|circle(d=50, anchor=polar_to_xy(1,45), $fn = 8);]]
<pre class="openscad">
include <BOSL2/std.scad>
circle(d=50, anchor=polar_to_xy(1,45), $fn = 8);
</pre>
Beachte, dass der Radius für den Anker keine Rolle spielt, da nur die Richtung des Ankers das Ergebnis beeinflusst.
=== show_anchors() ===
[[Datei:BOSL2-show anchor.png|mini|zentriert|show_anchors]]
Du kannst die typischen Ankerpunkte sehen, indem du <code>show_anchors()</code> als Kind der Form übergibst:
<pre class="openscad">include <BOSL2/std.scad>
square([60,40], center=true)
show_anchors();</pre>
<pre class="openscad">include <BOSL2/std.scad>
circle(d=50)
show_anchors();</pre>
<span id="drehung-spin"></span>
=== Drehung (Spin): ===
Die zweite Erweiterung von <code>square()</code> und <code>circle()</code> ist die Drehung (Spin). Wenn du die Form erstellst, kannst du sie mit dem <code>spin=</code>-Argument an Ort und Stelle drehen. Du übergibst einfach die Anzahl der Grad, um die sie im Uhrzeigersinn gedreht werden soll:
<pre class="openscad">include <BOSL2/std.scad>
square([60,40], anchor=CENTER, spin=30);</pre>
Die Verankerung oder Zentrierung erfolgt vor der Drehung:
<pre class="openscad">include <BOSL2/std.scad>
square([60,40], anchor=BACK, spin=30);</pre>
Bei Kreisen kann Spin nützlich sein, wenn auch <code>$fn=</code> angegeben wird:
<pre class="openscad">include <BOSL2/std.scad>
circle(d=50, $fn=6, spin=15);</pre>
Da die Verankerung vor der Drehung erfolgt, kannst du beides zusammen verwenden, um um den Anker herum zu drehen:
<pre class="openscad">include <BOSL2/std.scad>
circle(d=50, $fn=6, anchor=LEFT, spin=15);</pre>
<span id="anhängbarkeit-attachability"></span>
=== Anhängbarkeit (Attachability): ===
Die dritte Erweiterung von <code>square()</code> und <code>circle()</code> ist, dass du sie auf verschiedene Weise an Ankerpunkten zusammenhängen kannst. Dies geschieht, indem du eine Form zum Kind der Form machst, an die du sie anhängen möchtest.
==== Standard (ohne Spez. für anchor oder position) ====
Standardmäßig wird das Kind beim einfachen Untereinanderstellen im Zentrum der Elternform angehängt.
[[Datei:BOSL2-attach-standard-normal.png|mini|zentriert|alternativtext=square(50) #square(50);|square(50) #square(50);<br>
Kind-Objekt (rot) wird ans Zentrum des Elternobjekts angehängt]]
<pre class="openscad">
include <BOSL2/std.scad>
square(50) #square(50);
</pre>
==== anchor für child spezifiziert ====
[[Datei:BOSL2-attach-anchor-LEFTplusFWD.png|mini|zentriert|alternativtext=square(50, center=true) #square([20,40], anchor=LEFT+FWD);|square(50, center=true)#square([20,40], '''anchor=LEFT+FWD''');]]
<pre class="openscad">include <BOSL2/std.scad>
square(50, center=true)
#square([20,40], anchor=LEFT+FWD);</pre>
==== position() ====
[[Datei:BOSL2-attach-position.png|mini|zentriert|alternativtext=position(RIGHT)|square(50) '''position(RIGHT)''' #square(25) '''position(BACK)''' #square(25);]]
Durch Hinzufügen des <code>position()</code>-Moduls kannst du das Kind an jedem Ankerpunkt '''des Elternteils''' positionieren, das "Kindes-Kind wird am Ankerpunkt des übergeordneten Objekts positioniert:
<pre class="openscad">
include <BOSL2/std.scad>
square(50) position(RIGHT) #square(25)
position(BACK) #square(25);
</pre>
==== orient() ====
Ankerpunkte sind jedoch nicht nur Positionen auf dem Elternteil. Sie haben auch eine Ausrichtung. In den meisten Fällen zeigt die Ausrichtung eines Ankerpunkts nach außen, weg von der Fläche der Wand, also im Allgemeinen vom Zentrum der Form weg.
[[Datei:BOSL2-show anchor.png|mini|zentriert|show_anchors]]
Wenn du das Kind so ausrichten möchtest, dass es der Ausrichtung eines Ankerpunkts entspricht, kannst du das <code>orient()</code>-Modul verwenden. Es positioniert das Kind nicht, es dreht es nur:
[[Datei:BOSL2-attach-orient anchor.png|mini|zentriert|alternativtext= orient(anchor=LEFT+BOTTOM)|square(50) '''orient(anchor=LEFT+BOTTOM)''' #square([10,40]);]]
<pre class="openscad">include <BOSL2/std.scad>
square(50)
orient(anchor=LEFT+BOTTOM) #square([10,40]);</pre>
Das geht auch beim '''Kreis (circle)''' mit '''polar_to_xy''':
[[Datei:BOSL2-attach-orient polar to xy circle.png|mini|zentriert|alternativtext=orient(polar_to_xy(1,30))|circle(d=50) ''' orient(polar_to_xy(1,30))''' #square([10,40], anchor=FWD);]]
<pre class="openscad">include <BOSL2/std.scad>
circle(d=50)
orient(polar_to_xy(1,30))
#square([10,40], anchor=FWD);</pre>
==== position() + orient() ====
Du kannst <code>position()</code> und <code>orient()</code> zusammen verwenden, um sowohl zu positionieren als auch an einem Ankerpunkt auszurichten:
[[Datei:BOSL2-attach-position pluss orient polar to xy circle.png|mini|zentriert|alternativtext=position(polar_to_xy(1,30)) orient(polar_to_xy(1,30))|circle(d=50) '''position(polar_to_xy(1,30)) orient(polar_to_xy(1,30))''' #square([10,40], anchor=FWD);]]
<pre class="openscad">include <BOSL2/std.scad>
circle(d=50)
position(polar_to_xy(1,30))
orient(polar_to_xy(1,30))
#square([10,40], anchor=FWD);</pre>
=== attach () mit einem Argument ===
Aber es ist einfacher das <code>attach()</code>-Modul zu verwenden, um beides auf einmal zu erledigen:
[[Datei:BOSL2-attach-position pluss orient polar to xy circle.png|mini|zentriert|alternativtext=attach(polar_to_xy(1,30))|circle(d=50) '''attach(polar_to_xy(1,30))''' #square([10,40], anchor=FWD); ]]
Gleiches Ergebnis, aber übersichtlicherer Code.
<pre class="openscad">include <BOSL2/std.scad>
square(50, center=true)
attach(LEFT+BACK)
#square([10,40], anchor=FWD);</pre>
=== attach () mit zwei Argumenten ===
Anstatt den <code>anchor=</code> im Kind anzugeben, kannst du ein '''zweites Argument''' an <code>attach()</code> übergeben, das ihm sagt, welche Seite des Kindes mit dem Elternteil verbunden werden soll:
<pre class="openscad">
include <BOSL2/std.scad>
circle(d=50) attach(polar_to_xy(1,30), FWD) #square([10,40]);
</pre>
Damit lässt sich der Code noch mehr straffen.
[[Datei:BOSL2-attach-position pluss orient polar to xy circle.png|mini|zentriert|alternativtext=attach(polar_to_xy(1,30), FWD)|circle(d=50) '''attach(polar_to_xy(1,30), FWD)''' #square([10,40]); ]]
<span id="rechtecke-rectangles"></span>
== Rechtecke (Rectangles) ==
=== rect() ===
Die BOSL2-Bibliothek bietet eine Alternative zu <code>square()</code>, die mehr Funktionen unterstützt. Sie heißt <code>rect()</code>. Du kannst sie genauso verwenden wie <code>square()</code>, aber sie bietet auch erweiterte Funktionalität.
=== rect() mit rounding ===
[[Datei:BOSL2-rect rounding.png|mini|zentriert|alternativtext=rounding=10|rect([60,40], '''rounding=10''');]]
rect() erlaubt dir, die Ecken des Rechtecks abzurunden:
<pre class="openscad">include <BOSL2/std.scad>
rect([60,40], rounding=10);</pre>
=== rect() mit chamfer ===
[[Datei:BOSL2-rect chamfer.png|mini|zentriert|alternativtext=rect([60,40], chamfer=10);|rect([60,40], '''chamfer=10''');]]
Du kannst die Ecken des Rechtecks auch abfasen:
<pre class="openscad">include <BOSL2/std.scad>
rect([60,40], chamfer=10);</pre>
=== Unterschiedliche Abrundungen und Fasen an einem Rechteck ===
Du kannst sogar angeben, welche Ecken abgerundet oder abgefast werden. Wenn du eine Liste mit vier Größenwerten an die <code>rounding=</code>- oder <code>chamfer=</code>-Argumente übergibst, erhält jede Ecke ihre eigene Größe. Der Reihe nach geht es von der hinteren rechten Ecke (Quadrant I) gegen den Uhrzeigersinn zur hinteren linken Ecke (Quadrant II), zur vorderen linken Ecke (Quadrant III) und zur vorderen rechten Ecke (Quadrant IV):
Wenn eine Größe als <code>0</code> angegeben wird, gibt es keine Rundung und/oder Fase für die Ecke dieses Quadranten:
<pre class="openscad">include <BOSL2/std.scad>
rect([60,40], rounding=[0,5,10,15]);</pre>
<pre class="openscad">include <BOSL2/std.scad>
rect([60,40], chamfer=[0,5,10,15]);</pre>
Du kannst sowohl <code>rounding=</code>- als auch <code>chamfer=</code>-Argumente angeben, um Rundung und Fase zu mischen, aber nur, wenn du es pro Ecke angibst. Wenn du eine Rundung in einer Ecke möchtest, gib eine Fase von 0 für diese Ecke an und umgekehrt:
[[Datei:BOSL2-rect chamfer-rounding-mixed.png|mini|zentriert|alternativtext=ounding=[5,0,10,0], chamfer=[0,5,0,15]|rect([60,40], '''rounding=[5,0,10,0], chamfer=[0,5,0,15]''');]]
<pre class="openscad">include <BOSL2/std.scad>
rect([60,40], rounding=[5,0,10,0], chamfer=[0,5,0,15]);</pre>
<span id="ellipsen-ellipses"></span>
== Ellipsen (Ellipses) ==
Die BOSL2-Bibliothek bietet auch eine erweiterte Entsprechung von <code>circle()</code>, die <code>ellipse()</code> heißt. Du kannst sie genauso verwenden wie <code>circle()</code>, aber sie bietet auch erweiterte Funktionalität. Zum Beispiel erlaubt sie mehr Kontrolle über ihre Größe.
Da ein Kreis in OpenSCAD nur durch ein regelmäßiges Polygon mit einer Anzahl gerader Seiten angenähert werden kann, kann dies zu Ungenauigkeiten in Größe und Form führen. Um dem entgegenzuwirken, werden auch die Argumente <code>realign=</code> und <code>circum=</code> bereitgestellt.
=== realign= (ellipse-Argument) ===
Das <code>realign=</code>-Argument rotiert, wenn es auf <code>true</code> gesetzt wird, die <code>ellipse()</code> um den halben Winkel zwischen den Polygonseiten:
[[Datei:BOSL2-ellipse-realign.png|mini|zentriert|alternativtext=realign=true|#ellipse(d=100, $fn=8); color("lime") ellipse(d=100, $fn=8, '''realign=true''');]]
<pre class="openscad">
include <BOSL2/std.scad>
#ellipse(d=100, $fn=8);
color("lime") ellipse(d=100, $fn=8, realign=true);
</pre>
=== circum= (ellipse-Argument) ===
[[Datei:BOSL2-ellipse-circum.png|mini|zentriert|alternativtext=circum=true|Vergleich: rot (außen) mit circum=true und blau (innen) ohne circum. Referenz: idealer Kreis in gelb.]]
<pre class="openscad">
include <BOSL2/std.scad>
color("red") ellipse(d=100, $fn=6, circum=true);
color("yellow") ellipse(d=100, $fn=360);
color("blue") ellipse(d=100, $fn=6);
</pre>
Das <code>circum=</code>-Argument bewirkt, wenn es auf true gesetzt wird, dass das Polygon, das die <code>ellipse()</code> bildet, den idealen Kreis '''umschreibt''', anstatt ihn einzuschreiben.
Den idealen Kreis ''einschreiben'':
<pre class="openscad">include <BOSL2/std.scad>
color("green") ellipse(d=100, $fn=360);
ellipse(d=100, $fn=6);</pre>
Den idealen Kreis ''umschreiben'':
<pre class="openscad">include <BOSL2/std.scad>
ellipse(d=100, $fn=6, circum=true);
color("green") ellipse(d=100, $fn=360);</pre>
=== Ellipse mit 2 Radien ===
Das <code>ellipse()</code>-Modul kann, wie der Name schon sagt, mit separaten X- und Y-Radien oder -Durchmessern angegeben werden. Dazu gibst du einfach <code>r=</code> oder <code>d=</code> mit einer Liste von zwei Radien oder Durchmessern an:
[[Datei:BOSL2-ellipse-2Radien.png|mini|zentriert|alternativtext=2 Radien|ellipse('''r=[30,20]''');]]
==== r=[r1,r2] ====
<pre class="openscad">include <BOSL2/std.scad>
ellipse(r=[30,20]);</pre>
==== d=[d1,d2]====
<pre class="openscad">include <BOSL2/std.scad>
ellipse(d=[60,40]);</pre>
==== ellipse mit anchor ====
Wie bei <code>circle()</code> kannst du <code>ellipse()</code>-Formen verankern, drehen und anhängen:
[[Datei:BOSL2-ellipse-anchor.png|mini|zentriert|alternativtext=ellipse mit anchor|ellipse(d=[50,20], '''anchor=BACK'''); #ellipse(d=[50,20], '''anchor=FRONT''');]]
<pre class="openscad">
include <BOSL2/std.scad>
ellipse(d=[50,20], anchor=BACK);
#ellipse(d=[50,20], anchor=FRONT);
</pre>
==== ellipse mit attach ====
[[Datei:BOSL2-ellipse-attach.png|mini|zentriert|alternativtext=ellipse mit attach|ellipse(d=50) '''attach(BACK+RIGHT, FRONT+LEFT)''' #ellipse(d=[40,20]);]]
<pre class="openscad">
include <BOSL2/std.scad>
ellipse(d=50)
attach(BACK+RIGHT, FRONT+LEFT)
ellipse(d=30);
</pre>
<span id="rechtwinklige-dreiecke-right-triangles"></span>
==== ellipse mit spin ====
[[Datei:BOSL2-ellipse-attach-spin-anchor.png|mini|zentriert|alternativtext=spin = 90 bei ellipse|ellipse(d=50) attach(BACK) #ellipse(d=[40,20], '''spin=90''', anchor=LEFT);]]
<pre class="openscad">
include <BOSL2/std.scad>
ellipse(d=50)
attach(BACK)
#ellipse(d=[40,20], spin=90, anchor=LEFT);
</pre>
== Rechtwinklige Dreiecke (Right Triangles) ==
Die BOSL2-Bibliothek bietet eine einfache Möglichkeit, ein 2D-rechtwinkliges Dreieck mit dem <code>right_triangle()</code>-Modul zu erstellen:
[[Datei:BOSL2-right triangle.png|mini|zentriert|alternativtext=right_triangle([40,30])|right_triangle([40,30]);]]
<pre class="openscad">include <BOSL2/std.scad>
right_triangle([40,30]);</pre>
=== xflip() bei right_triangle ===
Du kannst <code>xflip()</code> und <code>yflip()</code> verwenden, um zu ändern, in welchem Quadranten das Dreieck gebildet wird:
[[Datei:BOSL2-right triangle xflip.png|mini|zentriert|alternativtext=right_triange mit xflip()|right_triangle([40,30]); '''xflip()''' #right_triangle([40,30]);]]
<pre class="openscad">include <BOSL2/std.scad>
xflip() right_triangle([40,30]);</pre>
=== yflip() bei right_triangle ===
[[Datei:BOSL2-right triangle yflip.png|mini|zentriert|alternativtext=right_triangle([40,30]) mit yflip()|right_triangle([40,30]); '''yflip()''' #right_triangle([40,30]);]]
<pre class="openscad">include <BOSL2/std.scad>
yflip() right_triangle([40,30]);</pre>
=== xflip() & yflip() bei right_triangle ===
[[Datei:BOSL2-right triangle xflip yflip.png|mini|zentriert|alternativtext=xflip() yflip()|right_triangle([40,30]); xflip() yflip() #right_triangle([40,30]);]]
<pre class="openscad">include <BOSL2/std.scad>
xflip() yflip() right_triangle([40,30]);</pre>
=== spin= bei right_triangle ===
Oder alternativ einfach mit <code>spin=</code> in den richtigen Quadranten drehen:
[[Datei:BOSL2-right triangle spin.png|mini|zentriert|alternativtext=right_triangle([40,30]) mit spin=90)|right_triangle([40,30]);
#right_triangle([40,30], '''spin=90''');]]
<pre class="openscad">include <BOSL2/std.scad>
right_triangle([40,30], spin=90);</pre>
<pre class="openscad">include <BOSL2/std.scad>
right_triangle([40,30], spin=-90);</pre>
Du kannst bei rechtwinkligen Dreiecken auch Verankerung verwenden:
<pre class="openscad">include <BOSL2/std.scad>
right_triangle([40,30], anchor=FWD+RIGHT);</pre>
<span id="trapeze-trapezoids"></span>
== Trapeze (Trapezoids) ==
OpenSCAD bietet keine einfache Möglichkeit, allgemeine 2D-Dreiecke, Trapeze oder Parallelogramme zu erstellen. Die BOSL2-Bibliothek kann all diese Formen mit dem <code>trapezoid()</code>-Modul bereitstellen.
=== Dreieck ===
Um ein gleichseitiges Dreieck zu erstellen, setze einfach eine der Breiten auf null:
[[Datei:BOSL2-trapezoid dreieck.png|mini|zentriert|alternativtext=Dreieck|trapezoid(w1=50, w2=0, h=40);<br>
Dreieck mit Seitenlänge = 50]]
<pre class="openscad">include <BOSL2/std.scad>
trapezoid(w1=50, w2=0, h=40);</pre>
Um ein rechtwinkliges Dreieck zu erstellen, musst du das <code>shift=</code>-Argument verwenden, um die Rückseite des Trapezes entlang der X-Achse zu verschieben:
[[Datei:BOSL2-trapezoid dreieck-rechtwinklig.png|mini|zentriert|alternativtext=Rechtwinkliges Dreieck|trapezoid(w1=50, w2=0, h=50, shift=-25);]]
<pre class="openscad">include <BOSL2/std.scad>
trapezoid(w1=50, w2=0, h=50, shift=-25);</pre>
<pre class="openscad">include <BOSL2/std.scad>
trapezoid(w1=50, w2=0, h=50, shift=25);</pre>
<pre class="openscad">include <BOSL2/std.scad>
trapezoid(w1=0, w2=50, h=50, shift=-25);</pre>
<pre class="openscad">include <BOSL2/std.scad>
trapezoid(w1=0, w2=50, h=50, shift=25);</pre>
=== Trapez ===
Du kannst ein Trapez erstellen, indem du für vorne (<code>w1=</code>) und hinten (<code>w2=</code>) von null verschiedene Breiten angibst:
[[Datei:BOSL2-trapezoid trapez.png|mini|zentriert|alternativtext=Trapez|trapezoid(w1=30, w2=50, h=50);]]
<pre class="openscad">include <BOSL2/std.scad>
trapezoid(w1=30, w2=50, h=50);</pre>
=== Parallelogramm ===
Ein Parallelogramm ist nur eine Frage der Verwendung der gleichen Breite für vorne und hinten, mit einer Verschiebung entlang der X-Achse:
[[Datei:BOSL2-trapezoid parallelogram.png|mini|zentriert|alternativtext=Parallelogramm|trapezoid(w1=50, w2=50, shift=20, h=50);]]
<pre class="openscad">include <BOSL2/std.scad>
trapezoid(w1=50, w2=50, shift=20, h=50);</pre>
=== Viereck ===
Ein Viereck kann erstellt werden, indem ungleiche, von null verschiedene Breiten für vorne (<code>w1=</code>) und hinten (<code>w2=</code>) verwendet werden, wobei die Rückseite entlang der X-Achse verschoben wird:
[[Datei:BOSL2-trapezoid viereck.png|mini|zentriert|alternativtext=Viereck|trapezoid(w1=50, w2=30, shift=20, h=50);]]
<pre class="openscad">include <BOSL2/std.scad>
trapezoid(w1=50, w2=30, shift=20, h=50);</pre>
Du kannst <code>anchor=</code> und <code>spin=</code> verwenden, genau wie bei anderen anhängbaren Formen. Die Ausrichtungen der Ankerpunkte basieren jedoch auf den Seitenwinkeln der Flächen und sind möglicherweise nicht das, was du erwartest:
<pre class="openscad">include <BOSL2/std.scad>
trapezoid(w1=30, w2=50, h=50)
show_anchors();</pre>
<span id="regelmäßige-n-ecke-regular-n-gons"></span>
== Regelmäßige n-Ecke (Regular N-Gons) ==
OpenSCAD ermöglicht es dir, regelmäßige n-Ecke (Fünfeck, Sechseck usw.) zu erstellen, indem du <code>circle()</code> mit <code>$fn</code> verwendest. Obwohl dies prägnant ist, mag es auf den ersten Blick weniger offensichtlich sein:
<pre class="openscad">include <BOSL2/std.scad>
circle(d=50, $fn=5);</pre>
Die BOSL2-Bibliothek hat Module, die für gängige n-Ecke klarer benannt sind:
=== Pentagon (d=<Durchmesser>) ===
[[Datei:BOSL2-Pentagon.png|mini|zentriert|alternativtext=Pentagon|pentagon(d=50);]]
<pre class="openscad">include <BOSL2/std.scad>
pentagon(d=50);</pre>
=== Hexagon (d=<Durchmesser>) ===
[[Datei:BOSL2-Hexagon.png|mini|zentriert|alternativtext=Hexagon| hexagon(d=50);]]
<pre class="openscad">include <BOSL2/std.scad>
hexagon(d=50);</pre>
=== Octagon (d= <Durchmesser>) ===
[[Datei:BOSL2-Octagon.png|mini|zentriert|alternativtext=octagon(d=50);|octagon(d=50);]]
<pre class="openscad">include <BOSL2/std.scad>
octagon(d=50);</pre>
=== regular_ngon (n=<Seitenanzahl>, d=<Durchmesser>) ===
[[Datei:BOSL2-regular ngon.png|mini|zentriert|alternativtext=regular_ngon|regular_ngon(n=7, d=50);]]
<pre class="openscad">include <BOSL2/std.scad>
regular_ngon(n=7, d=50);</pre>
=== side=<Seitenlänge> ===
Diese Module bieten dir auch zusätzliche Funktionalität. Sie können nach Seitenlänge dimensioniert werden:
[[Datei:BOSL2-Hexagon side50.png|mini|zentriert|alternativtext=hexagon(side=50);|hexagon(side=50);]]
<pre class="openscad">include <BOSL2/std.scad>
pentagon(side=50);</pre>
=== ir = <Innenradius> / id = <Innendurchmesser> ===
Sie können nach dem Radius/Durchmesser des umschriebenen Kreises (Innenkreis) dimensioniert werden:
[[Datei:BOSL2-Pentagon Innenradius.png|mini|zentriert|alternativtext=Innenradius|color("red") pentagon('''ir=25'''); color("yellow") circle(r=25,$fn=100);]]
<pre class="openscad">include <BOSL2/std.scad>
pentagon(ir=25);
pentagon(id=50);</pre>
=== realign=true/false ===
Die Polygone können um eine halbe Seite gedreht werden:
[[Datei:BOSL2-Pentagon realign.png|mini|zentriert|alternativtext=realign|pentagon(d=50, '''realign=false'''); #pentagon(d=50, '''realign=true''');]]
<pre class="openscad">include <BOSL2/std.scad>
left(30) pentagon(d=50, realign=true);
right(30) pentagon(d=50, realign=false);</pre>
=== rounding = <Rundung> ===
Die BOSL2-Polygone können abgerundet werden:
[[Datei:BOSL2-Polygon-rounding.png|mini|zentriert|alternativtext=rounding|pentagon(d=50, '''rounding=5''');]]
<pre class="openscad">include <BOSL2/std.scad>
pentagon(d=50, rounding=5);</pre>
=== show_anchors() ===
Die BOSL2-Polygone haben auch ein etwas anderes Anhangsverhalten als die regulären Polygone, die über $fn=<Seitenanzahl> erzeugt werden.
Ein Kreis mit einem kleinen <code>$fn=</code> hängt Dinge am idealen Kreis an, nicht entlang des erstellten Polygons:
[[Datei:BOSL2-polygon-outcircle-anchors.png|mini|zentriert|alternativtext=anchors Außenkreis|color("green") stroke(circle(d=50), closed=true); circle(d=50,$fn=6) show_anchors();]]
<pre class="openscad">include <BOSL2/std.scad>
color("green") stroke(circle(d=50), closed=true);
circle(d=50,$fn=6)
show_anchors();</pre>
Während ein BOSL2-n-Eck entlang des Polygons selbst (direkt) anhängt:
[[Datei:BOSL2-polygon-direct-anchors.png|mini|zentriert|alternativtext=anchors BOSL2 Polygone direkt|color("green") stroke(circle(d=50), closed=true); circle(d=50,$fn=6) show_anchors();]]
<pre class="openscad">include <BOSL2/std.scad>
hexagon(d=50)
show_anchors(custom=false);</pre>
Du kannst <code>anchor=</code> und <code>spin=</code> verwenden, genau wie bei anderen anhängbaren Formen. Die Ankerpunkte basieren jedoch darauf, wo der Ankervektor die Seite des n-Ecks schneiden würde, und sind möglicherweise nicht dort, wo du sie erwartest:
[[Datei:BOSL2-Pentagon-anchor.png|mini|zentriert|alternativtext=n-Polygon anchor|pentagon(d=50, '''anchor=FRONT+LEFT''') show_anchors(custom=false);]]
<pre class="openscad">include <BOSL2/std.scad>
pentagon(d=50, anchor=FRONT+LEFT)
show_anchors(custom=false);</pre>
=== Ankerpunkte für Seiten und Spitzen ===
n-Ecke haben auch benannte Ankerpunkte für ihre Seiten und Spitzen:
[[Datei:BOSL2-anchor-Spitzen-Seiten.png|mini|zentriert|alternativtext=Anker für Seiten und Spitzen|Spezielle Anker für die Spitzen und Seiten eines Pentagons (mit TikZ unter LaTeX erstellt)]]
Beachte, dass die Ankernamen in "" gesetzt werden müssen.
Zum Beispiel:
[[Datei:BOSL2-Pentagon anchor tip1.png|mini|zentriert|alternativtext=anchor="tip1"|pentagon(d=30, '''anchor="tip1" ''');]]
<pre class="openscad">include <BOSL2/std.scad>
pentagon(d=30, anchor="tip1");</pre>
<span id="sterne-stars"></span>
Beispiel mit attach():
[[Datei:BOSL2-anchor-Spitzen-Seiten attach.png|mini|zentriert|alternativtext=anchor="side2"|pentagon(d=30, anchor="side2") '''attach("tip0")''' circle(r=3,$fn=36);]]
<pre class="openscad">
include <BOSL2/std.scad>
pentagon(d=30, anchor="side2") attach("tip0") circle(r=3,$fn=36);
</pre>
== Sterne (Stars) ==
=== star() mit n, ir/id und or/od ===
Die BOSL2-Bibliothek hat Sterne als grundlegend unterstützte Form. Sie können eine beliebige Anzahl '''n''' von '''Spitzen''' haben. Du kannst die Form eines Sterns durch Spitzenanzahl, '''innere und äußere Scheitelpunkt-Radius/-Durchmesser''' angeben:
[[Datei:BOSL2-star n5 ir15 dr30-Veranschaulichung.png|mini|zentriert|alternativtext=Innerer und äußerer Radius bei star()|Veranschaulichung von den Parameter '''ir''' (oder id) und '''or''' (oder od). ''ir'' gibt den inneren Radius und or den äußeren Radius an. Die Anzahl der Zacken ist hier n=5. Siehe Code unten.]]
Begonnen wird der Stern mit einem Zacken nach rechts auf der X-Achse.
<pre class="openscad">
include <BOSL2/std.scad>
#circle(30, $fn=60);
color("blue") star(n=5, ir=15, or=30);
#circle(15, $fn=60);
color("darkblue") fwd(35) text("or=30", halign = "center", size=3);
color("yellow") text("ir=15",halign = "center", size=3, valign="center");
</pre>
=== star() mit Spannweite d ===
Statt '''od''' kann auch einfach '''d''' als Parameter verwendet werden.
[[Datei:BOSL2-star n3 id10 d50.png|mini|zentriert|alternativtext=star(n=3, id=10, d=50);|star(n=3, id=10, d=50);]]
<pre class="openscad">include <BOSL2/std.scad>
star(n=3, id=10, d=50);</pre>
[[Datei:BOSL2-star n5 id15 r25.png|mini|zentriert|alternativtext=star(n=5, id=15, r=25);|star(n=5, id=15, r=25);]]
<pre class="openscad">include <BOSL2/std.scad>
star(n=5, id=15, r=25);</pre>
[[Datei:BOSL2-star n10 id30 d50.png|mini|zentriert|alternativtext=star(n=10, id=30, d=50);|star(n=10, id=30, d=50);]]
<pre class="openscad">include <BOSL2/std.scad>
star(n=10, id=30, d=50);</pre>
=== star (n = <Spitzenanzahl>, step = <Anzahl zu überspringender Punkte>) ===
Oder du kannst die Sternform durch Spitzenanzahl '''n''' und Anzahl '''step''' der zu überspringenden Punkte angeben:
[[Datei:BOSL2-star n7 step2 d50.png|mini|zentriert|alternativtext=step|star(n=7, step=2, d=50);]]
<pre class="openscad">include <BOSL2/std.scad>
star(n=7, step=2, d=50);</pre>
[[Datei:BOSL2-star n7 step3 d50.png|mini|zentriert|alternativtext=step=3|star(n=7, step=3, d=50);]]
<pre class="openscad">include <BOSL2/std.scad>
star(n=7, step=3, d=50);</pre>
=== star() mit realign ===
Wenn dem <code>realign=</code>-Argument ein true-Wert übergeben wird, wird der Stern um einen halben Spitzenwinkel gedreht:
<pre class="openscad">include <BOSL2/std.scad>
left(30) star(n=5, step=2, d=50);
right(30) star(n=5, step=2, d=50, realign=true);</pre>
=== star() mit align_tip=<Anker> ===
Das <code>align_tip=</code>-Argument kann mit einem Vektor angegeben werden, damit du die erste Spitze in eine bestimmte Richtung ausrichten kannst:
[[Datei:BOSL2-star n5 align tip anchor tip0.png|mini|zentriert|alternativtext=align_tip=BACK|star(n=5, ir=15, or=30, align_tip=BACK) attach("tip0") color("blue") anchor_arrow2d();]]
<pre class="openscad">include <BOSL2/std.scad>
star(n=5, ir=15, or=30, align_tip=BACK)
attach("tip0") color("blue") anchor_arrow2d();</pre>
=== star() mit align_pit=<Anker> ===
Ebenso kann die erste Einkerbung oder Einbuchtung mit <code>align_pit=</code> in Richtung eines bestimmten Vektors ausgerichtet werden:
[[Datei:BOSL2-star n5 align pit BACK attach tip0.png|mini|zentriert|alternativtext=align_pit=BACK|star(n=5, ir=15, or=30, '''align_pit=BACK''') '''attach("tip0")''' color("blue") anchor_arrow2d();]]
<pre class="openscad">include <BOSL2/std.scad>
star(n=5, ir=15, or=30, align_pit=BACK)
attach("pit0") color("blue") anchor_arrow2d();</pre>
Du kannst <code>anchor=</code> und <code>spin=</code> verwenden, genau wie bei anderen anhängbaren Formen. Die Ankerpunkte basieren jedoch auf den äußersten Ausmaßen der Form und sind möglicherweise nicht dort, wo du sie erwartest:
[[Datei:BOSL2-star n5 anchor LEFT-show anchers.png|mini|zentriert|alternativtext=anchor=LEFT|star(n=5, step=2, d=50,'''anchor=LEFT''') '''show_anchors(custom=false)''';]]
<pre class="openscad">include <BOSL2/std.scad>
star(n=5, step=2, d=50)
show_anchors(custom=false);</pre>
=== Benannte Ankerpunkte bei star() ===
Sterne haben auch benannte Ankerpunkte für ihre Gruben, Spitzen und Mittelpunkte zwischen den Spitzen:
[[Datei:BOSL2-star n5 benannteAnker.png|mini|zentriert|alternativtext=benannten Ankerpunkte in star()|Zuordnung der benannten Ankerpunkte in star(). Spitzen beginnen mit "tipt0", Einkerbungen mit pit0.]]
==== Beispiel 1: anchor="tip0" attach("pit0") ====
[[Datei:BOSL2-star-n5 ir=15 or30 anchor tip0 pit0.png|mini|zentriert|alternativtext=anchor="tip0"|star(n=5, ir=15, or=30, anchor="tip0") attach("pit0") #circle(3);]]
<pre class="openscad">
include <BOSL2/std.scad>
star(n=5, ir=15, or=30, anchor="tip0") attach("pit0") #circle(3);
</pre>
==== Beispiel 2: anchor="pit0" attach("tip0") ====
[[Datei:BOSL2-star n5 anchor pit0 attach tip0.png|mini|zentriert|alternativtext=anchor="pit0" attach("tip0")|star(n=5, ir=15, or=30, anchor="pit0") attach("tip0") #circle(3);]]
<pre class="openscad">
include <BOSL2/std.scad>
star(n=5, ir=15, or=30, anchor="pit0") attach("tip0") #circle(3);
</pre>
<span id="tropfenform-2d-teardrop2d"></span>
== Tropfenform 2D (Teardrop2D) ==
Beim 3D-Druck möchtest du oft ein kreisförmiges Loch in eine vertikale Wand machen. Wenn das Loch jedoch zu groß ist, kann der Überhang an der Oberseite des Lochs Probleme beim Drucken auf einem FDM/FFF-Drucker verursachen. Wenn du kein Stützmaterial verwenden möchtest, kannst du einfach die Tropfenform verwenden. Das <code>teardrop2d()</code>-Modul ermöglicht es dir, eine 2D-Version der Tropfenform zu erstellen, damit du sie später extrudieren kannst:
[[Datei:BOSL2-teardrop2d r20.png|mini|zentriert|alternativtext=teardrop2d(r=20);|teardrop2d(r=20);]]
<pre class="openscad">include <BOSL2/std.scad>
teardrop2d(r=20);</pre>
=== Extrudiert als tropfenförmige Aussparung:
[[Datei:BOSL2-teardrop2d Loch linear extrudiert.png|mini|zentriert|alternativtext=Lineares Extrudieren eines Quadrats mit zentrierter Tropfenform|linear_extrude(5) { diff() { rect(50) attach(CTR,CTR, inside=true) teardrop2d(d=20); }}]]
<pre class="openscad">
include <BOSL2/std.scad>
linear_extrude(5) {
diff() {
rect(50)
attach(CTR,CTR, inside=true)
teardrop2d(d=20);
}}</pre>
=== ang=<Überhangwinkel> ===
Der Standard-Überhangwinkel beträgt 45 Grad, aber du kannst ihn mit dem <code>ang=</code>-Argument anpassen:
[[Datei:BOSL2-teardrop2d ang20.png|mini|zentriert|alternativtext=teardrop2d(d=50, ang=20);|teardrop2d(d=50, ang=20);]]
<pre class="openscad">include <BOSL2/std.scad>
teardrop2d(d=50, ang=20);</pre>
=== cap_h=<Kapphöhe> ===
Wenn du es vorziehst, die Oberseite des Tropfens abzuflachen, um das Bridging zu fördern, kannst du das <code>cap_h=</code>-Argument verwenden:
[[Datei:BOSL2-teardrop2d ang20 cap h38c.png|mini|zentriert|alternativtext=teardrop2d(d=50, ang=20, cap_h=38);|teardrop2d(d=50, ang=20, '''cap_h=38''');]]
<pre class="openscad">include <BOSL2/std.scad>
teardrop2d(d=50, ang=20, cap_h=38);</pre>
=== show_anchors() bei teardrop2d ===
Du kannst <code>anchor=</code> und <code>spin=</code> verwenden, genau wie bei anderen anhängbaren Formen. Die Ankerpunkte basieren jedoch auf den äußersten Ausmaßen der Form und sind möglicherweise nicht dort, wo du sie erwartest:
[[Datei:BOSL2-teardrop2d anchorBACK show anchors.png|mini|zentriert|alternativtext=teardrop2d(d=50, anchor=BACK) show_anchors();|teardrop2d(d=50, anchor=BACK) show_anchors();]]
<pre class="openscad">
include <BOSL2/std.scad>
teardrop2d(d=50, anchor=BACK)
show_anchors();
</pre>
<span id="verklebte-kreise-glued-circles"></span>
== Verklebte Kreise (Glued Circles) ==
Eine ungewöhnlichere Form, die BOSL2 bietet, sind verklebte Kreise (Glued Circles). Es handelt sich im Grunde um ein Paar von Kreisen, die durch etwas verbunden sind, das wie ein klebriger Meniskus aussieht:
[[Datei:BOSL2-glued circles d30 spread40.png|mini|zentriert|alternativtext=glued_circles(d=30, spread=40);|glued_circles(d=30, spread=40);]]
<pre class="openscad">include <BOSL2/std.scad>
glued_circles(d=30, spread=40);</pre>
=== d/r=<Kreisdurchmesser/Kreisradius>, spread=<Abstand Kreismittelpunkte> ===
Die <code>r=</code>/<code>d=</code>-Argumente können den Radius oder Durchmesser der beiden Kreise angeben:
<pre class="openscad">include <BOSL2/std.scad>
glued_circles(r=20, spread=45);</pre>
<pre class="openscad">include <BOSL2/std.scad>
glued_circles(d=40, spread=45);</pre>
Das <code>spread=</code>-Argument gibt den Abstand zwischen den Mittelpunkten der beiden Kreise an:
<pre class="openscad">include <BOSL2/std.scad>
glued_circles(d=30, spread=30);</pre>
=== tangent = <Tangentenwinkel-Miniskus> ===
Das <code>tangent=</code>-Argument gibt den Winkel der Tangente des Meniskus an den beiden Kreisen an:
[[Datei:BOSL2-glued circles d30 spread40 tangent=45.png|mini|zentriert|alternativtext=glued_circles(d=30, spread=30, tangent=45);|glued_circles(d=30, spread=30, tangent=45);]]
Auch negative Werte sind für den Tangentenwinkel möglich, so wird aus der Einbuchtung eine Ausbuchtung:
[[Datei:BOSL2-glued circles d30 spread40 tangent=-45.png|mini|zentriert|alternativtext= tangent=-40|glued_circles(d=30, spread=30, tangent=-40);]]
<pre class="openscad">include <BOSL2/std.scad>
glued_circles(d=30, spread=30, tangent=-45);</pre>
=== Langloch mit tangent=0 ===
Mit einem Tangentenwinkel von 0 erhält man eine Form, die sehr nützlich sein kann, um Langlöcher zu konstruieren.
[[Datei:BOSL2-glued circles Langlochform tangent0.png|mini|zentriert|alternativtext=Langlochform mit glued_circles|Langlochform mit glued_circles(d=30, spread=30, tangent=0);]]
<pre class="openscad">
include <BOSL2/std.scad>
glued_circles(d=30, spread=30, tangent=0);
</pre>
==== 3D-Langloch in Platte ====
[[Datei:BOSL2-glued circles Langlochform tangent0 3D.png|mini|zentriert|alternativtext=3D-Langloch glued_circlesh |Langloch (3D) durch lineares Extrudieren von glued_circles]]
Code-Variante A:
<pre class="openscad">
include <BOSL2/std.scad>
difference() {
cube([80, 80, 10], center = false);
right(40) back(40) down(2)
linear_extrude(height = 14) {
glued_circles(d = 30, spread = 30, tangent = 0);
}
}
</pre>
Code-Variante B:
<pre class="openscad">
include <BOSL2/std.scad>
linear_extrude(10)
diff("Langloch")
rect([80, 80], anchor=LEFT+FRONT)
tag("Langloch")
glued_circles(d = 25, spread = 30, tangent = 0);
</pre>
Code-Variante C:
<pre class="openscad">
include <BOSL2/std.scad>
linear_extrude(10)
diff()
rect([80, 80], anchor=LEFT+FRONT)
attach(CTR,CTR, inside=true)
glued_circles(d = 25, spread = 30, tangent = 0);
</pre>
Alle drei Varianten liefern das gleiche Ergebnis.
=== Gerippte Wand ===
Eine nützliche Sache, die du tun kannst, ist, einige <code>glued_circle()</code>s in einer Linie anzuordnen und sie dann zu extrudieren, um eine gerippte Wand zu erstellen:
[[Datei:BOSL2-glued circles gerippte Wand=-45.png|mini|zentriert|alternativtext=Gerippte Wand mit extrudierten glued_circles|$fn=64; s=10; linear_extrude(height=50,convexity=16,center=true) xcopies(s*sqrt(2),n=3) glued_circles(d=s, spread=s*sqrt(2), tangent=45);]]
<pre class="openscad">include <BOSL2/std.scad>
$fn=36; s=10;
linear_extrude(height=50,convexity=16,center=true)
xcopies(s*sqrt(2),n=3)
glued_circles(d=s, spread=s*sqrt(2), tangent=45);</pre>
Du kannst <code>anchor=</code> und <code>spin=</code> verwenden, genau wie bei anderen anhängbaren Formen. Die Ankerpunkte basieren jedoch auf den äußersten Ausmaßen der Form und sind möglicherweise nicht dort, wo du sie erwartest:
<pre class="openscad">include <BOSL2/std.scad>
glued_circles(d=40, spread=40, tangent=45)
show_anchors();</pre>
ds4dgvncxae9i0gtkrrzlu1v543sopg
1093540
1093539
2026-11-08T18:32:48Z
Jowi-ammerbuch
115360
/* Dreieck */
1093540
wikitext
text/x-wiki
{{MyNavi
|zurück = [[OpenSCAD Benutzerhandbuch/_BOSL2-Distributoren|Zurück]]
|buch = [[OpenSCAD Benutzerhandbuch/_BOSL2|BOSL2-Inhalt]]
|weiter = [[OpenSCAD Benutzerhandbuch/_BOSL2-3D|Weiter]]
}}
== 2D Grundformen (2D Primitive) ==
OpenSCAD bietet zwei eingebaute 2D-Grundformen: <code>square()</code> und <code>circle()</code>. Du kannst sie weiterhin auf die gewohnte Weise verwenden:
<pre class="openscad">include <BOSL2/std.scad>
square([60,40], center=true);</pre>
<pre class="openscad">include <BOSL2/std.scad>
circle(r=50);</pre>
<pre class="openscad">include <BOSL2/std.scad>
circle(d=100, $fn=8);</pre>
Diese Module wurden in der BOSL2-Bibliothek in drei Bereichen erweitert: Verankerung (Anchoring), Drehung (Spin) und Anhängbarkeit (Attachability).
<span id="verankerung-anchoring"></span>
=== Verankerung (Anchoring): ===
Wenn du ein <code>square()</code> erstellst, kannst du angeben, welche Ecke oder Seite am Ursprung verankert werden soll. Dies ersetzt das <code>center=</code>-Argument und ist flexibler. Das <code>anchor=</code>-Argument nimmt einen Vektor als Wert entgegen, der in grober Richtung der Seite oder Ecke zeigt, die du am Ursprung ausrichten möchtest.
=== anchor=[0,1] oder anchor=BACK ===
[[Datei:BOSL2-anchor-0-1.png|mini|zentriert|alternativtext=anchor=[0,1]);|square([60,40], '''anchor=[0,1]''');<br>
Oder: square([60,40], '''anchor=BACK''');]]
Um beispielsweise das '''Zentrum der hinteren Kante am Ursprung''' auszurichten, setzt du den Anker auf <code>[0,1]</code>:
<pre class="openscad">
include <BOSL2/std.scad>
square([60,40], anchor=[0,1]);
</pre>
Mit den leichter verständlichen vordefinierten '''Vektor-Konstanten''':
<pre class="openscad">
include <BOSL2/std.scad>
square([60,40], anchor=BACK+CENTER);
</pre>
=== anchor=[1,-1] oder anchor=RIGHT+FRONT ===
Um die '''vordere rechte Ecke am Ursprung''' auszurichten:
[[Datei:BOSL2-anchor-1 -1.png|mini|zentriert|alternativtext=anchor=RIGHT+FRONT);|square([60,40], '''anchor=[1,-1]''');<br>
Oder: square([60,40], '''anchor=RIGHT+FRONT''');]]
<pre class="openscad">
include <BOSL2/std.scad>
square([60,40], anchor=[1,-1]);
</pre>
'''Mit Vektor-Konstanten:'''
<pre class="openscad">
include <BOSL2/std.scad>
square([60,40], anchor=RIGHT+FRONT);
</pre>
=== anchor=[0,0] oder anchor=CENTER '''Fetter Text'''===
Um es zu '''zentrieren''':
<pre class="openscad">
include <BOSL2/std.scad>
square([60,40], anchor=[0,0]);
</pre>
'''Mit Vektor-Konstanten:'''
<pre class="openscad">
include <BOSL2/std.scad>
square([60,40], anchor=CENTER);
</pre>
=== Vektor-Konstanten am Rechteck ===
Um die Angabe von Vektoren übersichtlicher zu gestalten, sind mehrere Standard-Vektorkonstanten definiert:
[[Datei:BOSL2-anchor-Konstanten-Rechteck.png|gerahmt|zentriert|alternativtext=BOSL2 vordefinierte anchor-Konstanten|Die in BOSL2 vordefinierten anchor-Konstanten]]
{| class="wikitable"
|-
! Konstante
! Richtung
! Wert
|-
| LEFT
| X-
| [-1, 0, 0]
|-
| RIGHT
| X+
| [ 1, 0, 0]
|-
| FRONT / FORWARD / FWD
| Y-
| [ 0,-1, 0]
|-
| BACK
| Y+
| [ 0, 1, 0]
|-
| BOTTOM / BOT / BTM / DOWN
| Z-
| [ 0, 0,-1] (nur 3D)
|-
| TOP / UP
| Z+
| [ 0, 0, 1] (nur 3D)
|-
| CENTER / CTR
| Zentriert
| [ 0, 0, 0]
|}
Beachte, dass du die meisten dieser Konstanten (außer <code>UP</code>/<code>DOWN</code> natürlich) auch für Anker bei 2D-Formen verwenden kannst, obwohl es sich um 3D-Vektoren handelt:
<pre class="openscad">include <BOSL2/std.scad>
square([60,40], anchor=BACK);</pre>
<pre class="openscad">include <BOSL2/std.scad>
square([60,40], anchor=CENTER);</pre>
Du kannst Vektoren addieren, um auf Ecken zu zeigen:
<pre class="openscad">include <BOSL2/std.scad>
square([60,40], anchor=FRONT+RIGHT);</pre>
=== anchor = polar_to_xy ===
Für <code>circle()</code> kann der Ankervektor auf jeden beliebigen '''Punkt des Kreisumfangs''' zeigen:
[[Datei:BOSL2-anchor-polar to xy-circle.png|gerahmt|zentriert|alternativtext=anchor = polar_to_xy|anchor = polar_to_xy(1,Alpha), für Alpha = 0, 45, 90, ...]]
==== Beispiel: anchor=polar_to_xy(1,45) =====
[[Datei:BOSL2-anchor-polar to 1-45-octagon.png|mini|zentriert|alternativtext=circle(d=50, anchor=polar_to_xy(1,45), $fn = 8);|circle(d=50, anchor=polar_to_xy(1,45), $fn = 8);]]
<pre class="openscad">
include <BOSL2/std.scad>
circle(d=50, anchor=polar_to_xy(1,45), $fn = 8);
</pre>
Beachte, dass der Radius für den Anker keine Rolle spielt, da nur die Richtung des Ankers das Ergebnis beeinflusst.
=== show_anchors() ===
[[Datei:BOSL2-show anchor.png|mini|zentriert|show_anchors]]
Du kannst die typischen Ankerpunkte sehen, indem du <code>show_anchors()</code> als Kind der Form übergibst:
<pre class="openscad">include <BOSL2/std.scad>
square([60,40], center=true)
show_anchors();</pre>
<pre class="openscad">include <BOSL2/std.scad>
circle(d=50)
show_anchors();</pre>
<span id="drehung-spin"></span>
=== Drehung (Spin): ===
Die zweite Erweiterung von <code>square()</code> und <code>circle()</code> ist die Drehung (Spin). Wenn du die Form erstellst, kannst du sie mit dem <code>spin=</code>-Argument an Ort und Stelle drehen. Du übergibst einfach die Anzahl der Grad, um die sie im Uhrzeigersinn gedreht werden soll:
<pre class="openscad">include <BOSL2/std.scad>
square([60,40], anchor=CENTER, spin=30);</pre>
Die Verankerung oder Zentrierung erfolgt vor der Drehung:
<pre class="openscad">include <BOSL2/std.scad>
square([60,40], anchor=BACK, spin=30);</pre>
Bei Kreisen kann Spin nützlich sein, wenn auch <code>$fn=</code> angegeben wird:
<pre class="openscad">include <BOSL2/std.scad>
circle(d=50, $fn=6, spin=15);</pre>
Da die Verankerung vor der Drehung erfolgt, kannst du beides zusammen verwenden, um um den Anker herum zu drehen:
<pre class="openscad">include <BOSL2/std.scad>
circle(d=50, $fn=6, anchor=LEFT, spin=15);</pre>
<span id="anhängbarkeit-attachability"></span>
=== Anhängbarkeit (Attachability): ===
Die dritte Erweiterung von <code>square()</code> und <code>circle()</code> ist, dass du sie auf verschiedene Weise an Ankerpunkten zusammenhängen kannst. Dies geschieht, indem du eine Form zum Kind der Form machst, an die du sie anhängen möchtest.
==== Standard (ohne Spez. für anchor oder position) ====
Standardmäßig wird das Kind beim einfachen Untereinanderstellen im Zentrum der Elternform angehängt.
[[Datei:BOSL2-attach-standard-normal.png|mini|zentriert|alternativtext=square(50) #square(50);|square(50) #square(50);<br>
Kind-Objekt (rot) wird ans Zentrum des Elternobjekts angehängt]]
<pre class="openscad">
include <BOSL2/std.scad>
square(50) #square(50);
</pre>
==== anchor für child spezifiziert ====
[[Datei:BOSL2-attach-anchor-LEFTplusFWD.png|mini|zentriert|alternativtext=square(50, center=true) #square([20,40], anchor=LEFT+FWD);|square(50, center=true)#square([20,40], '''anchor=LEFT+FWD''');]]
<pre class="openscad">include <BOSL2/std.scad>
square(50, center=true)
#square([20,40], anchor=LEFT+FWD);</pre>
==== position() ====
[[Datei:BOSL2-attach-position.png|mini|zentriert|alternativtext=position(RIGHT)|square(50) '''position(RIGHT)''' #square(25) '''position(BACK)''' #square(25);]]
Durch Hinzufügen des <code>position()</code>-Moduls kannst du das Kind an jedem Ankerpunkt '''des Elternteils''' positionieren, das "Kindes-Kind wird am Ankerpunkt des übergeordneten Objekts positioniert:
<pre class="openscad">
include <BOSL2/std.scad>
square(50) position(RIGHT) #square(25)
position(BACK) #square(25);
</pre>
==== orient() ====
Ankerpunkte sind jedoch nicht nur Positionen auf dem Elternteil. Sie haben auch eine Ausrichtung. In den meisten Fällen zeigt die Ausrichtung eines Ankerpunkts nach außen, weg von der Fläche der Wand, also im Allgemeinen vom Zentrum der Form weg.
[[Datei:BOSL2-show anchor.png|mini|zentriert|show_anchors]]
Wenn du das Kind so ausrichten möchtest, dass es der Ausrichtung eines Ankerpunkts entspricht, kannst du das <code>orient()</code>-Modul verwenden. Es positioniert das Kind nicht, es dreht es nur:
[[Datei:BOSL2-attach-orient anchor.png|mini|zentriert|alternativtext= orient(anchor=LEFT+BOTTOM)|square(50) '''orient(anchor=LEFT+BOTTOM)''' #square([10,40]);]]
<pre class="openscad">include <BOSL2/std.scad>
square(50)
orient(anchor=LEFT+BOTTOM) #square([10,40]);</pre>
Das geht auch beim '''Kreis (circle)''' mit '''polar_to_xy''':
[[Datei:BOSL2-attach-orient polar to xy circle.png|mini|zentriert|alternativtext=orient(polar_to_xy(1,30))|circle(d=50) ''' orient(polar_to_xy(1,30))''' #square([10,40], anchor=FWD);]]
<pre class="openscad">include <BOSL2/std.scad>
circle(d=50)
orient(polar_to_xy(1,30))
#square([10,40], anchor=FWD);</pre>
==== position() + orient() ====
Du kannst <code>position()</code> und <code>orient()</code> zusammen verwenden, um sowohl zu positionieren als auch an einem Ankerpunkt auszurichten:
[[Datei:BOSL2-attach-position pluss orient polar to xy circle.png|mini|zentriert|alternativtext=position(polar_to_xy(1,30)) orient(polar_to_xy(1,30))|circle(d=50) '''position(polar_to_xy(1,30)) orient(polar_to_xy(1,30))''' #square([10,40], anchor=FWD);]]
<pre class="openscad">include <BOSL2/std.scad>
circle(d=50)
position(polar_to_xy(1,30))
orient(polar_to_xy(1,30))
#square([10,40], anchor=FWD);</pre>
=== attach () mit einem Argument ===
Aber es ist einfacher das <code>attach()</code>-Modul zu verwenden, um beides auf einmal zu erledigen:
[[Datei:BOSL2-attach-position pluss orient polar to xy circle.png|mini|zentriert|alternativtext=attach(polar_to_xy(1,30))|circle(d=50) '''attach(polar_to_xy(1,30))''' #square([10,40], anchor=FWD); ]]
Gleiches Ergebnis, aber übersichtlicherer Code.
<pre class="openscad">include <BOSL2/std.scad>
square(50, center=true)
attach(LEFT+BACK)
#square([10,40], anchor=FWD);</pre>
=== attach () mit zwei Argumenten ===
Anstatt den <code>anchor=</code> im Kind anzugeben, kannst du ein '''zweites Argument''' an <code>attach()</code> übergeben, das ihm sagt, welche Seite des Kindes mit dem Elternteil verbunden werden soll:
<pre class="openscad">
include <BOSL2/std.scad>
circle(d=50) attach(polar_to_xy(1,30), FWD) #square([10,40]);
</pre>
Damit lässt sich der Code noch mehr straffen.
[[Datei:BOSL2-attach-position pluss orient polar to xy circle.png|mini|zentriert|alternativtext=attach(polar_to_xy(1,30), FWD)|circle(d=50) '''attach(polar_to_xy(1,30), FWD)''' #square([10,40]); ]]
<span id="rechtecke-rectangles"></span>
== Rechtecke (Rectangles) ==
=== rect() ===
Die BOSL2-Bibliothek bietet eine Alternative zu <code>square()</code>, die mehr Funktionen unterstützt. Sie heißt <code>rect()</code>. Du kannst sie genauso verwenden wie <code>square()</code>, aber sie bietet auch erweiterte Funktionalität.
=== rect() mit rounding ===
[[Datei:BOSL2-rect rounding.png|mini|zentriert|alternativtext=rounding=10|rect([60,40], '''rounding=10''');]]
rect() erlaubt dir, die Ecken des Rechtecks abzurunden:
<pre class="openscad">include <BOSL2/std.scad>
rect([60,40], rounding=10);</pre>
=== rect() mit chamfer ===
[[Datei:BOSL2-rect chamfer.png|mini|zentriert|alternativtext=rect([60,40], chamfer=10);|rect([60,40], '''chamfer=10''');]]
Du kannst die Ecken des Rechtecks auch abfasen:
<pre class="openscad">include <BOSL2/std.scad>
rect([60,40], chamfer=10);</pre>
=== Unterschiedliche Abrundungen und Fasen an einem Rechteck ===
Du kannst sogar angeben, welche Ecken abgerundet oder abgefast werden. Wenn du eine Liste mit vier Größenwerten an die <code>rounding=</code>- oder <code>chamfer=</code>-Argumente übergibst, erhält jede Ecke ihre eigene Größe. Der Reihe nach geht es von der hinteren rechten Ecke (Quadrant I) gegen den Uhrzeigersinn zur hinteren linken Ecke (Quadrant II), zur vorderen linken Ecke (Quadrant III) und zur vorderen rechten Ecke (Quadrant IV):
Wenn eine Größe als <code>0</code> angegeben wird, gibt es keine Rundung und/oder Fase für die Ecke dieses Quadranten:
<pre class="openscad">include <BOSL2/std.scad>
rect([60,40], rounding=[0,5,10,15]);</pre>
<pre class="openscad">include <BOSL2/std.scad>
rect([60,40], chamfer=[0,5,10,15]);</pre>
Du kannst sowohl <code>rounding=</code>- als auch <code>chamfer=</code>-Argumente angeben, um Rundung und Fase zu mischen, aber nur, wenn du es pro Ecke angibst. Wenn du eine Rundung in einer Ecke möchtest, gib eine Fase von 0 für diese Ecke an und umgekehrt:
[[Datei:BOSL2-rect chamfer-rounding-mixed.png|mini|zentriert|alternativtext=ounding=[5,0,10,0], chamfer=[0,5,0,15]|rect([60,40], '''rounding=[5,0,10,0], chamfer=[0,5,0,15]''');]]
<pre class="openscad">include <BOSL2/std.scad>
rect([60,40], rounding=[5,0,10,0], chamfer=[0,5,0,15]);</pre>
<span id="ellipsen-ellipses"></span>
== Ellipsen (Ellipses) ==
Die BOSL2-Bibliothek bietet auch eine erweiterte Entsprechung von <code>circle()</code>, die <code>ellipse()</code> heißt. Du kannst sie genauso verwenden wie <code>circle()</code>, aber sie bietet auch erweiterte Funktionalität. Zum Beispiel erlaubt sie mehr Kontrolle über ihre Größe.
Da ein Kreis in OpenSCAD nur durch ein regelmäßiges Polygon mit einer Anzahl gerader Seiten angenähert werden kann, kann dies zu Ungenauigkeiten in Größe und Form führen. Um dem entgegenzuwirken, werden auch die Argumente <code>realign=</code> und <code>circum=</code> bereitgestellt.
=== realign= (ellipse-Argument) ===
Das <code>realign=</code>-Argument rotiert, wenn es auf <code>true</code> gesetzt wird, die <code>ellipse()</code> um den halben Winkel zwischen den Polygonseiten:
[[Datei:BOSL2-ellipse-realign.png|mini|zentriert|alternativtext=realign=true|#ellipse(d=100, $fn=8); color("lime") ellipse(d=100, $fn=8, '''realign=true''');]]
<pre class="openscad">
include <BOSL2/std.scad>
#ellipse(d=100, $fn=8);
color("lime") ellipse(d=100, $fn=8, realign=true);
</pre>
=== circum= (ellipse-Argument) ===
[[Datei:BOSL2-ellipse-circum.png|mini|zentriert|alternativtext=circum=true|Vergleich: rot (außen) mit circum=true und blau (innen) ohne circum. Referenz: idealer Kreis in gelb.]]
<pre class="openscad">
include <BOSL2/std.scad>
color("red") ellipse(d=100, $fn=6, circum=true);
color("yellow") ellipse(d=100, $fn=360);
color("blue") ellipse(d=100, $fn=6);
</pre>
Das <code>circum=</code>-Argument bewirkt, wenn es auf true gesetzt wird, dass das Polygon, das die <code>ellipse()</code> bildet, den idealen Kreis '''umschreibt''', anstatt ihn einzuschreiben.
Den idealen Kreis ''einschreiben'':
<pre class="openscad">include <BOSL2/std.scad>
color("green") ellipse(d=100, $fn=360);
ellipse(d=100, $fn=6);</pre>
Den idealen Kreis ''umschreiben'':
<pre class="openscad">include <BOSL2/std.scad>
ellipse(d=100, $fn=6, circum=true);
color("green") ellipse(d=100, $fn=360);</pre>
=== Ellipse mit 2 Radien ===
Das <code>ellipse()</code>-Modul kann, wie der Name schon sagt, mit separaten X- und Y-Radien oder -Durchmessern angegeben werden. Dazu gibst du einfach <code>r=</code> oder <code>d=</code> mit einer Liste von zwei Radien oder Durchmessern an:
[[Datei:BOSL2-ellipse-2Radien.png|mini|zentriert|alternativtext=2 Radien|ellipse('''r=[30,20]''');]]
==== r=[r1,r2] ====
<pre class="openscad">include <BOSL2/std.scad>
ellipse(r=[30,20]);</pre>
==== d=[d1,d2]====
<pre class="openscad">include <BOSL2/std.scad>
ellipse(d=[60,40]);</pre>
==== ellipse mit anchor ====
Wie bei <code>circle()</code> kannst du <code>ellipse()</code>-Formen verankern, drehen und anhängen:
[[Datei:BOSL2-ellipse-anchor.png|mini|zentriert|alternativtext=ellipse mit anchor|ellipse(d=[50,20], '''anchor=BACK'''); #ellipse(d=[50,20], '''anchor=FRONT''');]]
<pre class="openscad">
include <BOSL2/std.scad>
ellipse(d=[50,20], anchor=BACK);
#ellipse(d=[50,20], anchor=FRONT);
</pre>
==== ellipse mit attach ====
[[Datei:BOSL2-ellipse-attach.png|mini|zentriert|alternativtext=ellipse mit attach|ellipse(d=50) '''attach(BACK+RIGHT, FRONT+LEFT)''' #ellipse(d=[40,20]);]]
<pre class="openscad">
include <BOSL2/std.scad>
ellipse(d=50)
attach(BACK+RIGHT, FRONT+LEFT)
ellipse(d=30);
</pre>
<span id="rechtwinklige-dreiecke-right-triangles"></span>
==== ellipse mit spin ====
[[Datei:BOSL2-ellipse-attach-spin-anchor.png|mini|zentriert|alternativtext=spin = 90 bei ellipse|ellipse(d=50) attach(BACK) #ellipse(d=[40,20], '''spin=90''', anchor=LEFT);]]
<pre class="openscad">
include <BOSL2/std.scad>
ellipse(d=50)
attach(BACK)
#ellipse(d=[40,20], spin=90, anchor=LEFT);
</pre>
== Rechtwinklige Dreiecke (Right Triangles) ==
Die BOSL2-Bibliothek bietet eine einfache Möglichkeit, ein 2D-rechtwinkliges Dreieck mit dem <code>right_triangle()</code>-Modul zu erstellen:
[[Datei:BOSL2-right triangle.png|mini|zentriert|alternativtext=right_triangle([40,30])|right_triangle([40,30]);]]
<pre class="openscad">include <BOSL2/std.scad>
right_triangle([40,30]);</pre>
=== xflip() bei right_triangle ===
Du kannst <code>xflip()</code> und <code>yflip()</code> verwenden, um zu ändern, in welchem Quadranten das Dreieck gebildet wird:
[[Datei:BOSL2-right triangle xflip.png|mini|zentriert|alternativtext=right_triange mit xflip()|right_triangle([40,30]); '''xflip()''' #right_triangle([40,30]);]]
<pre class="openscad">include <BOSL2/std.scad>
xflip() right_triangle([40,30]);</pre>
=== yflip() bei right_triangle ===
[[Datei:BOSL2-right triangle yflip.png|mini|zentriert|alternativtext=right_triangle([40,30]) mit yflip()|right_triangle([40,30]); '''yflip()''' #right_triangle([40,30]);]]
<pre class="openscad">include <BOSL2/std.scad>
yflip() right_triangle([40,30]);</pre>
=== xflip() & yflip() bei right_triangle ===
[[Datei:BOSL2-right triangle xflip yflip.png|mini|zentriert|alternativtext=xflip() yflip()|right_triangle([40,30]); xflip() yflip() #right_triangle([40,30]);]]
<pre class="openscad">include <BOSL2/std.scad>
xflip() yflip() right_triangle([40,30]);</pre>
=== spin= bei right_triangle ===
Oder alternativ einfach mit <code>spin=</code> in den richtigen Quadranten drehen:
[[Datei:BOSL2-right triangle spin.png|mini|zentriert|alternativtext=right_triangle([40,30]) mit spin=90)|right_triangle([40,30]);
#right_triangle([40,30], '''spin=90''');]]
<pre class="openscad">include <BOSL2/std.scad>
right_triangle([40,30], spin=90);</pre>
<pre class="openscad">include <BOSL2/std.scad>
right_triangle([40,30], spin=-90);</pre>
Du kannst bei rechtwinkligen Dreiecken auch Verankerung verwenden:
<pre class="openscad">include <BOSL2/std.scad>
right_triangle([40,30], anchor=FWD+RIGHT);</pre>
<span id="trapeze-trapezoids"></span>
== Trapeze (Trapezoids) ==
OpenSCAD bietet keine einfache Möglichkeit, allgemeine 2D-Dreiecke, Trapeze oder Parallelogramme zu erstellen. Die BOSL2-Bibliothek kann all diese Formen mit dem <code>trapezoid()</code>-Modul bereitstellen.
=== Dreieck ===
==== Gleichseitiges Dreieck ====
Um ein gleichseitiges Dreieck zu erstellen, setze einfach eine der Breiten auf null:
[[Datei:BOSL2-trapezoid dreieck.png|mini|zentriert|alternativtext=Dreieck|trapezoid(w1=50, w2=0, h=40);<br>
Dreieck mit Seitenlänge = 50]]
<pre class="openscad">include <BOSL2/std.scad>
trapezoid(w1=50, w2=0, h=40);</pre>
==== Rechtwinkliges Dreieck ====
Um ein rechtwinkliges Dreieck zu erstellen, musst du das <code>shift=</code>-Argument verwenden, um die Rückseite des Trapezes entlang der X-Achse zu verschieben:
[[Datei:BOSL2-trapezoid dreieck-rechtwinklig.png|mini|zentriert|alternativtext=Rechtwinkliges Dreieck|trapezoid(w1=50, w2=0, h=50, shift=-25);]]
<pre class="openscad">include <BOSL2/std.scad>
trapezoid(w1=50, w2=0, h=50, shift=-25);</pre>
[[Datei:BOSL2-trapezoid dreieck-rechtwinklig shift25.png|mini|zentriert|alternativtext=trapezoid(w1=50, w2=0, h=50, shift=25);|trapezoid(w1=50, w2=0, h=50, shift=25);]]
<pre class="openscad">include <BOSL2/std.scad>
trapezoid(w1=50, w2=0, h=50, shift=25);</pre>
[[Datei:BOSL2-trapezoid dreieck-rechtwinklig shift-25.png|mini|zentriert|alternativtext=trapezoid(w1=0, w2=50, h=50, shift=-25);|trapezoid(w1=0, w2=50, h=50, shift=-25);]]
<pre class="openscad">include <BOSL2/std.scad>
trapezoid(w1=0, w2=50, h=50, shift=-25);</pre>
[[Datei:BOSL2-trapezoid dreieck-rechtwinklig shift25 w1=0.png|mini|zentriert|alternativtext=trapezoid(w1=0, w2=50, h=50, shift=25);|trapezoid(w1=0, w2=50, h=50, shift=25);]]
<pre class="openscad">include <BOSL2/std.scad>
trapezoid(w1=0, w2=50, h=50, shift=25);</pre>
=== Trapez ===
Du kannst ein Trapez erstellen, indem du für vorne (<code>w1=</code>) und hinten (<code>w2=</code>) von null verschiedene Breiten angibst:
[[Datei:BOSL2-trapezoid trapez.png|mini|zentriert|alternativtext=Trapez|trapezoid(w1=30, w2=50, h=50);]]
<pre class="openscad">include <BOSL2/std.scad>
trapezoid(w1=30, w2=50, h=50);</pre>
=== Parallelogramm ===
Ein Parallelogramm ist nur eine Frage der Verwendung der gleichen Breite für vorne und hinten, mit einer Verschiebung entlang der X-Achse:
[[Datei:BOSL2-trapezoid parallelogram.png|mini|zentriert|alternativtext=Parallelogramm|trapezoid(w1=50, w2=50, shift=20, h=50);]]
<pre class="openscad">include <BOSL2/std.scad>
trapezoid(w1=50, w2=50, shift=20, h=50);</pre>
=== Viereck ===
Ein Viereck kann erstellt werden, indem ungleiche, von null verschiedene Breiten für vorne (<code>w1=</code>) und hinten (<code>w2=</code>) verwendet werden, wobei die Rückseite entlang der X-Achse verschoben wird:
[[Datei:BOSL2-trapezoid viereck.png|mini|zentriert|alternativtext=Viereck|trapezoid(w1=50, w2=30, shift=20, h=50);]]
<pre class="openscad">include <BOSL2/std.scad>
trapezoid(w1=50, w2=30, shift=20, h=50);</pre>
Du kannst <code>anchor=</code> und <code>spin=</code> verwenden, genau wie bei anderen anhängbaren Formen. Die Ausrichtungen der Ankerpunkte basieren jedoch auf den Seitenwinkeln der Flächen und sind möglicherweise nicht das, was du erwartest:
<pre class="openscad">include <BOSL2/std.scad>
trapezoid(w1=30, w2=50, h=50)
show_anchors();</pre>
<span id="regelmäßige-n-ecke-regular-n-gons"></span>
== Regelmäßige n-Ecke (Regular N-Gons) ==
OpenSCAD ermöglicht es dir, regelmäßige n-Ecke (Fünfeck, Sechseck usw.) zu erstellen, indem du <code>circle()</code> mit <code>$fn</code> verwendest. Obwohl dies prägnant ist, mag es auf den ersten Blick weniger offensichtlich sein:
<pre class="openscad">include <BOSL2/std.scad>
circle(d=50, $fn=5);</pre>
Die BOSL2-Bibliothek hat Module, die für gängige n-Ecke klarer benannt sind:
=== Pentagon (d=<Durchmesser>) ===
[[Datei:BOSL2-Pentagon.png|mini|zentriert|alternativtext=Pentagon|pentagon(d=50);]]
<pre class="openscad">include <BOSL2/std.scad>
pentagon(d=50);</pre>
=== Hexagon (d=<Durchmesser>) ===
[[Datei:BOSL2-Hexagon.png|mini|zentriert|alternativtext=Hexagon| hexagon(d=50);]]
<pre class="openscad">include <BOSL2/std.scad>
hexagon(d=50);</pre>
=== Octagon (d= <Durchmesser>) ===
[[Datei:BOSL2-Octagon.png|mini|zentriert|alternativtext=octagon(d=50);|octagon(d=50);]]
<pre class="openscad">include <BOSL2/std.scad>
octagon(d=50);</pre>
=== regular_ngon (n=<Seitenanzahl>, d=<Durchmesser>) ===
[[Datei:BOSL2-regular ngon.png|mini|zentriert|alternativtext=regular_ngon|regular_ngon(n=7, d=50);]]
<pre class="openscad">include <BOSL2/std.scad>
regular_ngon(n=7, d=50);</pre>
=== side=<Seitenlänge> ===
Diese Module bieten dir auch zusätzliche Funktionalität. Sie können nach Seitenlänge dimensioniert werden:
[[Datei:BOSL2-Hexagon side50.png|mini|zentriert|alternativtext=hexagon(side=50);|hexagon(side=50);]]
<pre class="openscad">include <BOSL2/std.scad>
pentagon(side=50);</pre>
=== ir = <Innenradius> / id = <Innendurchmesser> ===
Sie können nach dem Radius/Durchmesser des umschriebenen Kreises (Innenkreis) dimensioniert werden:
[[Datei:BOSL2-Pentagon Innenradius.png|mini|zentriert|alternativtext=Innenradius|color("red") pentagon('''ir=25'''); color("yellow") circle(r=25,$fn=100);]]
<pre class="openscad">include <BOSL2/std.scad>
pentagon(ir=25);
pentagon(id=50);</pre>
=== realign=true/false ===
Die Polygone können um eine halbe Seite gedreht werden:
[[Datei:BOSL2-Pentagon realign.png|mini|zentriert|alternativtext=realign|pentagon(d=50, '''realign=false'''); #pentagon(d=50, '''realign=true''');]]
<pre class="openscad">include <BOSL2/std.scad>
left(30) pentagon(d=50, realign=true);
right(30) pentagon(d=50, realign=false);</pre>
=== rounding = <Rundung> ===
Die BOSL2-Polygone können abgerundet werden:
[[Datei:BOSL2-Polygon-rounding.png|mini|zentriert|alternativtext=rounding|pentagon(d=50, '''rounding=5''');]]
<pre class="openscad">include <BOSL2/std.scad>
pentagon(d=50, rounding=5);</pre>
=== show_anchors() ===
Die BOSL2-Polygone haben auch ein etwas anderes Anhangsverhalten als die regulären Polygone, die über $fn=<Seitenanzahl> erzeugt werden.
Ein Kreis mit einem kleinen <code>$fn=</code> hängt Dinge am idealen Kreis an, nicht entlang des erstellten Polygons:
[[Datei:BOSL2-polygon-outcircle-anchors.png|mini|zentriert|alternativtext=anchors Außenkreis|color("green") stroke(circle(d=50), closed=true); circle(d=50,$fn=6) show_anchors();]]
<pre class="openscad">include <BOSL2/std.scad>
color("green") stroke(circle(d=50), closed=true);
circle(d=50,$fn=6)
show_anchors();</pre>
Während ein BOSL2-n-Eck entlang des Polygons selbst (direkt) anhängt:
[[Datei:BOSL2-polygon-direct-anchors.png|mini|zentriert|alternativtext=anchors BOSL2 Polygone direkt|color("green") stroke(circle(d=50), closed=true); circle(d=50,$fn=6) show_anchors();]]
<pre class="openscad">include <BOSL2/std.scad>
hexagon(d=50)
show_anchors(custom=false);</pre>
Du kannst <code>anchor=</code> und <code>spin=</code> verwenden, genau wie bei anderen anhängbaren Formen. Die Ankerpunkte basieren jedoch darauf, wo der Ankervektor die Seite des n-Ecks schneiden würde, und sind möglicherweise nicht dort, wo du sie erwartest:
[[Datei:BOSL2-Pentagon-anchor.png|mini|zentriert|alternativtext=n-Polygon anchor|pentagon(d=50, '''anchor=FRONT+LEFT''') show_anchors(custom=false);]]
<pre class="openscad">include <BOSL2/std.scad>
pentagon(d=50, anchor=FRONT+LEFT)
show_anchors(custom=false);</pre>
=== Ankerpunkte für Seiten und Spitzen ===
n-Ecke haben auch benannte Ankerpunkte für ihre Seiten und Spitzen:
[[Datei:BOSL2-anchor-Spitzen-Seiten.png|mini|zentriert|alternativtext=Anker für Seiten und Spitzen|Spezielle Anker für die Spitzen und Seiten eines Pentagons (mit TikZ unter LaTeX erstellt)]]
Beachte, dass die Ankernamen in "" gesetzt werden müssen.
Zum Beispiel:
[[Datei:BOSL2-Pentagon anchor tip1.png|mini|zentriert|alternativtext=anchor="tip1"|pentagon(d=30, '''anchor="tip1" ''');]]
<pre class="openscad">include <BOSL2/std.scad>
pentagon(d=30, anchor="tip1");</pre>
<span id="sterne-stars"></span>
Beispiel mit attach():
[[Datei:BOSL2-anchor-Spitzen-Seiten attach.png|mini|zentriert|alternativtext=anchor="side2"|pentagon(d=30, anchor="side2") '''attach("tip0")''' circle(r=3,$fn=36);]]
<pre class="openscad">
include <BOSL2/std.scad>
pentagon(d=30, anchor="side2") attach("tip0") circle(r=3,$fn=36);
</pre>
== Sterne (Stars) ==
=== star() mit n, ir/id und or/od ===
Die BOSL2-Bibliothek hat Sterne als grundlegend unterstützte Form. Sie können eine beliebige Anzahl '''n''' von '''Spitzen''' haben. Du kannst die Form eines Sterns durch Spitzenanzahl, '''innere und äußere Scheitelpunkt-Radius/-Durchmesser''' angeben:
[[Datei:BOSL2-star n5 ir15 dr30-Veranschaulichung.png|mini|zentriert|alternativtext=Innerer und äußerer Radius bei star()|Veranschaulichung von den Parameter '''ir''' (oder id) und '''or''' (oder od). ''ir'' gibt den inneren Radius und or den äußeren Radius an. Die Anzahl der Zacken ist hier n=5. Siehe Code unten.]]
Begonnen wird der Stern mit einem Zacken nach rechts auf der X-Achse.
<pre class="openscad">
include <BOSL2/std.scad>
#circle(30, $fn=60);
color("blue") star(n=5, ir=15, or=30);
#circle(15, $fn=60);
color("darkblue") fwd(35) text("or=30", halign = "center", size=3);
color("yellow") text("ir=15",halign = "center", size=3, valign="center");
</pre>
=== star() mit Spannweite d ===
Statt '''od''' kann auch einfach '''d''' als Parameter verwendet werden.
[[Datei:BOSL2-star n3 id10 d50.png|mini|zentriert|alternativtext=star(n=3, id=10, d=50);|star(n=3, id=10, d=50);]]
<pre class="openscad">include <BOSL2/std.scad>
star(n=3, id=10, d=50);</pre>
[[Datei:BOSL2-star n5 id15 r25.png|mini|zentriert|alternativtext=star(n=5, id=15, r=25);|star(n=5, id=15, r=25);]]
<pre class="openscad">include <BOSL2/std.scad>
star(n=5, id=15, r=25);</pre>
[[Datei:BOSL2-star n10 id30 d50.png|mini|zentriert|alternativtext=star(n=10, id=30, d=50);|star(n=10, id=30, d=50);]]
<pre class="openscad">include <BOSL2/std.scad>
star(n=10, id=30, d=50);</pre>
=== star (n = <Spitzenanzahl>, step = <Anzahl zu überspringender Punkte>) ===
Oder du kannst die Sternform durch Spitzenanzahl '''n''' und Anzahl '''step''' der zu überspringenden Punkte angeben:
[[Datei:BOSL2-star n7 step2 d50.png|mini|zentriert|alternativtext=step|star(n=7, step=2, d=50);]]
<pre class="openscad">include <BOSL2/std.scad>
star(n=7, step=2, d=50);</pre>
[[Datei:BOSL2-star n7 step3 d50.png|mini|zentriert|alternativtext=step=3|star(n=7, step=3, d=50);]]
<pre class="openscad">include <BOSL2/std.scad>
star(n=7, step=3, d=50);</pre>
=== star() mit realign ===
Wenn dem <code>realign=</code>-Argument ein true-Wert übergeben wird, wird der Stern um einen halben Spitzenwinkel gedreht:
<pre class="openscad">include <BOSL2/std.scad>
left(30) star(n=5, step=2, d=50);
right(30) star(n=5, step=2, d=50, realign=true);</pre>
=== star() mit align_tip=<Anker> ===
Das <code>align_tip=</code>-Argument kann mit einem Vektor angegeben werden, damit du die erste Spitze in eine bestimmte Richtung ausrichten kannst:
[[Datei:BOSL2-star n5 align tip anchor tip0.png|mini|zentriert|alternativtext=align_tip=BACK|star(n=5, ir=15, or=30, align_tip=BACK) attach("tip0") color("blue") anchor_arrow2d();]]
<pre class="openscad">include <BOSL2/std.scad>
star(n=5, ir=15, or=30, align_tip=BACK)
attach("tip0") color("blue") anchor_arrow2d();</pre>
=== star() mit align_pit=<Anker> ===
Ebenso kann die erste Einkerbung oder Einbuchtung mit <code>align_pit=</code> in Richtung eines bestimmten Vektors ausgerichtet werden:
[[Datei:BOSL2-star n5 align pit BACK attach tip0.png|mini|zentriert|alternativtext=align_pit=BACK|star(n=5, ir=15, or=30, '''align_pit=BACK''') '''attach("tip0")''' color("blue") anchor_arrow2d();]]
<pre class="openscad">include <BOSL2/std.scad>
star(n=5, ir=15, or=30, align_pit=BACK)
attach("pit0") color("blue") anchor_arrow2d();</pre>
Du kannst <code>anchor=</code> und <code>spin=</code> verwenden, genau wie bei anderen anhängbaren Formen. Die Ankerpunkte basieren jedoch auf den äußersten Ausmaßen der Form und sind möglicherweise nicht dort, wo du sie erwartest:
[[Datei:BOSL2-star n5 anchor LEFT-show anchers.png|mini|zentriert|alternativtext=anchor=LEFT|star(n=5, step=2, d=50,'''anchor=LEFT''') '''show_anchors(custom=false)''';]]
<pre class="openscad">include <BOSL2/std.scad>
star(n=5, step=2, d=50)
show_anchors(custom=false);</pre>
=== Benannte Ankerpunkte bei star() ===
Sterne haben auch benannte Ankerpunkte für ihre Gruben, Spitzen und Mittelpunkte zwischen den Spitzen:
[[Datei:BOSL2-star n5 benannteAnker.png|mini|zentriert|alternativtext=benannten Ankerpunkte in star()|Zuordnung der benannten Ankerpunkte in star(). Spitzen beginnen mit "tipt0", Einkerbungen mit pit0.]]
==== Beispiel 1: anchor="tip0" attach("pit0") ====
[[Datei:BOSL2-star-n5 ir=15 or30 anchor tip0 pit0.png|mini|zentriert|alternativtext=anchor="tip0"|star(n=5, ir=15, or=30, anchor="tip0") attach("pit0") #circle(3);]]
<pre class="openscad">
include <BOSL2/std.scad>
star(n=5, ir=15, or=30, anchor="tip0") attach("pit0") #circle(3);
</pre>
==== Beispiel 2: anchor="pit0" attach("tip0") ====
[[Datei:BOSL2-star n5 anchor pit0 attach tip0.png|mini|zentriert|alternativtext=anchor="pit0" attach("tip0")|star(n=5, ir=15, or=30, anchor="pit0") attach("tip0") #circle(3);]]
<pre class="openscad">
include <BOSL2/std.scad>
star(n=5, ir=15, or=30, anchor="pit0") attach("tip0") #circle(3);
</pre>
<span id="tropfenform-2d-teardrop2d"></span>
== Tropfenform 2D (Teardrop2D) ==
Beim 3D-Druck möchtest du oft ein kreisförmiges Loch in eine vertikale Wand machen. Wenn das Loch jedoch zu groß ist, kann der Überhang an der Oberseite des Lochs Probleme beim Drucken auf einem FDM/FFF-Drucker verursachen. Wenn du kein Stützmaterial verwenden möchtest, kannst du einfach die Tropfenform verwenden. Das <code>teardrop2d()</code>-Modul ermöglicht es dir, eine 2D-Version der Tropfenform zu erstellen, damit du sie später extrudieren kannst:
[[Datei:BOSL2-teardrop2d r20.png|mini|zentriert|alternativtext=teardrop2d(r=20);|teardrop2d(r=20);]]
<pre class="openscad">include <BOSL2/std.scad>
teardrop2d(r=20);</pre>
=== Extrudiert als tropfenförmige Aussparung:
[[Datei:BOSL2-teardrop2d Loch linear extrudiert.png|mini|zentriert|alternativtext=Lineares Extrudieren eines Quadrats mit zentrierter Tropfenform|linear_extrude(5) { diff() { rect(50) attach(CTR,CTR, inside=true) teardrop2d(d=20); }}]]
<pre class="openscad">
include <BOSL2/std.scad>
linear_extrude(5) {
diff() {
rect(50)
attach(CTR,CTR, inside=true)
teardrop2d(d=20);
}}</pre>
=== ang=<Überhangwinkel> ===
Der Standard-Überhangwinkel beträgt 45 Grad, aber du kannst ihn mit dem <code>ang=</code>-Argument anpassen:
[[Datei:BOSL2-teardrop2d ang20.png|mini|zentriert|alternativtext=teardrop2d(d=50, ang=20);|teardrop2d(d=50, ang=20);]]
<pre class="openscad">include <BOSL2/std.scad>
teardrop2d(d=50, ang=20);</pre>
=== cap_h=<Kapphöhe> ===
Wenn du es vorziehst, die Oberseite des Tropfens abzuflachen, um das Bridging zu fördern, kannst du das <code>cap_h=</code>-Argument verwenden:
[[Datei:BOSL2-teardrop2d ang20 cap h38c.png|mini|zentriert|alternativtext=teardrop2d(d=50, ang=20, cap_h=38);|teardrop2d(d=50, ang=20, '''cap_h=38''');]]
<pre class="openscad">include <BOSL2/std.scad>
teardrop2d(d=50, ang=20, cap_h=38);</pre>
=== show_anchors() bei teardrop2d ===
Du kannst <code>anchor=</code> und <code>spin=</code> verwenden, genau wie bei anderen anhängbaren Formen. Die Ankerpunkte basieren jedoch auf den äußersten Ausmaßen der Form und sind möglicherweise nicht dort, wo du sie erwartest:
[[Datei:BOSL2-teardrop2d anchorBACK show anchors.png|mini|zentriert|alternativtext=teardrop2d(d=50, anchor=BACK) show_anchors();|teardrop2d(d=50, anchor=BACK) show_anchors();]]
<pre class="openscad">
include <BOSL2/std.scad>
teardrop2d(d=50, anchor=BACK)
show_anchors();
</pre>
<span id="verklebte-kreise-glued-circles"></span>
== Verklebte Kreise (Glued Circles) ==
Eine ungewöhnlichere Form, die BOSL2 bietet, sind verklebte Kreise (Glued Circles). Es handelt sich im Grunde um ein Paar von Kreisen, die durch etwas verbunden sind, das wie ein klebriger Meniskus aussieht:
[[Datei:BOSL2-glued circles d30 spread40.png|mini|zentriert|alternativtext=glued_circles(d=30, spread=40);|glued_circles(d=30, spread=40);]]
<pre class="openscad">include <BOSL2/std.scad>
glued_circles(d=30, spread=40);</pre>
=== d/r=<Kreisdurchmesser/Kreisradius>, spread=<Abstand Kreismittelpunkte> ===
Die <code>r=</code>/<code>d=</code>-Argumente können den Radius oder Durchmesser der beiden Kreise angeben:
<pre class="openscad">include <BOSL2/std.scad>
glued_circles(r=20, spread=45);</pre>
<pre class="openscad">include <BOSL2/std.scad>
glued_circles(d=40, spread=45);</pre>
Das <code>spread=</code>-Argument gibt den Abstand zwischen den Mittelpunkten der beiden Kreise an:
<pre class="openscad">include <BOSL2/std.scad>
glued_circles(d=30, spread=30);</pre>
=== tangent = <Tangentenwinkel-Miniskus> ===
Das <code>tangent=</code>-Argument gibt den Winkel der Tangente des Meniskus an den beiden Kreisen an:
[[Datei:BOSL2-glued circles d30 spread40 tangent=45.png|mini|zentriert|alternativtext=glued_circles(d=30, spread=30, tangent=45);|glued_circles(d=30, spread=30, tangent=45);]]
Auch negative Werte sind für den Tangentenwinkel möglich, so wird aus der Einbuchtung eine Ausbuchtung:
[[Datei:BOSL2-glued circles d30 spread40 tangent=-45.png|mini|zentriert|alternativtext= tangent=-40|glued_circles(d=30, spread=30, tangent=-40);]]
<pre class="openscad">include <BOSL2/std.scad>
glued_circles(d=30, spread=30, tangent=-45);</pre>
=== Langloch mit tangent=0 ===
Mit einem Tangentenwinkel von 0 erhält man eine Form, die sehr nützlich sein kann, um Langlöcher zu konstruieren.
[[Datei:BOSL2-glued circles Langlochform tangent0.png|mini|zentriert|alternativtext=Langlochform mit glued_circles|Langlochform mit glued_circles(d=30, spread=30, tangent=0);]]
<pre class="openscad">
include <BOSL2/std.scad>
glued_circles(d=30, spread=30, tangent=0);
</pre>
==== 3D-Langloch in Platte ====
[[Datei:BOSL2-glued circles Langlochform tangent0 3D.png|mini|zentriert|alternativtext=3D-Langloch glued_circlesh |Langloch (3D) durch lineares Extrudieren von glued_circles]]
Code-Variante A:
<pre class="openscad">
include <BOSL2/std.scad>
difference() {
cube([80, 80, 10], center = false);
right(40) back(40) down(2)
linear_extrude(height = 14) {
glued_circles(d = 30, spread = 30, tangent = 0);
}
}
</pre>
Code-Variante B:
<pre class="openscad">
include <BOSL2/std.scad>
linear_extrude(10)
diff("Langloch")
rect([80, 80], anchor=LEFT+FRONT)
tag("Langloch")
glued_circles(d = 25, spread = 30, tangent = 0);
</pre>
Code-Variante C:
<pre class="openscad">
include <BOSL2/std.scad>
linear_extrude(10)
diff()
rect([80, 80], anchor=LEFT+FRONT)
attach(CTR,CTR, inside=true)
glued_circles(d = 25, spread = 30, tangent = 0);
</pre>
Alle drei Varianten liefern das gleiche Ergebnis.
=== Gerippte Wand ===
Eine nützliche Sache, die du tun kannst, ist, einige <code>glued_circle()</code>s in einer Linie anzuordnen und sie dann zu extrudieren, um eine gerippte Wand zu erstellen:
[[Datei:BOSL2-glued circles gerippte Wand=-45.png|mini|zentriert|alternativtext=Gerippte Wand mit extrudierten glued_circles|$fn=64; s=10; linear_extrude(height=50,convexity=16,center=true) xcopies(s*sqrt(2),n=3) glued_circles(d=s, spread=s*sqrt(2), tangent=45);]]
<pre class="openscad">include <BOSL2/std.scad>
$fn=36; s=10;
linear_extrude(height=50,convexity=16,center=true)
xcopies(s*sqrt(2),n=3)
glued_circles(d=s, spread=s*sqrt(2), tangent=45);</pre>
Du kannst <code>anchor=</code> und <code>spin=</code> verwenden, genau wie bei anderen anhängbaren Formen. Die Ankerpunkte basieren jedoch auf den äußersten Ausmaßen der Form und sind möglicherweise nicht dort, wo du sie erwartest:
<pre class="openscad">include <BOSL2/std.scad>
glued_circles(d=40, spread=40, tangent=45)
show_anchors();</pre>
1eudqhv18z76295usz3bihxtebqnea8
1093542
1093540
2026-11-08T18:53:58Z
Jowi-ammerbuch
115360
/* spin= bei right_triangle */
1093542
wikitext
text/x-wiki
{{MyNavi
|zurück = [[OpenSCAD Benutzerhandbuch/_BOSL2-Distributoren|Zurück]]
|buch = [[OpenSCAD Benutzerhandbuch/_BOSL2|BOSL2-Inhalt]]
|weiter = [[OpenSCAD Benutzerhandbuch/_BOSL2-3D|Weiter]]
}}
== 2D Grundformen (2D Primitive) ==
OpenSCAD bietet zwei eingebaute 2D-Grundformen: <code>square()</code> und <code>circle()</code>. Du kannst sie weiterhin auf die gewohnte Weise verwenden:
<pre class="openscad">include <BOSL2/std.scad>
square([60,40], center=true);</pre>
<pre class="openscad">include <BOSL2/std.scad>
circle(r=50);</pre>
<pre class="openscad">include <BOSL2/std.scad>
circle(d=100, $fn=8);</pre>
Diese Module wurden in der BOSL2-Bibliothek in drei Bereichen erweitert: Verankerung (Anchoring), Drehung (Spin) und Anhängbarkeit (Attachability).
<span id="verankerung-anchoring"></span>
=== Verankerung (Anchoring): ===
Wenn du ein <code>square()</code> erstellst, kannst du angeben, welche Ecke oder Seite am Ursprung verankert werden soll. Dies ersetzt das <code>center=</code>-Argument und ist flexibler. Das <code>anchor=</code>-Argument nimmt einen Vektor als Wert entgegen, der in grober Richtung der Seite oder Ecke zeigt, die du am Ursprung ausrichten möchtest.
=== anchor=[0,1] oder anchor=BACK ===
[[Datei:BOSL2-anchor-0-1.png|mini|zentriert|alternativtext=anchor=[0,1]);|square([60,40], '''anchor=[0,1]''');<br>
Oder: square([60,40], '''anchor=BACK''');]]
Um beispielsweise das '''Zentrum der hinteren Kante am Ursprung''' auszurichten, setzt du den Anker auf <code>[0,1]</code>:
<pre class="openscad">
include <BOSL2/std.scad>
square([60,40], anchor=[0,1]);
</pre>
Mit den leichter verständlichen vordefinierten '''Vektor-Konstanten''':
<pre class="openscad">
include <BOSL2/std.scad>
square([60,40], anchor=BACK+CENTER);
</pre>
=== anchor=[1,-1] oder anchor=RIGHT+FRONT ===
Um die '''vordere rechte Ecke am Ursprung''' auszurichten:
[[Datei:BOSL2-anchor-1 -1.png|mini|zentriert|alternativtext=anchor=RIGHT+FRONT);|square([60,40], '''anchor=[1,-1]''');<br>
Oder: square([60,40], '''anchor=RIGHT+FRONT''');]]
<pre class="openscad">
include <BOSL2/std.scad>
square([60,40], anchor=[1,-1]);
</pre>
'''Mit Vektor-Konstanten:'''
<pre class="openscad">
include <BOSL2/std.scad>
square([60,40], anchor=RIGHT+FRONT);
</pre>
=== anchor=[0,0] oder anchor=CENTER '''Fetter Text'''===
Um es zu '''zentrieren''':
<pre class="openscad">
include <BOSL2/std.scad>
square([60,40], anchor=[0,0]);
</pre>
'''Mit Vektor-Konstanten:'''
<pre class="openscad">
include <BOSL2/std.scad>
square([60,40], anchor=CENTER);
</pre>
=== Vektor-Konstanten am Rechteck ===
Um die Angabe von Vektoren übersichtlicher zu gestalten, sind mehrere Standard-Vektorkonstanten definiert:
[[Datei:BOSL2-anchor-Konstanten-Rechteck.png|gerahmt|zentriert|alternativtext=BOSL2 vordefinierte anchor-Konstanten|Die in BOSL2 vordefinierten anchor-Konstanten]]
{| class="wikitable"
|-
! Konstante
! Richtung
! Wert
|-
| LEFT
| X-
| [-1, 0, 0]
|-
| RIGHT
| X+
| [ 1, 0, 0]
|-
| FRONT / FORWARD / FWD
| Y-
| [ 0,-1, 0]
|-
| BACK
| Y+
| [ 0, 1, 0]
|-
| BOTTOM / BOT / BTM / DOWN
| Z-
| [ 0, 0,-1] (nur 3D)
|-
| TOP / UP
| Z+
| [ 0, 0, 1] (nur 3D)
|-
| CENTER / CTR
| Zentriert
| [ 0, 0, 0]
|}
Beachte, dass du die meisten dieser Konstanten (außer <code>UP</code>/<code>DOWN</code> natürlich) auch für Anker bei 2D-Formen verwenden kannst, obwohl es sich um 3D-Vektoren handelt:
<pre class="openscad">include <BOSL2/std.scad>
square([60,40], anchor=BACK);</pre>
<pre class="openscad">include <BOSL2/std.scad>
square([60,40], anchor=CENTER);</pre>
Du kannst Vektoren addieren, um auf Ecken zu zeigen:
<pre class="openscad">include <BOSL2/std.scad>
square([60,40], anchor=FRONT+RIGHT);</pre>
=== anchor = polar_to_xy ===
Für <code>circle()</code> kann der Ankervektor auf jeden beliebigen '''Punkt des Kreisumfangs''' zeigen:
[[Datei:BOSL2-anchor-polar to xy-circle.png|gerahmt|zentriert|alternativtext=anchor = polar_to_xy|anchor = polar_to_xy(1,Alpha), für Alpha = 0, 45, 90, ...]]
==== Beispiel: anchor=polar_to_xy(1,45) =====
[[Datei:BOSL2-anchor-polar to 1-45-octagon.png|mini|zentriert|alternativtext=circle(d=50, anchor=polar_to_xy(1,45), $fn = 8);|circle(d=50, anchor=polar_to_xy(1,45), $fn = 8);]]
<pre class="openscad">
include <BOSL2/std.scad>
circle(d=50, anchor=polar_to_xy(1,45), $fn = 8);
</pre>
Beachte, dass der Radius für den Anker keine Rolle spielt, da nur die Richtung des Ankers das Ergebnis beeinflusst.
=== show_anchors() ===
[[Datei:BOSL2-show anchor.png|mini|zentriert|show_anchors]]
Du kannst die typischen Ankerpunkte sehen, indem du <code>show_anchors()</code> als Kind der Form übergibst:
<pre class="openscad">include <BOSL2/std.scad>
square([60,40], center=true)
show_anchors();</pre>
<pre class="openscad">include <BOSL2/std.scad>
circle(d=50)
show_anchors();</pre>
<span id="drehung-spin"></span>
=== Drehung (Spin): ===
Die zweite Erweiterung von <code>square()</code> und <code>circle()</code> ist die Drehung (Spin). Wenn du die Form erstellst, kannst du sie mit dem <code>spin=</code>-Argument an Ort und Stelle drehen. Du übergibst einfach die Anzahl der Grad, um die sie im Uhrzeigersinn gedreht werden soll:
<pre class="openscad">include <BOSL2/std.scad>
square([60,40], anchor=CENTER, spin=30);</pre>
Die Verankerung oder Zentrierung erfolgt vor der Drehung:
<pre class="openscad">include <BOSL2/std.scad>
square([60,40], anchor=BACK, spin=30);</pre>
Bei Kreisen kann Spin nützlich sein, wenn auch <code>$fn=</code> angegeben wird:
<pre class="openscad">include <BOSL2/std.scad>
circle(d=50, $fn=6, spin=15);</pre>
Da die Verankerung vor der Drehung erfolgt, kannst du beides zusammen verwenden, um um den Anker herum zu drehen:
<pre class="openscad">include <BOSL2/std.scad>
circle(d=50, $fn=6, anchor=LEFT, spin=15);</pre>
<span id="anhängbarkeit-attachability"></span>
=== Anhängbarkeit (Attachability): ===
Die dritte Erweiterung von <code>square()</code> und <code>circle()</code> ist, dass du sie auf verschiedene Weise an Ankerpunkten zusammenhängen kannst. Dies geschieht, indem du eine Form zum Kind der Form machst, an die du sie anhängen möchtest.
==== Standard (ohne Spez. für anchor oder position) ====
Standardmäßig wird das Kind beim einfachen Untereinanderstellen im Zentrum der Elternform angehängt.
[[Datei:BOSL2-attach-standard-normal.png|mini|zentriert|alternativtext=square(50) #square(50);|square(50) #square(50);<br>
Kind-Objekt (rot) wird ans Zentrum des Elternobjekts angehängt]]
<pre class="openscad">
include <BOSL2/std.scad>
square(50) #square(50);
</pre>
==== anchor für child spezifiziert ====
[[Datei:BOSL2-attach-anchor-LEFTplusFWD.png|mini|zentriert|alternativtext=square(50, center=true) #square([20,40], anchor=LEFT+FWD);|square(50, center=true)#square([20,40], '''anchor=LEFT+FWD''');]]
<pre class="openscad">include <BOSL2/std.scad>
square(50, center=true)
#square([20,40], anchor=LEFT+FWD);</pre>
==== position() ====
[[Datei:BOSL2-attach-position.png|mini|zentriert|alternativtext=position(RIGHT)|square(50) '''position(RIGHT)''' #square(25) '''position(BACK)''' #square(25);]]
Durch Hinzufügen des <code>position()</code>-Moduls kannst du das Kind an jedem Ankerpunkt '''des Elternteils''' positionieren, das "Kindes-Kind wird am Ankerpunkt des übergeordneten Objekts positioniert:
<pre class="openscad">
include <BOSL2/std.scad>
square(50) position(RIGHT) #square(25)
position(BACK) #square(25);
</pre>
==== orient() ====
Ankerpunkte sind jedoch nicht nur Positionen auf dem Elternteil. Sie haben auch eine Ausrichtung. In den meisten Fällen zeigt die Ausrichtung eines Ankerpunkts nach außen, weg von der Fläche der Wand, also im Allgemeinen vom Zentrum der Form weg.
[[Datei:BOSL2-show anchor.png|mini|zentriert|show_anchors]]
Wenn du das Kind so ausrichten möchtest, dass es der Ausrichtung eines Ankerpunkts entspricht, kannst du das <code>orient()</code>-Modul verwenden. Es positioniert das Kind nicht, es dreht es nur:
[[Datei:BOSL2-attach-orient anchor.png|mini|zentriert|alternativtext= orient(anchor=LEFT+BOTTOM)|square(50) '''orient(anchor=LEFT+BOTTOM)''' #square([10,40]);]]
<pre class="openscad">include <BOSL2/std.scad>
square(50)
orient(anchor=LEFT+BOTTOM) #square([10,40]);</pre>
Das geht auch beim '''Kreis (circle)''' mit '''polar_to_xy''':
[[Datei:BOSL2-attach-orient polar to xy circle.png|mini|zentriert|alternativtext=orient(polar_to_xy(1,30))|circle(d=50) ''' orient(polar_to_xy(1,30))''' #square([10,40], anchor=FWD);]]
<pre class="openscad">include <BOSL2/std.scad>
circle(d=50)
orient(polar_to_xy(1,30))
#square([10,40], anchor=FWD);</pre>
==== position() + orient() ====
Du kannst <code>position()</code> und <code>orient()</code> zusammen verwenden, um sowohl zu positionieren als auch an einem Ankerpunkt auszurichten:
[[Datei:BOSL2-attach-position pluss orient polar to xy circle.png|mini|zentriert|alternativtext=position(polar_to_xy(1,30)) orient(polar_to_xy(1,30))|circle(d=50) '''position(polar_to_xy(1,30)) orient(polar_to_xy(1,30))''' #square([10,40], anchor=FWD);]]
<pre class="openscad">include <BOSL2/std.scad>
circle(d=50)
position(polar_to_xy(1,30))
orient(polar_to_xy(1,30))
#square([10,40], anchor=FWD);</pre>
=== attach () mit einem Argument ===
Aber es ist einfacher das <code>attach()</code>-Modul zu verwenden, um beides auf einmal zu erledigen:
[[Datei:BOSL2-attach-position pluss orient polar to xy circle.png|mini|zentriert|alternativtext=attach(polar_to_xy(1,30))|circle(d=50) '''attach(polar_to_xy(1,30))''' #square([10,40], anchor=FWD); ]]
Gleiches Ergebnis, aber übersichtlicherer Code.
<pre class="openscad">include <BOSL2/std.scad>
square(50, center=true)
attach(LEFT+BACK)
#square([10,40], anchor=FWD);</pre>
=== attach () mit zwei Argumenten ===
Anstatt den <code>anchor=</code> im Kind anzugeben, kannst du ein '''zweites Argument''' an <code>attach()</code> übergeben, das ihm sagt, welche Seite des Kindes mit dem Elternteil verbunden werden soll:
<pre class="openscad">
include <BOSL2/std.scad>
circle(d=50) attach(polar_to_xy(1,30), FWD) #square([10,40]);
</pre>
Damit lässt sich der Code noch mehr straffen.
[[Datei:BOSL2-attach-position pluss orient polar to xy circle.png|mini|zentriert|alternativtext=attach(polar_to_xy(1,30), FWD)|circle(d=50) '''attach(polar_to_xy(1,30), FWD)''' #square([10,40]); ]]
<span id="rechtecke-rectangles"></span>
== Rechtecke (Rectangles) ==
=== rect() ===
Die BOSL2-Bibliothek bietet eine Alternative zu <code>square()</code>, die mehr Funktionen unterstützt. Sie heißt <code>rect()</code>. Du kannst sie genauso verwenden wie <code>square()</code>, aber sie bietet auch erweiterte Funktionalität.
=== rect() mit rounding ===
[[Datei:BOSL2-rect rounding.png|mini|zentriert|alternativtext=rounding=10|rect([60,40], '''rounding=10''');]]
rect() erlaubt dir, die Ecken des Rechtecks abzurunden:
<pre class="openscad">include <BOSL2/std.scad>
rect([60,40], rounding=10);</pre>
=== rect() mit chamfer ===
[[Datei:BOSL2-rect chamfer.png|mini|zentriert|alternativtext=rect([60,40], chamfer=10);|rect([60,40], '''chamfer=10''');]]
Du kannst die Ecken des Rechtecks auch abfasen:
<pre class="openscad">include <BOSL2/std.scad>
rect([60,40], chamfer=10);</pre>
=== Unterschiedliche Abrundungen und Fasen an einem Rechteck ===
Du kannst sogar angeben, welche Ecken abgerundet oder abgefast werden. Wenn du eine Liste mit vier Größenwerten an die <code>rounding=</code>- oder <code>chamfer=</code>-Argumente übergibst, erhält jede Ecke ihre eigene Größe. Der Reihe nach geht es von der hinteren rechten Ecke (Quadrant I) gegen den Uhrzeigersinn zur hinteren linken Ecke (Quadrant II), zur vorderen linken Ecke (Quadrant III) und zur vorderen rechten Ecke (Quadrant IV):
Wenn eine Größe als <code>0</code> angegeben wird, gibt es keine Rundung und/oder Fase für die Ecke dieses Quadranten:
<pre class="openscad">include <BOSL2/std.scad>
rect([60,40], rounding=[0,5,10,15]);</pre>
<pre class="openscad">include <BOSL2/std.scad>
rect([60,40], chamfer=[0,5,10,15]);</pre>
Du kannst sowohl <code>rounding=</code>- als auch <code>chamfer=</code>-Argumente angeben, um Rundung und Fase zu mischen, aber nur, wenn du es pro Ecke angibst. Wenn du eine Rundung in einer Ecke möchtest, gib eine Fase von 0 für diese Ecke an und umgekehrt:
[[Datei:BOSL2-rect chamfer-rounding-mixed.png|mini|zentriert|alternativtext=ounding=[5,0,10,0], chamfer=[0,5,0,15]|rect([60,40], '''rounding=[5,0,10,0], chamfer=[0,5,0,15]''');]]
<pre class="openscad">include <BOSL2/std.scad>
rect([60,40], rounding=[5,0,10,0], chamfer=[0,5,0,15]);</pre>
<span id="ellipsen-ellipses"></span>
== Ellipsen (Ellipses) ==
Die BOSL2-Bibliothek bietet auch eine erweiterte Entsprechung von <code>circle()</code>, die <code>ellipse()</code> heißt. Du kannst sie genauso verwenden wie <code>circle()</code>, aber sie bietet auch erweiterte Funktionalität. Zum Beispiel erlaubt sie mehr Kontrolle über ihre Größe.
Da ein Kreis in OpenSCAD nur durch ein regelmäßiges Polygon mit einer Anzahl gerader Seiten angenähert werden kann, kann dies zu Ungenauigkeiten in Größe und Form führen. Um dem entgegenzuwirken, werden auch die Argumente <code>realign=</code> und <code>circum=</code> bereitgestellt.
=== realign= (ellipse-Argument) ===
Das <code>realign=</code>-Argument rotiert, wenn es auf <code>true</code> gesetzt wird, die <code>ellipse()</code> um den halben Winkel zwischen den Polygonseiten:
[[Datei:BOSL2-ellipse-realign.png|mini|zentriert|alternativtext=realign=true|#ellipse(d=100, $fn=8); color("lime") ellipse(d=100, $fn=8, '''realign=true''');]]
<pre class="openscad">
include <BOSL2/std.scad>
#ellipse(d=100, $fn=8);
color("lime") ellipse(d=100, $fn=8, realign=true);
</pre>
=== circum= (ellipse-Argument) ===
[[Datei:BOSL2-ellipse-circum.png|mini|zentriert|alternativtext=circum=true|Vergleich: rot (außen) mit circum=true und blau (innen) ohne circum. Referenz: idealer Kreis in gelb.]]
<pre class="openscad">
include <BOSL2/std.scad>
color("red") ellipse(d=100, $fn=6, circum=true);
color("yellow") ellipse(d=100, $fn=360);
color("blue") ellipse(d=100, $fn=6);
</pre>
Das <code>circum=</code>-Argument bewirkt, wenn es auf true gesetzt wird, dass das Polygon, das die <code>ellipse()</code> bildet, den idealen Kreis '''umschreibt''', anstatt ihn einzuschreiben.
Den idealen Kreis ''einschreiben'':
<pre class="openscad">include <BOSL2/std.scad>
color("green") ellipse(d=100, $fn=360);
ellipse(d=100, $fn=6);</pre>
Den idealen Kreis ''umschreiben'':
<pre class="openscad">include <BOSL2/std.scad>
ellipse(d=100, $fn=6, circum=true);
color("green") ellipse(d=100, $fn=360);</pre>
=== Ellipse mit 2 Radien ===
Das <code>ellipse()</code>-Modul kann, wie der Name schon sagt, mit separaten X- und Y-Radien oder -Durchmessern angegeben werden. Dazu gibst du einfach <code>r=</code> oder <code>d=</code> mit einer Liste von zwei Radien oder Durchmessern an:
[[Datei:BOSL2-ellipse-2Radien.png|mini|zentriert|alternativtext=2 Radien|ellipse('''r=[30,20]''');]]
==== r=[r1,r2] ====
<pre class="openscad">include <BOSL2/std.scad>
ellipse(r=[30,20]);</pre>
==== d=[d1,d2]====
<pre class="openscad">include <BOSL2/std.scad>
ellipse(d=[60,40]);</pre>
==== ellipse mit anchor ====
Wie bei <code>circle()</code> kannst du <code>ellipse()</code>-Formen verankern, drehen und anhängen:
[[Datei:BOSL2-ellipse-anchor.png|mini|zentriert|alternativtext=ellipse mit anchor|ellipse(d=[50,20], '''anchor=BACK'''); #ellipse(d=[50,20], '''anchor=FRONT''');]]
<pre class="openscad">
include <BOSL2/std.scad>
ellipse(d=[50,20], anchor=BACK);
#ellipse(d=[50,20], anchor=FRONT);
</pre>
==== ellipse mit attach ====
[[Datei:BOSL2-ellipse-attach.png|mini|zentriert|alternativtext=ellipse mit attach|ellipse(d=50) '''attach(BACK+RIGHT, FRONT+LEFT)''' #ellipse(d=[40,20]);]]
<pre class="openscad">
include <BOSL2/std.scad>
ellipse(d=50)
attach(BACK+RIGHT, FRONT+LEFT)
ellipse(d=30);
</pre>
<span id="rechtwinklige-dreiecke-right-triangles"></span>
==== ellipse mit spin ====
[[Datei:BOSL2-ellipse-attach-spin-anchor.png|mini|zentriert|alternativtext=spin = 90 bei ellipse|ellipse(d=50) attach(BACK) #ellipse(d=[40,20], '''spin=90''', anchor=LEFT);]]
<pre class="openscad">
include <BOSL2/std.scad>
ellipse(d=50)
attach(BACK)
#ellipse(d=[40,20], spin=90, anchor=LEFT);
</pre>
== Rechtwinklige Dreiecke (Right Triangles) ==
Die BOSL2-Bibliothek bietet eine einfache Möglichkeit, ein 2D-rechtwinkliges Dreieck mit dem <code>right_triangle()</code>-Modul zu erstellen:
[[Datei:BOSL2-right triangle.png|mini|zentriert|alternativtext=right_triangle([40,30])|right_triangle([40,30]);]]
<pre class="openscad">include <BOSL2/std.scad>
right_triangle([40,30]);</pre>
=== xflip() bei right_triangle ===
Du kannst <code>xflip()</code> und <code>yflip()</code> verwenden, um zu ändern, in welchem Quadranten das Dreieck gebildet wird:
[[Datei:BOSL2-right triangle xflip.png|mini|zentriert|alternativtext=right_triange mit xflip()|right_triangle([40,30]); '''xflip()''' #right_triangle([40,30]);]]
<pre class="openscad">include <BOSL2/std.scad>
xflip() right_triangle([40,30]);</pre>
=== yflip() bei right_triangle ===
[[Datei:BOSL2-right triangle yflip.png|mini|zentriert|alternativtext=right_triangle([40,30]) mit yflip()|right_triangle([40,30]); '''yflip()''' #right_triangle([40,30]);]]
<pre class="openscad">include <BOSL2/std.scad>
yflip() right_triangle([40,30]);</pre>
=== xflip() & yflip() bei right_triangle ===
[[Datei:BOSL2-right triangle xflip yflip.png|mini|zentriert|alternativtext=xflip() yflip()|right_triangle([40,30]); xflip() yflip() #right_triangle([40,30]);]]
<pre class="openscad">include <BOSL2/std.scad>
xflip() yflip() right_triangle([40,30]);</pre>
=== spin= bei right_triangle ===
Oder alternativ einfach mit <code>spin=</code> in den richtigen Quadranten drehen:
[[Datei:BOSL2-right triangle spin.png|mini|zentriert|alternativtext=right_triangle([40,30]) mit spin=90)|right_triangle([40,30]);
#right_triangle([40,30], '''spin=90''');]]
<pre class="openscad">include <BOSL2/std.scad>
right_triangle([40,30], spin=90);</pre>
<pre class="openscad">include <BOSL2/std.scad>
right_triangle([40,30], spin=-90);</pre>
Du kannst bei rechtwinkligen Dreiecken auch Verankerung verwenden:
[[Datei:BOSL2-right triangle anchors.png|mini|alternativtext=anchor=CTR|right_triangle([40,30], anchor=FWD+RIGHT) show_anchors();]]
<pre class="openscad">include <BOSL2/std.scad>
right_triangle([40,30], anchor=FWD+RIGHT) show_anchors();</pre>
<span id="trapeze-trapezoids"></span>
== Trapeze (Trapezoids) ==
OpenSCAD bietet keine einfache Möglichkeit, allgemeine 2D-Dreiecke, Trapeze oder Parallelogramme zu erstellen. Die BOSL2-Bibliothek kann all diese Formen mit dem <code>trapezoid()</code>-Modul bereitstellen.
=== Dreieck ===
==== Gleichseitiges Dreieck ====
Um ein gleichseitiges Dreieck zu erstellen, setze einfach eine der Breiten auf null:
[[Datei:BOSL2-trapezoid dreieck.png|mini|zentriert|alternativtext=Dreieck|trapezoid(w1=50, w2=0, h=40);<br>
Dreieck mit Seitenlänge = 50]]
<pre class="openscad">include <BOSL2/std.scad>
trapezoid(w1=50, w2=0, h=40);</pre>
==== Rechtwinkliges Dreieck ====
Um ein rechtwinkliges Dreieck zu erstellen, musst du das <code>shift=</code>-Argument verwenden, um die Rückseite des Trapezes entlang der X-Achse zu verschieben:
[[Datei:BOSL2-trapezoid dreieck-rechtwinklig.png|mini|zentriert|alternativtext=Rechtwinkliges Dreieck|trapezoid(w1=50, w2=0, h=50, shift=-25);]]
<pre class="openscad">include <BOSL2/std.scad>
trapezoid(w1=50, w2=0, h=50, shift=-25);</pre>
[[Datei:BOSL2-trapezoid dreieck-rechtwinklig shift25.png|mini|zentriert|alternativtext=trapezoid(w1=50, w2=0, h=50, shift=25);|trapezoid(w1=50, w2=0, h=50, shift=25);]]
<pre class="openscad">include <BOSL2/std.scad>
trapezoid(w1=50, w2=0, h=50, shift=25);</pre>
[[Datei:BOSL2-trapezoid dreieck-rechtwinklig shift-25.png|mini|zentriert|alternativtext=trapezoid(w1=0, w2=50, h=50, shift=-25);|trapezoid(w1=0, w2=50, h=50, shift=-25);]]
<pre class="openscad">include <BOSL2/std.scad>
trapezoid(w1=0, w2=50, h=50, shift=-25);</pre>
[[Datei:BOSL2-trapezoid dreieck-rechtwinklig shift25 w1=0.png|mini|zentriert|alternativtext=trapezoid(w1=0, w2=50, h=50, shift=25);|trapezoid(w1=0, w2=50, h=50, shift=25);]]
<pre class="openscad">include <BOSL2/std.scad>
trapezoid(w1=0, w2=50, h=50, shift=25);</pre>
=== Trapez ===
Du kannst ein Trapez erstellen, indem du für vorne (<code>w1=</code>) und hinten (<code>w2=</code>) von null verschiedene Breiten angibst:
[[Datei:BOSL2-trapezoid trapez.png|mini|zentriert|alternativtext=Trapez|trapezoid(w1=30, w2=50, h=50);]]
<pre class="openscad">include <BOSL2/std.scad>
trapezoid(w1=30, w2=50, h=50);</pre>
=== Parallelogramm ===
Ein Parallelogramm ist nur eine Frage der Verwendung der gleichen Breite für vorne und hinten, mit einer Verschiebung entlang der X-Achse:
[[Datei:BOSL2-trapezoid parallelogram.png|mini|zentriert|alternativtext=Parallelogramm|trapezoid(w1=50, w2=50, shift=20, h=50);]]
<pre class="openscad">include <BOSL2/std.scad>
trapezoid(w1=50, w2=50, shift=20, h=50);</pre>
=== Viereck ===
Ein Viereck kann erstellt werden, indem ungleiche, von null verschiedene Breiten für vorne (<code>w1=</code>) und hinten (<code>w2=</code>) verwendet werden, wobei die Rückseite entlang der X-Achse verschoben wird:
[[Datei:BOSL2-trapezoid viereck.png|mini|zentriert|alternativtext=Viereck|trapezoid(w1=50, w2=30, shift=20, h=50);]]
<pre class="openscad">include <BOSL2/std.scad>
trapezoid(w1=50, w2=30, shift=20, h=50);</pre>
Du kannst <code>anchor=</code> und <code>spin=</code> verwenden, genau wie bei anderen anhängbaren Formen. Die Ausrichtungen der Ankerpunkte basieren jedoch auf den Seitenwinkeln der Flächen und sind möglicherweise nicht das, was du erwartest:
<pre class="openscad">include <BOSL2/std.scad>
trapezoid(w1=30, w2=50, h=50)
show_anchors();</pre>
<span id="regelmäßige-n-ecke-regular-n-gons"></span>
== Regelmäßige n-Ecke (Regular N-Gons) ==
OpenSCAD ermöglicht es dir, regelmäßige n-Ecke (Fünfeck, Sechseck usw.) zu erstellen, indem du <code>circle()</code> mit <code>$fn</code> verwendest. Obwohl dies prägnant ist, mag es auf den ersten Blick weniger offensichtlich sein:
<pre class="openscad">include <BOSL2/std.scad>
circle(d=50, $fn=5);</pre>
Die BOSL2-Bibliothek hat Module, die für gängige n-Ecke klarer benannt sind:
=== Pentagon (d=<Durchmesser>) ===
[[Datei:BOSL2-Pentagon.png|mini|zentriert|alternativtext=Pentagon|pentagon(d=50);]]
<pre class="openscad">include <BOSL2/std.scad>
pentagon(d=50);</pre>
=== Hexagon (d=<Durchmesser>) ===
[[Datei:BOSL2-Hexagon.png|mini|zentriert|alternativtext=Hexagon| hexagon(d=50);]]
<pre class="openscad">include <BOSL2/std.scad>
hexagon(d=50);</pre>
=== Octagon (d= <Durchmesser>) ===
[[Datei:BOSL2-Octagon.png|mini|zentriert|alternativtext=octagon(d=50);|octagon(d=50);]]
<pre class="openscad">include <BOSL2/std.scad>
octagon(d=50);</pre>
=== regular_ngon (n=<Seitenanzahl>, d=<Durchmesser>) ===
[[Datei:BOSL2-regular ngon.png|mini|zentriert|alternativtext=regular_ngon|regular_ngon(n=7, d=50);]]
<pre class="openscad">include <BOSL2/std.scad>
regular_ngon(n=7, d=50);</pre>
=== side=<Seitenlänge> ===
Diese Module bieten dir auch zusätzliche Funktionalität. Sie können nach Seitenlänge dimensioniert werden:
[[Datei:BOSL2-Hexagon side50.png|mini|zentriert|alternativtext=hexagon(side=50);|hexagon(side=50);]]
<pre class="openscad">include <BOSL2/std.scad>
pentagon(side=50);</pre>
=== ir = <Innenradius> / id = <Innendurchmesser> ===
Sie können nach dem Radius/Durchmesser des umschriebenen Kreises (Innenkreis) dimensioniert werden:
[[Datei:BOSL2-Pentagon Innenradius.png|mini|zentriert|alternativtext=Innenradius|color("red") pentagon('''ir=25'''); color("yellow") circle(r=25,$fn=100);]]
<pre class="openscad">include <BOSL2/std.scad>
pentagon(ir=25);
pentagon(id=50);</pre>
=== realign=true/false ===
Die Polygone können um eine halbe Seite gedreht werden:
[[Datei:BOSL2-Pentagon realign.png|mini|zentriert|alternativtext=realign|pentagon(d=50, '''realign=false'''); #pentagon(d=50, '''realign=true''');]]
<pre class="openscad">include <BOSL2/std.scad>
left(30) pentagon(d=50, realign=true);
right(30) pentagon(d=50, realign=false);</pre>
=== rounding = <Rundung> ===
Die BOSL2-Polygone können abgerundet werden:
[[Datei:BOSL2-Polygon-rounding.png|mini|zentriert|alternativtext=rounding|pentagon(d=50, '''rounding=5''');]]
<pre class="openscad">include <BOSL2/std.scad>
pentagon(d=50, rounding=5);</pre>
=== show_anchors() ===
Die BOSL2-Polygone haben auch ein etwas anderes Anhangsverhalten als die regulären Polygone, die über $fn=<Seitenanzahl> erzeugt werden.
Ein Kreis mit einem kleinen <code>$fn=</code> hängt Dinge am idealen Kreis an, nicht entlang des erstellten Polygons:
[[Datei:BOSL2-polygon-outcircle-anchors.png|mini|zentriert|alternativtext=anchors Außenkreis|color("green") stroke(circle(d=50), closed=true); circle(d=50,$fn=6) show_anchors();]]
<pre class="openscad">include <BOSL2/std.scad>
color("green") stroke(circle(d=50), closed=true);
circle(d=50,$fn=6)
show_anchors();</pre>
Während ein BOSL2-n-Eck entlang des Polygons selbst (direkt) anhängt:
[[Datei:BOSL2-polygon-direct-anchors.png|mini|zentriert|alternativtext=anchors BOSL2 Polygone direkt|color("green") stroke(circle(d=50), closed=true); circle(d=50,$fn=6) show_anchors();]]
<pre class="openscad">include <BOSL2/std.scad>
hexagon(d=50)
show_anchors(custom=false);</pre>
Du kannst <code>anchor=</code> und <code>spin=</code> verwenden, genau wie bei anderen anhängbaren Formen. Die Ankerpunkte basieren jedoch darauf, wo der Ankervektor die Seite des n-Ecks schneiden würde, und sind möglicherweise nicht dort, wo du sie erwartest:
[[Datei:BOSL2-Pentagon-anchor.png|mini|zentriert|alternativtext=n-Polygon anchor|pentagon(d=50, '''anchor=FRONT+LEFT''') show_anchors(custom=false);]]
<pre class="openscad">include <BOSL2/std.scad>
pentagon(d=50, anchor=FRONT+LEFT)
show_anchors(custom=false);</pre>
=== Ankerpunkte für Seiten und Spitzen ===
n-Ecke haben auch benannte Ankerpunkte für ihre Seiten und Spitzen:
[[Datei:BOSL2-anchor-Spitzen-Seiten.png|mini|zentriert|alternativtext=Anker für Seiten und Spitzen|Spezielle Anker für die Spitzen und Seiten eines Pentagons (mit TikZ unter LaTeX erstellt)]]
Beachte, dass die Ankernamen in "" gesetzt werden müssen.
Zum Beispiel:
[[Datei:BOSL2-Pentagon anchor tip1.png|mini|zentriert|alternativtext=anchor="tip1"|pentagon(d=30, '''anchor="tip1" ''');]]
<pre class="openscad">include <BOSL2/std.scad>
pentagon(d=30, anchor="tip1");</pre>
<span id="sterne-stars"></span>
Beispiel mit attach():
[[Datei:BOSL2-anchor-Spitzen-Seiten attach.png|mini|zentriert|alternativtext=anchor="side2"|pentagon(d=30, anchor="side2") '''attach("tip0")''' circle(r=3,$fn=36);]]
<pre class="openscad">
include <BOSL2/std.scad>
pentagon(d=30, anchor="side2") attach("tip0") circle(r=3,$fn=36);
</pre>
== Sterne (Stars) ==
=== star() mit n, ir/id und or/od ===
Die BOSL2-Bibliothek hat Sterne als grundlegend unterstützte Form. Sie können eine beliebige Anzahl '''n''' von '''Spitzen''' haben. Du kannst die Form eines Sterns durch Spitzenanzahl, '''innere und äußere Scheitelpunkt-Radius/-Durchmesser''' angeben:
[[Datei:BOSL2-star n5 ir15 dr30-Veranschaulichung.png|mini|zentriert|alternativtext=Innerer und äußerer Radius bei star()|Veranschaulichung von den Parameter '''ir''' (oder id) und '''or''' (oder od). ''ir'' gibt den inneren Radius und or den äußeren Radius an. Die Anzahl der Zacken ist hier n=5. Siehe Code unten.]]
Begonnen wird der Stern mit einem Zacken nach rechts auf der X-Achse.
<pre class="openscad">
include <BOSL2/std.scad>
#circle(30, $fn=60);
color("blue") star(n=5, ir=15, or=30);
#circle(15, $fn=60);
color("darkblue") fwd(35) text("or=30", halign = "center", size=3);
color("yellow") text("ir=15",halign = "center", size=3, valign="center");
</pre>
=== star() mit Spannweite d ===
Statt '''od''' kann auch einfach '''d''' als Parameter verwendet werden.
[[Datei:BOSL2-star n3 id10 d50.png|mini|zentriert|alternativtext=star(n=3, id=10, d=50);|star(n=3, id=10, d=50);]]
<pre class="openscad">include <BOSL2/std.scad>
star(n=3, id=10, d=50);</pre>
[[Datei:BOSL2-star n5 id15 r25.png|mini|zentriert|alternativtext=star(n=5, id=15, r=25);|star(n=5, id=15, r=25);]]
<pre class="openscad">include <BOSL2/std.scad>
star(n=5, id=15, r=25);</pre>
[[Datei:BOSL2-star n10 id30 d50.png|mini|zentriert|alternativtext=star(n=10, id=30, d=50);|star(n=10, id=30, d=50);]]
<pre class="openscad">include <BOSL2/std.scad>
star(n=10, id=30, d=50);</pre>
=== star (n = <Spitzenanzahl>, step = <Anzahl zu überspringender Punkte>) ===
Oder du kannst die Sternform durch Spitzenanzahl '''n''' und Anzahl '''step''' der zu überspringenden Punkte angeben:
[[Datei:BOSL2-star n7 step2 d50.png|mini|zentriert|alternativtext=step|star(n=7, step=2, d=50);]]
<pre class="openscad">include <BOSL2/std.scad>
star(n=7, step=2, d=50);</pre>
[[Datei:BOSL2-star n7 step3 d50.png|mini|zentriert|alternativtext=step=3|star(n=7, step=3, d=50);]]
<pre class="openscad">include <BOSL2/std.scad>
star(n=7, step=3, d=50);</pre>
=== star() mit realign ===
Wenn dem <code>realign=</code>-Argument ein true-Wert übergeben wird, wird der Stern um einen halben Spitzenwinkel gedreht:
<pre class="openscad">include <BOSL2/std.scad>
left(30) star(n=5, step=2, d=50);
right(30) star(n=5, step=2, d=50, realign=true);</pre>
=== star() mit align_tip=<Anker> ===
Das <code>align_tip=</code>-Argument kann mit einem Vektor angegeben werden, damit du die erste Spitze in eine bestimmte Richtung ausrichten kannst:
[[Datei:BOSL2-star n5 align tip anchor tip0.png|mini|zentriert|alternativtext=align_tip=BACK|star(n=5, ir=15, or=30, align_tip=BACK) attach("tip0") color("blue") anchor_arrow2d();]]
<pre class="openscad">include <BOSL2/std.scad>
star(n=5, ir=15, or=30, align_tip=BACK)
attach("tip0") color("blue") anchor_arrow2d();</pre>
=== star() mit align_pit=<Anker> ===
Ebenso kann die erste Einkerbung oder Einbuchtung mit <code>align_pit=</code> in Richtung eines bestimmten Vektors ausgerichtet werden:
[[Datei:BOSL2-star n5 align pit BACK attach tip0.png|mini|zentriert|alternativtext=align_pit=BACK|star(n=5, ir=15, or=30, '''align_pit=BACK''') '''attach("tip0")''' color("blue") anchor_arrow2d();]]
<pre class="openscad">include <BOSL2/std.scad>
star(n=5, ir=15, or=30, align_pit=BACK)
attach("pit0") color("blue") anchor_arrow2d();</pre>
Du kannst <code>anchor=</code> und <code>spin=</code> verwenden, genau wie bei anderen anhängbaren Formen. Die Ankerpunkte basieren jedoch auf den äußersten Ausmaßen der Form und sind möglicherweise nicht dort, wo du sie erwartest:
[[Datei:BOSL2-star n5 anchor LEFT-show anchers.png|mini|zentriert|alternativtext=anchor=LEFT|star(n=5, step=2, d=50,'''anchor=LEFT''') '''show_anchors(custom=false)''';]]
<pre class="openscad">include <BOSL2/std.scad>
star(n=5, step=2, d=50)
show_anchors(custom=false);</pre>
=== Benannte Ankerpunkte bei star() ===
Sterne haben auch benannte Ankerpunkte für ihre Gruben, Spitzen und Mittelpunkte zwischen den Spitzen:
[[Datei:BOSL2-star n5 benannteAnker.png|mini|zentriert|alternativtext=benannten Ankerpunkte in star()|Zuordnung der benannten Ankerpunkte in star(). Spitzen beginnen mit "tipt0", Einkerbungen mit pit0.]]
==== Beispiel 1: anchor="tip0" attach("pit0") ====
[[Datei:BOSL2-star-n5 ir=15 or30 anchor tip0 pit0.png|mini|zentriert|alternativtext=anchor="tip0"|star(n=5, ir=15, or=30, anchor="tip0") attach("pit0") #circle(3);]]
<pre class="openscad">
include <BOSL2/std.scad>
star(n=5, ir=15, or=30, anchor="tip0") attach("pit0") #circle(3);
</pre>
==== Beispiel 2: anchor="pit0" attach("tip0") ====
[[Datei:BOSL2-star n5 anchor pit0 attach tip0.png|mini|zentriert|alternativtext=anchor="pit0" attach("tip0")|star(n=5, ir=15, or=30, anchor="pit0") attach("tip0") #circle(3);]]
<pre class="openscad">
include <BOSL2/std.scad>
star(n=5, ir=15, or=30, anchor="pit0") attach("tip0") #circle(3);
</pre>
<span id="tropfenform-2d-teardrop2d"></span>
== Tropfenform 2D (Teardrop2D) ==
Beim 3D-Druck möchtest du oft ein kreisförmiges Loch in eine vertikale Wand machen. Wenn das Loch jedoch zu groß ist, kann der Überhang an der Oberseite des Lochs Probleme beim Drucken auf einem FDM/FFF-Drucker verursachen. Wenn du kein Stützmaterial verwenden möchtest, kannst du einfach die Tropfenform verwenden. Das <code>teardrop2d()</code>-Modul ermöglicht es dir, eine 2D-Version der Tropfenform zu erstellen, damit du sie später extrudieren kannst:
[[Datei:BOSL2-teardrop2d r20.png|mini|zentriert|alternativtext=teardrop2d(r=20);|teardrop2d(r=20);]]
<pre class="openscad">include <BOSL2/std.scad>
teardrop2d(r=20);</pre>
=== Extrudiert als tropfenförmige Aussparung:
[[Datei:BOSL2-teardrop2d Loch linear extrudiert.png|mini|zentriert|alternativtext=Lineares Extrudieren eines Quadrats mit zentrierter Tropfenform|linear_extrude(5) { diff() { rect(50) attach(CTR,CTR, inside=true) teardrop2d(d=20); }}]]
<pre class="openscad">
include <BOSL2/std.scad>
linear_extrude(5) {
diff() {
rect(50)
attach(CTR,CTR, inside=true)
teardrop2d(d=20);
}}</pre>
=== ang=<Überhangwinkel> ===
Der Standard-Überhangwinkel beträgt 45 Grad, aber du kannst ihn mit dem <code>ang=</code>-Argument anpassen:
[[Datei:BOSL2-teardrop2d ang20.png|mini|zentriert|alternativtext=teardrop2d(d=50, ang=20);|teardrop2d(d=50, ang=20);]]
<pre class="openscad">include <BOSL2/std.scad>
teardrop2d(d=50, ang=20);</pre>
=== cap_h=<Kapphöhe> ===
Wenn du es vorziehst, die Oberseite des Tropfens abzuflachen, um das Bridging zu fördern, kannst du das <code>cap_h=</code>-Argument verwenden:
[[Datei:BOSL2-teardrop2d ang20 cap h38c.png|mini|zentriert|alternativtext=teardrop2d(d=50, ang=20, cap_h=38);|teardrop2d(d=50, ang=20, '''cap_h=38''');]]
<pre class="openscad">include <BOSL2/std.scad>
teardrop2d(d=50, ang=20, cap_h=38);</pre>
=== show_anchors() bei teardrop2d ===
Du kannst <code>anchor=</code> und <code>spin=</code> verwenden, genau wie bei anderen anhängbaren Formen. Die Ankerpunkte basieren jedoch auf den äußersten Ausmaßen der Form und sind möglicherweise nicht dort, wo du sie erwartest:
[[Datei:BOSL2-teardrop2d anchorBACK show anchors.png|mini|zentriert|alternativtext=teardrop2d(d=50, anchor=BACK) show_anchors();|teardrop2d(d=50, anchor=BACK) show_anchors();]]
<pre class="openscad">
include <BOSL2/std.scad>
teardrop2d(d=50, anchor=BACK)
show_anchors();
</pre>
<span id="verklebte-kreise-glued-circles"></span>
== Verklebte Kreise (Glued Circles) ==
Eine ungewöhnlichere Form, die BOSL2 bietet, sind verklebte Kreise (Glued Circles). Es handelt sich im Grunde um ein Paar von Kreisen, die durch etwas verbunden sind, das wie ein klebriger Meniskus aussieht:
[[Datei:BOSL2-glued circles d30 spread40.png|mini|zentriert|alternativtext=glued_circles(d=30, spread=40);|glued_circles(d=30, spread=40);]]
<pre class="openscad">include <BOSL2/std.scad>
glued_circles(d=30, spread=40);</pre>
=== d/r=<Kreisdurchmesser/Kreisradius>, spread=<Abstand Kreismittelpunkte> ===
Die <code>r=</code>/<code>d=</code>-Argumente können den Radius oder Durchmesser der beiden Kreise angeben:
<pre class="openscad">include <BOSL2/std.scad>
glued_circles(r=20, spread=45);</pre>
<pre class="openscad">include <BOSL2/std.scad>
glued_circles(d=40, spread=45);</pre>
Das <code>spread=</code>-Argument gibt den Abstand zwischen den Mittelpunkten der beiden Kreise an:
<pre class="openscad">include <BOSL2/std.scad>
glued_circles(d=30, spread=30);</pre>
=== tangent = <Tangentenwinkel-Miniskus> ===
Das <code>tangent=</code>-Argument gibt den Winkel der Tangente des Meniskus an den beiden Kreisen an:
[[Datei:BOSL2-glued circles d30 spread40 tangent=45.png|mini|zentriert|alternativtext=glued_circles(d=30, spread=30, tangent=45);|glued_circles(d=30, spread=30, tangent=45);]]
Auch negative Werte sind für den Tangentenwinkel möglich, so wird aus der Einbuchtung eine Ausbuchtung:
[[Datei:BOSL2-glued circles d30 spread40 tangent=-45.png|mini|zentriert|alternativtext= tangent=-40|glued_circles(d=30, spread=30, tangent=-40);]]
<pre class="openscad">include <BOSL2/std.scad>
glued_circles(d=30, spread=30, tangent=-45);</pre>
=== Langloch mit tangent=0 ===
Mit einem Tangentenwinkel von 0 erhält man eine Form, die sehr nützlich sein kann, um Langlöcher zu konstruieren.
[[Datei:BOSL2-glued circles Langlochform tangent0.png|mini|zentriert|alternativtext=Langlochform mit glued_circles|Langlochform mit glued_circles(d=30, spread=30, tangent=0);]]
<pre class="openscad">
include <BOSL2/std.scad>
glued_circles(d=30, spread=30, tangent=0);
</pre>
==== 3D-Langloch in Platte ====
[[Datei:BOSL2-glued circles Langlochform tangent0 3D.png|mini|zentriert|alternativtext=3D-Langloch glued_circlesh |Langloch (3D) durch lineares Extrudieren von glued_circles]]
Code-Variante A:
<pre class="openscad">
include <BOSL2/std.scad>
difference() {
cube([80, 80, 10], center = false);
right(40) back(40) down(2)
linear_extrude(height = 14) {
glued_circles(d = 30, spread = 30, tangent = 0);
}
}
</pre>
Code-Variante B:
<pre class="openscad">
include <BOSL2/std.scad>
linear_extrude(10)
diff("Langloch")
rect([80, 80], anchor=LEFT+FRONT)
tag("Langloch")
glued_circles(d = 25, spread = 30, tangent = 0);
</pre>
Code-Variante C:
<pre class="openscad">
include <BOSL2/std.scad>
linear_extrude(10)
diff()
rect([80, 80], anchor=LEFT+FRONT)
attach(CTR,CTR, inside=true)
glued_circles(d = 25, spread = 30, tangent = 0);
</pre>
Alle drei Varianten liefern das gleiche Ergebnis.
=== Gerippte Wand ===
Eine nützliche Sache, die du tun kannst, ist, einige <code>glued_circle()</code>s in einer Linie anzuordnen und sie dann zu extrudieren, um eine gerippte Wand zu erstellen:
[[Datei:BOSL2-glued circles gerippte Wand=-45.png|mini|zentriert|alternativtext=Gerippte Wand mit extrudierten glued_circles|$fn=64; s=10; linear_extrude(height=50,convexity=16,center=true) xcopies(s*sqrt(2),n=3) glued_circles(d=s, spread=s*sqrt(2), tangent=45);]]
<pre class="openscad">include <BOSL2/std.scad>
$fn=36; s=10;
linear_extrude(height=50,convexity=16,center=true)
xcopies(s*sqrt(2),n=3)
glued_circles(d=s, spread=s*sqrt(2), tangent=45);</pre>
Du kannst <code>anchor=</code> und <code>spin=</code> verwenden, genau wie bei anderen anhängbaren Formen. Die Ankerpunkte basieren jedoch auf den äußersten Ausmaßen der Form und sind möglicherweise nicht dort, wo du sie erwartest:
<pre class="openscad">include <BOSL2/std.scad>
glued_circles(d=40, spread=40, tangent=45)
show_anchors();</pre>
r7d0bmxphs6w64dvgtj9h89dejlo0ok
1093543
1093542
2026-11-08T18:54:20Z
Jowi-ammerbuch
115360
/* spin= bei right_triangle */
1093543
wikitext
text/x-wiki
{{MyNavi
|zurück = [[OpenSCAD Benutzerhandbuch/_BOSL2-Distributoren|Zurück]]
|buch = [[OpenSCAD Benutzerhandbuch/_BOSL2|BOSL2-Inhalt]]
|weiter = [[OpenSCAD Benutzerhandbuch/_BOSL2-3D|Weiter]]
}}
== 2D Grundformen (2D Primitive) ==
OpenSCAD bietet zwei eingebaute 2D-Grundformen: <code>square()</code> und <code>circle()</code>. Du kannst sie weiterhin auf die gewohnte Weise verwenden:
<pre class="openscad">include <BOSL2/std.scad>
square([60,40], center=true);</pre>
<pre class="openscad">include <BOSL2/std.scad>
circle(r=50);</pre>
<pre class="openscad">include <BOSL2/std.scad>
circle(d=100, $fn=8);</pre>
Diese Module wurden in der BOSL2-Bibliothek in drei Bereichen erweitert: Verankerung (Anchoring), Drehung (Spin) und Anhängbarkeit (Attachability).
<span id="verankerung-anchoring"></span>
=== Verankerung (Anchoring): ===
Wenn du ein <code>square()</code> erstellst, kannst du angeben, welche Ecke oder Seite am Ursprung verankert werden soll. Dies ersetzt das <code>center=</code>-Argument und ist flexibler. Das <code>anchor=</code>-Argument nimmt einen Vektor als Wert entgegen, der in grober Richtung der Seite oder Ecke zeigt, die du am Ursprung ausrichten möchtest.
=== anchor=[0,1] oder anchor=BACK ===
[[Datei:BOSL2-anchor-0-1.png|mini|zentriert|alternativtext=anchor=[0,1]);|square([60,40], '''anchor=[0,1]''');<br>
Oder: square([60,40], '''anchor=BACK''');]]
Um beispielsweise das '''Zentrum der hinteren Kante am Ursprung''' auszurichten, setzt du den Anker auf <code>[0,1]</code>:
<pre class="openscad">
include <BOSL2/std.scad>
square([60,40], anchor=[0,1]);
</pre>
Mit den leichter verständlichen vordefinierten '''Vektor-Konstanten''':
<pre class="openscad">
include <BOSL2/std.scad>
square([60,40], anchor=BACK+CENTER);
</pre>
=== anchor=[1,-1] oder anchor=RIGHT+FRONT ===
Um die '''vordere rechte Ecke am Ursprung''' auszurichten:
[[Datei:BOSL2-anchor-1 -1.png|mini|zentriert|alternativtext=anchor=RIGHT+FRONT);|square([60,40], '''anchor=[1,-1]''');<br>
Oder: square([60,40], '''anchor=RIGHT+FRONT''');]]
<pre class="openscad">
include <BOSL2/std.scad>
square([60,40], anchor=[1,-1]);
</pre>
'''Mit Vektor-Konstanten:'''
<pre class="openscad">
include <BOSL2/std.scad>
square([60,40], anchor=RIGHT+FRONT);
</pre>
=== anchor=[0,0] oder anchor=CENTER '''Fetter Text'''===
Um es zu '''zentrieren''':
<pre class="openscad">
include <BOSL2/std.scad>
square([60,40], anchor=[0,0]);
</pre>
'''Mit Vektor-Konstanten:'''
<pre class="openscad">
include <BOSL2/std.scad>
square([60,40], anchor=CENTER);
</pre>
=== Vektor-Konstanten am Rechteck ===
Um die Angabe von Vektoren übersichtlicher zu gestalten, sind mehrere Standard-Vektorkonstanten definiert:
[[Datei:BOSL2-anchor-Konstanten-Rechteck.png|gerahmt|zentriert|alternativtext=BOSL2 vordefinierte anchor-Konstanten|Die in BOSL2 vordefinierten anchor-Konstanten]]
{| class="wikitable"
|-
! Konstante
! Richtung
! Wert
|-
| LEFT
| X-
| [-1, 0, 0]
|-
| RIGHT
| X+
| [ 1, 0, 0]
|-
| FRONT / FORWARD / FWD
| Y-
| [ 0,-1, 0]
|-
| BACK
| Y+
| [ 0, 1, 0]
|-
| BOTTOM / BOT / BTM / DOWN
| Z-
| [ 0, 0,-1] (nur 3D)
|-
| TOP / UP
| Z+
| [ 0, 0, 1] (nur 3D)
|-
| CENTER / CTR
| Zentriert
| [ 0, 0, 0]
|}
Beachte, dass du die meisten dieser Konstanten (außer <code>UP</code>/<code>DOWN</code> natürlich) auch für Anker bei 2D-Formen verwenden kannst, obwohl es sich um 3D-Vektoren handelt:
<pre class="openscad">include <BOSL2/std.scad>
square([60,40], anchor=BACK);</pre>
<pre class="openscad">include <BOSL2/std.scad>
square([60,40], anchor=CENTER);</pre>
Du kannst Vektoren addieren, um auf Ecken zu zeigen:
<pre class="openscad">include <BOSL2/std.scad>
square([60,40], anchor=FRONT+RIGHT);</pre>
=== anchor = polar_to_xy ===
Für <code>circle()</code> kann der Ankervektor auf jeden beliebigen '''Punkt des Kreisumfangs''' zeigen:
[[Datei:BOSL2-anchor-polar to xy-circle.png|gerahmt|zentriert|alternativtext=anchor = polar_to_xy|anchor = polar_to_xy(1,Alpha), für Alpha = 0, 45, 90, ...]]
==== Beispiel: anchor=polar_to_xy(1,45) =====
[[Datei:BOSL2-anchor-polar to 1-45-octagon.png|mini|zentriert|alternativtext=circle(d=50, anchor=polar_to_xy(1,45), $fn = 8);|circle(d=50, anchor=polar_to_xy(1,45), $fn = 8);]]
<pre class="openscad">
include <BOSL2/std.scad>
circle(d=50, anchor=polar_to_xy(1,45), $fn = 8);
</pre>
Beachte, dass der Radius für den Anker keine Rolle spielt, da nur die Richtung des Ankers das Ergebnis beeinflusst.
=== show_anchors() ===
[[Datei:BOSL2-show anchor.png|mini|zentriert|show_anchors]]
Du kannst die typischen Ankerpunkte sehen, indem du <code>show_anchors()</code> als Kind der Form übergibst:
<pre class="openscad">include <BOSL2/std.scad>
square([60,40], center=true)
show_anchors();</pre>
<pre class="openscad">include <BOSL2/std.scad>
circle(d=50)
show_anchors();</pre>
<span id="drehung-spin"></span>
=== Drehung (Spin): ===
Die zweite Erweiterung von <code>square()</code> und <code>circle()</code> ist die Drehung (Spin). Wenn du die Form erstellst, kannst du sie mit dem <code>spin=</code>-Argument an Ort und Stelle drehen. Du übergibst einfach die Anzahl der Grad, um die sie im Uhrzeigersinn gedreht werden soll:
<pre class="openscad">include <BOSL2/std.scad>
square([60,40], anchor=CENTER, spin=30);</pre>
Die Verankerung oder Zentrierung erfolgt vor der Drehung:
<pre class="openscad">include <BOSL2/std.scad>
square([60,40], anchor=BACK, spin=30);</pre>
Bei Kreisen kann Spin nützlich sein, wenn auch <code>$fn=</code> angegeben wird:
<pre class="openscad">include <BOSL2/std.scad>
circle(d=50, $fn=6, spin=15);</pre>
Da die Verankerung vor der Drehung erfolgt, kannst du beides zusammen verwenden, um um den Anker herum zu drehen:
<pre class="openscad">include <BOSL2/std.scad>
circle(d=50, $fn=6, anchor=LEFT, spin=15);</pre>
<span id="anhängbarkeit-attachability"></span>
=== Anhängbarkeit (Attachability): ===
Die dritte Erweiterung von <code>square()</code> und <code>circle()</code> ist, dass du sie auf verschiedene Weise an Ankerpunkten zusammenhängen kannst. Dies geschieht, indem du eine Form zum Kind der Form machst, an die du sie anhängen möchtest.
==== Standard (ohne Spez. für anchor oder position) ====
Standardmäßig wird das Kind beim einfachen Untereinanderstellen im Zentrum der Elternform angehängt.
[[Datei:BOSL2-attach-standard-normal.png|mini|zentriert|alternativtext=square(50) #square(50);|square(50) #square(50);<br>
Kind-Objekt (rot) wird ans Zentrum des Elternobjekts angehängt]]
<pre class="openscad">
include <BOSL2/std.scad>
square(50) #square(50);
</pre>
==== anchor für child spezifiziert ====
[[Datei:BOSL2-attach-anchor-LEFTplusFWD.png|mini|zentriert|alternativtext=square(50, center=true) #square([20,40], anchor=LEFT+FWD);|square(50, center=true)#square([20,40], '''anchor=LEFT+FWD''');]]
<pre class="openscad">include <BOSL2/std.scad>
square(50, center=true)
#square([20,40], anchor=LEFT+FWD);</pre>
==== position() ====
[[Datei:BOSL2-attach-position.png|mini|zentriert|alternativtext=position(RIGHT)|square(50) '''position(RIGHT)''' #square(25) '''position(BACK)''' #square(25);]]
Durch Hinzufügen des <code>position()</code>-Moduls kannst du das Kind an jedem Ankerpunkt '''des Elternteils''' positionieren, das "Kindes-Kind wird am Ankerpunkt des übergeordneten Objekts positioniert:
<pre class="openscad">
include <BOSL2/std.scad>
square(50) position(RIGHT) #square(25)
position(BACK) #square(25);
</pre>
==== orient() ====
Ankerpunkte sind jedoch nicht nur Positionen auf dem Elternteil. Sie haben auch eine Ausrichtung. In den meisten Fällen zeigt die Ausrichtung eines Ankerpunkts nach außen, weg von der Fläche der Wand, also im Allgemeinen vom Zentrum der Form weg.
[[Datei:BOSL2-show anchor.png|mini|zentriert|show_anchors]]
Wenn du das Kind so ausrichten möchtest, dass es der Ausrichtung eines Ankerpunkts entspricht, kannst du das <code>orient()</code>-Modul verwenden. Es positioniert das Kind nicht, es dreht es nur:
[[Datei:BOSL2-attach-orient anchor.png|mini|zentriert|alternativtext= orient(anchor=LEFT+BOTTOM)|square(50) '''orient(anchor=LEFT+BOTTOM)''' #square([10,40]);]]
<pre class="openscad">include <BOSL2/std.scad>
square(50)
orient(anchor=LEFT+BOTTOM) #square([10,40]);</pre>
Das geht auch beim '''Kreis (circle)''' mit '''polar_to_xy''':
[[Datei:BOSL2-attach-orient polar to xy circle.png|mini|zentriert|alternativtext=orient(polar_to_xy(1,30))|circle(d=50) ''' orient(polar_to_xy(1,30))''' #square([10,40], anchor=FWD);]]
<pre class="openscad">include <BOSL2/std.scad>
circle(d=50)
orient(polar_to_xy(1,30))
#square([10,40], anchor=FWD);</pre>
==== position() + orient() ====
Du kannst <code>position()</code> und <code>orient()</code> zusammen verwenden, um sowohl zu positionieren als auch an einem Ankerpunkt auszurichten:
[[Datei:BOSL2-attach-position pluss orient polar to xy circle.png|mini|zentriert|alternativtext=position(polar_to_xy(1,30)) orient(polar_to_xy(1,30))|circle(d=50) '''position(polar_to_xy(1,30)) orient(polar_to_xy(1,30))''' #square([10,40], anchor=FWD);]]
<pre class="openscad">include <BOSL2/std.scad>
circle(d=50)
position(polar_to_xy(1,30))
orient(polar_to_xy(1,30))
#square([10,40], anchor=FWD);</pre>
=== attach () mit einem Argument ===
Aber es ist einfacher das <code>attach()</code>-Modul zu verwenden, um beides auf einmal zu erledigen:
[[Datei:BOSL2-attach-position pluss orient polar to xy circle.png|mini|zentriert|alternativtext=attach(polar_to_xy(1,30))|circle(d=50) '''attach(polar_to_xy(1,30))''' #square([10,40], anchor=FWD); ]]
Gleiches Ergebnis, aber übersichtlicherer Code.
<pre class="openscad">include <BOSL2/std.scad>
square(50, center=true)
attach(LEFT+BACK)
#square([10,40], anchor=FWD);</pre>
=== attach () mit zwei Argumenten ===
Anstatt den <code>anchor=</code> im Kind anzugeben, kannst du ein '''zweites Argument''' an <code>attach()</code> übergeben, das ihm sagt, welche Seite des Kindes mit dem Elternteil verbunden werden soll:
<pre class="openscad">
include <BOSL2/std.scad>
circle(d=50) attach(polar_to_xy(1,30), FWD) #square([10,40]);
</pre>
Damit lässt sich der Code noch mehr straffen.
[[Datei:BOSL2-attach-position pluss orient polar to xy circle.png|mini|zentriert|alternativtext=attach(polar_to_xy(1,30), FWD)|circle(d=50) '''attach(polar_to_xy(1,30), FWD)''' #square([10,40]); ]]
<span id="rechtecke-rectangles"></span>
== Rechtecke (Rectangles) ==
=== rect() ===
Die BOSL2-Bibliothek bietet eine Alternative zu <code>square()</code>, die mehr Funktionen unterstützt. Sie heißt <code>rect()</code>. Du kannst sie genauso verwenden wie <code>square()</code>, aber sie bietet auch erweiterte Funktionalität.
=== rect() mit rounding ===
[[Datei:BOSL2-rect rounding.png|mini|zentriert|alternativtext=rounding=10|rect([60,40], '''rounding=10''');]]
rect() erlaubt dir, die Ecken des Rechtecks abzurunden:
<pre class="openscad">include <BOSL2/std.scad>
rect([60,40], rounding=10);</pre>
=== rect() mit chamfer ===
[[Datei:BOSL2-rect chamfer.png|mini|zentriert|alternativtext=rect([60,40], chamfer=10);|rect([60,40], '''chamfer=10''');]]
Du kannst die Ecken des Rechtecks auch abfasen:
<pre class="openscad">include <BOSL2/std.scad>
rect([60,40], chamfer=10);</pre>
=== Unterschiedliche Abrundungen und Fasen an einem Rechteck ===
Du kannst sogar angeben, welche Ecken abgerundet oder abgefast werden. Wenn du eine Liste mit vier Größenwerten an die <code>rounding=</code>- oder <code>chamfer=</code>-Argumente übergibst, erhält jede Ecke ihre eigene Größe. Der Reihe nach geht es von der hinteren rechten Ecke (Quadrant I) gegen den Uhrzeigersinn zur hinteren linken Ecke (Quadrant II), zur vorderen linken Ecke (Quadrant III) und zur vorderen rechten Ecke (Quadrant IV):
Wenn eine Größe als <code>0</code> angegeben wird, gibt es keine Rundung und/oder Fase für die Ecke dieses Quadranten:
<pre class="openscad">include <BOSL2/std.scad>
rect([60,40], rounding=[0,5,10,15]);</pre>
<pre class="openscad">include <BOSL2/std.scad>
rect([60,40], chamfer=[0,5,10,15]);</pre>
Du kannst sowohl <code>rounding=</code>- als auch <code>chamfer=</code>-Argumente angeben, um Rundung und Fase zu mischen, aber nur, wenn du es pro Ecke angibst. Wenn du eine Rundung in einer Ecke möchtest, gib eine Fase von 0 für diese Ecke an und umgekehrt:
[[Datei:BOSL2-rect chamfer-rounding-mixed.png|mini|zentriert|alternativtext=ounding=[5,0,10,0], chamfer=[0,5,0,15]|rect([60,40], '''rounding=[5,0,10,0], chamfer=[0,5,0,15]''');]]
<pre class="openscad">include <BOSL2/std.scad>
rect([60,40], rounding=[5,0,10,0], chamfer=[0,5,0,15]);</pre>
<span id="ellipsen-ellipses"></span>
== Ellipsen (Ellipses) ==
Die BOSL2-Bibliothek bietet auch eine erweiterte Entsprechung von <code>circle()</code>, die <code>ellipse()</code> heißt. Du kannst sie genauso verwenden wie <code>circle()</code>, aber sie bietet auch erweiterte Funktionalität. Zum Beispiel erlaubt sie mehr Kontrolle über ihre Größe.
Da ein Kreis in OpenSCAD nur durch ein regelmäßiges Polygon mit einer Anzahl gerader Seiten angenähert werden kann, kann dies zu Ungenauigkeiten in Größe und Form führen. Um dem entgegenzuwirken, werden auch die Argumente <code>realign=</code> und <code>circum=</code> bereitgestellt.
=== realign= (ellipse-Argument) ===
Das <code>realign=</code>-Argument rotiert, wenn es auf <code>true</code> gesetzt wird, die <code>ellipse()</code> um den halben Winkel zwischen den Polygonseiten:
[[Datei:BOSL2-ellipse-realign.png|mini|zentriert|alternativtext=realign=true|#ellipse(d=100, $fn=8); color("lime") ellipse(d=100, $fn=8, '''realign=true''');]]
<pre class="openscad">
include <BOSL2/std.scad>
#ellipse(d=100, $fn=8);
color("lime") ellipse(d=100, $fn=8, realign=true);
</pre>
=== circum= (ellipse-Argument) ===
[[Datei:BOSL2-ellipse-circum.png|mini|zentriert|alternativtext=circum=true|Vergleich: rot (außen) mit circum=true und blau (innen) ohne circum. Referenz: idealer Kreis in gelb.]]
<pre class="openscad">
include <BOSL2/std.scad>
color("red") ellipse(d=100, $fn=6, circum=true);
color("yellow") ellipse(d=100, $fn=360);
color("blue") ellipse(d=100, $fn=6);
</pre>
Das <code>circum=</code>-Argument bewirkt, wenn es auf true gesetzt wird, dass das Polygon, das die <code>ellipse()</code> bildet, den idealen Kreis '''umschreibt''', anstatt ihn einzuschreiben.
Den idealen Kreis ''einschreiben'':
<pre class="openscad">include <BOSL2/std.scad>
color("green") ellipse(d=100, $fn=360);
ellipse(d=100, $fn=6);</pre>
Den idealen Kreis ''umschreiben'':
<pre class="openscad">include <BOSL2/std.scad>
ellipse(d=100, $fn=6, circum=true);
color("green") ellipse(d=100, $fn=360);</pre>
=== Ellipse mit 2 Radien ===
Das <code>ellipse()</code>-Modul kann, wie der Name schon sagt, mit separaten X- und Y-Radien oder -Durchmessern angegeben werden. Dazu gibst du einfach <code>r=</code> oder <code>d=</code> mit einer Liste von zwei Radien oder Durchmessern an:
[[Datei:BOSL2-ellipse-2Radien.png|mini|zentriert|alternativtext=2 Radien|ellipse('''r=[30,20]''');]]
==== r=[r1,r2] ====
<pre class="openscad">include <BOSL2/std.scad>
ellipse(r=[30,20]);</pre>
==== d=[d1,d2]====
<pre class="openscad">include <BOSL2/std.scad>
ellipse(d=[60,40]);</pre>
==== ellipse mit anchor ====
Wie bei <code>circle()</code> kannst du <code>ellipse()</code>-Formen verankern, drehen und anhängen:
[[Datei:BOSL2-ellipse-anchor.png|mini|zentriert|alternativtext=ellipse mit anchor|ellipse(d=[50,20], '''anchor=BACK'''); #ellipse(d=[50,20], '''anchor=FRONT''');]]
<pre class="openscad">
include <BOSL2/std.scad>
ellipse(d=[50,20], anchor=BACK);
#ellipse(d=[50,20], anchor=FRONT);
</pre>
==== ellipse mit attach ====
[[Datei:BOSL2-ellipse-attach.png|mini|zentriert|alternativtext=ellipse mit attach|ellipse(d=50) '''attach(BACK+RIGHT, FRONT+LEFT)''' #ellipse(d=[40,20]);]]
<pre class="openscad">
include <BOSL2/std.scad>
ellipse(d=50)
attach(BACK+RIGHT, FRONT+LEFT)
ellipse(d=30);
</pre>
<span id="rechtwinklige-dreiecke-right-triangles"></span>
==== ellipse mit spin ====
[[Datei:BOSL2-ellipse-attach-spin-anchor.png|mini|zentriert|alternativtext=spin = 90 bei ellipse|ellipse(d=50) attach(BACK) #ellipse(d=[40,20], '''spin=90''', anchor=LEFT);]]
<pre class="openscad">
include <BOSL2/std.scad>
ellipse(d=50)
attach(BACK)
#ellipse(d=[40,20], spin=90, anchor=LEFT);
</pre>
== Rechtwinklige Dreiecke (Right Triangles) ==
Die BOSL2-Bibliothek bietet eine einfache Möglichkeit, ein 2D-rechtwinkliges Dreieck mit dem <code>right_triangle()</code>-Modul zu erstellen:
[[Datei:BOSL2-right triangle.png|mini|zentriert|alternativtext=right_triangle([40,30])|right_triangle([40,30]);]]
<pre class="openscad">include <BOSL2/std.scad>
right_triangle([40,30]);</pre>
=== xflip() bei right_triangle ===
Du kannst <code>xflip()</code> und <code>yflip()</code> verwenden, um zu ändern, in welchem Quadranten das Dreieck gebildet wird:
[[Datei:BOSL2-right triangle xflip.png|mini|zentriert|alternativtext=right_triange mit xflip()|right_triangle([40,30]); '''xflip()''' #right_triangle([40,30]);]]
<pre class="openscad">include <BOSL2/std.scad>
xflip() right_triangle([40,30]);</pre>
=== yflip() bei right_triangle ===
[[Datei:BOSL2-right triangle yflip.png|mini|zentriert|alternativtext=right_triangle([40,30]) mit yflip()|right_triangle([40,30]); '''yflip()''' #right_triangle([40,30]);]]
<pre class="openscad">include <BOSL2/std.scad>
yflip() right_triangle([40,30]);</pre>
=== xflip() & yflip() bei right_triangle ===
[[Datei:BOSL2-right triangle xflip yflip.png|mini|zentriert|alternativtext=xflip() yflip()|right_triangle([40,30]); xflip() yflip() #right_triangle([40,30]);]]
<pre class="openscad">include <BOSL2/std.scad>
xflip() yflip() right_triangle([40,30]);</pre>
=== spin= bei right_triangle ===
Oder alternativ einfach mit <code>spin=</code> in den richtigen Quadranten drehen:
[[Datei:BOSL2-right triangle spin.png|mini|zentriert|alternativtext=right_triangle([40,30]) mit spin=90)|right_triangle([40,30]);
#right_triangle([40,30], '''spin=90''');]]
<pre class="openscad">include <BOSL2/std.scad>
right_triangle([40,30], spin=90);</pre>
<pre class="openscad">include <BOSL2/std.scad>
right_triangle([40,30], spin=-90);</pre>
Du kannst bei rechtwinkligen Dreiecken auch Verankerung verwenden:
[[Datei:BOSL2-right triangle anchors.png|mini|zentriert|alternativtext=anchor=CTR|right_triangle([40,30], anchor=FWD+RIGHT) show_anchors();]]
<pre class="openscad">include <BOSL2/std.scad>
right_triangle([40,30], anchor=FWD+RIGHT) show_anchors();</pre>
<span id="trapeze-trapezoids"></span>
== Trapeze (Trapezoids) ==
OpenSCAD bietet keine einfache Möglichkeit, allgemeine 2D-Dreiecke, Trapeze oder Parallelogramme zu erstellen. Die BOSL2-Bibliothek kann all diese Formen mit dem <code>trapezoid()</code>-Modul bereitstellen.
=== Dreieck ===
==== Gleichseitiges Dreieck ====
Um ein gleichseitiges Dreieck zu erstellen, setze einfach eine der Breiten auf null:
[[Datei:BOSL2-trapezoid dreieck.png|mini|zentriert|alternativtext=Dreieck|trapezoid(w1=50, w2=0, h=40);<br>
Dreieck mit Seitenlänge = 50]]
<pre class="openscad">include <BOSL2/std.scad>
trapezoid(w1=50, w2=0, h=40);</pre>
==== Rechtwinkliges Dreieck ====
Um ein rechtwinkliges Dreieck zu erstellen, musst du das <code>shift=</code>-Argument verwenden, um die Rückseite des Trapezes entlang der X-Achse zu verschieben:
[[Datei:BOSL2-trapezoid dreieck-rechtwinklig.png|mini|zentriert|alternativtext=Rechtwinkliges Dreieck|trapezoid(w1=50, w2=0, h=50, shift=-25);]]
<pre class="openscad">include <BOSL2/std.scad>
trapezoid(w1=50, w2=0, h=50, shift=-25);</pre>
[[Datei:BOSL2-trapezoid dreieck-rechtwinklig shift25.png|mini|zentriert|alternativtext=trapezoid(w1=50, w2=0, h=50, shift=25);|trapezoid(w1=50, w2=0, h=50, shift=25);]]
<pre class="openscad">include <BOSL2/std.scad>
trapezoid(w1=50, w2=0, h=50, shift=25);</pre>
[[Datei:BOSL2-trapezoid dreieck-rechtwinklig shift-25.png|mini|zentriert|alternativtext=trapezoid(w1=0, w2=50, h=50, shift=-25);|trapezoid(w1=0, w2=50, h=50, shift=-25);]]
<pre class="openscad">include <BOSL2/std.scad>
trapezoid(w1=0, w2=50, h=50, shift=-25);</pre>
[[Datei:BOSL2-trapezoid dreieck-rechtwinklig shift25 w1=0.png|mini|zentriert|alternativtext=trapezoid(w1=0, w2=50, h=50, shift=25);|trapezoid(w1=0, w2=50, h=50, shift=25);]]
<pre class="openscad">include <BOSL2/std.scad>
trapezoid(w1=0, w2=50, h=50, shift=25);</pre>
=== Trapez ===
Du kannst ein Trapez erstellen, indem du für vorne (<code>w1=</code>) und hinten (<code>w2=</code>) von null verschiedene Breiten angibst:
[[Datei:BOSL2-trapezoid trapez.png|mini|zentriert|alternativtext=Trapez|trapezoid(w1=30, w2=50, h=50);]]
<pre class="openscad">include <BOSL2/std.scad>
trapezoid(w1=30, w2=50, h=50);</pre>
=== Parallelogramm ===
Ein Parallelogramm ist nur eine Frage der Verwendung der gleichen Breite für vorne und hinten, mit einer Verschiebung entlang der X-Achse:
[[Datei:BOSL2-trapezoid parallelogram.png|mini|zentriert|alternativtext=Parallelogramm|trapezoid(w1=50, w2=50, shift=20, h=50);]]
<pre class="openscad">include <BOSL2/std.scad>
trapezoid(w1=50, w2=50, shift=20, h=50);</pre>
=== Viereck ===
Ein Viereck kann erstellt werden, indem ungleiche, von null verschiedene Breiten für vorne (<code>w1=</code>) und hinten (<code>w2=</code>) verwendet werden, wobei die Rückseite entlang der X-Achse verschoben wird:
[[Datei:BOSL2-trapezoid viereck.png|mini|zentriert|alternativtext=Viereck|trapezoid(w1=50, w2=30, shift=20, h=50);]]
<pre class="openscad">include <BOSL2/std.scad>
trapezoid(w1=50, w2=30, shift=20, h=50);</pre>
Du kannst <code>anchor=</code> und <code>spin=</code> verwenden, genau wie bei anderen anhängbaren Formen. Die Ausrichtungen der Ankerpunkte basieren jedoch auf den Seitenwinkeln der Flächen und sind möglicherweise nicht das, was du erwartest:
<pre class="openscad">include <BOSL2/std.scad>
trapezoid(w1=30, w2=50, h=50)
show_anchors();</pre>
<span id="regelmäßige-n-ecke-regular-n-gons"></span>
== Regelmäßige n-Ecke (Regular N-Gons) ==
OpenSCAD ermöglicht es dir, regelmäßige n-Ecke (Fünfeck, Sechseck usw.) zu erstellen, indem du <code>circle()</code> mit <code>$fn</code> verwendest. Obwohl dies prägnant ist, mag es auf den ersten Blick weniger offensichtlich sein:
<pre class="openscad">include <BOSL2/std.scad>
circle(d=50, $fn=5);</pre>
Die BOSL2-Bibliothek hat Module, die für gängige n-Ecke klarer benannt sind:
=== Pentagon (d=<Durchmesser>) ===
[[Datei:BOSL2-Pentagon.png|mini|zentriert|alternativtext=Pentagon|pentagon(d=50);]]
<pre class="openscad">include <BOSL2/std.scad>
pentagon(d=50);</pre>
=== Hexagon (d=<Durchmesser>) ===
[[Datei:BOSL2-Hexagon.png|mini|zentriert|alternativtext=Hexagon| hexagon(d=50);]]
<pre class="openscad">include <BOSL2/std.scad>
hexagon(d=50);</pre>
=== Octagon (d= <Durchmesser>) ===
[[Datei:BOSL2-Octagon.png|mini|zentriert|alternativtext=octagon(d=50);|octagon(d=50);]]
<pre class="openscad">include <BOSL2/std.scad>
octagon(d=50);</pre>
=== regular_ngon (n=<Seitenanzahl>, d=<Durchmesser>) ===
[[Datei:BOSL2-regular ngon.png|mini|zentriert|alternativtext=regular_ngon|regular_ngon(n=7, d=50);]]
<pre class="openscad">include <BOSL2/std.scad>
regular_ngon(n=7, d=50);</pre>
=== side=<Seitenlänge> ===
Diese Module bieten dir auch zusätzliche Funktionalität. Sie können nach Seitenlänge dimensioniert werden:
[[Datei:BOSL2-Hexagon side50.png|mini|zentriert|alternativtext=hexagon(side=50);|hexagon(side=50);]]
<pre class="openscad">include <BOSL2/std.scad>
pentagon(side=50);</pre>
=== ir = <Innenradius> / id = <Innendurchmesser> ===
Sie können nach dem Radius/Durchmesser des umschriebenen Kreises (Innenkreis) dimensioniert werden:
[[Datei:BOSL2-Pentagon Innenradius.png|mini|zentriert|alternativtext=Innenradius|color("red") pentagon('''ir=25'''); color("yellow") circle(r=25,$fn=100);]]
<pre class="openscad">include <BOSL2/std.scad>
pentagon(ir=25);
pentagon(id=50);</pre>
=== realign=true/false ===
Die Polygone können um eine halbe Seite gedreht werden:
[[Datei:BOSL2-Pentagon realign.png|mini|zentriert|alternativtext=realign|pentagon(d=50, '''realign=false'''); #pentagon(d=50, '''realign=true''');]]
<pre class="openscad">include <BOSL2/std.scad>
left(30) pentagon(d=50, realign=true);
right(30) pentagon(d=50, realign=false);</pre>
=== rounding = <Rundung> ===
Die BOSL2-Polygone können abgerundet werden:
[[Datei:BOSL2-Polygon-rounding.png|mini|zentriert|alternativtext=rounding|pentagon(d=50, '''rounding=5''');]]
<pre class="openscad">include <BOSL2/std.scad>
pentagon(d=50, rounding=5);</pre>
=== show_anchors() ===
Die BOSL2-Polygone haben auch ein etwas anderes Anhangsverhalten als die regulären Polygone, die über $fn=<Seitenanzahl> erzeugt werden.
Ein Kreis mit einem kleinen <code>$fn=</code> hängt Dinge am idealen Kreis an, nicht entlang des erstellten Polygons:
[[Datei:BOSL2-polygon-outcircle-anchors.png|mini|zentriert|alternativtext=anchors Außenkreis|color("green") stroke(circle(d=50), closed=true); circle(d=50,$fn=6) show_anchors();]]
<pre class="openscad">include <BOSL2/std.scad>
color("green") stroke(circle(d=50), closed=true);
circle(d=50,$fn=6)
show_anchors();</pre>
Während ein BOSL2-n-Eck entlang des Polygons selbst (direkt) anhängt:
[[Datei:BOSL2-polygon-direct-anchors.png|mini|zentriert|alternativtext=anchors BOSL2 Polygone direkt|color("green") stroke(circle(d=50), closed=true); circle(d=50,$fn=6) show_anchors();]]
<pre class="openscad">include <BOSL2/std.scad>
hexagon(d=50)
show_anchors(custom=false);</pre>
Du kannst <code>anchor=</code> und <code>spin=</code> verwenden, genau wie bei anderen anhängbaren Formen. Die Ankerpunkte basieren jedoch darauf, wo der Ankervektor die Seite des n-Ecks schneiden würde, und sind möglicherweise nicht dort, wo du sie erwartest:
[[Datei:BOSL2-Pentagon-anchor.png|mini|zentriert|alternativtext=n-Polygon anchor|pentagon(d=50, '''anchor=FRONT+LEFT''') show_anchors(custom=false);]]
<pre class="openscad">include <BOSL2/std.scad>
pentagon(d=50, anchor=FRONT+LEFT)
show_anchors(custom=false);</pre>
=== Ankerpunkte für Seiten und Spitzen ===
n-Ecke haben auch benannte Ankerpunkte für ihre Seiten und Spitzen:
[[Datei:BOSL2-anchor-Spitzen-Seiten.png|mini|zentriert|alternativtext=Anker für Seiten und Spitzen|Spezielle Anker für die Spitzen und Seiten eines Pentagons (mit TikZ unter LaTeX erstellt)]]
Beachte, dass die Ankernamen in "" gesetzt werden müssen.
Zum Beispiel:
[[Datei:BOSL2-Pentagon anchor tip1.png|mini|zentriert|alternativtext=anchor="tip1"|pentagon(d=30, '''anchor="tip1" ''');]]
<pre class="openscad">include <BOSL2/std.scad>
pentagon(d=30, anchor="tip1");</pre>
<span id="sterne-stars"></span>
Beispiel mit attach():
[[Datei:BOSL2-anchor-Spitzen-Seiten attach.png|mini|zentriert|alternativtext=anchor="side2"|pentagon(d=30, anchor="side2") '''attach("tip0")''' circle(r=3,$fn=36);]]
<pre class="openscad">
include <BOSL2/std.scad>
pentagon(d=30, anchor="side2") attach("tip0") circle(r=3,$fn=36);
</pre>
== Sterne (Stars) ==
=== star() mit n, ir/id und or/od ===
Die BOSL2-Bibliothek hat Sterne als grundlegend unterstützte Form. Sie können eine beliebige Anzahl '''n''' von '''Spitzen''' haben. Du kannst die Form eines Sterns durch Spitzenanzahl, '''innere und äußere Scheitelpunkt-Radius/-Durchmesser''' angeben:
[[Datei:BOSL2-star n5 ir15 dr30-Veranschaulichung.png|mini|zentriert|alternativtext=Innerer und äußerer Radius bei star()|Veranschaulichung von den Parameter '''ir''' (oder id) und '''or''' (oder od). ''ir'' gibt den inneren Radius und or den äußeren Radius an. Die Anzahl der Zacken ist hier n=5. Siehe Code unten.]]
Begonnen wird der Stern mit einem Zacken nach rechts auf der X-Achse.
<pre class="openscad">
include <BOSL2/std.scad>
#circle(30, $fn=60);
color("blue") star(n=5, ir=15, or=30);
#circle(15, $fn=60);
color("darkblue") fwd(35) text("or=30", halign = "center", size=3);
color("yellow") text("ir=15",halign = "center", size=3, valign="center");
</pre>
=== star() mit Spannweite d ===
Statt '''od''' kann auch einfach '''d''' als Parameter verwendet werden.
[[Datei:BOSL2-star n3 id10 d50.png|mini|zentriert|alternativtext=star(n=3, id=10, d=50);|star(n=3, id=10, d=50);]]
<pre class="openscad">include <BOSL2/std.scad>
star(n=3, id=10, d=50);</pre>
[[Datei:BOSL2-star n5 id15 r25.png|mini|zentriert|alternativtext=star(n=5, id=15, r=25);|star(n=5, id=15, r=25);]]
<pre class="openscad">include <BOSL2/std.scad>
star(n=5, id=15, r=25);</pre>
[[Datei:BOSL2-star n10 id30 d50.png|mini|zentriert|alternativtext=star(n=10, id=30, d=50);|star(n=10, id=30, d=50);]]
<pre class="openscad">include <BOSL2/std.scad>
star(n=10, id=30, d=50);</pre>
=== star (n = <Spitzenanzahl>, step = <Anzahl zu überspringender Punkte>) ===
Oder du kannst die Sternform durch Spitzenanzahl '''n''' und Anzahl '''step''' der zu überspringenden Punkte angeben:
[[Datei:BOSL2-star n7 step2 d50.png|mini|zentriert|alternativtext=step|star(n=7, step=2, d=50);]]
<pre class="openscad">include <BOSL2/std.scad>
star(n=7, step=2, d=50);</pre>
[[Datei:BOSL2-star n7 step3 d50.png|mini|zentriert|alternativtext=step=3|star(n=7, step=3, d=50);]]
<pre class="openscad">include <BOSL2/std.scad>
star(n=7, step=3, d=50);</pre>
=== star() mit realign ===
Wenn dem <code>realign=</code>-Argument ein true-Wert übergeben wird, wird der Stern um einen halben Spitzenwinkel gedreht:
<pre class="openscad">include <BOSL2/std.scad>
left(30) star(n=5, step=2, d=50);
right(30) star(n=5, step=2, d=50, realign=true);</pre>
=== star() mit align_tip=<Anker> ===
Das <code>align_tip=</code>-Argument kann mit einem Vektor angegeben werden, damit du die erste Spitze in eine bestimmte Richtung ausrichten kannst:
[[Datei:BOSL2-star n5 align tip anchor tip0.png|mini|zentriert|alternativtext=align_tip=BACK|star(n=5, ir=15, or=30, align_tip=BACK) attach("tip0") color("blue") anchor_arrow2d();]]
<pre class="openscad">include <BOSL2/std.scad>
star(n=5, ir=15, or=30, align_tip=BACK)
attach("tip0") color("blue") anchor_arrow2d();</pre>
=== star() mit align_pit=<Anker> ===
Ebenso kann die erste Einkerbung oder Einbuchtung mit <code>align_pit=</code> in Richtung eines bestimmten Vektors ausgerichtet werden:
[[Datei:BOSL2-star n5 align pit BACK attach tip0.png|mini|zentriert|alternativtext=align_pit=BACK|star(n=5, ir=15, or=30, '''align_pit=BACK''') '''attach("tip0")''' color("blue") anchor_arrow2d();]]
<pre class="openscad">include <BOSL2/std.scad>
star(n=5, ir=15, or=30, align_pit=BACK)
attach("pit0") color("blue") anchor_arrow2d();</pre>
Du kannst <code>anchor=</code> und <code>spin=</code> verwenden, genau wie bei anderen anhängbaren Formen. Die Ankerpunkte basieren jedoch auf den äußersten Ausmaßen der Form und sind möglicherweise nicht dort, wo du sie erwartest:
[[Datei:BOSL2-star n5 anchor LEFT-show anchers.png|mini|zentriert|alternativtext=anchor=LEFT|star(n=5, step=2, d=50,'''anchor=LEFT''') '''show_anchors(custom=false)''';]]
<pre class="openscad">include <BOSL2/std.scad>
star(n=5, step=2, d=50)
show_anchors(custom=false);</pre>
=== Benannte Ankerpunkte bei star() ===
Sterne haben auch benannte Ankerpunkte für ihre Gruben, Spitzen und Mittelpunkte zwischen den Spitzen:
[[Datei:BOSL2-star n5 benannteAnker.png|mini|zentriert|alternativtext=benannten Ankerpunkte in star()|Zuordnung der benannten Ankerpunkte in star(). Spitzen beginnen mit "tipt0", Einkerbungen mit pit0.]]
==== Beispiel 1: anchor="tip0" attach("pit0") ====
[[Datei:BOSL2-star-n5 ir=15 or30 anchor tip0 pit0.png|mini|zentriert|alternativtext=anchor="tip0"|star(n=5, ir=15, or=30, anchor="tip0") attach("pit0") #circle(3);]]
<pre class="openscad">
include <BOSL2/std.scad>
star(n=5, ir=15, or=30, anchor="tip0") attach("pit0") #circle(3);
</pre>
==== Beispiel 2: anchor="pit0" attach("tip0") ====
[[Datei:BOSL2-star n5 anchor pit0 attach tip0.png|mini|zentriert|alternativtext=anchor="pit0" attach("tip0")|star(n=5, ir=15, or=30, anchor="pit0") attach("tip0") #circle(3);]]
<pre class="openscad">
include <BOSL2/std.scad>
star(n=5, ir=15, or=30, anchor="pit0") attach("tip0") #circle(3);
</pre>
<span id="tropfenform-2d-teardrop2d"></span>
== Tropfenform 2D (Teardrop2D) ==
Beim 3D-Druck möchtest du oft ein kreisförmiges Loch in eine vertikale Wand machen. Wenn das Loch jedoch zu groß ist, kann der Überhang an der Oberseite des Lochs Probleme beim Drucken auf einem FDM/FFF-Drucker verursachen. Wenn du kein Stützmaterial verwenden möchtest, kannst du einfach die Tropfenform verwenden. Das <code>teardrop2d()</code>-Modul ermöglicht es dir, eine 2D-Version der Tropfenform zu erstellen, damit du sie später extrudieren kannst:
[[Datei:BOSL2-teardrop2d r20.png|mini|zentriert|alternativtext=teardrop2d(r=20);|teardrop2d(r=20);]]
<pre class="openscad">include <BOSL2/std.scad>
teardrop2d(r=20);</pre>
=== Extrudiert als tropfenförmige Aussparung:
[[Datei:BOSL2-teardrop2d Loch linear extrudiert.png|mini|zentriert|alternativtext=Lineares Extrudieren eines Quadrats mit zentrierter Tropfenform|linear_extrude(5) { diff() { rect(50) attach(CTR,CTR, inside=true) teardrop2d(d=20); }}]]
<pre class="openscad">
include <BOSL2/std.scad>
linear_extrude(5) {
diff() {
rect(50)
attach(CTR,CTR, inside=true)
teardrop2d(d=20);
}}</pre>
=== ang=<Überhangwinkel> ===
Der Standard-Überhangwinkel beträgt 45 Grad, aber du kannst ihn mit dem <code>ang=</code>-Argument anpassen:
[[Datei:BOSL2-teardrop2d ang20.png|mini|zentriert|alternativtext=teardrop2d(d=50, ang=20);|teardrop2d(d=50, ang=20);]]
<pre class="openscad">include <BOSL2/std.scad>
teardrop2d(d=50, ang=20);</pre>
=== cap_h=<Kapphöhe> ===
Wenn du es vorziehst, die Oberseite des Tropfens abzuflachen, um das Bridging zu fördern, kannst du das <code>cap_h=</code>-Argument verwenden:
[[Datei:BOSL2-teardrop2d ang20 cap h38c.png|mini|zentriert|alternativtext=teardrop2d(d=50, ang=20, cap_h=38);|teardrop2d(d=50, ang=20, '''cap_h=38''');]]
<pre class="openscad">include <BOSL2/std.scad>
teardrop2d(d=50, ang=20, cap_h=38);</pre>
=== show_anchors() bei teardrop2d ===
Du kannst <code>anchor=</code> und <code>spin=</code> verwenden, genau wie bei anderen anhängbaren Formen. Die Ankerpunkte basieren jedoch auf den äußersten Ausmaßen der Form und sind möglicherweise nicht dort, wo du sie erwartest:
[[Datei:BOSL2-teardrop2d anchorBACK show anchors.png|mini|zentriert|alternativtext=teardrop2d(d=50, anchor=BACK) show_anchors();|teardrop2d(d=50, anchor=BACK) show_anchors();]]
<pre class="openscad">
include <BOSL2/std.scad>
teardrop2d(d=50, anchor=BACK)
show_anchors();
</pre>
<span id="verklebte-kreise-glued-circles"></span>
== Verklebte Kreise (Glued Circles) ==
Eine ungewöhnlichere Form, die BOSL2 bietet, sind verklebte Kreise (Glued Circles). Es handelt sich im Grunde um ein Paar von Kreisen, die durch etwas verbunden sind, das wie ein klebriger Meniskus aussieht:
[[Datei:BOSL2-glued circles d30 spread40.png|mini|zentriert|alternativtext=glued_circles(d=30, spread=40);|glued_circles(d=30, spread=40);]]
<pre class="openscad">include <BOSL2/std.scad>
glued_circles(d=30, spread=40);</pre>
=== d/r=<Kreisdurchmesser/Kreisradius>, spread=<Abstand Kreismittelpunkte> ===
Die <code>r=</code>/<code>d=</code>-Argumente können den Radius oder Durchmesser der beiden Kreise angeben:
<pre class="openscad">include <BOSL2/std.scad>
glued_circles(r=20, spread=45);</pre>
<pre class="openscad">include <BOSL2/std.scad>
glued_circles(d=40, spread=45);</pre>
Das <code>spread=</code>-Argument gibt den Abstand zwischen den Mittelpunkten der beiden Kreise an:
<pre class="openscad">include <BOSL2/std.scad>
glued_circles(d=30, spread=30);</pre>
=== tangent = <Tangentenwinkel-Miniskus> ===
Das <code>tangent=</code>-Argument gibt den Winkel der Tangente des Meniskus an den beiden Kreisen an:
[[Datei:BOSL2-glued circles d30 spread40 tangent=45.png|mini|zentriert|alternativtext=glued_circles(d=30, spread=30, tangent=45);|glued_circles(d=30, spread=30, tangent=45);]]
Auch negative Werte sind für den Tangentenwinkel möglich, so wird aus der Einbuchtung eine Ausbuchtung:
[[Datei:BOSL2-glued circles d30 spread40 tangent=-45.png|mini|zentriert|alternativtext= tangent=-40|glued_circles(d=30, spread=30, tangent=-40);]]
<pre class="openscad">include <BOSL2/std.scad>
glued_circles(d=30, spread=30, tangent=-45);</pre>
=== Langloch mit tangent=0 ===
Mit einem Tangentenwinkel von 0 erhält man eine Form, die sehr nützlich sein kann, um Langlöcher zu konstruieren.
[[Datei:BOSL2-glued circles Langlochform tangent0.png|mini|zentriert|alternativtext=Langlochform mit glued_circles|Langlochform mit glued_circles(d=30, spread=30, tangent=0);]]
<pre class="openscad">
include <BOSL2/std.scad>
glued_circles(d=30, spread=30, tangent=0);
</pre>
==== 3D-Langloch in Platte ====
[[Datei:BOSL2-glued circles Langlochform tangent0 3D.png|mini|zentriert|alternativtext=3D-Langloch glued_circlesh |Langloch (3D) durch lineares Extrudieren von glued_circles]]
Code-Variante A:
<pre class="openscad">
include <BOSL2/std.scad>
difference() {
cube([80, 80, 10], center = false);
right(40) back(40) down(2)
linear_extrude(height = 14) {
glued_circles(d = 30, spread = 30, tangent = 0);
}
}
</pre>
Code-Variante B:
<pre class="openscad">
include <BOSL2/std.scad>
linear_extrude(10)
diff("Langloch")
rect([80, 80], anchor=LEFT+FRONT)
tag("Langloch")
glued_circles(d = 25, spread = 30, tangent = 0);
</pre>
Code-Variante C:
<pre class="openscad">
include <BOSL2/std.scad>
linear_extrude(10)
diff()
rect([80, 80], anchor=LEFT+FRONT)
attach(CTR,CTR, inside=true)
glued_circles(d = 25, spread = 30, tangent = 0);
</pre>
Alle drei Varianten liefern das gleiche Ergebnis.
=== Gerippte Wand ===
Eine nützliche Sache, die du tun kannst, ist, einige <code>glued_circle()</code>s in einer Linie anzuordnen und sie dann zu extrudieren, um eine gerippte Wand zu erstellen:
[[Datei:BOSL2-glued circles gerippte Wand=-45.png|mini|zentriert|alternativtext=Gerippte Wand mit extrudierten glued_circles|$fn=64; s=10; linear_extrude(height=50,convexity=16,center=true) xcopies(s*sqrt(2),n=3) glued_circles(d=s, spread=s*sqrt(2), tangent=45);]]
<pre class="openscad">include <BOSL2/std.scad>
$fn=36; s=10;
linear_extrude(height=50,convexity=16,center=true)
xcopies(s*sqrt(2),n=3)
glued_circles(d=s, spread=s*sqrt(2), tangent=45);</pre>
Du kannst <code>anchor=</code> und <code>spin=</code> verwenden, genau wie bei anderen anhängbaren Formen. Die Ankerpunkte basieren jedoch auf den äußersten Ausmaßen der Form und sind möglicherweise nicht dort, wo du sie erwartest:
<pre class="openscad">include <BOSL2/std.scad>
glued_circles(d=40, spread=40, tangent=45)
show_anchors();</pre>
eyfsdoz9lk19zda175zqhya08lue1vy
OpenSCAD Benutzerhandbuch/ BOSL2-3D
0
123360
1093544
1093290
2026-11-08T19:03:22Z
Jowi-ammerbuch
115360
1093544
wikitext
text/x-wiki
{{MyNavi
|zurück = [[OpenSCAD Benutzerhandbuch/_BOSL2-2D|Zurück]]
|buch = [[OpenSCAD Benutzerhandbuch/_BOSL2|BOSL2-Inhalt]]
|weiter = [[OpenSCAD Benutzerhandbuch/_BOSL2|Weiter]]
}}
<span id="grundlagen-tutorial-3d-formen"></span>
= Grundlagen-Tutorial: 3D-Formen =
<span id="primitive-grundformen"></span>
== Primitive (Grundformen) ==
OpenSCAD bietet 3 eingebaute 3D-Grundformen: <code>cube()</code>, <code>cylinder()</code> und <code>sphere()</code>. Die BOSL2-Bibliothek erweitert diese Formen und bietet Alternativen, sodass sie mehr Funktionen unterstützen und sich einfacher neu ausrichten lassen.
<span id="3d-würfel-quader"></span>
=== 3D-Würfel (Quader) ===
BOSL2 überschreibt das eingebaute <code>cube()</code>-Modul. Es kann immer noch wie gewohnt verwendet werden:
<pre class="openscad">include <BOSL2/std.scad>
cube(100);</pre>
<pre class="openscad">include <BOSL2/std.scad>
cube(100, center=true);</pre>
<pre class="openscad">include <BOSL2/std.scad>
cube([50,40,20], center=true);</pre>
Es wurde zudem erweitert, sodass du es verankern (<code>anchor</code>), drehen (<code>spin</code>), ausrichten (<code>orient</code>) und anhängen (<code>attach</code>) kannst. Du kannst <code>anchor=</code> ähnlich verwenden wie bei <code>rect()</code> oder <code>ellipse()</code>, mit dem Unterschied, dass du im 3D-Raum auch vertikal verankern kannst. Das ermöglicht die Verankerung an Flächen, Kanten und Ecken:
<pre class="openscad">include <BOSL2/std.scad>
cube([50,40,20], anchor=BOTTOM);</pre>
<pre class="openscad">include <BOSL2/std.scad>
cube([50,40,20], anchor=TOP+BACK);</pre>
<pre class="openscad">include <BOSL2/std.scad>
cube([50,40,20], anchor=TOP+FRONT+LEFT);</pre>
Mit <code>spin=</code> kannst du das Objekt nach der Verankerung um die Z-Achse drehen:
<pre class="openscad">include <BOSL2/std.scad>
cube([50,40,20], anchor=FRONT, spin=30);</pre>
3D-Objekte können auch ein <code>orient=</code>-Argument als Vektor erhalten, der in die Richtung zeigt, in die die Oberseite des Objekts gedreht werden soll.
<pre class="openscad">include <BOSL2/std.scad>
cube([50,40,20], orient=UP+BACK+RIGHT);</pre>
Wenn du <code>anchor=</code>, <code>spin=</code> und <code>orient=</code> zusammen verwendest, wird zuerst die Verankerung ausgeführt, dann die Drehung und schließlich die Ausrichtung:
<pre class="openscad">include <BOSL2/std.scad>
cube([50,40,20], anchor=FRONT);</pre>
<pre class="openscad">include <BOSL2/std.scad>
cube([50,40,20], anchor=FRONT, spin=45);</pre>
<pre class="openscad">include <BOSL2/std.scad>
cube([50,40,20], anchor=FRONT, spin=45, orient=UP+FWD+RIGHT);</pre>
BOSL2 stellt ein <code>cuboid()</code>-Modul bereit, das <code>cube()</code> erweitert, indem es das Verrunden und Abschrägen von Kanten ermöglicht. Du kannst es ähnlich wie <code>cube()</code> verwenden, wobei <code>cuboid()</code> standardmäßig zentriert ist.
Du kannst die Kanten mit dem Argument <code>rounding=</code> verrunden:
<pre class="openscad">include <BOSL2/std.scad>
cuboid([100,80,60], rounding=20);</pre>
Ebenso kannst du die Kanten mit dem Argument <code>chamfer=</code> abschrägen:
<pre class="openscad">include <BOSL2/std.scad>
cuboid([100,80,60], chamfer=10);</pre>
Du kannst auch nur bestimmte Kanten verrunden, indem du das Argument <code>edges=</code> verwendest. Es akzeptiert verschiedene Arten von Argumenten. Wenn du einen Vektor übergibst, der auf eine Fläche zeigt, werden nur die Kanten um diese Fläche herum verrundet:
<pre class="openscad">include <BOSL2/std.scad>
cuboid([100,80,60], rounding=20, edges=TOP);</pre>
<pre class="openscad">include <BOSL2/std.scad>
cuboid([100,80,60], rounding=20, edges=RIGHT);</pre>
Wenn du <code>edges=</code> einen Vektor übergibst, der auf eine Ecke zeigt, werden alle Kanten verrundet, die an dieser Ecke zusammenlaufen:
<pre class="openscad">include <BOSL2/std.scad>
cuboid([100,80,60], rounding=20, edges=RIGHT+FRONT+TOP);</pre>
<pre class="openscad">include <BOSL2/std.scad>
cuboid([100,80,60], rounding=20, edges=LEFT+FRONT+TOP);</pre>
Wenn du <code>edges=</code> einen Vektor übergibst, der auf eine Kante zeigt, wird nur diese spezifische Kante verrundet:
<pre class="openscad">include <BOSL2/std.scad>
cuboid([100,80,60], rounding=10, edges=FRONT+TOP);</pre>
<pre class="openscad">include <BOSL2/std.scad>
cuboid([100,80,60], rounding=10, edges=RIGHT+FRONT);</pre>
Wenn du den String "X", "Y" oder "Z" übergibst, werden alle Kanten verrundet, die parallel zur jeweiligen Achse verlaufen:
<pre class="openscad">include <BOSL2/std.scad>
cuboid([100,80,60], rounding=10, edges="X");</pre>
<pre class="openscad">include <BOSL2/std.scad>
cuboid([100,80,60], rounding=10, edges="Y");</pre>
<pre class="openscad">include <BOSL2/std.scad>
cuboid([100,80,60], rounding=10, edges="Z");</pre>
Wenn du eine Liste von Kanten-Spezifikationen übergibst, werden alle in der Liste referenzierten Kanten verrundet:
<pre class="openscad">include <BOSL2/std.scad>
cuboid([100,80,60], rounding=10, edges=[TOP,"Z",BOTTOM+RIGHT]);</pre>
Der Standardwert für <code>edges=</code> ist <code>EDGES_ALL</code>, also alle Kanten. Du kannst auch das Argument <code>except_edges=</code> verwenden, um Kanten anzugeben, die ''nicht'' verrundet werden sollen:
<pre class="openscad">include <BOSL2/std.scad>
cuboid([100,80,60], rounding=10, except_edges=BOTTOM+RIGHT);</pre>
Du kannst <code>except_edges=</code> dieselben Argumenttypen übergeben wie <code>edges=</code>:
<pre class="openscad">include <BOSL2/std.scad>
cuboid([100,80,60], rounding=10, except_edges=[BOTTOM,"Z",TOP+RIGHT]);</pre>
Du kannst sowohl <code>edges=</code> als auch <code>except_edges=</code> angeben, um die Kanten-Spezifikationen zu vereinfachen:
<pre class="openscad">include <BOSL2/std.scad>
cuboid([100,80,60], rounding=10, edges=[TOP,FRONT], except_edges=TOP+FRONT);</pre>
Das Abschrägen bestimmter Kanten funktioniert auf dieselbe Weise:
<pre class="openscad">include <BOSL2/std.scad>
cuboid([100,80,60], chamfer=10, edges=[TOP,FRONT], except_edges=TOP+FRONT);</pre>
<span id="3d-zylinder"></span>
=== 3D-Zylinder ===
BOSL2 überschreibt das eingebaute <code>cylinder()</code>-Modul. Es kann weiterhin wie gewohnt verwendet werden:
<pre class="openscad">include <BOSL2/std.scad>
cylinder(r=50,h=50);</pre>
<pre class="openscad">include <BOSL2/std.scad>
cylinder(r=50,h=50,center=true);</pre>
<pre class="openscad">include <BOSL2/std.scad>
cylinder(d=100,h=50,center=true);</pre>
<pre class="openscad">include <BOSL2/std.scad>
cylinder(d1=100,d2=80,h=50,center=true);</pre>
Du kannst es auch wie das <code>cuboid()</code>-Modul verankern, drehen, ausrichten und anhängen:
<pre class="openscad">include <BOSL2/std.scad>
cylinder(r=50, h=50, anchor=TOP+FRONT);</pre>
<pre class="openscad">include <BOSL2/std.scad>
cylinder(r=50, h=50, anchor=BOTTOM+LEFT);</pre>
<pre class="openscad">include <BOSL2/std.scad>
cylinder(r=50, h=50, anchor=BOTTOM+LEFT, spin=30);</pre>
<pre class="openscad">include <BOSL2/std.scad>
cylinder(r=50, h=50, anchor=BOTTOM, orient=UP+BACK+RIGHT);</pre>
BOSL2 bietet ein <code>cyl()</code>-Modul, das <code>cylinder()</code> um das Verrunden und Abschrägen von Kanten erweitert. Du kannst es ähnlich wie <code>cylinder()</code> verwenden, wobei <code>cyl()</code> den Zylinder standardmäßig zentriert.
<pre class="openscad">include <BOSL2/std.scad>
cyl(r=60, l=100);</pre>
<pre class="openscad">include <BOSL2/std.scad>
cyl(d=100, l=100);</pre>
<pre class="openscad">include <BOSL2/std.scad>
cyl(d=100, l=100, anchor=TOP);</pre>
Du kannst die Kanten mit dem Argument <code>rounding=</code> verrunden:
<pre class="openscad">include <BOSL2/std.scad>
cyl(d=100, l=100, rounding=20);</pre>
Ebenso kannst du die Kanten mit dem Argument <code>chamfer=</code> abschrägen:
<pre class="openscad">include <BOSL2/std.scad>
cyl(d=100, l=100, chamfer=10);</pre>
Du kannst das Verrunden und Abschrägen für jedes Ende auch individuell festlegen:
<pre class="openscad">include <BOSL2/std.scad>
cyl(d=100, l=100, rounding1=20);</pre>
<pre class="openscad">include <BOSL2/std.scad>
cyl(d=100, l=100, rounding2=20);</pre>
<pre class="openscad">include <BOSL2/std.scad>
cyl(d=100, l=100, chamfer1=10);</pre>
<pre class="openscad">include <BOSL2/std.scad>
cyl(d=100, l=100, chamfer2=10);</pre>
Du kannst Verrundungen und Abschrägungen sogar miteinander kombinieren:
<pre class="openscad">include <BOSL2/std.scad>
cyl(d=100, l=100, rounding1=20, chamfer2=10);</pre>
<pre class="openscad">include <BOSL2/std.scad>
cyl(d=100, l=100, rounding2=20, chamfer1=10);</pre>
<span id="3d-kugeln"></span>
=== 3D-Kugeln ===
BOSL2 überschreibt das eingebaute <code>sphere()</code>-Modul. Es kann weiterhin wie gewohnt verwendet werden:
<pre class="openscad">include <BOSL2/std.scad>
sphere(r=50);</pre>
<pre class="openscad">include <BOSL2/std.scad>
sphere(d=100);</pre>
Du kannst <code>sphere()</code>-Objekte ähnlich wie <code>cylinder()</code> und <code>cube()</code> verankern, drehen und ausrichten:
<pre class="openscad">include <BOSL2/std.scad>
sphere(d=100, anchor=FRONT);</pre>
<pre class="openscad">include <BOSL2/std.scad>
sphere(d=100, anchor=FRONT, spin=30);</pre>
<pre class="openscad">include <BOSL2/std.scad>
sphere(d=100, anchor=BOTTOM, orient=RIGHT+TOP);</pre>
BOSL2 bietet außerdem <code>spheroid()</code>, was <code>sphere()</code> um einige Funktionen wie die Argumente <code>circum=</code> und <code>style=</code> erweitert:
Mit dem Argument <code>circum=true</code> kannst du erzwingen, dass die Kugel die ideale Kugel umschreibt (umschließend), anstatt sie standardmäßig einzuschreiben (innenliegend):
<pre class="openscad">include <BOSL2/std.scad>
spheroid(d=100, circum=true);</pre>
Das Argument <code>style=</code> bestimmt, wie die Kugel konstruiert wird:
Der Stil "orig" entspricht der Konstruktion des eingebauten <code>sphere()</code>:
<pre class="openscad">include <BOSL2/std.scad>
spheroid(d=100, style="orig", $fn=20);</pre>
Der Stil "aligned" stellt sicher, dass an den äußeren Punkten jeder Achse ein Vertex (Eckpunkt) vorhanden ist, solange <code>$fn</code> ein Vielfaches von 4 ist.
<pre class="openscad">include <BOSL2/std.scad>
spheroid(d=100, style="aligned", $fn=20);</pre>
Der Stil "stagger" versetzt die Triangulierung (Vernetzung) der vertikalen Reihen:
<pre class="openscad">include <BOSL2/std.scad>
spheroid(d=100, style="stagger", $fn=20);</pre>
Der Stil "icosa" erzeugt annähernd gleich große Dreiecke für die gesamte Kugeloberfläche, basierend auf der Unterteilung eines Ikosaeders. Dieser Stil rundet das effektive <code>$fn</code> beim Konstruieren des Spheroids auf ein Vielfaches von 5:
<pre class="openscad">include <BOSL2/std.scad>
spheroid(d=100, style="icosa", $fn=20);</pre>
Der Stil "octa" erzeugt ebenfalls annähernd gleich große Dreiecke für die gesamte Oberfläche, basiert aber auf der Unterteilung eines Oktaeders. Das ist nützlich, da es Vertizes an den äußeren Punkten der Achsen garantiert. Dieser Stil rundet das effektive <code>$fn</code> auf ein Vielfaches von 4:
<pre class="openscad">include <BOSL2/std.scad>
spheroid(d=100, style="octa", $fn=20);</pre>
sisndm7umejk48jpktllhr1mqilhtts
1093545
1093544
2026-11-08T19:41:37Z
Jowi-ammerbuch
115360
/* 3D-Würfel (Quader) */
1093545
wikitext
text/x-wiki
{{MyNavi
|zurück = [[OpenSCAD Benutzerhandbuch/_BOSL2-2D|Zurück]]
|buch = [[OpenSCAD Benutzerhandbuch/_BOSL2|BOSL2-Inhalt]]
|weiter = [[OpenSCAD Benutzerhandbuch/_BOSL2|Weiter]]
}}
<span id="grundlagen-tutorial-3d-formen"></span>
= Grundlagen-Tutorial: 3D-Formen =
<span id="primitive-grundformen"></span>
== Primitive (Grundformen) ==
OpenSCAD bietet 3 eingebaute 3D-Grundformen: <code>cube()</code>, <code>cylinder()</code> und <code>sphere()</code>. Die BOSL2-Bibliothek erweitert diese Formen und bietet Alternativen, sodass sie mehr Funktionen unterstützen und sich einfacher neu ausrichten lassen.
<span id="3d-würfel-quader"></span>
== 3D-Würfel (Quader) ==
BOSL2 überschreibt das eingebaute <code>cube()</code>-Modul. Es kann immer noch wie gewohnt verwendet werden:
<pre class="openscad">include <BOSL2/std.scad>
cube(100);</pre>
<pre class="openscad">include <BOSL2/std.scad>
cube(100, center=true);</pre>
<pre class="openscad">include <BOSL2/std.scad>
cube([50,40,20], center=true);</pre>
=== cube() mit anchors ===
Es wurde zudem erweitert, sodass du es verankern (<code>anchor</code>), drehen (<code>spin</code>), ausrichten (<code>orient</code>) und anhängen (<code>attach</code>) kannst. Du kannst <code>anchor=</code> ähnlich verwenden wie bei <code>rect()</code> oder <code>ellipse()</code>, mit dem Unterschied, dass du im 3D-Raum auch vertikal verankern kannst. Das ermöglicht die Verankerung an Flächen, Kanten und Ecken:
[[Datei:BOSL2-cube anchor show anchors.png|mini|zentriert|alternativtext=cube mit anchors|cube([50,40,20], anchor=BOTTOM+LEFT+FRONT) show_anchors();]]
<pre class="openscad">include <BOSL2/std.scad>
cube([50,40,20], anchor=BOTTOM+LEFT+FRONT) show_anchors();</pre>
=== cube() mit spin=<Winkel> ===
[[Datei:BOSL2-cube spin.png|mini|zentriert|alternativtext=cube([50,40,20], anchor=FRONT, spin=30);|cube([50,40,20], anchor=FRONT, spin=30);]]
Mit <code>spin=</code> kannst du das Objekt nach der Verankerung um die Z-Achse drehen:
<pre class="openscad">include <BOSL2/std.scad>
cube([50,40,20], anchor=FRONT, spin=30);</pre>
=== cube() mit orient=<Vectorkoordinaten-Oberseite> ===
3D-Objekte können auch ein <code>orient=</code>-Argument als Vektor erhalten, der in die Richtung zeigt, in die die Oberseite des Objekts gedreht werden soll.
[[Datei:BOSL2-cube orient.png|mini|zentriert|alternativtext=orient=RIGHT|#cube([50,40,20]) attach(TOP) #sphere(4); cube([50,40,20], orient=RIGHT) attach(TOP) color("magenta")sphere(4);]]
<pre class="openscad">include <BOSL2/std.scad>
#cube([50,40,20]) attach(TOP) #sphere(4);
cube([50,40,20], orient=RIGHT) attach(TOP) color("magenta")sphere(4);
</pre>
Im Beispiel wurde die Oberseite (TOP) nach rechts gedreht. Die an die Oberseite angehängten Kugeln dienen lediglich der Markierung und Orientierung.
=== cube mit anchor + spin + orient ===
Wenn du <code>anchor=</code>, <code>spin=</code> und <code>orient=</code> zusammen verwendest, wird zuerst die Verankerung ausgeführt, dann die Drehung und schließlich die Ausrichtung:
[[Datei:BOSL2-cube anchor spin orient.png|mini|zentriert|alternativtext=anchor, spin und orient am cube()|Veranschaulichung der Reihenfolge von anchor, spin und orient am cube()]]
<pre class="openscad">include <BOSL2/std.scad>
cube([50,40,20], anchor=FRONT);</pre>
<pre class="openscad">include <BOSL2/std.scad>
cube([50,40,20], anchor=FRONT, spin=45);</pre>
<pre class="openscad">include <BOSL2/std.scad>
cube([50,40,20], anchor=FRONT, spin=45, orient=UP+FWD+RIGHT);</pre>
BOSL2 stellt ein <code>cuboid()</code>-Modul bereit, das <code>cube()</code> erweitert, indem es das Verrunden und Abschrägen von Kanten ermöglicht. Du kannst es ähnlich wie <code>cube()</code> verwenden, wobei <code>cuboid()</code> standardmäßig zentriert ist.
Du kannst die Kanten mit dem Argument <code>rounding=</code> verrunden:
<pre class="openscad">include <BOSL2/std.scad>
cuboid([100,80,60], rounding=20);</pre>
Ebenso kannst du die Kanten mit dem Argument <code>chamfer=</code> abschrägen:
<pre class="openscad">include <BOSL2/std.scad>
cuboid([100,80,60], chamfer=10);</pre>
Du kannst auch nur bestimmte Kanten verrunden, indem du das Argument <code>edges=</code> verwendest. Es akzeptiert verschiedene Arten von Argumenten. Wenn du einen Vektor übergibst, der auf eine Fläche zeigt, werden nur die Kanten um diese Fläche herum verrundet:
<pre class="openscad">include <BOSL2/std.scad>
cuboid([100,80,60], rounding=20, edges=TOP);</pre>
<pre class="openscad">include <BOSL2/std.scad>
cuboid([100,80,60], rounding=20, edges=RIGHT);</pre>
Wenn du <code>edges=</code> einen Vektor übergibst, der auf eine Ecke zeigt, werden alle Kanten verrundet, die an dieser Ecke zusammenlaufen:
<pre class="openscad">include <BOSL2/std.scad>
cuboid([100,80,60], rounding=20, edges=RIGHT+FRONT+TOP);</pre>
<pre class="openscad">include <BOSL2/std.scad>
cuboid([100,80,60], rounding=20, edges=LEFT+FRONT+TOP);</pre>
Wenn du <code>edges=</code> einen Vektor übergibst, der auf eine Kante zeigt, wird nur diese spezifische Kante verrundet:
<pre class="openscad">include <BOSL2/std.scad>
cuboid([100,80,60], rounding=10, edges=FRONT+TOP);</pre>
<pre class="openscad">include <BOSL2/std.scad>
cuboid([100,80,60], rounding=10, edges=RIGHT+FRONT);</pre>
Wenn du den String "X", "Y" oder "Z" übergibst, werden alle Kanten verrundet, die parallel zur jeweiligen Achse verlaufen:
<pre class="openscad">include <BOSL2/std.scad>
cuboid([100,80,60], rounding=10, edges="X");</pre>
<pre class="openscad">include <BOSL2/std.scad>
cuboid([100,80,60], rounding=10, edges="Y");</pre>
<pre class="openscad">include <BOSL2/std.scad>
cuboid([100,80,60], rounding=10, edges="Z");</pre>
Wenn du eine Liste von Kanten-Spezifikationen übergibst, werden alle in der Liste referenzierten Kanten verrundet:
<pre class="openscad">include <BOSL2/std.scad>
cuboid([100,80,60], rounding=10, edges=[TOP,"Z",BOTTOM+RIGHT]);</pre>
Der Standardwert für <code>edges=</code> ist <code>EDGES_ALL</code>, also alle Kanten. Du kannst auch das Argument <code>except_edges=</code> verwenden, um Kanten anzugeben, die ''nicht'' verrundet werden sollen:
<pre class="openscad">include <BOSL2/std.scad>
cuboid([100,80,60], rounding=10, except_edges=BOTTOM+RIGHT);</pre>
Du kannst <code>except_edges=</code> dieselben Argumenttypen übergeben wie <code>edges=</code>:
<pre class="openscad">include <BOSL2/std.scad>
cuboid([100,80,60], rounding=10, except_edges=[BOTTOM,"Z",TOP+RIGHT]);</pre>
Du kannst sowohl <code>edges=</code> als auch <code>except_edges=</code> angeben, um die Kanten-Spezifikationen zu vereinfachen:
<pre class="openscad">include <BOSL2/std.scad>
cuboid([100,80,60], rounding=10, edges=[TOP,FRONT], except_edges=TOP+FRONT);</pre>
Das Abschrägen bestimmter Kanten funktioniert auf dieselbe Weise:
<pre class="openscad">include <BOSL2/std.scad>
cuboid([100,80,60], chamfer=10, edges=[TOP,FRONT], except_edges=TOP+FRONT);</pre>
<span id="3d-zylinder"></span>
=== 3D-Zylinder ===
BOSL2 überschreibt das eingebaute <code>cylinder()</code>-Modul. Es kann weiterhin wie gewohnt verwendet werden:
<pre class="openscad">include <BOSL2/std.scad>
cylinder(r=50,h=50);</pre>
<pre class="openscad">include <BOSL2/std.scad>
cylinder(r=50,h=50,center=true);</pre>
<pre class="openscad">include <BOSL2/std.scad>
cylinder(d=100,h=50,center=true);</pre>
<pre class="openscad">include <BOSL2/std.scad>
cylinder(d1=100,d2=80,h=50,center=true);</pre>
Du kannst es auch wie das <code>cuboid()</code>-Modul verankern, drehen, ausrichten und anhängen:
<pre class="openscad">include <BOSL2/std.scad>
cylinder(r=50, h=50, anchor=TOP+FRONT);</pre>
<pre class="openscad">include <BOSL2/std.scad>
cylinder(r=50, h=50, anchor=BOTTOM+LEFT);</pre>
<pre class="openscad">include <BOSL2/std.scad>
cylinder(r=50, h=50, anchor=BOTTOM+LEFT, spin=30);</pre>
<pre class="openscad">include <BOSL2/std.scad>
cylinder(r=50, h=50, anchor=BOTTOM, orient=UP+BACK+RIGHT);</pre>
BOSL2 bietet ein <code>cyl()</code>-Modul, das <code>cylinder()</code> um das Verrunden und Abschrägen von Kanten erweitert. Du kannst es ähnlich wie <code>cylinder()</code> verwenden, wobei <code>cyl()</code> den Zylinder standardmäßig zentriert.
<pre class="openscad">include <BOSL2/std.scad>
cyl(r=60, l=100);</pre>
<pre class="openscad">include <BOSL2/std.scad>
cyl(d=100, l=100);</pre>
<pre class="openscad">include <BOSL2/std.scad>
cyl(d=100, l=100, anchor=TOP);</pre>
Du kannst die Kanten mit dem Argument <code>rounding=</code> verrunden:
<pre class="openscad">include <BOSL2/std.scad>
cyl(d=100, l=100, rounding=20);</pre>
Ebenso kannst du die Kanten mit dem Argument <code>chamfer=</code> abschrägen:
<pre class="openscad">include <BOSL2/std.scad>
cyl(d=100, l=100, chamfer=10);</pre>
Du kannst das Verrunden und Abschrägen für jedes Ende auch individuell festlegen:
<pre class="openscad">include <BOSL2/std.scad>
cyl(d=100, l=100, rounding1=20);</pre>
<pre class="openscad">include <BOSL2/std.scad>
cyl(d=100, l=100, rounding2=20);</pre>
<pre class="openscad">include <BOSL2/std.scad>
cyl(d=100, l=100, chamfer1=10);</pre>
<pre class="openscad">include <BOSL2/std.scad>
cyl(d=100, l=100, chamfer2=10);</pre>
Du kannst Verrundungen und Abschrägungen sogar miteinander kombinieren:
<pre class="openscad">include <BOSL2/std.scad>
cyl(d=100, l=100, rounding1=20, chamfer2=10);</pre>
<pre class="openscad">include <BOSL2/std.scad>
cyl(d=100, l=100, rounding2=20, chamfer1=10);</pre>
<span id="3d-kugeln"></span>
=== 3D-Kugeln ===
BOSL2 überschreibt das eingebaute <code>sphere()</code>-Modul. Es kann weiterhin wie gewohnt verwendet werden:
<pre class="openscad">include <BOSL2/std.scad>
sphere(r=50);</pre>
<pre class="openscad">include <BOSL2/std.scad>
sphere(d=100);</pre>
Du kannst <code>sphere()</code>-Objekte ähnlich wie <code>cylinder()</code> und <code>cube()</code> verankern, drehen und ausrichten:
<pre class="openscad">include <BOSL2/std.scad>
sphere(d=100, anchor=FRONT);</pre>
<pre class="openscad">include <BOSL2/std.scad>
sphere(d=100, anchor=FRONT, spin=30);</pre>
<pre class="openscad">include <BOSL2/std.scad>
sphere(d=100, anchor=BOTTOM, orient=RIGHT+TOP);</pre>
BOSL2 bietet außerdem <code>spheroid()</code>, was <code>sphere()</code> um einige Funktionen wie die Argumente <code>circum=</code> und <code>style=</code> erweitert:
Mit dem Argument <code>circum=true</code> kannst du erzwingen, dass die Kugel die ideale Kugel umschreibt (umschließend), anstatt sie standardmäßig einzuschreiben (innenliegend):
<pre class="openscad">include <BOSL2/std.scad>
spheroid(d=100, circum=true);</pre>
Das Argument <code>style=</code> bestimmt, wie die Kugel konstruiert wird:
Der Stil "orig" entspricht der Konstruktion des eingebauten <code>sphere()</code>:
<pre class="openscad">include <BOSL2/std.scad>
spheroid(d=100, style="orig", $fn=20);</pre>
Der Stil "aligned" stellt sicher, dass an den äußeren Punkten jeder Achse ein Vertex (Eckpunkt) vorhanden ist, solange <code>$fn</code> ein Vielfaches von 4 ist.
<pre class="openscad">include <BOSL2/std.scad>
spheroid(d=100, style="aligned", $fn=20);</pre>
Der Stil "stagger" versetzt die Triangulierung (Vernetzung) der vertikalen Reihen:
<pre class="openscad">include <BOSL2/std.scad>
spheroid(d=100, style="stagger", $fn=20);</pre>
Der Stil "icosa" erzeugt annähernd gleich große Dreiecke für die gesamte Kugeloberfläche, basierend auf der Unterteilung eines Ikosaeders. Dieser Stil rundet das effektive <code>$fn</code> beim Konstruieren des Spheroids auf ein Vielfaches von 5:
<pre class="openscad">include <BOSL2/std.scad>
spheroid(d=100, style="icosa", $fn=20);</pre>
Der Stil "octa" erzeugt ebenfalls annähernd gleich große Dreiecke für die gesamte Oberfläche, basiert aber auf der Unterteilung eines Oktaeders. Das ist nützlich, da es Vertizes an den äußeren Punkten der Achsen garantiert. Dieser Stil rundet das effektive <code>$fn</code> auf ein Vielfaches von 4:
<pre class="openscad">include <BOSL2/std.scad>
spheroid(d=100, style="octa", $fn=20);</pre>
se9zkqa3yj5uynkuiteeuca6r2z51rt
1093546
1093545
2026-11-08T20:26:25Z
Jowi-ammerbuch
115360
/* cube mit anchor + spin + orient */
1093546
wikitext
text/x-wiki
{{MyNavi
|zurück = [[OpenSCAD Benutzerhandbuch/_BOSL2-2D|Zurück]]
|buch = [[OpenSCAD Benutzerhandbuch/_BOSL2|BOSL2-Inhalt]]
|weiter = [[OpenSCAD Benutzerhandbuch/_BOSL2|Weiter]]
}}
<span id="grundlagen-tutorial-3d-formen"></span>
= Grundlagen-Tutorial: 3D-Formen =
<span id="primitive-grundformen"></span>
== Primitive (Grundformen) ==
OpenSCAD bietet 3 eingebaute 3D-Grundformen: <code>cube()</code>, <code>cylinder()</code> und <code>sphere()</code>. Die BOSL2-Bibliothek erweitert diese Formen und bietet Alternativen, sodass sie mehr Funktionen unterstützen und sich einfacher neu ausrichten lassen.
<span id="3d-würfel-quader"></span>
== 3D-Würfel (Quader) ==
BOSL2 überschreibt das eingebaute <code>cube()</code>-Modul. Es kann immer noch wie gewohnt verwendet werden:
<pre class="openscad">include <BOSL2/std.scad>
cube(100);</pre>
<pre class="openscad">include <BOSL2/std.scad>
cube(100, center=true);</pre>
<pre class="openscad">include <BOSL2/std.scad>
cube([50,40,20], center=true);</pre>
=== cube() mit anchors ===
Es wurde zudem erweitert, sodass du es verankern (<code>anchor</code>), drehen (<code>spin</code>), ausrichten (<code>orient</code>) und anhängen (<code>attach</code>) kannst. Du kannst <code>anchor=</code> ähnlich verwenden wie bei <code>rect()</code> oder <code>ellipse()</code>, mit dem Unterschied, dass du im 3D-Raum auch vertikal verankern kannst. Das ermöglicht die Verankerung an Flächen, Kanten und Ecken:
[[Datei:BOSL2-cube anchor show anchors.png|mini|zentriert|alternativtext=cube mit anchors|cube([50,40,20], anchor=BOTTOM+LEFT+FRONT) show_anchors();]]
<pre class="openscad">include <BOSL2/std.scad>
cube([50,40,20], anchor=BOTTOM+LEFT+FRONT) show_anchors();</pre>
=== cube() mit spin=<Winkel> ===
[[Datei:BOSL2-cube spin.png|mini|zentriert|alternativtext=cube([50,40,20], anchor=FRONT, spin=30);|cube([50,40,20], anchor=FRONT, spin=30);]]
Mit <code>spin=</code> kannst du das Objekt nach der Verankerung um die Z-Achse drehen:
<pre class="openscad">include <BOSL2/std.scad>
cube([50,40,20], anchor=FRONT, spin=30);</pre>
=== cube() mit orient=<Vectorkoordinaten-Oberseite> ===
3D-Objekte können auch ein <code>orient=</code>-Argument als Vektor erhalten, der in die Richtung zeigt, in die die Oberseite des Objekts gedreht werden soll.
[[Datei:BOSL2-cube orient.png|mini|zentriert|alternativtext=orient=RIGHT|#cube([50,40,20]) attach(TOP) #sphere(4); cube([50,40,20], orient=RIGHT) attach(TOP) color("magenta")sphere(4);]]
<pre class="openscad">include <BOSL2/std.scad>
#cube([50,40,20]) attach(TOP) #sphere(4);
cube([50,40,20], orient=RIGHT) attach(TOP) color("magenta")sphere(4);
</pre>
Im Beispiel wurde die Oberseite (TOP) nach rechts gedreht. Die an die Oberseite angehängten Kugeln dienen lediglich der Markierung und Orientierung.
=== cube mit anchor + spin + orient ===
Wenn du <code>anchor=</code>, <code>spin=</code> und <code>orient=</code> zusammen verwendest, wird zuerst die Verankerung ausgeführt, dann die Drehung und schließlich die Ausrichtung:
[[Datei:BOSL2-cube anchor spin orient.png|mini|zentriert|alternativtext=anchor, spin und orient am cube()|Veranschaulichung der Reihenfolge von anchor, spin und orient am cube()]]
<pre class="openscad">include <BOSL2/std.scad>
cube([50,40,20], anchor=FRONT);</pre>
<pre class="openscad">include <BOSL2/std.scad>
cube([50,40,20], anchor=FRONT, spin=45);</pre>
<pre class="openscad">include <BOSL2/std.scad>
cube([50,40,20], anchor=FRONT, spin=45, orient=UP+FWD+RIGHT);</pre>
== cuboid() ==
BOSL2 stellt ein <code>cuboid()</code>-Modul bereit, das <code>cube()</code> erweitert, indem es das Verrunden und Abschrägen von Kanten ermöglicht. Du kannst es ähnlich wie <code>cube()</code> verwenden, wobei <code>cuboid()</code> standardmäßig zentriert ist.
=== cuboid() mit rounding = <Radius> ===
Du kannst die Kanten mit dem Argument <code>rounding=</code> verrunden:
[[Datei:BOSL2-cuboid rounding.png|mini|zentriert|alternativtext=cuboid([100,80,60], rounding=10);|cuboid([100,80,60], rounding=10);]]
<pre class="openscad">
include <BOSL2/std.scad>
$fn=60;
cuboid([100,80,60], rounding=10);
</pre>
'''Ohne BOSL2''' müsste der Code für einen gerundeten Quader z.B. so aussehen:
<pre class="openscad">
minkowski() {
cube([80, 60, 40], center = true);
sphere(r = 10);
}
</pre>
Der BOSL2-Code ist leserlicher, da intuitiver nachvollziehbar.
=== cuboid() mit camfer ===
Ebenso kannst du die Kanten mit dem Argument <code>chamfer=</code> abschrägen:
[[Datei:BOSL2-cuboid camfer.png|mini|zentriert|alternativtext=cuboid([100,80,60], chamfer=10);|cuboid([100,80,60], chamfer=10);]]
<pre class="openscad">include <BOSL2/std.scad>
cuboid([100,80,60], chamfer=10);</pre>
Um dieses Ergebnis '''ohne BOSL2''' zu erreichen, müsste man einen deutlich umfangreicheren und schwerer verständlichen Code schreiben, den ich durch KI (Google Gemini) erstellen ließ:
<pre class="openscad">
module chamfered_cuboid_exact(size, c) {
inner_size = [size[0] - 2*c, size[1] - 2*c, size[2] - 2*c];
minkowski() {
cube(inner_size, center = true);
polyhedron(
points = [
[c, 0, 0], [-c, 0, 0],
[0, c, 0], [0, -c, 0],
[0, 0, c], [0, 0, -c]
],
faces = [
[0, 2, 4], [2, 1, 4], [1, 3, 4], [3, 0, 4],
[2, 0, 5], [1, 2, 5], [3, 1, 5], [0, 3, 5]
]
);
}
}
chamfered_cuboid_exact([100, 80, 60], 10);
</pre>
=== cuboid() mit edges=<Vektor> Verrundung ausgewählter Kanten ===
Du kannst auch nur bestimmte Kanten verrunden, indem du das Argument <code>edges=</code> verwendest. Es akzeptiert verschiedene Arten von Argumenten. Wenn du einen Vektor übergibst, der auf eine Fläche zeigt, werden nur die Kanten um diese Fläche herum verrundet:
[[Datei:BOSL2-cuboid rounding edges top.png|mini|zentriert|alternativtext=cuboid([100,80,60], rounding=20, edges=TOP);|cuboid([100,80,60], rounding=20, edges=TOP);]]
<pre class="openscad">include <BOSL2/std.scad>
cuboid([100,80,60], rounding=20, edges=TOP);</pre>
[[Datei:BOSL2-cuboid rounding edges RIGHT.png|mini|zentriert|alternativtext=rounding=20, edges=RIGHT|cuboid([100,80,60], rounding=20, edges=RIGHT);]]
<pre class="openscad">include <BOSL2/std.scad>
cuboid([100,80,60], rounding=20, edges=RIGHT);</pre>
Wenn du <code>edges=</code> einen Vektor übergibst, der auf eine Ecke zeigt, werden alle Kanten verrundet, die an dieser Ecke zusammenlaufen:
[[Datei:BOSL2-cuboid rounding edges RIGHT FRONT TOP.png|mini|zentriert|alternativtext=rounding=20, edges=RIGHT+FRONT+TOP|cuboid([100,80,60], rounding=20, edges=RIGHT+FRONT+TOP);]]
<pre class="openscad">include <BOSL2/std.scad>
cuboid([100,80,60], rounding=20, edges=RIGHT+FRONT+TOP);</pre>
Wenn du <code>edges=</code> einen Vektor übergibst, der auf eine Kante zeigt, wird nur diese spezifische Kante verrundet:
[[Datei:BOSL2-cuboid rounding edges RIGHT FRONT.png|mini|zentriert|alternativtext=rounding=10, edges=FRONT+TOP|cuboid([100,80,60], rounding=10, edges=FRONT+TOP);]]
<pre class="openscad">include <BOSL2/std.scad>
cuboid([100,80,60], rounding=10, edges=RIGHT+FRONT);</pre>
=== cuboid() mit edges=<"X"/"Y"/"Z"> Verrundung ausgewählter Kanten ===
Wenn du den String "X", "Y" oder "Z" übergibst, werden alle Kanten verrundet, die parallel zur jeweiligen Achse verlaufen:
[[Datei:BOSL2-cuboid rounding edges X.png|mini|zentriert|alternativtext=edges="X"|cuboid([100,80,60], rounding=10, edges="X");]]
<pre class="openscad">include <BOSL2/std.scad>
cuboid([100,80,60], rounding=10, edges="X");</pre>
[[Datei:BOSL2-cuboid rounding edges Y.png|mini|zentriert|alternativtext=edges="Y"|cuboid([100,80,60], rounding=10, edges="Y");]]
<pre class="openscad">include <BOSL2/std.scad>
cuboid([100,80,60], rounding=10, edges="Y");</pre>
[[Datei:BOSL2-cuboid rounding edges Z.png|mini|zentriert|alternativtext=edges="Z"|cuboid([100,80,60], rounding=10, edges="Z");]]
<pre class="openscad">include <BOSL2/std.scad>
cuboid([100,80,60], rounding=10, edges="Z");</pre>
Wenn du eine Liste von Kanten-Spezifikationen übergibst, werden alle in der Liste referenzierten Kanten verrundet:
<pre class="openscad">include <BOSL2/std.scad>
cuboid([100,80,60], rounding=10, edges=[TOP,"Z",BOTTOM+RIGHT]);</pre>
Der Standardwert für <code>edges=</code> ist <code>EDGES_ALL</code>, also alle Kanten. Du kannst auch das Argument <code>except_edges=</code> verwenden, um Kanten anzugeben, die ''nicht'' verrundet werden sollen:
<pre class="openscad">include <BOSL2/std.scad>
cuboid([100,80,60], rounding=10, except_edges=BOTTOM+RIGHT);</pre>
Du kannst <code>except_edges=</code> dieselben Argumenttypen übergeben wie <code>edges=</code>:
<pre class="openscad">include <BOSL2/std.scad>
cuboid([100,80,60], rounding=10, except_edges=[BOTTOM,"Z",TOP+RIGHT]);</pre>
Du kannst sowohl <code>edges=</code> als auch <code>except_edges=</code> angeben, um die Kanten-Spezifikationen zu vereinfachen:
<pre class="openscad">include <BOSL2/std.scad>
cuboid([100,80,60], rounding=10, edges=[TOP,FRONT], except_edges=TOP+FRONT);</pre>
Das Abschrägen bestimmter Kanten funktioniert auf dieselbe Weise:
<pre class="openscad">include <BOSL2/std.scad>
cuboid([100,80,60], chamfer=10, edges=[TOP,FRONT], except_edges=TOP+FRONT);</pre>
<span id="3d-zylinder"></span>
=== 3D-Zylinder ===
BOSL2 überschreibt das eingebaute <code>cylinder()</code>-Modul. Es kann weiterhin wie gewohnt verwendet werden:
<pre class="openscad">include <BOSL2/std.scad>
cylinder(r=50,h=50);</pre>
<pre class="openscad">include <BOSL2/std.scad>
cylinder(r=50,h=50,center=true);</pre>
<pre class="openscad">include <BOSL2/std.scad>
cylinder(d=100,h=50,center=true);</pre>
<pre class="openscad">include <BOSL2/std.scad>
cylinder(d1=100,d2=80,h=50,center=true);</pre>
Du kannst es auch wie das <code>cuboid()</code>-Modul verankern, drehen, ausrichten und anhängen:
<pre class="openscad">include <BOSL2/std.scad>
cylinder(r=50, h=50, anchor=TOP+FRONT);</pre>
<pre class="openscad">include <BOSL2/std.scad>
cylinder(r=50, h=50, anchor=BOTTOM+LEFT);</pre>
<pre class="openscad">include <BOSL2/std.scad>
cylinder(r=50, h=50, anchor=BOTTOM+LEFT, spin=30);</pre>
<pre class="openscad">include <BOSL2/std.scad>
cylinder(r=50, h=50, anchor=BOTTOM, orient=UP+BACK+RIGHT);</pre>
BOSL2 bietet ein <code>cyl()</code>-Modul, das <code>cylinder()</code> um das Verrunden und Abschrägen von Kanten erweitert. Du kannst es ähnlich wie <code>cylinder()</code> verwenden, wobei <code>cyl()</code> den Zylinder standardmäßig zentriert.
<pre class="openscad">include <BOSL2/std.scad>
cyl(r=60, l=100);</pre>
<pre class="openscad">include <BOSL2/std.scad>
cyl(d=100, l=100);</pre>
<pre class="openscad">include <BOSL2/std.scad>
cyl(d=100, l=100, anchor=TOP);</pre>
Du kannst die Kanten mit dem Argument <code>rounding=</code> verrunden:
<pre class="openscad">include <BOSL2/std.scad>
cyl(d=100, l=100, rounding=20);</pre>
Ebenso kannst du die Kanten mit dem Argument <code>chamfer=</code> abschrägen:
<pre class="openscad">include <BOSL2/std.scad>
cyl(d=100, l=100, chamfer=10);</pre>
Du kannst das Verrunden und Abschrägen für jedes Ende auch individuell festlegen:
<pre class="openscad">include <BOSL2/std.scad>
cyl(d=100, l=100, rounding1=20);</pre>
<pre class="openscad">include <BOSL2/std.scad>
cyl(d=100, l=100, rounding2=20);</pre>
<pre class="openscad">include <BOSL2/std.scad>
cyl(d=100, l=100, chamfer1=10);</pre>
<pre class="openscad">include <BOSL2/std.scad>
cyl(d=100, l=100, chamfer2=10);</pre>
Du kannst Verrundungen und Abschrägungen sogar miteinander kombinieren:
<pre class="openscad">include <BOSL2/std.scad>
cyl(d=100, l=100, rounding1=20, chamfer2=10);</pre>
<pre class="openscad">include <BOSL2/std.scad>
cyl(d=100, l=100, rounding2=20, chamfer1=10);</pre>
<span id="3d-kugeln"></span>
=== 3D-Kugeln ===
BOSL2 überschreibt das eingebaute <code>sphere()</code>-Modul. Es kann weiterhin wie gewohnt verwendet werden:
<pre class="openscad">include <BOSL2/std.scad>
sphere(r=50);</pre>
<pre class="openscad">include <BOSL2/std.scad>
sphere(d=100);</pre>
Du kannst <code>sphere()</code>-Objekte ähnlich wie <code>cylinder()</code> und <code>cube()</code> verankern, drehen und ausrichten:
<pre class="openscad">include <BOSL2/std.scad>
sphere(d=100, anchor=FRONT);</pre>
<pre class="openscad">include <BOSL2/std.scad>
sphere(d=100, anchor=FRONT, spin=30);</pre>
<pre class="openscad">include <BOSL2/std.scad>
sphere(d=100, anchor=BOTTOM, orient=RIGHT+TOP);</pre>
BOSL2 bietet außerdem <code>spheroid()</code>, was <code>sphere()</code> um einige Funktionen wie die Argumente <code>circum=</code> und <code>style=</code> erweitert:
Mit dem Argument <code>circum=true</code> kannst du erzwingen, dass die Kugel die ideale Kugel umschreibt (umschließend), anstatt sie standardmäßig einzuschreiben (innenliegend):
<pre class="openscad">include <BOSL2/std.scad>
spheroid(d=100, circum=true);</pre>
Das Argument <code>style=</code> bestimmt, wie die Kugel konstruiert wird:
Der Stil "orig" entspricht der Konstruktion des eingebauten <code>sphere()</code>:
<pre class="openscad">include <BOSL2/std.scad>
spheroid(d=100, style="orig", $fn=20);</pre>
Der Stil "aligned" stellt sicher, dass an den äußeren Punkten jeder Achse ein Vertex (Eckpunkt) vorhanden ist, solange <code>$fn</code> ein Vielfaches von 4 ist.
<pre class="openscad">include <BOSL2/std.scad>
spheroid(d=100, style="aligned", $fn=20);</pre>
Der Stil "stagger" versetzt die Triangulierung (Vernetzung) der vertikalen Reihen:
<pre class="openscad">include <BOSL2/std.scad>
spheroid(d=100, style="stagger", $fn=20);</pre>
Der Stil "icosa" erzeugt annähernd gleich große Dreiecke für die gesamte Kugeloberfläche, basierend auf der Unterteilung eines Ikosaeders. Dieser Stil rundet das effektive <code>$fn</code> beim Konstruieren des Spheroids auf ein Vielfaches von 5:
<pre class="openscad">include <BOSL2/std.scad>
spheroid(d=100, style="icosa", $fn=20);</pre>
Der Stil "octa" erzeugt ebenfalls annähernd gleich große Dreiecke für die gesamte Oberfläche, basiert aber auf der Unterteilung eines Oktaeders. Das ist nützlich, da es Vertizes an den äußeren Punkten der Achsen garantiert. Dieser Stil rundet das effektive <code>$fn</code> auf ein Vielfaches von 4:
<pre class="openscad">include <BOSL2/std.scad>
spheroid(d=100, style="octa", $fn=20);</pre>
nm6q55zcoghscyh17z3ocm8her6mjik
1093547
1093546
2026-11-08T20:42:26Z
Jowi-ammerbuch
115360
/* cuboid() mit edges= Verrundung ausgewählter Kanten */
1093547
wikitext
text/x-wiki
{{MyNavi
|zurück = [[OpenSCAD Benutzerhandbuch/_BOSL2-2D|Zurück]]
|buch = [[OpenSCAD Benutzerhandbuch/_BOSL2|BOSL2-Inhalt]]
|weiter = [[OpenSCAD Benutzerhandbuch/_BOSL2|Weiter]]
}}
<span id="grundlagen-tutorial-3d-formen"></span>
= Grundlagen-Tutorial: 3D-Formen =
<span id="primitive-grundformen"></span>
== Primitive (Grundformen) ==
OpenSCAD bietet 3 eingebaute 3D-Grundformen: <code>cube()</code>, <code>cylinder()</code> und <code>sphere()</code>. Die BOSL2-Bibliothek erweitert diese Formen und bietet Alternativen, sodass sie mehr Funktionen unterstützen und sich einfacher neu ausrichten lassen.
<span id="3d-würfel-quader"></span>
== 3D-Würfel (Quader) ==
BOSL2 überschreibt das eingebaute <code>cube()</code>-Modul. Es kann immer noch wie gewohnt verwendet werden:
<pre class="openscad">include <BOSL2/std.scad>
cube(100);</pre>
<pre class="openscad">include <BOSL2/std.scad>
cube(100, center=true);</pre>
<pre class="openscad">include <BOSL2/std.scad>
cube([50,40,20], center=true);</pre>
=== cube() mit anchors ===
Es wurde zudem erweitert, sodass du es verankern (<code>anchor</code>), drehen (<code>spin</code>), ausrichten (<code>orient</code>) und anhängen (<code>attach</code>) kannst. Du kannst <code>anchor=</code> ähnlich verwenden wie bei <code>rect()</code> oder <code>ellipse()</code>, mit dem Unterschied, dass du im 3D-Raum auch vertikal verankern kannst. Das ermöglicht die Verankerung an Flächen, Kanten und Ecken:
[[Datei:BOSL2-cube anchor show anchors.png|mini|zentriert|alternativtext=cube mit anchors|cube([50,40,20], anchor=BOTTOM+LEFT+FRONT) show_anchors();]]
<pre class="openscad">include <BOSL2/std.scad>
cube([50,40,20], anchor=BOTTOM+LEFT+FRONT) show_anchors();</pre>
=== cube() mit spin=<Winkel> ===
[[Datei:BOSL2-cube spin.png|mini|zentriert|alternativtext=cube([50,40,20], anchor=FRONT, spin=30);|cube([50,40,20], anchor=FRONT, spin=30);]]
Mit <code>spin=</code> kannst du das Objekt nach der Verankerung um die Z-Achse drehen:
<pre class="openscad">include <BOSL2/std.scad>
cube([50,40,20], anchor=FRONT, spin=30);</pre>
=== cube() mit orient=<Vectorkoordinaten-Oberseite> ===
3D-Objekte können auch ein <code>orient=</code>-Argument als Vektor erhalten, der in die Richtung zeigt, in die die Oberseite des Objekts gedreht werden soll.
[[Datei:BOSL2-cube orient.png|mini|zentriert|alternativtext=orient=RIGHT|#cube([50,40,20]) attach(TOP) #sphere(4); cube([50,40,20], orient=RIGHT) attach(TOP) color("magenta")sphere(4);]]
<pre class="openscad">include <BOSL2/std.scad>
#cube([50,40,20]) attach(TOP) #sphere(4);
cube([50,40,20], orient=RIGHT) attach(TOP) color("magenta")sphere(4);
</pre>
Im Beispiel wurde die Oberseite (TOP) nach rechts gedreht. Die an die Oberseite angehängten Kugeln dienen lediglich der Markierung und Orientierung.
=== cube mit anchor + spin + orient ===
Wenn du <code>anchor=</code>, <code>spin=</code> und <code>orient=</code> zusammen verwendest, wird zuerst die Verankerung ausgeführt, dann die Drehung und schließlich die Ausrichtung:
[[Datei:BOSL2-cube anchor spin orient.png|mini|zentriert|alternativtext=anchor, spin und orient am cube()|Veranschaulichung der Reihenfolge von anchor, spin und orient am cube()]]
<pre class="openscad">include <BOSL2/std.scad>
cube([50,40,20], anchor=FRONT);</pre>
<pre class="openscad">include <BOSL2/std.scad>
cube([50,40,20], anchor=FRONT, spin=45);</pre>
<pre class="openscad">include <BOSL2/std.scad>
cube([50,40,20], anchor=FRONT, spin=45, orient=UP+FWD+RIGHT);</pre>
== cuboid() ==
BOSL2 stellt ein <code>cuboid()</code>-Modul bereit, das <code>cube()</code> erweitert, indem es das Verrunden und Abschrägen von Kanten ermöglicht. Du kannst es ähnlich wie <code>cube()</code> verwenden, wobei <code>cuboid()</code> standardmäßig zentriert ist.
=== cuboid() mit rounding = <Radius> ===
Du kannst die Kanten mit dem Argument <code>rounding=</code> verrunden:
[[Datei:BOSL2-cuboid rounding.png|mini|zentriert|alternativtext=cuboid([100,80,60], rounding=10);|cuboid([100,80,60], rounding=10);]]
<pre class="openscad">
include <BOSL2/std.scad>
$fn=60;
cuboid([100,80,60], rounding=10);
</pre>
'''Ohne BOSL2''' müsste der Code für einen gerundeten Quader z.B. so aussehen:
<pre class="openscad">
minkowski() {
cube([80, 60, 40], center = true);
sphere(r = 10);
}
</pre>
Der BOSL2-Code ist leserlicher, da intuitiver nachvollziehbar.
=== cuboid() mit camfer ===
Ebenso kannst du die Kanten mit dem Argument <code>chamfer=</code> abschrägen:
[[Datei:BOSL2-cuboid camfer.png|mini|zentriert|alternativtext=cuboid([100,80,60], chamfer=10);|cuboid([100,80,60], chamfer=10);]]
<pre class="openscad">include <BOSL2/std.scad>
cuboid([100,80,60], chamfer=10);</pre>
Um dieses Ergebnis '''ohne BOSL2''' zu erreichen, müsste man einen deutlich umfangreicheren und schwerer verständlichen Code schreiben, den ich durch KI (Google Gemini) erstellen ließ:
<pre class="openscad">
module chamfered_cuboid_exact(size, c) {
inner_size = [size[0] - 2*c, size[1] - 2*c, size[2] - 2*c];
minkowski() {
cube(inner_size, center = true);
polyhedron(
points = [
[c, 0, 0], [-c, 0, 0],
[0, c, 0], [0, -c, 0],
[0, 0, c], [0, 0, -c]
],
faces = [
[0, 2, 4], [2, 1, 4], [1, 3, 4], [3, 0, 4],
[2, 0, 5], [1, 2, 5], [3, 1, 5], [0, 3, 5]
]
);
}
}
chamfered_cuboid_exact([100, 80, 60], 10);
</pre>
=== cuboid() mit edges=<Vektor> Verrundung ausgewählter Kanten ===
Du kannst auch nur bestimmte Kanten verrunden, indem du das Argument <code>edges=</code> verwendest. Es akzeptiert verschiedene Arten von Argumenten. Wenn du einen Vektor übergibst, der auf eine Fläche zeigt, werden nur die Kanten um diese Fläche herum verrundet:
[[Datei:BOSL2-cuboid rounding edges top.png|mini|zentriert|alternativtext=cuboid([100,80,60], rounding=20, edges=TOP);|cuboid([100,80,60], rounding=20, edges=TOP);]]
<pre class="openscad">include <BOSL2/std.scad>
cuboid([100,80,60], rounding=20, edges=TOP);</pre>
[[Datei:BOSL2-cuboid rounding edges RIGHT.png|mini|zentriert|alternativtext=rounding=20, edges=RIGHT|cuboid([100,80,60], rounding=20, edges=RIGHT);]]
<pre class="openscad">include <BOSL2/std.scad>
cuboid([100,80,60], rounding=20, edges=RIGHT);</pre>
Wenn du <code>edges=</code> einen Vektor übergibst, der auf eine Ecke zeigt, werden alle Kanten verrundet, die an dieser Ecke zusammenlaufen:
[[Datei:BOSL2-cuboid rounding edges RIGHT FRONT TOP.png|mini|zentriert|alternativtext=rounding=20, edges=RIGHT+FRONT+TOP|cuboid([100,80,60], rounding=20, edges=RIGHT+FRONT+TOP);]]
<pre class="openscad">include <BOSL2/std.scad>
cuboid([100,80,60], rounding=20, edges=RIGHT+FRONT+TOP);</pre>
Wenn du <code>edges=</code> einen Vektor übergibst, der auf eine Kante zeigt, wird nur diese spezifische Kante verrundet:
[[Datei:BOSL2-cuboid rounding edges RIGHT FRONT.png|mini|zentriert|alternativtext=rounding=10, edges=FRONT+TOP|cuboid([100,80,60], rounding=10, edges=FRONT+TOP);]]
<pre class="openscad">include <BOSL2/std.scad>
cuboid([100,80,60], rounding=10, edges=RIGHT+FRONT);</pre>
=== cuboid() mit edges=<"X"/"Y"/"Z"> Verrundung ausgewählter Kanten ===
Wenn du den String "X", "Y" oder "Z" übergibst, werden alle Kanten verrundet, die parallel zur jeweiligen Achse verlaufen:
[[Datei:BOSL2-cuboid rounding edges X.png|mini|zentriert|alternativtext=edges="X"|cuboid([100,80,60], rounding=10, edges="X");]]
<pre class="openscad">include <BOSL2/std.scad>
cuboid([100,80,60], rounding=10, edges="X");</pre>
[[Datei:BOSL2-cuboid rounding edges Y.png|mini|zentriert|alternativtext=edges="Y"|cuboid([100,80,60], rounding=10, edges="Y");]]
<pre class="openscad">include <BOSL2/std.scad>
cuboid([100,80,60], rounding=10, edges="Y");</pre>
[[Datei:BOSL2-cuboid rounding edges Z.png|mini|zentriert|alternativtext=edges="Z"|cuboid([100,80,60], rounding=10, edges="Z");]]
<pre class="openscad">include <BOSL2/std.scad>
cuboid([100,80,60], rounding=10, edges="Z");</pre>
=== cuboid() mit edges=<[Liste]> Verrundung ausgewählter Kanten ===
Wenn du eine Liste von Kanten-Spezifikationen übergibst, werden alle in der Liste referenzierten Kanten verrundet:
[[Datei:BOSL2-cuboid rounding edges Liste.png|mini|zentriert|alternativtext=edges=[BOTTOM,"Z"]|cuboid([100,80,60], rounding=10, edges=[BOTTOM,"Z"]);]]
<pre class="openscad">include <BOSL2/std.scad>
cuboid([100,80,60], camfer=10, edges=[BOTTOM,"Z"]);</pre>
=== except_edges= ===
Der Standardwert für <code>edges=</code> ist <code>EDGES_ALL</code>, also alle Kanten. Du kannst auch das Argument <code>except_edges=</code> verwenden, um Kanten anzugeben, die ''nicht'' verrundet werden sollen:
[[Datei:BOSL2-cuboid rounding edges except edges.png|mini|zentriert|alternativtext=except_edges|cuboid([100,80,60], rounding=10, except_edges=TOP+RIGHT+FRONT);]]
<pre class="openscad">include <BOSL2/std.scad>
cuboid([100,80,60], rounding=10, except_edges=TOP+RIGHT+FRONT);</pre>
Du kannst <code>except_edges=</code> dieselben Argumenttypen übergeben wie <code>edges=</code>:
<pre class="openscad">include <BOSL2/std.scad>
cuboid([100,80,60], rounding=10, except_edges=[BOTTOM,"Z",TOP+RIGHT]);</pre>
Du kannst sowohl <code>edges=</code> als auch <code>except_edges=</code> angeben, um die Kanten-Spezifikationen zu vereinfachen:
<pre class="openscad">include <BOSL2/std.scad>
cuboid([100,80,60], rounding=10, edges=[TOP,FRONT], except_edges=TOP+FRONT);</pre>
Das Abschrägen bestimmter Kanten funktioniert auf dieselbe Weise:
<pre class="openscad">include <BOSL2/std.scad>
cuboid([100,80,60], chamfer=10, edges=[TOP,FRONT], except_edges=TOP+FRONT);</pre>
<span id="3d-zylinder"></span>
=== 3D-Zylinder ===
BOSL2 überschreibt das eingebaute <code>cylinder()</code>-Modul. Es kann weiterhin wie gewohnt verwendet werden:
<pre class="openscad">include <BOSL2/std.scad>
cylinder(r=50,h=50);</pre>
<pre class="openscad">include <BOSL2/std.scad>
cylinder(r=50,h=50,center=true);</pre>
<pre class="openscad">include <BOSL2/std.scad>
cylinder(d=100,h=50,center=true);</pre>
<pre class="openscad">include <BOSL2/std.scad>
cylinder(d1=100,d2=80,h=50,center=true);</pre>
Du kannst es auch wie das <code>cuboid()</code>-Modul verankern, drehen, ausrichten und anhängen:
<pre class="openscad">include <BOSL2/std.scad>
cylinder(r=50, h=50, anchor=TOP+FRONT);</pre>
<pre class="openscad">include <BOSL2/std.scad>
cylinder(r=50, h=50, anchor=BOTTOM+LEFT);</pre>
<pre class="openscad">include <BOSL2/std.scad>
cylinder(r=50, h=50, anchor=BOTTOM+LEFT, spin=30);</pre>
<pre class="openscad">include <BOSL2/std.scad>
cylinder(r=50, h=50, anchor=BOTTOM, orient=UP+BACK+RIGHT);</pre>
BOSL2 bietet ein <code>cyl()</code>-Modul, das <code>cylinder()</code> um das Verrunden und Abschrägen von Kanten erweitert. Du kannst es ähnlich wie <code>cylinder()</code> verwenden, wobei <code>cyl()</code> den Zylinder standardmäßig zentriert.
<pre class="openscad">include <BOSL2/std.scad>
cyl(r=60, l=100);</pre>
<pre class="openscad">include <BOSL2/std.scad>
cyl(d=100, l=100);</pre>
<pre class="openscad">include <BOSL2/std.scad>
cyl(d=100, l=100, anchor=TOP);</pre>
Du kannst die Kanten mit dem Argument <code>rounding=</code> verrunden:
<pre class="openscad">include <BOSL2/std.scad>
cyl(d=100, l=100, rounding=20);</pre>
Ebenso kannst du die Kanten mit dem Argument <code>chamfer=</code> abschrägen:
<pre class="openscad">include <BOSL2/std.scad>
cyl(d=100, l=100, chamfer=10);</pre>
Du kannst das Verrunden und Abschrägen für jedes Ende auch individuell festlegen:
<pre class="openscad">include <BOSL2/std.scad>
cyl(d=100, l=100, rounding1=20);</pre>
<pre class="openscad">include <BOSL2/std.scad>
cyl(d=100, l=100, rounding2=20);</pre>
<pre class="openscad">include <BOSL2/std.scad>
cyl(d=100, l=100, chamfer1=10);</pre>
<pre class="openscad">include <BOSL2/std.scad>
cyl(d=100, l=100, chamfer2=10);</pre>
Du kannst Verrundungen und Abschrägungen sogar miteinander kombinieren:
<pre class="openscad">include <BOSL2/std.scad>
cyl(d=100, l=100, rounding1=20, chamfer2=10);</pre>
<pre class="openscad">include <BOSL2/std.scad>
cyl(d=100, l=100, rounding2=20, chamfer1=10);</pre>
<span id="3d-kugeln"></span>
=== 3D-Kugeln ===
BOSL2 überschreibt das eingebaute <code>sphere()</code>-Modul. Es kann weiterhin wie gewohnt verwendet werden:
<pre class="openscad">include <BOSL2/std.scad>
sphere(r=50);</pre>
<pre class="openscad">include <BOSL2/std.scad>
sphere(d=100);</pre>
Du kannst <code>sphere()</code>-Objekte ähnlich wie <code>cylinder()</code> und <code>cube()</code> verankern, drehen und ausrichten:
<pre class="openscad">include <BOSL2/std.scad>
sphere(d=100, anchor=FRONT);</pre>
<pre class="openscad">include <BOSL2/std.scad>
sphere(d=100, anchor=FRONT, spin=30);</pre>
<pre class="openscad">include <BOSL2/std.scad>
sphere(d=100, anchor=BOTTOM, orient=RIGHT+TOP);</pre>
BOSL2 bietet außerdem <code>spheroid()</code>, was <code>sphere()</code> um einige Funktionen wie die Argumente <code>circum=</code> und <code>style=</code> erweitert:
Mit dem Argument <code>circum=true</code> kannst du erzwingen, dass die Kugel die ideale Kugel umschreibt (umschließend), anstatt sie standardmäßig einzuschreiben (innenliegend):
<pre class="openscad">include <BOSL2/std.scad>
spheroid(d=100, circum=true);</pre>
Das Argument <code>style=</code> bestimmt, wie die Kugel konstruiert wird:
Der Stil "orig" entspricht der Konstruktion des eingebauten <code>sphere()</code>:
<pre class="openscad">include <BOSL2/std.scad>
spheroid(d=100, style="orig", $fn=20);</pre>
Der Stil "aligned" stellt sicher, dass an den äußeren Punkten jeder Achse ein Vertex (Eckpunkt) vorhanden ist, solange <code>$fn</code> ein Vielfaches von 4 ist.
<pre class="openscad">include <BOSL2/std.scad>
spheroid(d=100, style="aligned", $fn=20);</pre>
Der Stil "stagger" versetzt die Triangulierung (Vernetzung) der vertikalen Reihen:
<pre class="openscad">include <BOSL2/std.scad>
spheroid(d=100, style="stagger", $fn=20);</pre>
Der Stil "icosa" erzeugt annähernd gleich große Dreiecke für die gesamte Kugeloberfläche, basierend auf der Unterteilung eines Ikosaeders. Dieser Stil rundet das effektive <code>$fn</code> beim Konstruieren des Spheroids auf ein Vielfaches von 5:
<pre class="openscad">include <BOSL2/std.scad>
spheroid(d=100, style="icosa", $fn=20);</pre>
Der Stil "octa" erzeugt ebenfalls annähernd gleich große Dreiecke für die gesamte Oberfläche, basiert aber auf der Unterteilung eines Oktaeders. Das ist nützlich, da es Vertizes an den äußeren Punkten der Achsen garantiert. Dieser Stil rundet das effektive <code>$fn</code> auf ein Vielfaches von 4:
<pre class="openscad">include <BOSL2/std.scad>
spheroid(d=100, style="octa", $fn=20);</pre>
fxzgv8fafxc7zgcg2xpygkkm55ictme
1093548
1093547
2026-11-08T20:42:57Z
Jowi-ammerbuch
115360
/* cuboid() mit camfer */
1093548
wikitext
text/x-wiki
{{MyNavi
|zurück = [[OpenSCAD Benutzerhandbuch/_BOSL2-2D|Zurück]]
|buch = [[OpenSCAD Benutzerhandbuch/_BOSL2|BOSL2-Inhalt]]
|weiter = [[OpenSCAD Benutzerhandbuch/_BOSL2|Weiter]]
}}
<span id="grundlagen-tutorial-3d-formen"></span>
= Grundlagen-Tutorial: 3D-Formen =
<span id="primitive-grundformen"></span>
== Primitive (Grundformen) ==
OpenSCAD bietet 3 eingebaute 3D-Grundformen: <code>cube()</code>, <code>cylinder()</code> und <code>sphere()</code>. Die BOSL2-Bibliothek erweitert diese Formen und bietet Alternativen, sodass sie mehr Funktionen unterstützen und sich einfacher neu ausrichten lassen.
<span id="3d-würfel-quader"></span>
== 3D-Würfel (Quader) ==
BOSL2 überschreibt das eingebaute <code>cube()</code>-Modul. Es kann immer noch wie gewohnt verwendet werden:
<pre class="openscad">include <BOSL2/std.scad>
cube(100);</pre>
<pre class="openscad">include <BOSL2/std.scad>
cube(100, center=true);</pre>
<pre class="openscad">include <BOSL2/std.scad>
cube([50,40,20], center=true);</pre>
=== cube() mit anchors ===
Es wurde zudem erweitert, sodass du es verankern (<code>anchor</code>), drehen (<code>spin</code>), ausrichten (<code>orient</code>) und anhängen (<code>attach</code>) kannst. Du kannst <code>anchor=</code> ähnlich verwenden wie bei <code>rect()</code> oder <code>ellipse()</code>, mit dem Unterschied, dass du im 3D-Raum auch vertikal verankern kannst. Das ermöglicht die Verankerung an Flächen, Kanten und Ecken:
[[Datei:BOSL2-cube anchor show anchors.png|mini|zentriert|alternativtext=cube mit anchors|cube([50,40,20], anchor=BOTTOM+LEFT+FRONT) show_anchors();]]
<pre class="openscad">include <BOSL2/std.scad>
cube([50,40,20], anchor=BOTTOM+LEFT+FRONT) show_anchors();</pre>
=== cube() mit spin=<Winkel> ===
[[Datei:BOSL2-cube spin.png|mini|zentriert|alternativtext=cube([50,40,20], anchor=FRONT, spin=30);|cube([50,40,20], anchor=FRONT, spin=30);]]
Mit <code>spin=</code> kannst du das Objekt nach der Verankerung um die Z-Achse drehen:
<pre class="openscad">include <BOSL2/std.scad>
cube([50,40,20], anchor=FRONT, spin=30);</pre>
=== cube() mit orient=<Vectorkoordinaten-Oberseite> ===
3D-Objekte können auch ein <code>orient=</code>-Argument als Vektor erhalten, der in die Richtung zeigt, in die die Oberseite des Objekts gedreht werden soll.
[[Datei:BOSL2-cube orient.png|mini|zentriert|alternativtext=orient=RIGHT|#cube([50,40,20]) attach(TOP) #sphere(4); cube([50,40,20], orient=RIGHT) attach(TOP) color("magenta")sphere(4);]]
<pre class="openscad">include <BOSL2/std.scad>
#cube([50,40,20]) attach(TOP) #sphere(4);
cube([50,40,20], orient=RIGHT) attach(TOP) color("magenta")sphere(4);
</pre>
Im Beispiel wurde die Oberseite (TOP) nach rechts gedreht. Die an die Oberseite angehängten Kugeln dienen lediglich der Markierung und Orientierung.
=== cube mit anchor + spin + orient ===
Wenn du <code>anchor=</code>, <code>spin=</code> und <code>orient=</code> zusammen verwendest, wird zuerst die Verankerung ausgeführt, dann die Drehung und schließlich die Ausrichtung:
[[Datei:BOSL2-cube anchor spin orient.png|mini|zentriert|alternativtext=anchor, spin und orient am cube()|Veranschaulichung der Reihenfolge von anchor, spin und orient am cube()]]
<pre class="openscad">include <BOSL2/std.scad>
cube([50,40,20], anchor=FRONT);</pre>
<pre class="openscad">include <BOSL2/std.scad>
cube([50,40,20], anchor=FRONT, spin=45);</pre>
<pre class="openscad">include <BOSL2/std.scad>
cube([50,40,20], anchor=FRONT, spin=45, orient=UP+FWD+RIGHT);</pre>
== cuboid() ==
BOSL2 stellt ein <code>cuboid()</code>-Modul bereit, das <code>cube()</code> erweitert, indem es das Verrunden und Abschrägen von Kanten ermöglicht. Du kannst es ähnlich wie <code>cube()</code> verwenden, wobei <code>cuboid()</code> standardmäßig zentriert ist.
=== cuboid() mit rounding = <Radius> ===
Du kannst die Kanten mit dem Argument <code>rounding=</code> verrunden:
[[Datei:BOSL2-cuboid rounding.png|mini|zentriert|alternativtext=cuboid([100,80,60], rounding=10);|cuboid([100,80,60], rounding=10);]]
<pre class="openscad">
include <BOSL2/std.scad>
$fn=60;
cuboid([100,80,60], rounding=10);
</pre>
'''Ohne BOSL2''' müsste der Code für einen gerundeten Quader z.B. so aussehen:
<pre class="openscad">
minkowski() {
cube([80, 60, 40], center = true);
sphere(r = 10);
}
</pre>
Der BOSL2-Code ist leserlicher, da intuitiver nachvollziehbar.
=== cuboid() mit chamfer ===
Ebenso kannst du die Kanten mit dem Argument <code>chamfer=</code> abschrägen:
[[Datei:BOSL2-cuboid camfer.png|mini|zentriert|alternativtext=cuboid([100,80,60], chamfer=10);|cuboid([100,80,60], chamfer=10);]]
<pre class="openscad">include <BOSL2/std.scad>
cuboid([100,80,60], chamfer=10);</pre>
Um dieses Ergebnis '''ohne BOSL2''' zu erreichen, müsste man einen deutlich umfangreicheren und schwerer verständlichen Code schreiben, den ich durch KI (Google Gemini) erstellen ließ:
<pre class="openscad">
module chamfered_cuboid_exact(size, c) {
inner_size = [size[0] - 2*c, size[1] - 2*c, size[2] - 2*c];
minkowski() {
cube(inner_size, center = true);
polyhedron(
points = [
[c, 0, 0], [-c, 0, 0],
[0, c, 0], [0, -c, 0],
[0, 0, c], [0, 0, -c]
],
faces = [
[0, 2, 4], [2, 1, 4], [1, 3, 4], [3, 0, 4],
[2, 0, 5], [1, 2, 5], [3, 1, 5], [0, 3, 5]
]
);
}
}
chamfered_cuboid_exact([100, 80, 60], 10);
</pre>
=== cuboid() mit edges=<Vektor> Verrundung ausgewählter Kanten ===
Du kannst auch nur bestimmte Kanten verrunden, indem du das Argument <code>edges=</code> verwendest. Es akzeptiert verschiedene Arten von Argumenten. Wenn du einen Vektor übergibst, der auf eine Fläche zeigt, werden nur die Kanten um diese Fläche herum verrundet:
[[Datei:BOSL2-cuboid rounding edges top.png|mini|zentriert|alternativtext=cuboid([100,80,60], rounding=20, edges=TOP);|cuboid([100,80,60], rounding=20, edges=TOP);]]
<pre class="openscad">include <BOSL2/std.scad>
cuboid([100,80,60], rounding=20, edges=TOP);</pre>
[[Datei:BOSL2-cuboid rounding edges RIGHT.png|mini|zentriert|alternativtext=rounding=20, edges=RIGHT|cuboid([100,80,60], rounding=20, edges=RIGHT);]]
<pre class="openscad">include <BOSL2/std.scad>
cuboid([100,80,60], rounding=20, edges=RIGHT);</pre>
Wenn du <code>edges=</code> einen Vektor übergibst, der auf eine Ecke zeigt, werden alle Kanten verrundet, die an dieser Ecke zusammenlaufen:
[[Datei:BOSL2-cuboid rounding edges RIGHT FRONT TOP.png|mini|zentriert|alternativtext=rounding=20, edges=RIGHT+FRONT+TOP|cuboid([100,80,60], rounding=20, edges=RIGHT+FRONT+TOP);]]
<pre class="openscad">include <BOSL2/std.scad>
cuboid([100,80,60], rounding=20, edges=RIGHT+FRONT+TOP);</pre>
Wenn du <code>edges=</code> einen Vektor übergibst, der auf eine Kante zeigt, wird nur diese spezifische Kante verrundet:
[[Datei:BOSL2-cuboid rounding edges RIGHT FRONT.png|mini|zentriert|alternativtext=rounding=10, edges=FRONT+TOP|cuboid([100,80,60], rounding=10, edges=FRONT+TOP);]]
<pre class="openscad">include <BOSL2/std.scad>
cuboid([100,80,60], rounding=10, edges=RIGHT+FRONT);</pre>
=== cuboid() mit edges=<"X"/"Y"/"Z"> Verrundung ausgewählter Kanten ===
Wenn du den String "X", "Y" oder "Z" übergibst, werden alle Kanten verrundet, die parallel zur jeweiligen Achse verlaufen:
[[Datei:BOSL2-cuboid rounding edges X.png|mini|zentriert|alternativtext=edges="X"|cuboid([100,80,60], rounding=10, edges="X");]]
<pre class="openscad">include <BOSL2/std.scad>
cuboid([100,80,60], rounding=10, edges="X");</pre>
[[Datei:BOSL2-cuboid rounding edges Y.png|mini|zentriert|alternativtext=edges="Y"|cuboid([100,80,60], rounding=10, edges="Y");]]
<pre class="openscad">include <BOSL2/std.scad>
cuboid([100,80,60], rounding=10, edges="Y");</pre>
[[Datei:BOSL2-cuboid rounding edges Z.png|mini|zentriert|alternativtext=edges="Z"|cuboid([100,80,60], rounding=10, edges="Z");]]
<pre class="openscad">include <BOSL2/std.scad>
cuboid([100,80,60], rounding=10, edges="Z");</pre>
=== cuboid() mit edges=<[Liste]> Verrundung ausgewählter Kanten ===
Wenn du eine Liste von Kanten-Spezifikationen übergibst, werden alle in der Liste referenzierten Kanten verrundet:
[[Datei:BOSL2-cuboid rounding edges Liste.png|mini|zentriert|alternativtext=edges=[BOTTOM,"Z"]|cuboid([100,80,60], rounding=10, edges=[BOTTOM,"Z"]);]]
<pre class="openscad">include <BOSL2/std.scad>
cuboid([100,80,60], camfer=10, edges=[BOTTOM,"Z"]);</pre>
=== except_edges= ===
Der Standardwert für <code>edges=</code> ist <code>EDGES_ALL</code>, also alle Kanten. Du kannst auch das Argument <code>except_edges=</code> verwenden, um Kanten anzugeben, die ''nicht'' verrundet werden sollen:
[[Datei:BOSL2-cuboid rounding edges except edges.png|mini|zentriert|alternativtext=except_edges|cuboid([100,80,60], rounding=10, except_edges=TOP+RIGHT+FRONT);]]
<pre class="openscad">include <BOSL2/std.scad>
cuboid([100,80,60], rounding=10, except_edges=TOP+RIGHT+FRONT);</pre>
Du kannst <code>except_edges=</code> dieselben Argumenttypen übergeben wie <code>edges=</code>:
<pre class="openscad">include <BOSL2/std.scad>
cuboid([100,80,60], rounding=10, except_edges=[BOTTOM,"Z",TOP+RIGHT]);</pre>
Du kannst sowohl <code>edges=</code> als auch <code>except_edges=</code> angeben, um die Kanten-Spezifikationen zu vereinfachen:
<pre class="openscad">include <BOSL2/std.scad>
cuboid([100,80,60], rounding=10, edges=[TOP,FRONT], except_edges=TOP+FRONT);</pre>
Das Abschrägen bestimmter Kanten funktioniert auf dieselbe Weise:
<pre class="openscad">include <BOSL2/std.scad>
cuboid([100,80,60], chamfer=10, edges=[TOP,FRONT], except_edges=TOP+FRONT);</pre>
<span id="3d-zylinder"></span>
=== 3D-Zylinder ===
BOSL2 überschreibt das eingebaute <code>cylinder()</code>-Modul. Es kann weiterhin wie gewohnt verwendet werden:
<pre class="openscad">include <BOSL2/std.scad>
cylinder(r=50,h=50);</pre>
<pre class="openscad">include <BOSL2/std.scad>
cylinder(r=50,h=50,center=true);</pre>
<pre class="openscad">include <BOSL2/std.scad>
cylinder(d=100,h=50,center=true);</pre>
<pre class="openscad">include <BOSL2/std.scad>
cylinder(d1=100,d2=80,h=50,center=true);</pre>
Du kannst es auch wie das <code>cuboid()</code>-Modul verankern, drehen, ausrichten und anhängen:
<pre class="openscad">include <BOSL2/std.scad>
cylinder(r=50, h=50, anchor=TOP+FRONT);</pre>
<pre class="openscad">include <BOSL2/std.scad>
cylinder(r=50, h=50, anchor=BOTTOM+LEFT);</pre>
<pre class="openscad">include <BOSL2/std.scad>
cylinder(r=50, h=50, anchor=BOTTOM+LEFT, spin=30);</pre>
<pre class="openscad">include <BOSL2/std.scad>
cylinder(r=50, h=50, anchor=BOTTOM, orient=UP+BACK+RIGHT);</pre>
BOSL2 bietet ein <code>cyl()</code>-Modul, das <code>cylinder()</code> um das Verrunden und Abschrägen von Kanten erweitert. Du kannst es ähnlich wie <code>cylinder()</code> verwenden, wobei <code>cyl()</code> den Zylinder standardmäßig zentriert.
<pre class="openscad">include <BOSL2/std.scad>
cyl(r=60, l=100);</pre>
<pre class="openscad">include <BOSL2/std.scad>
cyl(d=100, l=100);</pre>
<pre class="openscad">include <BOSL2/std.scad>
cyl(d=100, l=100, anchor=TOP);</pre>
Du kannst die Kanten mit dem Argument <code>rounding=</code> verrunden:
<pre class="openscad">include <BOSL2/std.scad>
cyl(d=100, l=100, rounding=20);</pre>
Ebenso kannst du die Kanten mit dem Argument <code>chamfer=</code> abschrägen:
<pre class="openscad">include <BOSL2/std.scad>
cyl(d=100, l=100, chamfer=10);</pre>
Du kannst das Verrunden und Abschrägen für jedes Ende auch individuell festlegen:
<pre class="openscad">include <BOSL2/std.scad>
cyl(d=100, l=100, rounding1=20);</pre>
<pre class="openscad">include <BOSL2/std.scad>
cyl(d=100, l=100, rounding2=20);</pre>
<pre class="openscad">include <BOSL2/std.scad>
cyl(d=100, l=100, chamfer1=10);</pre>
<pre class="openscad">include <BOSL2/std.scad>
cyl(d=100, l=100, chamfer2=10);</pre>
Du kannst Verrundungen und Abschrägungen sogar miteinander kombinieren:
<pre class="openscad">include <BOSL2/std.scad>
cyl(d=100, l=100, rounding1=20, chamfer2=10);</pre>
<pre class="openscad">include <BOSL2/std.scad>
cyl(d=100, l=100, rounding2=20, chamfer1=10);</pre>
<span id="3d-kugeln"></span>
=== 3D-Kugeln ===
BOSL2 überschreibt das eingebaute <code>sphere()</code>-Modul. Es kann weiterhin wie gewohnt verwendet werden:
<pre class="openscad">include <BOSL2/std.scad>
sphere(r=50);</pre>
<pre class="openscad">include <BOSL2/std.scad>
sphere(d=100);</pre>
Du kannst <code>sphere()</code>-Objekte ähnlich wie <code>cylinder()</code> und <code>cube()</code> verankern, drehen und ausrichten:
<pre class="openscad">include <BOSL2/std.scad>
sphere(d=100, anchor=FRONT);</pre>
<pre class="openscad">include <BOSL2/std.scad>
sphere(d=100, anchor=FRONT, spin=30);</pre>
<pre class="openscad">include <BOSL2/std.scad>
sphere(d=100, anchor=BOTTOM, orient=RIGHT+TOP);</pre>
BOSL2 bietet außerdem <code>spheroid()</code>, was <code>sphere()</code> um einige Funktionen wie die Argumente <code>circum=</code> und <code>style=</code> erweitert:
Mit dem Argument <code>circum=true</code> kannst du erzwingen, dass die Kugel die ideale Kugel umschreibt (umschließend), anstatt sie standardmäßig einzuschreiben (innenliegend):
<pre class="openscad">include <BOSL2/std.scad>
spheroid(d=100, circum=true);</pre>
Das Argument <code>style=</code> bestimmt, wie die Kugel konstruiert wird:
Der Stil "orig" entspricht der Konstruktion des eingebauten <code>sphere()</code>:
<pre class="openscad">include <BOSL2/std.scad>
spheroid(d=100, style="orig", $fn=20);</pre>
Der Stil "aligned" stellt sicher, dass an den äußeren Punkten jeder Achse ein Vertex (Eckpunkt) vorhanden ist, solange <code>$fn</code> ein Vielfaches von 4 ist.
<pre class="openscad">include <BOSL2/std.scad>
spheroid(d=100, style="aligned", $fn=20);</pre>
Der Stil "stagger" versetzt die Triangulierung (Vernetzung) der vertikalen Reihen:
<pre class="openscad">include <BOSL2/std.scad>
spheroid(d=100, style="stagger", $fn=20);</pre>
Der Stil "icosa" erzeugt annähernd gleich große Dreiecke für die gesamte Kugeloberfläche, basierend auf der Unterteilung eines Ikosaeders. Dieser Stil rundet das effektive <code>$fn</code> beim Konstruieren des Spheroids auf ein Vielfaches von 5:
<pre class="openscad">include <BOSL2/std.scad>
spheroid(d=100, style="icosa", $fn=20);</pre>
Der Stil "octa" erzeugt ebenfalls annähernd gleich große Dreiecke für die gesamte Oberfläche, basiert aber auf der Unterteilung eines Oktaeders. Das ist nützlich, da es Vertizes an den äußeren Punkten der Achsen garantiert. Dieser Stil rundet das effektive <code>$fn</code> auf ein Vielfaches von 4:
<pre class="openscad">include <BOSL2/std.scad>
spheroid(d=100, style="octa", $fn=20);</pre>
dyfjixupsxa3a1d5aps2wfzx9edwuxf
1093549
1093548
2026-11-08T20:47:54Z
Jowi-ammerbuch
115360
/* cuboid() mit chamfer */
1093549
wikitext
text/x-wiki
{{MyNavi
|zurück = [[OpenSCAD Benutzerhandbuch/_BOSL2-2D|Zurück]]
|buch = [[OpenSCAD Benutzerhandbuch/_BOSL2|BOSL2-Inhalt]]
|weiter = [[OpenSCAD Benutzerhandbuch/_BOSL2|Weiter]]
}}
<span id="grundlagen-tutorial-3d-formen"></span>
= Grundlagen-Tutorial: 3D-Formen =
<span id="primitive-grundformen"></span>
== Primitive (Grundformen) ==
OpenSCAD bietet 3 eingebaute 3D-Grundformen: <code>cube()</code>, <code>cylinder()</code> und <code>sphere()</code>. Die BOSL2-Bibliothek erweitert diese Formen und bietet Alternativen, sodass sie mehr Funktionen unterstützen und sich einfacher neu ausrichten lassen.
<span id="3d-würfel-quader"></span>
== 3D-Würfel (Quader) ==
BOSL2 überschreibt das eingebaute <code>cube()</code>-Modul. Es kann immer noch wie gewohnt verwendet werden:
<pre class="openscad">include <BOSL2/std.scad>
cube(100);</pre>
<pre class="openscad">include <BOSL2/std.scad>
cube(100, center=true);</pre>
<pre class="openscad">include <BOSL2/std.scad>
cube([50,40,20], center=true);</pre>
=== cube() mit anchors ===
Es wurde zudem erweitert, sodass du es verankern (<code>anchor</code>), drehen (<code>spin</code>), ausrichten (<code>orient</code>) und anhängen (<code>attach</code>) kannst. Du kannst <code>anchor=</code> ähnlich verwenden wie bei <code>rect()</code> oder <code>ellipse()</code>, mit dem Unterschied, dass du im 3D-Raum auch vertikal verankern kannst. Das ermöglicht die Verankerung an Flächen, Kanten und Ecken:
[[Datei:BOSL2-cube anchor show anchors.png|mini|zentriert|alternativtext=cube mit anchors|cube([50,40,20], anchor=BOTTOM+LEFT+FRONT) show_anchors();]]
<pre class="openscad">include <BOSL2/std.scad>
cube([50,40,20], anchor=BOTTOM+LEFT+FRONT) show_anchors();</pre>
=== cube() mit spin=<Winkel> ===
[[Datei:BOSL2-cube spin.png|mini|zentriert|alternativtext=cube([50,40,20], anchor=FRONT, spin=30);|cube([50,40,20], anchor=FRONT, spin=30);]]
Mit <code>spin=</code> kannst du das Objekt nach der Verankerung um die Z-Achse drehen:
<pre class="openscad">include <BOSL2/std.scad>
cube([50,40,20], anchor=FRONT, spin=30);</pre>
=== cube() mit orient=<Vectorkoordinaten-Oberseite> ===
3D-Objekte können auch ein <code>orient=</code>-Argument als Vektor erhalten, der in die Richtung zeigt, in die die Oberseite des Objekts gedreht werden soll.
[[Datei:BOSL2-cube orient.png|mini|zentriert|alternativtext=orient=RIGHT|#cube([50,40,20]) attach(TOP) #sphere(4); cube([50,40,20], orient=RIGHT) attach(TOP) color("magenta")sphere(4);]]
<pre class="openscad">include <BOSL2/std.scad>
#cube([50,40,20]) attach(TOP) #sphere(4);
cube([50,40,20], orient=RIGHT) attach(TOP) color("magenta")sphere(4);
</pre>
Im Beispiel wurde die Oberseite (TOP) nach rechts gedreht. Die an die Oberseite angehängten Kugeln dienen lediglich der Markierung und Orientierung.
=== cube mit anchor + spin + orient ===
Wenn du <code>anchor=</code>, <code>spin=</code> und <code>orient=</code> zusammen verwendest, wird zuerst die Verankerung ausgeführt, dann die Drehung und schließlich die Ausrichtung:
[[Datei:BOSL2-cube anchor spin orient.png|mini|zentriert|alternativtext=anchor, spin und orient am cube()|Veranschaulichung der Reihenfolge von anchor, spin und orient am cube()]]
<pre class="openscad">include <BOSL2/std.scad>
cube([50,40,20], anchor=FRONT);</pre>
<pre class="openscad">include <BOSL2/std.scad>
cube([50,40,20], anchor=FRONT, spin=45);</pre>
<pre class="openscad">include <BOSL2/std.scad>
cube([50,40,20], anchor=FRONT, spin=45, orient=UP+FWD+RIGHT);</pre>
== cuboid() ==
BOSL2 stellt ein <code>cuboid()</code>-Modul bereit, das <code>cube()</code> erweitert, indem es das Verrunden und Abschrägen von Kanten ermöglicht. Du kannst es ähnlich wie <code>cube()</code> verwenden, wobei <code>cuboid()</code> standardmäßig zentriert ist.
=== cuboid() mit rounding = <Radius> ===
Du kannst die Kanten mit dem Argument <code>rounding=</code> verrunden:
[[Datei:BOSL2-cuboid rounding.png|mini|zentriert|alternativtext=cuboid([100,80,60], rounding=10);|cuboid([100,80,60], rounding=10);]]
<pre class="openscad">
include <BOSL2/std.scad>
$fn=60;
cuboid([100,80,60], rounding=10);
</pre>
'''Ohne BOSL2''' müsste der Code für einen gerundeten Quader z.B. so aussehen:
<pre class="openscad">
minkowski() {
cube([80, 60, 40], center = true);
sphere(r = 10);
}
</pre>
Der BOSL2-Code ist leserlicher, da intuitiver nachvollziehbar.
=== cuboid() mit chamfer ===
Ebenso kannst du die Kanten mit dem Argument <code>chamfer=</code> abschrägen:
[[Datei:BOSL2-cuboid camfer.png|mini|zentriert|alternativtext=cuboid([100,80,60], chamfer=10);|cuboid([100,80,60], chamfer=10);]]
<pre class="openscad">include <BOSL2/std.scad>
cuboid([100,80,60], chamfer=10);</pre>
Um diese ''Fasen'' (abgeschrägte Kanten) '''ohne BOSL2''' zu erreichen, müsste man einen deutlich umfangreicheren und schwerer verständlichen Code schreiben, den ich durch KI (Google Gemini) erstellen ließ:
<pre class="openscad">
module chamfered_cuboid_exact(size, c) {
inner_size = [size[0] - 2*c, size[1] - 2*c, size[2] - 2*c];
minkowski() {
cube(inner_size, center = true);
polyhedron(
points = [
[c, 0, 0], [-c, 0, 0],
[0, c, 0], [0, -c, 0],
[0, 0, c], [0, 0, -c]
],
faces = [
[0, 2, 4], [2, 1, 4], [1, 3, 4], [3, 0, 4],
[2, 0, 5], [1, 2, 5], [3, 1, 5], [0, 3, 5]
]
);
}
}
chamfered_cuboid_exact([100, 80, 60], 10);
</pre>
=== cuboid() mit edges=<Vektor> Verrundung ausgewählter Kanten ===
Du kannst auch nur bestimmte Kanten verrunden, indem du das Argument <code>edges=</code> verwendest. Es akzeptiert verschiedene Arten von Argumenten. Wenn du einen Vektor übergibst, der auf eine Fläche zeigt, werden nur die Kanten um diese Fläche herum verrundet:
[[Datei:BOSL2-cuboid rounding edges top.png|mini|zentriert|alternativtext=cuboid([100,80,60], rounding=20, edges=TOP);|cuboid([100,80,60], rounding=20, edges=TOP);]]
<pre class="openscad">include <BOSL2/std.scad>
cuboid([100,80,60], rounding=20, edges=TOP);</pre>
[[Datei:BOSL2-cuboid rounding edges RIGHT.png|mini|zentriert|alternativtext=rounding=20, edges=RIGHT|cuboid([100,80,60], rounding=20, edges=RIGHT);]]
<pre class="openscad">include <BOSL2/std.scad>
cuboid([100,80,60], rounding=20, edges=RIGHT);</pre>
Wenn du <code>edges=</code> einen Vektor übergibst, der auf eine Ecke zeigt, werden alle Kanten verrundet, die an dieser Ecke zusammenlaufen:
[[Datei:BOSL2-cuboid rounding edges RIGHT FRONT TOP.png|mini|zentriert|alternativtext=rounding=20, edges=RIGHT+FRONT+TOP|cuboid([100,80,60], rounding=20, edges=RIGHT+FRONT+TOP);]]
<pre class="openscad">include <BOSL2/std.scad>
cuboid([100,80,60], rounding=20, edges=RIGHT+FRONT+TOP);</pre>
Wenn du <code>edges=</code> einen Vektor übergibst, der auf eine Kante zeigt, wird nur diese spezifische Kante verrundet:
[[Datei:BOSL2-cuboid rounding edges RIGHT FRONT.png|mini|zentriert|alternativtext=rounding=10, edges=FRONT+TOP|cuboid([100,80,60], rounding=10, edges=FRONT+TOP);]]
<pre class="openscad">include <BOSL2/std.scad>
cuboid([100,80,60], rounding=10, edges=RIGHT+FRONT);</pre>
=== cuboid() mit edges=<"X"/"Y"/"Z"> Verrundung ausgewählter Kanten ===
Wenn du den String "X", "Y" oder "Z" übergibst, werden alle Kanten verrundet, die parallel zur jeweiligen Achse verlaufen:
[[Datei:BOSL2-cuboid rounding edges X.png|mini|zentriert|alternativtext=edges="X"|cuboid([100,80,60], rounding=10, edges="X");]]
<pre class="openscad">include <BOSL2/std.scad>
cuboid([100,80,60], rounding=10, edges="X");</pre>
[[Datei:BOSL2-cuboid rounding edges Y.png|mini|zentriert|alternativtext=edges="Y"|cuboid([100,80,60], rounding=10, edges="Y");]]
<pre class="openscad">include <BOSL2/std.scad>
cuboid([100,80,60], rounding=10, edges="Y");</pre>
[[Datei:BOSL2-cuboid rounding edges Z.png|mini|zentriert|alternativtext=edges="Z"|cuboid([100,80,60], rounding=10, edges="Z");]]
<pre class="openscad">include <BOSL2/std.scad>
cuboid([100,80,60], rounding=10, edges="Z");</pre>
=== cuboid() mit edges=<[Liste]> Verrundung ausgewählter Kanten ===
Wenn du eine Liste von Kanten-Spezifikationen übergibst, werden alle in der Liste referenzierten Kanten verrundet:
[[Datei:BOSL2-cuboid rounding edges Liste.png|mini|zentriert|alternativtext=edges=[BOTTOM,"Z"]|cuboid([100,80,60], rounding=10, edges=[BOTTOM,"Z"]);]]
<pre class="openscad">include <BOSL2/std.scad>
cuboid([100,80,60], camfer=10, edges=[BOTTOM,"Z"]);</pre>
=== except_edges= ===
Der Standardwert für <code>edges=</code> ist <code>EDGES_ALL</code>, also alle Kanten. Du kannst auch das Argument <code>except_edges=</code> verwenden, um Kanten anzugeben, die ''nicht'' verrundet werden sollen:
[[Datei:BOSL2-cuboid rounding edges except edges.png|mini|zentriert|alternativtext=except_edges|cuboid([100,80,60], rounding=10, except_edges=TOP+RIGHT+FRONT);]]
<pre class="openscad">include <BOSL2/std.scad>
cuboid([100,80,60], rounding=10, except_edges=TOP+RIGHT+FRONT);</pre>
Du kannst <code>except_edges=</code> dieselben Argumenttypen übergeben wie <code>edges=</code>:
<pre class="openscad">include <BOSL2/std.scad>
cuboid([100,80,60], rounding=10, except_edges=[BOTTOM,"Z",TOP+RIGHT]);</pre>
Du kannst sowohl <code>edges=</code> als auch <code>except_edges=</code> angeben, um die Kanten-Spezifikationen zu vereinfachen:
<pre class="openscad">include <BOSL2/std.scad>
cuboid([100,80,60], rounding=10, edges=[TOP,FRONT], except_edges=TOP+FRONT);</pre>
Das Abschrägen bestimmter Kanten funktioniert auf dieselbe Weise:
<pre class="openscad">include <BOSL2/std.scad>
cuboid([100,80,60], chamfer=10, edges=[TOP,FRONT], except_edges=TOP+FRONT);</pre>
<span id="3d-zylinder"></span>
=== 3D-Zylinder ===
BOSL2 überschreibt das eingebaute <code>cylinder()</code>-Modul. Es kann weiterhin wie gewohnt verwendet werden:
<pre class="openscad">include <BOSL2/std.scad>
cylinder(r=50,h=50);</pre>
<pre class="openscad">include <BOSL2/std.scad>
cylinder(r=50,h=50,center=true);</pre>
<pre class="openscad">include <BOSL2/std.scad>
cylinder(d=100,h=50,center=true);</pre>
<pre class="openscad">include <BOSL2/std.scad>
cylinder(d1=100,d2=80,h=50,center=true);</pre>
Du kannst es auch wie das <code>cuboid()</code>-Modul verankern, drehen, ausrichten und anhängen:
<pre class="openscad">include <BOSL2/std.scad>
cylinder(r=50, h=50, anchor=TOP+FRONT);</pre>
<pre class="openscad">include <BOSL2/std.scad>
cylinder(r=50, h=50, anchor=BOTTOM+LEFT);</pre>
<pre class="openscad">include <BOSL2/std.scad>
cylinder(r=50, h=50, anchor=BOTTOM+LEFT, spin=30);</pre>
<pre class="openscad">include <BOSL2/std.scad>
cylinder(r=50, h=50, anchor=BOTTOM, orient=UP+BACK+RIGHT);</pre>
BOSL2 bietet ein <code>cyl()</code>-Modul, das <code>cylinder()</code> um das Verrunden und Abschrägen von Kanten erweitert. Du kannst es ähnlich wie <code>cylinder()</code> verwenden, wobei <code>cyl()</code> den Zylinder standardmäßig zentriert.
<pre class="openscad">include <BOSL2/std.scad>
cyl(r=60, l=100);</pre>
<pre class="openscad">include <BOSL2/std.scad>
cyl(d=100, l=100);</pre>
<pre class="openscad">include <BOSL2/std.scad>
cyl(d=100, l=100, anchor=TOP);</pre>
Du kannst die Kanten mit dem Argument <code>rounding=</code> verrunden:
<pre class="openscad">include <BOSL2/std.scad>
cyl(d=100, l=100, rounding=20);</pre>
Ebenso kannst du die Kanten mit dem Argument <code>chamfer=</code> abschrägen:
<pre class="openscad">include <BOSL2/std.scad>
cyl(d=100, l=100, chamfer=10);</pre>
Du kannst das Verrunden und Abschrägen für jedes Ende auch individuell festlegen:
<pre class="openscad">include <BOSL2/std.scad>
cyl(d=100, l=100, rounding1=20);</pre>
<pre class="openscad">include <BOSL2/std.scad>
cyl(d=100, l=100, rounding2=20);</pre>
<pre class="openscad">include <BOSL2/std.scad>
cyl(d=100, l=100, chamfer1=10);</pre>
<pre class="openscad">include <BOSL2/std.scad>
cyl(d=100, l=100, chamfer2=10);</pre>
Du kannst Verrundungen und Abschrägungen sogar miteinander kombinieren:
<pre class="openscad">include <BOSL2/std.scad>
cyl(d=100, l=100, rounding1=20, chamfer2=10);</pre>
<pre class="openscad">include <BOSL2/std.scad>
cyl(d=100, l=100, rounding2=20, chamfer1=10);</pre>
<span id="3d-kugeln"></span>
=== 3D-Kugeln ===
BOSL2 überschreibt das eingebaute <code>sphere()</code>-Modul. Es kann weiterhin wie gewohnt verwendet werden:
<pre class="openscad">include <BOSL2/std.scad>
sphere(r=50);</pre>
<pre class="openscad">include <BOSL2/std.scad>
sphere(d=100);</pre>
Du kannst <code>sphere()</code>-Objekte ähnlich wie <code>cylinder()</code> und <code>cube()</code> verankern, drehen und ausrichten:
<pre class="openscad">include <BOSL2/std.scad>
sphere(d=100, anchor=FRONT);</pre>
<pre class="openscad">include <BOSL2/std.scad>
sphere(d=100, anchor=FRONT, spin=30);</pre>
<pre class="openscad">include <BOSL2/std.scad>
sphere(d=100, anchor=BOTTOM, orient=RIGHT+TOP);</pre>
BOSL2 bietet außerdem <code>spheroid()</code>, was <code>sphere()</code> um einige Funktionen wie die Argumente <code>circum=</code> und <code>style=</code> erweitert:
Mit dem Argument <code>circum=true</code> kannst du erzwingen, dass die Kugel die ideale Kugel umschreibt (umschließend), anstatt sie standardmäßig einzuschreiben (innenliegend):
<pre class="openscad">include <BOSL2/std.scad>
spheroid(d=100, circum=true);</pre>
Das Argument <code>style=</code> bestimmt, wie die Kugel konstruiert wird:
Der Stil "orig" entspricht der Konstruktion des eingebauten <code>sphere()</code>:
<pre class="openscad">include <BOSL2/std.scad>
spheroid(d=100, style="orig", $fn=20);</pre>
Der Stil "aligned" stellt sicher, dass an den äußeren Punkten jeder Achse ein Vertex (Eckpunkt) vorhanden ist, solange <code>$fn</code> ein Vielfaches von 4 ist.
<pre class="openscad">include <BOSL2/std.scad>
spheroid(d=100, style="aligned", $fn=20);</pre>
Der Stil "stagger" versetzt die Triangulierung (Vernetzung) der vertikalen Reihen:
<pre class="openscad">include <BOSL2/std.scad>
spheroid(d=100, style="stagger", $fn=20);</pre>
Der Stil "icosa" erzeugt annähernd gleich große Dreiecke für die gesamte Kugeloberfläche, basierend auf der Unterteilung eines Ikosaeders. Dieser Stil rundet das effektive <code>$fn</code> beim Konstruieren des Spheroids auf ein Vielfaches von 5:
<pre class="openscad">include <BOSL2/std.scad>
spheroid(d=100, style="icosa", $fn=20);</pre>
Der Stil "octa" erzeugt ebenfalls annähernd gleich große Dreiecke für die gesamte Oberfläche, basiert aber auf der Unterteilung eines Oktaeders. Das ist nützlich, da es Vertizes an den äußeren Punkten der Achsen garantiert. Dieser Stil rundet das effektive <code>$fn</code> auf ein Vielfaches von 4:
<pre class="openscad">include <BOSL2/std.scad>
spheroid(d=100, style="octa", $fn=20);</pre>
edzyjquxwwa5xrkco2bndtru65s8xxq
Traktorenlexikon: Allis-Chalmers HD - 10
0
123392
1093526
2026-11-08T13:26:56Z
Baupit
56622
Neue Seite (vgl. [[WB:AZ]])
1093526
wikitext
text/x-wiki
{{:Traktorenlexikon: Navigation |HERSTELLER-LINK=Traktorenlexikon: Allis-Chalmers |HERSTELLER= Allis-Chalmers}}
{{:Traktorenlexikon: Modell-Infobox
| HERSTELLER = ALLIS-CHALMERS
| MODELLREIHE = HD-Baureihe
| MODELL = HD-10 (W)
| BILD =
| BILDBESCHREIBUNG =
| BAUWEISE = Blockbauweise
| PRODUKTIONSBEGINN = 1940
| PRODUKTIONSENDE = 1950
| STÜCKZAHL = 10.197
| EIGENGEWICHT = 9.507 (W: 9.811)
| LÄNGE = 3.821
| BREITE = 2.100
| HÖHE = 1.908
| RADSTAND =
| BODENFREIHEIT = 295
| SPURWEITE = 1.575 (W:1.880)
| SPURWEITE VORNE =
| SPURWEITE HINTEN =
| WENDERADIUS MIT LENKBREMSE = 2.489 (W: 2.642)
| WENDERADIUS OHNE LENKBREMSE =
| KETTEN = 6.402 x 457
| LEISTUNG KW = 64,7
| LEISTUNG PS = 88
| NENNDREHZAHL = 1.600
| ZYLINDER = 4
| HUBRAUM = 4.649
| DREHMOMENTANSTIEG =
| KRAFTSTOFF = Diesel
| KÜHLSYSTEM = Wasserkühlung
| ANTRIEBSTYP = Kettenantrieb
| GETRIEBE = 6 V/2 R
| HÖCHSTGESCHWINDIGKEIT = 9,7
| KATEGORIESORTIERUNG = Raupenschlepper
}}
Der ALLIS-CHALMERS HD-10 wurde im Jahr 1940 vorgestellt und war für schwere Arbeiten in der Landwirtschaft konzipiert. Das eingesetzte wassergekühlte Vierzylinder-Zweitakt-DETROIT-DIESEL-Aggregat war ein robustes und leistungsstarkes Aggregat. Verblockt wurde dieses Aggregat mit einem 6/2-Schaltmuffengetriebe. Der ALLIS-CHALMERS HD-10 war in einer Standard- und einer breiten Ausführung erhältlich. Der breiten Ausführung wurde in der Typenbezeichnung ein "W" für Wide angehängt. 415 Exemplare des ALLIS-CHALMERS HD-10 W wurden im zweiten Weltkrieg, im Rahmen des Leih- und Pachtgesetzes an die Sowjetunion geliefert.
==Motor==
* DETRIOT-DIESEL, Typ: 4-71, stehender wassergekühlter Zweitakt-Vierzylinder-Dieselmotor mit Druckschmierung mittels Zahnradpumpe, GENERAL-MOTORS-Pumpe-Düse-System, ALLIS-CHALMERS Kraftstofffilter, Zylindereinzeleinspritzung, zahnradgetriebene Nockenwelle, Zahnradkraftstoffpumpe, zahnradgetriebene Nockenwelle, ALLIS-CHALMERS Ölfilter, trockene Zylinderlaufbuchsen, GENERAL-MOTORS-Einspritzpumpe, HANDY-Drehzahlregler, unidirektionalen Spülung durch zahnradgetriebenes ROOTS-Gebläse, fünffach-gelagerte Kurbelwelle, UNITED-Ölbadluftfilter, Vierringkolben und Lamellenkühler mit BISHOP & BABCOCK Thermostat.
* Bohrung = 107,95 mm, Hub = 127 mm
* Verdichtungsverhältnis = 16:1
* Drehmoment = 462 Nm bei 900 U/min.
* Kolbengeschwindigkeit = 6,77 m/s
* Geregelter Drehzahlbereich = 450 bis 1.750 U/min.
* Öldruck = 0,35 bis 2,41 bar
* Fördermenge der Kraftstoffpumpe = 113,6 l/h bei 3,45 bar und Nenndrehzahl
* Max. Einspritzdruck = 138 bar
* Leistung an der Deichsel = 83,3 DIN-PS
* Leistung an der Riemenscheibe = 99,8 DIN-PS
==Kupplung==
* Handhebel-betätigte, trockene ROCKFORD-Einscheibenkupplung, im Verbund mit einer Getriebebremse
==Getriebe==
* Im Ölbad laufendes, mechanisches Schaltmuffengetriebe
* Wechselgetriebe mit sechs Vorwärts- und einem Rückwärtsgang
* Der Rückwärtsgang wird mittels eines Reversier-Elements in die Stufen: L und H unterteilt
6 Vorwärts- und 2 Rückwärtsgang
==Geschwindigkeiten vor- und rückwärts==
{| class="wikitable"
|-
! bei Motordrehzahl (U/min) !! 1.600
|-
| 1.Gang || 2,72 km/h
|-
| 2.Gang || 3,32 km/h
|-
| 3.Gang || 4,31 km/h
|-
| 4.Gang || 6,08 km/h
|-
| 5.Gang || 7,44 km/h
|-
| 6.Gang || 9,70 km/h
|-
| 1.Rückwärtsgang-LOW || 2,99 km/h
|-
| 3.Rückwärtsgang-HIGH || 6,71 km/h
|-
|}
==Zapfwelle==
* Optional mechanisch-betätigte Getriebezapfwelle, mit nicht umkehrbarem Untersetzungsgetriebe
Drehzahl = 574 U/min. mit Nenndrehzahl
* Optional mechanisch-betätigte Getriebezapfwelle, mit direktem Antrieb
Drehzahlen = 192 U/min. und 430 U/min. mit Nenndrehzahl
* Optional mechanisch-betätigte Getriebezapfwelle, mit umkehrbarem Untersetzungsgetriebe
Drehzahlen im Uhrzeigersinn = 148 U/min. und gegen den Uhrzeigersinn = 334 U/min. mit Nenndrehzahl
* Optional Riemenscheibe mit 340 mm Durchmesser und 254 mm Breite
929 und 412 U/min. mit Nenndrehzahl
* Riemengeschwindigkeit = 16,5 und 7,3 m/sec.
==Bremsen==
* Mechanisch-betätigte Band-Trommelbremse, mittels zwei separater Pedale auf die Ketten wirkend
==Achsen==
* Zwei Ketten mit 32 Gliedern, mit je fünf Rollen und einer Stützrolle (Ab Seriennummer 5574 = 34 Gliedern, mit je sechs Rollen und einer Stützrolle)
Spurweite = 1.575 mm (Ausführung-W = 1.880 mm)
* Gefederter Kettenrahmen mit vorderem Stabilisator
* Starre Hinterachse mit Stirnradgetriebe und Endantrieb
* Achswelle läuft in einem separaten Endantriebsgehäuse, auf der Innenseite der Welle sitzt das große Antriebszahnrad
==Lenkung==
"Lenkkupplungs-Bremssystem:"
* Jede Kettenseite besitzt eine eigene, separate Kupplung, die sich in einem hinteren Gehäuse des Endantriebs befindet.
* Kupplungspaket entspricht wechselnd-angeordneten vier Radscheiben und drei Trennscheiben
* Betätigt man einen der beiden Lenkhebel, wird die entsprechende Kupplung über ein Gestänge und Ausrücklager getrennt.
* Die Kette verliert ihren Antrieb und rollt nur noch im Leerlauf mit, wodurch das Fahrzeug in eine Richtung lenkt
* Für enge Kurvenfahrten oder auf der Stelle wenden, wird das System durch mechanische Bremsen ergänzt
Lenkkupplung mit je 15 Faser- und 15 Stahlscheiben (Außendurchmesser = 347,5 mm)
* Reibungsfläche je Scheibe = 314,8 cm²
* Gesamte Reibungsfläche = 9.445 cm²
==Hydrauliksystem und Kraftheber==
==Steuergeräte==
==Elektrische Ausrüstung==
"12 Volt-Einrichtung"
==Maße und Abmessungen==
* Länge über alles = 3.821 mm
* Breite über alles = 2.100 mm (Ausführung-W = 2.405 mm)
* Höhe über alles = 1.908 mm
* Bodenfreiheit = 295 mm
* Betriebsgewicht HD-10 = 9.507 kg
* Betriebsgewicht HD-10 W = 9.811 kg
==Ketten==
* Kette = 6.402 mm x 457 mm
* Auflagelänge = 2.157 mm
* Auflagefläche der Kette = 19.729 cm²
* Anpressdruck = 0,48 kg/cm² (Ausführung-W = 0,50 kg/cm²)
"Optional:"
* Kettenbreite = 406 mm, 508, 559 mm und 610 mm
==Füllmengen==
* Tankinhalt = 166,6 l
* Motoröl = 12,3 l
* Ölbadluftfilter = 1,9 l
* Kühlsystem = 36,9 l
* Getriebe = 26,5 l
* Endantrieb je 7,6 l
* Kettengehäuse je 7,1 l
==Verbrauch==
* Kraftstoffverbrauch = 25,9 l/h bei 99,8 DIN-PS und Nenndrehzahl
==Kabine==
* Offener Fahrerstand mit leicht gefederten Sitz, Öl- und Ladeanzeige, Amperemeter und Temperaturanzeige
* Auf Wunsch mit Betriebsstundenzähler
==Sonderausrüstung==
* Betriebsstundenzähler
* Motorseitenabdeckungen
* Kettenschutz
* Heckscheinwerfer
* Kühlerschutz
* Riemenscheibe
* Zapfwelle
* Kettenbreiten
* Kotflügel
==Literatur & Weblinks==
* TractorData.com
* Brochure Allis Corporation
* digitalcommons.unl.edu (Test-Nr. 361/40)
* Allis-Chalmers Farm Tractors and Crawler-Data Book (Terry Dean)
<references />
{{:Traktorenlexikon: Navigation |HERSTELLER-LINK=Traktorenlexikon: Allis-Chalmers |HERSTELLER= Allis-Chalmers}}
p6rl350vv4k1ocr55152zdnwxb9elaa
Kinder wollen singen/ Ein Männlein steht im Walde
0
123393
1093552
2026-11-08T23:38:46Z
Mjchael
2222
Neue Seite (vgl. [[WB:AZ]])
1093552
wikitext
text/x-wiki
{{bc|[[Gitarre: schneller Griffwechsel]]}}
<noinclude>
{{:Kinder wollen singen:_Schule und Beruf/_Navi}}
</noinclude>
{{:Liederbuch/_Ein Männlein steht im Walde}}
<div class="noprint"><small>Eingefügt aus: [[Liederbuch/_Ein Männlein steht im Walde]]</small></div>
<noinclude>
{{:Kinder_wollen-singen:_Wortspiel/_Liederbox}}
</noinclude>
oz7ekkmq13j7npvj5l7q54vsgyvv2mj
Kinder wollen singen: Themen/ Wortspiel
0
123394
1093553
2026-11-08T23:42:50Z
Mjchael
2222
Ein Männlein steht im Walde
1093553
wikitext
text/x-wiki
== [[Kinder wollen singen/ Wortspiel|Wortspiel]]e ==
* [[Kinder wollen singen/_Drei Chinesen mit dem Kontrabass|Drei Chinesen mit dem Kontrabass]]
* [[Kinder wollen singen/_Ein Männlein steht im Walde|Ein Männlein steht im Walde]]
51cl9b4n6kou80lepkjqeucdrvqb0o4