Intersection of a vector with a sphere

Triv Prasad — Sun, 20 May 2018 06:02:13 +0000

A good friend of mine wanted some help with a VR project to see if a ray (controller's motion vector) is intersecting with a spherical viewport of the user. Here's a rudimentary java program to check for a vector intersecting a sphere.

User input <- Coordinates of the two points of the vector and the coordinates of the sphere center and sphere radius
Output -> Coordinates of the point(s) of intersection

Have not programmed in Java for a couple of decades so was an interesting and enriching experience as the program slowly got built out, refined and refactored (to the best of my ability). Sure it's not computationally efficient but hoping to make it an API to use within Unity at some point!

/** Copyright - Trivikram Prasad
    Date: May 19, 2018
    All Rights Reserved
 */

// Program to calculate the points of intersection of a vector with a Sphere
import java.util.Scanner;


// DEFINE ALL CLASSES

// 3D Point class
class Point3D{
    double x,y,z;   //Coordinates of a point

    public Point3D (double x, double y, double z)
    {
        this.x = x;
        this.y = y; 
        this.z = z;
    }
}

// Sphere Class
class Sphere{
    double cX, cY, cZ; // Coordinates of the sphere center
    double cR;      // Radius of sphere

    public Sphere (double cX, double cY, double cZ, double cR)
    {
        this.cX = cX;
        this.cY = cY;
        this.cZ = cZ;
        this.cR = cR;
    }
}

// String class -- only for formatting output
class StringPoint{
    String pX, pY, pZ; // Converting coordinate values to string values for formatting

    public StringPoint (String pX, String pY, String pZ)
    {
        this.pX = pX;
        this.pY = pY;
        this.pZ = pZ;       
    }
}

// The main class. This is where the real s**t happens
public class lineSphereX {
    public static void main(String[] args){
        double a,b,c;   // Coefficients of the quadratic equation
        double discr;   // Square of the discriminant of the quadratic
        double t1 = 0.0; // parameter 1
        double t2 = 0.0; // parameter 2

        Scanner in = new Scanner(System.in);

        // Read coordinates of the first point on the line
        System.out.print("Enter x, y, z coordinates of the 1st point on the line: ");
        Point3D point1 = readLineInputCoordinates(in);

        // Read coordinates of the second point on the line
        System.out.print("Enter x, y, z coordinates of the 2nd point on the line: ");
        Point3D point2 = readLineInputCoordinates(in);

        // Read center coordinates and radius of sphere
        System.out.print("Enter x, y, z center coordinates and RADIUS 'r' of the sphere: ");
        Sphere sphCenter= readSphereInputCoordinates(in);

        in.close();

        //Calculate coefficients: 'a', 'b', 'c' for the equation 'ax^2 + bx + c = 0
        a = Math.pow(point2.x - point1.x,2) + Math.pow(point2.y - point1.y,2) + Math.pow(point2.z - point1.z,2);
        b = 2 * ((point2.x-point1.x) * (point1.x-sphCenter.cX) + (point2.y-point1.y) * (point1.y-sphCenter.cY)+ (point2.z-point1.z) * (point1.z-sphCenter.cZ));
        c = Math.pow((point1.x - sphCenter.cX),2) +  Math.pow((point1.y - sphCenter.cY),2) +  Math.pow((point1.z - sphCenter.cZ),2) - Math.pow(sphCenter.cR, 2);
        discr = Math.pow(b, 2) - (4*a*c);

        // No intersection points`
        if (discr < 0)
        {
            System.out.println("\nVector does not intersect the sphere");
            return;     
        }
        else if(discr == 0)  // Single intersection point
        {

            System.out.println("\nVector intersects the sphere at a single point:");

            if (a > 0)
            {
                t1 = -b/(2*a);

                StringPoint XPoint = findXPoint(point1, point2, t1);

                System.out.println("The tangent to sphere is at " + XPoint.pX + ","+ XPoint.pY + "," + XPoint.pZ + "\n");
            }
            else{
                System.out.println("Not a line\n");
            }
        }

        else // Two intersection points
        {
            System.out.println("\nVector intersects the sphere at two points");
            t1 = (-b - Math.sqrt(discr))/(2*a); // 1st Vector equation parameter
            t2 = (-b + Math.sqrt(discr))/(2*a); // 2nd Vector equation parameter

            // Find the points of intersection
            StringPoint XPoint1 = findXPoint(point1, point2, t1);
            StringPoint XPoint2 = findXPoint(point1, point2, t2);

            System.out.println("1st point of vector intersection with sphere: " + XPoint1.pX + "," + XPoint1.pY + "," + XPoint1.pZ);
            System.out.println("2nd point of vector intersection with sphere: " + XPoint2.pX + "," + XPoint2.pY + "," + XPoint2.pZ + "\n");
        }

        System.exit(0);     
    }

    // Function for user input of sphere center coordinates and radius
    private static Sphere readSphereInputCoordinates(Scanner input) {

        double sphere_ctr [] = new double[4];
        Sphere input_sphere = new Sphere(0,0,0,0);
        for (int i = 0; i < 4; i++)
        {
            sphere_ctr[i] = input.nextDouble();
        }
        input_sphere.cX= sphere_ctr[0];
        input_sphere.cY = sphere_ctr[1];
        input_sphere.cZ = sphere_ctr[2];
        input_sphere.cR = sphere_ctr[3];

        return input_sphere;        
    }

    // Function for user inputs of point coordinates
    private static Point3D readLineInputCoordinates(Scanner input) {

        double line_pt [] = new double[3];
        Point3D input_coords = new Point3D(0,0,0);  
        for (int i = 0; i < 3; i++)
        {
            line_pt[i] = input.nextDouble();
        }
        input_coords.x = line_pt[0];
        input_coords.y = line_pt[1];
        input_coords.z = line_pt[2];

        return input_coords;    
    }

    // Function to calculate the point of intersection
    private static StringPoint findXPoint(Point3D point1, Point3D point2, double t) {

        Point3D intPoint = new Point3D(0,0,0);
        StringPoint XStrPoint = new StringPoint("","","");

        // Parametric equation of the form L = P + tU
        // where 'L' is the intersection point, 'P' is the point on the line and
        // U is the unit vector (Point2 - Point1)
        intPoint.x = point1.x + t * (point2.x - point1.x);
        intPoint.y = point1.y + t * (point2.y - point1.y);      
        intPoint.z = point1.z + t * (point2.z - point1.z);

        XStrPoint = formatString(intPoint);

        return XStrPoint;   
    }

    // Function to format the coordinates to string for display/output to console
    private static StringPoint formatString(Point3D intPoint) {

        StringPoint strPoint = new StringPoint("","","");

        strPoint.pX = String.format("%.2f", intPoint.x);
        strPoint.pY= String.format("%.2f", intPoint.y);
        strPoint.pZ = String.format("%.2f", intPoint.z);

        return strPoint;
    }
}

Area of intersecting circles

Triv Prasad — Thu, 08 Mar 2018 11:34:37 +0000

A few days ago, my daughters wanted to know how to find out the bounded area of two intersecting circles. This program is an attempt to teach them both Trigonometry as well as computer science. We started off doing only the basic condition when both circles play nice and intersect with the distance between centers parallel to the horizontal axis. Slowly, we extended the code to cater for other cases where the circles only touch at one point, may not touch at all or one circle is completely inside the other circle.

Basically, the input takes three parameters -> the distance between the centers of the two circles and the radii of the two circles in question. The common area is the output of the program.

Looking for ways to make this a more optimal program as I'm new to python.

import sys
import math

# Return the area of the smaller circle
def smallercirclearea(r1, r2):
    radsmaller = min(r1, r2)
    return math.pi * radsmaller * radsmaller

def calcAreaIntersectingCircles(d, rad1, rad2):
    rad1sqr = rad1 * rad1
    rad2sqr = rad2 * rad2

    #if the circle centers are the same
    if d == 0:
        print ('\nCircles have the same center. Intersecting area will be area of smaller circle')
        return smallercirclearea(rad1,rad2)

    angle1 = (rad1sqr + (d * d) - rad2sqr) / (2 * rad1 * d)
    angle2 = (rad2sqr + (d * d) - rad1sqr) / (2 * rad2 * d)

    # Check to see if the circles are overlapping
    if ((angle1 < 1 and angle1 >= -1) or (angle2 < 1 and angle2 >= -1)):
        theta1 = (math.acos(angle1) * 2)
        theta2 = (math.acos(angle2) * 2)

        area1 = (0.5 * theta2 * rad2sqr) - (0.5 * rad2sqr * math.sin(theta2))
        area2 = (0.5 * theta1 * rad1sqr) - (0.5 * rad1sqr * math.sin(theta1))

        return area1 + area2
    elif angle1 == 1 and angle2 == 1:
        print ('\nCircles touch at a single degenerate point and do not intersect\n')
        return 0
    elif angle1 < -1 or angle2 < -1:
        print('\nSmaller circle is completely inside the larger circle. Intersecting area will be area of smaller circle')
        return smallercirclearea(rad1,rad2)
    else:
        print ('\nImaginary touch points\n')
        return -1

#Read the distance and radii from the command line
if len(sys.argv) == 4:
    distance = int(sys.argv[1])
    radiusCircle1 = int(sys.argv[2])
    radiusCircle2 = int(sys.argv[3])
    if distance < 0 or radiusCircle1 < 0 or radiusCircle2 < 0:
        print('Values cannot be negative. Goodbye')
        exit(1)

    print('\nThe intersecting area of the two circles is', round(calcAreaIntersectingCircles(float(distance), float(radiusCircle1), float(radiusCircle2)), 2), 'square units\n')
else:
    print('\nNEED 3 VALUES IN THE INPUT!!\n')
    exit(1)

DEV Community: Triv Prasad

Intersection of a vector with a sphere

Area of intersecting circles