/// <summary>
/// Invalidates the geometry of this shape.
/// </summary>
protected void InvalidateGeometry()
{
_renderedGeometry = null;
_definingGeometry = null;
InvalidateMeasure();
}
public WorkTask(Guid mRID, Project project, string name, Geometry?location = null)
{
MRID = mRID;
Project = project;
Name = name;
Location = location;
}
internal Visual(XmlNode node)
{
Name = node.Attributes?["name"]?.Value;
Geometry?geometry = null;
foreach (XmlNode child in node.ChildNodes)
{
switch (child.Name)
{
case "cast_shadows":
CastShadows = BoolElement.ValueOf(child);
break;
case "transparency":
Transparency = DoubleElement.ValueOf(child);
break;
case "pose":
Pose = new Pose(child);
break;
case "material":
Material = new Material(child);
break;
case "geometry":
geometry = new Geometry(child);
break;
}
}
Geometry = geometry ?? throw new MalformedSdfException(node, "Expected geometry!");
HasUri = Geometry.HasUri;
}
internal Visual(XmlNode node)
{
Name = node.Attributes?["name"]?.Value;
Geometry?geometry = null;
Origin? origin = null;
foreach (XmlNode child in node.ChildNodes)
{
switch (child.Name)
{
case "origin":
origin = new Origin(child);
break;
case "geometry":
geometry = new Geometry(child);
break;
case "material":
Material = new Material(child);
break;
}
}
Geometry = geometry ?? throw new MalformedUrdfException(node);
Origin = origin ?? Origin.Identity;
}
private static LogEventProperty?WriteBBox(Envelope?value, Geometry?geometry)
{
// if we don't want to write "null" bounding boxes, bail out.
if (value == null || value.IsNull)
{
return(null);
}
// Don't clutter export with bounding box if geometry is a point!
if (geometry is Point)
{
return(null);
}
return(new LogEventProperty(
"bbox",
value.IsNull
? new ScalarValue(null)
: new SequenceValue(
new[]
{
new ScalarValue(value.MinX),
new ScalarValue(value.MinY),
new ScalarValue(value.MaxX),
new ScalarValue(value.MaxY),
}
)
));
}
public CombinedGeometry(
GeometryCombineMode combineMode,
Geometry?geometry1,
Geometry?geometry2,
Transform?transform)
{
Geometry1 = geometry1;
Geometry2 = geometry2;
GeometryCombineMode = combineMode;
Transform = transform;
}
protected override Size ArrangeOverride(Size finalSize)
{
EnsureFormattedText();
// update the formatted text with the final size
_FormattedText !.MaxTextWidth = finalSize.Width;
_FormattedText.MaxTextHeight = Math.Max(0.0001d, finalSize.Height);
// need to re-generate the geometry now that the dimensions have changed
_TextGeometry = null;
UpdatePen();
return(finalSize);
}
private void UpdateCropGeometry(Geometry?geo = null)
{
Geometry newGeo = geo ?? Geometry.Blank;
if (geo == null)
{
newGeo.X = (double)NumX.Value;
newGeo.Y = (double)NumY.Value;
newGeo.Width = (double)NumWidth.Value;
newGeo.Height = (double)NumHeight.Value;
}
Scanner.CropGeometry = newGeo.Min(maxGeometry).Max(minGeometry);
Scanner.UpdateCropGeometry();
RefreshThumbnail();
}
private void EnsureGeometry()
{
if (_TextGeometry != null)
{
return;
}
EnsureFormattedText();
_TextGeometry = _FormattedText !.BuildGeometry(new Point(0, 0));
if (StrokePosition == StrokePosition.Outside)
{
var boundsGeo = new RectangleGeometry(new Rect(0, 0, ActualWidth, ActualHeight));
_clipGeometry = Geometry.Combine(boundsGeo, _TextGeometry, GeometryCombineMode.Exclude, null);
}
}
private static GeometryBase?Transform(Geometry?geometry)
{
if (geometry == null)
{
return(null);
}
return(geometry.Type switch
{
"Point" => ToPointGeometry((JArray)geometry.Coordinates),
"MultiPoint" => ToMultiPointGeometry((JArray)geometry.Coordinates),
"LineString" => ToLineStringGeometry((JArray)geometry.Coordinates),
"MultiLineString" => ToMultiLineStringGeometry((JArray)geometry.Coordinates),
"Polygon" => ToPolygonGeometry((JArray)geometry.Coordinates),
"MultiPolygon" => ToMultiPolygonGeometry((JArray)geometry.Coordinates),
_ => null,
});
private static void Draw(SKCanvas canvas, IReadOnlyViewport viewport, IStyle style, float layerOpacity,
IFeature feature, Geometry?geometry, SymbolCache symbolCache)
{
if (geometry is Point point)
{
PointRenderer.Draw(canvas, viewport, style, feature, point.X, point.Y, symbolCache,
layerOpacity * style.Opacity);
}
else if (geometry is MultiPoint multiPoint)
{
MultiPointRenderer.Draw(canvas, viewport, style, feature, multiPoint,
symbolCache, layerOpacity * style.Opacity);
}
else if (geometry is LineString lineString)
{
LineStringRenderer.Draw(canvas, viewport, style, feature, lineString,
layerOpacity * style.Opacity);
}
else if (geometry is MultiLineString multiLineString)
{
MultiLineStringRenderer.Draw(canvas, viewport, style, feature, multiLineString,
layerOpacity * style.Opacity);
}
else if (geometry is Polygon polygon)
{
PolygonRenderer.Draw(canvas, viewport, style, feature, polygon,
layerOpacity * style.Opacity, symbolCache);
}
else if (geometry is MultiPolygon multiPolygon)
{
MultiPolygonRenderer.Draw(canvas, viewport, style, feature, multiPolygon,
layerOpacity * style.Opacity, symbolCache);
}
else if (geometry is GeometryCollection collection)
{
for (var i = 0; i < collection.NumGeometries; i++)
{
Draw(canvas, viewport, style, layerOpacity, feature, collection.GetGeometryN(i), symbolCache);
}
}
else
{
Logger.Log(LogLevel.Warning,
$"Failed to find renderer for geometry feature of type {geometry?.GetType()}");
}
}
private void CreateCustomGeometry(double deflateAmount)
{
try
{
double width = Led.RgbLed.Size.Width - deflateAmount;
double height = Led.RgbLed.Size.Height - deflateAmount;
// DisplayGeometry = Geometry.Parse(Led.RgbLed.ShapeData);
DisplayGeometry = Geometry.Combine(
Geometry.Empty,
Geometry.Parse(Led.RgbLed.ShapeData),
GeometryCombineMode.Union,
new TransformGroup
{
Children = new TransformCollection
{
new ScaleTransform(width, height),
new TranslateTransform(deflateAmount / 2, deflateAmount / 2)
}
}
);
if (DisplayGeometry.Bounds.Width > width)
{
DisplayGeometry = Geometry.Combine(Geometry.Empty, DisplayGeometry, GeometryCombineMode.Union, new TransformGroup
{
Children = new TransformCollection {
new ScaleTransform(width / DisplayGeometry.Bounds.Width, 1)
}
});
}
if (DisplayGeometry.Bounds.Height > height)
{
DisplayGeometry = Geometry.Combine(Geometry.Empty, DisplayGeometry, GeometryCombineMode.Union, new TransformGroup
{
Children = new TransformCollection {
new ScaleTransform(1, height / DisplayGeometry.Bounds.Height)
}
});
}
}
catch (Exception)
{
CreateRectangleGeometry();
}
}
public bool SetProperties(Rect rect, bool visible, bool overwriteMode)
{
var samePos = this.rect == rect && this.visible == visible;
if (samePos && IsOverwriteMode == overwriteMode)
{
return(false);
}
if (!samePos)
{
geometry = null;
}
this.rect = rect;
this.visible = visible;
IsOverwriteMode = overwriteMode;
return(true);
}
private Size CalculateShapeSizeAndSetTransform(Size availableSize)
{
if (DefiningGeometry != null)
{
// This should probably use GetRenderBounds(strokeThickness) but then the calculations
// will multiply the stroke thickness as well, which isn't correct.
var(size, transform) = CalculateSizeAndTransform(availableSize, DefiningGeometry.Bounds, Stretch);
if (_transform != transform)
{
_transform = transform;
_renderedGeometry = null;
}
return(size);
}
return(Size.Empty);
}
internal Collision(XmlNode node)
{
Name = node.Attributes?["name"]?.Value;
Origin?origin = null;
foreach (XmlNode child in node.ChildNodes)
{
switch (child.Name)
{
case "origin":
origin = new Origin(child);
break;
case "geometry":
Geometry = new Geometry(child);
break;
}
}
Origin = origin ?? Origin.Identity;
}
public static Geometry?DeleteCoordinate(this Geometry?geometry, int index)
{
if (geometry is null)
{
return(null);
}
var vertices = geometry.MainCoordinates();
vertices.RemoveAt(index);
if (geometry is Polygon)
{
return(vertices.ToPolygon());
}
else if (geometry is LineString)
{
return(vertices.ToLineString());
}
else
{
throw new NotSupportedException();
}
}
public static Geometry?InsertCoordinate(this Geometry?geometry, Coordinate coordinate, int segment)
{
if (geometry is null)
{
return(null);
}
var vertices = geometry.MainCoordinates();
vertices.Insert(segment + 1, coordinate);
if (geometry is Polygon)
{
return(vertices.ToPolygon());
}
else if (geometry is LineString)
{
return(vertices.ToLineString());
}
else
{
throw new NotSupportedException();
}
}
/// <summary>Helper for setting <see cref="GeometryProperty"/> on <paramref name="element"/>.</summary>
/// <param name="element"><see cref="FrameworkElement"/> to set <see cref="GeometryProperty"/> on.</param>
/// <param name="value">Geometry property value.</param>
public static void SetGeometry(this FrameworkElement element, Geometry?value)
{
element.SetValue(GeometryProperty, value);
}
public GeometryFeature(Geometry?geometry)
{
Geometry = geometry;
}
private void CreateKeyCapGeometry()
{
DisplayGeometry = new RectangleGeometry(new Rect(1, 1, Led.RgbLed.Size.Width - 2, Led.RgbLed.Size.Height - 2), 1.6, 1.6);
}
private void CreateCircleGeometry()
{
DisplayGeometry = new EllipseGeometry(new Rect(0.5, 0.5, Led.RgbLed.Size.Width - 1, Led.RgbLed.Size.Height - 1));
}
public CombinedGeometry(GeometryCombineMode combineMode, Geometry?geometry1, Geometry?geometry2)
{
Geometry1 = geometry1;
Geometry2 = geometry2;
GeometryCombineMode = combineMode;
}
