Can someone please share a snippet of .net code for creating a fillet between line and polyline as it's shown in this picture below?
Fillet in .net
This is a math problem rather than anything else.
A few time ago I was working in a soil engineering project from which we had to do several interactions using circles to find the rupture surface of a soil mass.
The project was a Frankenstein of "Math exchange" algorithms and self produced codes but it worked.
I just extracted a part of it and did a little adaptation to fit your needings:
[CommandMethod("CircleTangentToCircleAndLine")]
public static void DrawCircles()
{
Document doc = Application.DocumentManager.MdiActiveDocument;
Editor ed = doc.Editor;
Database db = doc.Database;
ObjectId Circleid = ObjectId.Null, Lineid = ObjectId.Null;
bool isok = false; ;
while (!isok)
{
var selection = ed.GetSelection(new PromptSelectionOptions() { MessageForAdding = "Select only a circle and a line!" });
if (selection.Status == PromptStatus.Cancel) return;
if (selection.Value.GetObjectIds().Count() > 2) continue;
using (Transaction tr = db.TransactionManager.StartTransaction())
{
foreach (ObjectId n in selection.Value.GetObjectIds())
{
if (n.GetObject(OpenMode.ForRead) as Autodesk.AutoCAD.DatabaseServices.Line != null) Lineid = n;
if (n.GetObject(OpenMode.ForRead) as Autodesk.AutoCAD.DatabaseServices.Circle != null) Circleid = n;
}
tr.Commit();
}
if (Circleid != ObjectId.Null && Lineid != ObjectId.Null) isok = true;
}
var radius = ed.GetDistance(new PromptDistanceOptions("Enter Radius of the Tangent."));
if (radius.Status == PromptStatus.Cancel) return;
using (Transaction tr = db.TransactionManager.StartTransaction())
{
var line = Lineid.GetObject(OpenMode.ForRead) as Autodesk.AutoCAD.DatabaseServices.Line;
var circle = Circleid.GetObject(OpenMode.ForRead) as Autodesk.AutoCAD.DatabaseServices.Circle;
Line Offset = (new Line(new Point(line.StartPoint.X, line.StartPoint.Y),new Point(line.EndPoint.X, line.EndPoint.Y))).Offset(radius.Value);
Circle WholeCircle = new Circle(circle.Center.X, circle.Center.Y, circle.Radius + radius.Value);
KeyValuePair<Point, Point> Interseptions = new KeyValuePair<Point, Point>();
if (!Offset.TryGetCircleIntersection(WholeCircle, out Interseptions))
{
ed.WriteMessage("No fillet found!\n"); return;
}
var currentlayout = LayoutManager.Current.GetLayoutId(LayoutManager.Current.CurrentLayout);
var btr = (currentlayout.GetObject(OpenMode.ForRead) as Layout).BlockTableRecordId.GetObject(OpenMode.ForWrite) as BlockTableRecord;
using (var newCircle1 = new Autodesk.AutoCAD.DatabaseServices.Circle())
using (var newCircle2 = new Autodesk.AutoCAD.DatabaseServices.Circle())
{
newCircle1.Center = new Autodesk.AutoCAD.Geometry.Point3d(Interseptions.Key.x, Interseptions.Key.y, 0);
newCircle2.Center = new Autodesk.AutoCAD.Geometry.Point3d(Interseptions.Value.x, Interseptions.Value.y, 0);
newCircle1.Radius = radius.Value;
newCircle2.Radius = radius.Value;
btr.AppendEntity(newCircle1);
tr.AddNewlyCreatedDBObject(newCircle1, true);
btr.AppendEntity(newCircle2);
tr.AddNewlyCreatedDBObject(newCircle2, true);
}
tr.Commit();
}
}
internal class Point
{
public double x, y;
public Point(double px, double py)
{
x = px;
y = py;
}
public Point sub(Point p2)
{
return new Point(x - p2.x, y - p2.y);
}
public Point add(Point p2)
{
return new Point(x + p2.x, y + p2.y);
}
public double distance(Point p2)
{
return Math.Sqrt((x - p2.x) * (x - p2.x) + (y - p2.y) * (y - p2.y));
}
public Point normal()
{
var length = Math.Sqrt(x * x + y * y);
return new Point(x / length, y / length);
}
public Point scale(double s)
{
return new Point(x * s, y * s);
}
public static Point operator -(Point p1, Point p2)
{
return new Point(p1.x - p2.x, p1.y - p2.y);
}
};
internal class Line
{
public Point p1, p2;
public Line(Point p1, Point p2)
{
this.p1 = p1;
this.p2 = p2;
}
public Line Offset(double distance)
{
var L = Math.Sqrt((p1.x - p2.x) * (p1.x - p2.x) + (p1.y - p2.y) * (p1.y - p2.y));
var offsetPixels = distance;
// This is the second line
var x1p = p1.x + offsetPixels * (p2.y - p1.y) / L;
var x2p = p2.x + offsetPixels * (p2.y - p1.y) / L;
var y1p = p1.y + offsetPixels * (p1.x - p2.x) / L;
var y2p = p2.y + offsetPixels * (p1.x - p2.x) / L;
return new Line(new Point(x1p, y1p ), new Point(x2p, y2p));
}
public bool TryGetCircleIntersection(Circle c, out KeyValuePair<Point,Point> Interseptions)
{
// compute the euclidean distance between A and B
var LAB = Math.Sqrt(Math.Pow(p2.x - p1.x, 2) + (Math.Pow(p2.y - p1.y, 2)));
// compute the direction vector D from A to B
var Dx = (p2.x - p1.x) / LAB;
var Dy = (p2.y - p1.y) / LAB;
// Now the line equation is x = Dx*t + Ax, y = Dy*t + Ay with 0 <= t <= 1.
// compute the value t of the closest point to the circle center (Cx, Cy)
var t = Dx * (c.x - p1.x) + Dy * (c.y - p1.y);
// This is the projection of C on the line from A to B.
// compute the coordinates of the point E on line and closest to C
var Ex = t * Dx + p1.x;
var Ey = t * Dy + p1.y;
// compute the euclidean distance from E to C
var LEC = Math.Sqrt(Math.Pow(Ex - c.x, 2) + Math.Pow(Ey - c.y, 2));
// test if the line intersects the circle
if (LEC < c.r)
{
// compute distance from t to circle intersection point
var dt = Math.Sqrt(Math.Pow(c.r, 2) - Math.Pow(LEC, 2));
// compute first intersection point
var Fx = (t - dt) * Dx + p1.x;
var Fy = (t - dt) * Dy + p1.y;
// compute second intersection point
var Gx = (t + dt) * Dx + p1.x;
var Gy = (t + dt) * Dy + p1.y;
Interseptions = new KeyValuePair<Point, Point>(new Point(Fx, Fy), new Point(Gx, Gy));
return true;
}
// else test if the line is tangent to circle
else if (LEC == c.r)
{
Interseptions = new KeyValuePair<Point, Point>(new Point(Ex, Ey), new Point(Ex, Ey));
return true;
}
// tangent point to circle is E
else
{
Interseptions = new KeyValuePair<Point, Point>(new Point(double.NaN, double.NaN), new Point(double.NaN, double.NaN));
return false;
}
// line doesn't touch circle
}
}
internal class Circle
{
public double x, y, r, left;
public Circle(double cx, double cy, double cr)
{
x = cx;
y = cy;
r = cr;
left = x - r;
}
};Currently, it works only for a line and a circle.
It also will draw two circles, instead of a single fillet:
Nevertheless, the properties the code extracts from this entities are found in polylines and arcs so the code only needs a little adaptation...
If I have more time later I'll improve the code.
Accepted solution