Based on the function that draws Isosceles Trapezoid in the this previous project, draw the following fractal tree with Python and Turtle.
Related Projects:
Based on the function that draws Isosceles Trapezoid in the this previous project, draw the following fractal tree with Python and Turtle.
Related Projects:
Based on golden fractal tree project, draw the following shape that contains 5 golden fractal trees.
Golden Fractal Tree is a tree based on Golden Ratio. The golden fractal tree contains the main branch and three smaller golden fractal trees: the first branch turns left by 72 degrees with ratio of main branch to the parent’s main branch = 2-golden_ratio; the second branch have the same the direction as the parent with ratio of main branch to the parent’s main branch = golden_ratio-1; the first branch turns right by 72 degrees with ratio of main branch to the parent’s main branch = 2-golden_ratio. For more details on golden fractal tree, please check out this web page.
Source Code:
import turtle
import math
screen = turtle.Screen()
screen.title('Golden Fractal Tree - PythonTurtle.Academy')
screen.setup(1000,1000)
screen.setworldcoordinates(-1000,-1000,1000,1000)
turtle.speed(0)
turtle.hideturtle()
turtle.tracer(0,0)
golden_ratio = (1+5**0.5)/2
def golden_fractal_tree(x,y,direction,length):
turtle.up()
turtle.goto(x,y)
turtle.seth(direction)
turtle.pensize(math.log(length,2)/3)
if length<10: turtle.color('forest green')
else: turtle.color('gray')
turtle.down()
turtle.fd(length)
if length < 3: return
cx,cy = turtle.xcor(), turtle.ycor()
golden_fractal_tree(cx,cy,direction+72,(2-golden_ratio)*length)
golden_fractal_tree(cx,cy,direction-72,(2-golden_ratio)*length)
golden_fractal_tree(cx,cy,direction,(golden_ratio-1)*length)
golden_fractal_tree(0,-900,90,700)
turtle.update()
Fill the five pointed stars with random colors with random colors. Refer to this project that draw uncolored five pointed star fractal.
Draw a five pointed star fractal that have nested five pointed star as shown.
Hint: Create a function that draws five pointed star in any location, orientation, and size.
Source Code:
import turtle
import math
screen = turtle.Screen()
screen.title('Five Pointed Star Fractal - PythonTurtle.Academy')
screen.setup(1000,1000)
screen.setworldcoordinates(-1000,-1000,1000,1000)
turtle.speed(0)
turtle.hideturtle()
turtle.pensize(1)
def five_pointed_star(x,y,direction,r): #x,y is the center
turtle.up()
turtle.goto(x,y)
turtle.seth(direction)
turtle.fd(r)
turtle.right(180-18)
turtle.down()
length = r*math.sin(math.pi*2/5)/(1+math.sin(math.pi/10))
for _ in range(5):
turtle.fd(length)
turtle.left(72)
turtle.fd(length)
turtle.right(180-36)
def five_pointed_star_fractal(x,y,direction,r): #x,y is the center
five_pointed_star(x,y,direction,r)
if r < 20: return
five_pointed_star_fractal(x,y,180+direction,r*math.sin(math.pi/10)/math.cos(math.pi/5))
five_pointed_star_fractal(0,-40,90,1000)
Draw the following fractal made up of nesting pentagrams with either recursion or iteration.
Hint: Making a function that draws pentagram in any location, radius, and direction will help!
Source Code:
import turtle
import math
screen = turtle.Screen()
screen.title('Pentagram Fractal - PythonTurtle.Academy')
screen.setup(1000,1000)
screen.setworldcoordinates(-1000,-1000,1000,1000)
turtle.speed(0)
turtle.hideturtle()
def star(x,y,direction,r): #x,y is the center
turtle.up()
turtle.goto(x,y)
turtle.seth(direction)
turtle.fd(r)
turtle.right(180-18)
turtle.down()
length = 2*r*math.sin(math.pi*2/5)
for _ in range(5):
turtle.fd(length)
turtle.right(180-36)
def star_fractal(x,y,direction,r):
star(x,y,direction,r)
if r < 50: return
star_fractal(x,y,180+direction,r*math.sin(math.pi/10)/math.cos(math.pi/5))
star_fractal(0,0,90,1000)
Using the center coordinate and zoom factor to draw the following Mandelbrot Set visualizations.
Source Code:
from PIL import Image
import colorsys
import math
px, py = -0.7746806106269039, -0.1374168856037867 #Tante Renate
px, py, zoom = -0.74384935657398, -0.13170134084746293, 5788441.443619884
px, py, zoom = 2.613577e-1, -2.018128e-3, 3.354786e+3
px, py, zoom = -0.59990625, -0.4290703125, 1024
px, py, zoom = -1.038650e-1, -9.584393e-1, 1.674667e+5
px, py, zoom = -0.761574, -0.0847596, 78125
px, py, zoom = -1.62917,-0.0203968, 3125
px, py, zoom = -0.75,0,1
R = 3
max_iteration = 512
w, h = 1250,1250
mfactor = 1
def Mandelbrot(x,y,max_iteration,minx,maxx,miny,maxy):
zx = 0
zy = 0
RX1, RX2, RY1, RY2 = px-R/2, px+R/2,py-R/2,py+R/2
cx = (x-minx)/(maxx-minx)*(RX2-RX1)+RX1
cy = (y-miny)/(maxy-miny)*(RY2-RY1)+RY1
i=0
while zx**2 + zy**2 <= 4 and i < max_iteration:
temp = zx**2 - zy**2
zy = 2*zx*zy + cy
zx = temp + cx
i += 1
return i
def gen_Mandelbrot_image():
bitmap = Image.new("RGB", (w, h), "white")
pix = bitmap.load()
for x in range(w):
for y in range(h):
c=Mandelbrot(x,y,max_iteration,0,w-1,0,h-1)
v = c**mfactor/max_iteration**mfactor
hv = 0.67-v*2
#if hv<0: hv+=1
r,g,b = colorsys.hsv_to_rgb(hv,1,1-(v-0.1)**2/0.9**2)
r = min(255,round(r*255))
g = min(255,round(g*255))
b = min(255,round(b*255))
pix[x,y] = int(r) + (int(g) << 8) + (int(b) << 16)
bitmap.save("Mandelbrot_"+str(px)+"_"+str(py)+"_"+str(zoom)+".jpg")
bitmap.show()
R=3/zoom
gen_Mandelbrot_image()
Write a Python program to generate 1000+ images of Mandelbrot Set with ever zooming ranges. Please note that Turtle is not used in this project for speed consideration. Then use an external software to combine the images into a video:
Source Code:
from PIL import Image
import colorsys
import math
px, py = -0.7746806106269039, -0.1374168856037867 #Tante Renate
R = 3
max_iteration = 2500
w, h = 1024,1024
mfactor = 0.5
def Mandelbrot(x,y,max_iteration,minx,maxx,miny,maxy):
zx = 0
zy = 0
RX1, RX2, RY1, RY2 = px-R/2, px+R/2,py-R/2,py+R/2
cx = (x-minx)/(maxx-minx)*(RX2-RX1)+RX1
cy = (y-miny)/(maxy-miny)*(RY2-RY1)+RY1
i=0
while zx**2 + zy**2 <= 4 and i < max_iteration:
temp = zx**2 - zy**2
zy = 2*zx*zy + cy
zx = temp + cx
i += 1
return i
def gen_Mandelbrot_image(sequence):
bitmap = Image.new("RGB", (w, h), "white")
pix = bitmap.load()
for x in range(w):
for y in range(h):
c=Mandelbrot(x,y,max_iteration,0,w-1,0,h-1)
v = c**mfactor/max_iteration**mfactor
hv = 0.67-v
if hv<0: hv+=1
r,g,b = colorsys.hsv_to_rgb(hv,1,1-(v-0.1)**2/0.9**2)
r = min(255,round(r*255))
g = min(255,round(g*255))
b = min(255,round(b*255))
pix[x,y] = int(r) + (int(g) << 8) + (int(b) << 16)
bitmap.save("Mandelbrot_"+str(sequence)+".jpg")
R=3
f = 0.975
RZF = 1/1000000000000
k=1
while R>RZF:
if k>100: break
mfactor = 0.5 + (1/1000000000000)**0.1/R**0.1
print(k,mfactor)
gen_Mandelbrot_image(k)
R *= f
k+=1
This program generates over 1000 images and may be quite slow. You can make it faster by dividing the work to multiple programs each doing a portion of those images.
Write a Python program to generate hundreds of images of Julia Set with ever zooming ranges. Please note that Turtle is not used in this project for speed consideration. Then use an external software to combine the images into a video:
The video above zooms into the center at 0.0958598997051 + 1.1501990019993i with c = 0.355 + 0.355i. In each iteration the range shrinks by 5% until the range becomes 1/10^13 the size of the original range. You can modify the code to try different centers and c. The following is the source code:
from PIL import Image
import colorsys
cx = -0.7269
cy = 0.1889
R = (1+(1+4*(cx**2+cy**2)**0.5)**0.5)/2+0.001
max_iteration = 512
print(R)
w, h, zoom = 1500,1500,1
def julia(cx,cy,RZ,px,py,R,max_iteration,x,y,minx,maxx,miny,maxy):
zx = (x-minx)/(maxx-minx)*2*RZ-RZ+px
zy = (y-miny)/(maxy-miny)*2*RZ-RZ+py
i=0
while zx**2 + zy**2 < R**2 and i < max_iteration:
temp = zx**2 - zy**2
zy = 2*zx*zy + cy
zx = temp + cx
i += 1
return i
def gen_julia_image(sequence,cx,cy,RZ):
bitmap = Image.new("RGB", (w, h), "white")
pix = bitmap.load()
for x in range(w):
for y in range(h):
# smllaer: right,down
c=julia(cx,cy,RZ,0.0958598997051,1.1501990019993,R,max_iteration,x,y,0,w-1,0,h-1)
v = c/max_iteration
hv = 0.67-v*0.67
r,g,b = colorsys.hsv_to_rgb(hv,1,v/2+0.45)
r = min(255,round(r*255))
g = min(255,round(g*255))
b = min(255,round(b*255))
pix[x,y] = int(r) + (int(g) << 8) + (int(b) << 16)
bitmap.save("julia_"+str(sequence)+".jpg")
# bitmap.show()
f = 0.95
RZF = 1/1000000000000
RZ = 1
k=1
while RZ>RZF:
print(k,RZ)
gen_julia_image(k,0.355,0.355,RZ)
RZ *= f
k+=1
In this project, we are generate several Julia Sets by varying the constant c in the normal Julia Set function. Turtle will be too slow to do this work. Instead we are going to use the PIL library. Please check out Julia Set Animation project for source code.