Uva 12304 2D Geometry 110 in 1!（圆综合题）

题目地址：https://uva.onlinejudge.org/index.php?option=com_onlinejudge&Itemid=8&page=show_problem&problem=3726

思路：居然错在了求内切圆gg。

1.求外接圆：

求出任意两条垂直平分线，求交点即可。

2.求内切圆：

设三角形三点坐标分别为(x1, y1), (x2, y2), (x3, y3)，则三角形的内心坐标(X, Y)为： 
X = (BC*x1 + AC*x2 + AB*x3)/(BC + AC + AB) 
Y = (BC*y1 + AC*y2 + AB*y3)/(BC + AC + AB)
3.求过定点圆的切线：设定点为p，切点为q，圆心为c。则先求出pq的距离和pc的夹角ang，则向量pc的极角加减ang就是两条切线的极角，可求出切线。
4.过定点p且与直线（x1，y1）-----（x2，y2）相切且半径为r的圆：
圆心到直线距离为r，圆心的轨迹为两条直线，可将直线顺时针（逆时针）旋转90度得到向量l，其方向向量为v。以直线上两点为端点，以v为方向向量求出两模为r的向量，其两端点即为圆心所在直线上两点。据此，可求出圆心所在直线L。
（1）可以根据圆心到定点p的距离为r，列方程求解圆心。
（2）圆心同时在以p为圆心，以r为半径的圆C上。所以可以求出圆C与直线L的交点，即为圆心。
5.半径为r且与两条直线相切的圆：
与4类似，求出圆心所在直线，两两求交点即为圆心坐标。
6.与两圆相外切半径为r的圆：
根据两圆得到以C1为圆心，以C1.r+R为半径的圆和以C2为圆心，以C2.r+R为半径的圆，求其交点即为所求圆心。
lrj code：
// UVa12304 2D Geometry 110 in 1!
// Rujia Liu
#include<cstdio>
#include<cmath>
#include<algorithm>
#include<string>
#include<iostream>
#include<vector>
#include<cassert>
using namespace std;

const double eps = 1e-6;
int dcmp(double x)
{
if(fabs(x) < eps) return 0;
else return x < 0 ? -1 : 1;
}

const double PI = acos(-1);

struct Point
{
double x, y;
Point(double x=0, double y=0):x(x),y(y) { }
};

typedef Point Vector;

Vector operator + (Vector A, Vector B)
{
return Vector(A.x+B.x, A.y+B.y);
}
Vector operator - (Point A, Point B)
{
return Vector(A.x-B.x, A.y-B.y);
}
Vector operator * (Vector A, double p)
{
return Vector(A.x*p, A.y*p);
}
Vector operator / (Vector A, double p)
{
return Vector(A.x/p, A.y/p);
}

bool operator < (const Point& a, const Point& b)
{
return a.x < b.x || (a.x == b.x && a.y < b.y);
}

bool operator == (const Point& a, const Point &b)
{
return dcmp(a.x-b.x) == 0 && dcmp(a.y-b.y) == 0;
}

double Dot(Vector A, Vector B)
{
return A.x*B.x + A.y*B.y;
}
double Length(Vector A)
{
return sqrt(Dot(A, A));
}
double Angle(Vector A, Vector B)
{
return acos(Dot(A, B) / Length(A) / Length(B));
}
double Cross(Vector A, Vector B)
{
return A.x*B.y - A.y*B.x;
}

Vector Rotate(Vector A, double rad)
{
return Vector(A.x*cos(rad)-A.y*sin(rad), A.x*sin(rad)+A.y*cos(rad));
}

Vector Normal(Vector A)
{
double L = Length(A);
return Vector(-A.y/L, A.x/L);
}

Point GetLineIntersection(Point P, Point v, Point Q, Point w)
{
Vector u = P-Q;
double t = Cross(w, u) / Cross(v, w);
return P+v*t;
}

Point GetLineProjection(Point P, Point A, Point B)
{
Vector v = B-A;
return A+v*(Dot(v, P-A) / Dot(v, v));
}

double DistanceToLine(Point P, Point A, Point B)
{
Vector v1 = B - A, v2 = P - A;
return fabs(Cross(v1, v2)) / Length(v1); // 如果不取绝对值，得到的是有向距离
}

struct Line
{
Point p;
Vector v;
Line(Point p, Vector v):p(p),v(v) { }
Point point(double t)
{
return p + v*t;
}
Line Move(double d)
{
return Line(p + Normal(v)*d, v);
}
};

struct Circle
{
Point c;
double r;
Circle(Point c, double r):c(c),r(r) {}
Point point(double a)
{
return Point(c.x + cos(a)*r, c.y + sin(a)*r);
}
};

Point GetLineIntersection(Line a, Line b)
{
return GetLineIntersection(a.p, a.v, b.p, b.v);
}

double angle(Vector v)
{
return atan2(v.y, v.x);
}

int getLineCircleIntersection(Line L, Circle C, double& t1, double& t2, vector<Point>& sol)
{
double a = L.v.x, b = L.p.x - C.c.x, c = L.v.y, d = L.p.y - C.c.y;
double e = a*a + c*c, f = 2*(a*b + c*d), g = b*b + d*d - C.r*C.r;
double delta = f*f - 4*e*g; // 判别式
if(dcmp(delta) < 0) return 0; // 相离
if(dcmp(delta) == 0) // 相切
{
t1 = t2 = -f / (2 * e);
sol.push_back(L.point(t1));
return 1;
}
// 相交
t1 = (-f - sqrt(delta)) / (2 * e);
sol.push_back(L.point(t1));
t2 = (-f + sqrt(delta)) / (2 * e);
sol.push_back(L.point(t2));
return 2;
}

int getCircleCircleIntersection(Circle C1, Circle C2, vector<Point>& sol)
{
double d = Length(C1.c - C2.c);
if(dcmp(d) == 0)
{
if(dcmp(C1.r - C2.r) == 0) return -1; // 重合，无穷多交点
return 0;
}
if(dcmp(C1.r + C2.r - d) < 0) return 0;
if(dcmp(fabs(C1.r-C2.r) - d) > 0) return 0;

double a = angle(C2.c - C1.c);
double da = acos((C1.r*C1.r + d*d - C2.r*C2.r) / (2*C1.r*d));
Point p1 = C1.point(a-da), p2 = C1.point(a+da);

sol.push_back(p1);
if(p1 == p2) return 1;
sol.push_back(p2);
return 2;
}

/******************* Problem 1 **********************/

Circle CircumscribedCircle(Point p1, Point p2, Point p3)
{
double Bx = p2.x-p1.x, By = p2.y-p1.y;
double Cx = p3.x-p1.x, Cy = p3.y-p1.y;
double D = 2*(Bx*Cy-By*Cx);
double cx = (Cy*(Bx*Bx+By*By) - By*(Cx*Cx+Cy*Cy))/D + p1.x;
double cy = (Bx*(Cx*Cx+Cy*Cy) - Cx*(Bx*Bx+By*By))/D + p1.y;
Point p = Point(cx, cy);
return Circle(p, Length(p1-p));
}

/******************* Problem 2 **********************/

Circle InscribedCircle(Point p1, Point p2, Point p3)
{
double a = Length(p2-p3);
double b = Length(p3-p1);
double c = Length(p1-p2);
Point p = (p1*a+p2*b+p3*c)/(a+b+c);
return Circle(p, DistanceToLine(p, p1, p2));
}

/******************* Problem 3 **********************/

// 过点p到圆C的切线。v[i]是第i条切线的向量。返回切线条数
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) // p在圆上，只有一条切线
{
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;
}
}

/******************* Problem 4 **********************/

vector<Point> CircleThroughPointTangentToLineGivenRadius(Point p, Line L, double r)
{
vector<Point> ans;
double t1, t2;
getLineCircleIntersection(L.Move(-r), Circle(p, r), t1, t2, ans);
getLineCircleIntersection(L.Move(r), Circle(p, r), t1, t2, ans);
return ans;
}

/******************* Problem 5 **********************/

vector<Point> CircleTangentToLinesGivenRadius(Line a, Line b, double r)
{
vector<Point> ans;
Line L1 = a.Move(-r), L2 = a.Move(r);
Line L3 = b.Move(-r), L4 = b.Move(r);
ans.push_back(GetLineIntersection(L1, L3));
ans.push_back(GetLineIntersection(L1, L4));
ans.push_back(GetLineIntersection(L2, L3));
ans.push_back(GetLineIntersection(L2, L4));
return ans;
}

/******************* Problem 6 **********************/

vector<Point> CircleTangentToTwoDisjointCirclesWithRadius(Circle c1, Circle c2, double r)
{
vector<Point> ans;
Vector v = c2.c - c1.c;
double dist = Length(v);
int d = dcmp(dist - c1.r -c2.r - r*2);
if(d > 0) return ans;
getCircleCircleIntersection(Circle(c1.c, c1.r+r), Circle(c2.c, c2.r+r), ans);
return ans;
}

// formatting
double lineAngleDegree(Vector v)
{
double ang = angle(v)*180.0/PI;
while(dcmp(ang) < 0) ang += 360.0;
while(dcmp(ang-180) >= 0) ang -= 180.0;
return ang;
}

void format(Circle c)
{
printf("(%.6lf,%.6lf,%.6lf)\n", c.c.x, c.c.y, c.r);
}

void format(vector<double> ans)
{
int n = ans.size();
sort(ans.begin(), ans.end());
printf("[");
if(n)
{
printf("%.6lf", ans[0]);
for(int i = 1; i < n; i++) printf(",%.6lf", ans[i]);
}
printf("]\n");
}

void format(vector<Point> ans)
{
int n = ans.size();
sort(ans.begin(), ans.end());
printf("[");
if(n)
{
printf("(%.6lf,%.6lf)", ans[0].x, ans[0].y);
for(int i = 1; i < n; i++) printf(",(%.6lf,%.6lf)", ans[i].x, ans[i].y);
}
printf("]\n");
}

Line getLine(double x1, double y1, double x2, double y2)
{
Point p1(x1,y1);
Point p2(x2,y2);
return Line(p1, p2-p1);
}

int main()
{
//freopen("in.txt","r",stdin);
string cmd;
while(cin >> cmd)
{
double x1, y1, x2, y2, x3, y3, x4, y4, xp, yp, xc, yc, r1, r2, r;
if(cmd == "CircumscribedCircle")
{
cin >> x1 >> y1 >> x2 >> y2 >> x3 >> y3;
format(CircumscribedCircle(Point(x1,y1), Point(x2,y2), Point(x3,y3)));
}
if(cmd == "InscribedCircle")
{
cin >> x1 >> y1 >> x2 >> y2 >> x3 >> y3;
format(InscribedCircle(Point(x1,y1), Point(x2,y2), Point(x3,y3)));
}
if(cmd == "TangentLineThroughPoint")
{
cin >> xc >> yc >> r >> xp >> yp;
Vector v[2];
vector<double> ans;
int cnt = getTangents(Point(xp, yp), Circle(Point(xc, yc), r), v);
for(int i = 0; i < cnt; i++) ans.push_back(lineAngleDegree(v[i]));
format(ans);
}
if(cmd == "CircleThroughAPointAndTangentToALineWithRadius")
{
cin >> xp >> yp >> x1 >> y1 >> x2 >> y2 >> r;
format(CircleThroughPointTangentToLineGivenRadius(Point(xp, yp), getLine(x1, y1, x2, y2), r));
}
if(cmd == "CircleTangentToTwoLinesWithRadius")
{
cin >> x1 >> y1 >> x2 >> y2 >> x3 >> y3 >> x4 >> y4 >> r;
format(CircleTangentToLinesGivenRadius(getLine(x1, y1, x2, y2), getLine(x3, y3, x4, y4), r));
}
if(cmd == "CircleTangentToTwoDisjointCirclesWithRadius")
{
cin >> x1 >> y1 >> r1 >> x2 >> y2 >> r2 >> r;
format(CircleTangentToTwoDisjointCirclesWithRadius(Circle(Point(x1, y1), r1), Circle(Point(x2, y2), r2), r));
}
}
return 0;
}

my code：
#include<cmath>
#include<cstdio>
#include<vector>
#include<cstring>
#include<iostream>
#include<algorithm>
#define debug
using namespace std;
const double eps=1e-10;
const double PI=acos(-1.0);
const int INF=0x3f3f3f3f;

struct Equ
{
double x,y;
};

struct Point
{
double x,y;
Point(double x=0,double y=0):x(x),y(y) {}
void read()
{
scanf("%lf%lf",&x,&y);
}
void print()
{
printf("%.6f %.6f",x,y);
}
};

struct Line
{
Point p1,p2;
Line(Point p1=NULL,Point p2=NULL):p1(p1),p2(p2) {}
void read()
{
p1.read();
p2.read();
}
};

struct Circle
{
Point c;
double r;
Circle(Point c=NULL,double r=0.0):c(c),r(r) {}
Point point(double a)
{
return Point(c.x+cos(a)*r,c.y+sin(a)*r);
}
void read()
{
c.read();
scanf("%lf",&r);
}
void print()
{
c.print();
printf(" %f",r);
}
};

typedef Point Vector;

Vector operator + (Vector A,Vector B)
{
return Vector(A.x+B.x,A.y+B.y);
}

Vector operator - (Point A,Point B)
{
return Vector(A.x-B.x,A.y-B.y);
}

Vector operator * (Vector A,double p)
{
return Vector(A.x*p,A.y*p);
}

Vector operator / (Vector A,double p)
{
return Vector(A.x/p,A.y/p);
}

bool operator < (const Point &a,const Point &b)
{
return a.x<b.x||(a.x==b.x&&a.y<b.y);
}

int dcmp(double x)
{
if(fabs(x)<eps) return 0;
else return x<0?-1:1;
}

bool operator == (const Point &a,const Point &b)
{
return dcmp(a.x-b.x)==0&&dcmp(a.y-b.y)==0;
}

double Dot(Vector A,Vector B)
{
return A.x*B.x+A.y*B.y;
}

double Length(Vector A)
{
return sqrt(Dot(A,A));
}

double changeAngle(double ang)
{
double tmp=180.0*ang/PI;
if(tmp>=180) tmp-=180;
if(tmp<0) tmp+=180;
return tmp;
}

double Angle(Vector A,Vector B)
{
return acos(Dot(A,B)/Length(A)/Length(B));
}

double polarAngle(Vector v)
{
return atan2(v.y,v.x);
}

Vector Normal(Vector A)
{
double L=Length(A);
return Vector(-A.y/L,A.x/L);
}

Vector changeLen(Vector v,double l)
{
double len=Length(v);
if(dcmp(len)==0) return v;
l/=len;
return Vector(v.x*l,v.y*l);
}

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 Cross(Vector A,Vector B)
{
return A.x*B.y-A.y*B.x;
}

Point GetLineIntersection(Point P,Vector v,Point Q,Vector w)
{
Vector u=P-Q;
double t=Cross(w,u)/Cross(v,w);
return P+v*t;
}

bool SegmentProperIntersection(Point a1,Point a2,Point b1,Point b2)
{
double c1=Cross(a2-a1,b1-a1),c2=Cross(a2-a1,b2-a1),
c3=Cross(b2-b1,a1-b1),c4=Cross(b2-b1,a2-b1);
return dcmp(c1)*dcmp(c2)<0&&dcmp(c3)*dcmp(c4)<0;
}

bool OnSegment(Point p,Point a1,Point a2)
{
return dcmp(Cross(a1-p,a2-p))==0&&dcmp(Dot(a1-p,a2-p))<0;
}

double DistanceToSegment(Point P,Point A,Point B)
{
if(A==B) return Length(P-A);
Vector v1=B-A,v2=P-A,v3=P-B;
if(dcmp(Dot(v1,v2))<0) return Length(v2);
else if(dcmp(Dot(v1,v3))>0) return Length(v3);
else return fabs(Cross(v1,v2))/Length(v1);
}

int getCircleCircleIntersection(Circle C1,Circle C2,vector<Point> &sol)
{
double d=Length(C1.c-C2.c);
if(dcmp(d)==0)
{
if(dcmp(C1.r-C2.r)==0) return -1;
return 0;
}

if(dcmp(C1.r+C2.r-d)<0) return 0;
if(dcmp(fabs(C1.r-C2.r)-d)>0) return 0;

double a=polarAngle(C2.c-C1.c);
double da=acos((C1.r*C1.r+d*d-C2.r*C2.r)/(2*C1.r*d));
Point p1=C1.point(a-da),p2=C1.point(a+da);

sol.push_back(p1);
if(p1==p2) return 1;
sol.push_back(p2);
return 2;
}

void CircumscribedCircle(Point p1,Point p2,Point p3,Point &P,double &R)
{
Vector u=p2-p1;
Vector v=p3-p1;
Vector norU=Normal(u);
Vector norV=Normal(v);

P=GetLineIntersection((p1+p2)/2,norU,(p1+p3)/2,norV);
R=Length(p1-P);

printf("(%.6f,%.6f,%.6f)\n",P.x,P.y,R);
}

double DistanceToLine(Point P,Point A,Point B)
{
Vector v1=B-A,v2=P-A;
return fabs(Cross(v1,v2))/Length(v1);
}

void InscribedCircle(Point p1,Point p2,Point p3)
{
double a = Length(p2-p3);
double b = Length(p3-p1);
double c = Length(p1-p2);
Point p = (p1*a+p2*b+p3*c)/(a+b+c);
printf("(%.6f,%.6f,%.6f)\n",p.x,p.y,DistanceToLine(p,p1,p2));
}

int getTangents(Point p,Circle C,Vector *v,vector<double> &ans)
{
Vector u=C.c-p;
double dist=Length(u);

if(dist<C.r)
{

}
else if(dcmp(dist-C.r)==0)
{
v[0]=Rotate(u,PI/2);
ans.push_back(changeAngle(polarAngle(v[0])));
}
else
{
double ang=asin(C.r/dist);
v[0]=Rotate(u,-ang);
v[1]=Rotate(u,ang);
ans.push_back(changeAngle(polarAngle(v[0])));
ans.push_back(changeAngle(polarAngle(v[1])));
}

sort(ans.begin(),ans.end());
printf("[");
for(int i=0; i<ans.size(); i++)
{
if(i==0) printf("%.6f",ans[i]);
else printf(",%.6f",ans[i]);
}
printf("]\n");

}

int solveEqu(double a,double b,double c,vector<double>& sol)
{
double t1,t2;
double delta=b*b-4*a*c;
if(dcmp(delta)<0) return 0;
if(dcmp(delta)==0)
{
t1=t2=-b/(2*a);
sol.push_back(t1);
return 1;
}
else
{
t1=(-b+sqrt(delta))/(2*a);
t2=(-b-sqrt(delta))/(2*a);
sol.push_back(t1);
sol.push_back(t2);
return 2;
}
}

int cmp(Equ a,Equ b)
{
if(dcmp(a.x-b.x)==0) return dcmp(a.y-b.y)<0;
else return dcmp(a.x-b.x)<0;
}

void CircleThroughAPointAndTangentToALineWithRadius(Point p,Line l,double r)
{
vector<double>sol;
vector<Equ> ans;

double k,b,kk,bb;

Vector p1=l.p1+(changeLen(Rotate(l.p1-l.p2,-PI/2),r));
Vector p2=l.p2+(changeLen(Rotate(l.p1-l.p2,-PI/2),r));

if(dcmp(p1.x-p2.x)==0)
{
sol.clear();
solveEqu(1,-2*p.y,p.y*p.y+(p1.x-p.x)*(p1.x-p.x)-r*r,sol);
for(int i=0; i<sol.size(); i++)
{
ans.push_back((Equ){l.p1.x,sol[i]});
}
}
else
{
k=(p2.y-p1.y)/(p2.x-p1.x);
b=p2.y-k*p2.x;

double A=1+k*k;
double B=-2*p.x+2*k*b-2*k*p.y;
double C=p.x*p.x+b*b-2*b*p.y+p.y*p.y-r*r;

sol.clear();

solveEqu(A,B,C,sol);
for(int i=0; i<sol.size(); i++)
{
ans.push_back((Equ){sol[i],sol[i]*k+b});
}

}

Vector p3=l.p1+(changeLen(Rotate(l.p1-l.p2,PI/2),r));
Vector p4=l.p2+(changeLen(Rotate(l.p1-l.p2,PI/2),r));

if(dcmp(p3.x-p4.x)==0)
{
sol.clear();
solveEqu(1,-2*p.y,p.y*p.y+(p3.x-p.x)*(p3.x-p.x)-r*r,sol);
for(int i=0; i<sol.size(); i++)
{
ans.push_back((Equ){p3.x,sol[i]});
}
}
else
{
kk=(p3.y-p4.y)/(p3.x-p4.x);
bb=p3.y-kk*p3.x;

double AA=1+kk*kk;
double BB=-2*p.x+2*kk*bb-2*kk*p.y;
double CC=p.x*p.x+bb*bb-2*bb*p.y+p.y*p.y-r*r;

sol.clear();

solveEqu(AA,BB,CC,sol);
for(int i=0; i<sol.size(); i++)
{
ans.push_back((Equ){sol[i],sol[i]*kk+bb});
}
}

sort(ans.begin(),ans.end(),cmp);

printf("[");
for(int i=0; i<ans.size(); i++)
{
if(i!=0) printf(",");
printf("(%.6f,%.6f)",ans[i].x,ans[i].y);
}
printf("]\n");

}

void CircleTangentToTwoLinesWithRadius(Line l1,Line l2,double r)
{
vector<Point> ans;

Vector p1=l1.p1+(changeLen(Rotate(l1.p1-l1.p2,-PI/2),r));
Vector p2=l1.p2+(changeLen(Rotate(l1.p1-l1.p2,-PI/2),r));
Vector p3=l1.p1+(changeLen(Rotate(l1.p1-l1.p2,PI/2),r));
Vector p4=l1.p2+(changeLen(Rotate(l1.p1-l1.p2,PI/2),r));

Vector pp1=l2.p1+(changeLen(Rotate(l2.p1-l2.p2,-PI/2),r));
Vector pp2=l2.p2+(changeLen(Rotate(l2.p1-l2.p2,-PI/2),r));
Vector pp3=l2.p1+(changeLen(Rotate(l2.p1-l2.p2,PI/2),r));
Vector pp4=l2.p2+(changeLen(Rotate(l2.p1-l2.p2,PI/2),r));

ans.push_back(GetLineIntersection(p1,p2-p1,pp1,pp2-pp1));
ans.push_back(GetLineIntersection(p1,p2-p1,pp3,pp4-pp3));

ans.push_back(GetLineIntersection(p3,p4-p3,pp1,pp2-pp1));
ans.push_back(GetLineIntersection(p3,p4-p3,pp3,pp4-pp3));

sort(ans.begin(),ans.end());

printf("[");
for(int i=0;i<ans.size();i++)
{
if(i!=0) printf(",");
printf("(%.6f,%.6f)",ans[i].x,ans[i].y);
}
printf("]\n");
}

void CircleTangentToTwoDisjointCirclesWithRadius(Circle c1,Circle c2,double r)
{
Point p1=c1.c,p2=c2.c;
Circle C1=Circle(p1,c1.r+r),C2=Circle(p2,c2.r+r);

vector<Point> sol;
getCircleCircleIntersection(C1,C2,sol);

sort(sol.begin(),sol.end());
printf("[");
for(int i=0;i<sol.size();i++)
{
if(i!=0) printf(",");
printf("(%.6f,%.6f)",sol[i].x,sol[i].y);
}
printf("]\n");
}

int main()

{
#ifdef debu
freopen("in.txt","r",stdin);
//freopen("out.txt","w",stdout);
#endif // debug
string cmd;
while(cin>>cmd)
{
if(cmd=="CircumscribedCircle")
{
double r;
Point p1,p2,p3,p;
p1.read(),p2.read(),p3.read();
CircumscribedCircle(p1,p2,p3,p,r);
}
if(cmd=="InscribedCircle")
{
Point p1,p2,p3;
p1.read(),p2.read(),p3.read();
InscribedCircle(p1,p2,p3);
}
if(cmd=="TangentLineThroughPoint")
{
Point p;
Circle C;
C.read();
p.read();

Vector v[2];
vector<double> ans;
getTangents(p,C,v,ans);
}
if(cmd=="CircleThroughAPointAndTangentToALineWithRadius")
{
Point p;
p.read();
Line l;
l.read();
double r;
scanf("%lf",&r);
CircleThroughAPointAndTangentToALineWithRadius(p,l,r);
}
if(cmd=="CircleTangentToTwoLinesWithRadius")
{
Line l1,l2;
l1.read();l2.read();
double r;
scanf("%lf",&r);
CircleTangentToTwoLinesWithRadius(l1,l2,r);
}
if(cmd=="CircleTangentToTwoDisjointCirclesWithRadius")
{
Circle c1,c2;
c1.read();c2.read();
double r;
scanf("%lf",&r);
CircleTangentToTwoDisjointCirclesWithRadius(c1,c2,r);
}
}

}