Use Python and Turtle and Random library to draw the 50 random Rhombus shapes as shown in the following figure.
Hints:
Related Projects:
Draw the following hexagram with Python and Turtle.
Hint:
Think about where to start. The point at the bottom looks like a good starting point.
Related Projects:
Modify circle of isosceles triangle projects to make all triangles point inward as shown.
Related Projects:
Use the Isosceles triangle function created in this project, draw the circle of isosceles triangles as shown below. Your code should easily change the number of triangles, and radius and height of the triangles.
Source Code:
from turtle import *
import math
import random
title('Isosceles Triangle Circle - PythonTurtle.Academy')
setup(1000,1000)
setworldcoordinates(-500,-500,500,500)
hideturtle()
tracer(0,0)
# x,y is the center of the base, width: length of base, height: height of triangle from the top to base
# direction:direction from the center of base to top
def IsoscelesTriangle(x,y,width,height,direction,c):
up()
goto(x,y)
seth(direction-90)
fd(width/2)
p1x, p1y = xcor(), ycor() # first point: bottom right
back(width)
p2x, p2y = xcor(), ycor() # second point: bottom left
goto(x,y)
seth(direction)
fd(height)
p3x, p3y = xcor(), ycor() # third point: top
goto(p1x,p1y)
down()
fillcolor(c)
begin_fill()
goto(p2x,p2y)
goto(p3x,p3y)
goto(p1x,p1y)
end_fill()
n=12
r=300
width=2*r*math.sin(math.radians(180/n))
height=200
for i in range(n):
IsoscelesTriangle(r*math.cos(math.radians(180/n))*math.cos(math.radians(i*360/n)),
r*math.cos(math.radians(180/n))*math.sin(math.radians(i*360/n)),width,height,i*360/n,'blue')
update()
Related Projects:
Use Python and Turtle and Random library to draw the 50 random isosceles triangles as shown in the following figure.
Hints:
Source Code:
from turtle import *
import math
import random
title('Isosceles Triangle Madness - PythonTurtle.Academy')
setup(1000,1000)
setworldcoordinates(-500,-500,500,500)
hideturtle()
tracer(0,0)
# x,y is the center of the base, width: length of base, height: height of triangle from the top to base
# direction:direction from the center of base to top
def IsoscelesTriangle(x,y,width,height,direction,c):
up()
goto(x,y)
seth(direction-90)
fd(width/2)
p1x, p1y = xcor(), ycor() # first point: bottom right
back(width)
p2x, p2y = xcor(), ycor() # second point: bottom left
goto(x,y)
seth(direction)
fd(height)
p3x, p3y = xcor(), ycor() # third point: top
goto(p1x,p1y)
down()
fillcolor(c)
begin_fill()
goto(p2x,p2y)
goto(p3x,p3y)
goto(p1x,p1y)
end_fill()
for _ in range(50):
IsoscelesTriangle(random.uniform(-400,400),random.uniform(-400,400),
random.uniform(30,300), random.uniform(30,300),
random.uniform(0,360),
(random.uniform(0,1),random.uniform(0,1),random.uniform(0,1)))
update()
Draw the 50 random isosceles trapezoids with random locations, random sizes, and random filled colors.
Hints:
Draw a sun shape with a circle and evenly space isosceles triangles surrounding the circle. You may need to use trigonometry to draw this shape. You can also color the circle and the triangles.
Animate a throbbing heart. Check out this simple heart drawing tutorial if you need help.
Source Code:
import turtle
import math
screen = turtle.Screen()
screen.title('Heart Animation - PythonTurtle.Academy')
screen.setup(1000,1000)
screen.setworldcoordinates(-1000,-1000,1000,1000)
turtle.speed(0)
turtle.hideturtle()
screen.tracer(0,0)
turtle.color('red')
def draw_heart(alpha,d):
r = d/math.tan(math.radians(180-alpha/2))
turtle.up()
turtle.goto(0,-d*math.cos(math.radians(45)))
turtle.seth(90-(alpha-180))
turtle.down()
turtle.begin_fill()
turtle.fd(d)
turtle.circle(r,alpha)
turtle.left(180)
turtle.circle(r,alpha)
turtle.fd(d)
turtle.end_fill()
a = 220
sign = -1
def animate():
global a,sign
turtle.clear()
draw_heart(a,1000)
screen.update()
a += sign
if a < 215:
sign = -sign
elif a > 220:
sign = -sign
screen.ontimer(animate,50)
animate()
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+=1This 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.