using System; using System.Collections.Generic; using System.Linq; using System.Runtime.CompilerServices; using Avalonia; using Avalonia.Input; using Avalonia.Media; using Avalonia.Platform; using Avalonia.Rendering.SceneGraph; using Avalonia.Skia; using OpenNest.Avalonia.Rendering; using OpenNest.CNC; using OpenNest.Desktop.Rendering; using OpenNest.Geometry; using OpenNest.Support; using SkiaSharp; using Control = Avalonia.Controls.Control; using Vector = OpenNest.Geometry.Vector; namespace OpenNest.Avalonia.Controls { /// /// Draws one plate with Skia as the WinForms plate view does, in the colours of /// : the sheet (or irregular outline), edge spacing, filled parts with their /// numbers, cut-offs, clamps, common lines and the View toggles in . Pans /// with a left or middle drag, zooms at the cursor with the wheel, fits on a double click, and /// highlights the part under the cursor. /// public sealed class PlateCanvas : Control { // Paths are built once per part pose and only read afterwards, so the render thread may draw // them while the UI thread builds others. private readonly Dictionary paths = new(); private readonly Dictionary labelPoints = new(); private readonly ConditionalWeakTable offsets = new(); private readonly SupportAnalysisCache supports = new(); private readonly Dictionary commonLineChecks = new(); private readonly ViewTransform view = new(); private Plate plate; private Point? dragStart; private bool fitPending = true; private sealed record OffsetEntry(CNC.Program Program, double Rotation, double Spacing, double Tolerance, SKPath Path); public Plate Plate { get => plate; set { plate = value; HoveredPart = null; SelectedPart = null; fitPending = true; TrimCache(); InvalidateVisual(); } } /// The colours drawn with: the application's active scheme unless set. public ColorScheme Scheme { get; set; } = ColorScheme.Default; /// The View menu toggles this view draws with. public PlateViewOptions Options { get; set; } = new(); public Part HoveredPart { get; private set; } public Part SelectedPart { get; private set; } /// The cursor in plate coordinates, or null when it is outside the view. public Vector? CursorWorld { get; private set; } /// Pixels per drawing unit. public double Zoom => view.Scale; /// The view's world/screen mapping. public ViewTransform View => view; public event EventHandler ViewChanged; public PlateCanvas() { ClipToBounds = true; Focusable = true; } public void ClearCache() { paths.Clear(); labelPoints.Clear(); commonLineChecks.Clear(); } // Keeps only the shown plate's parts, so closed plates do not hold their paths. private void TrimCache() { if (plate == null) { paths.Clear(); labelPoints.Clear(); return; } var shown = new HashSet(plate.Parts); foreach (var stale in paths.Keys.Where(part => !shown.Contains(part)).ToList()) paths.Remove(stale); var drawings = new HashSet(plate.Parts.Select(part => part.BaseDrawing)); foreach (var stale in labelPoints.Keys.Where(drawing => !drawings.Contains(drawing)).ToList()) labelPoints.Remove(stale); } public void ZoomToFit() { if (!Fit()) return; InvalidateVisual(); ViewChanged?.Invoke(this, EventArgs.Empty); } /// Fits the view to the plate and its parts without requesting a redraw. private bool Fit() { if (plate == null || Bounds.Width <= 0 || Bounds.Height <= 0) return false; view.Resize(Bounds.Width, Bounds.Height); if (!view.ZoomToArea(plate.BoundingBox(true))) return false; fitPending = false; return true; } private Vector ToWorld(Point p) => view.ScreenToWorld(p.X, p.Y); private SKMatrix WorldMatrix => new((float)view.Scale, 0, (float)view.OriginX, 0, (float)-view.Scale, (float)view.OriginY, 0, 0, 1); private PartPaths PathsFor(Part part) { if (!paths.TryGetValue(part, out var result) || !result.Geometry.IsCurrentFor(part)) paths[part] = result = PartPaths.Build(part); return result; } private Vector LabelPoint(Part part) { if (PartLabels.CutOffSegmentPoint(part) is { } cutOff) return cutOff; var drawing = part.BaseDrawing; if (!labelPoints.TryGetValue(drawing, out var cached) || !ReferenceEquals(cached.Program, drawing.Program) || cached.Rotation != drawing.Program.Rotation) { cached = (drawing.Program, drawing.Program.Rotation, PartLabels.LabelPoint(drawing)); labelPoints[drawing] = cached; } return PartLabels.Place(part, cached.Point); } private SKPath OffsetFor(Part part, double spacing, double tolerance) { if (offsets.TryGetValue(part, out var entry) && ReferenceEquals(entry.Program, part.Program) && entry.Rotation == part.Rotation && entry.Spacing == spacing && entry.Tolerance == tolerance) return entry.Path; var polygons = PlateOverlays.OffsetOutline(part, spacing, tolerance); var path = SkiaFigures.Polygons(polygons.Select(p => (IReadOnlyList)p.Vertices)); offsets.AddOrUpdate(part, new OffsetEntry(part.Program, part.Rotation, spacing, tolerance, path)); return path; } public override void Render(DrawingContext context) { // A redraw may not be requested during a render, so tell listeners afterwards. if (fitPending && Fit()) global::Avalonia.Threading.Dispatcher.UIThread.Post(() => ViewChanged?.Invoke(this, EventArgs.Empty)); if (Bounds.Width > 0 && Bounds.Height > 0) view.Resize(Bounds.Width, Bounds.Height); var scene = new Scene { Bounds = new Rect(Bounds.Size), Palette = SkiaSchemePalette.For(Scheme ?? ColorScheme.Default), Matrix = WorldMatrix, Scale = view.Scale, DrawOrigin = Options.DrawOrigin, }; if (plate != null) BuildScene(scene); context.Custom(new PlateDrawOperation(scene)); } private void BuildScene(Scene scene) { var options = Options; var visible = view.VisibleWorld(); scene.Sheet = PlateOverlays.Sheet(plate); if (plate.Outline is { } outline) { scene.SheetOutline = SkiaFigures.Polygons(new[] { PlateOverlays.PlaceOutline(plate, outline.Points) } .Concat(outline.Obstacles.Select(o => PlateOverlays.PlaceOutline(plate, o)))); scene.Obstacles = outline.Obstacles.Count == 0 ? null : SkiaFigures.Polygons(outline.Obstacles.Select(o => PlateOverlays.PlaceOutline(plate, o))); var usable = PlateOverlays.UsableOutline(plate); scene.Usable = usable.Count == 0 ? null : SkiaFigures.Polygons(usable); } else { var edge = PlateOverlays.EdgeSpacing(plate); // As WinForms: the edge-spacing line is left out while it surrounds the whole view. if (!Contains(edge, visible)) scene.EdgeSpacing = edge; } var palette = scene.Palette; for (var i = 0; i < plate.Parts.Count; i++) { var part = plate.Parts[i]; var partPaths = PathsFor(part); var bounds = partPaths.StrokeBounds; var placed = bounds == null ? null : bounds.Translate(part.Location.X, part.Location.Y); if (placed == null || !Intersects(placed, visible)) continue; var color = ToSkColor(part.BaseDrawing.Color); scene.Parts.Add(new PartItem(partPaths, part.Location, placed, color, palette.PartOutline(color), (i + 1).ToString(), LabelPoint(part), ReferenceEquals(part, SelectedPart), ReferenceEquals(part, HoveredPart), part.BaseDrawing.IsCutOff)); } if (options.DrawOffset && plate.PartSpacing > 0) { foreach (var part in plate.Parts) scene.Offsets.Add((OffsetFor(part, plate.PartSpacing, options.OffsetTolerance), part.Location)); } if (options.DrawBounds && SelectedPart != null) scene.SelectionBounds = PlateOverlays.SelectionBounds(new[] { SelectedPart }); if (options.DrawRapid) scene.Rapids = PlateOverlays.Rapids(plate); if (options.DrawPiercePoints) scene.PiercePoints = PlateOverlays.PiercePoints(plate); if (options.DrawCutDirection) scene.Arrows = PlateOverlays.CutDirection(plate, view.LengthToWorld(60)); scene.Clamps = PlateOverlays.Clamps(plate); scene.RemovedClamps = PlateOverlays.RemovedClamps(plate); scene.CutOffStrokes = PlateOverlays.CutOffStrokes(plate); BuildCommonLines(scene); if (options.DrawSupport) BuildSupport(scene); } private void BuildCommonLines(Scene scene) { if (plate.CommonLines is not { Count: > 0 } groups) { commonLineChecks.Clear(); return; } foreach (var stale in commonLineChecks.Keys.Where(group => !groups.Contains(group)).ToList()) commonLineChecks.Remove(stale); foreach (var group in groups) { var state = string.Join(";", group.Members.Select(m => $"{m.Location.X:R},{m.Location.Y:R},{m.Rotation:R},{RuntimeHelpers.GetHashCode(m.BaseDrawing.Program)}")); if (!commonLineChecks.TryGetValue(group, out var cached) || cached.State != state) { cached = (state, CommonLineGeometry.Check(group)); commonLineChecks[group] = cached; } foreach (var path in CommonLineGeometry.Paths(cached.Check.Spans, group.Kerf)) scene.CommonLines.Add(path.Points); foreach (var problem in cached.Check.Problems) { // A copy: moving the part changes its box in place while the render thread draws. var box = problem.Part.BoundingBox; scene.CommonLineProblems.Add(new Box(box.X, box.Y, box.Length, box.Width)); } } } private void BuildSupport(Scene scene) { if (plate.SupportBed is not { } bed) return; // Grid points and slats only while they are at least 6 pixels apart on screen. const double minimumSpacing = 6; if (bed is SupportGrid grid && view.LengthToScreen(System.Math.Min(grid.PitchX, grid.PitchY)) >= minimumSpacing) scene.GridPoints = grid.PointsIn(scene.Sheet, plate.Quadrant); else if (bed is SupportSlats slats && view.LengthToScreen(slats.Pitch) >= minimumSpacing) scene.Slats = slats.SlatsIn(scene.Sheet, plate.Quadrant); var clearance = PlateOverlays.SupportClearance(plate); foreach (var part in plate.Parts) { var support = supports.Analyze(part, bed, plate.Quadrant, clearance); if (support is not { IsComplete: true }) continue; scene.Supports.Add(new SupportItem(support.Contacts, support.CenterOfGravity, support.IsSupported, support.IsSupported ? null : support.BestTabPoint)); } } private static bool Contains(Box outer, Box inner) => inner.Left >= outer.Left && inner.Right <= outer.Right && inner.Bottom >= outer.Bottom && inner.Top <= outer.Top; private static bool Intersects(Box a, Box b) => a.Left <= b.Right && a.Right >= b.Left && a.Bottom <= b.Top && a.Top >= b.Bottom; private static SKColor ToSkColor(System.Drawing.Color color) => color.IsEmpty ? new SKColor(130, 204, 130) : new SKColor(color.R, color.G, color.B, color.A); protected override void OnPointerWheelChanged(PointerWheelEventArgs e) { var at = e.GetPosition(this); view.ZoomAt(new ScreenPoint(at.X, at.Y), System.Math.Pow(1.2, e.Delta.Y)); InvalidateVisual(); ViewChanged?.Invoke(this, EventArgs.Empty); e.Handled = true; } protected override void OnPointerPressed(PointerPressedEventArgs e) { Focus(); var point = e.GetCurrentPoint(this); if (e.ClickCount == 2) { ZoomToFit(); return; } if (point.Properties.IsLeftButtonPressed) { SelectedPart = HitTest(ToWorld(point.Position)); InvalidateVisual(); ViewChanged?.Invoke(this, EventArgs.Empty); } if (point.Properties.IsLeftButtonPressed || point.Properties.IsMiddleButtonPressed) { dragStart = point.Position; e.Pointer.Capture(this); } } protected override void OnPointerMoved(PointerEventArgs e) { var at = e.GetPosition(this); if (dragStart is { } start) { view.Pan(at.X - start.X, at.Y - start.Y); dragStart = at; InvalidateVisual(); } CursorWorld = ToWorld(at); var hovered = dragStart == null ? HitTest(CursorWorld.Value) : HoveredPart; if (!ReferenceEquals(hovered, HoveredPart)) { HoveredPart = hovered; InvalidateVisual(); } ViewChanged?.Invoke(this, EventArgs.Empty); } protected override void OnPointerReleased(PointerReleasedEventArgs e) { dragStart = null; e.Pointer.Capture(null); } protected override void OnPointerExited(PointerEventArgs e) { CursorWorld = null; if (HoveredPart != null) { HoveredPart = null; InvalidateVisual(); } ViewChanged?.Invoke(this, EventArgs.Empty); } protected override void OnKeyDown(KeyEventArgs e) { if (e.Key == Key.F) { ZoomToFit(); e.Handled = true; } } protected override void OnSizeChanged(global::Avalonia.Controls.SizeChangedEventArgs e) { base.OnSizeChanged(e); view.Resize(e.NewSize.Width, e.NewSize.Height); InvalidateVisual(); } /// The topmost part whose material (or, for an etch-only part, closed mark) holds . private Part HitTest(Vector world) { if (plate == null) return null; for (var i = plate.Parts.Count - 1; i >= 0; i--) { var part = plate.Parts[i]; var box = part.BoundingBox; if (world.X < box.Left || world.X > box.Right || world.Y < box.Bottom || world.Y > box.Top) continue; var local = world - part.Location; if (PathsFor(part).Selection.Contains((float)local.X, (float)local.Y)) return part; } return null; } private sealed record PartItem(PartPaths Paths, Vector Location, Box Bounds, SKColor Color, SKColor Outline, string Label, Vector LabelPoint, bool Selected, bool Hovered, bool IsCutOff); private sealed record SupportItem(IReadOnlyList Contacts, Vector CenterOfGravity, bool Supported, Vector? Tab); /// Everything one frame draws, built on the UI thread and only read on the render thread. private sealed class Scene { public Rect Bounds; public SkiaSchemePalette Palette; public SKMatrix Matrix; public double Scale; public bool DrawOrigin; public Box Sheet; public SKPath SheetOutline; public SKPath Obstacles; public SKPath Usable; public Box EdgeSpacing; public readonly List Parts = new(); public readonly List<(SKPath Path, Vector Location)> Offsets = new(); public Box SelectionBounds; public IReadOnlyList Rapids; public IReadOnlyList PiercePoints; public IReadOnlyList Arrows; public IReadOnlyList Clamps; public IReadOnlyList RemovedClamps; public IReadOnlyList CutOffStrokes; public readonly List> CommonLines = new(); public readonly List CommonLineProblems = new(); public IReadOnlyList GridPoints; public IReadOnlyList Slats; public readonly List Supports = new(); } private sealed class PlateDrawOperation : ICustomDrawOperation { private readonly Scene scene; public PlateDrawOperation(Scene scene) { this.scene = scene; } public Rect Bounds => scene.Bounds; public bool HitTest(Point p) => Bounds.Contains(p); public bool Equals(ICustomDrawOperation other) => false; public void Dispose() { } public void Render(ImmediateDrawingContext context) { var lease = context.TryGetFeature(); if (lease == null) return; using var api = lease.Lease(); var canvas = api.SkCanvas; canvas.Save(); canvas.ClipRect(new SKRect(0, 0, (float)Bounds.Width, (float)Bounds.Height)); canvas.Clear(scene.Palette.Background); new PlatePainter(canvas, scene).Paint(); canvas.Restore(); } } /// /// Paints a scene in the WinForms view's order and pen sizes: widths and dashes are screen /// pixels, so parts drawn in world units scale them by the zoom. /// private sealed class PlatePainter { private static readonly SKColor LeadColor = new(255, 69, 0); // OrangeRed private static readonly SKColor DisplayColor = new(70, 110, 140); private static readonly SKColor OffsetColor = new(255, 100, 100, 120); private static readonly SKColor CutDirectionColor = new(60, 60, 60); private static readonly SKColor PierceFill = new(255, 0, 0); private static readonly SKColor PierceOutline = new(139, 0, 0); // DarkRed private static readonly SKColor ClampHatch = new(70, 80, 90, 150); private static readonly SKColor ClampBack = new(230, 170, 40, 70); private static readonly SKColor ClampOutline = new(150, 100, 0, 220); private static readonly SKColor RemovedClampOutline = new(110, 110, 110, 200); private static readonly SKColor ObstacleHatch = new(120, 60, 60, 170); private static readonly SKColor ObstacleBack = new(200, 80, 80, 60); private static readonly SKColor CutOffColor = new(255, 69, 0); // OrangeRed private static readonly SKColor CommonLineColor = new(0, 150, 136); private static readonly SKColor BrokenCommonLineColor = new(255, 0, 0); private static readonly SKColor GridColor = new(120, 120, 120, 110); private static readonly SKColor SlatColor = new(120, 120, 120, 90); private static readonly SKColor ContactColor = new(30, 150, 60, 220); private static readonly SKColor SupportedColor = new(20, 140, 50, 230); private static readonly SKColor TippingColor = new(210, 30, 30, 240); private static readonly SKColor TabColor = new(240, 140, 0, 240); // The WinForms default font, bold and underlined, for part numbers. private static readonly SKTypeface LabelTypeface = SKTypeface.FromFamilyName(null, SKFontStyle.Bold) ?? SKTypeface.Default; private readonly SKCanvas canvas; private readonly Scene scene; // Not readonly: SKCanvas.Concat takes it by reference. private SKMatrix matrix; private readonly float scale; public PlatePainter(SKCanvas canvas, Scene scene) { this.canvas = canvas; this.scene = scene; matrix = scene.Matrix; scale = (float)scene.Scale; } private SKPoint Screen(Vector world) => matrix.MapPoint((float)world.X, (float)world.Y); private SKRect Screen(Box box) { var a = Screen(new Vector(box.Left, box.Top)); var b = Screen(new Vector(box.Right, box.Bottom)); return new SKRect(System.Math.Min(a.X, b.X), System.Math.Min(a.Y, b.Y), System.Math.Max(a.X, b.X), System.Math.Max(a.Y, b.Y)); } private static SKPaint Stroke(SKColor color, float width = 1, float[] dash = null) => new() { Style = SKPaintStyle.Stroke, Color = color, StrokeWidth = width, IsAntialias = true, PathEffect = dash == null ? null : SKPathEffect.CreateDash(dash, 0), }; private static SKPaint Fill(SKColor color) => new() { Style = SKPaintStyle.Fill, Color = color, IsAntialias = true }; // A pen of screen width in the world frame: width 1 stays a one-pixel hairline. private SKPaint WorldStroke(SKColor color, float width = 1, float[] dash = null) => Stroke(color, width <= 1 && dash == null ? 0 : width / scale, dash?.Select(d => d / scale).ToArray()); public void Paint() { if (scene.DrawOrigin) { using var origin = Stroke(scene.Palette.Origin); origin.IsAntialias = false; var o = Screen(Vector.Zero); canvas.DrawLine(o.X, 0, o.X, (float)scene.Bounds.Height, origin); canvas.DrawLine(0, o.Y, (float)scene.Bounds.Width, o.Y, origin); } if (scene.Sheet == null) return; DrawSheet(); DrawParts(); DrawOffsets(); if (scene.SelectionBounds != null) { using var pen = Stroke(scene.Palette.BoundingBox); canvas.DrawRect(Screen(scene.SelectionBounds), pen); } DrawRapids(); DrawPiercePoints(); DrawCutDirection(); DrawClamps(); DrawCutOffs(); DrawCommonLines(); DrawSupport(); } private void DrawSheet() { var palette = scene.Palette; canvas.Save(); canvas.Concat(ref matrix); using var sheetFill = Fill(palette.PlateFill); if (scene.SheetOutline != null) { canvas.DrawPath(scene.SheetOutline, sheetFill); canvas.Restore(); if (scene.Obstacles != null) { HatchPath(scene.Obstacles, ObstacleHatch, ObstacleBack); using var obstaclePen = WorldStroke(ObstacleHatch, 1.5f); DrawWorld(scene.Obstacles, obstaclePen); } if (scene.Usable != null) { using var usablePen = WorldStroke(palette.EdgeSpacing, 1, new float[] { 3, 3 }); DrawWorld(scene.Usable, usablePen); } using var outlinePen = WorldStroke(palette.PlateOutline); DrawWorld(scene.SheetOutline, outlinePen); return; } var sheet = scene.Sheet; canvas.DrawRect(new SKRect((float)sheet.Left, (float)sheet.Bottom, (float)sheet.Right, (float)sheet.Top), sheetFill); canvas.Restore(); if (scene.EdgeSpacing != null) { using var edgePen = Stroke(palette.EdgeSpacing, 1, new float[] { 3, 3 }); edgePen.IsAntialias = false; canvas.DrawRect(Screen(scene.EdgeSpacing), edgePen); } using var outline = Stroke(palette.PlateOutline); outline.IsAntialias = false; canvas.DrawRect(Screen(sheet), outline); } private void DrawWorld(SKPath path, SKPaint paint) { canvas.Save(); canvas.Concat(ref matrix); canvas.DrawPath(path, paint); canvas.Restore(); } // GDI+ WideUpwardDiagonal: three-pixel "/" stripes every eight pixels, in screen space. private void HatchPath(SKPath worldPath, SKColor hatch, SKColor back) { using var screenPath = new SKPath(worldPath); screenPath.Transform(matrix); using var shader = HatchShader(hatch, back); using var paint = new SKPaint { Style = SKPaintStyle.Fill, Shader = shader }; canvas.DrawPath(screenPath, paint); } private void HatchRect(SKRect rect, SKColor hatch, SKColor back) { using var shader = HatchShader(hatch, back); using var paint = new SKPaint { Style = SKPaintStyle.Fill, Shader = shader }; canvas.DrawRect(rect, paint); } private static SKShader HatchShader(SKColor hatch, SKColor back) { using var bitmap = new SKBitmap(8, 8, SKColorType.Rgba8888, SKAlphaType.Unpremul); for (var y = 0; y < 8; y++) for (var x = 0; x < 8; x++) bitmap.SetPixel(x, y, (x + y) % 8 < 3 ? hatch : back); return SKShader.CreateBitmap(bitmap, SKShaderTileMode.Repeat, SKShaderTileMode.Repeat); } private void DrawParts() { var palette = scene.Palette; using var fill = Fill(SKColors.Black); using var cut = WorldStroke(SKColors.Black); using var etch = WorldStroke(palette.Etch, 1.5f); using var lead = WorldStroke(LeadColor, 1.5f); using var display = WorldStroke(DisplayColor, 1, new float[] { 6, 3 }); using var text = new SKPaint { Color = SKColors.Black, IsAntialias = true, TextSize = 11, Typeface = LabelTypeface, TextAlign = SKTextAlign.Center, }; using var underline = Stroke(SKColors.Black); var metrics = text.FontMetrics; var textHeight = metrics.Descent - metrics.Ascent; foreach (var item in scene.Parts) { canvas.Save(); canvas.Concat(ref matrix); canvas.Translate((float)item.Location.X, (float)item.Location.Y); fill.Color = item.Selected ? palette.SelectedFill : item.Hovered ? Lighten(item.Color) : item.Color; canvas.DrawPath(item.Paths.Material, fill); if (item.Paths.Display != null) canvas.DrawPath(item.Paths.Display, display); canvas.DrawPath(item.Paths.Etch, etch); // Keep real cuts visible even where an etch overlaps them. cut.Color = item.Selected ? palette.SelectedOutline : item.Outline; canvas.DrawPath(item.Paths.Cut, cut); // As on the desktop, only manually placed lead-ins are shown. canvas.DrawPath(item.Paths.Lead, lead); canvas.Restore(); // A number shows only once the part is big enough on screen to hold it. if (item.IsCutOff) continue; var bounds = Screen(item.Bounds); var width = text.MeasureText(item.Label); if (bounds.Width < width || bounds.Height < textHeight) continue; var at = Screen(item.LabelPoint); var baseline = at.Y - (metrics.Ascent + metrics.Descent) / 2; canvas.DrawText(item.Label, at.X, baseline, text); var lineY = baseline + System.Math.Max(1, metrics.UnderlinePosition ?? 1.5f); canvas.DrawLine(at.X - width / 2, lineY, at.X + width / 2, lineY, underline); } } private void DrawOffsets() { if (scene.Offsets.Count == 0) return; using var pen = WorldStroke(OffsetColor); foreach (var (path, location) in scene.Offsets) { canvas.Save(); canvas.Concat(ref matrix); canvas.Translate((float)location.X, (float)location.Y); canvas.DrawPath(path, pen); canvas.Restore(); } } private void DrawRapids() { if (scene.Rapids == null) return; using var pen = Stroke(scene.Palette.Rapid, 1, new float[] { 10, 10 }); foreach (var segment in scene.Rapids) canvas.DrawLine(Screen(segment.From), Screen(segment.To), pen); } private void DrawPiercePoints() { if (scene.PiercePoints == null) return; using var fill = Fill(PierceFill); using var pen = Stroke(PierceOutline); foreach (var point in scene.PiercePoints) { var p = Screen(point); canvas.DrawCircle(p, 2, fill); canvas.DrawCircle(p, 2, pen); } } private void DrawCutDirection() { if (scene.Arrows == null) return; const float size = 6; using var pen = Stroke(CutDirectionColor, 1.5f); foreach (var sample in scene.Arrows) { var tip = Screen(sample.Position); // Screen space flips Y, so the screen angle mirrors the world tangent. var angle = System.Math.Atan2(-sample.Direction.Y, sample.Direction.X); foreach (var side in new[] { 0.5, -0.5 }) { var a = angle + System.Math.PI + side; canvas.DrawLine(tip.X + size * (float)System.Math.Cos(a), tip.Y + size * (float)System.Math.Sin(a), tip.X, tip.Y, pen); } } } // Machine clamps are fixtures, not material: a translucent hatched amber keep-out. private void DrawClamps() { using var outline = Stroke(ClampOutline, 1.5f); foreach (var clamp in scene.Clamps) { var rect = Screen(clamp); HatchRect(rect, ClampHatch, ClampBack); canvas.DrawRect(rect, outline); } using var removed = Stroke(RemovedClampOutline, 1.5f, new float[] { 4.5f, 1.5f }); using var text = new SKPaint { Color = RemovedClampOutline, IsAntialias = true, TextSize = 9 }; foreach (var clamp in scene.RemovedClamps) { var rect = Screen(clamp); canvas.DrawRect(rect, removed); canvas.DrawText("remove", rect.Left, rect.Top - text.FontMetrics.Descent, text); } } // Scrap cut-off lines stand out from the dark part outlines: a saturated orange-red dash. private void DrawCutOffs() { using var pen = Stroke(CutOffColor, 2, new float[] { 6, 2 }); foreach (var stroke in scene.CutOffStrokes) canvas.DrawLine(Screen(stroke.StartPoint), Screen(stroke.EndPoint), pen); // Each segment's number over the line, on a disc of the line's colour. using var disc = Fill(CutOffColor); using var text = new SKPaint { Color = SKColors.White, IsAntialias = true, TextSize = 11, Typeface = LabelTypeface, TextAlign = SKTextAlign.Center, }; var metrics = text.FontMetrics; var textHeight = metrics.Descent - metrics.Ascent; foreach (var item in scene.Parts) { if (!item.IsCutOff) continue; var bounds = Screen(item.Bounds); var diameter = System.Math.Max(text.MeasureText(item.Label), textHeight) + 2; if (System.Math.Max(bounds.Width, bounds.Height) < diameter) continue; var at = Screen(item.LabelPoint); canvas.DrawCircle(at, diameter / 2, disc); canvas.DrawText(item.Label, at.X, at.Y - (metrics.Ascent + metrics.Descent) / 2, text); } } private void DrawCommonLines() { using var pen = Stroke(CommonLineColor, 2, new float[] { 6, 2 }); foreach (var points in scene.CommonLines) for (var i = 1; i < points.Count; i++) canvas.DrawLine(Screen(points[i - 1]), Screen(points[i]), pen); using var broken = Stroke(BrokenCommonLineColor, 2); foreach (var box in scene.CommonLineProblems) canvas.DrawRect(Screen(box), broken); } private void DrawSupport() { if (scene.GridPoints != null) { // Whole-pixel squares, not anti-aliased dots, so every point is the same size. using var grid = new SKPaint { Style = SKPaintStyle.Fill, Color = GridColor, IsAntialias = false }; foreach (var point in scene.GridPoints) { var p = Screen(point); var x = (float)System.Math.Round(p.X) - 1; var y = (float)System.Math.Round(p.Y) - 1; canvas.DrawRect(x, y, 3, 3, grid); } } if (scene.Slats != null) { using var slat = new SKPaint { Style = SKPaintStyle.Fill, Color = SlatColor, IsAntialias = false }; foreach (var box in scene.Slats) { var rect = Screen(box); // At least a pixel wide however far out the view is. if (rect.Width < 1) rect = new SKRect(rect.MidX - 0.5f, rect.Top, rect.MidX + 0.5f, rect.Bottom); if (rect.Height < 1) rect = new SKRect(rect.Left, rect.MidY - 0.5f, rect.Right, rect.MidY + 0.5f); canvas.DrawRect(rect, slat); } } using var contact = Fill(ContactColor); using var supported = Stroke(SupportedColor, 2); using var tipping = Stroke(TippingColor, 2); using var tab = Fill(TabColor); foreach (var item in scene.Supports) { foreach (var point in item.Contacts) canvas.DrawCircle(Screen(point), 2.5f, contact); const float size = 6; var c = Screen(item.CenterOfGravity); var pen = item.Supported ? supported : tipping; canvas.DrawCircle(c, size, pen); canvas.DrawLine(c.X - size, c.Y, c.X + size, c.Y, pen); canvas.DrawLine(c.X, c.Y - size, c.X, c.Y + size, pen); if (item.Tab is { } point2) { const float d = 5; var t = Screen(point2); using var diamond = new SKPath(); diamond.MoveTo(t.X, t.Y - d); diamond.LineTo(t.X + d, t.Y); diamond.LineTo(t.X, t.Y + d); diamond.LineTo(t.X - d, t.Y); diamond.Close(); canvas.DrawPath(diamond, tab); } } } private static SKColor Lighten(SKColor c) => new((byte)(c.Red + (255 - c.Red) / 2), (byte)(c.Green + (255 - c.Green) / 2), (byte)(c.Blue + (255 - c.Blue) / 2), c.Alpha); } } }