public override void Draw(
IList<Point> points,
double thickness,
int miterLimit,
ILogicalToScreenMapper logicalToScreenMapper)
{
// First define the geometric shape
var streamGeometry = new StreamGeometry();
using (var gc = streamGeometry.Open())
{
gc.BeginFigure(points[0], _fillAndClose, _fillAndClose);
points.RemoveAt(0);
gc.PolyLineTo(points, true, true);
}
using (var dc = RenderOpen())
dc.DrawGeometry(
_fillAndClose ? Brushes.White : null,
new Pen(
Brushes.White,
thickness == 1 ? 0.25 : thickness)
{
MiterLimit = miterLimit
},
streamGeometry);
}
/// <summary>
/// Does a one off calculation of the geometry to be rendered
/// </summary>
private void CalculateGeometry() {
if(_recalcGeometry) {
Func<bool, int, StreamGeometry> buildGeometry = (bool isFilled, int pointIndex) => {
StreamGeometry childGeometry = new StreamGeometry();
using(StreamGeometryContext ctx = childGeometry.Open()) {
// Break up into groups of 4
ctx.BeginFigure(Points[pointIndex], isFilled, isFilled);
for(int j = 0; j < 4; ++j) {
ctx.LineTo(Points[pointIndex + j], !isFilled, true);
}
if(!isFilled) {
ctx.LineTo(Points[pointIndex], !isFilled, true);
}
}
return childGeometry;
};
_filledGeometry = _filledGeometry ?? new GeometryGroup();
_unfilledGeometry = _unfilledGeometry ?? new GeometryGroup();
_filledGeometry.Children.Clear();
_unfilledGeometry.Children.Clear();
if(Points.Count > 0) {
for(int pointIndex = 0, colorIndex = 0; pointIndex < (Points.Count - 3); pointIndex += 4, colorIndex += 1) {
_unfilledGeometry.Children.Add(buildGeometry(false, pointIndex));
_filledGeometry.Children.Add(buildGeometry(true, pointIndex));
}
}
_recalcGeometry = false;
}
}
//Redraw the streamgeometry
public void createGeometry() {
// Create a StreamGeometry to use to specify myPath.
geometry = new StreamGeometry();
// Open a StreamGeometryContext that can be used to describe this StreamGeometry
// object's contents.
using (StreamGeometryContext geo = geometry.Open())
{
double xmax = window.anchorOut; //views xmax
double xmin = window.anchorIn; //views xmin
int xres = (int)Math.Ceiling((xmax-xmin) / window.plot.Width);
geo.BeginFigure(new Point(0, 0), false, false);
for (int i = (int)xmin; i < xmax; i+=1) //always 600 steps
{
double value;
if (i < (values.Count() - 1))
{
value = values[i];
}
else { break; }
geo.LineTo(new Point(i, value), true, false);
i++;
}
}
geometry.Freeze(); //Freeze to free resources
line.Data = geometry;
}
public void Draw(TextView textView, DrawingContext drawingContext)
{
foreach (TextSegment current in this.SearchHitsSegments)
{
foreach (Rect current2 in BackgroundGeometryBuilder.GetRectsForSegment(textView, current))
{
Point bottomLeft = current2.BottomLeft;
Point bottomRight = current2.BottomRight;
Pen pen = new Pen(new SolidColorBrush(Colors.OrangeRed), 1);
pen.Freeze();
double num = 2.5;
int count = System.Math.Max((int)((bottomRight.X - bottomLeft.X) / num) + 1, 4);
StreamGeometry streamGeometry = new StreamGeometry();
using (StreamGeometryContext streamGeometryContext = streamGeometry.Open())
{
streamGeometryContext.BeginFigure(bottomLeft, true, true);
streamGeometryContext.LineTo(current2.TopLeft, true, false);
streamGeometryContext.LineTo(current2.TopRight, true, false);
streamGeometryContext.LineTo(current2.BottomRight, true, false);
}
streamGeometry.Freeze();
drawingContext.DrawGeometry(Brushes.Transparent, pen, streamGeometry);
}
}
}
/// <summary>
/// Create an Arc geometry drawing of an ellipse or circle
/// </summary>
/// <param name="rect">Box to hold the whole ellipse described by the arc</param>
/// <param name="startDegrees">Start angle of the arc degrees within the ellipse. 0 degrees is a line to the right.</param>
/// <param name="sweepDegrees">Sweep angle, -ve = Counterclockwise, +ve = Clockwise</param>
/// <returns>GeometryDrawing object</returns>
private static GeometryDrawing CreateArcDrawing(Rect rect, double startDegrees, double sweepDegrees)
{
// degrees to radians conversion
double startRadians = startDegrees * Math.PI / 180.0;
double sweepRadians = sweepDegrees * Math.PI / 180.0;
// x and y radius
double dx = rect.Width / 2;
double dy = rect.Height / 2;
// determine the start point
double xs = rect.X + dx + (Math.Cos(startRadians) * dx);
double ys = rect.Y + dy + (Math.Sin(startRadians) * dy);
// determine the end point
double xe = rect.X + dx + (Math.Cos(startRadians + sweepRadians) * dx);
double ye = rect.Y + dy + (Math.Sin(startRadians + sweepRadians) * dy);
// draw the arc into a stream geometry
StreamGeometry streamGeom = new StreamGeometry();
using (StreamGeometryContext ctx = streamGeom.Open())
{
bool isLargeArc = Math.Abs(sweepDegrees) > 180;
SweepDirection sweepDirection = sweepDegrees < 0 ? SweepDirection.Counterclockwise : SweepDirection.Clockwise;
ctx.BeginFigure(new Point(xs, ys), false, false);
ctx.ArcTo(new Point(xe, ye), new Size(dx, dy), 0, isLargeArc, sweepDirection, true, false);
}
// create the drawing
GeometryDrawing drawing = new GeometryDrawing();
drawing.Geometry = streamGeom;
return drawing;
}
public TextBoxUpDownAdorner(TextBox adornedTextBox)
: base(adornedTextBox)
{
this.triangle = new StreamGeometry();
this.triangle.FillRule = FillRule.Nonzero;
using (StreamGeometryContext geometryContext = this.triangle.Open())
{
geometryContext.BeginFigure(new Point(-6, 0), true /* filled */, true /* closed */);
geometryContext.LineTo(new Point(6, 0), true, false);
geometryContext.LineTo(new Point(0, 8), true, false);
}
this.triangle.Freeze();
this.MouseDown += (s, e) =>
{
if (this.Button_Clicked != null)
{
bool up = e.GetPosition(this.AdornedElement).Y < (top + bottom) / 2;
this.Button_Clicked((TextBox)this.AdornedElement, up ? 1 : -1);
}
};
adornedTextBox.LostFocus += this.FocusLostOrSelectionChanged;
adornedTextBox.SelectionChanged += this.FocusLostOrSelectionChanged;
}
private void CalculateShape()
{
//Vorberechnen für bessere Performance
float angle = Angle * (float)(Math.PI / 180);
float sinAngle = (float)Math.Sin(angle);
float cosAngle = (float)Math.Cos(angle);
//P_L
startPoint = new Point(Size - cosAngle * Size, Size + sinAngle * Size);
//P_O
circleIntersectionPoint = new Point(2 * Size, Size);
//P_R
circleEndPoint = new Point(Size * 3 + cosAngle * Size, Size + sinAngle * Size);
//P_U
Vector angledVector = new Vector(-sinAngle, cosAngle);
double lineLength = (2 * Size - (Size * 3 + cosAngle * Size)) / angledVector.X;
trianglePoint = Point.Add(circleEndPoint, Vector.Multiply(angledVector, lineLength));
//Form aus Punkten erstellen
heart = new StreamGeometry();
using (StreamGeometryContext ctx = heart.Open())
{
ctx.BeginFigure(startPoint, true, true);
ctx.ArcTo(circleIntersectionPoint, new Size(Size, Size), Math.PI + angle, true, SweepDirection.Clockwise, true, false);
ctx.ArcTo(circleEndPoint, new Size(Size, Size), Math.PI + angle, true, SweepDirection.Clockwise, true, false);
ctx.LineTo(trianglePoint, true, false);
}
heart.Freeze();
}
public PathOutlineVisual(IPathOutline outline)
{
var brush = new SolidColorBrush(outline.LineColor);
var pen = new Pen(brush, 1);
var geometry = new StreamGeometry();
using (var gc = geometry.Open())
{
gc.BeginFigure(outline.BottomLeft, false, false);
gc.LineTo(outline.TopLeft, true, true);
gc.ArcTo(outline.TopRight,
new Size(outline.Radius + (outline.Width / 2), outline.Radius + (outline.Width / 2)),
1,
false,
outline.Direction == PathType.Convex ? SweepDirection.Clockwise : SweepDirection.Counterclockwise,
true,
true);
gc.LineTo(outline.BottomRight, true, true);
gc.ArcTo(outline.BottomLeft,
new Size(outline.Radius - (outline.Width / 2), outline.Radius - (outline.Width / 2)),
1,
false,
outline.Direction == PathType.Convex ? SweepDirection.Counterclockwise : SweepDirection.Clockwise,
true,
true);
}
using (var context = RenderOpen())
{
context.DrawGeometry(brush, pen, geometry);
}
}
public PathOutlineVisualOld(IPathOld path, Color color)
{
var brush = new SolidColorBrush(color);
var pen = new Pen(brush, 1);
var geometry = new StreamGeometry();
using (var gc = geometry.Open())
{
gc.BeginFigure(path.StartBottomEdge, false, false);
gc.LineTo(path.StartTopEdge, true, true);
gc.ArcTo(path.EndTopEdge, new Size(path.Radius+(path.Width/2), path.Radius+(path.Width/2)), 1, false, SweepDirection.Clockwise, true, true);
gc.LineTo(path.EndBottomEdge, true, true);
gc.ArcTo(path.StartBottomEdge, new Size(path.Radius-(path.Width/2), path.Radius-(path.Width/2)), 1, false, SweepDirection.Counterclockwise, true, true);
}
using (var context = RenderOpen())
{
context.DrawGeometry(brush, pen, geometry);
var points = CalculateSteps(path);
foreach (var point in points)
{
DrawPoint(point, Brushes.Blue, context);
}
}
}
public void Draw( EdgeLayout layoutState )
{
var styleState = myPresentation.GetPropertySetFor<EdgeStyle>().Get( Owner.Id );
var stream = new StreamGeometry();
var context = stream.Open();
context.BeginFigure( layoutState.Points.First(), false, false );
context.PolyBezierTo( layoutState.Points.Skip( 1 ).ToList(), true, false );
// draw arrow head
var start = layoutState.Points.Last();
var v = start - layoutState.Points.ElementAt( layoutState.Points.Count() - 2 );
v.Normalize();
start = start - v * 0.15;
context.BeginFigure( start + v * 0.28, true, true );
double t = v.X; v.X = v.Y; v.Y = -t; // Rotate 90°
context.LineTo( start + v * 0.08, true, true );
context.LineTo( start + v * -0.08, true, true );
context.Close();
var pen = new Pen( styleState.Color, 0.016 );
// http://stackoverflow.com/questions/1755520/improve-drawingvisual-renders-speed
Visual = new DrawingVisual();
var dc = Visual.RenderOpen();
dc.DrawGeometry( pen.Brush, pen, stream );
dc.Close();
Visual.SetValue( GraphItemProperty, Owner );
}
internal void MakeGeometry()
{
if (Edge.Points.Count > 0)
{
var points = Edge.Points;
StreamGeometry g = new StreamGeometry();
StreamGeometryContext c = g.Open();
c.BeginFigure(points[0], false, false);
var r = Edge.Points.Where(p => p != Edge.Points[0]);
c.PolyBezierTo(r.ToList(), true, false);
if (Edge.EndPoint.HasValue)
{
Point from = Edge.Points.Last();
Point to = Edge.EndPoint.Value;
DrawArrow(c, from, to, 4);
}
if (Edge.StartPoint.HasValue)
{
Point from = Edge.Points.First();
Point to = Edge.StartPoint.Value;
DrawArrow(c, from, to, 4);
}
c.Close();
g.Freeze();
EdgeGeometry = g;
}
}
public AreaSeries2D()
{
// 初始化保存数据点的变量
_points = new SeriesPointCollection();
_points.CollectionChanged += _points_CollectionChanged;
// 初始化绘制曲线的画板
gStream_Line = new StreamGeometry();
gStream_Area = new StreamGeometry();
gDrawing_Line = new GeometryDrawing();
gDrawing_Line.Brush = null;
gDrawing_Line.Pen = new Pen()
{
Thickness = 1,
Brush = Brushes.Black
};
gDrawing_Line.Geometry = gStream_Line;
/* 初始化绘制填充色的画板 */
gDrawing_Area = new GeometryDrawing();
gDrawing_Area.Brush = Brushes.Red;
gDrawing_Area.Pen = new Pen()
{
Thickness = 0,
Brush = null
};
gDrawing_Area.Geometry = gStream_Area;
/* 生成绘画组 */
drawingGroup = new DrawingGroup();
drawingGroup.Children.Add(gDrawing_Line);
drawingGroup.Children.Add(gDrawing_Area);
}
public void Draw(DrawingContext context, DrawingArgs args)
{
context.PushClip(new RectangleGeometry(args.RenderBounds));
if (m_IsDirty || args.RequiresFullRedraw)
{
m_LonePoints.Clear();
System.Windows.Media.StreamGeometry geo = new StreamGeometry();
using (var c = geo.Open())
{
Point? figureStart = null;
int pointCount = 0; //point in the figure
if (Values.Count() == 1 && Values.First().HasValue)
{
m_LonePoints.Add(Values.First().Value);
}
else
{
foreach (var p in Values)
{
if (p.HasValue)
{
if (!figureStart.HasValue)
{
figureStart = p.Value;
c.BeginFigure(figureStart.Value, false, false);
pointCount = 1;
}
else
{
c.LineTo(p.Value, true, true);
pointCount++;
}
}
else
{
//detect lone points and draw a cross
if (pointCount == 1)
{
m_LonePoints.Add(figureStart.Value);
}
figureStart = null;
}
}
}
}
m_Geo = geo;
m_IsDirty = false;
}
m_Geo.Transform = args.Transform;
context.DrawGeometry(null, Pen, m_Geo);
var radius = Pen.Thickness;
foreach (var p in m_LonePoints)
{
context.DrawEllipse(m_Pen.Brush, null, args.Transform.Transform(p), radius, radius);
}
}
public static Pen CreateErrorPen(Color color)
{
var geometry = new StreamGeometry();
using (var context = geometry.Open())
{
context.BeginFigure(new Point(-1, 0), false, false);
context.PolyLineTo(new[] {
new Point(-0.5, 0.4),
new Point(0, 0),
new Point(0.5, -0.4),
new Point(1, 0),
}, true, true);
}
var brushPattern = new GeometryDrawing
{
Pen = new Pen(new SolidColorBrush(color), 0.4),
Geometry = geometry
};
var brush = new DrawingBrush(brushPattern)
{
TileMode = TileMode.Tile,
Viewport = new Rect(-1, -1, 2, 2),
ViewportUnits = BrushMappingMode.Absolute,
Viewbox = new Rect(-1, -1, 2, 2),
ViewboxUnits = BrushMappingMode.Absolute,
};
var pen = new Pen(brush, 3.0);
pen.Freeze();
return pen;
}
public void Render(DrawingContext context, IElement element)
{
var pathElement = element as CurvedPathElement;
if (pathElement != null)
{
var pen = new Pen(new SolidColorBrush(pathElement.LineColor), pathElement.LineWidth);
var brush = new SolidColorBrush(pathElement.FillColor);
var topCurveRadius = pathElement.Radius +(pathElement.PathWidth/2);
var bottomCurveRadius = pathElement.Radius -(pathElement.PathWidth/2);
var geometry = new StreamGeometry();
using (var gc = geometry.Open())
{
gc.BeginFigure(pathElement.BottomLeft, false, true);
gc.LineTo(pathElement.TopLeft, true, true);
gc.ArcTo(pathElement.TopRight,
new Size(topCurveRadius, topCurveRadius),
1, false, SweepDirection.Clockwise, true, true);
gc.LineTo(pathElement.BottomRight, true, true);
gc.ArcTo(pathElement.BottomLeft,
new Size(bottomCurveRadius, bottomCurveRadius),
1, false, SweepDirection.Counterclockwise, true, true);
}
context.DrawGeometry(brush, pen, geometry);
//var topPen = new Pen(Brushes.Red, 1);
//var bottomPen = new Pen(Brushes.Blue, 1);
//context.DrawEllipse(brush, topPen, pathElement.Origin, topCurveRadius, topCurveRadius);
//context.DrawEllipse(brush, bottomPen, pathElement.Origin, bottomCurveRadius, bottomCurveRadius);
//context.DrawEllipse(brush, pen, pathElement.Origin, pathElement.Radius, pathElement.Radius);
}
}
public static StreamGeometry StreamGeometryFromCurve(Curve curve, MatrixTransform graphToCanvas)
{
double[] tempX;
double[] tempY;
if (graphToCanvas != null)
{
tempX = curve.xTransformed.MultiplyBy(graphToCanvas.Matrix.M11).SumWith(graphToCanvas.Matrix.OffsetX);
tempY = curve.yTransformed.MultiplyBy(graphToCanvas.Matrix.M22).SumWith(graphToCanvas.Matrix.OffsetY);
}
else
{
tempX = curve.xTransformed; tempY = curve.yTransformed;
}
StreamGeometry streamGeometry = new StreamGeometry();
StreamGeometryContext context = streamGeometry.Open();
int lines = 0;
for (int i = 0; i < curve.x.Count(); ++i)
{
if (i == 0)
{
context.BeginFigure(new Point(tempX[i], tempY[i]), false, false);
}
else
{
if (curve.includeLinePoint[i])
{
context.LineTo(new Point(tempX[i], tempY[i]), true, false);
lines++;
}
}
}
context.Close();
return streamGeometry;
}
private void AddArrow(Panel rootCanvas, Point arrowPoint)
{
var size = 10.0;
var relationshipPath = new Path
{
Stroke = Brushes.Black,
StrokeThickness = 2,
Visibility = Visibility.Visible,
Fill = Brushes.Black
};
var geometry = new StreamGeometry
{
FillRule = FillRule.EvenOdd
};
using (var ctx = geometry.Open())
{
ctx.BeginFigure(new Point(arrowPoint.X, arrowPoint.Y), true, true);
ctx.LineTo(new Point(arrowPoint.X - size / 2, arrowPoint.Y - size), true, true);
ctx.LineTo(new Point(arrowPoint.X + size / 2, arrowPoint.Y - size), true, true);
}
geometry.Freeze();
relationshipPath.Data = geometry;
rootCanvas.Children.Add(relationshipPath);
}
public static Geometry ToWpfGeometry(this SqlGeometry sqlGeometry, double pointSize)
{
StreamGeometry streamGeometry = new StreamGeometry();
using (StreamGeometryContext streamGeometryContext = streamGeometry.Open())
{
if (sqlGeometry != null && !sqlGeometry.IsNull)
{
for (int geometryIndex = 0; geometryIndex < (int)sqlGeometry.STNumGeometries(); geometryIndex++)
{
SqlGeometry subGeometry = sqlGeometry.STGeometryN(geometryIndex + 1);
if (subGeometry.STGeometryType() == "Polygon" || subGeometry.STGeometryType() == "MultiPolygon")
{
Point[] points = GetPointsFromSqlGeometry(subGeometry.STExteriorRing());
AddSegmentToGeometry(streamGeometryContext, points, true);
for (int interiorRingIndex = 0; interiorRingIndex < subGeometry.STNumInteriorRing(); interiorRingIndex++)
{
points = GetPointsFromSqlGeometry(subGeometry.STInteriorRingN(interiorRingIndex + 1));
AddSegmentToGeometry(streamGeometryContext, points, true);
}
}
else if (subGeometry.STGeometryType() == "MultiPoint" || subGeometry.STGeometryType() == "Point")
{
Point[] points = GetPointsFromSqlGeometry(subGeometry);
AddCircleToGeometry(streamGeometryContext, points, pointSize);
}
else if (subGeometry.STGeometryType() == "LineString" || subGeometry.STGeometryType() == "MultiLineString")
{
Point[] points = GetPointsFromSqlGeometry(subGeometry);
AddSegmentToGeometry(streamGeometryContext, points, false);
}
}
}
}
return streamGeometry;
}
private Geometry GetArcGeoMetry()
{
Point startPoint = PointAtAngle(Math.Min(StartAngle, EndAngle));
Point endPoint = PointAtAngle(Math.Max(StartAngle, EndAngle));
Size arcSize = new Size(Math.Max(0, (RenderSize.Width - StrokeThickness) / 2),
Math.Max(0, (RenderSize.Height - StrokeThickness) / 2));
bool isLargeArc = Math.Abs(EndAngle - StartAngle) > 180;
var sw = SweepDirection.Clockwise;
if (EndAngle - StartAngle < 0)
{
sw = SweepDirection.Counterclockwise;
isLargeArc = false;
}
StreamGeometry geom = new StreamGeometry();
if (EndAngle - StartAngle >= 360)
{
using (StreamGeometryContext context = geom.Open())
{
context.BeginFigure(PointAtAngle(0), false, true);
context.ArcTo(PointAtAngle(359.99), arcSize, 0, isLargeArc, sw, true, false);
}
}
else
{
using (StreamGeometryContext context = geom.Open())
{
context.BeginFigure(startPoint, false, false);
context.ArcTo(endPoint, arcSize, 0, isLargeArc, sw, true, false);
}
}
geom.Transform = new TranslateTransform(StrokeThickness / 2, StrokeThickness / 2);
return geom;
}
//public double GetTheta(double x, double y)
//{
// return
//}
public StreamGeometry DrawArrowGeometry(StreamGeometry geometry, double centreX, double centreY, double circleWidth, double circleHeight, double innerWidth,
double startAngle, double stopAngle)
{
//This code is based on http://marktinderholt.wordpress.com/2009/01/30/donut-shape-in-wpf/
var context = geometry.Open();
// Setup the Center Point & Radius
Point c = new Point(centreX, centreY);
double rOutterX = circleWidth/ 2;
double rOutterY = circleHeight / 2;
double rInnerX = rOutterX - innerWidth;
double rInnerY = rOutterY - innerWidth;
double theta = 0;
bool hasBegun = false;
double x;
double y;
Point currentPoint;
// Draw the Outside Edge
for (theta = startAngle; theta <= stopAngle; theta++)
{
x = c.X + rOutterX * Math.Cos(GetRadian(theta));
y = c.Y + rOutterY * Math.Sin(GetRadian(theta));
currentPoint = new Point(x, y);
if (!hasBegun)
{
context.BeginFigure(currentPoint, true, true);
hasBegun = true;
}
context.LineTo(currentPoint, true, true);
}
// Connect the Outside Edge to the Inner Edge
x = c.X + rInnerX * Math.Cos(GetRadian(stopAngle));
y = c.Y + rInnerY * Math.Sin(GetRadian(stopAngle));
currentPoint = new Point(x, y);
context.LineTo(currentPoint, true, true);
// Draw the Inner Edge
for (theta = stopAngle; theta >= startAngle; theta--)
{
x = c.X + rInnerX * Math.Cos(GetRadian(theta));
y = c.Y + rInnerY * Math.Sin(GetRadian(theta));
currentPoint = new Point(x, y);
context.LineTo(currentPoint, true, true);
}
// Connect the Inner Edge to the Outside Edge
x = c.X + rOutterX * Math.Cos(GetRadian(startAngle));
y = c.Y + rOutterY * Math.Sin(GetRadian(startAngle));
currentPoint = new Point(x, y);
context.LineTo(currentPoint, true, true);
context.Close();
return geometry;
}
public GridLines(Axis2D axis)
{
this.axis = axis;
gridLinesGeometry = new StreamGeometry();
this.Stroke = Brushes.LightGray;
this.StrokeThickness = 1;
this.StrokeLineJoin = PenLineJoin.Miter;
}
public GridLineController(DesignerCanvas canvas)
{
IsVisible = true;
_canvas = canvas;
_geometry = new StreamGeometry();
GridLines = new ObservableCollection<GridLine>();
GridLines.CollectionChanged += (s, e) => Invalidate();
Invalidate();
}
private void Draw(DrawingContext dc)
{
StreamGeometry sg = new StreamGeometry();
StreamGeometryContext sgc = sg.Open();
sgc.BeginFigure(points[0], false, false);
sgc.PolyLineTo(points, true, true);
sgc.Close();
dc.DrawGeometry(null, pen, sg);
}
protected override Geometry GetOrCreateBoxGeometry(Size renderSize)
{
var rect = new Rect(new Point(0, 0), renderSize);
this.SetCurrentValue(RectProperty, rect);
if (rect.Width <= 0 || rect.Height <= 0)
{
return Geometry.Empty;
}
if (this.CornerRadius.IsAllEqual())
{
// using TopLeft here as we have already checked that they are equal
if (this.BoxGeometry is RectangleGeometry)
{
return this.BoxGeometry;
}
var geometry = new RectangleGeometry();
geometry.Bind(RectangleGeometry.RectProperty)
.OneWayTo(this, RectProperty);
geometry.Bind(RectangleGeometry.RadiusXProperty)
.OneWayTo(this, CornerRadiusProperty, CornerRadiusTopLeftConverter.Default);
geometry.Bind(RectangleGeometry.RadiusYProperty)
.OneWayTo(this, CornerRadiusProperty, CornerRadiusTopLeftConverter.Default);
return geometry;
}
else
{
var geometry = new StreamGeometry();
using (var context = geometry.Open())
{
var cr = this.AdjustedCornerRadius();
var p = cr.TopLeft > 0
? new Point(cr.TopLeft + this.StrokeThickness / 2, this.StrokeThickness / 2)
: new Point(this.StrokeThickness / 2, this.StrokeThickness / 2);
context.BeginFigure(p, true, true);
p = p.WithOffset(rect.Width - cr.TopLeft - cr.TopRight, 0);
context.LineTo(p, true, true);
p = context.DrawCorner(p, cr.TopRight, cr.TopRight);
p = p.WithOffset(0, rect.Height - cr.TopRight - cr.BottomRight);
context.LineTo(p, true, true);
p = context.DrawCorner(p, -cr.BottomRight, cr.BottomRight);
p = p.WithOffset(-rect.Width + cr.BottomRight + cr.BottomLeft, 0);
context.LineTo(p, true, true);
p = context.DrawCorner(p, -cr.BottomLeft, -cr.BottomLeft);
p = p.WithOffset(0, -rect.Height + cr.TopLeft + cr.BottomLeft);
context.LineTo(p, true, true);
context.DrawCorner(p, cr.TopLeft, -cr.TopLeft);
}
geometry.Freeze();
return geometry;
}
}
internal static Geometry DefiningTargetArrowHead(EdgeGeometry edgeGeometry, double thickness) {
if (edgeGeometry.TargetArrowhead == null || edgeGeometry.Curve==null)
return null;
var streamGeometry = new StreamGeometry();
using (StreamGeometryContext context = streamGeometry.Open()) {
AddArrow(context, edgeGeometry.Curve.End,
edgeGeometry.TargetArrowhead.TipPosition, thickness);
return streamGeometry;
}
}
protected override void OnRender(DrawingContext drawingContext)
{
if (Plotter2D == null) return;
if (DataSource == null) return;
if (Collection == null) return;
if (Collection.Lines.Count == 0)
{
IsolineBuilder.DataSource = DataSource;
}
var dc = drawingContext;
var dataSource = DataSource;
var localMinMax = dataSource.GetMinMax();
var globalMinMax = dataSource.Range.Value;
double lengthsRatio = globalMinMax.GetLength() / localMinMax.GetLength();
if (lengthsRatio > 16)
{
double log = Math.Round(Math.Log(lengthsRatio, 2));
double number = 2 * Math.Pow(2, log);
double delta = globalMinMax.GetLength() / number;
double start = Math.Floor((localMinMax.Min - globalMinMax.Min) / delta) * delta + globalMinMax.Min;
double end = localMinMax.Max;
var transform = Plotter2D.Transform;
var strokeThickness = StrokeThickness;
double x = start;
while (x < end)
{
var collection = IsolineBuilder.BuildIsoline(x);
foreach (LevelLine line in collection)
{
StreamGeometry lineGeometry = new StreamGeometry();
using (var context = lineGeometry.Open())
{
context.BeginFigure(line.StartPoint.ViewportToScreen(transform), false, false);
context.PolyLineTo(line.OtherPoints.ViewportToScreen(transform).ToArray(), true, true);
}
lineGeometry.Freeze();
var paletteRatio = (line.RealValue - globalMinMax.Min) / globalMinMax.GetLength();
Pen pen = new Pen(new SolidColorBrush(Palette.GetColor(paletteRatio)), strokeThickness);
dc.DrawGeometry(null, pen, lineGeometry);
}
x += delta;
}
}
//dc.DrawRectangle(Brushes.Green.MakeTransparent(0.3), null, new Rect(RenderSize));
}
public void FindLines(StreamGeometry geometry, bool stroke, bool fill, Matrix trans)
{
Debug.Assert(stroke || fill, "should not be a nop");
_transform = trans;
_fill = fill;
_stroke = stroke;
PathGeometry.ParsePathGeometryData(geometry.GetPathGeometryData(), this);
CheckCloseFigure();
}
internal static object DeserializeStreamGeometry( BinaryReader reader )
{
StreamGeometry geometry = new StreamGeometry();
using (StreamGeometryContext context = geometry.Open())
{
ParserStreamGeometryContext.Deserialize( reader, context, geometry );
}
geometry.Freeze();
return geometry;
}
/// <summary/>
protected override void OnRender(DrawingContext dc) {
base.OnRender(dc);
var hasFill = (Fill != null);
var hasStroke = (Stroke != null && StrokeThickness > 0);
if (!hasFill && !hasStroke) return;
double cx, cy, r0, r1;
if (!ComputeBoundingCircles(out cx, out cy, out r0, out r1)) return;
var a0 = StartAngle;
var a1 = EndAngle;
Gauge.NormalizeAngularRange(ref a0, ref a1);
if (a0.AlmostEquals(a1)) return;
var isLargeArc = (a1 - a0).CertainlyGreater(180);
var isCircular = (a1 - a0).AlmostEquals(360);
a0 = (a0 - 90).ToRadians();
a1 = (a1 - 90).ToRadians();
var geometry = new StreamGeometry();
if (isCircular) {
using (var gc = geometry.Open()) {
var p0 = new Point(cx, cy - r1); // first point on the outer circle
var p1 = new Point(cx, cy + r1); // second point on the outer circle
var p2 = new Point(cx, cy - r0); // first point on the inner circle
var p3 = new Point(cx, cy + r0); // second point on the inner circle
gc.BeginFigure(p0, hasFill, true);
gc.ArcTo(p1, new Size(r1, r1), 0, true, SweepDirection.Clockwise, hasStroke, false);
gc.ArcTo(p0, new Size(r1, r1), 0, true, SweepDirection.Clockwise, hasStroke, false);
if (r0.IsPositive()) {
gc.BeginFigure(p2, hasFill, true);
gc.ArcTo(p3, new Size(r0, r0), 0, true, SweepDirection.Clockwise, hasStroke, false);
gc.ArcTo(p2, new Size(r0, r0), 0, true, SweepDirection.Clockwise, hasStroke, false);
geometry.FillRule = FillRule.EvenOdd; // this will subtract the inner circle from the outer circle, forming a ring
}
}
} else {
using (var gc = geometry.Open()) {
var p0 = new Point(cx + r0 * Math.Cos(a0), cy + r0 * Math.Sin(a0)); // start point of the inner arc
var p1 = new Point(cx + r1 * Math.Cos(a0), cy + r1 * Math.Sin(a0)); // start point of the outer arc
var p2 = new Point(cx + r1 * Math.Cos(a1), cy + r1 * Math.Sin(a1)); // end point of the outer arc
var p3 = new Point(cx + r0 * Math.Cos(a1), cy + r0 * Math.Sin(a1)); // end point of the inner arc
gc.BeginFigure(p0, hasFill, true);
gc.LineTo(p1, hasStroke, false);
gc.ArcTo(p2, new Size(r1, r1), 0, isLargeArc, SweepDirection.Clockwise, hasStroke, false);
gc.LineTo(p3, hasStroke, false);
gc.ArcTo(p0, new Size(r0, r0), 0, isLargeArc, SweepDirection.Counterclockwise, hasStroke, false);
}
}
geometry.Freeze();
dc.DrawGeometry(Fill, GetStrokePen(), geometry);
}
protected Geometry DrawLine(List<Point> listp)
{
StreamGeometry geometry = new StreamGeometry();
geometry.FillRule = FillRule.EvenOdd;
using (StreamGeometryContext context = geometry.Open())
{
InternalDrawGeometrys(context, listp);
}
return geometry;
}
public static swm.Geometry CreateArcDrawing(sw.Rect rect, double startDegrees, double sweepDegrees, bool closed)
{
// degrees to radians conversion
double startRadians = startDegrees * Math.PI / 180.0;
double sweepRadians = sweepDegrees * Math.PI / 180.0;
// x and y radius
double dx = rect.Width / 2;
double dy = rect.Height / 2;
// determine the start point
double xs = rect.X + dx + (Math.Cos(startRadians) * dx);
double ys = rect.Y + dy + (Math.Sin(startRadians) * dy);
// determine the end point
double xe = rect.X + dx + (Math.Cos(startRadians + sweepRadians) * dx);
double ye = rect.Y + dy + (Math.Sin(startRadians + sweepRadians) * dy);
var centerPoint = new sw.Point(rect.X + rect.Width / 2, rect.Y + rect.Height / 2);
// draw the arc into a stream geometry
var streamGeom = new swm.StreamGeometry();
using (var ctx = streamGeom.Open())
{
bool isLargeArc = Math.Abs(sweepDegrees) > 180;
var sweepDirection = sweepDegrees < 0 ? swm.SweepDirection.Counterclockwise : swm.SweepDirection.Clockwise;
if (closed)
{
ctx.BeginFigure(centerPoint, true, true);
ctx.LineTo(new sw.Point(xs, ys), true, true);
}
else
{
ctx.BeginFigure(new sw.Point(xs, ys), true, false);
}
ctx.ArcTo(new sw.Point(xe, ye), new sw.Size(dx, dy), 0, isLargeArc, sweepDirection, true, false);
if (closed)
{
ctx.LineTo(centerPoint, true, true);
}
}
return(streamGeom);
}
///<summary>
/// Creates a new polygon shape.
///</summary>
/// <param name="shellVertices">The vertices of the shell</param>
/// <param name="holeVerticesCollection">A collection of Coordinate[] for each hole</param>
public PolygonWpfStreamGeometry(Coordinate[] shellVertices,
IEnumerable <Coordinate[]> holeVerticesCollection)
{
var path = new WpfStreamGeometry();
using (var sgc = path.Open())
{
AddRing(sgc, shellVertices, true);
if (holeVerticesCollection != null)
{
foreach (var hole in holeVerticesCollection)
{
AddRing(sgc, hole, false);
}
}
}
Path = path;
}
/// <summary>
///
/// </summary>
/// <param name="sg"></param>
/// <returns></returns>
public string ToSource(WM.StreamGeometry sg)
{
return(sg.ToString(CultureInfo.InvariantCulture));
}
/// <summary>
///
/// </summary>
/// <param name="xpg"></param>
/// <param name="dx"></param>
/// <param name="dy"></param>
/// <returns></returns>
public WM.StreamGeometry ToStreamGeometry(IPathGeometry xpg, double dx, double dy)
{
var sg = new WM.StreamGeometry();
using (var sgc = sg.Open())
{
foreach (var xpf in xpg.Figures)
{
sgc.BeginFigure(
new W.Point(xpf.StartPoint.X, xpf.StartPoint.Y),
xpf.IsFilled,
xpf.IsClosed);
foreach (var segment in xpf.Segments)
{
if (segment is IArcSegment arcSegment)
{
sgc.ArcTo(
new W.Point(arcSegment.Point.X + dx, arcSegment.Point.Y + dy),
new W.Size(arcSegment.Size.Width, arcSegment.Size.Height),
arcSegment.RotationAngle,
arcSegment.IsLargeArc,
arcSegment.SweepDirection == SweepDirection.Clockwise ? WM.SweepDirection.Clockwise : WM.SweepDirection.Counterclockwise,
arcSegment.IsStroked,
arcSegment.IsSmoothJoin);
}
else if (segment is ICubicBezierSegment cubicBezierSegment)
{
sgc.BezierTo(
new W.Point(cubicBezierSegment.Point1.X + dx, cubicBezierSegment.Point1.Y + dy),
new W.Point(cubicBezierSegment.Point2.X + dx, cubicBezierSegment.Point2.Y + dy),
new W.Point(cubicBezierSegment.Point3.X + dx, cubicBezierSegment.Point3.Y + dy),
cubicBezierSegment.IsStroked,
cubicBezierSegment.IsSmoothJoin);
}
else if (segment is ILineSegment lineSegment)
{
sgc.LineTo(
new W.Point(lineSegment.Point.X + dx, lineSegment.Point.Y + dy),
lineSegment.IsStroked,
lineSegment.IsSmoothJoin);
}
else if (segment is IPolyCubicBezierSegment polyCubicBezierSegment)
{
sgc.PolyBezierTo(
ToPoints(polyCubicBezierSegment.Points, dx, dy),
polyCubicBezierSegment.IsStroked,
polyCubicBezierSegment.IsSmoothJoin);
}
else if (segment is IPolyLineSegment polyLineSegment)
{
sgc.PolyLineTo(
ToPoints(polyLineSegment.Points, dx, dy),
polyLineSegment.IsStroked,
polyLineSegment.IsSmoothJoin);
}
else if (segment is IPolyQuadraticBezierSegment polyQuadraticSegment)
{
sgc.PolyQuadraticBezierTo(
ToPoints(polyQuadraticSegment.Points, dx, dy),
polyQuadraticSegment.IsStroked,
polyQuadraticSegment.IsSmoothJoin);
}
else if (segment is IQuadraticBezierSegment quadraticBezierSegment)
{
sgc.QuadraticBezierTo(
new W.Point(quadraticBezierSegment.Point1.X + dx, quadraticBezierSegment.Point1.Y + dy),
new W.Point(quadraticBezierSegment.Point2.X + dx, quadraticBezierSegment.Point2.Y + dy),
quadraticBezierSegment.IsStroked,
quadraticBezierSegment.IsSmoothJoin);
}
else
{
throw new NotSupportedException("Not supported segment type: " + segment.GetType());
}
}
}
}
sg.FillRule = xpg.FillRule == FillRule.Nonzero ? WM.FillRule.Nonzero : WM.FillRule.EvenOdd;
sg.Freeze();
return(sg);
}
/// <summary>
/// Creates a geometry stream context which is associated with a given owner
/// </summary>
internal StreamGeometryCallbackContext(StreamGeometry owner)
{
_owner = owner;
}
public void Return(System.Windows.Media.StreamGeometry geometry)
{
_Pool.Enqueue(geometry);
}