1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:
64:
65:
66:
67:
68:
69:
70:
71:
72:
73:
74:
75:
76:
77:
78:
79:
80:
81:
82:
83:
84:
85:
86:
87:
88:
89:
90:
91:
92:
93:
94:
95:
96:
97:
98:
99:
100:
101:
102:
103:
104:
105:
106:
107:
108:
109:
110:
111:
112:
113:
114:
115:
116:
117:
118:
119:
120:
121:
122:
123:
124:
125:
126:
127:
128:
129:
130:
131:

#region Initialisation

public void Initialise(int xRadius, int yRadius) {
    this.xRadius = xRadius;
    this.yRadius = yRadius;

    origin = new Vector2i(xRadius, yRadius);

    int count = 4 * (xRadius + yRadius);
    float angleIncrement = 360.0f / count;

    points = new SortingEllipsePoint[count];

    for (int i = 1; i <= count; i++) {
        points[i - 1] = new SortingEllipsePoint(i, GetEllipsePoint(xRadius, yRadius, origin, i * angleIncrement - 90.0f), Rainbow(i/(float)count));
    }

    SetImage();
}

#endregion

#region Perparation

public void BeginShuffle() {
    new Thread(() => Shuffle()).Start();
}

private void Shuffle() {
    int displayCount = 0;

    for (int i = 0; i < points.Length; i++, displayCount++) {
        SwapPoints(i, rnd.Next(0, points.Length));

        if (displayCount == 30) {
            SetImage();
            displayCount = 0;
        }
    }

    OnShuffleFinish?.Invoke(this, new EventArgs());
}

#endregion

#region Sorting

public void InsertionSort() {

    new Thread(() => {
        for (int i = 1; i < points.Length; i++) {
            SortingEllipsePoint insert = points[i];
            int j = i;

            while (j > 0 && points[j - 1].CompareTo(insert) > 0) {
                Assign(j, points[j - 1]);
                j--;
            }

            Assign(j, insert);
            swapCount++;

            if (swapCount > 20) {
                SetImage();
                swapCount = 0;
            }
        }

        swapCount = 0;
        SetImage();
    }).Start();
}

#endregion

#region Swap and Assign

private void Assign(int from, int to) {
    points[to] = new SortingEllipsePoint(points[from].value, points[to].maxPoint, points[from].color);
    points[to].point = GetPoint(points[to]);
}

private void Assign(int to, SortingEllipsePoint point) {
    points[to] = new SortingEllipsePoint(point.value, points[to].maxPoint, point.color);
    points[to].point = GetPoint(points[to]);
}

private void SwapPoints(int first, int second) {
    SortingEllipsePoint point = points[first];

    points[first] = new SortingEllipsePoint(points[second].value, points[first].maxPoint, points[second].color);
    points[second] = new SortingEllipsePoint(point.value, points[second].maxPoint, point.color);

    points[first].point = GetPoint(points[first]);
    points[second].point = GetPoint(points[second]);
}

private Vector2i GetPoint(SortingEllipsePoint point) {
    float angle = SFMLMath.Angle(point.maxPoint - origin, points[point.value - 1].maxPoint - origin);
    float percent = 1 - (angle / 180.0f);

    Vector2i vector = point.maxPoint - origin;

    return origin + new Vector2i((int)(vector.X * percent), (int)(vector.Y * percent));
}

#endregion

#region Presentation

private void SetImage() {
    Color[,] pixels = new Color[2 * xRadius + 1, 2 * yRadius + 1];

    for (int i = 0; i < points.Length; i++) {
        pixels[points[i].point.X, points[i].point.Y] = points[i].color; <<<------ Hier tritt der Fehler auf
    }

    _image = new Image(pixels);

    OnImageChange?.Invoke(this, new EventArgs());
}

private Vector2i GetEllipsePoint(int dHalfwidthEllipse, int dHalfheightEllipse, Vector2i origin, float t) {
    return new Vector2i((int)(origin.X + dHalfwidthEllipse * Math.Cos(t * Math.PI / 180)), (int)(origin.Y + dHalfheightEllipse * Math.Sin(t * Math.PI / 180)));
}

private Color Rainbow(float progress) {
    // unwichtig
}

#endregion                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:

public class SortingEllipsePoint : IComparable<SortingEllipsePoint> {
    public Vector2i point, maxPoint;
    public SFML.Graphics.Color color;
    public int value;

    public SortingEllipsePoint(int value, Vector2i maxPoint, SFML.Graphics.Color color) {
        this.value = value;
        this.maxPoint = this.point = maxPoint;
        this.color = color;
    }

    public int CompareTo(SortingEllipsePoint obj) {
        return value < obj.value ? -1 : (value > obj.value ? 1 : 0);
    }
}                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:

private void SetImage() {
    lock (lockMe) {
        _image = new Bitmap(width, height);

        for (int i = 0; i < points.Length && points[i] != null; i++) {
            int x = points[i].point.X < 0 ? 0 : (points[i].point.X > width - 1 ? width - 1 : points[i].point.X);
            int y = points[i].point.Y < 0 ? 0 : (points[i].point.Y > height - 1 ? height - 1 : points[i].point.Y);

            _image.SetPixel(x, y, points[i].color);
        }

        OnImageChange?.Invoke(this, new EventArgs());
    }
}                    

1:

VectorMath.Angle(new Point(365, -236), new Point(-365, 236));                    

1:

a = a < -1 ? -1 : (a > 1 ? 1 : a);                    

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:

using System.ComponentModel;
using System.Threading;

private readonly SynchronizationContext syncContext;
public event ImageChangeEventHandler OnImageChange = null;

public Ellipse() {
    syncContext = AsyncOperationManager.SynchronizationContext;
}

private void SetImage() {
    Bitmap image = new Bitmap(width, height);

    // ...

    syncContext.Post(ImageChanged, new ImageChangeEventArgs((Bitmap)image.Clone()));
    image.Dispose();
}

private void ImageChanged(object args) {
    if (!(args is ImageChangeEventArgs))
        return;

    OnImageChange?.Invoke(this, (ImageChangeEventArgs)args);
}