Creating A Cloud With Python Turtle: A Step-By-Step Guide

Python Turtle is a popular graphics package that can be used to create fun and educational drawings. In this tutorial, we will explore how to create a cloud using Python Turtle. Drawing a cloud may seem like a simple task, but it can be achieved in multiple ways, including using arcs of different sizes and extents or drawing multiple circles. We will also discuss how to set up the screen by configuring the height and width of the canvas and explore the use of functions to streamline the drawing process. By the end of this tutorial, you should be able to create your own clouds and even experiment with different shapes and colours.

Using circles to draw a cloud

Python Turtle is a great way to create graphics and visualise data. In this case, we will be using Python Turtle to draw a cloud using circles.

To start, we need to set up the screen and import the necessary libraries. We will use the Turtle library to create the graphics and also import the random library to generate random numbers.

Python

Import turtle

Import random

Screen = turtle.Screen()

Screen.setup(width=1000, height=1000)

Screen.bgcolor('dodger blue')

The code above sets the screen size to 1000x1000 pixels and the background colour to "dodger blue". Now, we can start drawing our cloud.

One way to draw a cloud is to use multiple circles with different sizes and positions. We can use a loop to draw multiple circles and vary their sizes and positions randomly.

Python

Turtle.speed(0)

Turtle.hideturtle()

Turtle.pencolor('white')

Turtle.pensize(2)

For i in range(15):

Radius = random.randint(10, 50)

X_position = random.randint(-200, 200)

Y_position = random.randint(-200, 200)

Turtle.up()

Turtle.goto(x_position, y_position)

Turtle.down()

Turtle.begin_fill()

Turtle.circle(radius)

Turtle.end_fill()

In the code above, we first set the speed of the turtle to 0, which is the fastest setting. We then hide the turtle shape, set the pen colour to white, and set the pen size to 2 pixels.

We then use a for loop to draw 15 circles. For each circle, we randomly generate a radius between 10 and 50 pixels and x and y coordinates between -200 and 200 pixels. We move the turtle to the specified coordinates, start filling the shape, draw the circle, and then end the fill.

By using random numbers for the size and position of the circles, we can create a cloud-like shape with overlapping circles.

You can further customise the cloud by adjusting the range of random numbers or adding more circles.

Finally, we can finish the program by closing the turtle screen when the user clicks the close button.

Python

Screen.exitonclick()

This code will close the turtle window when the user clicks the close button, typically the "X" button in the top right corner of the window.

Setting up the screen

To set the size of the window, use the screensize() command, specifying the desired width and height in pixels. For example, t.Screen().screensize(500, 500) sets the width and height of the canvas to 500 pixels each.

Next, use the setworldcoordinates() command to subdivide the window into the desired number of pixels and set up the coordinate axes. For instance, t.Screen().setworldcoordinates(-300, 300, 300, 900) sets the y-axis range from 300 to 900, creating a square grid.

You can then set the background colour of the screen using the bgcolor() command. For a blue sky, you might choose lightblue as the background colour: t.Screen().bgcolor("lightblue").

Once you have set up the screen, you can start drawing the cloud. One approach is to use circles to create the cloud shape. Start with a filled circle by specifying the colour and using the begin_fill(), circle(), and end_fill() commands. For example:

Python

Import turtle as t

T.Screen().bgcolor("lightblue")

T.color("white", "white")

T.begin_fill())

T.circle(50)

T.end_fill())

This will create a white-filled circle with a radius of 50 pixels on the light blue background.

You can then define a function to encapsulate this code and make it easier to draw multiple circles with different radii and colours. Here's an example of how you might define a filled_circle() function:

Python

Def filled_circle(radius, colour):

T.color(colour, colour)

T.begin_fill())

T.circle(radius)

T.end_fill())

Now, you can call this function to draw circles with different radii and colours, gradually building up the shape of the cloud.

Drawing an oval shape

To draw an oval shape in Python Turtle, you can use the following approach:

First, understand that an oval is essentially a stretched circle. So, to draw an oval, you can start by drawing a circle using the `circle() function in Python Turtle. You can specify the radius and the degree of the arc you want to create.

Next, you can use the `turtlesize()` function to stretch the circle and turn it into an oval. Here's an example code snippet:

Python

Turtle.circle(50) # Draw a circle with a radius of 50

Turtle.turtlesize(stretch_wid=None, stretch_len=10) # Stretch the circle horizontally to create an oval

You can adjust the `stretch_len` value to control the amount of stretching and thus, the shape of your oval.

Additionally, you can create a custom function to draw ovals of different sizes and orientations. Here's an example:

Python

Def talloval(r):

Turtle.left(45)

For loop in range(2):

Turtle.circle(r, 90) # Draw the long curved part

Turtle.circle(r/2, 90) # Draw the short curved part

Def flatoval(r):

Turtle.right(45)

For loop in range(2):

Turtle.circle(r, 90)

Turtle.circle(r/2, 90)

In this code, `talloval(r)` draws a vertical oval, while `flatoval(r)` draws a horizontal oval. The `r` parameter controls the size of the oval.

You can also use parametric equations to create an oval shape. This approach allows you to draw the oval in any orientation you desire. Here's an example:

Python

Import turtle

Import math

Def ellipse(a, b, h=None, k=None, angle=None, angle_unit=None):

Myturtle = turtle.Turtle()

If h is None:

H = 0

If k is None:

K = 0

If angle is None:

Angle = 360

Converted_angle = angle * 0.875

If angle_unit == 'd' or angle_unit is None:

Converted_angle = angle * 0.875

Elif angle_unit == "r":

Converted_angle = (angle * 0.875 * (180/math.pi))

For i in range(int(converted_angle)+1):

If i == 0:

Myturtle.up()

Else:

Myturtle.down()

Myturtle.setposition(h+a*math.cos(i/50), k+b*math.sin(i/50))

Turtle.done()

In this code, `ellipse(a, b, h, k, angle, angle_unit)` allows you to specify the radii `a` and `b`, the horizontal and vertical positions `h` and `k`, the angle `angle`, and the angle unit `angle_unit`.

Drawing random arcs

Understanding the Cloud Shape

The cloud shape is created by drawing multiple arcs of different sizes and extents. The challenge is to determine the starting and ending points of these arcs to form the cloud outline. The solution is to use an oval shape to control the endpoints of the arcs. The arcs start and end on the points of this oval, creating the cloud's irregular shape.

Algorithm for Drawing the Cloud

Here's an overview of the algorithm to draw the cloud:

• Create an oval shape using two halves of ellipses. The top ellipse is taller than the bottom one, giving the cloud a flatter bottom.
• Put the coordinates of the points on the oval into a list.
• Randomly select two points from the list and decide the extent of the arc.
• Draw the arc between the selected points.
• Repeat steps 3 and 4 until all the points on the oval are covered.

Now, let's focus on the process of drawing random arcs:

• Computing Euclidean Distance: To draw an arc between two points, you need to calculate the Euclidean distance between them. This distance will be used to determine the radius and initial heading for drawing the arc. The `dist` function in the code snippet provided in the source calculates this distance using the formula: `((p1 [0]-p2 [0])^2 + (p1 [1]-p2 [1])^2)^0.5`.
• Drawing the Arc: The `draw_arc` function takes two points, `p1` and `p2`, and an extent value, `ext`, as parameters. It uses the turtle.circle function to draw the arc between the points. Here's a breakdown of the process:

• `turtle.up(): Lift the pen, so the turtle can move without drawing.
• `turtle.goto(p1): Move the turtle to the starting point, `p1`.
• `turtle.seth(turtle.towards(p2)): Set the turtle's heading towards the endpoint, `p2`.
• `a = turtle.heading(): Get the current heading of the turtle.
• Calculate the values of `b`, `c`, `d`, `e`, and `r`: These values are used to determine the radius and initial heading for drawing the arc. They are computed using trigonometry and the Euclidean distance calculated earlier.
• `turtle.seth(e)`: Set the initial heading of the circle to `e`.
• `turtle.down(): Put the pen down to start drawing.
• `turtle.circle(r, ext, 100): Draw the arc with radius `r` and extent `ext`. The third argument, `100`, specifies the number of steps used to approximate the arc.

Repeating the Process: To draw the cloud, you repeat the process of selecting random points and drawing arcs. The `cloud` function in the code snippet provided in the source demonstrates this. It uses the `ellipse` function to create the oval shape and then randomly selects points from the list of coordinates, `P`, to draw arcs. The range of random values for the extent and the step size vary between the top and bottom halves of the cloud to create the desired raggedness.

By following these steps and using the provided code as a guide, you can create a random cloud shape using Python Turtle by drawing multiple arcs of varying sizes and extents.

Using a list of random colours

Python's turtle module is a fun and interactive way to create simple drawings and animations using a "turtle" that moves around the screen. The turtle module can be used to draw interesting shapes and drawings, and the random module can be used to generate random numbers, which can be used to create random colours.

Python

Import turtle

Import random

Set up the screen and title

Screen = turtle.Screen()

Screen.setup(1000, 1000)

Screen.title("Random Cloud")

Set the turtle speed and hide the turtle icon

Turtle.speed(0)

Turtle.hideturtle()

Turtle.up()

Set the background colour and pen colour

Turtle.bgcolor('dodger blue')

Turtle.pencolor('white')

Turtle.pensize(2)

Define the ellipse function to create the oval shape for the cloud

Def ellipse(X, Y, a, b, ts, te, P):

T = ts

For i in range(n):

X = a * math.cos(t)

Y = b * math.sin(t)

P.append((x + X, y + Y))

T += (te - ts) / (n - 1)

Define the function to draw an arc between two points with a random extent

Def draw_arc(p1, p2, ext):

Turtle.up()

Turtle.goto(p1)

Turtle.seth(turtle.towards(p2))

A = turtle.heading()

B = 360 - ext

C = (180 - b) / 2

D = a - c

E = d - 90

R = ((p1 [0] - p2 [0]) 2 + (p1 [1] - p2 [1]) 2) 0.5

Turtle.seth(e)

Turtle.down()

Turtle.circle(r, ext, 100)

Return (turtle.xcor(), turtle.ycor())

Define the cloud function to draw the arcs that make up the cloud shape

Def cloud(P):

Step = n // 10

A = 0

B = a + random.randint(step // 2, step * 2)

P1 = P [a]

Turtle.fillcolor(random.choice(colours)) # Choose a random colour from the list of colours

Turtle.begin_fill()

P3 = draw_arc(p1, P [b], random.uniform(70, 180))

While b < len(P) - 1:

P1 = p3

If b < len(P) / 2:

Ext = random.uniform(70, 180)

B += random.randint(step // 2, step * 2)

Else:

Ext = random.uniform(30, 70)

B += random.randint(step, step * 2)

B = min(b, len(P) - 1)

P2 = P [b]

P3 = draw_arc(p1, p2, ext)

Turtle.end_fill()

Create a list of random colours

Colours = []

For i in range(5):

Colours.append((random.randint(0, 255), random.randint(0, 255), random.randint(0, 255)))

Create the oval shape for the cloud

N = 500

P = []

Ellipse(0, 0, 300, 200, 0, math.pi, P)

Ellipse(0, 0, 300, 50, math.pi, math.pi * 2, P)

Draw the cloud using the cloud function

Cloud(P)

In this code, we first import the necessary modules, set up the screen and title, and hide the turtle icon. We then define the `ellipse`, `draw_arc`, and `cloud` functions, which are used to create the cloud shape. The `colours` list is created by generating five random RGB colour tuples. The oval shape for the cloud is created using the `ellipse` function, and finally, the `cloud` function is called to draw the cloud with random colours.

You can modify the code to create different cloud shapes and experiment with different colour combinations to create unique and interesting clouds.

Frequently asked questions