Detect Circular Region in Java - Senior Secondary Maths Tutorial

Using the Circle Equation for Region Detection

In this tutorial, you'll learn how to detect a circular region in Java 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 Java Canvas. Understanding how to check whether a point or object lies inside a circle region is useful in Java geometry programming, especially for animations, canvas graphics, and collision detection.

Understanding the Circle Equation | Maths Explanation for Java Kids

As already explained extensively in the How to Draw and Animate a Circle in Java 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 Java

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: Java circle region detection example on Java canvas

Create a new Java project; call it Dymetric.
Create 3 new Java classes; File, New.
Call them Facet, PanelsCircularRegion and CircularRegion.
Type out the adjoining Java code for detecting the instance a travelling body crosses the boundary of a circle.

How the Java 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 Java 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 Java geometry detection.

Key Takeaways on Circular Region Detection in Java

In this tutorial, you've learned that:

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

With just a few lines of Java, 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 Java canvas example that visualizes circle region detection in real time.

FAQs: Circle Equation and Java

What is a circular region in Java?

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

How do you detect a circle boundary in Java?

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 Java game development, collision detection, and animations.

Summary: Visualizing Circular Region in Java

In this lesson, you've learnt how to detect a circular region in Java 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 Java geometry programming through step-by-step examples and code.

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

So! Java 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.

Java Circular Boundary Code - Main Class

package dymetric;

public class Dymetric {

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

}

Java Circular 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 Circular 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 CircularRegion cyc_region;

    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());
        cyc_region = new CircularRegion();
        // attach appropriate drawing component
        canvas_panel.add(cyc_region, BorderLayout.CENTER);
    }

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

Java Animation Code for Circular Region Class

package dymetric;

import java.awt.*;

public class CircularRegion extends Canvas {

    protected Color sq_colour;
    // coordinates for the ball(circle)
    protected int x_square = 10;
    protected int y_square = 150;
    protected int previous_x = x_square;
    protected int previous_y = y_square;
    protected final int sqLENGTH = 100;

    //circle coordinates
    protected int a = 300;
    protected int b = 175;
    protected final int r = 150;
    protected double discriminant;

    public CircularRegion() {
        setBackground(Color.LIGHT_GRAY); // canvas color
        sq_colour = Color.YELLOW;
    }

    // Feel free to double buffer if flickering occurs
    public void paint(Graphics g) {
        // draw a circle
        g.drawOval(a - r, b - r, 2 * r, 2 * r);

        g.clearRect(previous_x, previous_y, sqLENGTH, sqLENGTH); // erase previous square
        // draw square
        g.setColor(sq_colour);
        g.fillRect(x_square, y_square, sqLENGTH, sqLENGTH);
        previous_x = x_square;
        previous_y = y_square;
    }

    public void circledSquare() {
        // condition for continuing motion
        while (x_square + sqLENGTH < 750) {
            int square_left = x_square;
            int square_right = x_square + sqLENGTH;
            int square_top = y_square;
            int square_bottom = y_square + sqLENGTH;
            // determinants for each side of the square
            int x_left_det = (int) Math.round(Math.sqrt(Math.pow(r, 2) - Math.pow((square_left - a), 2)));
            int x_right_det = (int) Math.round(Math.sqrt(Math.pow(r, 2) - Math.pow((square_right - a), 2)));
            int y_up_det = (int) Math.round(Math.sqrt(Math.pow(r, 2) - Math.pow((square_top - b), 2)));
            int y_down_det = (int) Math.round(Math.sqrt(Math.pow(r, 2) - Math.pow((square_bottom - b), 2)));

            // check the bounds of the circle
            if (square_top > b - x_left_det && square_bottom < b + x_left_det
                    && square_top > b - x_right_det && square_bottom < b + x_right_det
                    && square_left > a - y_up_det && square_right < a + y_up_det
                    && square_left > a - y_down_det && square_right < a + y_down_det) {
                sq_colour = Color.GREEN; // color for our moving body(square) inside our circle
            } else {
                sq_colour = Color.YELLOW; // color for our moving body(square) outside our circle
            }

            paint(this.getGraphics());
            // introduce a delay between renderings

            x_square += 10;
            try {
                Thread.sleep(50);
            } catch (InterruptedException e) {
            }
        }
    }
}

I have a better version / See other versions.