Quadratic Region Detection in Python

Understanding the Quadratic Region Concept | Maths Explanation for Python Kids

In this tutorial, you'll learn how to detect the region under a quadratic curve using Python. The curve is defined by the equation y = a x² + b x + c, and we'll use the discriminant method to find when a point or object lies within the quadratic region. This concept helps students connect algebraic reasoning with programming and visualization using the Turtle canvas.

What is a Quadratic Region? | Maths Explanation for Python Kids

A quadratic region in Python represents the area bounded by a quadratic curve. Every quadratic equation has two x-values (roots) for any given y - except at its turning point (maximum or minimum).
We can use these roots as boundaries for region detection.

More technically, a quadratic region is the area defined by a quadratic inequality such as y ≤ ax² + bx + c.
This concept is useful in computer graphics, physics simulations, and quadratic curve collision detection (JS) projects.

Checking the Boundaries of a Quadratic Curve in Python

To visualize the region under a quadratic curve, we'll use Python to calculate the upper and lower limits dynamically. This makes it possible to detect when an object (like a moving ball) enters or exits the quadratic region.

As discussed in the Animating along a Straight Line in Python tutorial, any quadratic equation always have two roots for any value of y (except at it's maximum or minimum point).
All we need to do is use these two roots (x values) as boundaries for our check.
y = ax² + bx + c
ax² + bx + (c-y) = 0

x =	-b ± √(b² - 4a(c-y))
	2a

Our range will then be:

-b - √(b² - 4a(c-y))	≤ x ≤	-b + √(b² - 4a(c-y))
2a	≤ x ≤	2a

where a, b, and c are constants.
We will reuse the moving ball graphic from the Solving and Animating a Quadratic Equation in Python tutorial and check for when it enters the region of our curve.

visualizing quadratic curve region in Python and ball trajectory crossing into it on Turtle canvas — Figure: Visualizing quadratic curve region in Python and an object trajectory passing through it on Turtle canvas.

Python Code Example: Detecting Entrance into a Quadratic Region

To check for when our ball enters the quadratic curve, we will continually check the x position of the ball against the x position gotten using the quadratic equation at the same y position as that of the ball.

We'll designate the coordinates of the ball as (x_b, y_b), and those of the curve as (x_q, y_q).

Canvas quadratic region detection Python example — Figure: Detecting and visualizing the quadratic region on a Turtle canvas using Python.

To detect a point inside a parabola using Python, you can compare its coordinates to the quadratic curve. We'll determine whether a moving ball lies within this region by solving for x using the quadratic formula. If y is less than or equal to the value of the quadratic equation, the point lies within the region.

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

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

Summary: Detecting Quadratic Boundaries with Python

In this senior secondary Python math tutorial, you've learnt how to identify whether a moving point lies inside a quadratic region. We've used simple algebra and the Python canvas to visualize and draw the quadratic region bounded by a parabolic curve.

Formula Recap:

The general form of a quadratic equation is y = a x² + b x + c. To find the region under the curve, we can rearrange this equation to get a x² + b x + (c - y) = 0 and use the discriminant D = b² - 4a(c - y).

For any given y-value, if D is positive, the quadratic crosses that y-level at two x-values. The region between these two x-values represents the quadratic region.

y = ax² + bx + c
⟹ ax² + bx + (c - y) = 0
⟹ x = (-b ± √(b² - 4a(c - y))) / 2a

Thus, the quadratic region boundaries are:
(-b - √(b² - 4a(c - y))) / 2a ≤ x ≤ (-b + √(b² - 4a(c - y))) / 2a

Understanding how to compute and visualize quadratic regions in Python bridges mathematical theory and practical coding. It helps students apply concepts from coordinate geometry in a real-world programming context.

Applying the Line Region Detection Logic in Python

This tutorial teaches you to:

Compute the region under a quadratic function in Python
Use real-time region detection to track an object's position
Apply mathematical concepts like discriminants and boundaries in interactive graphics

To determine if a point lies inside a quadratic region, we've used a Python quadratic region detection function. This approach is often used in interactive canvas demos and collision detection algorithms.

So! Python Fun Practice Exercise - Detect Quadratic curve Boundary

As a fun practice exercise, try experimenting with different coefficients (a, b, and c) to see how the quadratic region changes shape. You can also animate a point moving across the screen to test when it enters or exits the region on the Turtle canvas. Experiment with different equations and visualize how region boundaries change dynamically in Python. This is a great way to explore the relationship between algebra and geometry in senior secondary mathematics.

Python Quadratic Curve 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 Quadratic Region File

#!usr/bin/env python3

import math
from Facet import Template

def prep():
    global ball_colour, x_ball, y_ball, xq_lb, xq_ub, turtle_radius

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

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

    # ball parameters
    diameter = 5
    ball_colour = "#ffff00"
    x_ball = 100 - scene.wnd_width/2; y_ball = 0

    # quadratic curve parameters
    xq_start = -200; yq_start = scene.wnd_height/3
    xq_min = 0; yq_min = -scene.wnd_height/3

    a = (yq_start - yq_min) / math.pow((xq_start - xq_min), 2)
    b = -2*a*xq_min
    c = yq_min + a*math.pow(xq_min, 2)

    # curve bounds
    discriminant = math.sqrt(b*b - 4*a*(c - y_ball))
    if a < 0:
        xq_lb = (-b + discriminant) / (2*a)
        xq_ub = (-b - discriminant) / (2*a)
    else:
        xq_lb = (-b - discriminant) / (2*a)
        xq_ub = (-b + discriminant) / (2*a)

    # draw quadratic curve
    xq = xq_start; yq = yq_start
    turtle.penup()
    turtle.setposition(xq, yq)
    turtle.pendown()
    while xq <= -xq_start:
        yq = a*xq*xq + b*xq + c
        turtle.setposition(xq, yq)
        xq += 1

    screen.delay(20)

    # transform turtle into a ball
    turtle.penup()
    turtle.setposition(x_ball, y_ball)
    turtle.setheading(0)
    turtle.shape("turtle")
    turtle.shapesize(diameter, diameter)
    turtle.color(ball_colour, ball_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 x_ball, y_ball, ball_colour, xq_lb, xq_ub, turtle_radius

    if x_ball < scene.wnd_width/2 - turtle_radius:
        # yellow outside the quadratic region
        ball_colour = "#ffff00"
        if (x_ball - turtle_radius <= xq_lb and x_ball + turtle_radius >= xq_lb) or\
           (x_ball - turtle_radius <= xq_ub and x_ball + turtle_radius >= xq_ub):
            # red on the quadratic outline
            ball_colour = "#ff0000"
        elif x_ball - turtle_radius >= xq_lb and x_ball + turtle_radius <= xq_ub:
            # green inside the quadratic region
            ball_colour = "#00ff00"
        turtle.color(ball_colour, ball_colour)

        # change ball's coordinates
        turtle.setposition(x_ball, y_ball)

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

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

prep()

I have a better version / See other versions.