public static void GenerateRectangleNonAlloc(
            Coordinates start,
            Coordinates end, bool fill, int thickness, List <Coordinates> output)
        {
            DoubleCoords fixedCoordinates = CalculateCoordinatesForShapeRotation(start, end);

            CalculateRectanglePoints(fixedCoordinates, output);

            for (int i = 1; i < (int)Math.Floor(thickness / 2f) + 1; i++)
            {
                CalculateRectanglePoints(
                    new DoubleCoords(
                        new Coordinates(fixedCoordinates.Coords1.X - i, fixedCoordinates.Coords1.Y - i),
                        new Coordinates(fixedCoordinates.Coords2.X + i, fixedCoordinates.Coords2.Y + i)), output);
            }

            for (int i = 1; i < (int)Math.Ceiling(thickness / 2f); i++)
            {
                CalculateRectanglePoints(
                    new DoubleCoords(
                        new Coordinates(fixedCoordinates.Coords1.X + i, fixedCoordinates.Coords1.Y + i),
                        new Coordinates(fixedCoordinates.Coords2.X - i, fixedCoordinates.Coords2.Y - i)), output);
            }

            if (fill)
            {
                CalculateRectangleFillNonAlloc(start, end, thickness, output);
            }
        }
        private static void CalculateRectangleFillNonAlloc(Coordinates start, Coordinates end, int thickness, List <Coordinates> output)
        {
            int          offset     = (int)Math.Ceiling(thickness / 2f);
            DoubleCoords fixedCords = CalculateCoordinatesForShapeRotation(start, end);

            DoubleCoords innerCords = new DoubleCoords
            {
                Coords1 = new Coordinates(fixedCords.Coords1.X + offset, fixedCords.Coords1.Y + offset),
                Coords2 = new Coordinates(fixedCords.Coords2.X - (offset - 1), fixedCords.Coords2.Y - (offset - 1))
            };

            int height = innerCords.Coords2.Y - innerCords.Coords1.Y;
            int width  = innerCords.Coords2.X - innerCords.Coords1.X;

            if (height < 1 || width < 1)
            {
                return;
            }

            int i = 0;

            for (int y = 0; y < height; y++)
            {
                for (int x = 0; x < width; x++)
                {
                    output.Add(new Coordinates(innerCords.Coords1.X + x, innerCords.Coords1.Y + y));
                    i++;
                }
            }
        }
        public static List <Coordinates> GenerateEllipseFromRect(DoubleCoords rect, List <Coordinates> listToFill = null)
        {
            float radiusX = (rect.Coords2.X - rect.Coords1.X) / 2.0f;
            float radiusY = (rect.Coords2.Y - rect.Coords1.Y) / 2.0f;
            float centerX = (rect.Coords1.X + rect.Coords2.X + 1) / 2.0f;
            float centerY = (rect.Coords1.Y + rect.Coords2.Y + 1) / 2.0f;

            return(GenerateMidpointEllipse(radiusX, radiusY, centerX, centerY, listToFill));
        }
        public static void GenerateEllipseNonAlloc(Coordinates start, Coordinates end, bool fill,
                                                   List <Coordinates> output)
        {
            DoubleCoords fixedCoordinates = CalculateCoordinatesForShapeRotation(start, end);

            EllipseGenerator.GenerateEllipseFromRect(fixedCoordinates, output);
            if (fill)
            {
                CalculateFillForEllipse(output);
            }
        }
        private static void CalculateRectanglePoints(DoubleCoords coordinates, List <Coordinates> output)
        {
            for (int i = coordinates.Coords1.X; i < coordinates.Coords2.X + 1; i++)
            {
                output.Add(new Coordinates(i, coordinates.Coords1.Y));
                output.Add(new Coordinates(i, coordinates.Coords2.Y));
            }

            for (int i = coordinates.Coords1.Y + 1; i <= coordinates.Coords2.Y - 1; i++)
            {
                output.Add(new Coordinates(coordinates.Coords1.X, i));
                output.Add(new Coordinates(coordinates.Coords2.X, i));
            }
        }