gedrehte Ellipse (2 Brennpunke, Höhe) zeichnen

nachdem ich sehr lange erfolglos nach einer funktion gesucht habe, die eine gedrehte
ellipse zeichnet, welche durch zwei Brennpunkte und der Höhe definiert wird,
programmierte ich selbst. Für alle die sich dies ersparen möchten:

 
       private Point[] getEllipse(Point brennpunkt1, Point brennpunkt2, double Höhe, int dämmungsfaktor)
        {
            int x1, y1, x2, y2;
            double b = Höhe;

            if (dämmungsfaktor < 1)
            {
                dämmungsfaktor = 1;
            }

            if (brennpunkt1.X < brennpunkt2.X)
            {
                x1 = brennpunkt1.X;
                y1 = brennpunkt1.Y;
                x2 = brennpunkt2.X;
                y2 = brennpunkt2.Y;
            }
            else
            {
                x2 = brennpunkt1.X;
                y2 = brennpunkt1.Y;
                x1 = brennpunkt2.X;
                y1 = brennpunkt2.Y;
            }

            int brennpunktabstand = Convert.ToInt32(Math.Sqrt(Math.Pow((x1 - x2), 2) + Math.Pow((y1 - y2), 2)));
            int a = Convert.ToInt32(Math.Sqrt(Math.Pow(brennpunktabstand / 2, 2) + Math.Pow(b, 2)));

            Point[] points4 = new Point[a];
            Point[] points3 = new Point[a];
            Point[] points1 = new Point[a];
            Point[] points2 = new Point[a];
            Point[] pointstogether = new Point[4 * a];

            double xkoordinate, ykoordinate;

            for (int i = 0; i < a; i++)
            {
                xkoordinate = i + 1;
                ykoordinate = (b / a) * Math.Sqrt((-1 * Math.Pow(xkoordinate, 2)) + Math.Pow(a, 2));
                points4[i].X = Convert.ToInt32(xkoordinate + a);
                points4[i].Y = Convert.ToInt32(ykoordinate) + Convert.ToInt32(b);

                xkoordinate = i + 1;
                ykoordinate = -(b / a) * Math.Sqrt((-1 * Math.Pow(xkoordinate, 2)) + Math.Pow(a, 2));
                points1[i].X = Convert.ToInt32(xkoordinate + a);
                points1[i].Y = Convert.ToInt32(ykoordinate) + Convert.ToInt32(b);

                xkoordinate = -i - 1;
                ykoordinate = -(b / a) * Math.Sqrt((-1 * Math.Pow(xkoordinate, 2)) + Math.Pow(a, 2));
                points2[i].X = Convert.ToInt32(xkoordinate + a);
                points2[i].Y = Convert.ToInt32(ykoordinate) + Convert.ToInt32(b);

                xkoordinate = -i - 1;
                ykoordinate = (b / a) * Math.Sqrt((-1 * Math.Pow(xkoordinate, 2)) + Math.Pow(a, 2));
                points3[i].X = Convert.ToInt32(xkoordinate + a);
                points3[i].Y = Convert.ToInt32(ykoordinate) + Convert.ToInt32(b);

            }

            int j = a - 1;
            for (int i = 0; i < a; i++)
            {
                pointstogether[i].X = points1[i].X;
                pointstogether[i].Y = points1[i].Y - Convert.ToInt32(b);
                pointstogether[i + a].X = points4[j].X;
                pointstogether[i + a].Y = points4[j].Y - Convert.ToInt32(b);
                pointstogether[i + 2 * a].X = points3[i].X;
                pointstogether[i + 2 * a].Y = points3[i].Y - Convert.ToInt32(b);
                pointstogether[i + 3 * a].X = points2[j].X;
                pointstogether[i + 3 * a].Y = points2[j].Y - Convert.ToInt32(b);
                j--;
            }

            double alpha;

            if (brennpunkt1.X != brennpunkt2.X | brennpunkt1.Y != brennpunkt2.Y)
                alpha = Math.Atan((Math.Abs(Convert.ToDouble(y2 - y1))) / (Math.Abs(Convert.ToDouble(x2 - x1)))) * (180 / Math.PI);
            else
                alpha = 0;

            if (y1 > y2)
                alpha = 360 - alpha;

            double cosalpha = Math.Cos(alpha * Math.PI / 180);
            double sinalpha = Math.Sin(alpha * Math.PI / 180);

            for (int i = 0; i < pointstogether.Length; i++)
            {
                int xneu = Convert.ToInt32(pointstogether[i].X * cosalpha - pointstogether[i].Y * sinalpha);
                int yneu = Convert.ToInt32(pointstogether[i].X * sinalpha + pointstogether[i].Y * cosalpha) + y1;
                pointstogether[i].X = xneu - Convert.ToInt32((2 * a - brennpunktabstand) / 2 * cosalpha) + x1;
                pointstogether[i].Y = yneu - Convert.ToInt32((2 * a - brennpunktabstand) / 2 * sinalpha);

            }

            int anzahlgedämmterpunkte = Convert.ToInt32(pointstogether.Length / dämmungsfaktor);
            Point[] pointsgedämmt = new Point[anzahlgedämmterpunkte];

            for (int i = 0; i < pointsgedämmt.Length; i++)
            {
                pointsgedämmt[i] = pointstogether[i * dämmungsfaktor];
            }

            return (pointsgedämmt);
        }

enjoy 😁