public static List <PiePartGeometry> GetPieChart(ICanvasResourceCreator resourceCreator,
float[] valueList, ChartTextFormat textFormat, float radius, bool isShowData)
{
var centerPoint = new Vector2(radius, radius);
var geoList = new List <PiePartGeometry>();
var sum = valueList.Sum();
var startAngle = 0f;
var percentList = valueList.Select(o => o / sum);
foreach (var item in percentList)
{
var radian = item * 2 * Math.PI;
var builder = new CanvasPathBuilder(resourceCreator);
builder.BeginFigure(centerPoint);
builder.AddArc(centerPoint, radius, radius, startAngle, (float)radian);
builder.EndFigure(CanvasFigureLoop.Closed);
if (isShowData)
{
var partCenter = new Point(
(radius - textFormat.Thickness.Top) * Math.Cos(startAngle + radian / 2) + centerPoint.X,
(radius - textFormat.Thickness.Top) * Math.Sin(startAngle + radian / 2) + centerPoint.Y)
.ToVector2();
var textLayout = ChartDrawHelper.CreateCanvasText(resourceCreator,
$"{string.Format("{0:F1}", item * 100)}%", textFormat);
var textRect = textLayout.DrawBounds;
var textPos = new Point(partCenter.X - textRect.Width / 2, partCenter.Y - textRect.Height / 2);
var part = new PiePartGeometry
{
ShapeGeometry = CanvasGeometry.CreatePath(builder),
TextGeometry = CanvasGeometry.CreateText(textLayout),
DataRect = new Rect(textPos, new Size(textRect.Width, textRect.Height))
};
geoList.Add(part);
builder.Dispose();
textLayout.Dispose();
}
else
{
var part = new PiePartGeometry
{
ShapeGeometry = CanvasGeometry.CreatePath(builder)
};
geoList.Add(part);
builder.Dispose();
}
startAngle += (float)radian;
}
return(geoList);
}
public void EndLines()
{
if (_linesPath != null)
{
using (var g = CanvasGeometry.CreatePath(_linesPath)) {
_c.DrawGeometry(g, wcolor, _lineWidth);
}
_linesPath.Dispose();
_linesPath = null;
}
}
public void Reset()
{
Debug.Assert(_native != null);
var native = _native;
if (native != null)
{
native.Dispose();
_native = null;
}
_builder?.Dispose();
}
protected virtual void Dispose(Boolean disposing)
{
if (!disposed)
{
if (disposing == true && _cpb != null)
{
_cpb.Dispose();
_cpb = null;
}
disposed = true;
}
}
private void Dispose(bool disposing)
{
if (disposing)
{
if (pathBuilder != null)
{
pathBuilder.Dispose();
}
if (geometry != null)
{
geometry.Dispose();
}
}
}
public void DrawBezier(CanvasDrawingSession g2d, List <CalcPoint> pointslist, int xoffset, int yoffset, Color bordercolor, float linesize)
{
CanvasDevice device = CanvasDevice.GetSharedDevice();
CanvasGeometry geometry;
CanvasPathBuilder pathBuilder = new CanvasPathBuilder(device);
pathBuilder.BeginFigure(new Vector2(pointslist[0].X + xoffset, pointslist[0].Y + yoffset));
pathBuilder.AddCubicBezier(new Vector2(pointslist[1].X + xoffset, pointslist[1].Y + yoffset),
new Vector2(pointslist[2].X + xoffset, pointslist[2].Y + yoffset), new Vector2(pointslist[3].X + xoffset, pointslist[3].Y + yoffset));
pathBuilder.EndFigure(CanvasFigureLoop.Open);
geometry = CanvasGeometry.CreatePath(pathBuilder);
pathBuilder.Dispose();
g2d.DrawGeometry(geometry, bordercolor, linesize);
geometry.Dispose();
}
public static List <BarGroupGeometry> GetBarChart(ICanvasResourceCreator resourceCreator,
List <float[]> valuesList, float height, float barWidth, float barBorderWidth,
float barGap, float groupGap, ChartTextFormat dataLabelFormat)
{
var geoList = new List <BarGroupGeometry>();
var max = valuesList.Select(o => o.Max()).Max();
var barNum = valuesList.Count;
var totalGroupGap = (barWidth + barBorderWidth + barGap) * barNum + groupGap - barGap;
var offset = 0f;
foreach (var list in valuesList)
{
var builder = new CanvasPathBuilder(resourceCreator);
var heightList = list.Select(o => (float)(o / max * height)).ToArray();
var startPoint = new Vector2();
var markerPoints = new List <Vector2>();
var markerStrs = new List <string>();
for (int i = 0; i < heightList.Count(); i++)
{
builder.BeginFigure(startPoint);
builder.AddLine(new Vector2(startPoint.X, startPoint.Y - heightList[i]));
builder.AddLine(new Vector2(startPoint.X + barWidth, startPoint.Y - heightList[i]));
builder.AddLine(new Vector2(startPoint.X + barWidth, startPoint.Y));
builder.EndFigure(CanvasFigureLoop.Open);
var markerPoint = new Vector2(startPoint.X + barWidth / 2, startPoint.Y - heightList[i]);
markerPoints.Add(markerPoint);
markerStrs.Add($"{list[i]}");
startPoint = new Vector2(startPoint.X + totalGroupGap, startPoint.Y);
}
geoList.Add(new BarGroupGeometry
{
ShapeGeometry = CanvasGeometry.CreatePath(builder),
DataLabels = ChartDrawHelper.CreateValueMarker(resourceCreator, dataLabelFormat, markerPoints,
markerStrs,
MarkerPosition.Bottom),
Offset = offset
});
builder.Dispose();
offset += barGap + barWidth + barBorderWidth;
}
return(geoList);
}
public CanvasGeometry GetGeometry(CanvasDevice device)
{
var fill = FillType == PathFillType.Winding
? CanvasFilledRegionDetermination.Winding
: CanvasFilledRegionDetermination.Alternate;
CanvasGeometry finalGeometry = null;
var canvasPathBuilder = new CanvasPathBuilder(device);
canvasPathBuilder.SetFilledRegionDetermination(fill);
var closed = true;
for (var i = 0; i < Contours.Count; i++)
{
Contours[i].AddPathSegment(ref finalGeometry, canvasPathBuilder, device, ref closed);
if (finalGeometry != null)
{
canvasPathBuilder.Dispose();
canvasPathBuilder = new CanvasPathBuilder(device);
canvasPathBuilder.SetFilledRegionDetermination(fill);
}
}
if (!closed)
{
canvasPathBuilder.EndFigure(CanvasFigureLoop.Open);
}
if (finalGeometry == null)
{
finalGeometry = CanvasGeometry.CreatePath(canvasPathBuilder);
}
canvasPathBuilder.Dispose();
return(finalGeometry);
}
public static CanvasGeometry AsPath(this PathF path, float ox, float oy, float fx, float fy, ICanvasResourceCreator creator, CanvasFilledRegionDetermination fillMode = CanvasFilledRegionDetermination.Winding)
{
var builder = new CanvasPathBuilder(creator);
#if DEBUG
try
{
#endif
builder.SetFilledRegionDetermination(fillMode);
var pointIndex = 0;
var arcAngleIndex = 0;
var arcClockwiseIndex = 0;
var figureOpen = false;
var segmentIndex = -1;
var lastOperation = PathOperation.Move;
foreach (var type in path.SegmentTypes)
{
segmentIndex++;
if (type == PathOperation.Move)
{
if (lastOperation != PathOperation.Close && lastOperation != PathOperation.Move)
{
builder.EndFigure(CanvasFigureLoop.Open);
}
var point = path[pointIndex++];
var begin = CanvasFigureFill.Default;
builder.BeginFigure(ox + point.X * fx, oy + point.Y * fy, begin);
figureOpen = true;
}
else if (type == PathOperation.Line)
{
var point = path[pointIndex++];
builder.AddLine(ox + point.X * fx, oy + point.Y * fy);
}
else if (type == PathOperation.Quad)
{
var controlPoint = path[pointIndex++];
var endPoint = path[pointIndex++];
builder.AddQuadraticBezier(
new Vector2(ox + controlPoint.X * fx, oy + controlPoint.Y * fy),
new Vector2(ox + endPoint.X * fx, oy + endPoint.Y * fy));
}
else if (type == PathOperation.Cubic)
{
var controlPoint1 = path[pointIndex++];
var controlPoint2 = path[pointIndex++];
var endPoint = path[pointIndex++];
builder.AddCubicBezier(
new Vector2(ox + controlPoint1.X * fx, oy + controlPoint1.Y * fy),
new Vector2(ox + controlPoint2.X * fx, oy + controlPoint2.Y * fy),
new Vector2(ox + endPoint.X * fx, oy + endPoint.Y * fy));
}
else if (type == PathOperation.Arc)
{
var topLeft = path[pointIndex++];
var bottomRight = path[pointIndex++];
var startAngle = path.GetArcAngle(arcAngleIndex++);
var endAngle = path.GetArcAngle(arcAngleIndex++);
var clockwise = path.GetArcClockwise(arcClockwiseIndex++);
while (startAngle < 0)
{
startAngle += 360;
}
while (endAngle < 0)
{
endAngle += 360;
}
var rotation = Geometry.GetSweep(startAngle, endAngle, clockwise);
var absRotation = Math.Abs(rotation);
var rectX = ox + topLeft.X * fx;
var rectY = oy + topLeft.Y * fy;
var rectWidth = (ox + bottomRight.X * fx) - rectX;
var rectHeight = (oy + bottomRight.Y * fy) - rectY;
var startPoint = Geometry.EllipseAngleToPoint(rectX, rectY, rectWidth, rectHeight, -startAngle);
var endPoint = Geometry.EllipseAngleToPoint(rectX, rectY, rectWidth, rectHeight, -endAngle);
if (!figureOpen)
{
var begin = CanvasFigureFill.Default;
builder.BeginFigure(startPoint.X, startPoint.Y, begin);
figureOpen = true;
}
else
{
builder.AddLine(startPoint.X, startPoint.Y);
}
builder.AddArc(
new Vector2(endPoint.X, endPoint.Y),
rectWidth / 2,
rectHeight / 2,
0,
clockwise ? CanvasSweepDirection.Clockwise : CanvasSweepDirection.CounterClockwise,
absRotation >= 180 ? CanvasArcSize.Large : CanvasArcSize.Small
);
}
else if (type == PathOperation.Close)
{
builder.EndFigure(CanvasFigureLoop.Closed);
}
lastOperation = type;
}
if (segmentIndex >= 0 && lastOperation != PathOperation.Close)
{
builder.EndFigure(CanvasFigureLoop.Open);
}
var geometry = CanvasGeometry.CreatePath(builder);
return(geometry);
#if DEBUG
}
catch (Exception exc)
{
builder.Dispose();
var definition = path.ToDefinitionString();
Logger.Debug(string.Format("Unable to convert the path to a Win2D Path: {0}", definition), exc);
return(null);
}
#endif
}
public void Dispose()
{
mBuilder?.Dispose();
}
