Quadratic Region Detection in Java

Understanding the Quadratic Region Concept | Maths Explanation for Java Kids

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

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

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

To visualize the region under a quadratic curve, we'll use Java 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 Java 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 Java tutorial and check for when it enters the region of our curve.

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

Java 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 Java example — Figure: Detecting and visualizing the quadratic region on a Java canvas using Java.

To detect a point inside a parabola using Java, 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 Java project; call it Dymetric.
Create 3 new Java classes; File, New.
Call them Facet, PanelsQuadraticRegion and QuadraticRegion.
Type out the adjoining Java code for detecting the instance a travelling body crosses the boundary of a quadratic curve.

Summary: Detecting Quadratic Boundaries with Java

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

This tutorial teaches you to:

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

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

Java Quadratic Curve Boundary Code - Main Class

package dymetric;

public class Dymetric {

    public static void main(String[] args) {
        Facet lcd = new Facet();
        lcd.setVisible(true);
    }

}

Java Quadratic Curve Boundary Window Setup - Facet Class

package dymetric;

import java.awt.*;
import javax.swing.*;

/**
* This class just creates a display window to attach our canvas to.
*/
public class Facet extends JFrame {

    public Container face;
    public ButtonandCanvasPanels components;
    public ImageIcon logo;

    public Facet() {
        // Give our window a title
        super("A window that will hold a Canvas and Button");
        // set window start points and dimensions
        setSize(780,400);
        // close the window when told to
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        setResizable(true); // should this window be resizable?

        // It'll be nice to have our own logo (feel free to use yours)
        logo = new ImageIcon(getClass().getResource("studyingPays.png"));
        this.setIconImage(logo.getImage());

        face = this.getContentPane();
        // background colour - may not be necessay since our canvas will have a colour of its own
        face.setBackground(Color.PINK);


        components = new ButtonandCanvasPanels();
        // using the default layout manager
        face.add(components.button_panel, BorderLayout.NORTH);
        // attach appropriate drawing component
        face.add(components.canvas_panel, BorderLayout.CENTER);
    }
}

Java Quadratic Curve Boundary Canvas and Button Controls Class

package dymetric;

import java.awt.event.*;
import java.awt.*;
import javax.swing.*;

public class ButtonandCanvasPanels implements ActionListener {
    public JPanel button_panel, canvas_panel;
    public JButton motion_bttn;
    public QuadraticRegion qregion;

    public ButtonandCanvasPanels() {
        button_panel = new JPanel();
        // pick a background colour
        button_panel.setBackground(Color.PINK);
        button_panel.setLayout(new FlowLayout(FlowLayout.CENTER, 0, 0));
        // O my; but for convenience sake let's add our control button here
        motion_bttn = new JButton("Move");
        motion_bttn.setBackground(new Color(255, 0, 255));
        motion_bttn.addActionListener(this);
        // using the default layout manager
        button_panel.add(motion_bttn);


        canvas_panel = new JPanel();
        canvas_panel.setLayout(new BorderLayout());
        qregion = new QuadraticRegion();
        // attach appropriate drawing component
        canvas_panel.add(qregion, BorderLayout.CENTER);
    }

    /**
     * Respond to the button click event
     */
    public void actionPerformed(ActionEvent evt) {
        qregion.checkBoundary();
    }
}

Java Animation Code for Quadratic Region Class

package dymetric;

import java.awt.*;

public class QuadraticRegion extends Canvas {

    Color ball_colour;
    // coordinates for the ball(circle)
    protected int x_ball = 50;
    protected int y_ball = 100;
    protected int previous_x = x_ball;
    protected int previous_y = y_ball;
    protected final int ballWIDTH, ballHEIGHT;

    protected int xq_start = 300;
    protected int yq_start = 50;
    protected int xq_min = 450;
    protected int yq_min = 300;
    protected double xq_lb;
    protected double xq_ub;
    protected int xq_stop = 600;
    protected int x = xq_start;
    protected int y = yq_start;
    protected double a, b, c; // coefficients and constant
    protected double discriminant;
    protected final int aWIDTH, aHEIGHT;

    public QuadraticRegion() {
        setBackground(Color.LIGHT_GRAY); // canvas color
        ball_colour = Color.YELLOW;
        aWIDTH = aHEIGHT = 5;

        // constants
        a = (double) (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);

        ballWIDTH = ballHEIGHT = 100;

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

    // Feel free to double buffer if flickering occurs
    public void paint(Graphics g) {
        //draw quadratic curve
        g.setColor(Color.BLACK);
        for (; x < xq_stop; x++) {
            // redraw dot
            y = (int) Math.round(a * x * x + b * x + c);
            g.fillOval(x, y, aWIDTH, aHEIGHT);
        }
        x = xq_start;

        // erase previous circle
        g.setColor(Color.LIGHT_GRAY);
        g.fillOval(previous_x, previous_y, ballWIDTH, ballHEIGHT);
        g.setColor(ball_colour);
        // draw a circle
        g.fillOval(x_ball, y_ball, ballWIDTH, ballHEIGHT);
        previous_x = x_ball;
        previous_y = y_ball;
    }

    public void checkBoundary() {
        // condition for continuing motion
        while (x_ball <= 630) {
            if ((x_ball <= xq_lb && x_ball+ballWIDTH >= xq_lb)
                    || (x_ball <= xq_ub && x_ball + ballWIDTH >= xq_ub)) {
                ball_colour = Color.RED; // trespassing color for our moving body(circle)
            } else if (x_ball >= xq_lb && x_ball + ballWIDTH <= xq_ub) {
                ball_colour = Color.GREEN; // zone color for our moving body(circle)
            } else {
                ball_colour = Color.YELLOW; // out of zone color for our moving body(circle)
            }
            paint(this.getGraphics());

            x_ball += 5;
            // introduce a delay between renderings
            try {
                Thread.sleep(50);
            } catch (InterruptedException e) {
            }
        }
    }
}

I have a better version / See other versions.