【模板】 计几有关圆的模板

Vector Rotate(Vector A, double rad) {
    return Vector(A.x * cos(rad) - A.y * sin(rad), A.x * sin(rad) + A.y * cos(rad));
}
double angle(Vector v) {return atan2(v.y, v.x);}
struct Circle {
    Point c;
    double r;
    Circle(Point c, double r) {
        this->c = c;
        this->r = r;
    }
    Point point(double a) {
        return Point(c.x + cos(a) * r, c.y + sin(a) * r);
    }
};

Vector AngleBisector(Point p, Vector v1, Vector v2){//给定两个向量，求角平分线
    double rad = Angle(v1, v2);
    return Rotate(v1, dcmp(Cross(v1, v2)) * 0.5 * rad);
}

//求直线与圆的交点
int getLineCircleIntersection(Point p, Vector v, Circle c, vector<point> &sol) {
    double a1 = v.x, b1 = p.x - c.c.x, c1 = v.y, d1 = p.y - c.c.y;
    double e1 = a1 * a1 +  c1 * c1, f1 = 2 * (a1 * b1 + c1 * d1), g1 = b1 * b1 + d1 * d1 - c.r * c.r;
    double delta = f1 * f1 - 4 * e1 * g1, t;
    if(dcmp(delta) < 0) return 0;
    else if(dcmp(delta) == 0){
        t = (-f1) / (2 * e1);
        sol.push_back(p + v * t);
        return 1;
    } else{
        t = (-f1 + sqrt(delta)) / (2 * e1); sol.push_back(p + v * t);
        t = (-f1 - sqrt(delta)) / (2 * e1); sol.push_back(p + v * t);
        return 2;
    }
}

//点到圆的切线
int getTangents(Point p, Circle C, Vector *v) {
    Vector u = C.c - p;
    double dist = Length(u);
    if (dist < C.r) return 0;
    else if (dcmp(dist - C.r) == 0) {
        v[0] = Rotate(u, PI / 2);
        return 1;
    } else {
        double ang = asin(C.r / dist);
        v[0] = Rotate(u, -ang);
        v[1] = Rotate(u, +ang);
        return 2;
    }
}
 
//两圆公切线
//a[i], b[i]分别是第i条切线在圆A和圆B上的切点
int getCircleTangents(Circle A, Circle B, Point *a, Point *b) {
    int cnt = 0;
    if (A.r < B.r) { swap(A, B); swap(a, b); }
    //圆心距的平方
    double d2 = (A.c.x - B.c.x) * (A.c.x - B.c.x) + (A.c.y - B.c.y) * (A.c.y - B.c.y);
    double rdiff = A.r - B.r;
    double rsum = A.r + B.r;
    double base = angle(B.c - A.c);
    //重合有无限多条
    if (d2 == 0 && dcmp(A.r - B.r) == 0) return -1;
    //内切
    if (dcmp(d2 - rdiff * rdiff) == 0) {
        a[cnt] = A.point(base);
        b[cnt] = B.point(base);
        cnt++;
        return 1;
    }
    //有外公切线
    double ang = acos((A.r - B.r) / sqrt(d2));
    a[cnt] = A.point(base + ang); b[cnt] = B.point(base + ang); cnt++;
    a[cnt] = A.point(base - ang); b[cnt] = B.point(base - ang); cnt++;
 
    //一条内切线，两条内切线
    if (dcmp(d2 - rsum*rsum) == 0) {
        a[cnt] = A.point(base); b[cnt] = B.point(PI + base); cnt++;
    } else if (dcmp(d2 - rsum*rsum) > 0) {
        double ang = acos((A.r + B.r) / sqrt(d2));
        a[cnt] = A.point(base + ang); b[cnt] = B.point(pi+base + ang); cnt++;
        a[cnt] = A.point(base - ang); b[cnt] = B.point(pi+base - ang); cnt++;
    }
    return cnt;
}

//求经过点p1,与直线(p2, w)相切,半径为r的一组圆
int CircleThroughAPointAndTangentToALineWithRadius(Point p1, Point p2, Vector w, double r, vector<point> &sol) {
    Circle c1 = Circle(p1, r);
    double t = r / Length(w);
    Vector u = Vector(-w.y, w.x);
    Point p4 = p2 + u * t;
    int tot = getLineCircleIntersection(p4, w, c1, sol);
    u = Vector(w.y, -w.x);
    p4 = p2 + u * t;
    tot += getLineCircleIntersection(p4, w, c1, sol);
    return tot;
}

//给定两个向量，求两向量方向内夹着的圆的圆心。圆与两线均相切，圆的半径已给定
Point Centre_CircleTangentTwoNonParallelLineWithRadius(Point p1, Vector v1, Point p2, Vector v2, double r){
    Point p0 = GetLineIntersection(p1, v1, p2, v2);
    Vector u = AngleBisector(p0, v1, v2);
    double rad = 0.5 * Angle(v1, v2);
    double l = r / sin(rad);
    double t = l / Length(u);
    return p0 + u * t;
}

//求与两条不平行的直线都相切的4个圆，圆的半径已给定
int CircleThroughAPointAndTangentALineWithRadius(Point p1, Vector v1, Point p2, Vector v2, double r, Point *sol) {
    int ans = 0;
    sol[ans++] = Centre_CircleTangentTwoNonParallelLineWithRadius(p1, v1, p2, v2, r);
    sol[ans++] = Centre_CircleTangentTwoNonParallelLineWithRadius(p1, v1 * -1, p2, v2, r);
    sol[ans++] = Centre_CircleTangentTwoNonParallelLineWithRadius(p1, v1, p2, v2 * -1, r);
    sol[ans++] = Centre_CircleTangentTwoNonParallelLineWithRadius(p1, v1 * -1, p2, v2 * -1, r);
    return ans;
}

//求与两个相离的圆均外切的一组圆，三种情况
int CircleTangentToTwoDisjointCirclesWithRadius(Circle c1, Circle c2, double r, Point *sol){
    double dis1 = c1.r + r + r + c2.r;
    double dis2= Length(c1.c - c2.c);
    if(dcmp(dis1 - dis2) < 0) return 0;
    Vector u = c2.c - c1.c;
    double t = (r + c1.r) / Length(u);
    if(dcmp(dis1 - dis2)==0){
        Point p0 = c1.c + u * t;
        sol[0] = p0;
        return 1;
    }
    double aa = Length(c1.c - c2.c);
    double bb = r + c1.r, cc = r + c2.r;
    double rad = acos((aa * aa + bb * bb - cc * cc) / (2 * aa * bb));
    Vector w = Rotate(u, rad);
    Point p0 = c1.c + w * t;
    sol[0] = p0;
    w = Rotate(u, -rad);
    p0 = c1.c + w * t;
    sol[1] = p0;
    return 2;
}

 

 

常用的：

// 点到线段最短距离
double Point_to_Seg(Point p,Point a,Point b){
    if( sgn( dot(a,p,b) ) < 0 ) return dist(p,a);
    if( sgn( dot(b,p,a) ) < 0 ) return dist(p,b);
    return fabs( cross(p,a,b) ) / dist(a,b);
}
struct Circle{
    Point o;
    vector<int> v;
    //圆心发出的射线
    Point getPoint(double deta){
        return (Point){o.x + cos(deta)*R , o.y + sin(deta)*R };
    }
    //判断线段是否和圆相交
    bool is_insert(Point a,Point b){
        double d;
        if( dist(a,b) < eps ) d = dist(a,o);
        else d = Point_to_Seg(o,a,b);
        if( sgn(d  - R) < 0 ) return 1;
        return 0;
    }
}cir[10];
//点到圆切点
int getTangentPoints(Point p,Circle c,Point& r1,Point& r2){
    double d = dist(p,c.o);
    if( sgn(d-R) < 0 ) return 0;
    else if( sgn(d-R) == 0 ){
        r1 = p;        
        return 1;
    }
    else{
        double base = atan2(p.y - c.o.y,p.x - c.o.x);
        double deta = acos( R/d );
        r1 = c.getPoint(base - deta);
        r2 = c.getPoint(base + deta);
        return 2;
    }
}
//两圆公切线
//a[i], b[i]分别是第i条切线在圆A和圆B上的切点
int getCircleTangents(Circle A, Circle B, Point *a, Point *b) {
    int cnt = 0;
    if (A.r < B.r) { swap(A, B); swap(a, b); }
    //圆心距的平方
    double d2 = (A.c.x - B.c.x) * (A.c.x - B.c.x) + (A.c.y - B.c.y) * (A.c.y - B.c.y);
    double rdiff = A.r - B.r;
    double rsum = A.r + B.r;
    double base = angle(B.c - A.c);
    //重合有无限多条
    if (d2 == 0 && dcmp(A.r - B.r) == 0) return -1;
    //内切
    if (dcmp(d2 - rdiff * rdiff) == 0) {
        a[cnt] = A.point(base);
        b[cnt] = B.point(base);
        cnt++;
        return 1;
    }
    //有外公切线
    double ang = acos((A.r - B.r) / sqrt(d2));
    a[cnt] = A.point(base + ang); b[cnt] = B.point(base + ang); cnt++;
    a[cnt] = A.point(base - ang); b[cnt] = B.point(base - ang); cnt++;
 
    //一条内切线，两条内切线
    if (dcmp(d2 - rsum*rsum) == 0) {
        a[cnt] = A.point(base); b[cnt] = B.point(PI + base); cnt++;
    } else if (dcmp(d2 - rsum*rsum) > 0) {
        double ang = acos((A.r + B.r) / sqrt(d2));
        a[cnt] = A.point(base + ang); b[cnt] = B.point(pi+base + ang); cnt++;
        a[cnt] = A.point(base - ang); b[cnt] = B.point(pi+base - ang); cnt++;
    }
    return cnt;
}

 

两圆相交模板：

// p1,p2是交点
inline bool operator<(const Point& lhs, const Point& rhs) {
    if (fabs(lhs.x - rhs.x) > 1e-8) {
        return lhs.x < rhs.x;
    } else if (fabs(lhs.y - rhs.y) > 1e-8) {
        return lhs.y < rhs.y;
    } else {
        return false;
    }
}
double dis(Point a,Point b){
    return sqrt( (a.x - b.x)*(a.x - b.x) + (a.y - b.y)*(a.y - b.y));
}
double sqr(double x){return x*x;}
bool intersection(Point o1, double r1,  Point o2, double r2, Point& p1, Point& p2) {
    double d = dis(o1, o2);
    if (d < fabs(r1 - r2) - eps || d > r1 + r2 + eps) {
        return false;
    }
    double cosa = (sqr(r1) + sqr(d) - sqr(r2)) / (2 * r1 * d);
    double sina = sqrt(max(0.0, 1.0 - sqr(cosa)));
    p1 = p2 = o1;
    p1.x += r1 / d * ((o2.x - o1.x) * cosa + (o2.y - o1.y) * -sina);
    p1.y += r1 / d * ((o2.x - o1.x) * sina + (o2.y - o1.y) * cosa);
    p2.x += r1 / d * ((o2.x - o1.x) * cosa + (o2.y - o1.y) * sina);
    p2.y += r1 / d * ((o2.x - o1.x) * -sina + (o2.y - o1.y) * cosa);
    return true;
}

 

三点求圆心：

Point core(Point a,Point b,Point c){
    Point A=(Point){b.x-a.x,c.x-a.x}*2 , B = (Point){b.y-a.y,c.y-a.y}*2;
    Point C = (Point){ len2(b)-len2(a),len2(c)-len2(a) };
    return (Point){ cross(B,C)/cross(B,A),cross(A,C)/cross(A,B) };
}