My_Font = "Times-Roman" My_Start_Year = 2012 My_Longitude = -(2. + 41./60. + 42.4/3600.) # +ve East of Greenwich My_Time_Zone = 0. # +ve East of Greenwich My_Place = "Monmouth" My_Colour = 0 # 1 = Coloured : 0 = Black (suitable for etching) : -1 = Black & Grey My_Tweak = 1.026 # Depending on your location, you will need to marginally change this to close the Flame at 31 Dec Want_Multi_Year = False Want_Header = True # Draws or Supresses the Place Header Want_Label = True Want_EoT_Values = False Want_Zodiac = True Want_Soltices_and_Equinoxes = True Siderial_Zodiac = True Paper_Width = 21 * cm Paper_Height = 29.7 * cm EoT_Wid = 19.0 * cm EoT_Ht = EoT_Wid * 1.5 # You can use any other value but this gives nice proportions EoT_Left = -EoT_Wid / 2 # Centralise Plot on paper EoT_Bottom = EoT_Ht / 2 # Centralise Plot on paper # Degree_of_Greyness will lighten or darken the Greys if the Grey option is chosen Degree_of_Greyness = .4 # ••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••• # Set up Paper Size & move Origin to the Centre of the Page # ••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••• size (Paper_Width, Paper_Height) translate (WIDTH/2,HEIGHT/2) transform (CORNER) from math import degrees,sin,cos,sqrt,atan2,pi # ••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••• # Dashed Line Definition # ••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••• def Dash_Line(x1,y1,x2,y2,Dashes) : x_inc = (x2-x1)/Dashes y_inc = (y2-y1)/Dashes counter = 0 while counter < Dashes-1 : if counter % 2 == 0 : xx = x1 + counter * x_inc yy = y1 + counter * y_inc line(xx,yy,xx + x_inc,yy + y_inc) counter = counter + 1 # ••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••• # EoT Blob-Mark Definition # ••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••• def Blob (xx,yy,siz,Mon_Kol,The_Scale): push() if (siz == 0): strokewidth(.5 * The_Scale) stroke(Mon_Kol) fill(1) ss = 2.5*mm elif(siz == 1): fill(Mon_Kol) nostroke() ss = 1*mm elif(siz == 2): fill(Mon_Kol) nostroke() ss = 1.9*mm else: fill(Mon_Kol) nostroke() ss = 2.2*mm ss = ss * .4 * The_Scale oval(xx-ss/2, yy-ss/2, ss, ss) pop() # ••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••• # Calculate the EoT for a given day : This routine gives EoT accurate to +/- 1.5 second over the next 50 years # ••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••• def EoT_Calc (YYYY,DDD,The_Time_Zone,The_Longitude) : # Input : YYYY is Year # : DDD Days from Start of Year (0 = 0:00 hrs on 31st Dec; 1.5 noon on 1st Jan) # : Note this is in Local Civil Time (not UTC) # : Time_Zone in Hours (+ve East of Greenwich) # : The_Longitude, local Longtitude (+ve East of Greenwich) # Output : EOT & Longtitude Correction in MINUTES # : This is the correction to Sundial Time to give Lacal Mean Time # Accuracy : This routine will give EOT correct to +/- 3 seconds over the next 50 years # Days_2000 is deciaml days from Epoch 2000 Days_2000 = int((YYYY - 2000) * 365.25) + DDD - The_Time_Zone/24 if YYYY % 4 <> 0 : Days_2000 = Days_2000 + 1 # Eccentricity Component Ang_Anom = Days_2000 / 58.1329 # Anomalistic Phase Ecc_1 = 7.653 * sin(1 * Ang_Anom + 6.214) Ecc_2 = 0.081 * sin(2 * Ang_Anom + 6.154) # Obliquity Component Ang_Trop = Days_2000 / 58.1301 # Tropical phase Obl_1 = 0.329 * sin(1 * Ang_Trop + 3.532) Obl_2 = 9.848 * sin(2 * Ang_Trop + 0.314) Obl_3 = 0.316 * sin(3 * Ang_Trop + 0.217) Obl_4 = 0.219 * sin(4 * Ang_Trop + 0.609) Av = -0.006 Long_Adjust = The_Time_Zone * 60. - The_Longitude * 4. return Av + Ecc_1 + Ecc_2 + Obl_1 + Obl_2 + Obl_3 + Obl_4 + Long_Adjust # ••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••• # Gets the values of EoT and the coodinates requited for thre Flame Plot # ••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••• def Get_Flame_Coords(The_Start_Year, Multi_Year,The_Longitude, The_Time_Zone,This_Tweak) : global EoT_Array, Flame_Array # these are the output from this subroutine The_Start_Day = 1.5 #(noon on 1st Jan) The_29_Feb_Index = ((4 - The_Start_Year % 4) % 4) * 365 + 59 Month_Names = ["Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec"] if Multi_Year : # Fill a temporary array with 4 years of EoT values Temp = [] for i in range(0,1461) : Temp.append(EoT_Calc (The_Start_Year,i + The_Start_Day, The_Time_Zone, The_Longitude)) # Save & then delete the Leap Day value of EoT Leap_Value = Temp[The_29_Feb_Index] del Temp [The_29_Feb_Index] # Generate a 365 day array of average EoT values EoT_Array = [] EoT_Array = [(Temp[i] + Temp[i+365] + Temp[i+2*365] + Temp[i+3*365])/4. for i in range(0,365)] # Re-insert the 29th Feb EoT value EoT_Array.insert(59, Leap_Value) Days_in_Total = 366 else : if The_Start_Year % 4 == 0 : Days_in_Total = 366 else: Days_in_Total = 365 EoT_Array = [] for i in range(0, Days_in_Total) : EoT = EoT_Calc (The_Start_Year,i + The_Start_Day, The_Time_Zone, The_Longitude) EoT_Array.append(EoT) if Want_EoT_Values : if Multi_Year or The_Start_Year % 4 == 0 : month_starts = [0,31,60,91,121,152,182,213,244,274,305,335,366] else : month_starts = [0,31,59,90,120,151,181,212,243,273,304,334,365] for j in range(0,12): if i < month_starts[j+1] : Month = j print Month_Names[Month],i-month_starts[j]+1, EoT break # Generate an array with the change in EoT from one day to the next Change_Array = [0] for i in range(1, Days_in_Total) : Change_Array.append(EoT_Array[i] - EoT_Array[i-1]) # Max_Change is used in the final intrinsic curve calculation to ensure the curved base of the Flame Max_Change = max(Change_Array) Fold_Day1 = 121 # 1st May Fold_Day2 = 213 # 1st Aug Fold_Day3 = 274 # 1st Oct Fold_Day4 = 357 # 23rd Dec # The_Closing_Tweak marginally changes y-scale of Flame from Tweak_Start_Day to the end of the of the year # to force closure of the curve Tweak_Start_Day = 274 # 1st Oct # Direction_Changer folds the curve on the Fold Days Direction_Changer = 1 Intrinsic_Mod = 1 Flame_Array = [0] for i in range(1, Days_in_Total) : if i == Fold_Day1 or i == Fold_Day2 or i == Fold_Day3 or i == Fold_Day4 : Direction_Changer = - Direction_Changer if i == Tweak_Start_Day : Intrinsic_Mod = This_Tweak # •••• This is the guts of an intrinsic curve calculation ••• Flame_Array.append(Flame_Array[i-1] + Intrinsic_Mod * Direction_Changer * sqrt(Max_Change**2 - Change_Array[i]**2) ) # ••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••• # 12 Routines for Drawing the 12 Zodiac Symbolas # ••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••• def Aries(x,y,size,Kol): beginpath(-3.284,-540.339) curveto(21.973,-612.586,63.823,-673.23176652,122.267,-722.278) curveto(180.71,-771.323,243.118,-795.845814978,309.491,-795.846) curveto(333.574,-795.846,357.362,-792.321621145,380.857,-785.273) curveto(436.07,-768.239,481.003,-738.283621145,515.659,-695.405) curveto(550.901,-650.765,568.522,-599.957700441,568.522,-542.982) curveto(568.522,-505.39,560.593,-467.505330396,544.733,-429.326) lineto(437.244,-469.855) curveto(447.23,-495.699,452.222,-522.130555066,452.222,-549.15) curveto(452.222,-596.14,438.419,-635.64007489,410.813,-667.652) curveto(383.206,-699.664,348.845,-714.201189427,307.729,-711.264) curveto(267.2,-708.327,219.917,-682.483356828,165.879,-633.731) curveto(98.918,-572.644,62.795,-502.454140969,57.509,-423.159) lineto(24.91,86.093) lineto(-30.597,85.211) lineto(-67.601,-421.396) curveto(-73.475,-500.692,-108.717,-570.294854626,-173.328,-630.207) curveto(-225.605,-678.959,-272.3,-705.096898678,-313.416,-708.621) curveto(-353.945,-712.145,-389.334,-699.223348018,-419.584,-669.855) curveto(-449.833,-640.486,-464.958,-603.775550661,-464.958,-559.722) curveto(-464.958,-529.179,-456.735,-498.635982379,-440.289,-468.093) lineto(-550.421,-425.802) curveto(-566.867,-464.568,-575.09,-502.747242291,-575.09,-540.339) curveto(-575.09,-597.315,-557.176,-648.121656388,-521.346,-692.762) curveto(-486.691,-735.053,-441.757,-765.008722467,-386.544,-782.63) curveto(-363.049,-790.266,-338.967,-794.083700441,-314.297,-794.084) curveto(-247.924,-794.084,-185.37,-769.120660793,-126.632,-719.194) curveto(-70.832,-672.204,-29.716,-612.586264317,-3.284,-540.339) qq = endpath(draw=False) push() translate(x,y) rr=[] x_shunt = 3.284 y_shunt = 490 rw = .005 * size *290 for point in qq: point.x = .0025 * size * (point.x + x_shunt) point.y = .0025 * size * (point.y + y_shunt) point.ctrl1.x = .0025 * size * (point.ctrl1.x + x_shunt) point.ctrl1.y = .0025 * size * (point.ctrl1.y + y_shunt) point.ctrl2.x = .0025 * size * (point.ctrl2.x + x_shunt) point.ctrl2.y = .0025 * size * (point.ctrl2.y + y_shunt) rr.append(point) push() fill(1) nostroke() oval(-rw,-rw,2*rw,2*rw) pop() fill(Kol) drawpath(rr) nofill() pop() def Taurus(x,y,size,Kol): beginpath(-181.258,-601.132) curveto(-121.933,-606.419,-70.538,-631.675251101,-27.073,-676.903) curveto(16.393,-722.131,38.126,-770.588581498,38.126,-822.278) lineto(145.615,-821.396) curveto(145.615,-763.246,127.113,-708.327718062,90.108,-656.639) curveto(53.103,-604.95,4.646,-565.596317181,-55.267,-538.577) curveto(5.233,-514.495,53.838,-477.197022026,90.548,-426.683) curveto(127.259,-376.169,145.615,-319.19414978,145.615,-255.758) curveto(145.615,-170.001,112.135,-96.7271762115,45.174,-35.934) curveto(-21.787,24.859,-102.549,55.2555066079,-197.117,55.256) curveto(-292.271,55.256,-373.181,24.8593348018,-439.848,-35.934) curveto(-506.515,-96.727,-539.848,-170.001039648,-539.848,-255.758) curveto(-539.848,-318.607,-521.64,-375.287559471,-485.222,-425.802) curveto(-448.805,-476.316,-400.348,-513.613682819,-339.848,-537.696) curveto(-399.76,-563.541,-448.071,-602.600325991,-484.782,-654.877) curveto(-521.493,-707.153,-539.848,-762.659030837,-539.848,-821.396) lineto(-439.407,-822.278) curveto(-439.407,-768.826,-418.115,-719.781427313,-375.531,-675.141) curveto(-332.946,-630.501,-281.699,-605.831154185,-221.786,-601.132) curveto(-221.786,-601.132,-208.277,-601.13215859,-181.258,-601.132) qq = endpath(draw=False) beginpath(-177.733,-478.665) curveto(-190.656,-479.84,-203.871,-479.839947137,-217.381,-478.665) curveto(-279.055,-474.554,-330.89,-451.94,-372.888,-410.824) curveto(-414.885,-369.708,-435.883,-320.662546256,-435.883,-263.687) curveto(-435.883,-203.188,-412.682,-151.940004405,-366.28,-109.943) curveto(-319.877,-67.945,-263.49,-46.9471365639,-197.117,-46.947) curveto(-131.331,-46.947,-74.944,-68.0922995595,-27.954,-110.383) curveto(19.036,-152.674,42.531,-203.775030837,42.531,-263.687) curveto(42.531,-320.075,21.239,-368.973361233,-21.346,-410.383) curveto(-63.93,-451.793,-116.059,-474.553577093,-177.733,-478.665) qq1=endpath(draw=False) qq = qq.difference(qq1) push() translate(x,y) rr=[] x_shunt = 197.1165 y_shunt = 448 rw = .005 * size *253 for point in qq: point.x = .0025 * size * (point.x + x_shunt) point.y = .0025 * size * (point.y + y_shunt) point.ctrl1.x = .0025 * size * (point.ctrl1.x + x_shunt) point.ctrl1.y = .0025 * size * (point.ctrl1.y + y_shunt) point.ctrl2.x = .0025 * size * (point.ctrl2.x + x_shunt) point.ctrl2.y = .0025 * size * (point.ctrl2.y + y_shunt) rr.append(point) push() fill(1) nostroke() oval(-rw,-rw,2*rw,2*rw) pop() fill(Kol) drawpath(rr) nofill() pop() def Gemini(x,y,size,Kol): beginpath(-239.407,-98.93) curveto(-173.622,-103.041,-121.933,-105.0969163,-84.341,-105.097) curveto(-47.337,-105.097,3.764,-103.041136564,68.963,-98.93) lineto(68.963,-657.52) curveto(3.764,-652.821,-47.337,-650.471365639,-84.341,-650.471) curveto(-121.933,-650.471,-173.622,-652.820828194,-239.407,-657.52) qq = endpath(draw=False) beginpath(375.57,-68.093) lineto(375.57,39.396) curveto(179.975,8.266,26.672,-7.29955947137,-84.341,-7.3) curveto(-193.006,-7.3,-350.713,8.26562995595,-557.469,39.396) lineto(-557.469,-68.093) lineto(-348.659,-95.405) lineto(-348.659,-661.044) lineto(-557.469,-698.048) lineto(-557.469,-802.013) curveto(-497.557,-791.44,-440.876,-782.33630837,-387.425,-774.7) curveto(-258.79,-756.492,-157.763,-747.093982379,-84.341,-746.507) curveto(27.26,-745.919,180.562,-764.421251101,375.57,-802.013) lineto(375.57,-698.048) lineto(170.284,-661.044) lineto(170.284,-95.405) qq1=endpath(draw=False) qq = qq1.difference(qq) push() translate(x,y) rr=[] x_shunt = 90.9495 y_shunt = 380 rw = .005 * size *300 for point in qq: point.x = .0025 * size * (point.x + x_shunt) point.y = .0025 * size * (point.y + y_shunt) point.ctrl1.x = .0025 * size * (point.ctrl1.x + x_shunt) point.ctrl1.y = .0025 * size * (point.ctrl1.y + y_shunt) point.ctrl2.x = .0025 * size * (point.ctrl2.x + x_shunt) point.ctrl2.y = .0025 * size * (point.ctrl2.y + y_shunt) rr.append(point) push() fill(1) nostroke() oval(-rw,-rw,2*rw,2*rw) pop() fill(Kol) drawpath(rr) nofill() pop() def Cancer(x,y,size,Kol): beginpath(393.192,-229.326) lineto(391.43,-226.683) curveto(350.901,-165.596,286.731,-114.641907489,198.919,-73.819) curveto(111.106,-32.997,20.799,-12.5859030837,-72.007,-12.586) curveto(-274.651,-12.586,-443.518,-115.962255507,-578.615,-322.718) lineto(-516.941,-379.987) curveto(-398.291,-191.44,-247.338,-97.1674008811,-64.077,-97.167) curveto(32.252,-97.167,115.952,-116.84414978,187.024,-156.198) curveto(98.918,-163.834,54.866,-215.815964758,54.866,-312.145) curveto(54.866,-357.373,72.633,-395.992497797,108.17,-428.004) curveto(143.706,-460.016,186.73,-476.022026432,237.244,-476.022) curveto(286.584,-476.022,328.874,-460.016312775,364.117,-428.004) curveto(399.359,-395.992,416.98,-357.373207048,416.98,-312.145) curveto(416.98,-281.015,409.051,-253.408343612,393.192,-229.326) qq = endpath(draw=False) beginpath(60.152,-797.608) curveto(261.621,-797.608,430.489,-693.937894273,566.76,-486.595) lineto(504.205,-436.374) curveto(383.206,-624.334,232.546,-718.31277533,52.222,-718.313) curveto(-1.816,-718.313,-45.575,-715.082264317,-79.055,-708.621) curveto(-121.933,-700.985,-163.636,-685.713770925,-204.165,-662.806) curveto(-159.525,-659.282,-125.164,-641.954634361,-101.081,-610.824) curveto(-78.761,-582.042,-67.601,-545.038405286,-67.601,-499.811) curveto(-67.601,-454.583,-85.222,-415.81660793,-120.465,-383.511) curveto(-155.707,-351.205,-198.585,-335.052863436,-249.099,-335.053) curveto(-299.026,-335.053,-341.61,-351.205418502,-376.852,-383.511) curveto(-412.095,-415.817,-429.716,-454.582740088,-429.716,-499.811) curveto(-429.716,-526.83,-422.667,-553.261251101,-408.57,-579.106) curveto(-374.503,-641.955,-311.067,-694.524017621,-218.262,-736.815) curveto(-128.394,-777.344,-35.59,-797.607929515,60.152,-797.608) qq1 = endpath(draw=False) beginpath(-146.896,-499.811) curveto(-146.896,-525.068,-156.882,-546.800202643,-176.852,-565.009) curveto(-196.823,-583.217,-220.905,-592.321585903,-249.099,-592.322) curveto(-276.118,-592.322,-299.613,-583.217418502,-319.584,-565.009) curveto(-339.554,-546.8,-349.54,-525.067674009,-349.54,-499.811) curveto(-349.54,-474.553,-339.701,-452.967784141,-320.024,-435.053) curveto(-300.347,-417.138,-276.706,-408.18061674,-249.099,-408.181) curveto(-220.905,-408.181,-196.823,-417.137942731,-176.852,-435.053) curveto(-156.882,-452.968,-146.896,-474.553471366,-146.896,-499.811) rr = endpath(draw=False) beginpath(134.161,-312.145) curveto(134.161,-286.888,144.293,-265.008903084,164.557,-246.507) curveto(184.822,-228.004,209.051,-218.753303965,237.244,-218.753) curveto(264.851,-218.753,288.639,-228.004312775,308.61,-246.507) curveto(328.581,-265.009,338.566,-286.888273128,338.566,-312.145) curveto(338.566,-337.402,328.581,-358.988162996,308.61,-376.903) curveto(288.639,-394.818,264.851,-403.775330396,237.244,-403.775) curveto(209.051,-403.775,184.822,-394.818004405,164.557,-376.903) curveto(144.293,-358.988,134.161,-337.402475771,134.161,-312.145) rr1 = endpath(draw=False) aa = qq.difference(rr1) bb = qq1.difference(rr) qq = aa.union(bb) push() translate(x,y) rr=[] x_shunt = 5.9275 y_shunt = 409.804 rw = .005 * size *280 for point in qq: point.x = .0025 * size * (point.x + x_shunt) point.y = .0025 * size * (point.y + y_shunt) point.ctrl1.x = .0025 * size * (point.ctrl1.x + x_shunt) point.ctrl1.y = .0025 * size * (point.ctrl1.y + y_shunt) point.ctrl2.x = .0025 * size * (point.ctrl2.x + x_shunt) point.ctrl2.y = .0025 * size * (point.ctrl2.y + y_shunt) rr.append(point) push() fill(1) nostroke() oval(-rw,-rw,2*rw,2*rw) pop() fill(Kol) drawpath(rr) nofill() pop() def Leo(x,y,size,Kol): beginpath(-220.905,-311.264) curveto(-208.57,-291.294,-202.403,-270.148422907,-202.403,-247.828) lineto(-201.522,-240.78) lineto(-202.403,-240.78) curveto(-202.403,-199.664,-220.465,-164.568427313,-256.588,-135.493) curveto(-292.712,-106.418,-336.03,-91.8810572687,-386.544,-91.881) curveto(-437.058,-91.881,-480.083,-106.565198238,-515.619,-135.934) curveto(-551.155,-165.303,-568.923,-201.425629956,-568.923,-244.304) curveto(-568.923,-286.595,-551.302,-322.571070485,-516.059,-352.233) curveto(-480.817,-381.896,-437.646,-396.726872247,-386.544,-396.727) curveto(-353.651,-396.727,-333.974,-395.552140969,-327.513,-393.203) curveto(-370.392,-499.517,-391.83,-583.510704846,-391.83,-645.185) curveto(-391.83,-786.155,-291.391,-856.63876652,-90.509,-856.639) curveto(153.252,-856.639,275.13,-774.407577093,275.13,-609.943) curveto(275.13,-552.38,259.858,-484.245621145,229.315,-405.537) curveto(209.932,-355.611,181.151,-294.524590308,142.971,-222.278) curveto(110.666,-161.191,93.926,-126.536017621,92.751,-118.313) curveto(92.751,-70.735,121.238,-49.0029162996,178.214,-53.115) curveto(174.689,-52.527,172.634,-51.9397973568,172.046,-51.352) curveto(173.221,-51.352,174.102,-51.3524229075,174.689,-51.352) curveto(215.806,-51.352,246.936,-57.5197621145,268.081,-69.855) lineto(276.892,14.727) curveto(235.188,24.125,197.01,28.8237885463,162.355,28.824) curveto(129.462,28.824,104.205,24.1248634361,86.584,14.727) curveto(31.371,-14.054,3.764,-50.7648281938,3.764,-95.405) curveto(3.764,-103.629,4.645,-112.439013216,6.407,-121.837) curveto(8.757,-136.521,25.791,-173.231718062,57.509,-231.969) curveto(96.276,-304.804,123.882,-360.897013216,140.328,-400.251) curveto(169.11,-470.149,183.5,-529.178907489,183.5,-577.344) curveto(183.5,-698.93,92.165,-759.72246696,-90.509,-759.722) curveto(-225.605,-759.722,-293.152,-704.216414097,-293.152,-593.203) curveto(-293.152,-537.989,-269.07,-444.010942731,-220.905,-311.264) qq = endpath(draw=False) beginpath(-485.222,-244.304) curveto(-485.222,-221.984,-475.531,-202.747511013,-456.148,-186.595) curveto(-436.764,-170.442,-413.563,-162.365638767,-386.544,-162.366) curveto(-358.937,-162.366,-335.296,-170.4419163,-315.619,-186.595) curveto(-295.942,-202.748,-286.104,-221.983735683,-286.104,-244.304) curveto(-286.104,-267.212,-296.089,-286.594634361,-316.059,-302.454) curveto(-336.03,-318.313,-359.525,-326.242290749,-386.544,-326.242) curveto(-413.563,-326.242,-436.764,-318.312854626,-456.148,-302.454) curveto(-475.531,-286.595,-485.222,-267.211568282,-485.222,-244.304) qq1 = endpath(draw=False) qq = qq.difference(qq1) push() translate(x,y) rr=[] x_shunt = 80 y_shunt = 410 rw = .005 * size *350 for point in qq: point.x = .0025 * size * (point.x + x_shunt) point.y = .0025 * size * (point.y + y_shunt) point.ctrl1.x = .0025 * size * (point.ctrl1.x + x_shunt) point.ctrl1.y = .0025 * size * (point.ctrl1.y + y_shunt) point.ctrl2.x = .0025 * size * (point.ctrl2.x + x_shunt) point.ctrl2.y = .0025 * size * (point.ctrl2.y + y_shunt) rr.append(point) push() fill(1) nostroke() oval(-rw,-rw,2*rw,2*rw) pop() fill(Kol) drawpath(rr) nofill() pop() def Virgo(x,y,size,Kol): beginpath(247.817,-199.37) curveto(247.817,-169.414,257.509,-147.387735683,276.892,-133.291) curveto(318.008,-183.805,353.838,-253.114096916,384.381,-341.22) curveto(414.925,-427.564,429.609,-501.278696035,428.434,-562.366) curveto(427.847,-592.322,418.889,-618.018982379,401.562,-639.458) curveto(384.234,-660.897,363.236,-671.616740088,338.566,-671.617) curveto(313.309,-671.617,292.017,-660.750475771,274.689,-639.018) curveto(257.362,-617.285,248.698,-591.440678414,248.698,-561.485) qq = endpath(draw=False) beginpath(315.659,-76.022) curveto(362.649,-61.925,433.72,-58.400845815,528.874,-65.449) lineto(523.588,7.678) curveto(416.099,7.678,372.927,7.9720969163,394.073,8.559) curveto(341.796,6.797,300.387,-1.13208810573,269.844,-15.229) curveto(244.587,7.679,219.917,25.005814978,195.835,36.753) lineto(165.879,-27.564) curveto(180.563,-33.438,195.835,-43.129154185,211.694,-56.639) curveto(197.009,-70.148,187.612,-81.3083259912,183.5,-90.119) curveto(177.626,-102.454,174.689,-120.07477533,174.689,-142.982) lineto(174.689,-570.295) curveto(174.689,-606.125,166.466,-633.878022026,150.02,-653.555) curveto(133.573,-673.232,110.666,-683.070484581,81.297,-683.07) curveto(21.973,-683.07,-7.689,-641.367524229,-7.689,-557.96) lineto(-7.689,-89.238) lineto(-77.293,-89.238) lineto(-77.293,-557.96) curveto(-77.293,-592.615,-88.306,-622.130568282,-110.333,-646.507) curveto(-132.359,-670.883,-158.35,-683.070484581,-188.306,-683.07) curveto(-215.325,-683.07,-235.883,-670.148440529,-249.98,-644.304) curveto(-262.902,-621.984,-269.363,-593.202819383,-269.363,-557.96) lineto(-270.244,-557.96) lineto(-270.244,-89.238) lineto(-352.183,-89.238) lineto(-352.183,-557.96) curveto(-352.183,-636.669,-375.971,-676.022026432,-423.548,-676.022) curveto(-447.631,-676.022,-462.902,-671.616784141,-469.363,-662.806) curveto(-476.999,-647.534,-484.929,-631.969242291,-493.152,-616.11) lineto(-563.637,-616.11) curveto(-556.588,-654.289,-542.198,-686.007215859,-520.465,-711.264) curveto(-494.62,-741.22,-462.315,-756.198237885,-423.548,-756.198) curveto(-395.942,-756.198,-374.209,-750.618264317,-358.35,-739.458) curveto(-342.491,-728.298,-327.22,-709.208651982,-312.535,-682.189) curveto(-282.579,-741.514,-239.995,-771.176211454,-184.782,-771.176) curveto(-126.632,-771.176,-82.873,-741.514246696,-53.504,-682.189) curveto(-24.136,-741.514,19.623,-771.176211454,77.773,-771.176) curveto(135.923,-771.176,179.095,-741.220563877,207.289,-681.308) curveto(236.657,-741.221,279.829,-771.176211454,336.804,-771.176) curveto(379.682,-771.176,418.302,-752.821035242,452.663,-716.11) curveto(487.024,-679.399,503.911,-636.081013216,503.324,-586.154) curveto(502.736,-508.621,484.675,-421.396960352,449.139,-324.48) curveto(413.603,-227.563,369.11,-144.744837004,315.659,-76.022) qq1=endpath(draw=False) qq = qq1.difference(qq) push() translate(x,y) rr=[] x_shunt = -18 y_shunt = 378.2115 rw = .005 * size *380 for point in qq: point.x = .0025 * size * (point.x + x_shunt) point.y = .0025 * size * (point.y + y_shunt) point.ctrl1.x = .0025 * size * (point.ctrl1.x + x_shunt) point.ctrl1.y = .0025 * size * (point.ctrl1.y + y_shunt) point.ctrl2.x = .0025 * size * (point.ctrl2.x + x_shunt) point.ctrl2.y = .0025 * size * (point.ctrl2.y + y_shunt) rr.append(point) push() fill(1) nostroke() oval(-rw,-rw,2*rw,2*rw) pop() fill(Kol) drawpath(rr) nofill() pop() def Libra(x,y,size,Kol): beginpath(-563.637,-107.74) lineto(560.593,-107.74) lineto(560.593,-16.991) lineto(-563.637,-16.991) qq = endpath(draw=False) beginpath(121.826,-220.515) lineto(121.826,-330.648) curveto(156.481,-368.24,173.808,-411.998281938,173.808,-461.925) curveto(173.808,-511.852,156.775,-555.023312775,122.707,-591.441) curveto(88.639,-627.858,47.524,-646.066079295,-0.641,-646.066) curveto(-48.218,-646.066,-89.04,-627.857744493,-123.108,-591.441) curveto(-157.176,-555.023,-174.209,-511.851938326,-174.209,-461.925) curveto(-174.209,-410.824,-156.882,-367.064792952,-122.227,-330.648) lineto(-122.227,-220.515) lineto(-563.637,-219.634) lineto(-563.637,-313.907) lineto(-221.786,-313.907) curveto(-254.679,-361.485,-271.126,-415.816140969,-271.126,-476.903) curveto(-271.126,-555.611,-244.841,-622.717784141,-192.271,-678.225) curveto(-139.701,-733.732,-75.825,-761.484581498,-0.641,-761.485) curveto(73.956,-761.485,137.978,-733.731555066,191.43,-678.225) curveto(244.881,-622.718,271.606,-555.611259912,271.606,-476.903) curveto(271.606,-416.404,254.866,-362.072193833,221.385,-313.907) lineto(560.593,-313.907) lineto(560.593,-219.634) curveto(559.418,-217.872,413.164,-218.165920705,121.826,-220.515) qq1 = endpath(draw=False) qq = qq.union(qq1) push() translate(x,y) rr=[] x_shunt = -10 y_shunt = 305 rw = .005 * size *300 for point in qq: point.x = .0025 * size * (point.x + x_shunt) point.y = .0025 * size * (point.y + y_shunt) point.ctrl1.x = .0025 * size * (point.ctrl1.x + x_shunt) point.ctrl1.y = .0025 * size * (point.ctrl1.y + y_shunt) point.ctrl2.x = .0025 * size * (point.ctrl2.x + x_shunt) point.ctrl2.y = .0025 * size * (point.ctrl2.y + y_shunt) rr.append(point) push() fill(1) nostroke() oval(-rw,-rw,2*rw,2*rw) pop() fill(Kol) drawpath(rr) nofill() pop() def Scorpio(x,y,size,Kol): beginpath(-76.412,-682.189) curveto(-44.106,-741.514,3.47,-771.176211454,66.319,-771.176) curveto(112.722,-771.176,152.222,-753.114718062,184.822,-716.991) curveto(217.421,-680.868,233.72,-637.255762115,233.72,-586.154) curveto(233.72,-557.373,234.895,-483.658449339,237.244,-365.009) curveto(239.007,-299.223,237.832,-239.017894273,233.72,-184.392) curveto(229.609,-129.179,252.516,-101.572687225,302.443,-101.573) curveto(360.005,-101.573,417.567,-133.584114537,475.13,-197.608) lineto(412.575,-197.608) lineto(412.575,-253.996) lineto(584.381,-267.211) lineto(580.857,-62.806) lineto(529.756,-62.806) lineto(529.756,-143.863) curveto(493.338,-108.621,452.516,-79.2526872247,407.289,-55.758) curveto(357.362,-29.913,312.722,-16.9911894273,273.368,-16.991) curveto(192.31,-16.991,150.314,-69.8540969163,147.377,-175.581) curveto(147.377,-175.581,147.377,-309.794546256,147.377,-578.225) curveto(147.377,-656.345,119.183,-695.405286344,62.795,-695.405) curveto(-0.641,-695.405,-32.359,-658.98861674,-32.359,-586.154) lineto(-34.121,-586.154) lineto(-34.121,-89.238) lineto(-105.487,-89.238) lineto(-105.487,-573.819) curveto(-105.487,-607.3,-117.087,-633.143814978,-140.289,-651.352) curveto(-163.49,-669.561,-191.83,-678.665198238,-225.311,-678.665) curveto(-255.854,-678.665,-280.523,-665.743154185,-299.319,-639.899) curveto(-316.941,-616.404,-325.751,-587.91646696,-325.751,-554.436) lineto(-326.632,-554.436) lineto(-326.632,-89.238) lineto(-408.57,-89.238) lineto(-408.57,-554.436) curveto(-408.57,-607.887,-409.452,-638.136528634,-411.214,-645.185) curveto(-416.5,-670.442,-432.946,-683.070484581,-460.553,-683.07) curveto(-484.635,-683.07,-499.319,-680.427339207,-504.606,-675.141) curveto(-512.242,-667.505,-516.059,-647.240986784,-516.059,-614.348) lineto(-583.901,-614.348) curveto(-583.901,-667.799,-574.503,-707.299431718,-555.707,-732.85) curveto(-536.911,-758.401,-505.193,-771.176211454,-460.553,-771.176) curveto(-434.121,-771.176,-413.857,-763.54045815,-399.76,-748.269) curveto(-395.061,-742.982,-382.726,-722.130872247,-362.756,-685.714) curveto(-348.071,-711.558,-327.66,-732.262770925,-301.522,-747.828) curveto(-275.384,-763.394,-247.337,-771.176211454,-217.381,-771.176) curveto(-188.012,-771.176,-160.7,-763.099933921,-135.443,-746.947) curveto(-110.186,-730.794,-90.509,-709.208651982,-76.412,-682.189) qq = endpath(draw=False) push() translate(x,y) rr=[] x_shunt = -20 y_shunt = 415 rw = .005 * size *330 for point in qq: point.x = .0025 * size * (point.x + x_shunt) point.y = .0025 * size * (point.y + y_shunt) point.ctrl1.x = .0025 * size * (point.ctrl1.x + x_shunt) point.ctrl1.y = .0025 * size * (point.ctrl1.y + y_shunt) point.ctrl2.x = .0025 * size * (point.ctrl2.x + x_shunt) point.ctrl2.y = .0025 * size * (point.ctrl2.y + y_shunt) rr.append(point) push() fill(1) nostroke() oval(-rw,-rw,2*rw,2*rw) pop() fill(Kol) drawpath(rr) nofill() pop() def Sagitarius(x,y,size,Kol): beginpath(441.65,-714.789) lineto(-3.284,-405.537) lineto(49.579,-330.648) lineto(-46.456,-261.044) lineto(-99.319,-338.577) lineto(-493.152,-64.568) lineto(-549.54,-144.744) lineto(-155.707,-418.753) lineto(-206.808,-491) lineto(-112.535,-561.485) lineto(-59.672,-486.595) lineto(352.663,-772.938) lineto(239.888,-798.489) lineto(276.011,-872.498) lineto(543.852,-849.59) lineto(502.443,-601.132) lineto(409.051,-620.515) qq = endpath(draw=False) push() translate(x,y) rr=[] x_shunt = -10 y_shunt = 465 rw = .005 * size *320 for point in qq: point.x = .0025 * size * (point.x + x_shunt) point.y = .0025 * size * (point.y + y_shunt) point.ctrl1.x = .0025 * size * (point.ctrl1.x + x_shunt) point.ctrl1.y = .0025 * size * (point.ctrl1.y + y_shunt) point.ctrl2.x = .0025 * size * (point.ctrl2.x + x_shunt) point.ctrl2.y = .0025 * size * (point.ctrl2.y + y_shunt) rr.append(point) push() fill(1) nostroke() oval(-rw,-rw,2*rw,2*rw) pop() fill(Kol) drawpath(rr) nofill() pop() def Capricorn(x,y,size,Kol): beginpath(-558.35,-595.846) curveto(-567.748,-595.846,-572.447,-600.838422907,-572.447,-610.824) curveto(-572.447,-620.809,-567.748,-636.080660793,-558.35,-656.639) curveto(-550.127,-673.673,-542.198,-690.412546256,-534.562,-706.859) curveto(-516.353,-747.975,-497.851,-768.533039648,-479.055,-768.533) curveto(-452.036,-768.533,-427.66,-732.997418502,-405.927,-661.925) lineto(-221.786,-135.053) lineto(-18.262,-712.145) curveto(-12.388,-721.543,-6.221,-729.766484581,0.24,-736.815) curveto(14.924,-753.849,28.434,-762.365638767,40.769,-762.366) curveto(61.327,-762.366,82.472,-742.688889868,104.205,-703.335) curveto(110.079,-755.024,129.462,-797.314079295,162.355,-830.207) curveto(195.248,-863.1,236.657,-879.546255507,286.584,-879.546) curveto(335.923,-879.546,378.948,-861.631603524,415.659,-825.802) curveto(452.369,-789.972,470.725,-746.800546256,470.725,-696.286) curveto(470.725,-646.947,453.104,-604.069198238,417.861,-567.652) curveto(382.619,-531.235,341.209,-513.026431718,293.632,-513.026) curveto(298.331,-513.026,284.528,-514.494845815,252.222,-517.432) lineto(409.932,-215.229) curveto(423.441,-181.749,430.196,-156.492008811,430.196,-139.458) curveto(430.196,-88.944,420.505,-47.2409867841,401.121,-14.348) curveto(376.451,26.768,338.566,47.3259911894,287.465,47.326) curveto(234.014,47.326,192.017,29.1176563877,161.474,-7.3) curveto(133.28,-41.955,119.183,-86.5944405286,119.183,-141.22) curveto(119.183,-147.094,121.826,-150.030837004,127.112,-150.031) curveto(117.714,-149.443,123.882,-149.149779736,145.615,-149.15) curveto(154.425,-149.15,160.005,-144.450854626,162.355,-135.053) lineto(173.808,-90.119) curveto(180.857,-61.925,192.164,-41.6608546256,207.729,-29.326) curveto(223.294,-16.991,246.055,-10.8237885463,276.011,-10.824) curveto(313.016,-10.824,337.685,-23.7458325991,350.02,-49.59) curveto(358.83,-67.212,363.236,-96.2861409692,363.236,-136.815) curveto(363.236,-157.373,359.711,-173.819321586,352.663,-186.154) lineto(146.496,-542.101) lineto(55.747,-661.925) lineto(-221.786,63.185) lineto(-236.764,63.185) lineto(-483.46,-635.493) curveto(-518.115,-608.474,-543.078,-595.258440529,-558.35,-595.846) qq = endpath(draw=False) beginpath(285.703,-580.868) curveto(317.421,-580.868,344.146,-591.880947137,365.879,-613.907) curveto(387.612,-635.934,398.478,-663.09969163,398.478,-695.405) curveto(398.478,-727.711,387.759,-754.729700441,366.319,-776.463) curveto(344.88,-798.195,318.302,-809.061674009,286.584,-809.062) curveto(253.691,-809.062,225.938,-797.901726872,203.324,-775.581) curveto(180.71,-753.261,169.403,-726.242449339,169.403,-694.524) curveto(169.403,-663.393,180.563,-636.668246696,202.883,-614.348) curveto(225.203,-592.028,252.81,-580.86784141,285.703,-580.868) qq1 = endpath(draw=False) qq = qq.difference(qq1) push() translate(x,y) rr=[] x_shunt = 19 y_shunt = 425 rw = .005 * size *296 for point in qq: point.x = .0025 * size * (point.x + x_shunt) point.y = .0025 * size * (point.y + y_shunt) point.ctrl1.x = .0025 * size * (point.ctrl1.x + x_shunt) point.ctrl1.y = .0025 * size * (point.ctrl1.y + y_shunt) point.ctrl2.x = .0025 * size * (point.ctrl2.x + x_shunt) point.ctrl2.y = .0025 * size * (point.ctrl2.y + y_shunt) rr.append(point) push() fill(1) nostroke() oval(-rw,-rw,2*rw,2*rw) pop() fill(Kol) drawpath(rr) nofill() pop() def Aquarius(x,y,size,Kol): beginpath(-545.134,-498.93) curveto(-531.625,-498.93,-516.647,-510.676828194,-500.2,-534.172) curveto(-474.943,-570.002,-458.497,-591.440493392,-450.861,-598.489) curveto(-427.954,-621.397,-400.935,-632.850220264,-369.804,-632.85) curveto(-336.911,-632.85,-307.249,-621.396590308,-280.817,-598.489) curveto(-276.118,-593.79,-257.322,-572.351145374,-224.43,-534.172) curveto(-204.459,-510.677,-186.25,-498.929515419,-169.804,-498.93) curveto(-152.183,-498.93,-135.443,-510.383145374,-119.584,-533.291) curveto(-91.977,-573.82,-76.999,-595.258431718,-74.65,-597.608) curveto(-52.917,-621.103,-25.898,-632.850220264,6.407,-632.85) curveto(40.475,-632.85,70.137,-621.396590308,95.394,-598.489) curveto(100.681,-593.79,118.595,-572.057462555,149.139,-533.291) curveto(167.935,-510.383,185.849,-498.929515419,202.883,-498.93) curveto(219.917,-498.93,236.363,-510.676828194,252.222,-534.172) curveto(279.829,-574.113,295.101,-595.552114537,298.037,-598.489) curveto(319.77,-621.397,346.495,-632.850220264,378.214,-632.85) curveto(412.281,-632.85,442.824,-621.396590308,469.844,-598.489) curveto(479.242,-590.266,497.744,-569.120581498,525.35,-535.053) curveto(543.559,-512.145,559.711,-500.691629956,573.808,-500.692) lineto(573.808,-412.586) curveto(543.265,-412.586,515.952,-424.03953304,491.87,-446.947) curveto(474.249,-468.68,456.628,-490.118837004,439.007,-511.264) curveto(419.036,-534.172,398.772,-545.331867841,378.214,-544.744) curveto(361.18,-544.157,345.615,-532.409806167,331.518,-509.502) curveto(308.023,-472.498,293.632,-451.05876652,288.346,-445.185) curveto(266.613,-422.277,238.126,-410.823788546,202.883,-410.824) curveto(168.816,-410.824,139.154,-422.571101322,113.896,-446.066) curveto(108.61,-450.178,90.695,-471.616546256,60.152,-510.383) curveto(41.356,-533.291,23.441,-544.744493392,6.407,-544.744) curveto(-9.452,-544.744,-24.723,-533.290863436,-39.407,-510.383) curveto(-62.315,-473.966,-76.706,-452.527198238,-82.579,-446.066) curveto(-105.487,-422.571,-134.561,-410.823788546,-169.804,-410.824) curveto(-202.697,-410.824,-232.359,-422.277418502,-258.791,-445.185) curveto(-264.077,-449.884,-282.873,-471.322863436,-315.178,-509.502) curveto(-334.562,-532.41,-352.77,-544.157118943,-369.804,-544.744) curveto(-387.425,-545.332,-404.312,-534.318762115,-420.465,-511.705) curveto(-436.618,-489.091,-452.33,-466.917876652,-467.601,-445.185) curveto(-489.334,-421.69,-515.178,-410.236414097,-545.134,-410.824) qq = endpath(draw=False) beginpath(-541.61,-163.247) curveto(-528.101,-163.247,-513.123,-174.994008811,-496.676,-198.489) curveto(-471.419,-233.731,-454.973,-255.170299559,-447.337,-262.806) curveto(-423.842,-285.714,-396.53,-297.167400881,-365.399,-297.167) curveto(-333.093,-297.167,-303.725,-285.713770925,-277.293,-262.806) curveto(-273.181,-258.695,-254.386,-237.255700441,-220.905,-198.489) curveto(-200.935,-174.994,-182.433,-163.246696035,-165.399,-163.247) curveto(-147.777,-163.247,-131.038,-174.700325991,-115.178,-197.608) curveto(-88.159,-238.137,-73.475,-259.575612335,-71.126,-261.925) curveto(-48.805,-285.42,-21.493,-297.167400881,10.813,-297.167) curveto(44.88,-297.167,74.542,-285.713770925,99.8,-262.806) curveto(105.086,-258.107,123.001,-236.374643172,153.544,-197.608) curveto(171.753,-174.7,189.374,-163.246696035,206.407,-163.247) curveto(223.441,-163.247,240.181,-174.994008811,256.628,-198.489) curveto(284.822,-239.018,300.093,-260.456669604,302.443,-262.806) curveto(324.176,-285.714,350.901,-297.167400881,382.619,-297.167) curveto(416.687,-297.167,447.23,-285.713770925,474.249,-262.806) curveto(483.647,-254.583,502.149,-233.437762115,529.756,-199.37) curveto(547.964,-176.462,563.823,-165.008810573,577.333,-165.009) lineto(577.333,-76.903) curveto(546.789,-76.903,519.77,-88.3567136564,496.275,-111.264) curveto(478.067,-132.997,460.152,-154.436017621,442.531,-175.581) curveto(423.147,-198.489,403.177,-209.649048458,382.619,-209.062) curveto(365.585,-208.474,349.726,-196.726986784,335.042,-173.819) curveto(311.547,-136.227,297.156,-114.788572687,291.87,-109.502) curveto(270.137,-86.595,241.65,-75.140969163,206.407,-75.141) curveto(172.34,-75.141,142.678,-86.8882819383,117.421,-110.383) curveto(112.134,-115.082,94.22,-136.521101322,63.676,-174.7) curveto(45.468,-197.608,27.847,-209.061674009,10.813,-209.062) curveto(-5.634,-209.062,-21.199,-197.608044053,-35.883,-174.7) curveto(-58.791,-137.696,-73.181,-116.257004405,-79.055,-110.383) curveto(-101.375,-86.888,-130.156,-75.140969163,-165.399,-75.141) curveto(-198.879,-75.141,-228.541,-86.5945991189,-254.385,-109.502) curveto(-260.259,-114.201,-279.055,-135.640044053,-310.773,-173.819) curveto(-330.156,-196.727,-348.365,-208.474299559,-365.399,-209.062) curveto(-383.02,-209.649,-399.907,-198.635942731,-416.059,-176.022) curveto(-432.212,-153.408,-448.218,-131.235057269,-464.077,-109.502) curveto(-485.81,-86.007,-511.654,-74.5535947137,-541.61,-75.141) qq1 = endpath(draw=False) qq = qq.union(qq1) push() translate(x,y) rr=[] x_shunt = -16.0995 y_shunt = 285 rw = .005 * size *300 for point in qq: point.x = .0025 * size * (point.x + x_shunt) point.y = .0025 * size * (point.y + y_shunt) point.ctrl1.x = .0025 * size * (point.ctrl1.x + x_shunt) point.ctrl1.y = .0025 * size * (point.ctrl1.y + y_shunt) point.ctrl2.x = .0025 * size * (point.ctrl2.x + x_shunt) point.ctrl2.y = .0025 * size * (point.ctrl2.y + y_shunt) rr.append(point) push() fill(1) nostroke() oval(-rw,-rw,2*rw,2*rw) pop() fill(Kol) drawpath(rr) nofill() pop() def Pisces(x,y,size,Kol): beginpath(-224.43,-447.828) lineto(25.791,-447.828) curveto(35.189,-546.507,73.074,-626.682511013,139.447,-688.357) curveto(204.058,-748.856,281.591,-779.105726872,372.046,-779.106) lineto(372.046,-673.379) curveto(218.742,-673.379,132.399,-598.196052863,113.015,-447.828) lineto(253.104,-447.828) lineto(253.104,-360.604) lineto(120.945,-360.604) curveto(136.217,-206.711,218.448,-129.766519824,367.641,-129.767) lineto(367.641,-22.278) curveto(276.011,-22.278,198.185,-53.554753304,134.161,-116.11) curveto(70.137,-178.666,33.427,-260.162493392,24.029,-360.604) lineto(-223.548,-360.604) curveto(-231.184,-260.162,-267.307,-178.665511013,-331.919,-116.11) curveto(-396.53,-53.555,-475.824,-22.2775330396,-569.804,-22.278) lineto(-569.804,-135.934) curveto(-414.15,-135.934,-329.275,-210.823039648,-315.178,-360.604) lineto(-464.077,-360.604) lineto(-464.077,-447.828) lineto(-311.654,-447.828) curveto(-320.465,-523.012,-348.365,-579.986590308,-395.355,-618.753) curveto(-439.408,-655.171,-497.557,-673.378854626,-569.804,-673.379) lineto(-569.804,-779.106) curveto(-479.348,-779.106,-401.522,-748.562713656,-336.324,-687.476) curveto(-271.125,-626.389,-233.828,-546.507101322,-224.43,-447.828) qq = endpath(draw=False) push() translate(x,y) rr=[] x_shunt = 98.879 y_shunt = 400.553 rw = .005 * size *300 for point in qq: point.x = .0025 * size * (point.x + x_shunt) point.y = .0025 * size * (point.y + y_shunt) point.ctrl1.x = .0025 * size * (point.ctrl1.x + x_shunt) point.ctrl1.y = .0025 * size * (point.ctrl1.y + y_shunt) point.ctrl2.x = .0025 * size * (point.ctrl2.x + x_shunt) point.ctrl2.y = .0025 * size * (point.ctrl2.y + y_shunt) rr.append(point) push() fill(1) nostroke() oval(-rw,-rw,2*rw,2*rw) pop() fill(Kol) drawpath(rr) nofill() pop() # ••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••• # Routine for Drawing a Zodiac Sign # ••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••• def Zodiac_Sign(x,y,size,month,Kol): if month == 1: Aries (x,y,size,Kol) elif month == 2: Taurus (x,y,size,Kol) elif month == 3: Gemini (x,y,size,Kol) elif month == 4: Cancer (x,y,size,Kol) elif month == 5: Leo (x,y,size,Kol) elif month == 6: Virgo (x,y,size,Kol) elif month == 7: Libra (x,y,size,Kol) elif month == 8: Scorpio (x,y,size,Kol) elif month == 9: Sagitarius (x,y,size,Kol) elif month == 10: Capricorn (x,y,size,Kol) elif month == 11: Aquarius (x,y,size,Kol) else: Pisces (x,y,size,Kol) # ••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••• # Routine for Drawing the EoT Flame # ••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••• global EoT_Array, Flame_Array def DrawFlame(xx,yy, Chart_Width,Chart_Height,Coloured,Header,Zodiac,The_Font,The_Start_Year,Multi_Year,The_Longitude,The_Time_Zone,The_Place,The_Tweak): global EoT_Array,Flame_Array # these calculated in the Get_Flame_Coords subroiutine if Multi_Year or The_Start_Year % 4 == 0 : Days_in_Total = 366 else : Days_in_Total = 365 Black = False Grey = False Colour = False if Coloured == 0 : Black = True if Coloured == -1 : Grey = True if Coloured == 1 : Colour = True My_Grey = color(Degree_of_Greyness, Degree_of_Greyness, Degree_of_Greyness) Blacks = [color(0,0,0),color(0,0,0),color(0,0,0),color(0,0,0)] Greys = [color(0,0,0),My_Grey,color(0,0,0), My_Grey] Colors = [color(1,0,0),color(0,0,1),color(.9,0,.8),color(0,.6,0)] # Scaler scales all chart components to that of the original design, which was 6.4 cm Scaler = Chart_Width/(6.4*cm) font(The_Font) fontsize(10* Scaler) strokewidth(.4 * Scaler) if Coloured == 0 : strokewidth(max(.7,.4 * Scaler)) # for Photo-etchind force linewidth to be at least .7 points # ============================================ # TRANSLATE TO ORIGIN AND DRAW SURROUNDING BOX # ============================================ push() translate (xx,yy) stroke(0) if Coloured == 1 : stroke(1,0,0) nofill() rect (0,0, Chart_Width, -Chart_Height) # ======================= # TRANSLATE TO GRAPH AREA # ======================= Numbers_Gap = -5.5*mm*Scaler push() translate (0, Numbers_Gap) Plot_Height = Chart_Height + 2* Numbers_Gap # ===================== # GET THE ARRAY OF EoTs # ===================== # This is a 366 day array with all days, except 29 Feb, being the average over 4 years EoT_Array = [] Get_Flame_Coords(The_Start_Year, Multi_Year, The_Longitude, The_Time_Zone,The_Tweak) # =============== # SCALE THE CHART # =============== up_scale = int(max(EoT_Array)) + 2 down_scale = int(min(EoT_Array)) -2 Margin = .05 * max(Flame_Array) Max_Ys = Margin + max(Flame_Array) Min_Ys = -Margin - min(Flame_Array) Y_Range = Max_Ys - Min_Ys def EoT_to_Chart(EOT_val): return Chart_Width * (EOT_val - down_scale)/(up_scale - down_scale) def Ys_to_Chart (Y_val) : return - 5 - Plot_Height * (Y_val- Min_Ys) /(Y_Range) # ============== # VERTICAL LINES # ============== for counter in range (down_scale + 1, up_scale) : aa = EoT_to_Chart(float(counter)) Tick = 1.2*mm*Scaler if Colour : if counter % 5 == 0 : stroke(1,0,0) line(aa, Tick,aa,- Plot_Height-Tick) else: stroke(.6,.6,1) line(aa, 0,aa,- Plot_Height) elif Grey : if counter % 5 == 0 : stroke(0) line(aa, Tick,aa,- Plot_Height-Tick) else : stroke(.8) line(aa, 0,aa,- Plot_Height) else : stroke(color(0)) if counter % 5 == 0 : line(aa, Tick,aa,- Plot_Height-Tick) else: Dash_Line(aa, 0,aa,- Plot_Height,200) # ====================== # TOP AND BOTTOM MARGINS # ====================== stroke(0) if Coloured == 1 : stroke(1,0,0) aa = EoT_to_Chart(float(down_scale)) bb = EoT_to_Chart(float(up_scale) ) line(aa, - Plot_Height,bb,- Plot_Height) line(aa, 0,bb,0) # ============================================================ # CREATE A WHITE FILL JUST OUTSIDE THE AREA TAKEN BY THE FLAME # ============================================================ x_prev = EoT_to_Chart(EoT_Array[Days_in_Total-1]) y_prev = Ys_to_Chart(Flame_Array[Days_in_Total-1]) x_this = EoT_to_Chart(EoT_Array[0]) y_this = Ys_to_Chart(Flame_Array[0]) for counter in range(0, Days_in_Total-1): if counter <> Days_in_Total : x_next = EoT_to_Chart(EoT_Array[counter + 1]) y_next = Ys_to_Chart(Flame_Array[counter + 1]) else : x_next = EoT_to_Chart(EoT_Array[0]) y_next = Ys_to_Chart(Flame_Array[0]) # slope is normal to curve slope = atan2(-(y_next - y_prev),(x_next - x_prev)) xinc = x_this + .7 * mm * Scaler *sin(slope) yinc = y_this + .7 * mm * Scaler *cos(slope) if(counter == 0): beginpath(xinc, yinc) else: lineto(xinc, yinc) x_prev = x_this y_prev = y_this x_this = x_next y_this = y_next whiteout = endpath(draw=False) push() nostroke() fill(1) drawpath(whiteout) pop() # ============== # MINUTE NUMBERS # ============== font(My_Font) for counter in range (down_scale + 1, up_scale) : if counter % 5 == 0: textwid = 1.*textwidth (counter) textht = textheight(counter) xx = EoT_to_Chart(float(counter)) fill(0) if Coloured == 1: fill(0,0,1) text(counter,xx - textwid/2,-Plot_Height - 2*mm * Scaler) text(counter,xx - textwid/2, textht -1.3*mm * Scaler) # ================== # LITTLE BENT ARROWS # ================== if Multi_Year or The_Start_Year % 4 == 0 : month_starts = [0,31,60,91,121,152,182,213,244,274,305,335,366] else : month_starts = [0,31,59,90,120,151,181,212,243,273,304,334,365] L1 = 3.0 * mm * Scaler # Length of first part of arrow shaft L2 = 1.8 * mm * Scaler # Length of first part of arrow shaft HW = 0.5 * mm * Scaler # Width of Arrow Head HS = 0.8 * mm * Scaler # Head Spur Length HL = 0.8 * mm * Scaler # Length of Arrow Head for counter in range(0, 12) : the_index = month_starts[counter] x1 = EoT_to_Chart (EoT_Array [the_index]) y1 = Ys_to_Chart (Flame_Array[the_index]) x2 = EoT_to_Chart (EoT_Array [the_index+1]) y2 = Ys_to_Chart (Flame_Array[the_index+1]) turn = degrees(atan2((y2-y1),(x2-x1))) push() kol_index = counter % 4 if Black : Mon_Kol = Blacks[kol_index] if Grey : Mon_Kol = Greys [kol_index] if Colour : Mon_Kol = Colors[kol_index] stroke(Mon_Kol) strokewidth(.2*Scaler) fill(Mon_Kol) translate(x1,y1) if counter <> 4: rotate(-turn) beginpath(0,0) lineto(0,-L1) lineto(L2,-L1) lineto(L2-HS,-L1-HW) lineto(L2+HL,-L1) lineto(L2-HS,-L1+HW) lineto(L2,-L1) lineto(0,-L1) lineto(0,0) endpath(draw=True) else : # Special for May rotate(-85) LL2 = 4*mm * Scaler beginpath(0,0) lineto(LL2,0) lineto(LL2-HS,-HW) lineto(LL2+HS,0) lineto(LL2-HS,HW) lineto(LL2,0) lineto(0,0) endpath(draw=True) pop() # =========================== # MONTHLY LINES & DAILY BLOBS # =========================== # Blob sizes for each day of the month siz = [0,1,1,1,2,1,1,1,1,3,1,1,1,1,2,1,1,1,1,3,1,1,1,1,2,1,1,1,1,3,1] counter = 0 month_count = 0 for month_count in range(0, 12) : the_index = month_starts[month_count] last_index = month_starts[month_count+1] day = 0 while the_index < last_index: aa1 = EoT_to_Chart (EoT_Array [counter]) bb1 = Ys_to_Chart (Flame_Array[counter]) kol_index = month_count % 4 if Black : Mon_Kol = Blacks[kol_index] if Grey : Mon_Kol = Greys [kol_index] if Colour : Mon_Kol = Colors[kol_index] Blob(aa1, bb1, siz[day],Mon_Kol,Scaler) day += 1 counter += 1 the_index += 1 # ============ # ZODIAC SIGNS # ============ if Want_Zodiac : # These are Siderial Zodiac start dates zodiac_starts = [104,133,166,196,228,259,289,319,349,13,43,72] for counter in range(0,12) : the_index = zodiac_starts[counter] x1 = EoT_to_Chart (EoT_Array [the_index]) y1 = Ys_to_Chart (Flame_Array[the_index]) x2 = EoT_to_Chart (EoT_Array [the_index+1]) y2 = Ys_to_Chart (Flame_Array[the_index+1]) turn = pi/2. + atan2(-(y2-y1),(x2-x1)) push() translate(x1,y1) LL = 1.5*mm * Scaler if counter == 1: LL = 1*mm*Scaler xx = LL * cos(turn) yy = -LL * sin(turn) if Coloured == 1: Kol = color(.6,.7,.8) elif Coloured == 0: Kol = color(0) else: Kol = color(Degree_of_Greyness) stroke(Kol) strokewidth(.4) line(0,0,xx,yy) translate(xx,yy) xxx = LL * sin(turn) yyy = LL * cos(turn) line(0,0,xxx,yyy) nostroke() Zodiac_Sign( xxx,yyy,1.6*Scaler,counter+1,Kol) pop() White_Blob = .1*mm * Scaler fill(1) oval(x1-White_Blob,y1-White_Blob,2*White_Blob,2*White_Blob) # ========================= # SOLTICE & EQUINOX MARKERS # ========================= if Want_Soltices_and_Equinoxes and not Want_Multi_Year: # Table of Equinoxes and Soltices from 2010 - 2030 in UTC, expressed as days since 31st Dec at 0:00 hrs Spring = [79.7305555555577,79.9729166666657,80.2180555555533,79.4597222222219,79.7062500000029, 79.9479166666642,80.1875,79.4368055555533,79.6770833333358,79.9152777777781,80.159722222219, 79.4006944444409,79.6479166666686,79.8916666666701,80.1291666666657,79.3756944444467, 79.6152777777752,79.8506944444453,80.0951388888861,79.3347222222219,79.5777777777766] Summer = [172.477777777778,172.720138888886,172.964583333334,172.211111111108,172.45208333333, 172.693055555559,172.94027777778,172.183333333334,172.421527777777,172.662499999999, 172.905555555553,172.147222222222,172.384722222225,172.623611111114,172.868750000001, 172.112500000003,172.349999999999,172.59097222222,172.834722222222,172.074999999997,172.313194444447] Autumn = [266.131249999999,266.378472222219,266.617361111108,265.863888888889,266.103472222225, 266.347916666666,266.597916666666,265.834722222222,266.07916666667,266.326388888891, 266.563194444447,265.806250000001,266.044444444444,266.284722222219,266.530555555553, 265.763194444444,266.003472222219,266.251388888886,266.489583333336,265.734722222223,265.977083333331] Winter = [355.984722222223,356.229166666664,356.466666666667,355.71597222222,355.960416666669, 356.199999999997,356.447222222225,355.686111111114,355.932638888888,356.179861111108, 356.418055555558,355.665972222225,355.908333333333,356.143750000003,356.38958333333, 355.627083333333,355.868055555555,356.112500000003,356.347222222219,355.593055555553,355.840277777781] Year_Index = My_Start_Year - 2010 Local_Spring = int(Spring[Year_Index] + My_Time_Zone/24.) Local_Summer = int(Summer[Year_Index] + My_Time_Zone/24.) Local_Autumn = int(Autumn[Year_Index] + My_Time_Zone/24.) Local_Winter = int(Winter[Year_Index] + My_Time_Zone/24.) Key_Days = [Local_Spring-1, Local_Summer-1, Local_Autumn-1, Local_Winter-1] for counter in range(0,4) : the_index = Key_Days[counter] x1 = EoT_to_Chart (EoT_Array [the_index]) y1 = Ys_to_Chart (Flame_Array[the_index]) if My_Colour < 0 : This_Colour = Degree_of_Greyness elif My_Colour == 0 : This_Colour = 0 else: This_Colour = color(1,.5,0) Circ_Rad = (.65*mm * Scaler) Label = "Equinox" if counter % 2 == 1 : Label = "Soltice" push() stroke(This_Colour) strokewidth(1) nofill() oval(x1-Circ_Rad,y1-Circ_Rad,2*Circ_Rad,2*Circ_Rad) nostroke() fill(This_Colour) fontsize(Scaler * 1*mm) y_off = Scaler*.3*mm if counter == 0 or counter == 2 : x_off = textwidth(Label)+ 1*mm*Scaler elif counter == 1 : x_off = -1*mm*Scaler else : x_off = textwidth(Label)/2. y_off = -1*mm*Scaler text(Label, x1-x_off, y1 + y_off) pop() # ============ # MONTH NAMES # ============ # Text alignment for each month name Aligner = [-1,-1,-1,-1,1,1,1,-1,1,1,1,1] # Offset on the month names from the arrow heads Text_XX_Offset = [ 2, -5.5, -9, -9, 2.3, +3.0, +3.0, -8.5, -9, -3.5, +1.0, +4.2] Text_YY_Offset = [-4.3, -4.0, -2.0, -.9, 11.7, +5.0, +4.5, -3.5, -0.9, +7.0, +6.2, +1.0] Text_X_Offset =[] Text_Y_Offset =[] for count in range(0,12) : Text_X_Offset.append(Text_XX_Offset[count] * Scaler) for count in range(0,12) : Text_Y_Offset.append(Text_YY_Offset[count] * Scaler) Month_Names = ["Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec"] for counter in range(0,12) : This_Month = Month_Names[counter] kol_index = counter % 4 if Black : Mon_Kol = Blacks[kol_index] if Grey : Mon_Kol = Greys [kol_index] if Colour : Mon_Kol = Colors[kol_index] Vert_Align = Text_Y_Offset[counter] * mm Hor_Align = Text_X_Offset[counter] * mm indexer = month_starts [counter] aa = EoT_to_Chart(EoT_Array [indexer]) bb = Ys_to_Chart (Flame_Array [indexer]) fill(Mon_Kol) fontsize(10.*Scaler) if counter == 4 : # Special for May push() translate(aa + Hor_Align,bb + Vert_Align) rotate (90) text(This_Month, 0,0) rotate (-90) pop() else: text(This_Month, aa + Hor_Align,bb + Vert_Align) # =============== # HEADER TEXT BOX # =============== if Header : stroke(0) if Coloured == 1 : stroke(1,0,0) fill(1) Line1 = "Equation of Time" Line2 = "& Longitude Correction" Line3 = "for " + The_Place Line4 = "- in Minutes -" fontsize(7.5 * Scaler) LL = .7*textheight(Line1) Box_x = Chart_Width - 1*mm*Scaler Box_y = -Plot_Height + 1*mm*Scaler Box_w = max(textwidth(Line1),textwidth(Line2),textwidth(Line3)) + 2*mm*Scaler Box_h = 4 * LL + 1.2*mm*Scaler rect(Box_x, Box_y, -Box_w, Box_h) Line_y1 = Box_y + LL Line_y2 = Box_y + 2*LL Line_y3 = Box_y + 3*LL Line_y4 = Box_y + 4*LL fill(0) if Coloured == 1 : fill(0,0,1) text (Line1,Box_x - Box_w/2.- textwidth(Line1)/2., Line_y1) text (Line2,Box_x - Box_w/2.- textwidth(Line2)/2., Line_y2) text (Line3,Box_x - Box_w/2.- textwidth(Line3)/2., Line_y3) text (Line4,Box_x - Box_w/2.- textwidth(Line4)/2., Line_y4) # =========================== # LONGITUDE & TIME ZONE LABEL # =========================== pop() if Want_Label : if Want_Multi_Year : The_Years = str(My_Start_Year) + " - " + str(My_Start_Year + 3) else : The_Years = My_Start_Year Abs_Long = abs(My_Longitude) if My_Longitude < 0. : The_Long_Dir = "West" else: The_Long_Dir = "East" Degs = int(Abs_Long) Mins = int(60. * (Abs_Long - Degs)) Label1 = "EoT at Noon Civil Time for " + str(The_Years) Label2 = " at Longitude " + str(Degs) + " deg " + str(Mins) + " min " + The_Long_Dir Label3 = " : Time Zone " + str(int(My_Time_Zone)) Label4 = ". Zodiac marks are Sidereal" My_Label = Label1 + Label2 + Label3 + Label4 fill(.7) fontsize(3.5*Scaler) text (My_Label,Chart_Width/2.- textwidth(My_Label)/2., -.5*mm * Scaler) pop() # ••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••• # Finally, do the Drawing # ••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••••• DrawFlame(EoT_Left,EoT_Bottom,EoT_Wid,EoT_Ht,My_Colour,Want_Header,Want_Zodiac,My_Font,My_Start_Year, Want_Multi_Year,My_Longitude,My_Time_Zone,My_Place,My_Tweak)