/// <summary>
/// 创建J2项力求解器
/// </summary>
/// <param name="group"></param>
/// <returns></returns>
private J2Evaluator CreateEvaluator(EvaluatorGroup group)
{
if (this.m_targetPoint == null)
{
throw new PropertyInvalidException("TargetPoint", PropertyInvalidException.PropertyCannotBeNull);
}
if (this.m_centralBody == null)
{
throw new PropertyInvalidException("CentralBody", PropertyInvalidException.PropertyCannotBeNull);
}
if (this.m_gravitationalParameter < 0.0)
{
throw new PropertyInvalidException("GravitationalParameter", PropertyInvalidException.PropertyCannotBeNegative);
}
if (this.m_j2ZonalHarmonicCoefficient < 0.0)
{
throw new PropertyInvalidException("J2ZonalHarmonicCoefficient", PropertyInvalidException.PropertyMustBePositive);
}
if (this.m_referenceDistance < 0.0)
{
throw new PropertyInvalidException("ReferenceDistance", PropertyInvalidException.PropertyMustBePositive);
}
// 创建J2项引力的求解器类
return(new J2Evaluator(GeometryTransformer.ObservePoint(this.m_targetPoint, this.m_centralBody.InertialFrame, group), this.m_gravitationalParameter, this.m_centralBody.InertialFrame, this.m_j2ZonalHarmonicCoefficient, this.m_referenceDistance));
}
protected override void OnPaint(GUI.PaintEventArgs e)
{
Graphics graphics = e.Graphics;
graphics.SmoothingMode = SmoothingMode.AntiAlias;
graphics.PixelOffsetMode = PixelOffsetMode.None;
PolygonElement polygon = m_PolygonElement;
if (!polygon.IsModified)
{
//TEST return;
}
polygon.close(m_CloseCheckBox.IsChecked);
PolylineGeometry poly = new PolylineGeometry(polygon.Polygon, true, m_CloseCheckBox.IsChecked);
BSplineGeometry bspline = new BSplineGeometry(poly);
bspline.InterpolationStep = 1.0 / m_PointsNumberSlider.Value;
SinglePathTransform tcurve = new SinglePathTransform();
tcurve.PreserveXScale = m_PreserveXScaleCheckBox.IsChecked;
if (m_FixedLenCheckBox.IsChecked)
{
tcurve.BaseLength = 1120;
}
tcurve.AddPath(bspline);
GeometryTransformer ftrans = new GeometryTransformer(GetCurveTransformedTextGeometry(tcurve.TotalLength).Item1, tcurve);
if (m_FillCheckBox.IsChecked)
{
Brush brush = m_TextBrush;
// Irrlicht Renderer can't render smoothed gradients now
if (graphics.RenderSystemName.Contains(Graphics.RSN_Irrlicht))
{
if (m_TextBrush_Irrlicht == null)
{
m_TextBrush_Irrlicht = new SolidColorBrush(Color.Yellow);
}
brush = m_TextBrush_Irrlicht;
}
graphics.FillGeometry(brush, ftrans);
}
if (m_OutlineCheckBox.IsChecked)
{
graphics.DrawGeometry(m_FillCheckBox.IsChecked ? Color.Red : Color.White, ftrans, m_OutlineThicknessSlider.Value);
}
graphics.DrawGeometry(m_BSplinePen, bspline);
base.OnPaint(e);
}
private void button4_Click(object sender, EventArgs e)
{
Polygon p = g1[0].Geometry as Polygon;
GeometryTransformer tr = new GeometryTransformer();
double rad = (g1[0].Geometry.Area / g2[0].Geometry.Area);
MessageBox.Show(rad.ToString());
}
public GeometryAuxWeight(Geometry geometry)
{
m_mtx_zoom_in_y = Matrix4.CreateScaling(1, 100);
m_mtx_zoom_out_y = Matrix4.CreateScaling(1, 1.0 / 100.0);
m_trans_zoom_in_y = GeometryMatrix4Transformer.CreateOptimizedTransformer(geometry, m_mtx_zoom_in_y);
m_contour = new GeometryContour(m_trans_zoom_in_y);
m_trans_zoom_out = GeometryMatrix4Transformer.CreateOptimizedTransformer(m_contour, m_mtx_zoom_out_y);
m_contour.AutoDetectOrientation = false;
Geometry = m_trans_zoom_out;
}
void FillGeometry(Graphics graphics, PolarTransform transform, Color color, Geometry geometry)
{
if (graphics == null ||
geometry == null)
{
return;
}
GeometrySegmentator geometrySegmentator = new GeometrySegmentator(geometry);
GeometryTransformer geometrySegmentatorPolarTransformer = new GeometryTransformer(geometrySegmentator, transform);
graphics.FillGeometry(color, geometrySegmentatorPolarTransformer);
}
void DrawGeometry(Graphics graphics, PolarTransform transform, Color color, Geometry geometry, double thickness)
{
if (graphics == null ||
geometry == null)
{
return;
}
GeometrySegmentator geometrySegmentator = new GeometrySegmentator(geometry);
GeometryTransformer geometrySegmentatorPolarTransformer = new GeometryTransformer(geometrySegmentator, transform);
graphics.DrawGeometry(color, geometrySegmentatorPolarTransformer, thickness);
}
public void GeometryUpdaterTest_FailedTooShort()
{
IGeometryFactory gf = new GeometryFactory();
ILineString oldRefGeometry = gf.CreateLineString(new Coordinate[] { new Coordinate(0.4, 1), new Coordinate(0.6, 1) });
ILineString newSegmentGeometry = gf.CreateLineString(new Coordinate[] { new Coordinate(0, 0), new Coordinate(0.5, 0.5), new Coordinate(1, 0) });
GeometryTransformer gt = new GeometryTransformer(oldRefGeometry, newSegmentGeometry);
var result = gt.Transform();
ILineString newRefGeometry = result.NewRefGeometry;
Assert.IsNull(newRefGeometry);
Assert.IsTrue(result.ResultState == GeometryTransformerResultState.FailedWouldBeTooShort);
}
public void GeometryUpdaterTest_SuccessEqualGeoms()
{
IGeometryFactory gf = new GeometryFactory();
ILineString oldRefGeometry = gf.CreateLineString(new Coordinate[] { new Coordinate(0, 0), new Coordinate(1, 0) });
ILineString newSegmentGeometry = gf.CreateLineString(new Coordinate[] { new Coordinate(0, 0), new Coordinate(2, 0) });
GeometryTransformer gt = new GeometryTransformer(oldRefGeometry, newSegmentGeometry);
var result = gt.Transform();
ILineString newRefGeometry = result.NewRefGeometry;
Assert.AreEqual(oldRefGeometry, newRefGeometry);
Assert.IsTrue(result.ResultState == GeometryTransformerResultState.Success);
}
private void OnLoad(object sender, EventArgs e)
{
// Create overlay toolbar and panels
m_overlayToolbar = new OverlayToolbar(m_insight3D);
m_overlayToolbar.Overlay.Origin = ScreenOverlayOrigin.BottomCenter;
// Add additional toolbar buttons
// Number of Satellites Button
m_overlayToolbar.AddButton(GetDataFilePath("Textures/OverlayToolbar/manysatellites.png"),
GetDataFilePath("Textures/OverlayToolbar/fewsatellites.png"),
ToggleNumberOfSatellites);
// Show/Hide Access Button
m_overlayToolbar.AddButton(GetDataFilePath("Textures/OverlayToolbar/noshowaccess.png"),
GetDataFilePath("Textures/OverlayToolbar/showaccess.png"),
ToggleComputeAccess);
// Initialize the text panel
m_textPanel = new TextureScreenOverlay(0, 0, 80, 35)
{
Origin = ScreenOverlayOrigin.TopRight,
BorderSize = 2,
BorderColor = Color.Transparent,
BorderTranslucency = 0.6f,
Color = Color.Transparent,
Translucency = 0.4f
};
SceneManager.ScreenOverlays.Add(m_textPanel);
// Show label for the moon
Scene scene = m_insight3D.Scene;
scene.CentralBodies[CentralBodiesFacet.GetFromContext().Moon].ShowLabel = true;
// Create a marker primitive for the facility at Bells Beach Australia
EarthCentralBody earth = CentralBodiesFacet.GetFromContext().Earth;
Cartographic facilityPosition = new Cartographic(Trig.DegreesToRadians(144.2829), Trig.DegreesToRadians(-38.3697), 0.0);
Texture2D facilityTexture = SceneManager.Textures.FromUri(GetDataFilePath(@"Markers\Facility.png"));
MarkerBatchPrimitive marker = new MarkerBatchPrimitive(SetHint.Infrequent)
{
Texture = facilityTexture
};
marker.Set(new[] { earth.Shape.CartographicToCartesian(facilityPosition) });
SceneManager.Primitives.Add(marker);
PointCartographic point = new PointCartographic(earth, facilityPosition);
Axes topographic = new AxesNorthEastDown(earth, point);
ReferenceFrame facilityTopo = new ReferenceFrame(point, topographic);
m_fixedToFacilityTopoEvaluator = GeometryTransformer.GetReferenceFrameTransformation(earth.FixedFrame, facilityTopo);
Axes temeAxes = earth.TrueEquatorMeanEquinoxFrame.Axes;
m_temeToFixedEvaluator = GeometryTransformer.GetAxesTransformation(temeAxes, earth.FixedFrame.Axes);
m_showAccess = true;
m_satellites = new Satellites();
CreateSatellites("stkSatDb");
// This Render() is needed so that the stars will show.
scene.Render();
}
private IList <Guid> UpdateAchsenReferenzen(AchsenSegment currententity, IGeometry shape, bool persistChanges, AchseModificationAction modificationAction = AchseModificationAction.Change)
{
Dictionary <AchsenReferenz, GeometryTransformerResult> ret = new Dictionary <AchsenReferenz, GeometryTransformerResult>();
foreach (AchsenReferenz referenz in currententity.AchsenReferenzen.ToList())
{
ILineString oldRefGeometry = (ILineString)referenz.Shape;
ILineString newSegmentGeometry = (ILineString)shape;
GeometryTransformer gt = new GeometryTransformer(oldRefGeometry, newSegmentGeometry);
GeometryTransformerResult result = gt.Transform();
if (result.ResultState != GeometryTransformerResultState.Success || !result.NewRefGeometry.EqualsExact(oldRefGeometry))
{
ret.Add(referenz, result);
}
}
//check if strabs are overlapping other strabs
foreach (var pair in ret.Where(p => p.Key.ReferenzGruppe.StrassenabschnittGIS != null && p.Value.ResultState == GeometryTransformerResultState.Success).ToList())
{
IEnumerable <AchsenReferenz> strabsar = pair.Key.AchsenSegment.AchsenReferenzen.Where(ar => ar.Id != pair.Key.Id && ar.ReferenzGruppe.StrassenabschnittGIS != null);
foreach (AchsenReferenz strabref in strabsar)
{
IGeometry currentstrabref = strabref.Shape;
bool exists = true;
KeyValuePair <AchsenReferenz, GeometryTransformerResult> newZabref = ret.Where(p => p.Key.Id.Equals(strabref.Id)).SingleOrDefault();
if (!newZabref.Equals(default(KeyValuePair <AchsenReferenz, GeometryTransformerResult>)))
{
currentstrabref = newZabref.Value.NewRefGeometry;
exists = newZabref.Value.ResultState == GeometryTransformerResultState.Success;
}
if (exists)
{
if (!gisService.CheckOverlapp(new List <IGeometry>()
{
currentstrabref
}, pair.Value.NewRefGeometry))
{
ret[pair.Key] = new GeometryTransformerResult(GeometryTransformerResultState.FailedWouldBeOutside, pair.Value.NewRefGeometry);
}
}
}
}
//check if zabs still within strabs and update results if not, ensure zabs are not overlapping others
foreach (var pair in ret.Where(p => p.Key.ReferenzGruppe.ZustandsabschnittGIS != null && p.Value.ResultState == GeometryTransformerResultState.Success).ToList())
{
ZustandsabschnittGIS zab = pair.Key.ReferenzGruppe.ZustandsabschnittGIS;
if (zab != null && pair.Value.ResultState == GeometryTransformerResultState.Success)
{
IEnumerable <AchsenReferenz> strabrefs = ret.Where(p => p.Key.ReferenzGruppe.StrassenabschnittGIS != null &&
p.Key.ReferenzGruppe.StrassenabschnittGIS.Id == zab.StrassenabschnittGIS.Id &&
p.Value.ResultState == GeometryTransformerResultState.Success).Select(p => p.Key).ToList();
IList <IGeometry> zabrefs = new List <IGeometry>()
{
pair.Value.NewRefGeometry
};
foreach (AchsenReferenz achsref in strabrefs)
{
bool isWithin = false;
if (ret[achsref].ResultState == GeometryTransformerResultState.Success)
{
isWithin = isWithin || gisService.CheckGeometriesIsInControlGeometry(zabrefs, ret[achsref].NewRefGeometry);
}
if (!isWithin)
{
ret[pair.Key] = new GeometryTransformerResult(GeometryTransformerResultState.FailedWouldBeOutside, pair.Value.NewRefGeometry);
}
}
IEnumerable <AchsenReferenz> allzabrefs = zab.StrassenabschnittGIS.Zustandsabschnitten.SelectMany(z => z.ReferenzGruppe.AchsenReferenzen).Where(ar => !ar.Id.Equals(pair.Key.Id));
foreach (AchsenReferenz zabref in allzabrefs)
{
IGeometry currentzabref = zabref.Shape;
bool exists = true;
KeyValuePair <AchsenReferenz, GeometryTransformerResult> newZabref = ret.Where(p => p.Key.Id.Equals(zabref.Id)).SingleOrDefault();
if (!newZabref.Equals(default(KeyValuePair <AchsenReferenz, GeometryTransformerResult>)))
{
currentzabref = newZabref.Value.NewRefGeometry;
exists = newZabref.Value.ResultState == GeometryTransformerResultState.Success;
}
if (exists)
{
if (!gisService.CheckOverlapp(new List <IGeometry>()
{
currentzabref
}, pair.Value.NewRefGeometry))
{
ret[pair.Key] = new GeometryTransformerResult(GeometryTransformerResultState.FailedWouldBeOutside, pair.Value.NewRefGeometry);
}
}
}
}
}
if (persistChanges)
{
foreach (var pair in ret)
{
this.UpdateAchsenReferenz(pair.Key, pair.Value, modificationAction == AchseModificationAction.Delete);
}
}
return(ret.Keys.Select(k => k.Id).ToList());
}
protected override void OnPaint(GUI.PaintEventArgs e)
{
Graphics graphics = e.Graphics;
graphics.SmoothingMode = SmoothingMode.AntiAlias;
graphics.PixelOffsetMode = PixelOffsetMode.None;
// Polygon1
PolygonElement polygon1 = m_PolygonElement1;
PolylineGeometry path1 = new PolylineGeometry(polygon1.Polygon, true, false);
BSplineGeometry bspline1 = new BSplineGeometry(path1);
bspline1.InterpolationStep = 1.0 / m_PointsNumberSlider.Value;
// Polygon2
PolygonElement polygon2 = m_PolygonElement2;
PolylineGeometry path2 = new PolylineGeometry(polygon2.Polygon, true, false);
BSplineGeometry bspline2 = new BSplineGeometry(path2);
bspline1.InterpolationStep = 1.0 / m_PointsNumberSlider.Value;
DoublePathTransform tcurve = new DoublePathTransform();
tcurve.PreserveXScale = m_PreserveXScaleCheckBox.IsChecked;
if (m_FixedLenCheckBox.IsChecked)
{
tcurve.BaseLength = 1140.0;
}
tcurve.AddPaths(bspline1, bspline2);
Tuple <Geometry, double> geometry = GetCurveTransformedTextGeometry(tcurve.TotalLength1);
tcurve.BaseHeight = FontAscentInPixels + geometry.Item2 + 3;
GeometryTransformer ftrans = new GeometryTransformer(geometry.Item1, tcurve);
if (m_FillCheckBox.IsChecked)
{
Brush brush = m_TextBrush;
// Irrlicht Renderer can't render smoothed gradients now
if (graphics.RenderSystemName.Contains(Graphics.RSN_Irrlicht))
{
if (m_TextBrush_Irrlicht == null)
{
m_TextBrush_Irrlicht = new SolidColorBrush(Color.LawnGreen);
}
brush = m_TextBrush_Irrlicht;
}
graphics.FillGeometry(brush, ftrans);
}
if (m_OutlineCheckBox.IsChecked)
{
graphics.DrawGeometry(Color.White, ftrans, m_OutlineThicknessSlider.Value);
}
graphics.DrawGeometry(m_BSplinePen, bspline1);
graphics.DrawGeometry(m_BSplinePen, bspline2);
base.OnPaint(e);
}
void DrawingPanel_Paint(object sender, PaintEventArgs e)
{
e.Graphics.SmoothingMode = SmoothingMode.AntiAlias;
Matrix4 mtx = Matrix4.CreateTranslation(-m_SVGPathBounds.Center.X, -m_SVGPathBounds.Center.Y);
mtx.Scale(m_Scale, m_Scale, MatrixOrder.Append);
mtx.Translate(m_x, m_y, MatrixOrder.Append);
ITransform transform = null;
if (rbBilinear.IsChecked)
{
Bilinear tr = new Bilinear(
m_SVGPathScaledBounds.Left, m_SVGPathScaledBounds.Top,
m_SVGPathScaledBounds.Right, m_SVGPathScaledBounds.Bottom, m_PolygonElement.Polygon);
if (tr.IsValid)
{
transform = tr;
}
}
else
{
Perspective tr = new Perspective(
m_SVGPathScaledBounds.Left, m_SVGPathScaledBounds.Top,
m_SVGPathScaledBounds.Right, m_SVGPathScaledBounds.Bottom, m_PolygonElement.Polygon);
if (tr.IsValid() &&
Perspective.IsConvex(m_PolygonElement.Polygon))
{
transform = tr;
}
}
//
GeometryTransformer transformer = null;
if (transform != null)
{
transformer = new GeometryTransformer(transform);
}
// Render transformed SVG
m_SVGPath.Render(e.Graphics, mtx, transformer);
// Render transformed ellipse
Point center = m_SVGPathScaledBounds.Center;
EllipseGeometry FilledEllipse = new EllipseGeometry(center.X, center.Y, m_SVGPathScaledBounds.Width / 2, m_SVGPathScaledBounds.Height / 2, 200);
GeometryStroke EllipseOutline = new GeometryStroke(FilledEllipse);
EllipseOutline.Width = 3.0;
Geometry TransformedFilledEllipse = FilledEllipse;
Geometry TransformedEllipesOutline = EllipseOutline;
if (transform != null)
{
TransformedFilledEllipse = new GeometryTransformer(FilledEllipse, transform);
TransformedEllipesOutline = new GeometryTransformer(EllipseOutline, transform);
}
SmoothingMode saveSmoothingMode = e.Graphics.SmoothingMode;
e.Graphics.SmoothingMode = SmoothingMode.None;
{
e.Graphics.FillGeometry(m_EllipseBrush, TransformedFilledEllipse);
}
e.Graphics.SmoothingMode = saveSmoothingMode;
e.Graphics.FillGeometry(m_EllipsePen.Color, TransformedEllipesOutline);
}
protected override void OnPaint(GUI.PaintEventArgs e)
{
base.OnPaint(e);
Graphics graphics = e.Graphics;
graphics.SmoothingMode = SmoothingMode.AntiAlias;
PolarTransform polarTransform = new PolarTransform();
polarTransform.FullCircle = -600;
polarTransform.BaseScale = -1;
polarTransform.SetBaseOffset(0, m_BaseYSlider.Value);
polarTransform.SetTranslation(ClientWidth / 2.0, ClientHeight / 2.0 - 30.0);
polarTransform.Spiral = m_SpiralSlider.Value;
// Draw Background
RectangleGeometry borderGeometry = new RectangleGeometry(0, 0, m_TextBox.Width, m_TextBox.Height);
// Just for little optimization
GeometrySegmentator borderGeometrySegmentator = new GeometrySegmentator(borderGeometry);
GeometryTransformer borderGeometrySegmentatorPolarTransformer = new GeometryTransformer(borderGeometrySegmentator, polarTransform);
graphics.FillGeometry(Color.WhiteSmoke, borderGeometrySegmentatorPolarTransformer);
// Selection
if (m_TextBox.HasSelectionAndVisible)
{
RectangleGeometry selectionGeometry = new RectangleGeometry(m_TextBox.SelectionBounds
// Just to prevent some artefacts
- new PointI(0, 1) + new SizeI(0, 2));
FillGeometry(graphics, polarTransform, m_TextBox.SelectionColor, selectionGeometry);
}
// Caret
if (m_TextBox.IsCaretVisible)
{
RectangleGeometry caretGeometry = new RectangleGeometry(m_TextBox.CaretBounds);
FillGeometry(graphics, polarTransform, Color.Black, caretGeometry);
}
// Draw Border
graphics.DrawGeometry(Color.DodgerBlue, borderGeometrySegmentatorPolarTransformer, 2);
// Text
Font font = m_TextBox.Font;
GraphicsPath textGeometry = new GraphicsPath();
textGeometry.AddString(
m_TextBox.Text,
font.FontFamily, font.Style, font.Size * 96.0 / 72.0, new Point(4, 1), StringFormat.GenericTypographic);
FlattenCurveGeometry textFlattenGeometry = new FlattenCurveGeometry(textGeometry);
// Need for clip text
Geometry clippedTextFlattenGeometry = new FlattenCurveGeometry(
new CombinedGeometry(textFlattenGeometry, new RectangleGeometry(1, 1, m_TextBox.Width - 2, m_TextBox.Height - 2), CombinedGeometry.CombineMode.And));
FillGeometry(graphics, polarTransform, m_TextBox.TextColor, clippedTextFlattenGeometry);
}
void panel2_Paint(object sender, GUI.PaintEventArgs e)
{
Graphics graphics = e.Graphics;
bool isSoftwareGraphics = graphics is SoftwareGraphics;
//if (isSoftwareGraphics)
{
graphics.SmoothingMode = SmoothingMode.AntiAlias;
}
// Two simple paths
if (rbGeometry5.IsChecked)
{
GraphicsPath ps1_path = new GraphicsPath();
double x = m_X - m_DrawingPanel.ClientRectangle.Center.X / 2 + 100;
double y = m_Y - m_DrawingPanel.ClientRectangle.Center.Y / 2 + 100;
ps1_path.MoveTo(x + 140, y + 145);
ps1_path.LineTo(x + 225, y + 44);
ps1_path.LineTo(x + 296, y + 219);
ps1_path.ClosePolygon();
ps1_path.LineTo(x + 226, y + 289);
ps1_path.LineTo(x + 82, y + 292);
ps1_path.MoveTo(x + 220, y + 222);
ps1_path.LineTo(x + 363, y + 249);
ps1_path.LineTo(x + 265, y + 331);
ps1_path.MoveTo(x + 242, y + 243);
ps1_path.LineTo(x + 268, y + 309);
ps1_path.LineTo(x + 325, y + 261);
ps1_path.MoveTo(x + 259, y + 259);
ps1_path.LineTo(x + 273, y + 288);
ps1_path.LineTo(x + 298, y + 266);
Rect ps1Bounds = ps1_path.Bounds;
GeometryTransformer ps1 = GeometryMatrix4Transformer.CreateOptimizedTransformer(ps1_path, Matrix4.CreateTranslation(
m_X - ps1Bounds.Center.X,
m_Y - ps1Bounds.Center.Y));
GraphicsPath ps2_path = new GraphicsPath();
ps2_path.MoveTo(100 + 32, 100 + 77);
ps2_path.LineTo(100 + 473, 100 + 263);
ps2_path.LineTo(100 + 351, 100 + 290);
ps2_path.LineTo(100 + 354, 100 + 374);
Rect ps2Bounds = ps2_path.Bounds;
GeometryTransformer ps2 = GeometryMatrix4Transformer.CreateOptimizedTransformer(ps2_path, Matrix4.CreateTranslation(
(m_DrawingPanel.Width - ps2Bounds.Width) / 2 - ps2Bounds.Left,
(m_DrawingPanel.Height - ps2Bounds.Height) / 2 - ps2Bounds.Top));
graphics.FillGeometry(m_GeometryBColor, ps2);
graphics.FillGeometry(m_GeometryAColor, ps1);
CombinedGeometry clp = new CombinedGeometry(ps1, ps2, CombinedGeometry.CombineMode.Or, CombinedGeometry.FillType.NonZero, CombinedGeometry.FillType.NonZero);
PerformRendering(graphics, clp);
}
// Closed stroke
else if (rbGeometry4.IsChecked)
{
GraphicsPath ps1_path = new GraphicsPath();
double x = m_X - m_DrawingPanel.ClientRectangle.Center.X / 2 + 100;
double y = m_Y - m_DrawingPanel.ClientRectangle.Center.Y / 2 + 100;
ps1_path.MoveTo(x + 140, y + 145);
ps1_path.LineTo(x + 225, y + 44);
ps1_path.LineTo(x + 296, y + 219);
ps1_path.ClosePolygon();
ps1_path.LineTo(x + 226, y + 289);
ps1_path.LineTo(x + 82, y + 292);
ps1_path.MoveTo(x + 220 - 50, y + 222);
ps1_path.LineTo(x + 265 - 50, y + 331);
ps1_path.LineTo(x + 363 - 50, y + 249);
ps1_path.ClosePolygon(GeometryVertexCommandAndFlags.FlagCCW);
Rect ps1Bounds = ps1_path.Bounds;
GeometryTransformer ps1 = GeometryMatrix4Transformer.CreateOptimizedTransformer(ps1_path, Matrix4.CreateTranslation(
m_X - ps1Bounds.Center.X,
m_Y - ps1Bounds.Center.Y));
GraphicsPath ps2_path = new GraphicsPath();
ps2_path.MoveTo(100 + 32, 100 + 77);
ps2_path.LineTo(100 + 473, 100 + 263);
ps2_path.LineTo(100 + 351, 100 + 290);
ps2_path.LineTo(100 + 354, 100 + 374);
ps2_path.ClosePolygon();
Rect ps2Bounds = ps2_path.Bounds;
GeometryTransformer ps2 = GeometryMatrix4Transformer.CreateOptimizedTransformer(ps2_path, Matrix4.CreateTranslation(
(m_DrawingPanel.Width - ps2Bounds.Width) / 2 - ps2Bounds.Left,
(m_DrawingPanel.Height - ps2Bounds.Height) / 2 - ps2Bounds.Top));
GeometryStroke stroke = new GeometryStroke(ps2, 10);
graphics.FillGeometry(m_GeometryBColor, stroke);
graphics.FillGeometry(m_GeometryAColor, ps1);
CombinedGeometry clp = new CombinedGeometry(ps1, stroke, CombinedGeometry.CombineMode.Or, CombinedGeometry.FillType.NonZero, CombinedGeometry.FillType.NonZero);
PerformRendering(graphics, clp);
}
// Great Britain and Arrows
else if (rbGeometry3.IsChecked)
{
Geometry poly = GreatBritain;
Rect polyBounds = poly.Bounds;
double scale = 3;
Matrix4 mtx = Matrix4.CreateTranslation(-polyBounds.Center.X, -polyBounds.Center.Y);
mtx *= Matrix4.CreateScaling(scale, scale);
mtx *= Matrix4.CreateTranslation(m_DrawingPanel.Width / 2, m_DrawingPanel.Height / 2);
GeometryTransformer trans_gb_poly = GeometryMatrix4Transformer.CreateOptimizedTransformer(poly, mtx);
Geometry arrows = Arrows;
Rect arrowsBounds = arrows.Bounds;
mtx = Matrix4.CreateTranslation(-arrowsBounds.Center.X, -arrowsBounds.Center.Y);
mtx *= Matrix4.CreateScaling(scale, scale);
mtx *= Matrix4.CreateTranslation(m_X, m_Y);
GeometryTransformer trans_arrows = GeometryMatrix4Transformer.CreateOptimizedTransformer(arrows, mtx);
CombinedGeometry clp = new CombinedGeometry(trans_gb_poly, trans_arrows,
CombinedGeometry.CombineMode.Or,
CombinedGeometry.FillType.NonZero,
CombinedGeometry.FillType.NonZero);
graphics.FillGeometry(m_GeometryBColor, trans_gb_poly);
graphics.DrawGeometry(isSoftwareGraphics ? m_GreatBritainContourPen_SWR : m_GreatBritainContourPen_HWR, trans_gb_poly);
graphics.FillGeometry(m_GeometryAColor, trans_arrows);
PerformRendering(graphics, clp);
}
// Great Britain and a Spiral
else if (rbGeometry2.IsChecked)
{
Geometry poly = GreatBritain;
Rect polyBounds = poly.Bounds;
double scale = 3;
Matrix4 mtx = Matrix4.CreateTranslation(-polyBounds.Center.X, -polyBounds.Center.Y);
mtx *= Matrix4.CreateScaling(scale, scale);
mtx *= Matrix4.CreateTranslation(m_DrawingPanel.Width / 2, m_DrawingPanel.Height / 2);
GeometryTransformer trans_gb_poly = GeometryMatrix4Transformer.CreateOptimizedTransformer(poly, mtx);
Geometry sp = GeometryMatrix4Transformer.CreateOptimizedTransformer(Spiral, Matrix4.CreateTranslation(m_X, m_Y));
GeometryStroke stroke = new GeometryStroke(sp, 15);
CombinedGeometry clp = new CombinedGeometry(trans_gb_poly, stroke,
CombinedGeometry.CombineMode.Or,
CombinedGeometry.FillType.NonZero,
CombinedGeometry.FillType.NonZero);
graphics.FillGeometry(m_GeometryBColor, trans_gb_poly);
graphics.DrawGeometry(isSoftwareGraphics ? m_GreatBritainContourPen_SWR : m_GreatBritainContourPen_HWR, trans_gb_poly);
graphics.DrawGeometry(m_SpiralPen, sp);
PerformRendering(graphics, clp);
}
// Spiral and text
else if (rbGeometry1.IsChecked)
{
Geometry text = Text;
Rect textBounds = text.Bounds;
GeometryTransformer transformedText = GeometryMatrix4Transformer.CreateOptimizedTransformer(text,
Matrix4.CreateTranslation(
(m_DrawingPanel.Width - textBounds.Width) / 2 - textBounds.Left,
(m_DrawingPanel.Height - textBounds.Height) / 2 - textBounds.Top));
Geometry sp = GeometryMatrix4Transformer.CreateOptimizedTransformer(Spiral, Matrix4.CreateTranslation(m_X, m_Y));
GeometryStroke stroke = new GeometryStroke(sp, 15);
CombinedGeometry clp = new CombinedGeometry(stroke, transformedText,
CombinedGeometry.CombineMode.Or,
CombinedGeometry.FillType.NonZero,
CombinedGeometry.FillType.NonZero);
graphics.FillGeometry(m_GeometryBColor, transformedText);
graphics.DrawGeometry(m_SpiralPen, sp);
PerformRendering(graphics, clp);
}
}
