private static IEnumerable <IEntity2D> CreateRadius(Arc2D arc, Line2D line, double radiusValue, out bool radiusSuccess)
{
Arc2D filletArc = null;
var rsl = GeometryHelper.FilletEntity(arc, line, radiusValue, false, out filletArc);
if (rsl)
{
var lineWithRadius = new List <IEntity2D>();
/*
*
*
*/
arc.End = filletArc.Start;
line.Start = filletArc.End;
lineWithRadius.Add(arc);
lineWithRadius.Add(filletArc);
foreach (var entity2D in lineWithRadius)
{
entity2D.PlotStyle = arc.PlotStyle;
}
radiusSuccess = true;
return(lineWithRadius);
}
radiusSuccess = false;
return(null);
}
private static IEnumerable <IEntity2D> CreateRadius(Arc2D arc1, Arc2D arc2, double radiusValue, out bool radiusSuccess)
{
radiusSuccess = false;
return(null);
//var arc = new Arc2D()
//{
// Start = new Point2D(19.5002, 6.878),
// End = new Point2D(0, 10),
// Center = new Point2D(10, 10),
// Radius = 10,
//};
//var line = new Line2D()
//{
// Start = new Point2D(40.43, 0),
// End = new Point2D(19.5, 6.878),
//};
//var offsetArc = GeometryHelper.GetParallel(arc, 4, profileLeft);
//var offsetLine = GeometryHelper.GetParallel(line, 4, profileLeft);
//var pIncontro = GeometryHelper.GetIntersectPoint(offsetArc, offsetLine);
//var raccordo = new Arc2D();
//raccordo.Center = pIncontro;
//raccordo.Radius = 4;
//var pAttaccoLinea = GeometryHelper.GetIntersectPoint(raccordo, line);
//var pAttaccoRaggio = GeometryHelper.GetIntersectPoint(raccordo, arc, pIncontro);
}
public Profile2D GetClosedProfile()
{
var interasseArc = new Arc2D()
{
Center = new Point2D(CentroX, CentroY)
};
var clockWise = false;
var angoloStartRad = GeometryHelper.DegreeToRadian(AngoloStart);
var angoloEndRad = GeometryHelper.DegreeToRadian(AngoloStart + AngoloAmpiezza);
interasseArc.Radius = RaggioInterasse;
interasseArc.ClockWise = false;
interasseArc.Start = GeometryHelper.GetCoordinate(angoloStartRad, RaggioInterasse);
interasseArc.End = GeometryHelper.GetCoordinate(angoloEndRad, RaggioInterasse);
var offset = Larghezza / 2;
var arc1 = GeometryHelper.GetParallel(interasseArc, offset, true);
arc1.ClockWise = false;
var arc2 = GeometryHelper.GetParallel(interasseArc, offset, false);
arc2.ClockWise = true;
var temp = arc2.Start;
arc2.Start = arc2.End;
arc2.End = temp;
var arcEndCaps = new Arc2D()
{
Center = interasseArc.End,
ClockWise = true,
Start = arc1.End,
End = arc2.Start,
Radius = Larghezza / 2,
};
var arcStartCaps = new Arc2D()
{
Center = interasseArc.Start,
ClockWise = true,
Start = arc2.End,
End = arc1.Start,
Radius = Larghezza / 2,
};
var profile2D = new Profile2D();
profile2D.AddEntity(arc1);
profile2D.AddEntity(arcEndCaps);
profile2D.AddEntity(arc2);
profile2D.AddEntity(arcStartCaps);
arc1.PlotStyle = arc2.PlotStyle = arcStartCaps.PlotStyle = arcEndCaps.PlotStyle = EnumPlotStyle.Element;
return(profile2D);
}
private static IEnumerable <IEntity2D> CreateChamfer(Line2D line, Arc2D arc2D, double radiusValue, out bool radiusSuccess)
{
var rsl = ChamferEntity(arc2D, line, radiusValue, true, out radiusSuccess);
if (radiusSuccess)
{
return(rsl);
}
return(null);
}
private void UpdateGeometry()
{
/*
* se centro xy non è definito..
*/
_geometry = null;
/*
* qui mi devo basare sui punti che ho
* non devo fare calcoli ulteriori , se defined procedo , altrimenti mi attcco
*/
if (IsDefined && _prevTeoricalPnt != null && _endPnt != null)
{
if (!X.Value.HasValue || !Y.Value.HasValue || !Radius.Value.HasValue)
{
return;
}
var arc = new Arc2D
{
End = new Point2D(X.Value.Value, Y.Value.Value),
Radius = Radius.Value.Value,
Start = new Point2D(_prevTeoricalPnt),
ClockWise = IsClockwise,
};
if (CenterX.Value.HasValue)
{
arc.Center.X = CenterX.Value.Value;
}
if (CenterY.Value.HasValue)
{
arc.Center.Y = CenterY.Value.Value;
}
arc.PlotStyle = IsSelected ? EnumPlotStyle.SelectedElement : EnumPlotStyle.Element;
_geometry = arc;
// Set Plot Style
if (PlotStyle == EnumPlotStyle.Invisible)
{
_geometry.PlotStyle = EnumPlotStyle.Invisible;
}
}
}
internal ArcIterator(Arc2D a, AffineTransform at)
{
this.w = a.Width / 2;
this.h = a.Height / 2;
this.x = a.X + w;
this.y = a.Y + h;
this.AngStRad = -Math.ToRadians(a.GetAngleStart());
this.Affine = at;
double ext = -a.AngleExtent;
if (ext >= 360.0 || ext <= -360)
{
ArcSegs = 4;
this.Increment = Math.PI / 2;
// btan(Math.PI / 2);
this.Cv = 0.5522847498307933;
if (ext < 0)
{
Increment = -Increment;
Cv = -Cv;
}
}
else
{
ArcSegs = (int)System.Math.Ceiling(System.Math.Abs(ext) / 90.0);
this.Increment = Math.ToRadians(ext / ArcSegs);
this.Cv = Btan(Increment);
if (Cv == 0)
{
ArcSegs = 0;
}
}
switch (a.ArcType)
{
case Arc2D.OPEN:
LineSegs = 0;
break;
case Arc2D.CHORD:
LineSegs = 1;
break;
case Arc2D.PIE:
LineSegs = 2;
break;
}
if (w < 0 || h < 0)
{
ArcSegs = LineSegs = -1;
}
}
public static double[] GetIntersectionAngles(Segment2D line, Arc2D arc)
{
Vector2D delta = line.GetDelta();
double num1 = delta.X * delta.X + delta.Y * delta.Y;
Vector2D vector2D = line.Start - arc.Center;
double num2 = 2.0 * (vector2D.X * delta.X + vector2D.Y * delta.Y);
double num3 = vector2D.X * vector2D.X + vector2D.Y * vector2D.Y - arc.Radius * arc.Radius;
double d = num2 * num2 - 4.0 * num1 * num3;
if (d < 0.0)
{
return(new double[0]);
}
double num4 = System.Math.Sqrt(d);
double num5 = (-num2 - num4) / (2.0 * num1);
List <double> doubleList = new List <double>(2);
AngleIntervalD angleIntervalD = new AngleIntervalD(arc.StartAngle, arc.EndAngle);
if (num5 >= 0.0 && num5 <= 1.0)
{
double x = vector2D.X + delta.X * num5;
double num6 = System.Math.Atan2(vector2D.Y + delta.Y * num5, x);
if (num6 < 0.0)
{
num6 += 2.0 * System.Math.PI;
}
if (angleIntervalD.Contains(num6))
{
doubleList.Add(num6);
}
}
if (num4 != 0.0)
{
double num6 = (-num2 + num4) / (2.0 * num1);
if (num6 >= 0.0 && num6 <= 1.0)
{
double x = vector2D.X + delta.X * num6;
double num7 = System.Math.Atan2(vector2D.Y + delta.Y * num6, x);
if (num7 < 0.0)
{
num7 += 2.0 * System.Math.PI;
}
if (angleIntervalD.Contains(num7))
{
doubleList.Add(num7);
}
}
}
return(doubleList.ToArray());
}
public override ICurve2D GetProjectedCurve(ICurve curve, double precision)
{
if (curve is Line line)
{
// this must be a line through the apex, otherwise there are no lines on the cone
// if it is an extremely small line not through the apex, the result will also be a line, which
// in reverse projection will give a very short ellipse
return(new Line2D(PositionOf(line.StartPoint), PositionOf(line.EndPoint)));
}
else if (curve is Ellipse elli)
{
if (elli.IsCircle)
{
GeoPoint2D sp2d = PositionOf(elli.StartPoint);
if (elli.IsArc)
{
}
else
{
Arc2D a2d = new Arc2D(GeoPoint2D.Origin, sp2d.ToVector().Length, sp2d, sp2d, true);
GeoVector sdir = a2d.StartDirection.x * UDirection(sp2d) + a2d.StartDirection.y * VDirection(sp2d);
if (sdir * elli.StartDirection < 0)
{
a2d.counterClock = false;
}
return(a2d);
}
}
else
{
// this is a intersection with a plane.
GeoPoint2D[] fp2d = new GeoPoint2D[5];
double n = 5.0;
if (elli.IsArc)
{
n = 4.0;
}
for (int i = 0; i < 5; i++)
{
fp2d[i] = PositionOf(elli.PointAt(i / n));
}
Ellipse2D elli2d = Ellipse2D.FromFivePoints(fp2d, !elli.IsArc); // returns both full ellipse and ellipse arc
if (elli2d != null)
{
return(elli2d);
}
}
}
return(base.GetProjectedCurve(curve, precision));
}
//public override void SetZeroPoint(Point3D point3D)
//{
// throw new NotImplementedException();
//}
private void MoveArcWork(Arc2D arc, ref StringBuilder code)
{
var moveTypeCmd = string.Empty;
var moveType = arc.ClockWise ? MoveType.Cw : MoveType.Ccw;
if (CurrentMoveType != moveType)
{
CurrentMoveType = moveType;
moveTypeCmd = arc.ClockWise ? NumericControl.CMD_MoveCW : NumericControl.CMD_MoveCCW;
}
code.AppendLine(moveTypeCmd + "X" + arc.End.Y + "Z" + arc.End.X);
}
private ICurve2D fromPeriodic(ICurve2D curve2d)
{
// gegeben: Kurve im periodischen System, gesucht: Kurve im nichtperiodischen System
if (curve2d is Line2D)
{
Line2D l2d = curve2d as Line2D;
if (Math.Abs(l2d.StartDirection.y) < 1e-6)
{ // horizontale Linie im periodischen System wird Kreisbogen um den Mittelpunkt im nichtperiodischen System
Arc2D a2d = new Arc2D(GeoPoint2D.Origin, l2d.StartPoint.y - vmin, fromPeriodic(l2d.StartPoint), fromPeriodic(l2d.EndPoint), l2d.EndPoint.x > l2d.StartPoint.x);
return(a2d);
}
if (Math.Abs(l2d.StartDirection.x) < 1e-6)
{ // vertikale Linie um periodischen System sollte Linie durch den Ursprung im nichtperiodischen System werden
return(new Line2D(fromPeriodic(l2d.StartPoint), fromPeriodic(l2d.EndPoint)));
}
}
return(new TransformedCurve2D(curve2d, new NonPeriodicTransformation(vmin)));
}
/// <summary>
/// 判断画布中某个位置是否在某个圆弧附近;
/// </summary>
/// <param name="arc2D"></param>
/// <param name="point"></param>
/// <param name="canvasProxy"></param>
/// <returns></returns>
public static bool PointInArc(Arc2D arc2D, Vector2D point, ICanvasScreenConvertable canvasProxy)
{
if (canvasProxy == null)
{
return(false);
}
if (arc2D == null)
{
return(false);
}
//以视图单位为标准进行判断;
var screenPoint = canvasProxy.ToScreen(point);
var arcCenterScreenPoint = canvasProxy.ToScreen(arc2D.Center);
var screenRadius = canvasProxy.ToScreen(arc2D.Radius);
if (Math.Abs(arcCenterScreenPoint.Distance(screenPoint) - screenRadius) > TolerantedScreenLength)
{
return(false);
}
var centerToPointDirection = new Line2D(arc2D.Center, point).Direction;
if (Extension.AreEqual(centerToPointDirection.Modulus(), 0))
{
return(false);
}
var centerToPointAngle = Extension.AngleFrom(
new Vector3D(centerToPointDirection.X, centerToPointDirection.Y, 0),
Vector3D.BasisX
);
if (arc2D.Angle > 0)
{
return(centerToPointAngle < arc2D.StartAngle + arc2D.Angle && centerToPointAngle > arc2D.StartAngle);
}
else
{
return(centerToPointAngle < arc2D.StartAngle && centerToPointAngle > arc2D.StartAngle + arc2D.Angle);
}
}
private static Point2D GetInitChamferPointOnCfr(Arc2D cfrToChamfer, Point2D intersectPoint, double chamferValue, bool lineFirst)
{
// creo linea normale di lunghezza 1
var normalAngle = GeometryHelper.getNormalAngle(cfrToChamfer, intersectPoint);
var normalEndpoint = GeometryHelper.GetCoordinate(normalAngle, 1);
normalEndpoint.X += intersectPoint.X;
normalEndpoint.Y += intersectPoint.Y;
// trovo intersezioni tra cerchio da smussare e cerchio costruito sul punto di intersect
Point2D p1 = null;
Point2D p2 = null;
var pFlag = GeometryHelper.FindCircleCircleIntersections(cfrToChamfer.Center.X, cfrToChamfer.Center.Y, cfrToChamfer.Radius, intersectPoint.X, intersectPoint.Y, chamferValue, out p1, out p2);
if (pFlag == 2) // in questo metodo dovrebbe sempre restituire 2 punti ..
{
var d1 = GeometryHelper.Distance(normalEndpoint, p1);
var d2 = GeometryHelper.Distance(normalEndpoint, p2);
if (lineFirst)
{
if (d1 < d2)
{
return(p1);
}
return(p2);
}
else
{
if (d1 > d2)
{
return(p1);
}
return(p2);
}
}
else
{
throw new Exception("RawProfile.GetInitChamferPointOnCfr");
}
}
public static bool DoArc2DHandleInteraction(Arc2D arc, ref Vector2 centre, int hash, bool wasSelectedLast, Color lineColor, Color arcColor)
{
Event e = Event.current;
DrawArc2DHandle(arc, centre, hash, lineColor, arcColor, e);
if (wasSelectedLast || (HandleUtility.nearestControl == hash && e.type == e.GetTypeForControl(hash) && e.type == EventType.MouseDown))
{
Ray r = HandleUtility.GUIPointToWorldRay(e.mousePosition);
Plane p = new Plane(Vector3.forward, 0);
float outHit = 0;
if (p.Raycast(r, out outHit))
{
Vector2 pHit = r.origin + r.direction * outHit;
centre = pHit;
return(true);
}
}
return(false);
}
public Rect2D GetBoundary(Point startPoint)
{
switch (Type)
{
case SegmentType.StartPoint:
return(new Rect2D(Parameters[0], Parameters[1], 0, 0));
case SegmentType.Line:
return(new Rect2D(new Point(startPoint.X, startPoint.Y), new Point(Parameters[0], Parameters[1])));
case SegmentType.CircArc3Points:
{
var arc = new Arc2D(startPoint, new Point(Parameters[2], Parameters[3]), new Point(Parameters[0], Parameters[1]));
return(arc.GetBoundary());
}
default:
throw new NotImplementedException();
}
}
private void button1_Click(object sender, EventArgs e)
{
try
{
Vector2D vec1 = new Vector2D();
Vector2D vec2 = new Vector2D();
Point2D center = new Point2D(2003.4945, 1103.6469);
Point2D start = new Point2D(2494.6048, 982.6129);
Point2D end = new Point2D(1499.1729, 1142.3536);
Debug.WriteLine("distance between p1 p2 is : " + center.GetDistanceTo(start).ToString());
Debug.WriteLine("distance between p2 p3 is : " + end.GetDistanceTo(start).ToString());
Arc2D arc1 = new Arc2D(center, start, end);
vec1 = center.GetVector2DTo(start);
vec2 = center.GetVector2DTo(end);
}
catch (System.Exception ex)
{
Debug.WriteLine(ex.Message);
}
}
/// <summary>
/// Arc2DHandle.
/// </summary>
/// <returns>Returns the center position used to draw an Arc.</returns>
/// <param name="p1">Point 1.</param>
/// <param name="p2">Point 2.</param>
/// <param name="centre">Centre.</param>
/// <param name="wasHit">The tracking for whether the handle was selected.</param>
static Arc2D DrawArc2DHandle(Arc2D arc, Vector2 centre, int hash, Color lineColor, Color arcColor, Event e)
{
Vector3[] positions = new Vector3[20];
for (int i = 0; i < 20; i++)
{
positions [i] = arc.GetPosition(i / 19f);
positions [i] = positions [i];
}
Handles.color = arcColor;
Handles.DrawAAPolyLine(positions);
Handles.color = lineColor;
Handles.DrawLine(arc.centre, arc.p1);
Handles.DrawLine(arc.centre, arc.p2);
Handles.DrawDottedLine(arc.centre, centre, 5f);
float size = HandleUtility.GetHandleSize(centre) * 0.1f;
if (e.type == EventType.Layout)
{
HandleUtility.AddControl(hash, HandleUtility.DistanceToRectangle(Handles.matrix.MultiplyPoint(centre), Quaternion.identity, size));
}
Handles.RectangleHandleCap(hash, centre, Quaternion.identity, size, EventType.Repaint);
return(arc);
}
public Profile2D GetClosedProfile()
{
var cerchio = new Arc2D
{
Center = new Point2D(CentroX, CentroY),
Radius = Raggio,
ClockWise = false,
Start = { X = CentroX + Raggio },
End = { X = CentroX + Raggio },
};
cerchio.Start.Y = CentroY;
cerchio.End.Y = CentroY;
var profile2D = new Profile2D();
profile2D.AddEntity(cerchio);
cerchio.PlotStyle = EnumPlotStyle.Element;
return(profile2D);
}
public static bool equal(Arc2D a1, Arc2D a2)
{
if (a1 == null)
return a2 == null;
else
return a2 != null && ((RectangularShape) a1).getFrame().equals((object) ((RectangularShape) a2).getFrame()) && (a1.getAngleStart() == a2.getAngleStart() && a1.getAngleExtent() == a2.getAngleExtent()) && a1.getArcType() == a2.getArcType();
}
private static IEnumerable <IEntity2D> CreateChamfer(Arc2D arc, Arc2D arc2, double radiusValue, out bool radiusSuccess)
{
radiusSuccess = false;
return(null);
}
private static IEnumerable <IEntity2D> CreateRadius(Line2D geometry, Line2D line, double radiusValue, out bool radiusSuccess)
{
var l2P1 = line.Start;
var l2P2 = line.End;
var l1A = GeometryHelper.GetAngle(geometry.End, geometry.Start);
var l2A = GeometryHelper.GetAngle(l2P1, l2P2);
var teoricPnt = geometry.End;
//var angleResult = GetAverageAngle(l1A, l2A);
/// codice preso da internet , non ci ho pensato su molto forse buggy
double difference = l2A - l1A;
while (difference < -Math.PI)
{
difference += Math.PI * 2;
}
while (difference > Math.PI)
{
difference -= Math.PI * 2;
}
var angleAtRadius = Math.PI - Math.Abs(difference);
var distanceTrimmed = GetDistanceTrimmedByRadius(angleAtRadius / 2, radiusValue);
var puntoFinaleLinea = GeometryHelper.GetPointAtDistance(geometry.Start, geometry.End, distanceTrimmed, false);
var puntoFinaleRaggio = GeometryHelper.GetPointAtDistance(l2P1, l2P2, distanceTrimmed, true);
if (puntoFinaleLinea == null || puntoFinaleRaggio == null)
{
radiusSuccess = false;
return(null);
}
var lineWithRadius = new List <IEntity2D>();
geometry.End = puntoFinaleLinea;
line.Start = puntoFinaleRaggio;
var raccordo = new Arc2D {
Start = new Point2D(puntoFinaleLinea), End = new Point2D(puntoFinaleRaggio), Radius = radiusValue
};
raccordo.Center = CalcCenterRadius(geometry.Start, teoricPnt, l2P2, radiusValue);
raccordo.ClockWise = GeometryHelper.IsClockWise(puntoFinaleLinea, puntoFinaleRaggio, raccordo.Center);
// raccordo.Center = RawArc2D.GetCenterFromTwoPointsAndRadius(geometry.Start, geometry.End,radiusValue, false);
lineWithRadius.Add(geometry);
lineWithRadius.Add(raccordo);
foreach (var entity2D in lineWithRadius)
{
entity2D.PlotStyle = geometry.PlotStyle;
}
radiusSuccess = true;
return(lineWithRadius);
}
/// <summary>
/// Smusso fra arco - linea
/// </summary>
/// <param name="arc"></param>
/// <param name="line2D"></param>
/// <param name="chamferValue"></param>
/// <param name="lineFirst"></param>
/// <param name="chamferSuccess"></param>
/// <returns></returns>
public static IEnumerable <IEntity2D> ChamferEntity(Arc2D arc, Line2D line2D, double chamferValue, bool lineFirst, out bool chamferSuccess)
{
/*
* Per trovare punto sulla cfr
* - creo cerchio nel punto incontro con raggio == valore dello smusso
* - per linea faccio uguale metodo linea linea
*
*/
Point2D intersectionPnt = null;
if (lineFirst)
{
intersectionPnt = line2D.End;
}
else
{
intersectionPnt = arc.End;
}
//Point2D intersectionPnt = arc.Start;
var startArcChamfer = GetInitChamferPointOnCfr(arc, intersectionPnt, chamferValue, lineFirst);
var flagEnd = !lineFirst;
var puntoLineaRslt = GeometryHelper.GetPointAtDistance(line2D.Start, line2D.End, chamferValue, flagEnd);
if (puntoLineaRslt == null)
{
chamferSuccess = false;
return(null);
}
var lineChamfered = new List <IEntity2D>();
if (lineFirst)
{
line2D.End = puntoLineaRslt;
arc.Start = startArcChamfer;
var chamfer = new Line2D {
Start = new Point2D(puntoLineaRslt), End = new Point2D(startArcChamfer)
};
lineChamfered.Add(line2D);
lineChamfered.Add(chamfer);
foreach (var entity2D in lineChamfered)
{
entity2D.PlotStyle = line2D.PlotStyle;
}
}
else
{
line2D.Start = puntoLineaRslt;
arc.End = startArcChamfer;
var chamfer = new Line2D {
Start = new Point2D(startArcChamfer), End = new Point2D(puntoLineaRslt)
};
lineChamfered.Add(arc);
lineChamfered.Add(chamfer);
foreach (var entity2D in lineChamfered)
{
entity2D.PlotStyle = arc.PlotStyle;
}
}
chamferSuccess = true;
return(lineChamfered);
}
public Arc(Arc2D arc2D)
{
Arc2D = arc2D ?? throw new ArgumentNullException(nameof(arc2D));
Pen = LinePen;
}
/// <summary>
/// Funzione usata per disegnare linee
/// </summary>
void PlotElement(Arc2D arc)
{
// se l'arco è definito solamente dal raggio prendo cerchio
// è fare metodo per definire meglio il raggio dell'elemento da stampar..
if (arc.Start == null && arc.End == null && arc.Radius > 0 && arc.Center != null)
{
var el = new Ellipse {
Height = NormX(arc.Radius, arc.Radius), Width = NormX(Width, arc.Radius / 2)
};
el.SetValue(LeftProperty, NormX(arc.Center.X, arc.Radius / 2));
el.SetValue(TopProperty, NormY(arc.Center.Y, arc.Radius / 2));
//todo: il settaggio rtaggrupparlo con metodo setHiglight(ientity2d ent, graphicelemtne graphic element)
switch (arc.PlotStyle)
{
default:
case EnumPlotStyle.Element:
{
el.Stroke = Brushes.Green;
el.StrokeThickness = 1.5;
} break;
case EnumPlotStyle.SelectedElement:
{
el.Stroke = Brushes.Red;
el.StrokeThickness = 2.5;
} break;
case EnumPlotStyle.Path:
{
el.Stroke = Brushes.OrangeRed;
el.StrokeThickness = .3;
} break;
case EnumPlotStyle.SelectedPath:
{
el.Stroke = Brushes.Gainsboro;
el.StrokeThickness = .5;
} break;
}
Children.Add(el);
return;
}
// todo : controllare presenza 3 punti
var center = arc.Center;
var startAngle = GetPositiveAngle(arc.Start.X - center.X, arc.Start.Y - center.Y);
var endAngle = GetPositiveAngle(arc.End.X - center.X, arc.End.Y - center.Y);
var radius = arc.Radius;
var myPathFigure = new PathFigure();
myPathFigure.StartPoint = new Point(NormX(arc.Start.X, 0), NormY(arc.Start.Y, 0));
var myPathSegmentCollection = new PathSegmentCollection();
if (arc.ClockWise)
{
if (startAngle < endAngle)
{
startAngle += 2 * Math.PI;
}
for (var i = startAngle; i >= endAngle; i -= .05)
{
var myLineSegment = new LineSegment();
var x = (Math.Cos(i) * radius) + center.X;
var y = (Math.Sin(i) * radius) + center.Y;
myLineSegment.Point = new Point(NormX(x, 0), NormY(y, 0));
myPathSegmentCollection.Add(myLineSegment);
}
}
else
{
if (endAngle < startAngle)
{
endAngle += 2 * Math.PI;
}
if (endAngle > startAngle)
{
for (var i = startAngle; i <= endAngle; i += .05)
{
var myLineSegment = new LineSegment();
var x = (Math.Cos(i) * radius) + center.X;
var y = (Math.Sin(i) * radius) + center.Y;
myLineSegment.Point = new Point(NormX(x, 0), NormY(y, 0));
myPathSegmentCollection.Add(myLineSegment);
}
}
}
myPathFigure.Segments = myPathSegmentCollection;
var myPathFigureCollection = new PathFigureCollection {
myPathFigure
};
var myPathGeometry = new PathGeometry {
Figures = myPathFigureCollection
};
var myPath = new Path {
Data = myPathGeometry
};
switch (arc.PlotStyle)
{
default:
case EnumPlotStyle.Element:
{
myPath.Stroke = Brushes.Green;
myPath.StrokeThickness = 1.5;
} break;
case EnumPlotStyle.SelectedElement:
{
myPath.Stroke = Brushes.Red;
myPath.StrokeThickness = 2.5;
} break;
case EnumPlotStyle.Path:
{
myPath.Stroke = Brushes.OrangeRed;
myPath.StrokeThickness = .3;
} break;
case EnumPlotStyle.SelectedPath:
{
myPath.Stroke = Brushes.Gainsboro;
myPath.StrokeThickness = .5;
} break;
}
Children.Add(myPath);
}
/// <summary>
/// Detects arcs on gasket image
/// </summary>
private static void DetectArcs(Image gasketImage, out Arc2D[] detectedArcs, Segment2D[] conntectingSegments,
CoordinateSystem2D localSystem)
{
using (ArcFittingMap
arcMap1 = new ArcFittingMap(),
arcMap2 = new ArcFittingMap())
{
//public static void CreateArcFittingMap
//(
// AvlNet.ImageFormat inImageFormat,
// AvlNet.ArcFittingField inFittingField,
// AvlNet.CoordinateSystem2D? inFittingFieldAlignment,
// int inScanCount,
// int inScanWidth,
// AvlNet.InterpolationMethod inImageInterpolation,
// AvlNet.ArcFittingMap outFittingMap,
// IList<AvlNet.Segment2D> diagScanSegments,
// IList<AvlNet.Rectangle2D> diagSamplingAreas
//)
AVL.CreateArcFittingMap(new ImageFormat(gasketImage),
new ArcFittingField(upperExpectedArc, 20.0f),
localSystem,
10, 5,
InterpolationMethod.Bilinear,
arcMap1);
AVL.CreateArcFittingMap(new ImageFormat(gasketImage),
new ArcFittingField(lowerExpectedArc, 20.0f),
localSystem,
10, 5,
InterpolationMethod.Bilinear,
arcMap2);
Arc2D?upperArc, lowerArc;
//public static void FitArcToEdges
//(
// AvlNet.Image inImage,
// AvlNet.ArcFittingMap inFittingMap,
// AvlNet.EdgeScanParams inEdgeScanParams,
// AvlNet.Selection inEdgeSelection,
// AvlNet.LocalBlindness? inLocalBlindness,
// float inMaxIncompleteness,
// AvlNet.CircleFittingMethod inFittingMethod,
// AvlNet.MEstimator? inOutlierSuppression,
// out AvlNet.Arc2D? outArc,
// IList<AvlNet.Edge1D?> outEdges,
// INullable<AvlNet.Profile> outDeviationProfile,
// IList<AvlNet.Point2D> outInliers,
// IList<AvlNet.Profile> diagBrightnessProfiles,
// IList<AvlNet.Profile> diagResponseProfiles
//)
AVL.FitArcToEdges(gasketImage,
arcMap1,
scanParams,
Selection.Best, 0.1f, CircleFittingMethod.GeometricLandau,
out upperArc);
AVL.FitArcToEdges(gasketImage,
arcMap2,
scanParams,
Selection.Best, 0.1f, CircleFittingMethod.GeometricLandau,
out lowerArc);
if (upperArc.HasValue && lowerArc.HasValue)
{
//mr:: 这里使用了 Value 属性来取值.
detectedArcs = new[] { upperArc.Value, lowerArc.Value };
conntectingSegments[1] = new Segment2D(detectedArcs[0].Center, detectedArcs[1].Center);
}
else
{
detectedArcs = new Arc2D[0];
}
}
}
public static Arc2D[] CutRectangleFromArc(
Vector2D rectOrigin,
Vector2D rectDx,
Vector2D rectDy,
Arc2D arc)
{
Vector2D vector2D1 = rectOrigin;
Vector2D vector2D2 = rectOrigin + rectDx;
Vector2D vector2D3 = rectOrigin + rectDx + rectDy;
Vector2D vector2D4 = rectOrigin + rectDy;
Segment2D[] segment2DArray = new Segment2D[4] {
new Segment2D(vector2D1.X, vector2D1.Y, vector2D2.X, vector2D2.Y), new Segment2D(vector2D2.X, vector2D2.Y, vector2D3.X, vector2D3.Y), new Segment2D(vector2D3.X, vector2D3.Y, vector2D4.X, vector2D4.Y), new Segment2D(vector2D4.X, vector2D4.Y, vector2D1.X, vector2D1.Y)
};
List <IntersectionUtil.Struct1> struct1List = new List <IntersectionUtil.Struct1>();
for (int index = 0; index < segment2DArray.Length; ++index)
{
Segment2D line = segment2DArray[index];
foreach (double intersectionAngle in IntersectionUtil.GetIntersectionAngles(line, arc))
{
Vector2D delta = line.GetDelta();
double num = intersectionAngle + System.Math.PI / 2.0;
Vector2D vector2D5 = new Vector2D(System.Math.Cos(num), System.Math.Sin(num));
bool isStartOfCut = delta.X * vector2D5.Y - vector2D5.X * delta.Y > 0.0;
double angle = intersectionAngle - arc.StartAngle;
if (angle < 0.0)
{
angle += 2.0 * System.Math.PI;
}
struct1List.Add(new IntersectionUtil.Struct1(angle, isStartOfCut));
}
}
if (struct1List.Count == 0)
{
Vector2D u = (Vector2D)(arc.Center + arc.Radius * new Vector2D(System.Math.Cos(arc.StartAngle), System.Math.Sin(arc.StartAngle))) - rectOrigin;
double length1 = rectDx.GetLength();
double num1 = length1 * length1;
double length2 = rectDy.GetLength();
double num2 = length2 * length2;
double num3 = Vector2D.DotProduct(u, rectDx);
double num4 = Vector2D.DotProduct(u, rectDy);
if (num3 >= 0.0 && num3 <= num1 && (num4 >= 0.0 && num4 <= num2))
{
return(new Arc2D[0]);
}
return(new Arc2D[1] {
arc
});
}
struct1List.Sort();
IntersectionUtil.Struct1 struct1_1 = struct1List[0];
IntersectionUtil.Struct1 struct1_2 = struct1List[struct1List.Count - 1];
if (struct1_1.Angle != 0.0)
{
struct1List.Insert(0, new IntersectionUtil.Struct1(0.0, !struct1_1.IsStartOfCut));
}
double angle1 = arc.EndAngle - arc.StartAngle;
if (angle1 < 0.0)
{
angle1 += 2.0 * System.Math.PI;
}
if (struct1_2.Angle != angle1)
{
struct1List.Add(new IntersectionUtil.Struct1(angle1, !struct1_2.IsStartOfCut));
}
List <Arc2D> arc2DList = new List <Arc2D>(3);
for (int index = 0; index < struct1List.Count - 1; ++index)
{
IntersectionUtil.Struct1 struct1_3 = struct1List[index];
IntersectionUtil.Struct1 struct1_4 = struct1List[index + 1];
if (!struct1_3.IsStartOfCut && struct1_4.IsStartOfCut)
{
double startAngle = arc.StartAngle + struct1_3.Angle;
if (startAngle >= 2.0 * System.Math.PI)
{
startAngle -= 2.0 * System.Math.PI;
}
double endAngle = arc.StartAngle + struct1_4.Angle;
if (endAngle >= 2.0 * System.Math.PI)
{
endAngle -= 2.0 * System.Math.PI;
}
if (startAngle != endAngle)
{
Arc2D arc2D = new Arc2D(arc.Center, arc.Radius, startAngle, endAngle);
arc2DList.Add(arc2D);
}
}
}
return(arc2DList.ToArray());
}
