private void RouteProvider_RoutingCompleted(object sender, RoutingCompletedEventArgs e)
{
this.findRouteButton.IsEnabled = true;
RouteResponse routeResponse = e.Response as RouteResponse;
if (routeResponse != null
&& routeResponse.Error == null)
{
if (routeResponse.Result != null
&& routeResponse.Result.RoutePath != null)
{
PolylineData routeLine = new PolylineData()
{
Points = routeResponse.Result.RoutePath.Points,
ShapeFill = new MapShapeFill()
{
Stroke = new SolidColorBrush(Colors.Red),
StrokeThickness = 2
}
};
this.routeLayer.Items.Add(routeLine);
}
}
}
public void DrawPolyline()
{
var request = new PolylineData();
request.PinX = 3;
request.PinY = 3;
request.Width = 1;
request.Height = 1;
request.Points = new List <PointF> {
new PointF(0, 0), new PointF(0, 1), new PointF(1, 1), new PointF(1, 0)
};
request.Text = "test draw polyline";
var shapeStyleData = new ShapeStyleData();
shapeStyleData.FillBackGroundColor = "#FF0000";
var textStyleData = new TextStyleData();
textStyleData.FontSize = 0.25;
textStyleData.FontName = "Times New Roman";
request.ShapeStyleData = shapeStyleData;
request.TextStyleData = textStyleData;
var response = diagramApi.PutDrawPolyline(fileName, pageName, request, StorageTestFOLDER);
Assert.IsTrue(response.IsSuccess);
}
private void RouteProvider_RoutingCompleted(object sender, RoutingCompletedEventArgs e)
{
this.findRouteButton.IsEnabled = true;
RouteResponse routeResponse = e.Response as RouteResponse;
if (routeResponse != null &&
routeResponse.Error == null)
{
if (routeResponse.Result != null &&
routeResponse.Result.RoutePath != null)
{
PolylineData routeLine = new PolylineData()
{
Points = routeResponse.Result.RoutePath.Points,
ShapeFill = new MapShapeFill()
{
Stroke = new SolidColorBrush(Colors.Red),
StrokeThickness = 2
}
};
this.routeLayer.Items.Add(routeLine);
}
}
}
public void TestPolyline_2()
{
var polyline = new PolylineData(obj2.ID, file);
polyline.Bind();
// XXXX
// XXXXXXXXXXX
// XXXXXXXXXXXXXXXXX
// 0 1 2 3 4
polyline.Add(0, 1);
polyline.Add(1, 1);
polyline.Add(2, 3);
polyline.Add(4, 2);
Assert.AreEqual(polyline.GetIntegratedValue(0), 0);
Assert.AreEqual(polyline.GetIntegratedValue(1), 1);
Assert.AreEqual(polyline.GetIntegratedValue(2) - polyline.GetIntegratedValue(1), 2);
Assert.AreEqual(polyline.GetIntegratedValue(4), 8);
float y;
Assert.IsTrue(polyline.GetInvertedIntegratedValue(1.75f, out y));
Assert.AreEqual(y, 1.5f);
polyline.Unbind();
}
public void TestPolyline_1()
{
var polyline = new PolylineData(obj1.ID, file);
polyline.Bind();
polyline.Add(0, 0);
polyline.Add(1, 2);
Assert.AreEqual(polyline.GetValue(1), 2f);
Assert.AreEqual(polyline.GetValue(0.5f), 1f);
Assert.AreEqual(polyline.GetValue(0), 0f);
polyline.Add(0.5f, 1.5f);
Assert.AreEqual(polyline.GetValue(1), 2f);
Assert.AreEqual(polyline.GetValue(0.75f), 1.75f);
Assert.AreEqual(polyline.GetValue(0.5f), 1.5f);
Assert.AreEqual(polyline.GetValue(0.25f), 0.75f);
Assert.AreEqual(polyline.GetValue(0), 0f);
polyline.Add(1.25f, 1);
Assert.AreEqual(polyline.GetValue(1.0625f), 1.75f);
polyline.Unbind();
}
private PolylineData CreateNewPolyline(Color color, double thickness)
{
PolylineData routeLine = new PolylineData()
{
ShapeFill = new MapShapeFill()
{
Stroke = new SolidColorBrush(color),
StrokeThickness = thickness,
StrokeDashArray = this.request.Options.Mode == BingRestTravelMode.Walking ? new DoubleCollection()
{
2, 1
} : new DoubleCollection(),
},
Points = new LocationCollection(),
};
return(routeLine);
}
private void Provider_CalculateRouteCompleted(object sender, BingRestRoutingCompletedEventArgs e)
{
this.findRouteButton.IsEnabled = true;
BingRest.Route route = e.Route;
if (route != null)
{
PolylineData routeLine = this.CreateNewPolyline(Colors.Blue, 3);
// Building the polyline representing the route.
foreach (double[] coordinatePair in route.RoutePath.Line.Coordinates)
{
Location point = new Location(coordinatePair[0], coordinatePair[1]);
routeLine.Points.Add(point);
}
this.routeLayer.Items.Add(routeLine);
// Bringing the route into view.
double[] bbox = e.Route.BoundingBox;
LocationRect rect = new LocationRect(new Location(bbox[2], bbox[1]), new Location(bbox[0], bbox[3]));
this.radMap.SetView(rect);
}
}
private bool UpdateSketchGeometry(PathGeometry inputPath)
{
var flag = false;
flag |= GeometryHelper.EnsureGeometryType(out var geometry, ref CachedGeometry,
() => new PathGeometry());
flag |= geometry.Figures.EnsureListCount(inputPath.Figures.Count, () => new PathFigure());
var random = new RandomEngine(_randomSeed);
for (var i = 0; i < inputPath.Figures.Count; i++)
{
var pathFigure = inputPath.Figures[i];
var isClosed = pathFigure.IsClosed;
var isFilled = pathFigure.IsFilled;
if (pathFigure.Segments.Count == 0)
{
flag |= geometry.Figures[i]
.SetIfDifferent(PathFigure.StartPointProperty, pathFigure.StartPoint);
flag |= geometry.Figures[i].Segments.EnsureListCount(0);
}
else
{
var list = new List <Point>(pathFigure.Segments.Count * 3);
foreach (var segment in GetEffectiveSegments(pathFigure))
{
var resultPolyline = new List <Point>
{
segment.Points[0]
};
segment.Flatten(resultPolyline, 0.0, null);
var polyline = new PolylineData(resultPolyline);
if (resultPolyline.Count > 1 && polyline.TotalLength > 4.0)
{
var a = polyline.TotalLength / 8.0;
var sampleCount = (int)Math.Max(2.0, Math.Ceiling(a));
var interval = polyline.TotalLength / sampleCount;
var scale = interval / 8.0;
var samplePoints = new List <Point>(sampleCount);
var sampleNormals = new List <Vector>(sampleCount);
var sampleIndex = 0;
PolylineHelper.PathMarch(polyline, 0.0, 0.0, delegate(MarchLocation location)
{
if (location.Reason == MarchStopReason.CompletePolyline)
{
return(double.NaN);
}
if (location.Reason != MarchStopReason.CompleteStep)
{
return(location.Remain);
}
if (sampleIndex++ == sampleCount)
{
return(double.NaN);
}
samplePoints.Add(location.GetPoint(polyline.Points));
sampleNormals.Add(location.GetNormal(polyline));
return(interval);
});
DisturbPoints(random, scale, samplePoints, sampleNormals);
list.AddRange(samplePoints);
}
else
{
list.AddRange(resultPolyline);
list.RemoveLast();
}
}
if (!isClosed)
{
list.Add(pathFigure.Segments.Last().GetLastPoint());
}
flag |= PathFigureHelper.SyncPolylineFigure(geometry.Figures[i], list, isClosed,
isFilled);
}
}
if (flag)
{
CachedGeometry = PathGeometryHelper.FixPathGeometryBoundary(CachedGeometry);
}
return(flag);
}
public Vector GetNormal(PolylineData polyline, double cornerRadius = 0.0)
{
return(polyline.SmoothNormal(Index, Ratio, cornerRadius));
}
private void Provider_RoutingCompleted(object sender, RoutingCompletedEventArgs e)
{
this.findRouteButton.IsEnabled = true;
RouteResponse routeResponse = e.Response as RouteResponse;
if (routeResponse != null && routeResponse.Error == null &&
routeResponse.Result != null && routeResponse.Result.RoutePath != null)
{
this.routeLine = new PolylineData()
{
Points = routeResponse.Result.RoutePath.Points,
ShapeFill = new MapShapeFill()
{
Stroke = this.GetBrushFromCombo(),
StrokeThickness = 2
}
};
this.routeLayer.Items.Add(this.routeLine);
}
else
{
this.ErrorSummary.Visibility = Visibility.Visible;
}
}
public PolylineVM(PolylineData p, string type, string value)
{
polyline = p;
this.type = type;
typeValue = value;
}
public static void PathMarch(PolylineData polyline, double startArcLength, double cornerThreshold,
Func <MarchLocation, double> stopCallback)
{
if (polyline == null)
{
throw new ArgumentNullException(nameof(polyline));
}
var count = polyline.Count;
if (count <= 1)
{
throw new ArgumentOutOfRangeException(nameof(polyline));
}
var flag = false;
var x = startArcLength;
var before = 0.0;
var index = 0;
var num5 = Math.Cos(cornerThreshold * 3.1415926535897931 / 180.0);
while (true)
{
var num6 = polyline.Lengths[index];
if (!MathHelper.IsFiniteDouble(x))
{
return;
}
if (MathHelper.IsVerySmall(x))
{
x = stopCallback(MarchLocation.Create(MarchStopReason.CompleteStep, index, before,
num6 - before, x));
flag = true;
}
else if (MathHelper.GreaterThan(x, 0.0))
{
if (MathHelper.LessThanOrClose(x + before, num6))
{
before += x;
x = stopCallback(MarchLocation.Create(MarchStopReason.CompleteStep, index, before,
num6 - before, 0.0));
flag = true;
}
else if (index < count - 2)
{
index++;
var num7 = num6 - before;
x -= num7;
before = 0.0;
// ReSharper disable once CompareOfFloatsByEqualityOperator
if (flag && num5 != 1.0 && polyline.Angles[index] > num5)
{
num6 = polyline.Lengths[index];
x = stopCallback(MarchLocation.Create(MarchStopReason.CornerPoint, index, before,
num6 - before, x));
}
}
else
{
var num8 = num6 - before;
x -= num8;
num6 = polyline.Lengths[index];
before = polyline.Lengths[index];
x = stopCallback(MarchLocation.Create(MarchStopReason.CompletePolyline, index, before,
num6 - before, x));
flag = true;
}
}
else if (MathHelper.LessThan(x, 0.0))
{
if (MathHelper.GreaterThanOrClose(x + before, 0.0))
{
before += x;
x = stopCallback(MarchLocation.Create(MarchStopReason.CompleteStep, index, before,
num6 - before, 0.0));
flag = true;
}
else if (index > 0)
{
index--;
x += before;
before = polyline.Lengths[index];
// ReSharper disable once CompareOfFloatsByEqualityOperator
if (flag && num5 != 1.0 && polyline.Angles[index + 1] > num5)
{
num6 = polyline.Lengths[index];
x = stopCallback(MarchLocation.Create(MarchStopReason.CornerPoint, index, before,
num6 - before, x));
}
}
else
{
x += before;
num6 = polyline.Lengths[index];
before = 0.0;
x = stopCallback(MarchLocation.Create(MarchStopReason.CompletePolyline, index, before,
num6 - before, x));
flag = true;
}
}
}
}
