Lassen Sie uns die Flagge von Nepal zeichnen

28

Nepals Flagge ( Wikipedia , Numberphile ) sieht ganz anders aus als jede andere. Es enthält auch spezielle Zeichenanweisungen (im Wikipedia-Artikel enthalten). Ich möchte, dass ihr ein Programm macht, das die Flagge Nepals zeigt.

Der Benutzer gibt die gewünschte Höhe der Flagge ein (von 100 bis 10000 Pixel) und das Programm gibt die Flagge von Nepal aus. Sie können wählen, wie Sie die Flagge zeichnen möchten: von ASCII-Grafiken bis hin zu OpenGL.

Dies ist ein Beliebtheitswettbewerb, daher wird der Gewinner am 1. Februar die am höchsten bewertete Antwort sein. Machen Sie sich also keine Gedanken über die Länge des Codes.

Es gibt nur eine Voraussetzung: Sie dürfen keine Webressourcen verwenden.

Habe Spaß :)

Bild der Flagge von Nepal aus Wikimedia Commons

ST3
quelle
1
Deja vu! Wie viele Zeilen ASCII-Text sind in 100px?
Kendall Frey
@KendallFrey Nun, ASCII-Kunst ist eine der Möglichkeiten, dies zu lösen, es gibt jedoch keine Antwort auf Ihre Frage. Da dies von der Schriftgröße und dem Abstand zwischen den Zeilen abhängt, sollte der Antwortanbieter dies selbst zählen.
ST3
1
In diesem Fall ist sicherlich print("|\\\n|\\")eine gültige Lösung. Ich denke, Sie müssen die Regeln für Nicht-Bitmap-Einträge präzisieren.
Kendall Frey
5
Bitte lösche deine Frage nicht und poste sie erneut. Es gibt eine Bearbeitung aus einem bestimmten Grund. Außerdem enthält Ihre neue Frage keinen Link.
Türklinke
1
Warum sollte das Flag nicht gezeichnet (dh durch Code erstellt) werden, anstatt Internetressourcen zu verbieten?
Justin

Antworten:

18

SVG, 1375, 1262, 1036, 999, 943939

<svg>
<defs>
<style>.w{fill:white}</style>
<g id="f"><path d="M1,1L1,20L18,20L6,10L17,10z" style="stroke:#003893;fill:#dc143c"/></g>
<g id="m"><polygon points="1,0 -.5,.86 -.5,-.86"/></g>
<g id="b"><polygon points="1,0 -.5,.86 -.5,-.86"/><polygon points="1,0 -.5,.86 -.5,-.86"transform="rotate(32)"/></g>
<g id="t"><use xlink:href="#b"/><use xlink:href="#b"transform="rotate(60)"/></g>
<g id="s">
<use xlink:href="#m"/>
<use xlink:href="#m"transform="rotate(20)"/>
<use xlink:href="#m"transform="rotate(45)"/>
<use xlink:href="#m"transform="rotate(70)"/>
<use xlink:href="#m"transform="rotate(90)"/>
</g>
</defs>
<g transform="scale(.7)">
<use xlink:href="#f" x="5" y="6"transform="scale(19,23)"/>
<use xlink:href="#t" x="2.8" y="7"class="w"transform="scale(70)"/>
<path d="M157,292 A 40,35 0 1 0 237,292 43,45 0 1 1 157,292z"class="w"/>
<use xlink:href="#s" x="5.6" y="8.9"class="w"transform="scale(35)"/>
</g>
</svg>

Chrome-Rendering

SVG verfügt nicht wirklich über Benutzereingaben, AFAIK, sodass Sie die Skalierung ändern können, indem Sie diese Zeile ändern:

<g transform="scale(.7)">

Gabriele D'Antona
quelle
Es sollten genau 8 Dreiecke im Mond und 12 in der Sonne sein. Aber Sie haben 11 und 15.
Victor Stafusa
sollte behoben werden.
Gabriele D'Antona
2
Es hat Benutzereingaben. Durch Drücken von STRG + + oder STRG + - kann der Benutzer die Skalierung in vielen Webbrowsern ändern.
Konrad Borowski
Dies ist 918 Byte lang (Sie können anstelle von Windows Unix-Zeilenenden verwenden, um ein Byte pro Zeilenumbruch zu speichern). Und während wir bei diesem Thema sind, können Sie nur Zeilenumbrüche insgesamt Drop auf 897. zu bringen Aber diese machen gar nicht in entweder IE, Chrome, Firefox oder Inkscape für mich. Zumindest nicht als eigenständiges SVG. Nur wenn in HTML eingebettet (aber das bringt es auf 960 Bytes). Durch Beheben der XML-Fehler wird die Datei auf 1008 Byte vergrößert. Ich werde ein bisschen Golf spielen.
Joey
hypftier.de/temp/svg.7z ist ein Mercurial-Repository mit den Änderungen, die ich vorgenommen habe. Mit können Sie die Nachrichten am einfachsten überprüfen hg log --style=changelog -r 0..tip. Ich könnte die Techniken, die ich dort verwendet habe, genauer beschreiben.
Joey
27

JavaScript, 569 537 495 442 Zeichen (ASCII)

h="";M=Math;Z=M.max;Y=M.min;function d(a,b,r,s,t){n=M.sqrt(a*a+e*e);return n-(r+M.abs((M.atan2(a,e
)/M.PI*b+t)%1-0.5)*s*n)}f=parseInt(prompt(),10);for(g=0;g<f;g++){for(k=0;k<2*f;k++)e=k/(0.5*f)-0.8
,q=g/(0.25*f),u=q-1.08,v=q-1.29,z=e*e+u*u-0.3364,E=Z(-e-0.8,Y(Z(0.62*e+0.8-q,-2.06+q),Z(1*e+0.8+
0.85-q,-3.87+q))),p=0>Y(d(q-2.91,6,0.38,0.7,10),Y(Z(e*e+v*v-0.3025,-z),Z(d(q-1.54,8,0.25,0.6,10.5)
,q-1.7)))?" ":-0.13>E?";":0>=E?"8":"",h+=p;h+="\n"}h 

Zum Ausführen: Kopieren-Einfügen in die Browserkonsole (z. B. Chrome-Entwicklertools oder Firebug)

Ergebnis:

8 
8888 
8888888 
8888;88888 
8888;;;;88888 
8888;;;;;;;888888 
8888;;;;;;;;;;;88888 
8888;;;;;;;;;;;;;;88888 
8888;;;;;;;;;;;;;;;;;88888 
8888;;;;;;;;;;;;;;;;;;;;888888 
8888;;;;;;;;;;;;;;;;;;;;;;;;88888 
8888;;;;;;;;;;;;;;;;;;;;;;;;;;;88888 
8888;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;88888 
8888;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;88888 
8888;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;888888 
8888;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;88888 
8888;;;;;;;;;;;; ;  ;  ; ;;;;;;;;;;;;;;;;;;;;;;88888 
8888;;; ;;;;;               ;;;;; ;;;;;;;;;;;;;;;;88888 
8888;;;  ;;;;;;           ;;;;;;  ;;;;;;;;;;;;;;;;;;;888888 
8888;;;;   ;;;             ;;;   ;;;;;;;;;;;;;;;;;;;;;;;;88888 
8888;;;;;                       ;;;;;;;;;;;;;;;;;;;;;;;;;;;;88888 
8888;;;;;;;                   ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;88888 
8888;;;;;;;;;               ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;88888 
8888;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;888888 
8888;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;88888 
8888;;;;;;;;;;;;;;;;;;;;;;8888888888888888888888888888888888888888888888888888888 
8888;;;;;;;;;;;;;;;;;;;;;;;;888 
8888;;;;;;;;;;;;;;;;;;;;;;;;;;888 
8888;;;;;;;;;;;;;;;;;;;;;;;;;;;;888 
8888;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;888 
8888;;;;;;;;;;;;;;;; ;;;;;;;;;;;;;;;888 
8888;;;;;;;;;   ;;;   ;;;   ;;;;;;;;;;888 
8888;;;;;;;;;;             ;;;;;;;;;;;;;888 
8888;;;;                         ;;;;;;;;;888 
8888;;;;;;                     ;;;;;;;;;;;;;888 
8888;;;;;;;                   ;;;;;;;;;;;;;;;;888 
8888;;;                           ;;;;;;;;;;;;;;888 
8888;;;;;                       ;;;;;;;;;;;;;;;;;;888 
8888;;;;;;;                   ;;;;;;;;;;;;;;;;;;;;;;888 
8888;;;;;                       ;;;;;;;;;;;;;;;;;;;;;;888 
8888;;;; ;;;;;             ;;;;; ;;;;;;;;;;;;;;;;;;;;;;;888 
8888;;;;;;;;;               ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;888 
8888;;;;;;;;;  ;;;;   ;;;;  ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;888 
8888;;;;;;;;;;;;;;;; ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;888 
8888;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;888 
8888;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;888 
8888;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;888 
8888888888888888888888888888888888888888888888888888888888888888888888888 
888888888888888888888888888888888888888888888888888888888888888888888888888 

BEARBEITEN: Höhe als Benutzereingabe hinzugefügt, wie von ST3 vorgeschlagen. es funktioniert am besten mit großen Werten (zB: 120)

tigrou
quelle
Sieht gut aus, aber wo ist die Benutzereingabe? Es ist eine der Anforderungen.
ST3
Ich wusste das nicht (oder habe es zumindest nicht gelesen :)). Ich habe die Antwort aktualisiert.
Tigrou
Dein Mond hat 6 Dreiecke. Sollte 8. Außerdem stürzte mein Browser bei großen Werten ab.
Victor Stafusa
Ich habe den gesamten Code überarbeitet. Das Rendern ist jetzt näher an der ursprünglichen Markierung und sieht besser aus, insbesondere bei niedrigen Höhenwerten (z. B. 20 Pixel). Mond wurde repariert und hat die richtige Anzahl von Dreiecken (der Stern war zu niedrig, um alle zu sehen). Empfohlener Höhenwert ist "100".
Tigrou
Verrückte ausgezeichnete Vorlage.
Devon Parsons
23

Mathematica

Nepals Interimsverfassung - Anhang 1 (zu Artikel 6), S. 260 und 262, enthält 25 detaillierte Anweisungen zum Bau der Flagge. (siehe http://www.ccd.org.np/resources/interim.pdf ). Die Nummern in den Kommentaren beziehen sich auf die entsprechenden Anweisungen in der Satzung.

Wir brauchen Funktionen, um gleichseitige Dreiecke zu zeichnen und den Abstand von einem Punkt zu einer Linie zu bestimmen:

ClearAll[triangle]
triangle[a_?NumericQ,b_?NumericQ,c_?NumericQ,labeled_:True]:=
Block[{x,y,pt,sqr},sqr=#.#&;
pt[a1_,b1_,c1_]:=Reduce[sqr[{x,y}]==b1^2&&sqr[{x,y}-{a1,0}]==c1^2&&y>0,{x,y}];
{(
(*Polygon[{{0,0},{a,0},{x,y}}]*)
Polygon[{{-a/2(*0*),0},{a/2,0},{x-a/2,y}}]),
If[labeled,
{Text[Style[Framed[a,Background->LightYellow],11],{a/2,0}],
Text[Style[Framed[b,Background->LightYellow],11],{x/2,y/2}],
Text[Style[Framed[c,Background->LightYellow],11],{(a+x)/2,y/2}]},{}]}/.ToRules[pt[a,b,c]]]

(*distance from point to a line *)
dist[line_,{x0_,y0_}]:=(Abs[a x0+b y0+c]/.{x0-> m[[1]],y0-> m[[2]]})/Sqrt[a^2+b^2]; (* used below *)

Der verbleibende Code mit Nummern, die sich auf die Anweisungen beziehen. Die mit Abstand größte Herausforderung besteht darin, die Strahlen für Mond und Sonne zu erzeugen. GeometricalTransformationist praktisch für Übersetzungen und Rotationen.

    (*shape inside flag*)
(*1*)
w=100;a={0,0};b={w,0};
lAB=Line[{a,b}];
tA=Text["A",Offset[{-10,-20},a]];
tB=Text["B",Offset[{20,-20},b]];

(*2*)
c={0,w 4/3};d={0,w};
lAC=Line[{a,c}];
tC=Text["C",Offset[{-10,20},c]];
lAD=Line[{a,d}];
tD=Text["D",Offset[{-10,0},d]];
lBD=Line[{b,d}];

(*3*)
e=Solve[(x-w)^2+y^2==(w)^2&&y==w-x,{x,y}][[1,All,2]];
tE=Text["E",Offset[{15,0},e]];

(*4*)
f={0,e[[2]]};tF=Text["F",Offset[{-10,0},f]];
g={w,e[[2]]};tG=Text["G",Offset[{15,0},g]];
lFG=Line[{f,g}];
poly={a,b,e,g,c};

(*5*)lCG= Line[{c,g}];

(*moon*)
(*6*)
lineCG=N[((f[[2]]-c[[2]])/w)x+c[[2]](*100*)];
h={w/4,0};tH=Text["H",Offset[{0,-20},h]];
i={h[[1]],lineCG/.x->h[[1]]};tI=Text["I",Offset[{10,0},i]];
lHI={Dashed, LightGray,Line[{h,i}]};

(*7*)
j={0,f[[2]]+(c[[2]]-f[[2]])/2};tJ=Text["J",Offset[{-10,10},j]];
lineJG=N[((f[[2]]-j[[2]])/g[[1]])x+j[[2]]];
k={Solve[lineCG==j[[2]],x][[1,1,2]],j[[2]]};tK=Text["K",Offset[{10,10},k]];
(*k={Solve[lineCG\[Equal]c[[2]],x][[1,1,2]],j[[2]]};tK=Text["K",Offset[{10,10},k]];*)
lJK={Dashed, LightGray,Line[{j,k}]};

(*8*)l={i[[1]],j[[2]]};tL=Text["L",Offset[{0,10},l]];
(*9*)lJG={LightGray,Dashed,Line[{j,g}]};
(*10*)m={h[[1]],(lineJG/.x-> h[[1]])};tM=Text["M",Offset[{0,10},m]];
(*11*)distMfromBD=dist[{1,1,-w(*100*)},m];
 n={i[[1]],m[[2]]-distMfromBD};tN=Text["N",Offset[{0,0},n]];
(*ln=Abs[l[[2]]-n[[2]]];*)
(*12*)o={0,m[[2]]};tO=Text["O",Offset[{-10,0},o]];
lM={Dashed,LightGray,Line[{o,{g[[1]],o[[2]]}}]};

(*13*)
radiusLN=l[[2]]-n[[2]];
p={m[[1]]-radiusLN,m[[2]]};tP=Text["P",Offset[{0,10},p]];
q={m[[1]]+radiusLN,m[[2]]};tQ=Text["Q",Offset[{0,10},q]];
moonUpperEdge={White,Circle[l,radiusLN,{Pi,2 Pi}]};
moonLowerEdge={White,Circle[m,radiusMQ,{Pi,2 Pi}]};


(*14*)radiusMQ=q[[1]]-m[[1]];


(*15*)radiusNM=m[[2]]-n[[2]];
arc={Yellow,Circle[n,radiusNM,{Pi/7,6 Pi/7}]};
{r,s}=Solve[(x-l[[1]])^2+(y-l[[2]])^2==(radiusLN)^2 &&(x-n[[1]])^2+(y-n[[2]])^2==(radiusNM)^2,{x,y}][[All,All,2]];
tR=Text["R",Offset[{0,0},r]];
tS=Text["S",Offset[{0,0},s]];
t={h[[1]],r[[2]]};
tT={Black,Text["T",Offset[{0,0},t]]};


(*16*)radiusTS=Abs[t[[1]]-s[[1]]];
(*17*)radiusTM=Abs[t[[2]]-m[[2]]];

(*18 triangles*)
t2=Table[GeometricTransformation[GeometricTransformation[triangle[4,4,4,False][[1]],RotationTransform[k Pi/8]],{TranslationTransform[t]}],{k,-4,3}];
midRadius=(Abs[radiusTM+radiusTS]/2-2);
pos=1;table2=GeometricTransformation[t2[[pos++]],{TranslationTransform[#]}]&/@Table[midRadius {Cos@t,Sin[t]},{t,Pi/16,15 Pi/16,\[Pi]/8}];

(*19 sun*)u={0,f[[2]]/2};tU=Text["U",Offset[{-10,0},u]];
lineBD=N[(d[[2]]/w)x+d[[2]]];
v={-Solve[lineBD==u[[2]],x][[1,1,2]],u[[2]]};tV=Text["V",Offset[{10,0},v]];
lUV={LightGray,Dashed,Line[{u,v}]};

(*20*)w={h[[1]],u[[2]]};tW={Black,Text["W",Offset[{0,0},w]]};
(*21*)
(*22*)

t3=Table[GeometricTransformation[GeometricTransformation[triangle[9,9,9,False][[1]],RotationTransform[k Pi/6]],{TranslationTransform[w]}],{k,-3,9}];
midRadius3=(Abs[radiusTM+radiusTS]/2+2.5);
pos=1;
table3=GeometricTransformation[t3[[pos++]],{TranslationTransform[#]}]&/@Table[midRadius3 {Cos@t,Sin[t]},{t,0,2 Pi,2\[Pi]/12}];



Show[
Graphics[{Gray,
(*1*)lAB,tA,tB,
(*2*)lAC,tC,lAD,tD,lBD,
(*3*)tE,
(*4*)tF,lFG,tG,{Red,Opacity[.4],Polygon[poly]},
(*5*)lCG,
(*6*)tH,lCG,tI,lHI,
(*7*)tJ,lJK,tK,
(*8*)tL,
(*9*)lJG,
(*10*)tM,
(*11*)tN,
(*12*)lM,tO,
(*13*)moonUpperEdge,tP,tQ,
(*14*)moonLowerEdge,
(*15*)arc,tR,tS,tT,
(*16*){White,Dashed,Circle[t,radiusTS(*,{0, Pi}*)]},

(*17*){White,Opacity[.5],Disk[t,radiusTM,{0, 2 Pi}]},
(*18 triangles*){White,(*EdgeForm[Black],*)table2},
(*19 sun*)tU,tV,lUV,

(*20*)tW,{Opacity[.5],White,Disk[w,Abs[m[[2]]-n[[2]]]]},
(*21*)Circle[w,Abs[l[[2]]-n[[2]]]],
(*22*){Black(*White*),EdgeForm[Black],triangle[4,4,4,False](*table3*)},
{White,(*EdgeForm[Black],*)table3},

(*23*)
{Darker@Blue,Thickness[.03],Line[{a,b,e,g,c,a}]}

},
Ticks-> None(*{{0,100},{0,80,120,130}}*), BaseStyle-> 16,AspectRatio-> 1.3,Axes-> True],

(*cresent moon*)
RegionPlot[{(x-25)^2+(y-94.19)^2<21.4^2&&(x-25)^2+(y-102.02)^2>21.4^2},{x,0,100},{y,30,130},PlotStyle->{Red,White}]]

Das folgende Flag aus dem obigen Code wird gemäß den Anweisungen in der Verfassung erstellt.

Die Farben werden geändert, um das Anzeigen der Konstruktionslinien zu erleichtern. Die Buchstaben beziehen sich auf Punkte und Linien in der Anleitung.

Flaggenbau


Flaggen der Welt können übrigens direkt in Mathematica aufgerufen werden. Beispielsweise:

Graphics[CountryData["Nepal", "Flag"][[1]], ImageSize->{Automatic,200}]

Nepal

DavidC
quelle
1
Ähm, das ist wie Schummeln ...
Gabriele D'Antona
friol, ja, ich stimme zu. Deshalb habe ich eine Variante beigelegt.
DavidC
1
IMO verstößt dies nicht gegen die Regel, da keine Ressourcen direkt aus dem Web geladen werden.
Tyzoid
2
Mathematica erlaubt immer Möglichkeiten zu betrügen.
ST3
13
@ ST3 Mathematica ist der Betrüger.
Oberon
9

Python

import turtle, sys
from math import sqrt, sin, cos, pi

height = int(sys.argv[1])
width = height / 4 * 3
turtle.screensize(width, height)
t = turtle.Turtle()

# the layout
t.pencolor("#0044cc")
t.fillcolor("#cc2244")
t.pensize(width / 25)
t.pendown()
t.fill(True)
t.forward(width)
t.left(135)
t.forward(width)
t.right(135)
t.forward(width / sqrt(2))
t.right(90)
t.goto(0, height)
t.forward(height)
t.fill(False)
t.penup()

# the bottom star
t.fillcolor("#ffffff")
t.pencolor("#ffffff")
t.pensize(1)
radius = width / 5
x = width / 4
y = height / 4
t.goto(x + radius, y)
t.pendown()
t.fill(True)
for i in range(24):
    t.goto(x + radius * (5 + (-1) ** i) / 6 * cos(i * pi / 12), y + radius * (5 + (-1) ** i) / 6 * sin(i * pi / 12))
t.fill(False)
t.penup()

# the top star
radius = width / 9
x = width / 4
y = height * 2 / 3
t.goto(x + radius, y)
t.pendown()
t.fill(True)
for i in range(28):
    t.goto(x + radius * (6 + (-1) ** i) / 7 * cos(i * pi / 14), y + radius * (6 + (-1) ** i) / 7 * sin(i * pi / 14))
t.fill(False)
t.penup()

# the moon
radius = width / 5
x = width / 4
y = height / sqrt(2)
t.goto(x + radius, y)
t.pendown()
t.fill(True)
for i in range(30):
    t.goto(x + radius * cos(i * pi / 30), y - radius * sin(i * pi / 30))
for i in range(30):
    t.goto(x - radius * cos(i * pi / 30), y - radius / 2 * sin(i * pi / 30))
t.fill(False)
t.penup()
t.hideturtle()

raw_input("press enter")

Verwendet Pythons Tk Schildkröten, Beispiel python nepal.py 150und python nepal.py 200jeweils:

Bild

mniip
quelle
Können Sie die Anzahl der Zeichen in Ihren Quellcode schreiben?
Gabriele D'Antona
Warum? ist das Code-Golf ?
Mittwoch,
Der Mond sollte genau 8 Dreiecke haben. Ihre hat 9 und eine halbe.
Victor Stafusa
@ Victor Behoben.
Wusste
5

R (reden wir nicht über Länge )

nepaliflag = function(imaginary = FALSE, color = c("red", "white", "blue")){
    #Draws flag of Nepal with default colors red for inner area, white for Sun and Moon,
    #and blue for outer border
    #Based on instructions from http://www.servat.unibe.ch/icl/np01000_.html
    #Coded by Darshan Baral, with help from Urja Acharya
    #Fork at https://github.com/darshanbaral/R_codes/blob/master/nepali_flag.r
    graphics.off()
    windows(width = 6, height = 8)
    par(mar = c(3, 0.5, 2, 0.5))
    fs = 1 #Arbitrary scale unit for flag
    plot(fs, fs, xlim = c(0, fs), ylim = c(0, 1.5*fs),
         type = "p", pch = NA, axes = FALSE,
         xlab = "", ylab = "",
         asp = 1)

    title(main = "Flag of Nepal")

    #Perpendicular distance from a to bc
    dist_point_line <- function(a, b, c) {
        v1 <- b - c
        v2 <- a - b
        m <- cbind(v1,v2)
        return(abs(det(m))/sqrt(sum(v1*v1)))
    }

    #Distance from a to b
    dist_2_points <- function(a, b) {
        return(sqrt((a[1]-b[1])^2+(a[2]-b[2])^2))
    }

    #Intersection between lines ab and mn
    lines_intersection = function(a,b,m,n){
        A1 = b[2] - a[2]
        B1 = a[1] - b[1]
        C1 = a[1]*b[2] - a[2]*b[1]

        A2 = n[2] - m[2]
        B2 = m[1] - n[1]
        C2 = m[1]*n[2] - m[2]*n[1]      

        Delta = A1*B2 - A2*B1
        if(Delta == 0){
            return("Lines are parallel")
        } else {
            x = (B2*C1 - B1*C2)/Delta
            y = (A1*C2 - A2*C1)/Delta
            return(c(x,y))
        }
    }

    A = c(0,0)
    B = c(fs, 0)
    C = c(0, 4*B[1]/3)
    D = c(0, B[1])
    E = c( (B[1] - B[1]/sqrt(2)), B[1]/sqrt(2) )
    tE = c(E[1], A[2]) #Projecting E onto x-axis
    F = c(0, E[2] )
    G = c(B[1], E[2] )

    F_C = dist_2_points(F,C) #Distance between points F and C
    F_G = dist_2_points(F,G)
    B_tE = dist_2_points(B,tE)
    E_tE = dist_2_points(E,tE)

    upper_angle = pi/2 - atan(F_C/F_G) #Corner angle of upper triangle
    lower_angle = pi/2 - atan(E_tE/B_tE) #Corner angle of bottom triangle

    H = c(B[1]/4,0)
    I = c(H[1], G[2]+(G[1]-H[1])*(C[2]-F[2])/G[1] )
    J = c(0, 0.5*(C[2] + F[2]) )
    K = c( (C[2]-J[2])*G[1]/(C[2]-F[2]), J[2])
    L = c(H[1],J[2])
    M = lines_intersection(J, G, H, I)
    M_BD = dist_point_line(M, B, D) #Perpendicular distance between point M and line BD
    N = c(H[1], M[2]-M_BD)
    O = c(0, M[2])
    L_N = dist_2_points(L, N)
    L_M = dist_2_points(L, M)
    P = c(M[1] - sqrt(L_N^2 - L_M^2), M[2])
    Q = c(M[1] + sqrt(L_N^2 - L_M^2), M[2])
    L_Q = dist_2_points(L, Q)
    M_Q = dist_2_points(M, Q)
    M_N = dist_2_points(M, N)

    #Points of intersection of two circles
    temp_1 = (L_Q^2 - M_N^2 + M_N^2 ) / (2 * M_N)
    temp_2 = sqrt(L_Q^2 - temp_1^2)

    R = c(N[1]-temp_2, L[2]-temp_1)
    S = c(N[1]+temp_2, L[2]-temp_1)
    T = c(H[1], R[2])
    T_N = dist_2_points(T, N)
    T_S = dist_2_points(T, S)
    T_M = dist_2_points(T, M)

    U = c(A[1], 0.5 * (A[2]+F[2]))
    temp_U = c(H[1],U[2])
    V = lines_intersection(U, temp_U, B, E)
    W = c(H[1], U[2])

    #Draw inner polygon in red
    area = rbind(G, C, A, B, E)    
    polygon(area, col = color[1], border = NA)

    #Draw Moon arcs
    symbols (x = L[1], y = L[2], circles=c(L_N), add =TRUE, inches=FALSE, fg = NA, bg = color[2])
    symbols (x = M[1], y = M[2], circles=c(M_Q), add =TRUE, inches=FALSE, fg = NA, bg = color[2])
    symbols (x = L[1], y = L[2], circles=c(L_N), add =TRUE, inches=FALSE, fg = NA, bg = color[1])
    symbols (x = T[1], y = T[2], circles=c(T_M), add =TRUE, inches=FALSE, bg = color[2], fg = NA)

    #Draw Sun circles
    symbols (x = W[1], y = W[2], circles=c(M_N), add =TRUE, fg = NA, inches=FALSE, bg = NA)

    #Obtain points of triangles of the Sun
    sun_points = c(0,0)
    theta = 0
    for (i in 1:24){
        if (i %% 2 != 0){
            sun_points = rbind( sun_points, c( W[1]+L_N*cos(theta), W[2]+L_N*sin(theta)) )
        } else {
            sun_points = rbind( sun_points, c( W[1]+M_N*cos(theta), W[2]+M_N*sin(theta)) )
        }
        theta = theta + 2*pi/24
    }
    sun_points = sun_points[2:25,]

    #Obtain points of triangles of the Moon
    moon_points = c(0,0)
    theta = 0 - pi/8
    for (i in 1:20){
        if (i %% 2 != 0){
            moon_points = rbind( moon_points, c( T[1]+T_M*cos(theta), T[2]+T_M*sin(theta)) )
        } else {
            moon_points = rbind( moon_points, c( T[1]+T_S*cos(theta), T[2]+T_S*sin(theta)) )
        }
        theta = theta + pi/16
    }
    moon_points = moon_points[2:21,]

    par(xpd = TRUE)

    Ax = c(A[1] - T_N, A[2]) #Shift A to the left with a distance of TN
    Cx = c(C[1] - T_N, C[2])
    Ay = c(A[1], A[2] - T_N)
    By = c(B[1], B[2] - T_N) #Shift B to the bottom with a distance of TN

    Gx = c(G[1] + T_N, G[2])
    Gy = c(G[1], G[2] - T_N)
    Ey = c(E[1], E[2] - T_N)

    Kx = c(K[1] + T_N/cos(upper_angle), K[2]) #a point on parallel line TN away from upper slanting line
    Ix = c(I[1] + T_N/cos(upper_angle), I[2]) #another point on parallel line TN away from upper slanting line

    Bb = c(B[1] + T_N/cos(lower_angle), B[2]) #a point on parallel line TN away from lower slanting line
    Ee = c(E[1] + T_N/cos(lower_angle), E[2]) #another point on parallel line TN away from lower slanting line

    #Point of intersection for offsetting borders in corners
    Ap = lines_intersection(Ax, Cx, Ay, By) 
    Cp = lines_intersection(Kx, Ix, Ax, Cx)
    Gp = lines_intersection(Ix, Kx, Ey, Gy)
    Ep = lines_intersection(Bb, Ee, Ey, Gy)
    Bp = lines_intersection(Ay, By, Ee, Bb)

    #Draw triangles for Sun and Moon
    polygon(sun_points, col = color[2], border = NA)    
    polygon(moon_points, col = color[2], border = NA)   

    #Draw outer border
    borders = rbind(B, Bp, Ap, Cp, Gp, Ep, Bp, B, A, C, G, E, B)                
    polygon(borders, col=color[3], border = NA)

    #Draw white polygon on outside of upper triangle to get rid of part of initial circle
    outer_white = rbind(Cp,Gp,c(Gp[1],Cp[2]))
    polygon(outer_white,col = "white", border = NA)

    #Draw grids, cirlces, and points if imaginary is TRUE
    if (imaginary == TRUE){
        main_points = rbind(A, B, C, D, E, F, G, H, I, J, K, L, M, N, 
                            O, P, Q, R, S, T, U, V, W)  
        points(main_points, pch = 19, cex = 0.5)
        text(main_points, c("A", "B", "C", "D", "E", "F", "G", "H", "I",
                            "J", "K", "L", "M", "N", "O", "P", "Q", "R",
                            "S", "T", "U", "V", "W"), pos = 3, font =2)
        lines(rbind(H,I), lty = 2)
        lines(rbind(J,G), lty = 2)
        lines(rbind(J,K), lty = 2)
        lines(rbind(U,V), lty = 2)

        #Draw Moon arcs
        symbols (x = L[1], y = L[2], circles=c(L_N), add =TRUE, inches=FALSE, bg = NA)
        symbols (x = M[1], y = M[2], circles=c(M_Q), add =TRUE, inches=FALSE, bg = NA)
        symbols (x = N[1], y = N[2], circles=c(M_N), add =TRUE, inches=FALSE, bg = NA)
        symbols (x = T[1], y = T[2], circles=c(T_S), add =TRUE, inches=FALSE, bg = NA)
        symbols (x = T[1], y = T[2], circles=c(T_M), add =TRUE, inches=FALSE, bg = NA)

        #Draw Sun circles
        symbols (x = W[1], y = W[2], circles=c(M_N), add =TRUE, inches=FALSE, bg = NA)
        symbols (x = W[1], y = W[2], circles=c(L_N), add =TRUE, inches=FALSE, bg = NA)          
    }
}

Bildbeschreibung hier eingeben

db
quelle
4

Python (+ PIL), 578

Weil ich heute ziemlich gelangweilt bin ..

from PIL import Image,ImageDraw
from math import*
I,k,l,m,n,o,_=Image.new('P',(394,480)),479,180,465,232,347,255;D=ImageDraw.Draw(I);P,G=D.polygon,D.pieslice
I.putpalette([_,_,_,0,0,_,_,20,60])
def S(x,y,r,e,l,b):
 p,a,h=[],2*pi/e,r*l;c,d=[0,-a/2][b],[a/2,0][b]
 for i in range(e):p+=[(x+r*cos(i*a+c),y+r*sin(i*a+c)),(x+h*cos(i*a+d),y+h*sin(i*a+d))]
 P(p,fill=0)
P([(0,0),(393,246),(144,246),(375,k),(0,k)],fill=1)
P([(14,25),(o,n),(110,n),(o,m),(14,m)],fill=2)
S(96,o,68,12,.6,0)
G([(31,90),(163,221)],0,l,fill=0)
G([(28,68),(166,200)],0,l,fill=2)
S(96,178,40,16,.7,1)
I.show()

Nepal

Dieter
quelle
Sie haben zwei zusätzliche Dreiecke auf dem Mond und der Sonne, sollte 8 und 10 sein, nicht 10 und 12 :)
Kade