Task: Line circle intersection


C++: #include <iostream>
#include <utility>
#include <vector>

using Point = std::pair<double, double>;
constexpr auto eps = 1e-14;

std::ostream &operator<<(std::ostream &os, const Point &p) {
    auto x = p.first;
    if (x == 0.0) {
        x = 0.0;
    }
    auto y = p.second;
    if (y == 0.0) {
        y = 0.0;
    }
    return os << '(' << x << ", " << y << ')';
}

template <typename T>
std::ostream &operator<<(std::ostream &os, const std::vector<T> &v) {
    auto itr = v.cbegin();
    auto end = v.cend();

    os << '[';
    if (itr != end) {
        os << *itr;
        itr = std::next(itr);
    }
    while (itr != end) {
        os << ", " << *itr;
        itr = std::next(itr);
    }
    return os << ']';
}

double sq(double x) {
    return x * x;
}

std::vector<Point> intersects(const Point &p1, const Point &p2, const Point &cp, double r, bool segment) {
    std::vector<Point> res;
    auto x0 = cp.first;
    auto y0 = cp.second;
    auto x1 = p1.first;
    auto y1 = p1.second;
    auto x2 = p2.first;
    auto y2 = p2.second;
    auto A = y2 - y1;
    auto B = x1 - x2;
    auto C = x2 * y1 - x1 * y2;
    auto a = sq(A) + sq(B);
    double b, c;
    bool bnz = true;
    if (abs(B) >= eps) {
        b = 2 * (A * C + A * B * y0 - sq(B) * x0);
        c = sq(C) + 2 * B * C * y0 - sq(B) * (sq(r) - sq(x0) - sq(y0));
    } else {
        b = 2 * (B * C + A * B * x0 - sq(A) * y0);
        c = sq(C) + 2 * A * C * x0 - sq(A) * (sq(r) - sq(x0) - sq(y0));
        bnz = false;
    }
    auto d = sq(b) - 4 * a * c; 
    if (d < 0) {
        return res;
    }

    
    auto within = [x1, y1, x2, y2](double x, double y) {
        auto d1 = sqrt(sq(x2 - x1) + sq(y2 - y1));  
        auto d2 = sqrt(sq(x - x1) + sq(y - y1));    
        auto d3 = sqrt(sq(x2 - x) + sq(y2 - y));    
        auto delta = d1 - d2 - d3;
        return abs(delta) < eps;                    
    };

    auto fx = [A, B, C](double x) {
        return -(A * x + C) / B;
    };

    auto fy = [A, B, C](double y) {
        return -(B * y + C) / A;
    };

    auto rxy = [segment, &res, within](double x, double y) {
        if (!segment || within(x, y)) {
            res.push_back(std::make_pair(x, y));
        }
    };

    double x, y;
    if (d == 0.0) {
        
        if (bnz) {
            x = -b / (2 * a);
            y = fx(x);
            rxy(x, y);
        } else {
            y = -b / (2 * a);
            x = fy(y);
            rxy(x, y);
        }
    } else {
        
        d = sqrt(d);
        if (bnz) {
            x = (-b + d) / (2 * a);
            y = fx(x);
            rxy(x, y);
            x = (-b - d) / (2 * a);
            y = fx(x);
            rxy(x, y);
        } else {
            y = (-b + d) / (2 * a);
            x = fy(y);
            rxy(x, y);
            y = (-b - d) / (2 * a);
            x = fy(y);
            rxy(x, y);
        }
    }

    return res;
}

int main() {
    std::cout << "The intersection points (if any) between:\n";

    auto cp = std::make_pair(3.0, -5.0);
    auto r = 3.0;
    std::cout << "  A circle, center " << cp << " with radius " << r << ", and:\n";

    auto p1 = std::make_pair(-10.0, 11.0);
    auto p2 = std::make_pair(10.0, -9.0);
    std::cout << "    a line containing the points " << p1 << " and " << p2 << " is/are:\n";
    std::cout << "     " << intersects(p1, p2, cp, r, false) << '\n';

    p2 = std::make_pair(-10.0, 12.0);
    std::cout << "    a segment starting at " << p1 << " and ending at " << p2 << " is/are:\n";
    std::cout << "     " << intersects(p1, p2, cp, r, true) << '\n';

    p1 = std::make_pair(3.0, -2.0);
    p2 = std::make_pair(7.0, -2.0);
    std::cout << "    a horizontal line containing the points " << p1 << " and " << p2 << " is/are:\n";
    std::cout << "     " << intersects(p1, p2, cp, r, false) << '\n';

    cp = std::make_pair(0.0, 0.0);
    r = 4.0;
    std::cout << "  A circle, center " << cp << " with radius " << r << ", and:\n";

    p1 = std::make_pair(0.0, -3.0);
    p2 = std::make_pair(0.0, 6.0);
    std::cout << "    a vertical line containing the points " << p1 << " and " << p2 << " is/are:\n";
    std::cout << "     " << intersects(p1, p2, cp, r, false) << '\n';
    std::cout << "    a vertical segment containing the points " << p1 << " and " << p2 << " is/are:\n";
    std::cout << "     " << intersects(p1, p2, cp, r, true) << '\n';

    cp = std::make_pair(4.0, 2.0);
    r = 5.0;
    std::cout << "  A circle, center " << cp << " with radius " << r << ", and:\n";

    p1 = std::make_pair(6.0, 3.0);
    p2 = std::make_pair(10.0, 7.0);
    std::cout << "    a line containing the points " << p1 << " and " << p2 << " is/are:\n";
    std::cout << "     " << intersects(p1, p2, cp, r, false) << '\n';

    p1 = std::make_pair(7.0, 4.0);
    p2 = std::make_pair(11.0, 8.0);
    std::cout << "    a segment starting at " << p1 << " and ending at " << p2 << " is/are:\n";
    std::cout << "     " << intersects(p1, p2, cp, r, true) << '\n';

    return 0;
}



Go: package main

import (
    "fmt"
    "math"
)

const eps = 1e-14 

type point struct{ x, y float64 }

func (p point) String() string {
    
    
    if p.x == 0 {
        p.x = 0
    }
    if p.y == 0 {
        p.y = 0
    }
    return fmt.Sprintf("(%g, %g)", p.x, p.y)
}

func sq(x float64) float64 { return x * x }




func intersects(p1, p2, cp point, r float64, segment bool) []point {
    var res []point
    x0, y0 := cp.x, cp.y
    x1, y1 := p1.x, p1.y
    x2, y2 := p2.x, p2.y
    A := y2 - y1
    B := x1 - x2
    C := x2*y1 - x1*y2
    a := sq(A) + sq(B)
    var b, c float64
    var bnz = true
    if math.Abs(B) >= eps { 
        b = 2 * (A*C + A*B*y0 - sq(B)*x0)
        c = sq(C) + 2*B*C*y0 - sq(B)*(sq(r)-sq(x0)-sq(y0))
    } else {
        b = 2 * (B*C + A*B*x0 - sq(A)*y0)
        c = sq(C) + 2*A*C*x0 - sq(A)*(sq(r)-sq(x0)-sq(y0))
        bnz = false
    }
    d := sq(b) - 4*a*c 
    if d < 0 {
        
        return res
    }

    
    within := func(x, y float64) bool {
        d1 := math.Sqrt(sq(x2-x1) + sq(y2-y1)) 
        d2 := math.Sqrt(sq(x-x1) + sq(y-y1))   
        d3 := math.Sqrt(sq(x2-x) + sq(y2-y))   
        delta := d1 - d2 - d3
        return math.Abs(delta) < eps 
    }

    var x, y float64
    fx := func() float64 { return -(A*x + C) / B }
    fy := func() float64 { return -(B*y + C) / A }
    rxy := func() {
        if !segment || within(x, y) {
            res = append(res, point{x, y})
        }
    }

    if d == 0 {
        
        if bnz {
            x = -b / (2 * a)
            y = fx()
            rxy()
        } else {
            y = -b / (2 * a)
            x = fy()
            rxy()
        }
    } else {
        
        d = math.Sqrt(d)
        if bnz {
            x = (-b + d) / (2 * a)
            y = fx()
            rxy()
            x = (-b - d) / (2 * a)
            y = fx()
            rxy()
        } else {
            y = (-b + d) / (2 * a)
            x = fy()
            rxy()
            y = (-b - d) / (2 * a)
            x = fy()
            rxy()
        }
    }
    return res
}

func main() {
    cp := point{3, -5}
    r := 3.0
    fmt.Println("The intersection points (if any) between:")
    fmt.Println("\n  A circle, center (3, -5) with radius 3, and:")
    fmt.Println("\n    a line containing the points (-10, 11) and (10, -9) is/are:")
    fmt.Println("     ", intersects(point{-10, 11}, point{10, -9}, cp, r, false))
    fmt.Println("\n    a segment starting at (-10, 11) and ending at (-11, 12) is/are")
    fmt.Println("     ", intersects(point{-10, 11}, point{-11, 12}, cp, r, true))
    fmt.Println("\n    a horizontal line containing the points (3, -2) and (7, -2) is/are:")
    fmt.Println("     ", intersects(point{3, -2}, point{7, -2}, cp, r, false))
    cp = point{0, 0}
    r = 4.0
    fmt.Println("\n  A circle, center (0, 0) with radius 4, and:")
    fmt.Println("\n    a vertical line containing the points (0, -3) and (0, 6) is/are:")
    fmt.Println("     ", intersects(point{0, -3}, point{0, 6}, cp, r, false))
    fmt.Println("\n    a vertical segment starting at (0, -3) and ending at (0, 6) is/are:")
    fmt.Println("     ", intersects(point{0, -3}, point{0, 6}, cp, r, true))
    cp = point{4, 2}
    r = 5.0
    fmt.Println("\n  A circle, center (4, 2) with radius 5, and:")
    fmt.Println("\n    a line containing the points (6, 3) and (10, 7) is/are:")
    fmt.Println("     ", intersects(point{6, 3}, point{10, 7}, cp, r, false))
    fmt.Println("\n    a segment starting at (7, 4) and ending at (11, 8) is/are:")
    fmt.Println("     ", intersects(point{7, 4}, point{11, 8}, cp, r, true))
    cp = point{10, 10}
    r = 5.0
    fmt.Println("\n  A circle, center (10, 10) with radius 5, and:")
    fmt.Println("\n    a vertical line containing the points (5, 0) and (5, 20) is/are:")
    fmt.Println("     ", intersects(point{5, 0}, point{5, 20}, cp, r, false))
    fmt.Println("\n    a horizontal segment starting at (-5, 10) and ending at (5, 10) is/are:")
    fmt.Println("     ", intersects(point{-5, 10}, point{5, 10}, cp, r, true))
}