public static m.PathGeometry InvertHorizontally(m.PathGeometry toInvert, double maxHeight)
{
toInvert = toInvert.GetFlattenedPathGeometry(1, m.ToleranceType.Absolute);
m.PathGeometry toReturn = new m.PathGeometry();
foreach (m.PathFigure oldPf in toInvert.Figures)
{
m.PathFigure newPf = new m.PathFigure();
Point newStartPoint = oldPf.StartPoint;
newStartPoint.Y = maxHeight - newStartPoint.Y;
newStartPoint.X = newStartPoint.X;
newPf.StartPoint = newStartPoint;
foreach (m.PathSegment oldPs in oldPf.Segments)
{
m.PathSegment newPs = new m.PolyLineSegment();
foreach (Point point in ((m.PolyLineSegment)oldPs).Points)
{
Point tmp = point;
tmp.Y = maxHeight - tmp.Y;
((m.PolyLineSegment)newPs).Points.Add(tmp);
}
newPf.Segments.Add(newPs);
}
toReturn.Figures.Add(newPf);
}
return(toReturn);
}
public static m.PathGeometry ScalingPathGeometryOld(m.PathGeometry toDownsize, double scaling)
{
toDownsize = toDownsize.GetFlattenedPathGeometry(1, m.ToleranceType.Absolute);
m.PathGeometry toReturn = new m.PathGeometry();
foreach (m.PathFigure olfPf in toDownsize.Figures)
{
m.PathFigure newPf = new m.PathFigure();
Point newStartPoint = olfPf.StartPoint;
newStartPoint.X *= scaling;
newStartPoint.Y *= scaling;
newPf.StartPoint = newStartPoint;
foreach (m.PathSegment oldPs in olfPf.Segments)
{
m.PathSegment newPs = new m.PolyLineSegment();
foreach (Point point in ((m.PolyLineSegment)oldPs).Points)
{
Point tmp = point;
tmp.X *= scaling;
tmp.Y *= scaling;
((m.PolyLineSegment)newPs).Points.Add(tmp);
}
newPf.Segments.Add(newPs);
}
toReturn.Figures.Add(newPf);
}
return(toReturn);
}
public static m.PathGeometry CloseAllPathGeometries(m.PathGeometry toClose)
{
toClose = toClose.GetFlattenedPathGeometry(1, m.ToleranceType.Absolute);
m.PathGeometry toReturn = new m.PathGeometry();
foreach (m.PathFigure oldPf in toClose.Figures)
{
m.PathFigure newPf = new m.PathFigure {
StartPoint = oldPf.StartPoint
};
foreach (m.PathSegment oldPs in oldPf.Segments)
{
m.PathSegment newPs = new m.PolyLineSegment();
foreach (Point point in ((m.PolyLineSegment)oldPs).Points)
{
((m.PolyLineSegment)newPs).Points.Add(point);
}
((m.PolyLineSegment)newPs).Points.Add(((m.PolyLineSegment)newPs).Points[0]);
newPf.Segments.Add(newPs);
}
toReturn.Figures.Add(newPf);
}
return(toReturn);
}
private void DrawFormattedText(DpiScaleInfo dpiInfo)
{
FormattedText formattedText = new FormattedText(
"FABLE",
new System.Globalization.CultureInfo("en-US"),
FlowDirection.LeftToRight,
new Typeface(
new System.Windows.Media.FontFamily("Segoe UI"),
FontStyles.Normal,
FontWeights.Bold,
FontStretches.Normal),
120,
System.Windows.Media.Brushes.Red,
dpiInfo.PixelsPerDip);
// Build a geometry out of the text.
Geometry geometry = new PathGeometry();
geometry = formattedText.BuildGeometry(new System.Windows.Point(0, 0));
// Adjust the geometry to fit the aspect ration of the video by scaling it.
ScaleTransform myScaleTransform = new ScaleTransform();
myScaleTransform.ScaleX = .85;
myScaleTransform.ScaleY = 2.0;
geometry.Transform = myScaleTransform;
// Flatten the geometry and create a PathGeometry out of it.
PathGeometry pathGeometry = new PathGeometry();
pathGeometry = geometry.GetFlattenedPathGeometry();
// Use the PathGeometry for the empty placeholder Path element in XAML.
path.Data = pathGeometry;
// Use the PathGeometry for the animated ball that follows the path of the text outline.
matrixAnimation.PathGeometry = pathGeometry;
}
/// <summary>
/// Extracts the the Coordinates out of a PathGeometry and puts them into a PolyLineSegment.
/// </summary>
/// <param name="allPointsContainer">The PathGeometry that Contains the all the Coordinates you want to convert</param>
/// <returns></returns>
public static List <m.PolyLineSegment> PathGeometryToPlsListOld(m.PathGeometry allPointsContainer)
{
allPointsContainer = allPointsContainer.GetFlattenedPathGeometry(1.0, m.ToleranceType.Absolute);
return
(allPointsContainer.Figures.Select(
figures =>
figures.Segments.SelectMany(segments => ((m.PolyLineSegment)segments).Points).ToList())
.Select(allPoints => new m.PolyLineSegment(allPoints, true))
.ToList());
}
/// <summary>
/// Returns the pure PathGeometry to easily display at the screen.
/// </summary>
/// <returns></returns>
public static m.PathGeometry GeometryToPathGeometry(m.Geometry toConvert, double resolution = 20, bool wannaFlat = false)
{
m.PathGeometry myPathGeometry = toConvert.GetOutlinedPathGeometry(resolution,
m.ToleranceType.Relative);
if (wannaFlat)
{
myPathGeometry = myPathGeometry.GetFlattenedPathGeometry(resolution, m.ToleranceType.Relative);
}
return(myPathGeometry);
}
public static m.PathGeometry ScalingPathGeometry(m.PathGeometry toScale, double scaling, bool scaleAtZero = false)
{
toScale = toScale.GetFlattenedPathGeometry(1, m.ToleranceType.Absolute);
Point pointToScale = new Point();
if (scaleAtZero)
{
pointToScale = new Point(0, 0);
}
else
{
Rect rect = GetMinimalMaxRect(toScale, 0);
pointToScale = rect.BottomLeft;
}
m.PathGeometry toReturn = new m.PathGeometry();
foreach (m.PathFigure olfPf in toScale.Figures)
{
m.PathFigure newPf = new m.PathFigure();
Point newStartPoint = olfPf.StartPoint;
newStartPoint.X = (newStartPoint.X - pointToScale.X) * scaling + pointToScale.X;
newStartPoint.Y = (newStartPoint.Y - pointToScale.Y) * scaling + pointToScale.Y;
newPf.StartPoint = newStartPoint;
foreach (m.PathSegment oldPs in olfPf.Segments)
{
m.PathSegment newPs = new m.PolyLineSegment();
foreach (Point point in ((m.PolyLineSegment)oldPs).Points)
{
Point tmp = point;
tmp.X = (tmp.X - pointToScale.X) * scaling + pointToScale.X;
tmp.Y = (tmp.Y - pointToScale.Y) * scaling + pointToScale.Y;
((m.PolyLineSegment)newPs).Points.Add(tmp);
}
newPf.Segments.Add(newPs);
}
toReturn.Figures.Add(newPf);
}
return(toReturn);
}
public static double ComputeLength(PathGeometry path)
{
PathGeometry flattenedPath = path.GetFlattenedPathGeometry();
double length = 0;
Point prev = path.Figures[0].StartPoint;
foreach (PolyLineSegment segment in flattenedPath.Figures[0].Segments)
{
foreach (Point p in segment.Points)
{
double d = Point.Subtract(p, prev).Length;
prev = p;
length += d;
}
}
return length;
}
public static Rect GetMinimalMaxRect(m.PathGeometry pg, double rahmen)
{
pg = pg.GetFlattenedPathGeometry(1, m.ToleranceType.Absolute);
m.PathSegment tmp = pg.Figures[0].Segments[0];
Point firstPoint = ((m.PolyLineSegment)tmp).Points[0];
Point max = firstPoint;
Point min = firstPoint;
foreach (m.PathFigure pathFigure in pg.Figures)
{
foreach (m.PathSegment segments in pathFigure.Segments)
{
foreach (Point point in ((m.PolyLineSegment)segments).Points)
{
if (point.X > max.X)
{
max.X = point.X;
}
if (point.X < min.X)
{
min.X = point.X;
}
if (point.Y > max.Y)
{
max.Y = point.Y;
}
if (point.Y < min.Y)
{
min.Y = point.Y;
}
}
}
}
min.X -= rahmen;
min.Y -= rahmen;
max.X += rahmen;
max.Y += rahmen;
return(new Rect(min, max));
}
public static m.PathGeometry TranslatePathGeometry(m.PathGeometry toTranslate, double xOffset, double yOffset, bool textElement = false)
{
if (textElement)
{
yOffset *= -1;
}
toTranslate = toTranslate.GetFlattenedPathGeometry(1, m.ToleranceType.Absolute);
m.PathGeometry toReturn = new m.PathGeometry();
foreach (m.PathFigure oldPf in toTranslate.Figures)
{
m.PathFigure newPf = new m.PathFigure();
Point newStartPoint = oldPf.StartPoint;
newStartPoint.X = newStartPoint.X + xOffset;
newStartPoint.Y = newStartPoint.Y + yOffset;
newPf.StartPoint = newStartPoint;
foreach (m.PathSegment oldPs in oldPf.Segments)
{
m.PathSegment newPs = new m.PolyLineSegment();
foreach (Point point in ((m.PolyLineSegment)oldPs).Points)
{
Point tmp = point;
tmp.X = tmp.X + xOffset;
tmp.Y = tmp.Y + yOffset;
((m.PolyLineSegment)newPs).Points.Add(tmp);
}
newPf.Segments.Add(newPs);
}
toReturn.Figures.Add(newPf);
}
return(toReturn);
}
/// <summary>
/// Converts a PolyQuadraticBezierSegment into a PolyLineSegment because I currently have no muse to calculate
/// the correct Bézier curves.
/// </summary>
public static PdfSharp.Xps.XpsModel.PolyLineSegment FlattenSegment(PdfSharp.Xps.XpsModel.Point startPoint,
PdfSharp.Xps.XpsModel.PolyQuadraticBezierSegment seg)
{
PathGeometry geo = new PathGeometry();
PathFigure fig = new PathFigure();
geo.Figures.Add(fig);
fig.StartPoint = new Point(startPoint.X, startPoint.Y);
int count = seg.Points.Count;
Point[] points = new Point[count];
for (int idx = 0; idx < count - 1; idx += 2)
{
QuadraticBezierSegment qbseg = new QuadraticBezierSegment(
new Point(seg.Points[idx].X, seg.Points[idx].Y), new Point(seg.Points[idx + 1].X, seg.Points[idx + 1].Y), seg.IsStroked);
fig.Segments.Add(qbseg);
}
geo = geo.GetFlattenedPathGeometry();
fig = geo.Figures[0];
PolyLineSegment lineSeg = (PolyLineSegment)fig.Segments[0];
PdfSharp.Xps.XpsModel.PolyLineSegment resultSeg = new PdfSharp.Xps.XpsModel.PolyLineSegment();
foreach (Point point in lineSeg.Points)
resultSeg.Points.Add(new PdfSharp.Xps.XpsModel.Point(point.X, point.Y));
return resultSeg;
}
/// <summary>
/// Approximate this figure with a polygonal PathFigure
/// </summary>
/// <param name="tolerance">The approximation error tolerance</param>
/// <param name="type">The way the error tolerance will be interpreted - relative or absolute</param>
/// <returns>Returns the polygonal approximation as a PathFigure.</returns>
public PathFigure GetFlattenedPathFigure(double tolerance, ToleranceType type)
{
PathGeometry geometry = new PathGeometry();
geometry.Figures.Add(this);
PathGeometry flattenedGeometry = geometry.GetFlattenedPathGeometry(tolerance, type);
int count = flattenedGeometry.Figures.Count;
if (count == 0)
{
return(new PathFigure());
}
else if (count == 1)
{
return(flattenedGeometry.Figures[0]);
}
else
{
throw new InvalidOperationException(SR.Get(SRID.PathGeometry_InternalReadBackError));
}
}
/// <summary>
/// Converts an ArcSegment into a PolyLineSegment because I currently have no muse to calculate
/// the correct Bézier curves.
/// </summary>
public static PdfSharp.Xps.XpsModel.PolyLineSegment FlattenSegment(PdfSharp.Xps.XpsModel.Point startPoint,
PdfSharp.Xps.XpsModel.ArcSegment seg)
{
PathGeometry geo = new PathGeometry();
PathFigure fig = new PathFigure();
geo.Figures.Add(fig);
fig.StartPoint = new Point(startPoint.X, startPoint.Y);
ArcSegment aseg = new ArcSegment(new Point(seg.Point.X, seg.Point.Y), new Size(seg.Size.Width, seg.Size.Height), seg.RotationAngle,
seg.IsLargeArc, (SweepDirection)seg.SweepDirection, seg.IsStroked);
fig.Segments.Add(aseg);
geo = geo.GetFlattenedPathGeometry();
fig = geo.Figures[0];
//PolyLineSegment lineSeg = (PolyLineSegment)fig.Segments[0];
PdfSharp.Xps.XpsModel.PolyLineSegment resultSeg = new PdfSharp.Xps.XpsModel.PolyLineSegment();
int count = fig.Segments.Count;
for (int idx = 0; idx < count; idx++)
{
PathSegment pathSeg = fig.Segments[idx];
if (pathSeg is PolyLineSegment)
{
PolyLineSegment plseg = (PolyLineSegment)pathSeg;
foreach (Point point in plseg.Points)
resultSeg.Points.Add(new PdfSharp.Xps.XpsModel.Point(point.X, point.Y));
}
else if (pathSeg is LineSegment)
{
LineSegment lseg = (LineSegment)pathSeg;
resultSeg.Points.Add(new PdfSharp.Xps.XpsModel.Point(lseg.Point.X, lseg.Point.Y));
}
else
{
Debugger.Break();
}
}
return resultSeg;
}
/// <summary>
/// Appends the content of a PathGeometry object.
/// </summary>
internal void AppendPath(PathGeometry geometry)
{
#if true_
// sissy version
geometry = geometry.GetFlattenedPathGeometry();
#endif
foreach (PathFigure figure in geometry.Figures)
{
System.Windows.Point currentPoint = new System.Windows.Point();
// Move to start point
currentPoint = figure.StartPoint;
AppendFormat("{0:0.####} {1:0.####} m\n", currentPoint.X, currentPoint.Y);
foreach (PathSegment segment in figure.Segments)
{
Type type = segment.GetType();
if (type == typeof(LineSegment))
{
// Draw a single line
System.Windows.Point point = ((LineSegment)segment).Point;
currentPoint = point;
AppendFormat("{0:0.####} {1:0.####} l\n", point.X, point.Y);
}
else if (type == typeof(PolyLineSegment))
{
// Draw connected lines
PointCollection points = ((PolyLineSegment)segment).Points;
foreach (System.Windows.Point point in points)
{
currentPoint = point; // I forced myself not to optimize this assignment
AppendFormat("{0:0.####} {1:0.####} l\n", point.X, point.Y);
}
}
else if (type == typeof(BezierSegment))
{
// Draw Bézier curve
BezierSegment seg = (BezierSegment)segment;
System.Windows.Point point1 = seg.Point1;
System.Windows.Point point2 = seg.Point2;
System.Windows.Point point3 = seg.Point3;
AppendFormat("{0:0.####} {1:0.####} {2:0.####} {3:0.####} {4:0.####} {5:0.####} c\n",
point1.X, point1.Y, point2.X, point2.Y, point3.X, point3.Y);
currentPoint = point3;
}
else if (type == typeof(PolyBezierSegment))
{
// Draw connected Bézier curves
PointCollection points = ((PolyBezierSegment)segment).Points;
int count = points.Count;
if (count > 0)
{
Debug.Assert(count % 3 == 0, "Number of Points in PolyBezierSegment are not a multiple of 3.");
for (int idx = 0; idx < count - 2; idx += 3)
{
System.Windows.Point point1 = points[idx];
System.Windows.Point point2 = points[idx + 1];
System.Windows.Point point3 = points[idx + 2];
AppendFormat("{0:0.####} {1:0.####} {2:0.####} {3:0.####} {4:0.####} {5:0.####} c\n",
point1.X, point1.Y, point2.X, point2.Y, point3.X, point3.Y);
}
currentPoint = points[count - 1];
}
}
else if (type == typeof(ArcSegment))
{
// Draw arc
ArcSegment seg = (ArcSegment)segment;
AppendPartialArc(currentPoint, seg.Point, seg.RotationAngle, seg.Size, seg.IsLargeArc, seg.SweepDirection, PathStart.Ignore1st);
currentPoint = seg.Point;
}
else if (type == typeof(QuadraticBezierSegment))
{
QuadraticBezierSegment seg = (QuadraticBezierSegment)segment;
currentPoint = seg.Point2;
// TODOWPF: Undone because XGraphics has no such curve type
throw new NotImplementedException("AppendPath with QuadraticBezierSegment.");
}
else if (type == typeof(PolyQuadraticBezierSegment))
{
PolyQuadraticBezierSegment seg = (PolyQuadraticBezierSegment)segment;
currentPoint = seg.Points[seg.Points.Count - 1];
// TODOWPF: Undone because XGraphics has no such curve type
throw new NotImplementedException("AppendPath with PolyQuadraticBezierSegment.");
}
}
if (figure.IsClosed)
Append("h\n");
}
}
/// <summary>
/// Approximate this figure with a polygonal PathFigure
/// </summary>
/// <param name="tolerance">The approximation error tolerance</param>
/// <param name="type">The way the error tolerance will be interpreted - relative or absolute</param>
/// <returns>Returns the polygonal approximation as a PathFigure.</returns>
public PathFigure GetFlattenedPathFigure(double tolerance, ToleranceType type)
{
PathGeometry geometry = new PathGeometry();
geometry.Figures.Add(this);
PathGeometry flattenedGeometry = geometry.GetFlattenedPathGeometry(tolerance, type);
int count = flattenedGeometry.Figures.Count;
if (count == 0)
{
return new PathFigure();
}
else if (count == 1)
{
return flattenedGeometry.Figures[0];
}
else
{
throw new InvalidOperationException(SR.Get(SRID.PathGeometry_InternalReadBackError));
}
}
