Detect Circular Region in Python - Senior Secondary Maths Tutorial

Using the Circle Equation for Region Detection

In this tutorial, you'll learn how to detect a circular region in Python using the circle equation. The equation of a circle, (x - a)² + (y - b)² = r², defines all points (x, y) that are exactly r units away from the center (a, b). This formula helps determine whether a point or moving object lies inside or outside a circular region on an Turtle Canvas. Understanding how to check whether a point or object lies inside a circle region is useful in Python geometry programming, especially for animations, canvas graphics, and collision detection.

Understanding the Circle Equation | Maths Explanation for Python Kids

As already explained extensively in the How to Draw and Animate a Circle in Python tutorial, the equation of a circle with centre (a, b) and radius (r) is: (x - a)² + (y - b)² = r² ;
It can be deduced that y = b ± √(r² - (x - a)²) ;
And conversely x = a ± √(r² - (y - b)²).

Hence, the boundaries of any circle lie in the range
b - √(r² - (x_external - a)²) ≤ y ≤ b + √(r² - (x_external - a)²)
and
a - √(r² - (y_external - b)²) ≤ x ≤ a + √(r² - (y_external - b)²)

In other words,
* If (x, y) satisfies this equation, the point lies on the circle.
* If (x - a)^2 + (y - b)^2 < r^2, the point is inside the circular region.
* If (x - a)^2 + (y - b)^2 > r^2, the point is outside the circle.

Algorithm to Detect Entrance into Circular Region in Python

To detect when a second shape enters the circle, we use its coordinates in the circle equation to check if they fall within the upper, lower, left, and right boundaries:
That is, whether the y position of the second body lies between the top and bottom limits of the circle boundary at the x position of the second body:
y_{2nd_img}(top) > b - √(r² - (x_{2nd_img} - a)²)
and y_{2nd_img}(bottom) < b + √(r² - (x_{2nd_img} - a)²) ;
And at the same time, whether the x position of the second body lies between the left and right limits of the circle boundary at the y position of the second body:
x_{2nd_img}(left) > a - √(r² - (y_{2nd_img} - b)²)
and x_{2nd_img}(right) < a + √(r² - (y_{2nd_img} - b)²)

Figure: Python circle region detection example on Turtle canvas

Create 2 new Python files; File, New File.
Call them Facet.py and CircularRegion.py.
Type out the adjoining Python / Turtle code for detecting the instance a travelling body crosses the boundary of a circle.

Important: When trying to click on the button to get things started, you might need to click away from the button text.

How the Python Circular Region Detection Code Works

The code compares the distance of a point from the circle's centre with the radius. If the distance is smaller than or equal to the radius, the point is inside the circular region.

🟢 A green point shows it's inside the circular region.
🔴 A red point shows it's outside.

The code above demonstrates Python circle collision detection, a common concept in canvas-based animations and game design. This example shows how maths meets programming - turning the circle equation into real-time Python geometry detection.

Key Takeaways on Circular Region Detection in Python

In this tutorial, you've learned that:

The circle equation defines a circular region mathematically.
With a few lines of Python code, you can detect whether a point is inside or outside the circle.
This principle links senior secondary maths and practical Python applications, preparing you for real-world coding projects.

With just a few lines of Python, you've been able to check when a point enters or leaves a circular boundary - a technique useful in games, animations, and simulations. The tutorial also features a Python canvas example that visualizes circle region detection in real time.

FAQs: Circle Equation and Python

What is a circular region in Python?

A circular region refers to the area within a circle defined by its radius on the Turtle canvas. In Python, you can detect whether a point or shape lies inside it using the circle equation.

How do you detect a circle boundary in Python?

You can calculate the distance between a point and the circle's center and compare it to the radius - if the distance is less than the radius, the point is inside the circle.

Can this be used for games or simulations?

Yes! Circle region detection is common in Python game development, collision detection, and animations.

Summary: Visualizing Circular Region in Python

In this lesson, you've learnt how to detect a circular region in Python using the circle equation from coordinate geometry: (x - a)² + (y - b)² = r².

This powerful formula helps determine whether a point or object is inside, on, or outside a circle. It connects senior secondary mathematics with Python geometry programming through step-by-step examples and code.

By combining mathematics and Python coding, you can easily detect when objects cross a circular boundary. This exercise strengthens your understanding of circle equations and introduces essential concepts in Python graphics programming.

So! Python Fun Practice Exercise - Detect Circular Region

As a fun practice exercise, try changing the values of (a), (b), (r), (x), and (y) to test different points and circle sizes. You can also extend this idea to moving body detection inside a circle, or collision detection in small games and interactive animations.

Python Circular Boundary Code for Turtle Template - Facet Class

import turtle

class Template:
    def __init__(self):
        screen = turtle.getscreen()
        screen.title("usingMaths.com")
        screen.setup(width=0.9, height=0.9, startx=None, starty=None)
        screen.colormode(255)
        self.bgcolour = "#cccccc"
        screen.bgcolor(self.bgcolour)
        screen.delay(0)
        self.screen = screen

        self.wnd_width = self.screen.window_width()
        self.wnd_height = self.screen.window_height()

    def controlButtons(self):
        self.button = turtle.clone()

        turtle.speed(0)
        turtle.penup()
        turtle.setposition(-self.wnd_width/2, self.wnd_height/2)
        turtle.color("black", "pink")

        turtle.pendown()
        # draw button region
        turtle.begin_fill()
        turtle.forward(self.wnd_width)
        turtle.right(90)
        turtle.forward(50)
        turtle.right(90)
        turtle.forward(self.wnd_width)
        turtle.right(90)
        turtle.forward(50)
        turtle.end_fill()

        self.button.speed(0)
        self.button.penup()
        # draw button
        self.button.setposition(0, self.wnd_height/2 - 25)
        self.button.shape("square")
        self.button.resizemode("user")
        self.button.shapesize(2, 8)
        self.button.color("black", (255, 0, 255))

        return turtle.getturtle()

Python Animation Code for Circular Region File

#!usr/bin/env python3

import math
from Facet import Template

def prep():
    global sq_colour, x_square, y_square, a, b, r, turtle_radius

    # bind fun function
    scene.button.onrelease(play)

    # square parameters
    diameter = 5
    sq_colour = "#ffff00"
    x_square = 100 - scene.wnd_width/2; y_square = 0

    # centre point
    a = 0
    b = 0
    r = round(scene.wnd_height / 3)
    # draw circle
    turtle.penup()
    turtle.setposition(a+r, b)
    turtle.pendown()
    turtle.circle(r)

    turtle.penup()
    # button text
    turtle.setposition(scene.button.xcor(), scene.button.ycor()-10)
    turtle.pendown()
    turtle.write("Move", align="center", font=("Arial",16,"bold"))

    screen.delay(20)

    # transform turtle into a square
    turtle.penup()
    turtle.setposition(x_square, y_square)
    turtle.setheading(0)
    turtle.shape("turtle")
    turtle.shapesize(diameter, diameter)
    turtle.color(sq_colour, sq_colour)

    turtle_radius = 10*turtle.shapesize()[1]

# fun function when button is clicked
# just moves turtle until it hits the right boundary
def play(x, y):
    global sq_colour, x_square, y_square, a, b, r, turtle_radius

    if x_square < scene.wnd_width/2 - turtle_radius:

        square_left = x_square - turtle_radius
        square_right = x_square + turtle_radius
        square_top = y_square + turtle_radius
        square_bottom = y_square - turtle_radius

        # determinants for each side of the square
        x_left_det = math.sqrt(abs(math.pow(r, 2) - math.pow((square_left - a), 2)))
        x_right_det = math.sqrt(abs(math.pow(r, 2) - math.pow((square_right - a), 2)))
        y_up_det = math.sqrt(abs(math.pow(r, 2) - math.pow((square_top - b), 2)))
        y_down_det = math.sqrt(abs(math.pow(r, 2) - math.pow((square_bottom - b), 2)))

        # yellow outside the circle
        sq_colour = "#ffff00"
        if square_top > b - x_left_det and square_bottom < b + x_left_det and\
           square_top > b - x_right_det and square_bottom < b + x_right_det and\
           square_left > a - y_up_det and square_right < a + y_up_det and\
           square_left > a - y_down_det and square_right < a + y_down_det:
            # green inside the circle
            sq_colour = "#00ff00"
        turtle.color(sq_colour, sq_colour)

        # change ball's coordinates
        turtle.setposition(x_square, y_square)

        x_square += 10
        screen.ontimer(play(0,0), 500)
    else:
        x_square = 100 - scene.wnd_width/2; y_square = 0
        screen.mainloop()

# Let fly
scene = Template();
turtle = scene.controlButtons()
screen = scene.screen

prep()

I have a better version / See other versions.