Add benchmark, update readme

README.md

@@ -106,17 +106,22 @@ using (Image<Rgba32> image = Image.Load<Rgba32>(stream))
 }
 ```
 
-Setting individual pixel values is perfomed as follows:
+Setting individual pixel values can perfomed as follows:
 
 ```csharp
+// Individual pixels
 using (Image<Rgba32> image = new Image<Rgba32>(400, 400)
-using (PixelAccessor<Rgba32> pixels = image.Lock())
 {
-    pixels[200, 200] = Rgba32.White;
+    image[200, 200] = Rgba32.White;
 }
 ```
 
-For advanced usage there are multiple [PixelFormat implementations](https://github.com/JimBobSquarePants/ImageSharp/tree/master/src/ImageSharp/PixelFormats) available allowing developers to implement their own color models in the same manner as Microsoft XNA Game Studio and MonoGame. 
+For optimized access within a loop it is recommended that the following methods are used.
+
+1. `image.GetRowSpan(y)`
+2. `image.GetRowSPan(x, y)`
+
+For advanced pixel format usage there are multiple [PixelFormat implementations](https://github.com/JimBobSquarePants/ImageSharp/tree/master/src/ImageSharp/PixelFormats) available allowing developers to implement their own color models in the same manner as Microsoft XNA Game Studio and MonoGame. 
 
 All in all this should allow image processing to be much more accessible to developers which has always been my goal from the start.
 

tests/ImageSharp.Benchmarks/Image/CopyPixels.cs

@@ -5,19 +5,20 @@
 
 namespace ImageSharp.Benchmarks.Image
 {
+    using System;
     using System.Threading.Tasks;
 
     using BenchmarkDotNet.Attributes;
 
-    using ImageSharp.PixelFormats;
+    using ImageSharp.Memory;
 
     public class CopyPixels : BenchmarkBase
     {
-        [Benchmark(Description = "Copy by Pixel")]
-        public Rgba32 CopyByPixel()
+        [Benchmark(Baseline = true, Description = "PixelAccessor Copy by indexer")]
+        public Rgba32 CopyByPixelAccesor()
         {
-            using (Image<Rgba32> source = new Image<Rgba32>(1024, 768))
-            using (Image<Rgba32> target = new Image<Rgba32>(1024, 768))
+            using (var source = new Image<Rgba32>(1024, 768))
+            using (var target = new Image<Rgba32>(1024, 768))
             {
                 using (PixelAccessor<Rgba32> sourcePixels = source.Lock())
                 using (PixelAccessor<Rgba32> targetPixels = target.Lock())
@@ -38,5 +39,81 @@ namespace ImageSharp.Benchmarks.Image
                 }
             }
         }
+
+        [Benchmark(Description = "PixelAccessor Copy by Span")]
+        public Rgba32 CopyByPixelAccesorSpan()
+        {
+            using (var source = new Image<Rgba32>(1024, 768))
+            using (var target = new Image<Rgba32>(1024, 768))
+            {
+                using (PixelAccessor<Rgba32> sourcePixels = source.Lock())
+                using (PixelAccessor<Rgba32> targetPixels = target.Lock())
+                {
+                    Parallel.For(
+                        0,
+                        source.Height,
+                        Configuration.Default.ParallelOptions,
+                        y =>
+                        {
+                            Span<Rgba32> sourceRow = sourcePixels.GetRowSpan(y);
+                            Span<Rgba32> targetRow = targetPixels.GetRowSpan(y);
+
+                            for (int x = 0; x < source.Width; x++)
+                            {
+                                targetRow[x] = sourceRow[x];
+                            }
+                        });
+
+                    return targetPixels[0, 0];
+                }
+            }
+        }
+
+        [Benchmark(Description = "Copy by indexer")]
+        public Rgba32 Copy()
+        {
+            using (var source = new Image<Rgba32>(1024, 768))
+            using (var target = new Image<Rgba32>(1024, 768))
+            {
+                Parallel.For(
+                    0,
+                    source.Height,
+                    Configuration.Default.ParallelOptions,
+                    y =>
+                    {
+                        for (int x = 0; x < source.Width; x++)
+                        {
+                            target[x, y] = source[x, y];
+                        }
+                    });
+
+                return target[0, 0];
+            }
+        }
+
+        [Benchmark(Description = "Copy by Span")]
+        public Rgba32 CopySpan()
+        {
+            using (var source = new Image<Rgba32>(1024, 768))
+            using (var target = new Image<Rgba32>(1024, 768))
+            {
+                Parallel.For(
+                    0,
+                    source.Height,
+                    Configuration.Default.ParallelOptions,
+                    y =>
+                    {
+                        Span<Rgba32> sourceRow = source.GetRowSpan(y);
+                        Span<Rgba32> targetRow = target.GetRowSpan(y);
+
+                        for (int x = 0; x < source.Width; x++)
+                        {
+                            targetRow[x] = sourceRow[x];
+                        }
+                    });
+
+                return target[0, 0];
+            }
+        }
     }
 }