c - master - dashytka/Practice-Visualization

200 строк6 KB
dashytka
create c#
05 дек 2025, 21:01
05 дек 2025, 21:01489a551
using System;
using System.Globalization;
using Avalonia;
using Avalonia.Input;
using Avalonia.Media;

namespace Manipulation;

public static class VisualizerTask
{
    public static double X = 220;
    public static double Y = -100;
    public static double Alpha = 0.05;
    public static double Wrist = 2 * Math.PI / 3;
    public static double Elbow = 3 * Math.PI / 4;
    public static double Shoulder = Math.PI / 2;

    public static Brush UnreachableAreaBrush = 
        new SolidColorBrush(Color.FromArgb(255, 255, 230, 230));
    
    public static Brush ReachableAreaBrush = 
        new SolidColorBrush(Color.FromArgb(255, 230, 255, 230));
    
    public static Pen ManipulatorPen = new Pen(Brushes.Black, 3);
    public static Brush JointBrush = new SolidColorBrush(Colors.Gray);

    private const double AngleStep = 0.05;
    private const double JointRadius = 5;

    public static void KeyDown(Visual visual, KeyEventArgs key)
    {
        var keyPressed = key.Key;
        if (keyPressed == Key.Q)
            Shoulder += AngleStep;
        else if (keyPressed == Key.A)
            Shoulder -= AngleStep;
        else if (keyPressed == Key.W)
            Elbow += AngleStep;
        else if (keyPressed == Key.S)
            Elbow -= AngleStep;
        else
            return;

        Wrist = -Alpha - Shoulder - Elbow;
        visual.InvalidateVisual();
    }

    public static void MouseMove(Visual visual, PointerEventArgs e)
    {
        var shoulderPos = GetShoulderPos(visual);
        var windowPoint = e.GetPosition(visual);
        var mathPoint = ConvertWindowToMath(windowPoint, shoulderPos);
        
        X = mathPoint.X;
        Y = mathPoint.Y;
        
        UpdateManipulator();
        visual.InvalidateVisual();
    }

    public static void MouseWheel(Visual visual, PointerWheelEventArgs e)
    {
        Alpha += e.Delta.Y * 0.05;
        
        UpdateManipulator();
        visual.InvalidateVisual();
    }

    public static void UpdateManipulator()
    {
        var result = ManipulatorTask.MoveManipulatorTo(X, Y, Alpha);
        
        if (result.Length >= 3 && 
            !double.IsNaN(result[0]) && 
            !double.IsNaN(result[1]) && 
            !double.IsNaN(result[2]))
        {
            Shoulder = result[0];
            Elbow = result[1];
            Wrist = result[2];
        }
    }

    public static void DrawManipulator(DrawingContext context, Point shoulderPos)
    {
        var joints = GetJointPoints();
        DrawReachableZone(context, shoulderPos, joints);
        DrawCoordinatesText(context);
        DrawManipulatorLinesAndJoints(context, shoulderPos, joints);
    }

    private static Point[] GetJointPoints()
    {
        var joints = AnglesToCoordinatesTask.GetJointPositions(
            Shoulder, Elbow, Wrist);
        
        return new Point[]
        {
            new Point(joints[0].X, joints[0].Y),
            new Point(joints[1].X, joints[1].Y),
            new Point(joints[2].X, joints[2].Y)
        };
    }

    private static void DrawCoordinatesText(DrawingContext context)
    {
        var formattedText = CreateFormattedText();
        context.DrawText(formattedText, new Point(10, 10));
    }

    private static FormattedText CreateFormattedText()
    {
        return new FormattedText(
            $"X={X:0}, Y={Y:0}, Alpha={Alpha:0.00}",
            CultureInfo.InvariantCulture,
            FlowDirection.LeftToRight,
            Typeface.Default,
            18,
            Brushes.DarkRed
        )
        {
            TextAlignment = TextAlignment.Center
        };
    }

    private static void DrawManipulatorLinesAndJoints(
        DrawingContext context, Point shoulderPos, Point[] jointPoints)
    {
        var windowPositions = GetWindowPositions(jointPoints, shoulderPos);
        DrawLines(context, shoulderPos, windowPositions);
        DrawJoints(context, windowPositions);
    }

    private static Point[] GetWindowPositions(
        Point[] jointPoints, Point shoulderPos)
    {
        return new Point[]
        {
            ConvertMathToWindow(jointPoints[0], shoulderPos),
            ConvertMathToWindow(jointPoints[1], shoulderPos),
            ConvertMathToWindow(jointPoints[2], shoulderPos)
        };
    }

    private static void DrawLines(
        DrawingContext context, Point shoulderPos, Point[] windowPositions)
    {
        context.DrawLine(ManipulatorPen, shoulderPos, windowPositions[0]);
        context.DrawLine(ManipulatorPen, windowPositions[0], windowPositions[1]);
        context.DrawLine(ManipulatorPen, windowPositions[1], windowPositions[2]);
    }

    private static void DrawJoints(DrawingContext context, Point[] windowPositions)
    {
        context.DrawEllipse(
            JointBrush, null, windowPositions[0], JointRadius, JointRadius);
        context.DrawEllipse(
            JointBrush, null, windowPositions[1], JointRadius, JointRadius);
        context.DrawEllipse(
            JointBrush, null, windowPositions[2], JointRadius, JointRadius);
    }

    private static void DrawReachableZone(
        DrawingContext context, Point shoulderPos, Point[] joints)
    {
        var rmin = Math.Abs(Manipulator.UpperArm - Manipulator.Forearm);
        var rmax = Manipulator.UpperArm + Manipulator.Forearm;
        var mathCenter = new Point(
            joints[2].X - joints[1].X, 
            joints[2].Y - joints[1].Y);
        var windowCenter = ConvertMathToWindow(mathCenter, shoulderPos);
        
        context.DrawEllipse(
            ReachableAreaBrush, null, 
            new Point(windowCenter.X, windowCenter.Y), rmax, rmax);
            
        context.DrawEllipse(
            UnreachableAreaBrush, null, 
            new Point(windowCenter.X, windowCenter.Y), rmin, rmin);
    }

    public static Point GetShoulderPos(Visual visual)
    {
        return new Point(visual.Bounds.Width / 2, visual.Bounds.Height / 2);
    }

    public static Point ConvertMathToWindow(Point mathPoint, Point shoulderPos)
    {
        return new Point(
            mathPoint.X + shoulderPos.X, 
            shoulderPos.Y - mathPoint.Y);
    }

    public static Point ConvertWindowToMath(Point windowPoint, Point shoulderPos)
    {
        return new Point(
            windowPoint.X - shoulderPos.X, 
            shoulderPos.Y - windowPoint.Y);
    }
}