private void MainCanvas_MouseMove(object sender, MouseEventArgs e)
{
if (draggedElement == null)
{
return;
}
var position = e.GetPosition(mainCanvas);
if (Primitives.Point.Distance(position.X, position.Y, Canvas.GetLeft(draggedElement), Canvas.GetTop(draggedElement)) > 30)
{
draggedElement = null;
return;
}
position = new System.Windows.Point(position.X - mainCanvas.ActualWidth / 2, position.Y - mainCanvas.ActualHeight / 2);
if (!renderer.AngleDictionary.ContainsKey(draggedElement))
{
return;
}
var angle = renderer.AngleDictionary[draggedElement];
var sample = renderer.SampleDictionary[draggedElement];
var maxLength = mainCanvas.ActualWidth / 2;
var newLength = Math.Sqrt(Math.Pow(position.X, 2) + Math.Pow(position.Y, 2));
var delta = new PolarPoint(angle, newLength).ToCartesian();
sample.Value = ((MaxValue * newLength) / renderer.CalculatedMaxLineLength) / sample.Scale;
SampleValueChangedCommand?.Execute(sample);
Canvas.SetLeft(draggedElement, (mainCanvas.ActualWidth / 2 - (SamplePointDiameter / 2)) + delta.X);
Canvas.SetTop(draggedElement, (mainCanvas.ActualHeight / 2 - (SamplePointDiameter / 2)) + delta.Y);
}
public void CartesianCoordinateIsConvertedToPolar()
{
var testPoint = new PolarPoint(new Point(new Tube(2, 1, "Unknown")));
Assert.IsTrue(Math.Round(testPoint.R, 3) == 2.236);
Assert.IsTrue(Math.Round(testPoint.Degree, 3) == 26.565);
}
//private void renderCategoryLabels()
//{
// if (FocusedSegment == null)
// {
// return;
// }
// var context = new ProviderContext(Data.Count);
// MaterialProvider.Reset(context);
// _categoryLabels.Children.Clear();
// var diameter = _segments.RenderSize.Smallest() * CircleScale;
// var outerLabelRadius = (diameter / 2) * OuterLabelPositionScale;
// var overlayedLabelRadius = (diameter / 2) * .7;
// var targetAngularOffset = FocusedSegment.RequireType<ArcPath>().CalculateAngularOffset();
// foreach (var d in Data)
// {
// var materialSet = MaterialProvider.ProvideNext(context);
// var categoryNameLabel = positionLabel(d, outerLabelRadius, targetAngularOffset, true);
// categoryNameLabel.Content = d.CategoryName;
// categoryNameLabel.BindTextualPrimitive<BarTotalPrimitive>(this);
// categoryNameLabel.Foreground = BarTotalForeground.GetMaterial(materialSet);
// _categoryLabels.Children.Add(categoryNameLabel);
// var valueLabel = positionLabel(d, overlayedLabelRadius, targetAngularOffset);
// valueLabel.Content = d.Value;
// valueLabel.BindTextualPrimitive<ValuePrimitive>(this);
// valueLabel.Foreground = ValueForeground.GetMaterial(materialSet);
// _categoryLabels.Children.Add(valueLabel);
// }
//}
private Label positionLabel(CategoricalDouble d, double radius, double targetAngularOffset,
bool horizontalPositionSkew = false)
{
var categoryLabel = new Label
{
HorizontalAlignment = HorizontalAlignment.Center,
VerticalAlignment = VerticalAlignment.Center,
IsHitTestVisible = false
};
var pretransformedOffset = d.RenderedVisual.RequireType <ArcPath>().PolarOffset;
var arcAngle = d.RenderedVisual.RequireType <ArcPath>().ArcAngle;
var pretransformedLabelAngle = pretransformedOffset + (arcAngle / 2);
var actualLabelAngle = pretransformedLabelAngle - targetAngularOffset;
var horizontalLabelSkew = horizontalPositionSkew
? Math.Cos(CoordinateHelpers.ToRadian(actualLabelAngle)) * HorizontalLabelPositionSkew
: 0;
var labelRadius = radius;
var polarPoint = new PolarPoint(actualLabelAngle, labelRadius);
var labelCoordinate = polarPoint.ToCartesian();
categoryLabel.Margin = new Thickness(labelCoordinate.X + horizontalLabelSkew, -labelCoordinate.Y,
-labelCoordinate.X - horizontalLabelSkew, labelCoordinate.Y);
return(categoryLabel);
}
private SKPoint FromPolar(PolarPoint point)
{
float x = (float)(point.Radius * Math.Cos(point.Angle));
float y = (float)(point.Radius * Math.Sin(point.Angle));
return(new SKPoint(x, y));
}
public static Point2D ToPoint2D(this PolarPoint polarPoint)
{
var x = polarPoint.DistanceFromCenter * Math.Cos(polarPoint.Angle);
var y = polarPoint.DistanceFromCenter * Math.Sin(polarPoint.Angle);
return(new Point2D(x, y));
}
public void CalcMeasure()
{
if (measureRange.FromLocation != null && measureRange.ToLocation != null)
{
double lat1 = measureRange.FromLocation.Latitude;
double lon1 = measureRange.FromLocation.Longitude;
double lat2 = measureRange.ToLocation.Latitude;
double lon2 = measureRange.ToLocation.Longitude;
measureResult.DST = CalcDistance(lat1, lon1, lat2, lon2) / 1852;
double brg = CalcBearing(lat1, lon1, lat2, lon2);
measureResult.BRG = (brg + 360) % 360;
if (TWS.IsValid())
{
measureResult.TWA = TWD.Average(Inst.BufHalfMin) - brg;
}
double vmc = 0;
PolarPoint p = new PolarPoint();
if (SOG.IsValid())
{
vmc = SOG.Average(Inst.BufHalfMin);
}
if (TWD.IsValid() && SPD.IsValid() && NavPolar.IsLoaded)
{
double Angle = Math.Abs(measureResult.TWA % 360);
if (Angle > 180)
{
Angle = 360 - Angle;
}
if (Angle < 50)
{
p = NavPolar.GetBeatTarget(TWS.Average(Inst.BufHalfMin));
vmc = p.SPD * Math.Cos(p.TWA * Math.PI / 180);
}
else
if (Angle > 140)
{
p = NavPolar.GetRunTarget(TWS.Average(Inst.BufHalfMin));
vmc = -p.SPD * Math.Cos(p.TWA * Math.PI / 180);
}
else
{
vmc = NavPolar.GetTarget(Angle, TWS.Average(Inst.BufHalfMin));
}
}
if (vmc != 0)
{
measureResult.TTG = TimeSpan.FromHours(measureResult.DST / vmc);
}
else
{
measureResult.TTG = TimeSpan.FromHours(0);
}
}
}
public void PolarCoordinateIsConvertedTo()
{
var testPoint = new PolarPoint(new Point(new Tube(2, 1, "Unknown")));
var cartessianPoint = Point.FromPolarPoint(testPoint);
Assert.IsTrue(cartessianPoint.X == 1);
Assert.IsTrue(cartessianPoint.Y == 2);
}
public void PolarPointToPoint()
{
var polar = new PolarPoint(100D, Math.PI / 4);
var decart = polar.Point;
Aver.AreEqual(70D, Math.Floor((double)decart.X));
Aver.AreEqual(70D, Math.Floor((double)decart.Y));
}
public void PolarPointIsEqual()
{
var polar1 = new PolarPoint(100D, 1.2D);
var polar2 = new PolarPoint(10D, 2.17D);
var polar3 = new PolarPoint(100D, 1.2D);
Aver.AreObjectsNotEqual(polar1, polar2);
Aver.AreObjectsEqual(polar1, polar3);
}
public void PolarPointTheta()
{
var polar = new PolarPoint(100D, Math.PI);
Aver.AreEqual(314D, Math.Floor(polar.Theta * 100D));
polar.Theta = 1.18D;
Aver.AreEqual(118D, Math.Floor(polar.Theta * 100D));
}
public void PolarPointIsEqual()
{
var polar1 = new PolarPoint(100D, 1.2D);
var polar2 = new PolarPoint(10D, 2.17D);
var polar3 = new PolarPoint(100D, 1.2D);
Assert.AreNotEqual(polar1, polar2);
Assert.AreEqual(polar1, polar3);
}
public void PolarPointRadius()
{
var polar = new PolarPoint(100D, Math.PI);
Aver.AreEqual(100D, polar.R);
polar.R = 125D;
Aver.AreEqual(125D, polar.R);
}
public void PointToPolarPoint()
{
var center = new Point(0, 0);
var pnt = new Point(150, 0);
var polar = new PolarPoint(center, pnt);
Aver.AreEqual(150D, polar.R);
Aver.AreEqual(0D, polar.Theta);
}
public EdgeShape Construct(Template template, int reference, int neighbor)
{
PolarPoint polar = Angle.ToPolar(Calc.Difference(template.Minutiae[neighbor].Position, template.Minutiae[reference].Position));
EdgeShape edge;
edge.Length = (short)polar.Distance;
edge.ReferenceAngle = Angle.Difference(template.Minutiae[reference].Direction, polar.Angle);
edge.NeighborAngle = Angle.Difference(template.Minutiae[neighbor].Direction, Angle.Opposite(polar.Angle));
return(edge);
}
public static void CalcLongNav(DateTime now)
{
if (TWA.IsValid() && BRG.IsValid() && DRIFT.IsValid() && NavPolar.IsLoaded)
{
PolarPoint p = NavPolar.GetTargetVMC(TWS.Val, TWD.Val, BRG.Val, DRIFT.Val, SET.Val);
TGTVMC.Val = p.SPD;
TGTVMC.SetValid(now);
TGTCTS.Val = TWD.Val + p.TWA;
TGTCTS.SetValid(now);
}
}
public static void CalcLongNav(DateTime now)
{
if (TWA.IsValid() && BRG.IsValid() && DRIFT.IsValid() && NavPolar.IsLoaded)
{
PolarPoint p = NavPolar.GetTargetVMC(TWS.Average(Inst.BufTwoMin), TWD.Average(Inst.BufTwoMin), BRG.Val, DRIFT.Average(Inst.BufTwoMin), SET.Average(Inst.BufTwoMin));
TGTVMC.Val = p.SPD;
TGTVMC.SetValid(now);
TGTCTS.Val = TWD.Average(Inst.BufTwoMin) + p.TWA;
TGTCTS.SetValid(now);
}
}
public void ToCartesianToPolar_ExpectedParameter_OriginalValue()
{
//----------- Arrange -----------------------------
var origin = new PolarPoint(1, 1);
//----------- Act ---------------------------------
var result = origin.ToCartesian().ToPolar();
//----------- Assert-------------------------------
Assert.True(origin.R.Is(result.R, 1e-12) && origin.Θ.Is(result.Θ, 1e-12));
}
public void ToCartesian_LargeAngle_ExpectedBehavior()
{
//----------- Arrange -----------------------------
var right = new PolarPoint(1, 1000 * MathExt.TwoPi);
//----------- Act ---------------------------------
var ihat = right.ToCartesian();
//----------- Assert-------------------------------
Assert.True(ihat.X.Is(1, 1e-12) && ihat.Y.Is(0, 1e-12));
}
public void PolarPointInvalid()
{
try
{
var pp = new PolarPoint(100, 789);
Aver.Fail("Object was created");
}
catch (AzosException ex)
{
Aver.IsTrue(ex.Message.Contains("angle"));
}
}
public void PolarPointInvalid()
{
try
{
var pp = new PolarPoint(100, 789);
Assert.Fail();
}
catch (NFXException ex)
{
Assert.IsTrue(ex.Message.Contains("angle"));
}
}
public void PolarPointEquality_NotEqual_NotEqual()
{
//----------- Arrange -----------------------------
var data = new PolarPoint(1, 0);
var data2 = new PolarPoint(0.5, Math.PI);
//----------- Act ---------------------------------
bool result = data == data2;
bool inverse = data != data2;
//----------- Assert-------------------------------
Assert.False(result);
Assert.True(inverse);
}
private static PathGeometry SelectedGeometry(Size renderSpace)
{
var leftBaseAnchor = new Point(0, 0);
var rightBaseAnchor = leftBaseAnchor.PushHorizontal(renderSpace.Width);
var slopeVerticalPosition = renderSpace.Height / 2;
var rightTopAnchor = rightBaseAnchor.PushVertical(slopeVerticalPosition);
var leftTopAnchor = leftBaseAnchor.PushVertical(slopeVerticalPosition);
var leftTopAnchorControlVector = new PolarPoint(45, 30);
var rightTopAnchorControlVector = new PolarPoint(135, 30);
var leftTopAnchorControlPoint = leftTopAnchor.Add(leftTopAnchorControlVector.ToCartesian());
var rightTopAnchorControlPoint = rightTopAnchor.Add(rightTopAnchorControlVector.ToCartesian());
var topCenterAnchor = new Point(renderSpace.Width / 2, renderSpace.Height);
return(new PathGeometry
{
Figures = new PathFigureCollection
{
new PathFigure
{
StartPoint = leftBaseAnchor.LocalizeInCartesianSpace(renderSpace),
Segments = new PathSegmentCollection
{
new LineSegment {
Point = rightBaseAnchor.LocalizeInCartesianSpace(renderSpace)
},
new LineSegment {
Point = rightTopAnchor.LocalizeInCartesianSpace(renderSpace)
},
new QuadraticBezierSegment
{
Point1 = rightTopAnchorControlPoint.LocalizeInCartesianSpace(renderSpace),
Point2 = topCenterAnchor.LocalizeInCartesianSpace(renderSpace)
},
new QuadraticBezierSegment
{
Point1 = leftTopAnchorControlPoint.LocalizeInCartesianSpace(renderSpace),
Point2 = leftTopAnchor.LocalizeInCartesianSpace(renderSpace)
},
new LineSegment {
Point = leftBaseAnchor.LocalizeInCartesianSpace(renderSpace)
}
}
}
}
});
}
public static Geometry CalculateArcPath(Size size, double radius, double arcWidth, double angle, double offsetAngle)
{
if (radius <= 0 || arcWidth <= 0 || radius - arcWidth < 0)
{
return(Geometry.Empty);
}
var startOuterPolar = new PolarPoint(offsetAngle, radius);
var endOuterPolar = new PolarPoint(offsetAngle + angle, radius);
var startInnerPolar = new PolarPoint(offsetAngle, radius - arcWidth);
var endInnerPolar = new PolarPoint(offsetAngle + angle, radius - arcWidth);
var isLargeArc = angle > 180;
var startOuter = startOuterPolar.ToCartesian().LocalizeInPolarSpace(size);
var endOuter = endOuterPolar.ToCartesian().LocalizeInPolarSpace(size);
var startInner = startInnerPolar.ToCartesian().LocalizeInPolarSpace(size);
var endInner = endInnerPolar.ToCartesian().LocalizeInPolarSpace(size);
return(new PathGeometry
{
Figures = new PathFigureCollection
{
new PathFigure
{
StartPoint = startOuter,
Segments = new PathSegmentCollection
{
new ArcSegment
{
Size = new Size(radius, radius),
Point = endOuter,
IsLargeArc = isLargeArc
},
new LineSegment
{
Point = endInner
},
new ArcSegment
{
Size = new Size(radius - arcWidth, radius - arcWidth),
Point = startInner,
SweepDirection = SweepDirection.Clockwise,
IsLargeArc = isLargeArc
}
}
}
}
});
}
/// <summary>
/// Add a new triangle given vertex indices and adjacent half-edge ids.
/// </summary>
private int AddTriangle(PolarPoint i0, PolarPoint i1, PolarPoint i2, int a, int b, int c)
{
var t = trianglesPointIndex;
triangles[t] = i0;
triangles[t + 1] = i1;
triangles[t + 2] = i2;
Link(t, a);
Link(t + 1, b);
Link(t + 2, c);
trianglesPointIndex += 3;
return(t);
}
private PolarPoint cart2polar(int x, int y)
{
var polar = new PolarPoint();
polar.r = Math.Sqrt(Math.Pow((x - this.origin.X), 2) + Math.Pow((y - this.origin.Y), 2));
if (x != 0)
{
polar.theta = Math.Atan(y / x);
}
else
{
polar.theta = 0;
}
return(polar);
}
} // rechnet kartesische Koordinaten in Polarkoordinaten (r,phi) um
public Point PolarPointToPoint(PolarPoint pp, Point cp)
{
double r = pp.R, phi = pp.Phi;
int centerX = cp.X, centerY = cp.Y;
int x, y;
// umrechnen von polar zu point
if (phi >= 0 && phi <= 90)
{
x = centerX + Convert.ToInt32(Math.Cos(phi) * r); // x ist die Ankatete eines rechtwinkligen Dreieck und r ist dessen Hypotenuse
y = centerY + Convert.ToInt32(Math.Sin(phi) * r); // y ist die Gegenkatete eines rechtwinklingen Dreicke und r ist dessen Hypotenuse
}
else
{
if (phi <= 180)
{
x = centerX - Convert.ToInt32(Math.Cos(phi) * r);
y = centerY + Convert.ToInt32(Math.Sin(phi) * r);
}
else
{
if (phi <= 270)
{
x = centerX - Convert.ToInt32(Math.Cos(phi) * r);
y = centerY - Convert.ToInt32(Math.Sin(phi) * r);
}
else
{
if (phi <= 360)
{
x = centerX + Convert.ToInt32(Math.Cos(phi) * r);
y = centerY - Convert.ToInt32(Math.Sin(phi) * r);
}
else
{
// Winkel über 360° sind Fehler.
x = 0;
y = 0;
}
}
}
}
return(new Point(x, y));
} // rechnet Polarkoordinaten (r,phi) in kartesische Koordinaten (x,y) um
/// <summary>
/// Insert new node into double-linked list
/// </summary>
private PointNode InsertNode(PolarPoint p, PointNode prev = null)
{
var node = new PointNode(p);
if (prev == null)
{
node.Previous = node;
node.Next = node;
}
else
{
node.Next = prev.Next;
node.Previous = prev;
prev.Next.Previous = node;
prev.Next = node;
}
return(node);
}
public CustomPath CalculateActiveArcPath(Point center, double radius, double arcWidth, double angle)
{
var startOuterPolar = new PolarPoint(90, radius);
var endOuterPolar = new PolarPoint(90 + angle, radius);
var startInnerPolar = new PolarPoint(90, radius - arcWidth);
var endInnerPolar = new PolarPoint(90 + angle, radius - arcWidth);
var space = new Size(PART_main.RenderSize.Width, PART_main.RenderSize.Height * 2);
return(new CustomPath(null)
{
Data = new PathGeometry
{
Figures = new PathFigureCollection
{
new PathFigure
{
StartPoint = startOuterPolar.ToCartesian().LocalizeInPolarSpace(space),
Segments = new PathSegmentCollection
{
new ArcSegment
{
Size = new Size(radius, radius),
Point = endOuterPolar.ToCartesian().LocalizeInPolarSpace(space),
IsLargeArc = false
},
new LineSegment
{
Point = endInnerPolar.ToCartesian().LocalizeInPolarSpace(space)
},
new ArcSegment
{
Size = new Size(radius - arcWidth, radius - arcWidth),
Point = startInnerPolar.ToCartesian().LocalizeInPolarSpace(space),
SweepDirection = SweepDirection.Clockwise,
IsLargeArc = false
}
}
}
}
}
});
}
public void ToCartesian_FourCorners_UnitVectors()
{
//----------- Arrange -----------------------------
var right = new PolarPoint(1, 0);
var up = new PolarPoint(1, Math.PI / 2d);
var left = new PolarPoint(1, Math.PI);
var down = new PolarPoint(1, 3 * Math.PI / 2d);
//----------- Act ---------------------------------
var ihat = right.ToCartesian();
var jhat = up.ToCartesian();
var minusihat = left.ToCartesian();
var minusjhat = down.ToCartesian();
//----------- Assert-------------------------------
Assert.True(ihat.X.Is(1, 1e-12) && ihat.Y.Is(0, 1e-12));
Assert.True(jhat.X.Is(0, 1e-12) && jhat.Y.Is(1, 1e-12));
Assert.True(minusihat.X.Is(-1, 1e-12) && minusihat.Y.Is(0, 1e-12));
Assert.True(minusjhat.X.Is(0, 1e-12) && minusjhat.Y.Is(-1, 1e-12));
}
public void Day10Part2_TestSolution()
{
string[] map = DayDataUtilities.ReadLinesFromFile("day10.txt");
Assert.NotNull(map);
var sut = new MonitorStation(map);
var bestStation = new Point(26, 28);
var dictLos = sut.CalculateLOS(bestStation);
Assert.Equal(256, dictLos.Count);
var polarPts = sut.MakeMapPolar(bestStation);
// Start point is angle -1,5707963267948966, ie. -pi/2, wrap angle by adding 2 pi
foreach (var pt in polarPts)
{
if (pt.angle < -1.5707963267948966)
{
pt.angle += 2 * Math.PI;
}
}
Assert.Equal(sut.Asteroids.Count - 1, polarPts.Count);
SortedDictionary <double, List <PolarPoint> > dictPolar = sut.MakePolarLOS(polarPts);
sut.DumpPolarLOS(dictPolar);
Assert.Equal(267, dictPolar.Count);
int count = 1;
PolarPoint rock200 = null;
foreach (var angle in dictPolar.Keys)
{
if (count == 200)
{
rock200 = dictPolar[angle].Find(r => r.dist == dictPolar[angle].Min(p => p.dist));
break;
}
count++;
}
Assert.NotNull(rock200);
Assert.Equal(1309, rock200.cartPt.Y + rock200.cartPt.X * 100);
}
