Merge pull request #1194 from SixLabors/js-buffer2dregion

BufferRegion => Buffer2DRegion

Author: JimBobSquarePants

src/ImageSharp/Formats/Gif/GifDecoderCore.cs

@@ -543,7 +543,7 @@ private void RestoreToBackground<TPixel>(ImageFrame<TPixel> frame)
                 return;
             }
 
-            BufferRegion<TPixel> pixelRegion = frame.PixelBuffer.GetRegion(this.restoreArea.Value);
+            Buffer2DRegion<TPixel> pixelRegion = frame.PixelBuffer.GetRegion(this.restoreArea.Value);
             pixelRegion.Clear();
 
             this.restoreArea = null;

src/ImageSharp/Formats/Jpeg/Components/Block8x8F.ScaledCopyTo.cs

@@ -15,7 +15,7 @@ internal partial struct Block8x8F
         /// Copy block data into the destination color buffer pixel area with the provided horizontal and vertical scale factors.
         /// </summary>
         [MethodImpl(InliningOptions.ShortMethod)]
-        public void ScaledCopyTo(in BufferRegion<float> region, int horizontalScale, int verticalScale)
+        public void ScaledCopyTo(in Buffer2DRegion<float> region, int horizontalScale, int verticalScale)
         {
             ref float areaOrigin = ref region.GetReferenceToOrigin();
             this.ScaledCopyTo(ref areaOrigin, region.Stride, horizontalScale, verticalScale);

src/ImageSharp/Memory/Buffer2DExtensions.cs

@@ -80,29 +80,29 @@ internal static Rectangle FullRectangle<T>(this Buffer2D<T> buffer)
         }
 
         /// <summary>
-        /// Return a <see cref="BufferRegion{T}"/> to the subarea represented by 'rectangle'
+        /// Return a <see cref="Buffer2DRegion{T}"/> to the subregion represented by 'rectangle'
         /// </summary>
         /// <typeparam name="T">The element type</typeparam>
         /// <param name="buffer">The <see cref="Buffer2D{T}"/></param>
-        /// <param name="rectangle">The rectangle subarea</param>
-        /// <returns>The <see cref="BufferRegion{T}"/></returns>
-        internal static BufferRegion<T> GetRegion<T>(this Buffer2D<T> buffer, in Rectangle rectangle)
+        /// <param name="rectangle">The rectangle subregion</param>
+        /// <returns>The <see cref="Buffer2DRegion{T}"/></returns>
+        internal static Buffer2DRegion<T> GetRegion<T>(this Buffer2D<T> buffer, Rectangle rectangle)
             where T : unmanaged =>
-            new BufferRegion<T>(buffer, rectangle);
+            new Buffer2DRegion<T>(buffer, rectangle);
 
-        internal static BufferRegion<T> GetRegion<T>(this Buffer2D<T> buffer, int x, int y, int width, int height)
+        internal static Buffer2DRegion<T> GetRegion<T>(this Buffer2D<T> buffer, int x, int y, int width, int height)
             where T : unmanaged =>
-            new BufferRegion<T>(buffer, new Rectangle(x, y, width, height));
+            new Buffer2DRegion<T>(buffer, new Rectangle(x, y, width, height));
 
         /// <summary>
-        /// Return a <see cref="BufferRegion{T}"/> to the whole area of 'buffer'
+        /// Return a <see cref="Buffer2DRegion{T}"/> to the whole area of 'buffer'
         /// </summary>
         /// <typeparam name="T">The element type</typeparam>
         /// <param name="buffer">The <see cref="Buffer2D{T}"/></param>
-        /// <returns>The <see cref="BufferRegion{T}"/></returns>
-        internal static BufferRegion<T> GetRegion<T>(this Buffer2D<T> buffer)
+        /// <returns>The <see cref="Buffer2DRegion{T}"/></returns>
+        internal static Buffer2DRegion<T> GetRegion<T>(this Buffer2D<T> buffer)
             where T : unmanaged =>
-            new BufferRegion<T>(buffer);
+            new Buffer2DRegion<T>(buffer);
 
         /// <summary>
         /// Returns the size of the buffer.

src/ImageSharp/Memory/BufferRegion{T}.cs …c/ImageSharp/Memory/Buffer2DRegion{T}.cssrc/ImageSharp/Memory/BufferRegion{T}.cs renamed to src/ImageSharp/Memory/Buffer2DRegion{T}.cs src/ImageSharp/Memory/BufferRegion{T}.cs renamed to src/ImageSharp/Memory/Buffer2DRegion{T}.cs

@@ -9,16 +9,16 @@ namespace SixLabors.ImageSharp.Memory
     /// Represents a rectangular region inside a 2D memory buffer (<see cref="Buffer2D{T}"/>).
     /// </summary>
     /// <typeparam name="T">The element type.</typeparam>
-    public readonly struct BufferRegion<T>
+    public readonly struct Buffer2DRegion<T>
         where T : unmanaged
     {
         /// <summary>
-        /// Initializes a new instance of the <see cref="BufferRegion{T}"/> struct.
+        /// Initializes a new instance of the <see cref="Buffer2DRegion{T}"/> struct.
         /// </summary>
         /// <param name="buffer">The <see cref="Buffer2D{T}"/>.</param>
         /// <param name="rectangle">The <see cref="Rectangle"/> defining a rectangular area within the buffer.</param>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public BufferRegion(Buffer2D<T> buffer, Rectangle rectangle)
+        public Buffer2DRegion(Buffer2D<T> buffer, Rectangle rectangle)
         {
             DebugGuard.MustBeGreaterThanOrEqualTo(rectangle.X, 0, nameof(rectangle));
             DebugGuard.MustBeGreaterThanOrEqualTo(rectangle.Y, 0, nameof(rectangle));
@@ -30,11 +30,11 @@ public BufferRegion(Buffer2D<T> buffer, Rectangle rectangle)
         }
 
         /// <summary>
-        /// Initializes a new instance of the <see cref="BufferRegion{T}"/> struct.
+        /// Initializes a new instance of the <see cref="Buffer2DRegion{T}"/> struct.
         /// </summary>
         /// <param name="buffer">The <see cref="Buffer2D{T}"/>.</param>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public BufferRegion(Buffer2D<T> buffer)
+        public Buffer2DRegion(Buffer2D<T> buffer)
             : this(buffer, buffer.FullRectangle())
         {
         }
@@ -98,35 +98,35 @@ public Span<T> GetRowSpan(int y)
         }
 
         /// <summary>
-        /// Returns a sub-area as <see cref="BufferRegion{T}"/>. (Similar to <see cref="Span{T}.Slice(int, int)"/>.)
+        /// Returns a subregion as <see cref="Buffer2DRegion{T}"/>. (Similar to <see cref="Span{T}.Slice(int, int)"/>.)
         /// </summary>
-        /// <param name="x">The x index at the subarea origin.</param>
-        /// <param name="y">The y index at the subarea origin.</param>
-        /// <param name="width">The desired width of the subarea.</param>
-        /// <param name="height">The desired height of the subarea.</param>
-        /// <returns>The subarea</returns>
+        /// <param name="x">The x index at the subregion origin.</param>
+        /// <param name="y">The y index at the subregion origin.</param>
+        /// <param name="width">The desired width of the subregion.</param>
+        /// <param name="height">The desired height of the subregion.</param>
+        /// <returns>The subregion</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public BufferRegion<T> GetSubArea(int x, int y, int width, int height)
+        public Buffer2DRegion<T> GetSubRegion(int x, int y, int width, int height)
         {
             var rectangle = new Rectangle(x, y, width, height);
-            return this.GetSubArea(rectangle);
+            return this.GetSubRegion(rectangle);
         }
 
         /// <summary>
-        /// Returns a sub-area as <see cref="BufferRegion{T}"/>. (Similar to <see cref="Span{T}.Slice(int, int)"/>.)
+        /// Returns a subregion as <see cref="Buffer2DRegion{T}"/>. (Similar to <see cref="Span{T}.Slice(int, int)"/>.)
         /// </summary>
-        /// <param name="rectangle">The <see cref="Rectangle"/> specifying the boundaries of the subarea</param>
-        /// <returns>The subarea</returns>
+        /// <param name="rectangle">The <see cref="Rectangle"/> specifying the boundaries of the subregion</param>
+        /// <returns>The subregion</returns>
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public BufferRegion<T> GetSubArea(Rectangle rectangle)
+        public Buffer2DRegion<T> GetSubRegion(Rectangle rectangle)
         {
             DebugGuard.MustBeLessThanOrEqualTo(rectangle.Width, this.Rectangle.Width, nameof(rectangle));
             DebugGuard.MustBeLessThanOrEqualTo(rectangle.Height, this.Rectangle.Height, nameof(rectangle));
 
             int x = this.Rectangle.X + rectangle.X;
             int y = this.Rectangle.Y + rectangle.Y;
             rectangle = new Rectangle(x, y, rectangle.Width, rectangle.Height);
-            return new BufferRegion<T>(this.Buffer, rectangle);
+            return new Buffer2DRegion<T>(this.Buffer, rectangle);
         }
 
         /// <summary>

src/ImageSharp/Processing/Processors/Quantization/DefaultPixelSamplingStrategy.cs

@@ -50,7 +50,7 @@ public DefaultPixelSamplingStrategy(int maximumPixels, double minimumScanRatio)
         public double MinimumScanRatio { get; }
 
         /// <inheritdoc />
-        public IEnumerable<BufferRegion<TPixel>> EnumeratePixelRegions<TPixel>(Image<TPixel> image)
+        public IEnumerable<Buffer2DRegion<TPixel>> EnumeratePixelRegions<TPixel>(Image<TPixel> image)
             where TPixel : unmanaged, IPixel<TPixel>
         {
             long maximumPixels = Math.Min(this.MaximumPixels, (long)image.Width * image.Height * image.Frames.Count);
@@ -95,7 +95,7 @@ public IEnumerable<BufferRegion<TPixel>> EnumeratePixelRegions<TPixel>(Image<TPi
                     }
                 }
 
-                BufferRegion<TPixel> GetRow(int pos)
+                Buffer2DRegion<TPixel> GetRow(int pos)
                 {
                     int frameIdx = pos / image.Height;
                     int y = pos % image.Height;

src/ImageSharp/Processing/Processors/Quantization/ExtensivePixelSamplingStrategy.cs

@@ -13,7 +13,7 @@ namespace SixLabors.ImageSharp.Processing.Processors.Quantization
     public class ExtensivePixelSamplingStrategy : IPixelSamplingStrategy
     {
         /// <inheritdoc />
-        public IEnumerable<BufferRegion<TPixel>> EnumeratePixelRegions<TPixel>(Image<TPixel> image)
+        public IEnumerable<Buffer2DRegion<TPixel>> EnumeratePixelRegions<TPixel>(Image<TPixel> image)
             where TPixel : unmanaged, IPixel<TPixel>
         {
             foreach (ImageFrame<TPixel> frame in image.Frames)

src/ImageSharp/Processing/Processors/Quantization/IPixelSamplingStrategy.cs

@@ -13,12 +13,12 @@ namespace SixLabors.ImageSharp.Processing.Processors.Quantization
     public interface IPixelSamplingStrategy
     {
         /// <summary>
-        /// Enumerates pixel regions within the image as <see cref="BufferRegion{T}"/>.
+        /// Enumerates pixel regions within the image as <see cref="Buffer2DRegion{T}"/>.
         /// </summary>
         /// <param name="image">The image.</param>
         /// <typeparam name="TPixel">The pixel type.</typeparam>
         /// <returns>An enumeration of pixel regions.</returns>
-        IEnumerable<BufferRegion<TPixel>> EnumeratePixelRegions<TPixel>(Image<TPixel> image)
+        IEnumerable<Buffer2DRegion<TPixel>> EnumeratePixelRegions<TPixel>(Image<TPixel> image)
             where TPixel : unmanaged, IPixel<TPixel>;
     }
 }

src/ImageSharp/Processing/Processors/Quantization/IQuantizer{TPixel}.cs

@@ -35,8 +35,8 @@ public interface IQuantizer<TPixel> : IDisposable
         /// <summary>
         /// Adds colors to the quantized palette from the given pixel source.
         /// </summary>
-        /// <param name="pixelRegion">The <see cref="BufferRegion{T}"/> of source pixels to register.</param>
-        void AddPaletteColors(BufferRegion<TPixel> pixelRegion);
+        /// <param name="pixelRegion">The <see cref="Buffer2DRegion{T}"/> of source pixels to register.</param>
+        void AddPaletteColors(Buffer2DRegion<TPixel> pixelRegion);
 
         /// <summary>
         /// Quantizes an image frame and return the resulting output pixels.

src/ImageSharp/Processing/Processors/Quantization/OctreeQuantizer{TPixel}.cs

@@ -69,7 +69,7 @@ public ReadOnlyMemory<TPixel> Palette
 
         /// <inheritdoc/>
         [MethodImpl(InliningOptions.ShortMethod)]
-        public void AddPaletteColors(BufferRegion<TPixel> pixelRegion)
+        public void AddPaletteColors(Buffer2DRegion<TPixel> pixelRegion)
         {
             Rectangle bounds = pixelRegion.Rectangle;
             Buffer2D<TPixel> source = pixelRegion.Buffer;

src/ImageSharp/Processing/Processors/Quantization/PaletteQuantizer{TPixel}.cs

@@ -54,7 +54,7 @@ public readonly IndexedImageFrame<TPixel> QuantizeFrame(ImageFrame<TPixel> sourc
 
         /// <inheritdoc/>
         [MethodImpl(InliningOptions.ShortMethod)]
-        public void AddPaletteColors(BufferRegion<TPixel> pixelRegion)
+        public void AddPaletteColors(Buffer2DRegion<TPixel> pixelRegion)
         {
         }