private void AddSide(int level, Coordinate p0, Coordinate p1)
{
if (level == 0)
{
AddSegment(p0, p1);
}
else
{
var baseV = Vector2D.Create(p0, p1);
var midPt = baseV.Multiply(0.5).Translate(p0);
var heightVec = baseV.Multiply(ThirdHeight);
var offsetVec = heightVec.RotateByQuarterCircle(1);
var offsetPt = offsetVec.Translate(midPt);
int n2 = level - 1;
var thirdPt = baseV.Multiply(OneThird).Translate(p0);
var twoThirdPt = baseV.Multiply(TwoThirds).Translate(p0);
// construct sides recursively
AddSide(n2, p0, thirdPt);
AddSide(n2, thirdPt, offsetPt);
AddSide(n2, offsetPt, twoThirdPt);
AddSide(n2, twoThirdPt, p1);
}
}
/// <summary>
/// 开始绘制
/// </summary>
/// <param name="gs"></param>
private void A_DrawStartEvent(ActionEventArgs gs)
{
TextGeometry tg = (gs.Geometry2D as TextGeometry);
var md = KernelProperty.MMToPix(tg.FontSize);
Vector2D nv = Vector2D.Create(tg.Central.X, tg.Central.Y - md / 2);
this.Tip.SetText("|", nv, 0);
}
/// <summary>
/// 将屏幕上的像素转换为尺寸信息
/// </summary>
/// <returns></returns>
public static Vector2D PixToMM(Point p)
{
//获取中心点的实际尺寸
var mx = central.X + (p.X - MeasureWidth / 2) * pixelToSize;
var my = central.Y + (-p.Y + MeasureHeight / 2) * pixelToSize;
return(Vector2D.Create(mx, my));
}
public List <Line2D> Find2()
{
List <Line2D> line2ds = SearchLines2;
List <Line2D> result = new List <Line2D>();
if (result == null)
{
//说明直线高度不一致
throw new Exception("给的线段高度不一致");
}
List <Line2D> remainingLines = null;
if (IsDecompose)
{
//对当前的线段进行打断
remainingLines = line2ds.Decompose();
}
else
{
remainingLines = new List <Line2D>(line2ds);
}
//首先要移除独立的线，不和其他线供端点，或者只公用一个端点
//获取最近点坐标
Vector2D origin = null;
//返回所有最靠近原点的店
List <Line2D> huntLines = this.GetHuntWithOrigin(out origin, remainingLines);
//所有的外框线
List <Line2D> outerLines = new List <Line2D>();
//获取起点的墙体
this.FindOuterLinessWithAngle(remainingLines, huntLines, outerLines, origin);
if (outerLines != null)
{
outerLines.ForEach(x =>
{
Line2D line2d = new Line2D(Vector2D.Create(x.Start.X, x.Start.Y), Vector2D.Create(x.End.X, x.End.Y));
result.Add(line2d);
});
}
return(result);
}
/// <summary>
/// 绘图板的窗体尺寸改变事件
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void DrawingControl_SizeChanged(object sender, SizeChangedEventArgs e)
{
KernelProperty.MeasureWidth = this.ActualWidth;
KernelProperty.MeasureHeight = this.ActualHeight;
if (BindingBox == null)
{
BindingBox = new BindingBox(Vector2D.Create(-this.ActualWidth / 2, -this.ActualHeight / 2), Vector2D.Create(this.ActualWidth / 2, this.ActualHeight / 2));
}
//刷新当前界面
this.Update();
}
/// <summary>
/// 开始绘制
/// </summary>
/// <param name="ms"></param>
public override void Update()
{
if (start != null && End != null)
{
List <Vector2D> points = new List <Vector2D>();
points.Add(start);
points.Add(end);
var xl = KernelProperty.PixToMM(30);
var leg = Vector2D.Create(end.X + xl, end.Y);
points.Add(leg);
this.Draw(points);
}
}
/// <summary>
/// 当前线的拷贝
/// </summary>
/// <param name="v"></param>
public override Geometry2D Copy(bool isclone)
{
var nstart = Vector2D.Create(this.start.X, this.start.Y);
var nend = Vector2D.Create(this.end.X, this.end.Y);
CircleGeometry circleGeometry = new CircleGeometry(nstart, nend);
if (isclone)
{
}
else
{
circleGeometry.Element = this.Element;
}
circleGeometry.PenColor = this.PenColor;
circleGeometry.FillColor = this.FillColor;
return(circleGeometry);
}
/// <summary>
/// 当前线的拷贝
/// </summary>
/// <param name="v"></param>
public override Geometry2D Copy(bool isclone)
{
var nstart = Vector2D.Create(this.start.X, this.start.Y);
var nend = Vector2D.Create(this.end.X, this.end.Y);
SteelColumnGeometry steelColumnGeometry = new SteelColumnGeometry(nstart, nend);
if (isclone)
{
}
else
{
steelColumnGeometry.Element = this.Element;
}
steelColumnGeometry.PenColor = this.PenColor;
steelColumnGeometry.FillColor = this.FillColor;
return(steelColumnGeometry);
}
/// <summary>
/// 当前线的拷贝
/// </summary>
/// <param name="v"></param>
public override Geometry2D Copy(bool isclone)
{
var nstart = Vector2D.Create(this.start.X, this.start.Y);
var nend = Vector2D.Create(this.end.X, this.end.Y);
WallGeometry wallGeometry = new WallGeometry(nstart, nend);
if (isclone)
{
}
else
{
wallGeometry.Element = this.Element;
}
wallGeometry.thickness = this.thickness;
wallGeometry.PenColor = this.PenColor;
wallGeometry.FillColor = this.FillColor;
return(wallGeometry);
}
/// <summary>
/// 当前线的拷贝
/// </summary>
/// <param name="v"></param>
public override Geometry2D Copy(bool isclone)
{
var ncentral = Vector2D.Create(this.central.X, this.central.Y);
var nreference = Vector2D.Create(this.reference.X, this.reference.Y);
EllipseGeometry ellipseGeometry = new EllipseGeometry(ncentral, nreference);
if (isclone)
{
}
else
{
ellipseGeometry.Element = this.Element;
}
ellipseGeometry.PenColor = this.PenColor;
ellipseGeometry.FillColor = this.FillColor;
ellipseGeometry.Element = this.Element;
return(ellipseGeometry);
}
/// <summary>
/// 获取引用的点
/// </summary>
/// <param name="canCatchPoints"></param>
/// <param name="v"></param>
/// <returns></returns>
private IntersectPoint RefencePoint(List <Vector2D> canCatchPoints, Vector2D v)
{
IntersectPoint ip = null;
if (canCatchPoints != null && canCatchPoints.Count > 0)
{
Vector2D point1 = canCatchPoints.OrderBy(x => Math.Abs(v.Y - x.Y)).First();
if (Math.Abs(v.Y - point1.Y) < KernelProperty.Tolerance)
{
if (ip == null)
{
ip = new IntersectPoint();
ip.IntersectPointStyle = 2;
ip.Point = Vector2D.Create(v.X, point1.Y);
ip.Refences = new List <Line2D>();
}
else
{
ip.Point = Vector2D.Create(ip.Point.X, point1.Y);
}
ip.Refences.Add(Line2D.Create(point1, ip.Point));
}
Vector2D point2 = canCatchPoints.OrderBy(x => Math.Abs(v.X - x.X)).First();
if (Math.Abs(v.X - point2.X) < KernelProperty.Tolerance)
{
if (ip == null)
{
ip = new IntersectPoint();
ip.IntersectPointStyle = 2;
ip.Point = Vector2D.Create(point2.X, v.Y);
ip.Refences = new List <Line2D>();
}
else
{
ip.Point = Vector2D.Create(point2.X, ip.Point.Y);
}
ip.Refences.Add(Line2D.Create(point2, ip.Point));
}
}
return(ip);
}
/// <summary>
/// 给当前线段绘制箭头
/// </summary>
/// <param name="line"></param>
protected virtual void DrawArrow(DrawingContext dc, Line2D line)
{
this.dashStyle = null;
var start = line.Start;
Line3D line3d = Line3D.Create(Vector3D.Create(line.Start.X, line.Start.Y, 0), Vector3D.Create(line.End.X, line.End.Y, 0));
var dir = line3d.Direction.Cross(Vector3D.BasisZ);
var ndir = Vector2D.Create(dir.X, dir.Y);
var v1 = start.Offset(ndir * KernelProperty.PixToMM(5)).Offset(line.Direction * KernelProperty.PixToMM(5));
var v2 = start.Offset(-ndir * KernelProperty.PixToMM(5)).Offset(line.Direction * KernelProperty.PixToMM(5));
dc.DrawLine(Pen, KernelProperty.MMToPix(start), KernelProperty.MMToPix(v1));
dc.DrawLine(Pen, KernelProperty.MMToPix(v2), KernelProperty.MMToPix(start));
var end = line.End;
var v3 = end.Offset(ndir * KernelProperty.PixToMM(5)).Offset(-line.Direction * KernelProperty.PixToMM(5));
var v4 = end.Offset(-ndir * KernelProperty.PixToMM(5)).Offset(-line.Direction * KernelProperty.PixToMM(5));
dc.DrawLine(Pen, KernelProperty.MMToPix(end), KernelProperty.MMToPix(v3));
dc.DrawLine(Pen, KernelProperty.MMToPix(v4), KernelProperty.MMToPix(end));
}
/// <summary>
/// 进行拖拽转动
/// </summary>
/// <param name="gs"></param>
private void A_DrawEraseEvent(ActionEventArgs gs)
{
var start = command.Start;
var end = command.End;
sublineHGeometry.Start = start;
sublineHGeometry.End = Vector2D.Create(start.X + 500, start.Y);
sublineHGeometry.Update();
sublineVGeometry.Start = start;
sublineVGeometry.End = start + Line2D.Create(start, end).Direction * 500;
sublineVGeometry.Update();
angleGeometry.Start = Vector2D.Create(start.X + 100, start.Y);;
angleGeometry.End = start + Line2D.Create(start, end).Direction * 100;
angleGeometry.Angle = Line2D.Create(start, end).Direction.AngleFrom(Vector2D.BasisX);
angleGeometry.Update();
}
/// <summary>
/// 拷贝一个完整的元素
/// </summary>
/// <param name="v"></param>
public override Geometry2D Copy(bool isclone)
{
var nstart = Vector2D.Create(this.start.X, this.start.Y);
var nend = Vector2D.Create(this.end.X, this.end.Y);
MemberGeometry memberGeometry = new MemberGeometry(nstart, nend, this.thickness);
if (isclone)
{
}
else
{
memberGeometry.Element = this.Element;
}
memberGeometry.Thickness = this.thickness;
memberGeometry.PenColor = this.PenColor;
memberGeometry.FillColor = this.FillColor;
memberGeometry.Opacity = this.Opacity;
return(memberGeometry);
}
/// <summary>
/// 当前线的拷贝
/// </summary>
/// <param name="v"></param>
public override Geometry2D Copy(bool isclone)
{
List <Vector2D> vts = new List <Vector2D>();
this.pPoints.ForEach(x =>
{
vts.Add(Vector2D.Create(x.X, x.Y));
});
PolylineGeometry polylineGeometry = new PolylineGeometry(vts);
if (isclone)
{
}
else
{
polylineGeometry.Element = this.Element;
}
polylineGeometry.PenColor = this.PenColor;
return(polylineGeometry);
}
/// <summary>
/// 拷贝一个完整的元素
/// </summary>
/// <param name="v"></param>
public override Geometry2D Copy(bool isclone)
{
var nstart = Vector2D.Create(this.start.X, this.start.Y);
var nend = Vector2D.Create(this.end.X, this.end.Y);
SteelBeamGeometry steelBeamGeometry = new SteelBeamGeometry(nstart, nend, this.thickness);
if (isclone)
{
}
else
{
steelBeamGeometry.Element = this.Element;
}
steelBeamGeometry.IsActioning = false;
steelBeamGeometry.Thickness = this.thickness;
steelBeamGeometry.PenColor = this.PenColor;
steelBeamGeometry.FillColor = this.FillColor;
steelBeamGeometry.Opacity = this.Opacity;
return(steelBeamGeometry);
}
/// <summary>
/// 拷贝一个完整的元素
/// </summary>
/// <param name="v"></param>
public override Geometry2D Copy(bool isclone)
{
var nstart = Vector2D.Create(this.start.X, this.start.Y);
var nend = Vector2D.Create(this.end.X, this.end.Y);
BeamGeometry beamGeometry = new BeamGeometry(nstart, nend, this.thickness);
if (isclone)
{
}
else
{
beamGeometry.Element = this.Element;
}
beamGeometry.thickness = this.thickness;
beamGeometry.PenColor = this.PenColor;
beamGeometry.FillColor = this.FillColor;
beamGeometry.Opacity = this.Opacity;
return(beamGeometry);
}
private void A_DrawEraseEvent(ActionEventArgs gs)
{
var start = command.Start;
var end = command.End;
sublineHGeometry.Start = start;
sublineHGeometry.End = Vector2D.Create(end.X, start.Y);
if (sublineHGeometry.Start.IsAlmostEqualTo(sublineHGeometry.End))
{
sublineHGeometry.Opacity = 0;
}
else
{
sublineHGeometry.Opacity = 1;
sublineHGeometry.Update();
}
sublineVGeometry.Start = sublineHGeometry.End;
sublineVGeometry.End = Vector2D.Create(sublineHGeometry.End.X, end.Y);
if (sublineVGeometry.Start.IsAlmostEqualTo(sublineVGeometry.End))
{
sublineVGeometry.Opacity = 0;
}
else
{
sublineVGeometry.Opacity = 1;
sublineVGeometry.Update();
}
sublineJGeometry.Start = sublineHGeometry.Start;
sublineJGeometry.End = sublineVGeometry.End;
if (sublineHGeometry.Opacity == 0 || sublineVGeometry.Opacity == 0)
{
sublineJGeometry.Opacity = 0;
}
else
{
sublineJGeometry.Opacity = 1;
sublineJGeometry.Update();
}
}
/// <summary>
/// 绘制当前直线
/// </summary>
public override void Update()
{
if (Start != null && end != null)
{
//对直线矩形偏移
Line3D subline3d = Line3D.Create(Vector3D.Create(Start.X, Start.Y, 0), Vector3D.Create(end.X, end.Y, 0));
var offsetDirection = subline3d.Direction.Cross(Vector3D.BasisZ);
//获取偏移量
var offsetdir = Vector2D.Create(offsetDirection.X, offsetDirection.Y) * KernelProperty.PixToMM(SublineOffset);
//添加偏移
var offline = Line2D.Create(Start, end).Offset(offsetdir);
List <Vector2D> points = new List <Vector2D>();
this.DashStyle = new System.Windows.Media.DashStyle(new double[] { 5, 5 }, 10);
this.PenColor = Colors.DeepSkyBlue;
this.Pen.EndLineCap = PenLineCap.Triangle;
points.Add(Start);
points.Add(offline.Start);
points.Add(offline.End);
points.Add(end);
this.Draw(points);
}
}
private void A_DrawEraseEvent(ActionEventArgs gs)
{
EllipseGeometry ellipse = this.action.Geometry as EllipseGeometry;
var start = ellipse.Central;
var end = ellipse.Reference;
sublineHGeometry.Start = start;
sublineHGeometry.End = Vector2D.Create(end.X, start.Y);
sublineHGeometry.Update();
sublineVGeometry.Start = start;
sublineVGeometry.End = Vector2D.Create(start.X, end.Y);
sublineVGeometry.Update();
if (!action.ConfirmOne)
{
Tip.SetText(sublineHGeometry.TextValue, sublineHGeometry.TextPosition, sublineHGeometry.TextAngle);
}
else
{
Tip.SetText(sublineVGeometry.TextValue, sublineVGeometry.TextPosition, sublineVGeometry.TextAngle);
}
}
private void A_DrawEraseEvent(ActionEventArgs gs)
{
RectangleGeometry rectangle = this.action.Geometry as RectangleGeometry;
var start = rectangle.Start;
var end = rectangle.End;
sublineHGeometry.Start = start;
sublineHGeometry.End = Vector2D.Create(end.X, start.Y);
sublineHGeometry.Update();
sublineVGeometry.Start = start;
sublineVGeometry.End = Vector2D.Create(start.X, end.Y);
sublineVGeometry.Update();
if (!action.ConfirmOne)
{
Tip.SetText(sublineHGeometry.TextValue, sublineHGeometry.TextPosition, sublineHGeometry.TextAngle);
}
else
{
Tip.SetText(sublineVGeometry.TextValue, sublineVGeometry.TextPosition, sublineVGeometry.TextAngle);
}
}
/// <summary>
/// 当前线的拷贝
/// </summary>
/// <param name="v"></param>
public override Geometry2D Copy(bool isclone)
{
List <Vector2D> pps = new List <Vector2D>();
pPoints.ForEach(x =>
{
pps.Add(Vector2D.Create(x.X, x.Y));
});
OSBGeometry osbGeometry = new OSBGeometry();
osbGeometry.pPoints = pps;
if (isclone)
{
}
else
{
osbGeometry.Element = this.Element;
}
osbGeometry.PenColor = this.PenColor;
osbGeometry.FillColor = this.FillColor;
osbGeometry.Opacity = this.Opacity;
return(osbGeometry);
}
/// <summary>
/// 多选操作
/// </summary>
/// <param name="start"></param>
/// <param name="end"></param>
/// <returns></returns>
public List <IntersectGeometry> MuiltSelect(Vector2D start, Vector2D end)
{
List <IntersectGeometry> selects = new List <IntersectGeometry>();
List <Geometry2D> sgs = this.DrawingControl.GetDrawingVisuals();
Vector2D v1 = start;
Vector2D v3 = end;
Vector2D v2 = Vector2D.Create(v3.X, v1.Y);
Vector2D v4 = Vector2D.Create(v1.X, v3.Y);
Line2D l1 = Line2D.Create(v1, v2);
Line2D l2 = Line2D.Create(v2, v3);
Line2D l3 = Line2D.Create(v3, v4);
Line2D l4 = Line2D.Create(v4, v1);
List <Line2D> region = new List <Line2D>()
{
l1, l2, l3, l4
};
//下拉
if (v1.X < v3.X)
{
for (int i = 0; i < sgs.Count; i++)
{
//必须所有的线都在选中框内部
List <Line2D> lines = sgs[i].Lines;
bool isInRegion = false;
if (lines != null)
{
for (int j = 0; j < lines.Count; j++)
{
isInRegion = true;
if (!lines[j].IsInRegion(region))
{
isInRegion = false;
break;
}
}
}
else
{
if (sgs[i] is CircleGeometry)
{
var circle = sgs[i] as CircleGeometry;
//当前中心点在矩形区域之内
if (circle.Start.IsInRegion(region))
{
isInRegion = true;
}
for (int j = 0; j < region.Count; j++)
{
if (circle.Start.DistanceTo(region[j]) < circle.Radius)
{
isInRegion = false;
}
}
}
}
if (isInRegion)
{
IntersectGeometry ig = new IntersectGeometry();
ig.GeometryShape = sgs[i];
selects.Add(ig);
}
}
}
else
{
for (int i = 0; i < sgs.Count; i++)
{
//主要部分在其中，则选中
List <Line2D> lines = sgs[i].Lines;
bool isInRegion = false;
if (lines != null)
{
for (int j = 0; j < lines.Count; j++)
{
if (lines[j].IsInRegion(region) || lines[j].IsPartInRegion(region))
{
isInRegion = true;
break;
}
}
}
else
{
if (sgs[i] is CircleGeometry)
{
var circle = sgs[i] as CircleGeometry;
for (int j = 0; j < region.Count; j++)
{
if (circle.Start.DistanceTo(region[j]) < circle.Radius)
{
isInRegion = true;
}
}
}
if (sgs[i] is Geometries.Primitives.EllipseGeometry)
{
}
}
if (isInRegion)
{
IntersectGeometry ig = new IntersectGeometry();
ig.GeometryShape = sgs[i];
selects.Add(ig);
}
}
}
return(selects);
}
/// <summary>
/// 直接指定结果，不重新绘制
/// </summary>
/// <param name="result"></param>
public void SetResult(dynamic result)
{
this.circle.End = Vector2D.Create(this.circle.Start.X + result, this.circle.Start.Y);
this.circle.Update();
this.Complete();
}
static Vector2D Create(double x, double y)
{
return(Vector2D.Create(x, y));
}
/// <summary>
/// 更新当前图形
/// </summary>
/// <param name="ms"></param>
public override void Update()
{
List <Vector2D> points = new List <Vector2D>();
if (Central != null)
{
if (this.central.IntersectPointStyle == 0)
{
var v1 = new Vector2D(central.Point.X - 5 * KernelProperty.PixelToSize, central.Point.Y - 5 * KernelProperty.PixelToSize);
var v2 = new Vector2D(central.Point.X + 5 * KernelProperty.PixelToSize, central.Point.Y - 5 * KernelProperty.PixelToSize);
var v3 = new Vector2D(central.Point.X + 5 * KernelProperty.PixelToSize, central.Point.Y + 5 * KernelProperty.PixelToSize);
var v4 = new Vector2D(central.Point.X - 5 * KernelProperty.PixelToSize, central.Point.Y + 5 * KernelProperty.PixelToSize);
points.Add(v1);
points.Add(v2);
points.Add(v3);
points.Add(v4);
points.Add(v1);
base.Draw(points);
}
else if (this.central.IntersectPointStyle == 1)
{
if (this.central.Line != null)
{
var Start = this.central.Line.Start;
var End = this.central.Line.End;
var Middle = central.Point;
//对直线矩形偏移
Line3D subline3d = Line3D.Create(Vector3D.Create(Start.X, Start.Y, 0), Vector3D.Create(End.X, End.Y, 0));
var offsetDirection = subline3d.Direction.Cross(Vector3D.BasisZ);
//获取偏移量
var offsetdir = Vector2D.Create(offsetDirection.X, offsetDirection.Y) * KernelProperty.PixToMM(KernelProperty.SublineOffset);
//冻结画笔，这样能加快绘图速度
DrawingContext dc = this.RenderOpen();
Pen.Freeze();
this.DashStyle = new System.Windows.Media.DashStyle(new double[] { 5, 5 }, 10);
this.PenColor = Colors.DeepSkyBlue;
this.Pen.EndLineCap = PenLineCap.Triangle;
var v1 = Start;
//添加偏移
var v2 = Start.Offset(offsetdir);
//绘制第一个线
dc.DrawLine(Pen, KernelProperty.MMToPix(v1), KernelProperty.MMToPix(v2));
var v3 = Middle.Offset(offsetdir);
//第二个线
dc.DrawLine(Pen, KernelProperty.MMToPix(v2), KernelProperty.MMToPix(v3));
//绘制文本
this.SetText(dc, Line2D.Create(v2, v3));
//绘制三个线竖线
dc.DrawLine(Pen, KernelProperty.MMToPix(v3), KernelProperty.MMToPix(Middle));
var v4 = End.Offset(offsetdir);
//绘制第四个线
dc.DrawLine(Pen, KernelProperty.MMToPix(v3), KernelProperty.MMToPix(v4));
this.SetText(dc, Line2D.Create(v3, v4));
//绘制第五个线
dc.DrawLine(Pen, KernelProperty.MMToPix(v4), KernelProperty.MMToPix(End));
//绘制偏移的线
var v5 = new Vector2D(central.Point.X - 5 * KernelProperty.PixelToSize, central.Point.Y - 5 * KernelProperty.PixelToSize);
var v6 = new Vector2D(central.Point.X + 5 * KernelProperty.PixelToSize, central.Point.Y - 5 * KernelProperty.PixelToSize);
var v7 = new Vector2D(central.Point.X - 5 * KernelProperty.PixelToSize, central.Point.Y + 5 * KernelProperty.PixelToSize);
var v8 = new Vector2D(central.Point.X + 5 * KernelProperty.PixelToSize, central.Point.Y + 5 * KernelProperty.PixelToSize);
dc.DrawLine(Pen, KernelProperty.MMToPix(v5), KernelProperty.MMToPix(v6));
dc.DrawLine(Pen, KernelProperty.MMToPix(v6), KernelProperty.MMToPix(v7));
dc.DrawLine(Pen, KernelProperty.MMToPix(v7), KernelProperty.MMToPix(v8));
dc.DrawLine(Pen, KernelProperty.MMToPix(v8), KernelProperty.MMToPix(v5));
dc.Close();
}
}
else if (this.central.IntersectPointStyle == 2)
{
//冻结画笔，这样能加快绘图速度
DrawingContext dc = this.RenderOpen();
Pen.Freeze();
this.DashStyle = new System.Windows.Media.DashStyle(new double[] { 5, 5 }, 10);
this.PenColor = Colors.DeepSkyBlue;
this.Pen.EndLineCap = PenLineCap.Triangle;
if (this.central.Refences != null)
{
this.central.Refences.ForEach(x => {
dc.DrawLine(Pen, KernelProperty.MMToPix(x.Start), KernelProperty.MMToPix(x.End));
});
}
dc.Close();
}
else if (this.central.IntersectPointStyle == 3)
{
DrawingContext dc = this.RenderOpen();
Pen.Freeze();
}
}
}
/// <summary>
/// 直接指定结果，不重新绘制
/// </summary>
/// <param name="result"></param>
public void SetResult(dynamic result)
{
this.arcGeometry.End = Vector2D.Create(this.arcGeometry.Start.X + result, this.arcGeometry.Start.Y);
this.arcGeometry.Update();
this.Complete();
}
/// <summary>
/// 检测一个点是否在一个多边形内部
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void InsideTestBtn_Click(object sender, RoutedEventArgs e)
{
List <Geometry2D> gss = this.drawingKernel.GeometryShapes;
List <Line2D> lines = new List <Line2D>();
List <Vector2D> vts = new List <Vector2D>();
foreach (var g in gss)
{
if (g is PolygonGeometry)
{
PolygonGeometry poly = g as DrawingKernel.Geometries.Primitives.PolygonGeometry;
g.FillColor = Colors.Azure;
g.Opacity = 0.3;
poly.Update();
lines.AddRange(poly.Lines);
}
if (g is DrawingKernel.Geometries.Primitives.LineGeometry)
{
DrawingKernel.Geometries.Primitives.LineGeometry l = g as DrawingKernel.Geometries.Primitives.LineGeometry;
vts.Add(l.Start);
vts.Add(l.End);
}
if (g.GeometryId == "tp")
{
this.drawingKernel.RemoveGeometryShape(g);
}
}
if (vts != null)
{
int resultP = 0;
for (int i = 0; i < vts.Count; i++)
{
resultP = GraphicAlgorithm.InsideOfRegion(vts[i], lines);
if (resultP == 0)
{
CircleGeometry c = new DrawingKernel.Geometries.Primitives.CircleGeometry();
c.FillColor = Colors.Red;
c.Start = vts[i];
c.End = Vector2D.Create(vts[i].X + 5, vts[i].Y);
c.GeometryId = "tp";
this.drawingKernel.AddShape(c);
}
else if (resultP == 1)
{
CircleGeometry c = new DrawingKernel.Geometries.Primitives.CircleGeometry();
c.FillColor = Colors.Green;
c.Start = vts[i];
c.End = Vector2D.Create(vts[i].X + 5, vts[i].Y);
c.GeometryId = "tp";
this.drawingKernel.AddShape(c);
}
else
{
CircleGeometry c = new DrawingKernel.Geometries.Primitives.CircleGeometry();
c.FillColor = Colors.Yellow;
c.Start = vts[i];
c.End = Vector2D.Create(vts[i].X + 5, vts[i].Y);
c.GeometryId = "tp";
this.drawingKernel.AddShape(c);
}
}
}
}
/// <summary>
/// 获取焦点信息
/// </summary>
internal IntersectPoint GetInterestPoint(Vector2D v)
{
IntersectPoint ip = null;
if (this.DrawingControl.IsUpdated)
{
canCatchPoints = new List <Vector2D>();
//获取界面上所有可视化图形
canCatchVisuals = this.DrawingControl.CatchVisuals();
if (KernelProperty.CanCatchEndPoint)
{
//获取所有的端点
List <Vector2D> endpoints = this.GetEndPoint(canCatchVisuals);
//添加所有的端点
canCatchPoints.AddRange(endpoints);
}
//当前所有的兴趣线
List <Line2D> InerestLines = this.GetInterestLine(canCatchVisuals);
if (KernelProperty.CanCatchIntersect)
{
//获取当前的兴趣点
List <Vector2D> InerestPoints = this.InterestPoint(InerestLines);
canCatchPoints.AddRange(InerestPoints);
}
if (KernelProperty.CanCatchCentral)
{
//获取当前中心点
List <Vector2D> MiddlePoints = this.MiddlePoint(InerestLines);
canCatchPoints.AddRange(MiddlePoints);
}
//剔除当前正在绘制的点和绘制的上一个点，不会用于捕捉
if (this.action.GetLastPoint() != null)
{
canCatchPoints.Remove(this.action.GetLastPoint());
}
if (this.action.GetPreviousPoint() != null)
{
canCatchPoints.Remove(this.action.GetPreviousPoint());
}
this.DrawingControl.IsUpdated = false;
}
//查找最近的点
if (canCatchPoints != null && canCatchPoints.Count > 0)
{
//查找最近的端点和相交点
Vector2D point = canCatchPoints.OrderBy(x => v.Distance(x)).First();
//获取了端点
if (v.Distance(point) < KernelProperty.Tolerance)
{
ip = new IntersectPoint();
ip.IntersectPointStyle = 0;
ip.Point = Vector2D.Create(point.X, point.Y);
}
}
if (ip == null)
{
ip = CatchVisualPoint(canCatchVisuals, v, ip);
}
//辅助线捕获，应该在交点有何没有的情况下，都应该获取
if (ip == null)
{
ip = this.RefencePoint(canCatchPoints, v);
}
return(ip);
}
/// <summary>
/// 按照指定的高度和宽度，对规则矩形进行划分，当前算法，运行的前提条件是，传入的图形是矩形元素
/// </summary>
/// <param name="square"></param>
/// <param name="width"></param>
/// <param name="height"></param>
/// <returns></returns>
public List <List <Line2D> > Partition(List <Line2D> square, double width, double height, Vector2D offset)
{
//根据板子宽度和高度，重新定义偏移量
var loffset = this.LayoutOffset(width, height, offset);
//获取要划分的矩形裕兴
List <Line2D> lines = new List <Line2D>(square);
//获取当前的划分多边形
List <List <Line2D> > result = new List <List <Line2D> >();
//获取图形中的最小点
List <Vector2D> vst = new List <Vector2D>();
square.ForEach(x =>
{
vst.Add(x.Start);
vst.Add(x.End);
});
//排除相同点
vst = vst.Distinct(new Vector2DEqualityComparer()).ToList();
//查找最小角点
var origin = vst.OrderBy(a =>
{
return(Math.Round(a.X, 7));
}).ThenBy(b =>
{
return(Math.Round(b.Y, 7));
}).FirstOrDefault();
////查找最小角点
//var origin = vst.OrderBy(a => a.X).ThenBy(c => c.Y).FirstOrDefault();
//逆时针排序,排列出
List <Line2D> sequeeLines = GraphicAlgorithm.Sort(lines, origin, 1);
//获取当前矩形的实际宽度和高度
double sw = sequeeLines[0].Length + loffset.X;
double sh = sequeeLines[1].Length + loffset.Y;
//代表需要水平偏移的个数
var lnx = Math.Ceiling(sw / width);
//代表垂直偏移的个数
var lny = Math.Ceiling(sh / height);
for (int i = 0; i < lnx; i++)
{
for (int j = 0; j < lny; j++)
{
Vector2D startPoint = null;
if (loffset != null)
{
startPoint = origin - loffset;
}
//代表顶点的偏移
Vector2D v1 = startPoint.Offset(width * i * sequeeLines[0].Direction).Offset(height * j * sequeeLines[1].Direction);
//最右边的顶点偏移
Vector2D v2 = startPoint.Offset(width * (i + 1) * sequeeLines[0].Direction).Offset(height * j * sequeeLines[1].Direction);
//偏移Y方向的区域，假如超过边界，则取边界值
Vector2D v4 = startPoint.Offset(width * i * sequeeLines[0].Direction).Offset(height * (j + 1) * sequeeLines[1].Direction);
if (v1.X < origin.X)
{
v1.X = origin.X;
}
if (v1.Y < origin.Y)
{
v1.Y = origin.Y;
}
//假如超出边界，则取边界值
if (v2.X > (origin.X + sequeeLines[0].Length))
{
v2 = Vector2D.Create(origin.X + sequeeLines[0].Length, v2.Y);
}
if (v2.Y < origin.Y)
{
v2.Y = origin.Y;
}
if (v4.Y > (origin.Y + sequeeLines[1].Length))
{
v4 = Vector2D.Create(v1.X, origin.Y + sequeeLines[1].Length);
}
if (v4.X < origin.X)
{
v4.X = origin.X;
}
if (v4.Y < origin.Y)
{
v4.Y = origin.Y;
}
//计算对角点
Vector2D v3 = Vector2D.Create(v2.X, v4.Y);
//获取划分的小多边形
List <Line2D> line2ds = new List <Line2D>()
{
Line2D.Create(v1, v2),
Line2D.Create(v2, v3),
Line2D.Create(v3, v4),
Line2D.Create(v4, v1)
};
result.Add(line2ds);
}
}
return(result);
}
