private static List <BridgePoints> GetBridgeByCircle(Circle circle, UnitPoint p1, UnitPoint p2, BridgingModel param)
{
List <BridgePoints> retPoints = new List <BridgePoints>();
var line = DrawingOperationHelper.GetLineEquation(p1, p2);
double width = param.Width / 2;
List <UnitPoint> points = DrawingOperationHelper.GetIntersectPointByLineAndCircle(line.Item1, line.Item2, line.Item3, circle.Center, circle.Radius);
var hasPoints = points?.Where(p => !p.IsEmpty && HitUtil.IsPointInLine(p1, p2, p, 0.000001f)).ToList();
if (hasPoints != null && hasPoints.Count > 0)
{
//根据宽度求点
double angle = width / circle.Radius * (circle.IsClockwise ? 1 : -1);
List <UnitPointBulge> temps = new List <UnitPointBulge>();
hasPoints?.ForEach(p =>
{
double lineAngle = HitUtil.LineAngleR(circle.Center, p, 0);
double angle1 = lineAngle + angle;
double angle2 = lineAngle - angle;
//第一个位置点
UnitPoint retPoint1 = HitUtil.PointOnCircle(circle.Center, circle.Radius, angle1);
//第二个位置点
UnitPoint retPoint2 = HitUtil.PointOnCircle(circle.Center, circle.Radius, angle2);
BridgePoints bridges = new BridgePoints(circle,
new UnitPointBulge(retPoint1),
new UnitPointBulge(retPoint2),
HitUtil.Distance(p1, p));
retPoints.Add(bridges);
});
}
return(retPoints);
}
public bool HandleMouseDownForScale(UnitPoint mousePoint)
{
bool isComplete = false;
if (this.CurrentStatus == Status.BasePoint)
{
this.FirstPoint = this.SecondPoint = mousePoint;
this.CurrentStatus = Status.EndPoint;
foreach (IDrawObject obj in this.uCCanvas.Model.DrawingLayer.SelectedObjects)
{
this.originals.Add(obj);
this.Copies.Add(obj.Clone());
}
}
else if (this.CurrentStatus == Status.EndPoint)
{
this.SecondPoint = this.ThridPoint = mousePoint;
this.CurrentStatus = Status.OtherEndPoint;
this.lastLength = this.baseLength = HitUtil.Distance(this.FirstPoint, this.SecondPoint);
}
else
{
this.ThridPoint = mousePoint;
this.CurrentStatus = Status.BasePoint;
this.scaleCoff = HitUtil.Distance(this.FirstPoint, this.ThridPoint) / this.baseLength;
this.uCCanvas.Model.DoSizeChange(this.originals, this.FirstPoint.X, this.FirstPoint.Y, this.scaleCoff, this.scaleCoff);
isComplete = true;
}
this.uCCanvas.DoInvalidate(true);
return(isComplete);
}
public static bool IsPointInArc(double testAngle, double startAngle, double endAngle, bool clockWise)
{
double angle1 = HitUtil.CalAngleSweep(startAngle, endAngle, clockWise);
double angle2 = HitUtil.CalAngleSweep(startAngle, testAngle, clockWise);
if (Math.Abs(angle1 % 360) > Math.Abs(angle2 % 360))
{
return(true);
}
return(false);
}
public static ArcModelMini GetArcParametersFromThreePoints(UnitPoint startPoint, UnitPoint midPoint, UnitPoint endPoint)
{
ArcModelMini arcModel = new ArcModelMini();
arcModel.Clockwise = HitUtil.IsClockwiseByCross(startPoint, midPoint, endPoint);
arcModel.Center = HitUtil.CenterPointFrom3Points(startPoint, midPoint, endPoint);
arcModel.Radius = (float)HitUtil.Distance(arcModel.Center, startPoint);
arcModel.StartAngle = (float)HitUtil.RadiansToDegrees(HitUtil.LineAngleR(arcModel.Center, startPoint, 0));
float EndAngle = (float)HitUtil.RadiansToDegrees(HitUtil.LineAngleR(arcModel.Center, endPoint, 0));
arcModel.SweepAngle = (float)HitUtil.CalAngleSweep(arcModel.StartAngle, EndAngle, arcModel.Clockwise);
return(arcModel);
}
private void CalScaleCoff()
{
double currentLength = HitUtil.Distance(this.FirstPoint, this.ThridPoint);;
if (currentLength > 0.05 * this.baseLength)
{
this.scaleCoff = currentLength / this.lastLength;
this.lastLength = currentLength;
}
else
{
this.scaleCoff = 1;
}
}
/// <summary>
/// 得到直线或者圆弧的标准补偿点
/// </summary>
/// <param name="p1"></param>
/// <param name="p2"></param>
/// <param name="isOutside"></param>
/// <returns></returns>
public static Tuple <UnitPointBulge, UnitPointBulge> GetCompensationsPoint(UnitPointBulge p1, UnitPointBulge p2, double size, bool isOutside, bool isUpdateBulge = false)
{
UnitPointBulge up1 = new UnitPointBulge();
UnitPointBulge up2 = new UnitPointBulge();
if (!double.IsNaN(p1.Bulge))//圆弧
{
var arc = DrawingOperationHelper.GetArcParametersFromBulge(p1.Point, p2.Point, (float)p1.Bulge);
double r = arc.Clockwise ? arc.Radius - size : arc.Radius + size;
if (isOutside)
{
r = arc.Clockwise ? arc.Radius + size : arc.Radius - size;
}
if (r > 0)
{
UnitPoint point1 = HitUtil.GetLinePointByDistance(arc.Center, p1.Point, r, true);
UnitPoint point2 = HitUtil.GetLinePointByDistance(arc.Center, p2.Point, r, true);
up1 = new UnitPointBulge()
{
Point = point1, Bulge = p1.Bulge, HasMicroConn = p1.HasMicroConn
};
up2 = new UnitPointBulge()
{
Point = point2, Bulge = p2.Bulge, HasMicroConn = p2.HasMicroConn
};
if (isUpdateBulge)
{
up1.Bulge = BulgeHelper.GetBulgeFromTwoPointsAndCenter(arc.Center, up1.Point, up2.Point, arc.Clockwise);
}
}
}
else //直线
{
var line1d1 = DrawingOperationHelper.GetLinePointByVerticalLine(p1.Point, p2.Point, size);
var line1d2 = DrawingOperationHelper.GetLinePointByVerticalLine(p2.Point, p1.Point, size);
UnitPoint point1 = !isOutside ? line1d1.Item2 : line1d1.Item1;
UnitPoint point2 = !isOutside ? line1d2.Item1 : line1d2.Item2;
up1 = new UnitPointBulge()
{
Point = point1, Bulge = p1.Bulge, HasMicroConn = p1.HasMicroConn
};
up2 = new UnitPointBulge()
{
Point = point2, Bulge = p2.Bulge, HasMicroConn = p2.HasMicroConn
};
}
return(Tuple.Create(up1, up2));
}
/// <summary>
/// 求点到线段/直线的垂直距离
/// </summary>
/// <param name="p1">线段的第一个点</param>
/// <param name="p2">线段的第二个点</param>
/// <param name="testPoint"></param>
/// <returns></returns>
public static double DistanctPointToLine(UnitPoint p1, UnitPoint p2, UnitPoint testPoint)
{
//三角形边长
double distanceStartTest = HitUtil.Distance(p1, testPoint);
double distanceEndTest = HitUtil.Distance(p2, testPoint);
double distanceStartEnd = HitUtil.Distance(p1, p2);
//半周长
double p = (distanceStartTest + distanceEndTest + distanceStartEnd) / 2;
//海伦公式求三角形面积
double s = Math.Sqrt(p * Math.Abs(p - distanceStartTest) * Math.Abs(p - distanceEndTest) * Math.Abs(p - distanceStartEnd));
return(2 * s / distanceStartEnd);
}
private static List <BridgePoints> GetBridgeByArc(ArcBase arc, UnitPoint p1, UnitPoint p2, BridgingModel param)
{
List <BridgePoints> retPoints = new List <BridgePoints>();
var line = DrawingOperationHelper.GetLineEquation(p1, p2);
double width = param.Width / 2;
ArcModelMini arcMini = new DrawModel.ArcModelMini()
{
Center = arc.Center,
Radius = arc.Radius,
StartAngle = arc.StartAngle,
EndAngle = arc.EndAngle,
SweepAngle = arc.AngleSweep,
Clockwise = arc.IsClockwise
};
List <UnitPoint> points = DrawingOperationHelper.GetIntersectPointByLineAndCircle(line.Item1, line.Item2, line.Item3, arc.Center, arc.Radius);
var hasPoints = points?.Where(p => !p.IsEmpty && (HitUtil.IsPointOnArc(p, 0.000001f, arcMini) && HitUtil.IsPointInLine(p1, p2, p, 0.000001f))).ToList();
if (hasPoints != null && hasPoints.Count > 0)
{
//根据宽度求点
double angle = width / arc.Radius * (arc.IsClockwise ? 1 : -1);
hasPoints?.ForEach(p =>
{
double lineAngle = HitUtil.LineAngleR(arcMini.Center, p, 0);
double angle1 = lineAngle + angle;
double angle2 = lineAngle - angle;
UnitPoint retPoint1 = UnitPoint.Empty;
UnitPoint retPoint2 = UnitPoint.Empty;
if (HitUtil.IsPointInArc(HitUtil.RadiansToDegrees(angle1), arcMini.StartAngle, arcMini.EndAngle, arcMini.Clockwise))
{
//第一个位置点
retPoint1 = HitUtil.PointOnCircle(arcMini.Center, arcMini.Radius, angle1);
}
if (HitUtil.IsPointInArc(HitUtil.RadiansToDegrees(angle2), arcMini.StartAngle, arcMini.EndAngle, arcMini.Clockwise))
{
//第二个位置点
retPoint2 = HitUtil.PointOnCircle(arcMini.Center, arcMini.Radius, angle2);
}
BridgePoints bridges = new BridgePoints(arc,
new UnitPointBulge(retPoint1),
new UnitPointBulge(retPoint2),
HitUtil.Distance(p1, p));
retPoints.Add(bridges);
});
}
return(retPoints);
}
//TODO:此方法可能存在问题
public static bool IsLineOnArc(UnitPoint p1, UnitPoint p2, UnitPoint center, float radius, double startAngle, double angleSweep, bool clockwise, float thWidth)
{
List <UnitPoint> unitPoints = HitUtil.GetIntersectPointLineWithCircle(p1, p2, center, radius, thWidth);
for (int i = 0; i < unitPoints.Count; i++)
{
double angle = HitUtil.LineAngleR(center, unitPoints[i], 0);
angle = HitUtil.RadiansToDegrees(angle);
double sweepAngle = HitUtil.CalAngleSweep(startAngle, angle, clockwise);
if (Math.Abs(angleSweep) > Math.Abs(sweepAngle))
{
return(true);
}
}
return(false);
}
public static bool IsArcIntersectWithRect(ArcBase arcBase, RectangleF rectangle, float thWidth)
{
bool result = false;
UnitPoint p1 = new UnitPoint(rectangle.Left, rectangle.Top);
UnitPoint p2 = new UnitPoint(rectangle.Left, rectangle.Bottom);
if (HitUtil.CircleIntersectWithLine(arcBase.Center, arcBase.Radius, p1, p2))
{
result = HitUtil.IsLineOnArc(p1, p2, arcBase.Center, arcBase.Radius, arcBase.StartAngle, arcBase.AngleSweep, arcBase.IsClockwise, thWidth);
if (result)
{
return(result);
}
}
p1 = new UnitPoint(rectangle.Left, rectangle.Bottom);
p2 = new UnitPoint(rectangle.Right, rectangle.Bottom);
if (HitUtil.CircleIntersectWithLine(arcBase.Center, arcBase.Radius, p1, p2))
{
result = HitUtil.IsLineOnArc(p1, p2, arcBase.Center, arcBase.Radius, arcBase.StartAngle, arcBase.AngleSweep, arcBase.IsClockwise, thWidth);
if (result)
{
return(result);
}
}
p1 = new UnitPoint(rectangle.Left, rectangle.Top);
p2 = new UnitPoint(rectangle.Right, rectangle.Top);
if (HitUtil.CircleIntersectWithLine(arcBase.Center, arcBase.Radius, p1, p2))
{
result = HitUtil.IsLineOnArc(p1, p2, arcBase.Center, arcBase.Radius, arcBase.StartAngle, arcBase.AngleSweep, arcBase.IsClockwise, thWidth);
if (result)
{
return(result);
}
}
p1 = new UnitPoint(rectangle.Right, rectangle.Top);
p2 = new UnitPoint(rectangle.Right, rectangle.Bottom);
if (HitUtil.CircleIntersectWithLine(arcBase.Center, arcBase.Radius, p1, p2))
{
result = HitUtil.IsLineOnArc(p1, p2, arcBase.Center, arcBase.Radius, arcBase.StartAngle, arcBase.AngleSweep, arcBase.IsClockwise, thWidth);
if (result)
{
return(result);
}
}
return(result);
}
/// <summary>
/// 根据长度获取多段线的点坐标
/// </summary>
/// <param name="points">多段线的点</param>
/// <param name="index">当前开始的索引位置</param>
/// <param name="length">长度</param>
/// <param name="isPositive">是否正向计算长度，否则从反向计算长度</param>
/// <returns></returns>
private static UnitPointBulge GetEndPointByLength(List <UnitPointBulge> points, int index, double length, bool isPositive)
{
int next = index + 1 >= points.Count ? 0 : index + 1;
var p1 = points[index];
var p2 = points[next];
UnitPoint end = UnitPoint.Empty;
if (!double.IsNaN(p1.Bulge))
{
ArcModelMini arc = DrawingOperationHelper.GetArcParametersFromBulge(p1.Point, p2.Point, (float)p1.Bulge);
double curLength = DrawingOperationHelper.GetArcLength(arc.Radius, arc.SweepAngle);
if (length < curLength)
{
float angle = (float)((isPositive ? length : (curLength - length)) / curLength) * arc.SweepAngle;
angle = arc.StartAngle + (float)HitUtil.DegreesToRadians(angle);
end = HitUtil.PointOnCircle(arc.Center, arc.Radius, angle);
}
else if (!double.IsNaN(length - curLength))
{
int nextIndex = isPositive ? next : (index - 1) < 0 ? points.Count - 1 : (index - 1);
return(GetEndPointByLength(points, nextIndex, length - curLength, isPositive));
}
}
else
{
double curLength = HitUtil.Distance(p1.Point, p2.Point);
if (length < curLength)
{
if (isPositive)
{
end = HitUtil.GetLinePointByDistance(p1.Point, p2.Point, length);
}
else
{
end = HitUtil.GetLinePointByDistance(p2.Point, p1.Point, length);
}
}
else if (!double.IsNaN(length - curLength))
{
int nextIndex = isPositive ? next : (index - 1) < 0 ? points.Count - 1 : (index - 1);
return(GetEndPointByLength(points, nextIndex, length - curLength, isPositive));
}
}
return(new UnitPointBulge(end, bulge: p1.Bulge, position: index));
}
private void CalAngleAndDirection(UnitPoint lastPoint)
{
double angle = HitUtil.LineAngleR(this.FirstPoint, lastPoint, 0);
double angle2 = HitUtil.LineAngleR(this.FirstPoint, this.ThirdPoint, 0);
this.LastPoint = this.ThirdPoint;
double theta = angle2 - angle;
if (theta > Math.PI)
{
theta -= Math.PI * 2;
}
else if (theta < -Math.PI)
{
theta += Math.PI * 2;
}
clockwise = theta >= 0 ? false : true;
this.rotateAngle = Math.Abs(HitUtil.RadiansToDegrees(theta));
}
/// <summary>
/// 直线与直线，补偿求交点
/// </summary>
/// <param name="p1"></param>
/// <param name="p2"></param>
/// <param name="p3"></param>
/// <param name="indexCur"></param>
/// <returns></returns>
private static List <UnitPointBulge> CalCompensationsBy2Line(UnitPointBulge p1, UnitPointBulge p2, UnitPointBulge p3, int indexCur, CompensationModel compensationParam, bool isOutside)
{
var retPoints = new List <UnitPointBulge>();
var cPoints1 = GetCompensationsPoint(p1, p2, compensationParam.Size, isOutside);
var cPoints2 = GetCompensationsPoint(p2, p3, compensationParam.Size, isOutside);
//如果两点距离在误差范围内，当做同一个点处理
if (HitUtil.Distance(cPoints1.Item2.Point, cPoints2.Item1.Point) < errorRange)
{
retPoints.Add(new UnitPointBulge(cPoints1.Item2.Point, p2.Bulge, hasMicroConn: p2.HasMicroConn, position: indexCur));
return(retPoints);
}
var line1 = DrawingOperationHelper.GetLineEquation(cPoints1.Item1.Point, cPoints1.Item2.Point);
var line2 = DrawingOperationHelper.GetLineEquation(cPoints2.Item1.Point, cPoints2.Item2.Point);
UnitPoint point = DrawingOperationHelper.GetIntersectionPointBy2Line(line1.Item1, line1.Item2, line1.Item3, line2.Item1, line2.Item2, line2.Item3);
if (double.IsNaN(point.X) || double.IsNaN(point.Y))
{
//平行
retPoints.Add(new UnitPointBulge(cPoints1.Item2.Point, p2.Bulge, hasMicroConn: p2.HasMicroConn, position: indexCur));
return(retPoints);
}
else
{
bool pointInLine = HitUtil.IsPointInLine(cPoints1.Item1.Point, cPoints1.Item2.Point, point, errorRange);
if (compensationParam.IsSmooth && !pointInLine)
{
//圆角处理，转换为带弧度的点
bool closewise = HitUtil.IsClockwiseByCross(cPoints1.Item1.Point, cPoints1.Item2.Point, p2.Point);
double bulge = BulgeHelper.GetBulgeFromTwoPointsAndCenter(p2.Point, cPoints1.Item2.Point, cPoints2.Item1.Point, closewise);
retPoints.Add(new UnitPointBulge(cPoints1.Item2.Point, bulge, hasMicroConn: p2.HasMicroConn, position: -1 - indexCur));
retPoints.Add(new UnitPointBulge(cPoints2.Item1.Point, p2.Bulge, hasMicroConn: p2.HasMicroConn, position: indexCur));
return(retPoints);
}
else
{
retPoints.Add(new UnitPointBulge(point, p2.Bulge, hasMicroConn: p2.HasMicroConn, position: indexCur));
return(retPoints);
}
}
}
public static bool IsPointOnArc(UnitPoint testPoint, float thWidth, ArcModelMini arcModel)
{
List <UnitPoint> temp = new List <UnitPoint>();
temp.Add(new UnitPoint(testPoint.X + thWidth, testPoint.Y + thWidth));
temp.Add(new UnitPoint(testPoint.X + thWidth, testPoint.Y - thWidth));
temp.Add(new UnitPoint(testPoint.X - thWidth, testPoint.Y + thWidth));
temp.Add(new UnitPoint(testPoint.X - thWidth, testPoint.Y - thWidth));
for (int i = 0; i < temp.Count; i++)
{
if (HitUtil.IsLineOnArc(arcModel.Center, temp[i], arcModel.Center, arcModel.Radius, arcModel.StartAngle, arcModel.SweepAngle, arcModel.Clockwise, thWidth))
{
double distance = HitUtil.Distance(arcModel.Center, testPoint);
if (distance <= arcModel.Radius + thWidth && distance >= arcModel.Radius - thWidth)
{
return(true);
}
}
}
return(false);
}
public bool HandleMouseDownForMeasure(UnitPoint unitPoint)
{
bool isComplete = false;
string msg = "";
List <Patameter> SubPatameter = new List <Patameter>();
if (this.CurrentStatus == Status.BasePoint)
{
this.CurrentStatus = Status.EndPoint;
FirstPoint = unitPoint;
msg = $"{unitPoint.X},{unitPoint.Y}";
}
else if (this.CurrentStatus == Status.EndPoint)
{
this.CurrentStatus = Status.BasePoint;
SecondPoint = unitPoint;
msg = $"{unitPoint.X},{unitPoint.Y}";
SubPatameter = new List <Patameter>()
{
new Patameter()
{
Explain = "长度：", ParameterValue = HitUtil.Distance(FirstPoint, SecondPoint).ToString()
},
new Patameter()
{
Explain = "X方向：", ParameterValue = (SecondPoint.X - FirstPoint.X).ToString()
},
new Patameter()
{
Explain = "Y方向：", ParameterValue = (SecondPoint.Y - FirstPoint.Y).ToString()
},
};
this.uCCanvas.DoInvalidate(true);
isComplete = true;
}
uCCanvas.SendDrawMsg(CanvasCommands.Measure.ToString(), msg, SubPatameter);
return(isComplete);
}
private static List <IDrawObject> ConvertToMultiSegLine(ArcBase arc, List <BridgePoints> bridges)
{
List <IDrawObject> retObjects = new List <IDrawObject>();
if (bridges.Count == 2)
{
double angle1 = HitUtil.LineAngleR(arc.Center, bridges[0].Point1.Point, 0);
double angle2 = HitUtil.LineAngleR(arc.Center, bridges[1].Point1.Point, 0);
angle1 = HitUtil.CalAngleSweep(arc.StartAngle, HitUtil.RadiansToDegrees(angle1), arc.IsClockwise);
angle2 = HitUtil.CalAngleSweep(arc.StartAngle, HitUtil.RadiansToDegrees(angle2), arc.IsClockwise);
if (angle1 > angle2)
{
bridges.Reverse();
}
double bulge1 = BulgeHelper.GetBulgeFromTwoPointsAndCenter(arc.Center, arc.startPoint, bridges[0].Point1.Point, arc.IsClockwise);
retObjects.Add(new MultiSegmentLineBase()
{
IsCloseFigure = false,
LayerId = arc.LayerId,
GroupParam = CopyUtil.DeepCopy(arc.GroupParam),
Points = new List <UnitPointBulge>()
{
new UnitPointBulge(arc.startPoint, bulge1), bridges[0].Point1
}
});
bridges[0].Point2.Bulge = BulgeHelper.GetBulgeFromTwoPointsAndCenter(arc.Center, bridges[0].Point2.Point, bridges[1].Point1.Point, arc.IsClockwise);;
retObjects.Add(new MultiSegmentLineBase()
{
IsCloseFigure = false,
LayerId = arc.LayerId,
GroupParam = CopyUtil.DeepCopy(arc.GroupParam),
Points = new List <UnitPointBulge>()
{
bridges[0].Point2, bridges[1].Point1
}
});
bridges[1].Point2.Bulge = BulgeHelper.GetBulgeFromTwoPointsAndCenter(arc.Center, bridges[1].Point2.Point, arc.endPoint, arc.IsClockwise);;
retObjects.Add(new MultiSegmentLineBase()
{
IsCloseFigure = false,
LayerId = arc.LayerId,
GroupParam = CopyUtil.DeepCopy(arc.GroupParam),
Points = new List <UnitPointBulge>()
{
bridges[1].Point2, new UnitPointBulge(arc.endPoint, bridges[1].Point2.Bulge)
}
});
}
else if (bridges.Count == 1)
{
double bulge1 = BulgeHelper.GetBulgeFromTwoPointsAndCenter(arc.Center, arc.startPoint, bridges[0].Point1.Point, arc.IsClockwise);
retObjects.Add(new MultiSegmentLineBase()
{
IsCloseFigure = false,
LayerId = arc.LayerId,
GroupParam = CopyUtil.DeepCopy(arc.GroupParam),
Points = new List <UnitPointBulge>()
{
new UnitPointBulge(arc.startPoint, bulge1), bridges[0].Point1
}
});
bridges[0].Point2.Bulge = BulgeHelper.GetBulgeFromTwoPointsAndCenter(arc.Center, bridges[0].Point2.Point, arc.endPoint, arc.IsClockwise);;
retObjects.Add(new MultiSegmentLineBase()
{
IsCloseFigure = false,
LayerId = arc.LayerId,
GroupParam = CopyUtil.DeepCopy(arc.GroupParam),
Points = new List <UnitPointBulge>()
{
bridges[0].Point2, new UnitPointBulge(arc.endPoint, bridges[0].Point2.Bulge)
}
});
}
return(retObjects);
}
public static List <IDrawObject> GetBridgeObjects(List <IDrawObject> drawObjects, UnitPoint p1, UnitPoint p2, BridgingModel param, out bool isChanged)
{
isChanged = false;//桥接是否改变了图形
List <BridgePoints> bridgePoints = new List <BridgePoints>();
#region 计算桥接点在图形中的点的坐标
drawObjects?.ForEach(drawObject =>
{
if ((drawObject.FigureType == FigureTypes.Circle))
{
Circle circle = drawObject as Circle;
var bridges = BridgeHelper.GetBridgeByCircle(circle, p1, p2, param);
bridgePoints.AddRange(bridges);
}
else if (drawObject.FigureType == FigureTypes.Arc)
{
ArcBase arc = drawObject as ArcBase;
var bridges = BridgeHelper.GetBridgeByArc(arc, p1, p2, param);
bridgePoints.AddRange(bridges);
}
else if (drawObject.FigureType == FigureTypes.LwPolyline)
{
MultiSegmentLineBase multiSegLine = drawObject as MultiSegmentLineBase;
var bridges = BridgeHelper.GetBridgeByMultiSegLine(multiSegLine, p1, p2, param);
bridgePoints.AddRange(bridges);
}
});
#endregion
#region 根据桥接点坐标，按直线的起点距离排序,如果奇数个将移除最后一个，保证偶数个可以连接
bridgePoints.Sort((x, y) => { if (x.Distance > y.Distance)
{
return(1);
}
return(-1); });
if (bridgePoints.Count % 2 == 1)
{
bridgePoints.RemoveAt(bridgePoints.Count - 1);
}
#endregion
#region 移除间距大于最大条件的点
List <BridgePoints> removes = new List <BridgePoints>();
for (int i = 0; i < bridgePoints.Count - 1; i += 2)
{
var bridge1 = bridgePoints[i];
var bridge2 = bridgePoints[i + 1];
if (Math.Abs(bridge1.Distance - bridge2.Distance) > param.MaxDistance)
{
removes.Add(bridge1);
removes.Add(bridge2);
}
}
removes.ForEach(e => bridgePoints.Remove(e));
#endregion
if (bridgePoints.Count > 0)
{
List <IDrawObject> temps = new List <IDrawObject>(); //计算后的图形
List <IDrawObject> oldDraws = new List <IDrawObject>(); //不用计算的原图
#region 根据桥接点的位置把原图形拆为多段线
foreach (IDrawObject drawObject in drawObjects)
{
var points = bridgePoints.FindAll(b => b.Owner == drawObject);
if (points.Count > 0)
{
List <IDrawObject> draws = null;
if (drawObject.FigureType == FigureTypes.Circle)
{
draws = BridgeHelper.ConvertToMultiSegLine(drawObject as Circle, points);
}
else if (drawObject.FigureType == FigureTypes.Arc)
{
draws = BridgeHelper.ConvertToMultiSegLine(drawObject as ArcBase, points);
}
else if (drawObject.FigureType == FigureTypes.LwPolyline)
{
draws = BridgeHelper.ConvertToMultiSegLine(drawObject as MultiSegmentLineBase, points);
}
if (draws != null)
{
draws.RemoveAll(p => (p as MultiSegmentLineBase).Points.Count < 2);
temps.AddRange(draws);
}
}
else
{
oldDraws.Add(drawObject);
}
}
#endregion
#region 连接最新的桥接图形
for (int i = 0; i < bridgePoints.Count - 1; i += 2)
{
var bridge1 = bridgePoints[i];
var bridge2 = bridgePoints[i + 1];
bool clockwise1 = HitUtil.IsClockwiseByCross(p1, p2, bridge1.Point1.Point);
bool clockwise2 = HitUtil.IsClockwiseByCross(p1, p2, bridge2.Point1.Point);
UnitPointBulge point11 = !clockwise1 ? bridge1.Point1 : bridge1.Point2;
UnitPointBulge point12 = clockwise1 ? bridge1.Point1 : bridge1.Point2;
UnitPointBulge point21 = !clockwise2 ? bridge2.Point1 : bridge2.Point2;
UnitPointBulge point22 = clockwise2 ? bridge2.Point1 : bridge2.Point2;
MultiSegmentLineBase draw11 = temps.Find(d => (d as MultiSegmentLineBase).Points.Contains(point11)) as MultiSegmentLineBase;
MultiSegmentLineBase draw12 = temps.Find(d => (d as MultiSegmentLineBase).Points.Contains(point12)) as MultiSegmentLineBase;
MultiSegmentLineBase draw21 = temps.Find(d => (d as MultiSegmentLineBase).Points.Contains(point21)) as MultiSegmentLineBase;
MultiSegmentLineBase draw22 = temps.Find(d => (d as MultiSegmentLineBase).Points.Contains(point22)) as MultiSegmentLineBase;
if (draw11 == null)
{
draw11 = new MultiSegmentLineBase()
{
LayerId = (bridge1.Owner as DrawObjectBase).LayerId, GroupParam = CopyUtil.DeepCopy(bridge1.Owner.GroupParam), Points = new List <UnitPointBulge>()
};
}
if (draw12 == null)
{
draw12 = new MultiSegmentLineBase()
{
LayerId = (bridge1.Owner as DrawObjectBase).LayerId, GroupParam = CopyUtil.DeepCopy(bridge1.Owner.GroupParam), Points = new List <UnitPointBulge>()
};
}
if (draw21 == null)
{
draw21 = new MultiSegmentLineBase()
{
LayerId = (bridge2.Owner as DrawObjectBase).LayerId, GroupParam = CopyUtil.DeepCopy(bridge2.Owner.GroupParam), Points = new List <UnitPointBulge>()
};
}
if (draw22 == null)
{
draw22 = new MultiSegmentLineBase()
{
LayerId = (bridge2.Owner as DrawObjectBase).LayerId, GroupParam = CopyUtil.DeepCopy(bridge2.Owner.GroupParam), Points = new List <UnitPointBulge>()
};
}
#region 组合多段线
if (draw11 == draw12 && draw21 == draw22)
{
if (draw11.Points.Count > 0 && draw11.Points[0] == point11)
{
draw11.ReverseDirection();
}
if (draw21.Points.Count > 0 && draw21.Points[0] != point21)
{
draw11.ReverseDirection();
}
if (draw11.Points.Count > 0)
{
draw11.Points[draw11.Points.Count - 1].Bulge = double.NaN;
}
if (draw21.Points.Count > 0)
{
draw21.Points[draw21.Points.Count - 1].Bulge = double.NaN;
}
draw11.Points.AddRange(draw21.Points);
draw11.IsCloseFigure = true;
temps.Remove(draw21);
}
else if (draw11 == draw12 && draw21 != draw22)
{
if (draw21.Points.Count > 0 && draw21.Points[0] == point21)
{
draw21.ReverseDirection();
}
if (draw22.Points.Count > 0 && draw22.Points[0] != point22)
{
draw22.ReverseDirection();
}
if (draw11.Points.Count > 0 && draw11.Points[0] != point11)
{
draw11.ReverseDirection();
}
if (draw21.Points.Count > 0)
{
draw21.Points[draw21.Points.Count - 1].Bulge = double.NaN;
}
if (draw11.Points.Count > 0)
{
draw11.Points[draw11.Points.Count - 1].Bulge = double.NaN;
}
draw21.Points.AddRange(draw11.Points);
draw21.Points.AddRange(draw22.Points);
temps.Remove(draw11);
temps.Remove(draw22);
}
else if (draw11 != draw12 && draw21 == draw22)
{
if (draw11.Points.Count > 0 && draw11.Points[0] == point11)
{
draw11.ReverseDirection();
}
if (draw21.Points.Count > 0 && draw21.Points[0] != point21)
{
draw21.ReverseDirection();
}
if (draw12.Points.Count > 0 && draw12.Points[0] != point12)
{
draw12.ReverseDirection();
}
if (draw11.Points.Count > 0)
{
draw11.Points[draw11.Points.Count - 1].Bulge = double.NaN;
}
if (draw21.Points.Count > 0)
{
draw21.Points[draw21.Points.Count - 1].Bulge = double.NaN;
}
draw11.Points.AddRange(draw21.Points);
draw11.Points.AddRange(draw12.Points);
temps.Remove(draw21);
temps.Remove(draw12);
}
else if (draw11 == draw21 && draw12 == draw22)
{
if (draw11.Points.Count > 0 && draw11.Points[0] != point11)
{
draw11.ReverseDirection();
}
if (draw12.Points.Count > 0 && draw12.Points[0] != point12)
{
draw12.ReverseDirection();
}
if (draw11.Points.Count > 0)
{
draw11.Points[draw11.Points.Count - 1].Bulge = double.NaN;
}
if (draw12.Points.Count > 0)
{
draw12.Points[draw12.Points.Count - 1].Bulge = double.NaN;
}
draw11.IsCloseFigure = true;
draw12.IsCloseFigure = true;
}
else if (draw11 == draw21 && draw12 != draw22)
{
if (draw11.Points.Count > 0 && draw11.Points[0] != point11)
{
draw11.ReverseDirection();
}
if (draw12.Points.Count > 0 && draw12.Points[0] == point12)
{
draw12.ReverseDirection();
}
if (draw22.Points.Count > 0 && draw22.Points[0] != point22)
{
draw22.ReverseDirection();
}
if (draw11.Points.Count > 0)
{
draw11.Points[draw11.Points.Count - 1].Bulge = double.NaN;
}
if (draw12.Points.Count > 0)
{
draw12.Points[draw12.Points.Count - 1].Bulge = double.NaN;
}
draw11.IsCloseFigure = true;
draw12.Points.AddRange(draw22.Points);
temps.Remove(draw22);
}
else if (draw11 != draw21 && draw12 == draw22)
{
if (draw12.Points.Count > 0 && draw12.Points[0] != point12)
{
draw12.ReverseDirection();
}
if (draw11.Points.Count > 0 && draw11.Points[0] == point11)
{
draw11.ReverseDirection();
}
if (draw21.Points.Count > 0 && draw21.Points[0] != point21)
{
draw21.ReverseDirection();
}
if (draw12.Points.Count > 0)
{
draw12.Points[draw12.Points.Count - 1].Bulge = double.NaN;
}
if (draw11.Points.Count > 0)
{
draw11.Points[draw11.Points.Count - 1].Bulge = double.NaN;
}
draw12.IsCloseFigure = true;
draw11.Points.AddRange(draw21.Points);
temps.Remove(draw21);
}
else
{
if (draw11.Points.Count > 0 && draw11.Points[0] == point11)
{
draw11.ReverseDirection();
}
if (draw21.Points.Count > 0 && draw21.Points[0] != point21)
{
draw21.ReverseDirection();
}
if (draw12.Points.Count > 0 && draw12.Points[0] == point12)
{
draw12.ReverseDirection();
}
if (draw22.Points.Count > 0 && draw22.Points[0] != point22)
{
draw22.ReverseDirection();
}
if (draw11.Points.Count > 0)
{
draw11.Points[draw11.Points.Count - 1].Bulge = double.NaN;
}
if (draw12.Points.Count > 0)
{
draw12.Points[draw12.Points.Count - 1].Bulge = double.NaN;
}
draw11.Points.AddRange(draw21.Points);
draw12.Points.AddRange(draw22.Points);
temps.Remove(draw21);
temps.Remove(draw22);
}
#endregion
}
#endregion
isChanged = true;
temps.ForEach(d => d.Update());
temps.AddRange(oldDraws);
return(temps);
}
return(drawObjects);
}
private static List <IDrawObject> ConvertToMultiSegLine(MultiSegmentLineBase multiSegLine, List <BridgePoints> bridges)
{
List <IDrawObject> retObjects = new List <IDrawObject>();
double totalLength = 0;
List <MicroUnitPoint> microTemps = MicroConnectHelper.InitMicroUnitPoint(multiSegLine.Points, multiSegLine.IsCloseFigure, out totalLength);
List <MicroUnitPoint> microBridges = new List <MicroUnitPoint>();
microTemps.ForEach(e => e.Point.IsBasePoint = true);
#region 位置点计算长度
foreach (BridgePoints point in bridges)
{
//第一个位置点
MicroUnitPoint startPoint = microTemps[(int)point.Point1.Position];
MicroUnitPoint endPoint = microTemps[(int)point.Point1.Position + 1 > microTemps.Count - 1 ? 0 : (int)point.Point1.Position + 1];
double length = 0;
if (!double.IsNaN(startPoint.Point.Bulge))
{
var arcMini = DrawingOperationHelper.GetArcParametersFromBulge(startPoint.Point.Point, endPoint.Point.Point, (float)startPoint.Point.Bulge);
double bulge = BulgeHelper.GetBulgeFromTwoPointsAndCenter(arcMini.Center, startPoint.Point.Point, point.Point1.Point, arcMini.Clockwise);
var arcNew = DrawingOperationHelper.GetArcParametersFromBulge(startPoint.Point.Point, point.Point1.Point, (float)bulge);
length = DrawingOperationHelper.GetArcLength(arcNew.Radius, arcNew.SweepAngle);
}
else
{
length = HitUtil.Distance(startPoint.Point.Point, point.Point1.Point);
}
microBridges.Add(new MicroUnitPoint()
{
Point = point.Point1,
OwerPos = (int)point.Point1.Position,
StartLength = startPoint.StartLength + length,
Flags = MicroConnectFlags.None
});
//第二个位置点
startPoint = microTemps[(int)point.Point2.Position];
endPoint = microTemps[(int)point.Point2.Position + 1 > microTemps.Count - 1 ? 0 : (int)point.Point2.Position + 1];
if (!double.IsNaN(startPoint.Point.Bulge))
{
var arcMini = DrawingOperationHelper.GetArcParametersFromBulge(startPoint.Point.Point, endPoint.Point.Point, (float)startPoint.Point.Bulge);
double bulge = BulgeHelper.GetBulgeFromTwoPointsAndCenter(arcMini.Center, startPoint.Point.Point, point.Point2.Point, arcMini.Clockwise);
var arcNew = DrawingOperationHelper.GetArcParametersFromBulge(startPoint.Point.Point, point.Point2.Point, (float)bulge);
length = DrawingOperationHelper.GetArcLength(arcMini.Radius, arcNew.SweepAngle);
}
else
{
length = HitUtil.Distance(startPoint.Point.Point, point.Point2.Point);
}
microBridges.Add(new MicroUnitPoint()
{
Point = point.Point2,
OwerPos = (int)point.Point2.Position,
StartLength = startPoint.StartLength + length,
Flags = MicroConnectFlags.None
});
}
#endregion
#region 排序，相当于在合适的位置插入位置点
microTemps.AddRange(microBridges);
microTemps.Sort((x, y) => { if (x.StartLength > y.StartLength)
{
return(1);
}
return(-1); });
#endregion
#region 更新bulge
for (int i = 0; i < microTemps.Count; i++)
{
int iNext = i + 1 >= microTemps.Count ? 0 : i + 1;
if (!double.IsNaN(microTemps[i].Point.Bulge) &&
(!microTemps[i].Point.IsBasePoint || !microTemps[iNext].Point.IsBasePoint))
{
int mIndex = microTemps[i].Point.IsBasePoint ? microTemps[i].OwerPos : (int)microTemps[i].Point.Position;
int mNext = mIndex + 1 >= multiSegLine.Points.Count ? 0 : mIndex + 1;
ArcModelMini arc = DrawingOperationHelper.GetArcParametersFromBulge(multiSegLine.Points[mIndex].Point, multiSegLine.Points[mNext].Point, (float)multiSegLine.Points[mIndex].Bulge);
microTemps[i].Point.Bulge = BulgeHelper.GetBulgeFromTwoPointsAndCenter(arc.Center, microTemps[i].Point.Point, microTemps[iNext].Point.Point, arc.Clockwise);
}
}
#endregion
#region 更新断开的位置标志
bridges.ForEach(e =>
{
int startIndex = microTemps.FindIndex(m => m.Point == e.Point1);
int endIndex = microTemps.FindIndex(m => m.Point == e.Point2);
if (startIndex > endIndex)
{
var points1 = microTemps.GetRange(startIndex, microTemps.Count - startIndex);
var points2 = microTemps.GetRange(0, endIndex);
points1.ForEach(p => p.Point.HasMicroConn = true);
points2.ForEach(p => p.Point.HasMicroConn = true);
}
else
{
var points = microTemps.GetRange(startIndex, endIndex - startIndex);
points.ForEach(p => p.Point.HasMicroConn = true);
}
});
#endregion
#region 转换为多段线
MultiSegmentLineBase lwPolyLine = null;
for (int i = 0; i < microTemps.Count; i++)
{
if (microTemps[i].Point.HasMicroConn)
{
if (lwPolyLine != null)
{
microTemps[i].Point.HasMicroConn = false;
lwPolyLine.Points.Add(microTemps[i].Point);
retObjects.Add(lwPolyLine);
lwPolyLine = null;
}
}
else
{
if (lwPolyLine == null)
{
lwPolyLine = new MultiSegmentLineBase()
{
IsCloseFigure = false,
LayerId = multiSegLine.LayerId,
GroupParam = CopyUtil.DeepCopy(multiSegLine.GroupParam),
Points = new List <UnitPointBulge>()
};
}
lwPolyLine.Points.Add(microTemps[i].Point);
}
}
if (lwPolyLine != null)
{
if (multiSegLine.IsCloseFigure)
{
(retObjects[0] as MultiSegmentLineBase).Points.InsertRange(0, lwPolyLine.Points);
}
else
{
retObjects.Add(lwPolyLine);
}
}
#endregion
return(retObjects);
}
private static List <BridgePoints> GetBridgeByMultiSegLine(MultiSegmentLineBase multiSegLine, UnitPoint p1, UnitPoint p2, BridgingModel param)
{
List <BridgePoints> retPoints = new List <BridgePoints>();
var line = DrawingOperationHelper.GetLineEquation(p1, p2);
double width = param.Width / 2;
var oriPoints = multiSegLine.Points;
for (int index = 0; index < oriPoints.Count; index++)
{
int next = (index + 1 == oriPoints.Count) ? 0 : index + 1;
UnitPointBulge point1 = oriPoints[index];
UnitPointBulge point2 = oriPoints[next];
if (!multiSegLine.IsCloseFigure && index == oriPoints.Count - 1)
{
break;
}
if (!double.IsNaN(point1.Bulge))
{
//圆弧
ArcModelMini arcMini = DrawingOperationHelper.GetArcParametersFromBulge(point1.Point, point2.Point, (float)point1.Bulge);
arcMini.StartAngle = (float)HitUtil.RadiansToDegrees(arcMini.StartAngle);
arcMini.EndAngle = (float)HitUtil.RadiansToDegrees(arcMini.EndAngle);
List <UnitPoint> points = DrawingOperationHelper.GetIntersectPointByLineAndCircle(line.Item1, line.Item2, line.Item3, arcMini.Center, arcMini.Radius);
var hasPoints = points?.Where(p => !p.IsEmpty && HitUtil.IsPointOnArc(p, 0.000001f, arcMini) && HitUtil.IsPointInLine(p1, p2, p, 0.000001f)).ToList();
if (hasPoints != null && hasPoints.Count > 0)
{
arcMini.StartAngle = (float)HitUtil.DegreesToRadians(arcMini.StartAngle);
arcMini.EndAngle = (float)HitUtil.DegreesToRadians(arcMini.EndAngle);
//根据宽度求点
double arcLength = DrawingOperationHelper.GetArcLength(arcMini.Radius, arcMini.SweepAngle);
hasPoints?.ForEach(p =>
{
double percent = DrawingOperationHelper.GetPercentInArcByPoint(arcMini, p);
//第一个位置点
double length1 = arcLength * (1 - percent) + width;
UnitPointBulge retP1 = GetEndPointByLength(oriPoints, index, length1, false);
//第二个位置点
double length2 = arcLength * percent + width;
UnitPointBulge retP2 = GetEndPointByLength(oriPoints, index, length2, true);
var bridge = new BridgePoints(multiSegLine, retP1, retP2, HitUtil.Distance(p1, p));
retPoints.Add(bridge);
});
}
}
else
{
//直线
var lineABC = DrawingOperationHelper.GetLineEquation(point1.Point, point2.Point);
UnitPoint point = DrawingOperationHelper.GetIntersectionPointBy2Line(line.Item1, line.Item2, line.Item3, lineABC.Item1, lineABC.Item2, lineABC.Item3);
if (!point.IsEmpty && HitUtil.IsPointInLine(point1.Point, point2.Point, point, 0.000001f) && HitUtil.IsPointInLine(p1, p2, point, 0.000001f))
{
//第一个位置点
double lenght1 = HitUtil.Distance(point2.Point, point) + width;
UnitPointBulge retP1 = GetEndPointByLength(oriPoints, index, lenght1, false);
//第二个位置点
double lenght2 = HitUtil.Distance(point1.Point, point) + width;
UnitPointBulge retP2 = GetEndPointByLength(oriPoints, index, lenght2, true);
var bridge = new BridgePoints(multiSegLine, retP1, retP2, HitUtil.Distance(p1, point));
retPoints.Add(bridge);
}
}
}
return(retPoints);
}
/// <summary>
/// 圆弧到直线，补偿求交点
/// </summary>
/// <param name="p1"></param>
/// <param name="p2"></param>
/// <param name="p3"></param>
/// <param name="indexCur"></param>
/// <returns></returns>
private static List <UnitPointBulge> CalCompensationsByArcLine(UnitPointBulge p1, UnitPointBulge p2, UnitPointBulge p3, int indexCur, CompensationModel compensationParam, bool isOutside)
{
var retPoints = new List <UnitPointBulge>();
ArcModelMini arc = DrawingOperationHelper.GetArcParametersFromBulge(p1.Point, p2.Point, (float)p1.Bulge);
var cPoints = GetCompensationsPoint(p2, p3, compensationParam.Size, isOutside);
double r = arc.Clockwise ? arc.Radius - compensationParam.Size : arc.Radius + compensationParam.Size;
if (isOutside)
{
r = arc.Clockwise ? arc.Radius + compensationParam.Size : arc.Radius - compensationParam.Size;
}
UnitPoint point1 = HitUtil.GetLinePointByDistance(arc.Center, p2.Point, r, true);
//如果两点距离在误差范围内，当做同一个点处理
if (HitUtil.Distance(point1, cPoints.Item1.Point) < errorRange)
{
retPoints.Add(new UnitPointBulge(point1, p2.Bulge, hasMicroConn: p2.HasMicroConn, position: indexCur));
return(retPoints);
}
var line = DrawingOperationHelper.GetLineEquation(cPoints.Item1.Point, cPoints.Item2.Point);
var intersects = DrawingOperationHelper.GetIntersectPointByLineAndCircle(line.Item1, line.Item2, line.Item3, arc.Center, r);
var validPoint = new UnitPoint(double.NaN, double.NaN);
UnitPoint intersecteArcPoint = new UnitPoint(double.NaN, double.NaN);
//筛选有交点,如果有两个点就选距离p2近的点
if (intersects.Count == 1)
{
validPoint = intersects[0];
}
else if (intersects.Count == 2)
{
validPoint = HitUtil.Distance(intersects[0], p2.Point) < HitUtil.Distance(intersects[1], p2.Point) ? intersects[0] : intersects[1];
}
if (validPoint.IsEmpty) //|| !HitUtil.IsPointInLine(cPoints.Item1.Point, cPoints.Item2.Point, validPoint, errorRange))
{
//求圆弧的切线的交点
if (arc.Clockwise != HitUtil.IsClockwiseByCross(p2.Point, point1, cPoints.Item1.Point))
{
var l1 = DrawingOperationHelper.GetLineEquationByVerticalLine(point1, p2.Point);
intersecteArcPoint = DrawingOperationHelper.GetIntersectionPointBy2Line(l1.Item1, l1.Item2, l1.Item3, line.Item1, line.Item2, line.Item3);
}
}
bool completedSmooth = false; //是否完成圆角处理
if (compensationParam.IsSmooth) //圆角处理
{
if (!intersecteArcPoint.IsEmpty ||
(!validPoint.IsEmpty && !HitUtil.IsPointInLine(cPoints.Item1.Point, cPoints.Item2.Point, validPoint, errorRange)))
{
bool closewise = HitUtil.IsClockwiseByCross(p2.Point, cPoints.Item1.Point, cPoints.Item2.Point);
double bulge = BulgeHelper.GetBulgeFromTwoPointsAndCenter(p2.Point, point1, cPoints.Item1.Point, closewise);
retPoints.Add(new UnitPointBulge(point1, bulge, hasMicroConn: p2.HasMicroConn, position: -1 - indexCur));
retPoints.Add(new UnitPointBulge(cPoints.Item1.Point, p2.Bulge, hasMicroConn: p2.HasMicroConn, position: indexCur));
completedSmooth = true;
}
}
if (!completedSmooth)
{
if (!intersecteArcPoint.IsEmpty)
{
retPoints.Add(new UnitPointBulge(point1, position: indexCur));
retPoints.Add(new UnitPointBulge(intersecteArcPoint, position: indexCur));
}
else if (!validPoint.IsEmpty)
{
retPoints.Add(new UnitPointBulge(validPoint, p2.Bulge, hasMicroConn: p2.HasMicroConn, position: indexCur));
return(retPoints);
}
else
{
retPoints.Add(new UnitPointBulge(point1, position: indexCur));
retPoints.Add(new UnitPointBulge(p2.Point, position: indexCur));
retPoints.Add(new UnitPointBulge(cPoints.Item1.Point, p2.Bulge, hasMicroConn: p2.HasMicroConn, position: indexCur));
}
}
return(retPoints);
}
/// <summary>
/// 圆弧到圆弧,补偿求交点
/// </summary>
/// <param name="p1"></param>
/// <param name="p2"></param>
/// <param name="p3"></param>
/// <param name="indexCur"></param>
/// <returns></returns>
private static List <UnitPointBulge> CalCompensationsBy2Arc(UnitPointBulge p1, UnitPointBulge p2, UnitPointBulge p3, int indexCur, CompensationModel compensationParam, bool isOutside)
{
var retPoints = new List <UnitPointBulge>();
ArcModelMini arc1 = DrawingOperationHelper.GetArcParametersFromBulge(p1.Point, p2.Point, (float)p1.Bulge);
ArcModelMini arc2 = DrawingOperationHelper.GetArcParametersFromBulge(p2.Point, p3.Point, (float)p2.Bulge);
double r1 = arc1.Clockwise ? arc1.Radius - compensationParam.Size : arc1.Radius + compensationParam.Size;
double r2 = arc2.Clockwise ? arc2.Radius - compensationParam.Size : arc2.Radius + compensationParam.Size;
if (isOutside)
{
r1 = arc1.Clockwise ? arc1.Radius + compensationParam.Size : arc1.Radius - compensationParam.Size;
r2 = arc2.Clockwise ? arc2.Radius + compensationParam.Size : arc2.Radius - compensationParam.Size;
}
UnitPoint point1 = HitUtil.GetLinePointByDistance(arc1.Center, p2.Point, r1, true);
UnitPoint point2 = HitUtil.GetLinePointByDistance(arc2.Center, p2.Point, r2, true);
if (HitUtil.Distance(point1, point2) < errorRange)
{
retPoints.Add(new UnitPointBulge(point2, p2.Bulge, hasMicroConn: p2.HasMicroConn, position: indexCur));
return(retPoints);
}
var intersects = DrawingOperationHelper.GetIntersectPointBy2Circle(arc1.Center, r1, arc2.Center, r2);
var validPoint = new UnitPoint(double.NaN, double.NaN);
UnitPoint intersecteArcPoint = new UnitPoint(double.NaN, double.NaN);
//筛选有交点,如果有两个点就选距离p2近的点
if (intersects.Count == 1)
{
validPoint = intersects[0];
}
else if (intersects.Count == 2)
{
validPoint = HitUtil.Distance(intersects[0], p2.Point) < HitUtil.Distance(intersects[1], p2.Point) ? intersects[0] : intersects[1];
}
bool closewise = HitUtil.IsClockwiseByCross(p2.Point, point1, point2);
if (validPoint.IsEmpty)
{
if (arc1.Clockwise != closewise || arc2.Clockwise != closewise)//求两个圆弧的切线的交点
{
var line1 = DrawingOperationHelper.GetLineEquationByVerticalLine(point1, arc1.Center);
var line2 = DrawingOperationHelper.GetLineEquationByVerticalLine(point2, arc2.Center);
intersecteArcPoint = DrawingOperationHelper.GetIntersectionPointBy2Line(line1.Item1, line1.Item2, line1.Item3, line2.Item1, line2.Item2, line2.Item3);
}
}
bool completedSmooth = false; //是否完成圆角处理
if (compensationParam.IsSmooth) //圆角处理
{
bool needSmooth = false;
if (!validPoint.IsEmpty)
{
double lineAngle = HitUtil.LineAngleR(arc1.Center, validPoint, 0);
bool pointInArc = HitUtil.IsPointInArc(HitUtil.RadiansToDegrees(lineAngle), HitUtil.RadiansToDegrees(arc1.StartAngle), HitUtil.RadiansToDegrees(arc1.EndAngle), arc1.Clockwise);
needSmooth = !pointInArc;
}
if (!intersecteArcPoint.IsEmpty || needSmooth)
{
double bulge = BulgeHelper.GetBulgeFromTwoPointsAndCenter(p2.Point, point1, point2, closewise);
retPoints.Add(new UnitPointBulge(point1, bulge, hasMicroConn: p2.HasMicroConn, position: -1 - indexCur));
retPoints.Add(new UnitPointBulge(point2, p2.Bulge, hasMicroConn: p2.HasMicroConn, position: indexCur));
completedSmooth = true;
}
}
if (!completedSmooth)
{
if (!validPoint.IsEmpty)
{
retPoints.Add(new UnitPointBulge(validPoint, p2.Bulge, hasMicroConn: p2.HasMicroConn, position: indexCur));
return(retPoints);
}
else if (!intersecteArcPoint.IsEmpty)
{
retPoints.Add(new UnitPointBulge(point1, position: indexCur));
retPoints.Add(new UnitPointBulge(intersecteArcPoint, position: indexCur));
retPoints.Add(new UnitPointBulge(point2, p2.Bulge, hasMicroConn: p2.HasMicroConn, position: indexCur));
}
else
{
retPoints.Add(new UnitPointBulge(point1, position: indexCur));
retPoints.Add(new UnitPointBulge(p2.Point, position: indexCur));
retPoints.Add(new UnitPointBulge(point2, p2.Bulge, hasMicroConn: p2.HasMicroConn, position: indexCur));
}
}
return(retPoints);
}
/// <summary>
/// 计算阵列中心点
/// </summary>
public void CalRotateCenterUnitPoint()
{
bool isSetCenter = GlobalModel.Params.ArrayAnnular.IsSetArrayCenterScope;
if (isSetCenter)
{
RectangleF rectangleF = GetMaxUnit();
double centerStartAngle = GlobalModel.Params.ArrayAnnular.CenterStartAngle;
RotateCenterUnitPoint = new UnitPoint((rectangleF.X + rectangleF.Width / 2) - (Math.Cos(HitUtil.DegreesToRadians(centerStartAngle)) * GlobalModel.Params.ArrayAnnular.CenterCricleRadius), (rectangleF.Y + rectangleF.Height / 2) - (Math.Sin(HitUtil.DegreesToRadians(centerStartAngle)) * GlobalModel.Params.ArrayAnnular.CenterCricleRadius));
}
}
