All shapes are working

PixiEditorDotNetCore3/Models/Position/CoordinatesCalculator.cs → PixiEditor/Models/Position/CoordinatesCalculator.cs

@@ -32,6 +32,16 @@ namespace PixiEditor.Models.Position
             return new DoubleCords(new Coordinates(x1, y1), new Coordinates(x2 - 1, y2 - 1));
         }
 
+        public static Coordinates GetCenterPoint(Coordinates startingPoint, Coordinates endPoint)
+        {
+            double width = endPoint.X - startingPoint.X + 1;
+            double height = endPoint.Y - startingPoint.Y + 1;
+
+            int x = startingPoint.X + (int)Math.Floor(width / 2);
+            int y = startingPoint.Y + (int)Math.Floor(height / 2);
+            return new Coordinates(x, y);
+        }
+
         public static Coordinates[] RectangleToCoordinates(int x1, int y1, int x2, int y2)
         {
             x2++;

PixiEditor/Models/Tools/Tools/CircleTool.cs

@@ -0,0 +1,137 @@
+using PixiEditor.Models.Layers;
+using PixiEditor.Models.Position;
+using System.Collections.Generic;
+using System.Linq;
+using System.Windows.Media;
+using System.Windows.Media.Imaging;
+
+namespace PixiEditor.Models.Tools.Tools
+{
+    public class CircleTool : ShapeTool
+    {
+        public override ToolType ToolType => ToolType.Circle;
+
+        public override BitmapPixelChanges Use(Layer layer, Coordinates[] coordinates, Color color, int toolSize)
+        {
+            DoubleCords fixedCoordinates = CalculateCoordinatesForShapeRotation(coordinates[^1], coordinates[0]);
+            return BitmapPixelChanges.FromSingleColoredArray(CreateEllipse(fixedCoordinates.Coords1, fixedCoordinates.Coords2), color);
+        }
+
+        public Coordinates[] CreateEllipse(Coordinates startCoordinates, Coordinates endCoordinates)
+        {            
+            Coordinates centerCoordinates = CoordinatesCalculator.GetCenterPoint(startCoordinates, endCoordinates);
+            int radiusX = endCoordinates.X - centerCoordinates.X;
+            int radiusY = endCoordinates.Y - centerCoordinates.Y;
+            return MidpointEllipse(radiusX, radiusY, centerCoordinates.X, centerCoordinates.Y);
+        }
+
+        public Coordinates[] MidpointEllipse(double rx, double ry, double xc, double yc)
+        {
+            List<Coordinates> outputCoordinates = new List<Coordinates>();
+            double dx, dy, d1, d2, x, y;
+            x = 0;
+            y = ry;
+
+            d1 = (ry * ry) - (rx * rx * ry) + (0.25f * rx * rx);
+            dx = 2 * ry * ry * x;
+            dy = 2 * rx * rx * y;
+
+            while (dx < dy)
+            {
+                outputCoordinates.AddRange(GetRegionPoints(x, xc, y, yc));
+                if (d1 < 0)
+                {
+                    x++;
+                    dx += (2 * ry * ry);
+                    d1 = d1 + dx + (ry * ry);
+                }
+                else
+                {
+                    x++;
+                    y--;
+                    dx += (2 * ry * ry);
+                    dy -= (2 * rx * rx);
+                    d1 = d1 + dx - dy + (ry * ry);
+                }
+            }
+
+            //Yeah, it scares me too
+            d2 = (ry * ry * ((x + 0.5f) * (x + 0.5f))) + (rx * rx * ((y - 1) * (y - 1))) - (rx * rx * ry * ry);
+
+            while(y >= 0)
+            {
+                outputCoordinates.AddRange(GetRegionPoints(x, xc, y, yc));
+
+                if(d2 > 0)
+                {
+                    y--;
+                    dy -= (2 * rx * rx);
+                    d2 = d2 + (rx * rx) - dy;
+                }
+                else
+                {
+                    y--;
+                    x++;
+                    dx += (2 * ry * ry);
+                    dy -= (2 * rx * rx);
+                    d2 = d2 + dx - dy + (rx * rx);
+                }
+            }
+
+            return outputCoordinates.Distinct().ToArray();
+
+        }
+
+        private Coordinates[] GetRegionPoints(double x, double xc, double y, double yc)
+        {
+            Coordinates[] outputCoordinates = new Coordinates[4];
+            outputCoordinates[0] = (new Coordinates((int)x + (int)xc, (int)y + (int)yc));
+            outputCoordinates[1] = (new Coordinates((int)-x + (int)xc, (int)y + (int)yc));
+            outputCoordinates[2] = (new Coordinates((int)x + (int)xc, (int)-y + (int)yc));
+            outputCoordinates[3] = (new Coordinates((int)-x + (int)xc, (int)-y + (int)yc));
+            return outputCoordinates;
+        }
+
+        public Coordinates[] BresenhamCircle(Coordinates startCoordinates, Coordinates endCoordinates, int size)
+        {
+            List<Coordinates> outputCoordinates = new List<Coordinates>();
+            Coordinates centerCoordinates = CoordinatesCalculator.GetCenterPoint(startCoordinates, endCoordinates);
+            int radius = endCoordinates.X - centerCoordinates.X;
+            int x = 0;
+            int y = radius;
+            int decision = 3 - 2 * radius;
+            outputCoordinates.AddRange(GetPixelsForOctant(centerCoordinates.X, centerCoordinates.Y, x, y));
+
+            while (x <= y)
+            {
+                if (decision <= 0)
+                {
+                    decision = decision + (4 * x) + 6;
+                }
+                else
+                {
+                    decision = decision + (4 * x) - (4 * y) + 10;
+                    y--;
+                }
+                x++;
+                outputCoordinates.AddRange(GetPixelsForOctant(centerCoordinates.X, centerCoordinates.Y, x, y));
+            }
+            return outputCoordinates.Distinct().ToArray();
+        }
+
+        private Coordinates[] GetPixelsForOctant(int xc, int yc, int x, int y)
+        {
+            Coordinates[] outputCords = new Coordinates[8];
+            outputCords[0] = new Coordinates(x + xc, y + yc);
+            outputCords[1] = new Coordinates(x + xc, -y + yc);
+            outputCords[2] = new Coordinates(-x + xc, -y + yc);
+            outputCords[3] = new Coordinates(-x + xc, y + yc);
+            outputCords[4] = new Coordinates(y + xc, x + yc);
+            outputCords[5] = new Coordinates(y + xc, -x + yc);
+            outputCords[6] = new Coordinates(-y + xc, -x + yc);
+            outputCords[7] = new Coordinates(-y + xc, x + yc);
+            return outputCords;
+        }
+
+    }
+}

PixiEditorDotNetCore3/Models/Tools/Tools/CircleTool.cs

@@ -1,25 +0,0 @@
-using PixiEditor.Models.Layers;
-using PixiEditor.Models.Position;
-using System.Windows.Media;
-using System.Windows.Media.Imaging;
-
-namespace PixiEditor.Models.Tools.Tools
-{
-    public class CircleTool : ShapeTool
-    {
-        public override ToolType ToolType => ToolType.Circle;
-
-        public override BitmapPixelChanges Use(Layer layer, Coordinates[] coordinates, Color color, int toolSize)
-        {
-
-            return BitmapPixelChanges.FromSingleColoredArray(CreateCircle(coordinates, toolSize), color);
-        }
-
-        public Coordinates[] CreateCircle(Coordinates[] coordinates, int size)
-        {
-            return System.Array.Empty<Coordinates>();
-        }
-
-        
-    }
-}

PixiEditorTests/ModelsTests/ControllersTests/UndoManagerTests.cs

@@ -1,6 +1,6 @@
 using NUnit.Framework;
-using PixiEditorDotNetCore3.Models.Controllers;
-using PixiEditorDotNetCore3.Models.DataHolders;
+using PixiEditor.Models.Controllers;
+using PixiEditor.Models.DataHolders;
 using System;
 using System.Collections.Generic;
 using System.Text;

PixiEditorTests/ModelsTests/PositionTests/CoordinatesCalculatorTests.cs

@@ -1,19 +1,19 @@
 using NUnit.Framework;
 using PixiEditor.Models.Position;
-using System;
-using System.Collections.Generic;
-using System.Text;
 
 namespace PixiEditorTests.ModelsTests.PositionTests
 {
     [TestFixture]
     public class CoordinatesCalculatorTests
     {
-        [TestCase(5,5, 1)]
-        public void TestCenterOfThickness(int x1, int y1, int thickness)
+        [TestCase(0, 0, 3, 3, 2, 2)]
+        [TestCase(0, 0, 2, 2, 1, 1)]
+        [TestCase(5, 5, 7, 7, 6, 6)]
+        [TestCase(5, 5, 9, 9, 7, 7)]
+        public void TestGetCenter(int x1, int y1, int x2, int y2, int expectedX, int expectedY)
         {
-            CoordinatesCalculator.CalculateThicknessCenter(new Coordinates(x1, y1), thickness);
-            
+            Coordinates center = CoordinatesCalculator.GetCenterPoint(new Coordinates(x1, y1), new Coordinates(x2, y2));
+            Assert.AreEqual(center, new Coordinates(expectedX, expectedY));
         }
 
     }

PixiEditorTests/PixiEditorTests.csproj

@@ -21,7 +21,7 @@
   </ItemGroup>
 
   <ItemGroup>
-    <ProjectReference Include="..\PixiEditorDotNetCore3\PixiEditor.csproj" />
+    <ProjectReference Include="..\PixiEditor\PixiEditor.csproj" />
   </ItemGroup>
 
 </Project>

PixiEditorTests/WorkspaceTests/ColorsTests/ExtendedColorTests.cs

@@ -1,5 +1,5 @@
 using NUnit.Framework;
-using PixiEditorDotNetCore3.Models.Colors;
+using PixiEditor.Models.Colors;
 using System;
 using System.Collections.Generic;
 using System.Text;

PixiEditorTests/WorkspaceTests/ImageGeneratorTests.cs

@@ -1,5 +1,5 @@
 using NUnit.Framework;
-using PixiEditorDotNetCore3.Models.Images;
+using PixiEditor.Models.Images;
 using System;
 using System.Collections.Generic;
 using System.Text;

PixiEditorTests/WorkspaceTests/ToolsTests/CoordinatesCalculatorTests.cs

@@ -1,6 +1,6 @@
 using NUnit.Framework;
-using PixiEditorDotNetCore3.Models.Position;
-using PixiEditorDotNetCore3.Models.Tools.Tools;
+using PixiEditor.Models.Position;
+using PixiEditor.Models.Tools.Tools;
 using System;
 using System.Collections.Generic;
 using System.Text;