Quadratic Region Detection in C# | usingMaths Tutorial

Understanding the Quadratic Region Concept | Maths Explanation for C# Kids

In this tutorial, you'll learn how to detect the region under a quadratic curve using C#. 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 C# windows form.

What is a Quadratic Region? | Maths Explanation for C# Kids

A quadratic region in C# 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 C#

To visualize the region under a quadratic curve, we'll use C# 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.

Remember as discussed in the Animating along a Straight Line in C# tutorial, that 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 C# tutorial and check for when it enters the region of our curve.

visualizing quadratic curve region in C# and ball trajectory crossing into it on C# windows form — Figure: Visualizing quadratic curve region in C# and an object trajectory passing through it on C# windows form.

C# 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 C# example — Figure: Detecting and visualizing the quadratic region on a C# windows form using C#.

To detect a point inside a parabola using C#, 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 a new C# Windows Forms Application project ; call it Dymetric_CS.
Create 2 new classes;
Call them Dymetric and QuadraticRegion.
Type out the adjoining C# code for detecting the instance a travelling body crosses the boundary of a quadratic curve.

Summary: Detecting Quadratic Boundaries with C#

In this senior secondary C# math tutorial, you've learnt how to identify whether a moving point lies inside a quadratic region. We've used simple algebra and the C# 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 C# 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 C#

This tutorial teaches you to:

Compute the region under a quadratic function in C#
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 C# quadratic region detection function. This approach is often used in interactive canvas demos and collision detection algorithms.

So! C# 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 C# windows form. Experiment with different equations and visualize how region boundaries change dynamically in C#. This is a great way to explore the relationship between algebra and geometry in senior secondary mathematics.

C# Quadratic Curve Boundary Window Display Code Stub

Window Display Class Files

C# Quadratic Curve Boundary Code for Dymetric Class

using System.Windows.Forms;

namespace Dymetric
{
    class Dymetric
    {
        private QuadraticRegion quad_region;
        private bool do_simulation;

        public Dymetric(int screen_width, int screen_height)
        {
            quad_region = new QuadraticRegion(screen_width, screen_height);
            do_simulation = false;
        }

        // decide what course of action to take
        public void decideAction(PaintEventArgs e, bool click_check)
        {
            if (do_simulation && click_check)
            {
                // do animation
                quad_region.inPlay(e);
                do_simulation = false;
            }
            else
            {
                // Put ball on screen
                quad_region.clearAndDraw(e);
                do_simulation = true;
            }
        }
    }
}

C# Animation Code for Quadratic Region Class

using System;
using System.Threading;
using System.Drawing;
using System.Windows.Forms;

namespace Dymetric
{
    class QuadraticRegion
    {
        // ball coordinates
        private int x_ball, y_ball, previous_x, previous_y;
        private const int ballDIAMETER = 80;
        // quadratic variables
        private int xq_start, yq_start, xq_min, yq_min, xq_stop, x, y;
        private double xq_lb, xq_ub; // curve lower and upper boundary
        private double a, b, c, discriminant;
        private const int dotDIAMETER = 5;

        // we'll be drawing to and from a bitmap image
        private Bitmap offscreen_bitmap;
        Graphics offscreen_g;

        private Brush ball_colour, dot_colour, bg_colour;

        public QuadraticRegion(int screen_width, int screen_height)
        {
            ball_colour = new SolidBrush(Color.Yellow);
            dot_colour = new SolidBrush(Color.Black);
            bg_colour = new SolidBrush(Color.LightGray);

            // Create bitmap image
            offscreen_bitmap = new Bitmap(screen_width, screen_height - 55,
                System.Drawing.Imaging.PixelFormat.Format24bppRgb);

            // point graphic object to bitmap image
            offscreen_g = Graphics.FromImage(offscreen_bitmap);

            // Set background of bitmap graphic
            offscreen_g.Clear(Color.LightGray);

            previous_x = x_ball = 10;
            previous_y = y_ball = offscreen_bitmap.Height / 2 - ballDIAMETER / 2;

            xq_start = offscreen_bitmap.Width / 2 - 200;
            yq_start = 10;
            xq_min = offscreen_bitmap.Width / 2;
            yq_min = offscreen_bitmap.Height - 70;
            xq_stop = offscreen_bitmap.Width / 2 + 200;

            // constants
            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);

            discriminant = Math.Sqrt(b*b - 4*a*(c - (y_ball - ballDIAMETER / 2)));
            if (a < 0) // a is negative
            {
                xq_lb = (-b + discriminant) / (2 * a); // lower boundary
                xq_ub = (-b - discriminant) / (2 * a); // upper boundary
            }
            else
            {
                xq_lb = (-b - discriminant) / (2 * a); // lower boundary
                xq_ub = (-b + discriminant) / (2 * a); // upper boundary
            }
        }

        // draw first appearance of ball on the screen
        public void clearAndDraw(PaintEventArgs e)
        {
            /*
             * draw to offscreen bitmap
             */
            // draw quadratic curve
            for (x = xq_start; x <= xq_stop; x++)
            {
                y = (int)Math.Round(a * x * x + b * x + c);
                // redraw dot
                offscreen_g.FillEllipse(dot_colour, x, y, dotDIAMETER, dotDIAMETER);
            }

            // clear previous ball
            offscreen_g.FillEllipse(bg_colour, previous_x, previous_y, ballDIAMETER, ballDIAMETER);
            // draw ball
            offscreen_g.FillEllipse(ball_colour, x_ball, y_ball, ballDIAMETER, ballDIAMETER);
            previous_x = x_ball;
            previous_y = y_ball;

            // draw to screen
            Graphics gr = e.Graphics;
            gr.DrawImage(offscreen_bitmap, 0, 55, offscreen_bitmap.Width, offscreen_bitmap.Height);
        }

        // repetitively clear and draw ball on the screen - Simulate motion
        public void inPlay(PaintEventArgs e)
        {
            // condition for continuing motion
            while (x_ball < offscreen_bitmap.Width - ballDIAMETER)
            {
                // yellow outside the quadratic region
                ball_colour = new SolidBrush(Color.Yellow);
                if ((x_ball <= xq_lb && x_ball + ballDIAMETER >= xq_lb)
                    || (x_ball <= xq_ub && x_ball + ballDIAMETER >= xq_ub))
                {
                    // red on the quadratic outline
                    ball_colour = new SolidBrush(Color.Red);
                }
                else if (x_ball >= xq_lb && x_ball + ballDIAMETER <= xq_ub)
                {
                    // green inside the quadratic region
                    ball_colour = new SolidBrush(System.Drawing.Color.Green);
                }

                // redraw ball
                clearAndDraw(e);

                x_ball += 5;
                // take a time pause
                Thread.Sleep(50);
            }
            x_ball = 10;
            y_ball = offscreen_bitmap.Height / 2 - ballDIAMETER / 2;
        }
    }
}

I have a better version / See other versions.