Changed Coordinates[] to IEnumerable<Coordinates> in BitmapPixelChanges

This reduced amount of ToArray() calls, which potentially will reduce memory and CPU usage

PixiEditor/Models/DataHolders/BitmapPixelChanges.cs

@@ -28,10 +28,13 @@ namespace PixiEditor.Models.DataHolders
         /// <param name="coordinates"></param>
         /// <param name="color"></param>
         /// <returns>Single-colored BitmapPixelChanges</returns>
-        public static BitmapPixelChanges FromSingleColoredArray(Coordinates[] coordinates, Color color)
+        public static BitmapPixelChanges FromSingleColoredArray(IEnumerable<Coordinates> coordinates, Color color)
         {
             Dictionary<Coordinates, Color> dict = new Dictionary<Coordinates, Color>();
-            for (int i = 0; i < coordinates.Length; i++) dict.Add(coordinates[i], color);
+            foreach (var coordinate in coordinates)
+            {
+                dict.Add(coordinate, color);
+            }
             return new BitmapPixelChanges(dict) {WasBuiltAsSingleColored = true};
         }
 

PixiEditor/Models/DataHolders/Selection.cs

@@ -1,4 +1,5 @@
-using System.Collections.ObjectModel;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
 using System.Linq;
 using System.Windows.Media;
 using PixiEditor.Helpers;
@@ -34,7 +35,7 @@ namespace PixiEditor.Models.DataHolders
             _selectionBlue = Color.FromArgb(127, 142, 202, 255);
         }
 
-        public void SetSelection(Coordinates[] selection, SelectionType mode)
+        public void SetSelection(IEnumerable<Coordinates> selection, SelectionType mode)
         {
             Color selectionColor = _selectionBlue;
             switch (mode)

PixiEditor/Models/ImageManipulation/Morphology.cs

@@ -7,7 +7,7 @@ namespace PixiEditor.Models.ImageManipulation
 {
     public class Morphology
     {
-        public static Coordinates[] ApplyDilation(Coordinates[] points, int kernelSize, int[,] mask)
+        public static IEnumerable<Coordinates> ApplyDilation(Coordinates[] points, int kernelSize, int[,] mask)
         {
             int kernelDim = kernelSize;
 
@@ -37,10 +37,10 @@ namespace PixiEditor.Models.ImageManipulation
                 outputArray[x, y] = value;
             }
 
-            return ToCoordinates(outputArray, offset).Distinct().ToArray();
+            return ToCoordinates(outputArray, offset).Distinct();
         }
 
-        private static Coordinates[] ToCoordinates(byte[,] byteArray, Coordinates offset)
+        private static IEnumerable<Coordinates> ToCoordinates(byte[,] byteArray, Coordinates offset)
         {
             List<Coordinates> output = new List<Coordinates>();
             int width = byteArray.GetLength(0);
@@ -49,7 +49,7 @@ namespace PixiEditor.Models.ImageManipulation
             for (int x = 0; x < width; x++)
                 if (byteArray[x, y] == 1)
                     output.Add(new Coordinates(x + offset.X, y + offset.Y));
-            return output.ToArray();
+            return output;
         }
 
         private static byte[,] GetByteArrayForPoints(Coordinates[] points, int margin)

PixiEditor/Models/Tools/ShapeTool.cs

@@ -23,14 +23,14 @@ namespace PixiEditor.Models.Tools
 
         public abstract override LayerChange[] Use(Layer layer, Coordinates[] coordinates, Color color);
 
-        protected Coordinates[] GetThickShape(Coordinates[] shape, int thickness)
+        protected IEnumerable<Coordinates> GetThickShape(IEnumerable<Coordinates> shape, int thickness)
         {
             List<Coordinates> output = new List<Coordinates>();
-            for (int i = 0; i < shape.Length; i++)
+            foreach(var item in shape)
                 output.AddRange(
                     CoordinatesCalculator.RectangleToCoordinates(
-                        CoordinatesCalculator.CalculateThicknessCenter(shape[i], thickness)));
-            return output.Distinct().ToArray();
+                        CoordinatesCalculator.CalculateThicknessCenter(item, thickness)));
+            return output.Distinct();
         }
 
 

PixiEditor/Models/Tools/Tools/CircleTool.cs

@@ -24,7 +24,7 @@ namespace PixiEditor.Models.Tools.Tools
         {
             int thickness = (int) Toolbar.GetSetting("ToolSize").Value;
             DoubleCords fixedCoordinates = CalculateCoordinatesForShapeRotation(coordinates[^1], coordinates[0]);
-            Coordinates[] outline = CreateEllipse(fixedCoordinates.Coords1, fixedCoordinates.Coords2, thickness);
+            IEnumerable<Coordinates> outline = CreateEllipse(fixedCoordinates.Coords1, fixedCoordinates.Coords2, thickness);
             BitmapPixelChanges pixels = BitmapPixelChanges.FromSingleColoredArray(outline, color);
             if ((bool) Toolbar.GetSetting("Fill").Value)
             {
@@ -45,19 +45,19 @@ namespace PixiEditor.Models.Tools.Tools
         /// <param name="thickness">Thickness of ellipse</param>
         /// <param name="filled">Should ellipse be filled</param>
         /// <returns>Coordinates for ellipse</returns>
-        public Coordinates[] CreateEllipse(Coordinates startCoordinates, Coordinates endCoordinates, int thickness,
+        public IEnumerable<Coordinates> CreateEllipse(Coordinates startCoordinates, Coordinates endCoordinates, int thickness,
             bool filled)
         {
             List<Coordinates> output = new List<Coordinates>();
-            Coordinates[] outline = CreateEllipse(startCoordinates, endCoordinates, thickness);
+            IEnumerable<Coordinates> outline = CreateEllipse(startCoordinates, endCoordinates, thickness);
             output.AddRange(outline);
             if (filled)
             {
                 output.AddRange(CalculateFillForEllipse(outline));
-                return output.Distinct().ToArray();
+                return output.Distinct();
             }
 
-            return output.ToArray();
+            return output;
         }
         /// <summary>
         ///     Calculates ellipse points for specified coordinates and thickness.
@@ -67,7 +67,7 @@ namespace PixiEditor.Models.Tools.Tools
         /// <param name="thickness">Thickness of ellipse</param>
         /// <returns>Coordinates for ellipse</returns>
         
-        public Coordinates[] CreateEllipse(Coordinates startCoordinates, Coordinates endCoordinates, int thickness)
+        public IEnumerable<Coordinates> CreateEllipse(Coordinates startCoordinates, Coordinates endCoordinates, int thickness)
         {
             double radiusX = (endCoordinates.X - startCoordinates.X) / 2.0;
             double radiusY = (endCoordinates.Y - startCoordinates.Y) / 2.0;
@@ -75,15 +75,15 @@ namespace PixiEditor.Models.Tools.Tools
             double centerY = (startCoordinates.Y + endCoordinates.Y + 1) / 2.0;
 
             List<Coordinates> output = new List<Coordinates>();
-            Coordinates[] ellipse = MidpointEllipse(radiusX, radiusY, centerX, centerY);
+            IEnumerable<Coordinates> ellipse = MidpointEllipse(radiusX, radiusY, centerX, centerY);
             if (thickness == 1)
                 output.AddRange(ellipse);
             else
                 output.AddRange(GetThickShape(ellipse, thickness));
-            return output.Distinct().ToArray();
+            return output.Distinct();
         }
 
-        public Coordinates[] MidpointEllipse(double halfWidth, double halfHeight, double centerX, double centerY)
+        public IEnumerable<Coordinates> MidpointEllipse(double halfWidth, double halfHeight, double centerX, double centerY)
         {
             if (halfWidth < 1 || halfHeight < 1)
                 return FallbackRectangle(halfWidth, halfHeight, centerX, centerY);
@@ -134,7 +134,7 @@ namespace PixiEditor.Models.Tools.Tools
                 }
             }
 
-            return outputCoordinates.ToArray();
+            return outputCoordinates;
         }
 
         private Coordinates[] FallbackRectangle(double halfWidth, double halfHeight, double centerX, double centerY)
@@ -153,7 +153,7 @@ namespace PixiEditor.Models.Tools.Tools
             return coordinates.ToArray();
         }
 
-        private Coordinates[] CalculateFillForEllipse(Coordinates[] outlineCoordinates)
+        private IEnumerable<Coordinates> CalculateFillForEllipse(IEnumerable<Coordinates> outlineCoordinates)
         {
             List<Coordinates> finalCoordinates = new List<Coordinates>();
             int bottom = outlineCoordinates.Max(x => x.Y);
@@ -166,7 +166,7 @@ namespace PixiEditor.Models.Tools.Tools
                 for (int j = left + 1; j < right; j++) finalCoordinates.Add(new Coordinates(j, i));
             }
 
-            return finalCoordinates.ToArray();
+            return finalCoordinates;
         }
         private Coordinates[] GetRegionPoints(double x, double xc, double y, double yc)
         {

PixiEditor/Models/Tools/Tools/FloodFill.cs

@@ -59,7 +59,7 @@ namespace PixiEditor.Models.Tools.Tools
                 }
 
             }
-            return BitmapPixelChanges.FromSingleColoredArray(changedCoords.ToArray(), newColor);
+            return BitmapPixelChanges.FromSingleColoredArray(changedCoords, newColor);
         }
     }
 }

PixiEditor/Models/Tools/Tools/LineTool.cs

@@ -30,18 +30,18 @@ namespace PixiEditor.Models.Tools.Tools
             return Only(pixels, layer);
         }
 
-        public Coordinates[] CreateLine(Coordinates start, Coordinates end, int thickness)
+        public IEnumerable<Coordinates> CreateLine(Coordinates start, Coordinates end, int thickness)
         {
             return CreateLine(new[] { end, start }, thickness, CapType.Square, CapType.Square);
         }
 
-        public Coordinates[] CreateLine(Coordinates start, Coordinates end, int thickness, CapType startCap,
+        public IEnumerable<Coordinates> CreateLine(Coordinates start, Coordinates end, int thickness, CapType startCap,
             CapType endCap)
         {
             return CreateLine(new[] {end, start}, thickness, startCap, endCap);
         }
 
-        private Coordinates[] CreateLine(Coordinates[] coordinates, int thickness, CapType startCap, CapType endCap)
+        private IEnumerable<Coordinates> CreateLine(Coordinates[] coordinates, int thickness, CapType startCap, CapType endCap)
         {
             Coordinates startingCoordinates = coordinates[^1];
             Coordinates latestCoordinates = coordinates[0];
@@ -51,7 +51,7 @@ namespace PixiEditor.Models.Tools.Tools
             return GetLinePoints(startingCoordinates, latestCoordinates, thickness, startCap, endCap);
         }
 
-        private Coordinates[] GetLinePoints(Coordinates start, Coordinates end, int thickness, CapType startCap, CapType endCap)
+        private IEnumerable<Coordinates> GetLinePoints(Coordinates start, Coordinates end, int thickness, CapType startCap, CapType endCap)
         {
             var startingCap = GetCapCoordinates(startCap, start, thickness);
             if (start == end) return startingCap;
@@ -61,16 +61,16 @@ namespace PixiEditor.Models.Tools.Tools
             List<Coordinates> output = new List<Coordinates>(startingCap);
 
             output.AddRange(GetCapCoordinates(endCap, end, thickness));
-            if (line.Length > 2)
+            if (line.Count() > 2)
             {
                 output.AddRange(GetThickShape(line.Except(new []{start,end}).ToArray(), thickness));
             }
 
-            return output.Distinct().ToArray();
+            return output.Distinct();
 
         }
 
-        private Coordinates[] GetCapCoordinates(CapType cap, Coordinates position, int thickness)
+        private IEnumerable<Coordinates> GetCapCoordinates(CapType cap, Coordinates position, int thickness)
         {
             switch (cap)
             {
@@ -89,7 +89,7 @@ namespace PixiEditor.Models.Tools.Tools
         /// <param name="position">Starting position of cap</param>
         /// <param name="thickness">Thickness of cap</param>
         /// <returns></returns>
-        private Coordinates[] GetRoundCap(Coordinates position, int thickness)
+        private IEnumerable<Coordinates> GetRoundCap(Coordinates position, int thickness)
         {
             CircleTool circle = new CircleTool();
             var rectangleCords = CoordinatesCalculator.RectangleToCoordinates(
@@ -97,7 +97,7 @@ namespace PixiEditor.Models.Tools.Tools
             return circle.CreateEllipse(rectangleCords[0], rectangleCords[^1], 1, true);
         }
 
-        private Coordinates[] BresenhamLine(int x1, int y1, int x2, int y2)
+        private IEnumerable<Coordinates> BresenhamLine(int x1, int y1, int x2, int y2)
         {
             List<Coordinates> coordinates = new List<Coordinates>();
             if (x1 == x2 && y1 == y2) return new[] {new Coordinates(x1, y1)};
@@ -176,7 +176,7 @@ namespace PixiEditor.Models.Tools.Tools
                 }
             }
 
-            return coordinates.ToArray();
+            return coordinates;
         }
     }
 }

PixiEditor/Models/Tools/Tools/RectangleTool.cs

@@ -36,11 +36,11 @@ namespace PixiEditor.Models.Tools.Tools
             return new[] {new LayerChange(pixels, layer)};
         }
 
-        public Coordinates[] CreateRectangle(Coordinates[] coordinates, int thickness)
+        public IEnumerable<Coordinates> CreateRectangle(Coordinates[] coordinates, int thickness)
         {
             DoubleCords fixedCoordinates = CalculateCoordinatesForShapeRotation(coordinates[^1], coordinates[0]);
             List<Coordinates> output = new List<Coordinates>();
-            Coordinates[] rectangle = CalculateRectanglePoints(fixedCoordinates);
+            IEnumerable<Coordinates> rectangle = CalculateRectanglePoints(fixedCoordinates);
             output.AddRange(rectangle);
 
             for (int i = 1; i < (int) Math.Floor(thickness / 2f) + 1; i++)
@@ -52,15 +52,15 @@ namespace PixiEditor.Models.Tools.Tools
                     new Coordinates(fixedCoordinates.Coords1.X + i, fixedCoordinates.Coords1.Y + i),
                     new Coordinates(fixedCoordinates.Coords2.X - i, fixedCoordinates.Coords2.Y - i))));
 
-            return output.Distinct().ToArray();
+            return output.Distinct();
         }
 
-        public Coordinates[] CreateRectangle(Coordinates start, Coordinates end, int thickness)
+        public IEnumerable<Coordinates> CreateRectangle(Coordinates start, Coordinates end, int thickness)
         {
             return CreateRectangle(new[] {end, start}, thickness);
         }
 
-        private Coordinates[] CalculateRectanglePoints(DoubleCords coordinates)
+        private IEnumerable<Coordinates> CalculateRectanglePoints(DoubleCords coordinates)
         {
             List<Coordinates> finalCoordinates = new List<Coordinates>();
 
@@ -76,10 +76,10 @@ namespace PixiEditor.Models.Tools.Tools
                 finalCoordinates.Add(new Coordinates(coordinates.Coords2.X, i));
             }
 
-            return finalCoordinates.ToArray();
+            return finalCoordinates;
         }
 
-        public Coordinates[] CalculateFillForRectangle(Coordinates start, Coordinates end, int thickness)
+        public IEnumerable<Coordinates> CalculateFillForRectangle(Coordinates start, Coordinates end, int thickness)
         {
             int offset = (int) Math.Ceiling(thickness / 2f);
             DoubleCords fixedCords = CalculateCoordinatesForShapeRotation(start, end);
@@ -103,7 +103,7 @@ namespace PixiEditor.Models.Tools.Tools
                 i++;
             }
 
-            return filledCoordinates.Distinct().ToArray();
+            return filledCoordinates.Distinct();
         }
     }
 }

PixiEditor/Models/Tools/Tools/SelectTool.cs

@@ -48,23 +48,23 @@ namespace PixiEditor.Models.Tools.Tools
 
         private void Select(Coordinates[] pixels)
         {
-            Coordinates[] selection = GetRectangleSelectionForPoints(pixels[^1], pixels[0]);
+            IEnumerable<Coordinates> selection = GetRectangleSelectionForPoints(pixels[^1], pixels[0]);
             ViewModelMain.Current.ActiveSelection.SetSelection(selection, SelectionType);
         }
 
-        public Coordinates[] GetRectangleSelectionForPoints(Coordinates start, Coordinates end)
+        public IEnumerable<Coordinates> GetRectangleSelectionForPoints(Coordinates start, Coordinates end)
         {
             RectangleTool rectangleTool = new RectangleTool();
             List<Coordinates> selection = rectangleTool.CreateRectangle(start, end, 1).ToList();
             selection.AddRange(rectangleTool.CalculateFillForRectangle(start, end, 1));
-            return selection.ToArray();
+            return selection;
         }
 
         /// <summary>
         ///     Gets coordinates of every pixel in root layer
         /// </summary>
         /// <returns>Coordinates array of pixels</returns>
-        public Coordinates[] GetAllSelection()
+        public IEnumerable<Coordinates> GetAllSelection()
         {
             return GetAllSelection(ViewModelMain.Current.BitmapManager.ActiveDocument);
         }
@@ -74,7 +74,7 @@ namespace PixiEditor.Models.Tools.Tools
         /// </summary>
         /// <param name="document"></param>
         /// <returns>Coordinates array of pixels</returns>
-        public Coordinates[] GetAllSelection(Document document)
+        public IEnumerable<Coordinates> GetAllSelection(Document document)
         {
             return GetRectangleSelectionForPoints(new Coordinates(0, 0), new Coordinates(document.Width - 1, document.Height - 1));
         }