Straight Line Region in C# | Detect When an Object Crosses a Line

Detecting Regions Divided by a Diagonal Line | Maths Explanation for C# Kids

In this tutorial, you'll learn how to detect when an object crosses a straight line in C#. We'll explore how to check which side of a line a point lies on, and how to apply this logic to a C# canvas animation.

When working with graphics or simulations in C#, you might need to check which side of a line a ball or object is on. This technique is common in C# canvas collision detection and helps define regions divided by a line.

Consider a moving body (circle). When it moves across a diagonal straight line, we can perform an action - such as changing the ball's colour - after it crosses from one region to another.

Figure: C# diagram showing object crossing a straight line region

Understanding the Straight Line Equation in C#

We use the slope-intercept formula (y = mx + c) to define boundaries for region detection in C#.

To implement straight line region detection, we'll compare the ball's x-position with the position of the line at the same y-coordinate, using the line equation in C#.
If the ball's midpoint is (x_b, y_b) and the line at that height is (x_l, y_l), then:
x_l = my_d + c
The ball crosses the line when: x_d >= x_l.

Figure: C# straight line region diagram showing object coordinates for line detection

This logic uses the line equation in C# to check when an object moves from one region to another.
This can also help with collision detection and boundary demarcation in C# graphics or HTML canvas.

C# Code: Detecting Line Crossing in Canvas

To determine which side of a diagonal boundary a point belongs to, we use a simple line equation. This C# example demonstrates line region detection using the slope-intercept method.

Create a new C# Windows Forms Application project ; call it Dymetric_CS.
Create 2 new C# classes;
Call them Dymetric and StraightLineRegion.
Type out the adjoining C# code for detecting the instance a travelling body crosses the path of a straight line.
This C# line crossing detection example changes the ball's colour once it moves across the line.

Summary: Detecting Line Boundaries with C#

You've learned how to use the line equation in C# to **detect regions divided by a straight line and trigger actions when objects cross the line**. This simple logic forms the foundation of C# graphics and animation algorithms.

By now, you can use C# to detect when an object crosses a straight line and determine which region it belongs to. This simple mathematical approach is useful for animations, physics simulations, and canvas line region detection.

Applying the Line Region Detection Logic in C#

This tutorial teaches you to:

Detect when a ball crosses a straight or diagonal line.
Identify which side of a line a point lies on.
Create interactive C# canvas projects with region-based logic.

You can extend this principle to handle collision detection, line-segment intersection, or more complex 2D graphics region detection.

So! C# Fun Practice Exercise - Detect Straight Line Boundary

As a fun practice exercise, try modifying the C# code to explore different coordinates and intercepts. This will be a great way to connect mathematics and programming, and help you understand more about C# animations and linear boundaries.

C# Straight Line Boundary Window Display Code Stub

Window Display Class Files

C# Straight Line Boundary Code for Dymetric Class

using System.Windows.Forms;

namespace Dymetric
{
    class Dymetric
    {
        private StraightLineRegion line_region;
        private bool do_simulation;

        public Dymetric(int screen_width, int screen_height)
        {
            line_region = new StraightLineRegion(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
                line_region.inPlay(e);
                do_simulation = false;
            }
            else
            {
                // Put ball on screen
                line_region.clearAndDraw(e);
                do_simulation = true;
            }
        }
    }
}

C# Animation Code for Straight Line Region class

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

namespace Dymetric
{
    class StraightLineRegion
    {
        // ball coordinates
        private int x_ball, y_ball, previous_x, previous_y;
        private const int ballDIAMETER = 80;
        // line variables
        private int x1, y1, x2, y2;
        private double m, c, x_line;

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

        private Brush ball_colour, bg_colour;

        public StraightLineRegion(int screen_width, int screen_height)
        {
            ball_colour = new SolidBrush(Color.Yellow);
            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;

            x1 = offscreen_bitmap.Width / 2 - 100;
            y1 = 10;
            x2 = offscreen_bitmap.Width / 2 + 100;
            y2 = offscreen_bitmap.Height - 50;

            m = (y2 - y1) / (x2 - x1); // slope
            c = (x2 * y1 - x1 * y2) / (x2 - x1); // y-intercept

            // Point where ball will cross line
            x_line = (y_ball - c) / m;
        }

        // draw first appearance of ball on the screen
        public void clearAndDraw(PaintEventArgs e)
        {
            /*
             * draw to offscreen bitmap
             */
            // draw line
            offscreen_g.DrawLine(Pens.Black, x1, y1, x2, y2);

            // 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)
            {
                // redraw ball
                clearAndDraw(e);

                x_ball += 10;
                // 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.