Computational Geometry - Algorithms for Geometry

class Point {
    double x, y;

    Point(double x, double y) {
        this.x = x;
        this.y = y;
    }
}

class Line {
    Point p, q;

    Line(Point p, Point q) {
        this.p = p;
        this.q = q;
    }
}

public class Main {
    // Function to check if two lines intersect
    static boolean doIntersect(Line l1, Line l2) {
        return false;
    }

    // Function to compute the intersection point of two lines
    static Point computeIntersection(Line l1, Line l2) {
        double x1 = l1.p.x, y1 = l1.p.y;
        double x2 = l1.q.x, y2 = l1.q.y;
        double x3 = l2.p.x, y3 = l2.p.y;
        double x4 = l2.q.x, y4 = l2.q.y;

        double denom = (y4 - y3) * (x2 - x1) - (x4 - x3) * (y2 - y1);
        double num1 = (x4 - x3) * (y1 - y3) - (y4 - y3) * (x1 - x3);
        double num2 = (x2 - x1) * (y1 - y3) - (y2 - y1) * (x1 - x3);

        if (denom == 0) {
            // Lines are parallel
            return new Point(Double.POSITIVE_INFINITY, Double.POSITIVE_INFINITY);
        }

        double ua = num1 / denom;
        double ub = num2 / denom;

        if (ua >= 0 && ua <= 1 && ub >= 0 && ub <= 1) {
            // Intersection point lies on both line segments
            double x = x1 + ua * (x2 - x1);
            double y = y1 + ua * (y2 - y1);
            return new Point(x, y);
        }

        // Lines do not intersect
        return new Point(Double.POSITIVE_INFINITY, Double.POSITIVE_INFINITY);
    }

    // Driver's code
    public static void main(String[] args) {
        Line l1 = new Line(new Point(0, 0), new Point(1, 1));
        Line l2 = new Line(new Point(0, 1), new Point(1, 0));

        if (doIntersect(l1, l2)) {
            // Function call
            Point p = computeIntersection(l1, l2);
            System.out.println("Intersection point: (" + p.x + ", " + p.y + ")");
        } else {
            System.out.println("Lines do not intersect");
        }
    }
}

import java.util.Arrays;
import java.util.Stack;

// Class representing a 2D point
class Point {
    int x, y;

    Point(int x, int y) {
        this.x = x;
        this.y = y;
    }
}

public class ConvexHullGrahamScan {

    static Point p0; // Reference point for sorting and orientation

    // Function to compare two points based on their polar angles
    static int compare(Point p1, Point p2) {
        // Calculate orientation using cross product of vectors p0p1 and p0p2
        int orientation = (p1.y - p0.y) * (p2.x - p1.x) - (p1.x - p0.x) * (p2.y - p1.y);

        // If points are collinear, sort by distance from p0
        if (orientation == 0) {
            return Integer.compare(p1.x + p1.y, p2.x + p2.y);
        }
        return (orientation < 0) ? -1 : 1;
    }

    // Function to determine orientation of three points
    static int orientation(Point p, Point q, Point r) {
        int val = (q.y - p.y) * (r.x - q.x) - (q.x - p.x) * (r.y - q.y);
        if (val == 0) {
            return 0; // Collinear
        }
        return (val > 0) ? 1 : 2; // 1 for clockwise, 2 for counterclockwise
    }

    // Function to find the convex hull of a set of points
    static void convexHull(Point[] points) {
        int n = points.length;

        // Find the point with the lowest y-coordinate (and leftmost if ties)
        int ymin = points[0].y;
        int min = 0;
        for (int i = 1; i < n; i++) {
            int y = points[i].y;
            if ((y < ymin) || (ymin == y && points[i].x < points[min].x)) {
                ymin = points[i].y;
                min = i;
            }
        }

        // Swap the lowest point with the first point
        Point temp = points[0];
        points[0] = points[min];
        points[min] = temp;

        // Set the lowest point as the reference point
        p0 = points[0];

        // Sort the points based on polar angle with respect to p0
        Arrays.sort(points, 1, n, ConvexHullGrahamScan::compare);

        int m = 1; // Initialize the modified size of points[] after removing collinear points

        // Remove collinear points except for the farthest
        for (int i = 1; i < n; i++) {
            while (i < n - 1 && orientation(p0, points[i], points[i + 1]) == 0) {
                i++;
            }
            points[m] = points[i];
            m++;
        }

        if (m < 3) {
            return; // Convex hull not possible with less than 3 points
        }

        // Create a stack to store points on the convex hull
        Stack<Point> hull = new Stack<>();
        hull.push(points[0]);
        hull.push(points[1]);
        hull.push(points[2]);

        // Process remaining points to find the convex hull
        for (int i = 3; i < n; i++) {
            while (hull.size() > 1 && orientation(hull.get(hull.size() - 2), hull.peek(), points[i]) != 2) {
                hull.pop();
            }
            hull.push(points[i]);
        }

        // Print vertices of the convex hull
        System.out.println("Vertices of the convex hull:");
        while (!hull.isEmpty()) {
            Point p = hull.pop();
            System.out.println("(" + p.x + ", " + p.y + ")");
        }
    }

    public static void main(String[] args) {
        // Test points
        Point[] points = { new Point(0, 3), new Point(1, 1), new Point(2, 2), new Point(4, 4),
                new Point(0, 0), new Point(1, 2), new Point(3, 1), new Point(3, 3) };

        // Find and print the convex hull of the points
        convexHull(points);
    }
}