public void AddPaletteColors(Buffer2DRegion <TPixel> pixelRegion)
{
Rectangle bounds = pixelRegion.Rectangle;
Buffer2D <TPixel> source = pixelRegion.Buffer;
using IMemoryOwner <Rgba32> buffer = this.Configuration.MemoryAllocator.Allocate <Rgba32>(bounds.Width);
Span <Rgba32> bufferSpan = buffer.GetSpan();
// Loop through each row
for (int y = bounds.Top; y < bounds.Bottom; y++)
{
Span <TPixel> row = source.GetRowSpan(y).Slice(bounds.Left, bounds.Width);
PixelOperations <TPixel> .Instance.ToRgba32(this.Configuration, row, bufferSpan);
for (int x = 0; x < bufferSpan.Length; x++)
{
Rgba32 rgba = bufferSpan[x];
// Add the color to the Octree
this.octree.AddColor(rgba);
}
}
Span <TPixel> paletteSpan = this.paletteOwner.GetSpan();
int paletteIndex = 0;
this.octree.Palletize(paletteSpan, this.maxColors, ref paletteIndex);
// Length of reduced palette + transparency.
ReadOnlyMemory <TPixel> result = this.paletteOwner.Memory.Slice(0, Math.Min(paletteIndex + 2, this.maxColors));
this.pixelMap = new EuclideanPixelMap <TPixel>(this.Configuration, result);
this.palette = result;
}
public void CopyTo(int horizontalFactor, int verticalFactor)
{
Block8x8F block = CreateRandomFloatBlock(0, 100);
var start = new Point(50, 50);
using (Buffer2D <float> buffer = Configuration.Default.MemoryAllocator.Allocate2D <float>(100, 100, AllocationOptions.Clean))
{
Buffer2DRegion <float> region = buffer.GetRegion(start.X, start.Y, 8 * horizontalFactor, 8 * verticalFactor);
block.ScaledCopyTo(region, horizontalFactor, verticalFactor);
for (int y = 0; y < 8 * verticalFactor; y++)
{
for (int x = 0; x < 8 * horizontalFactor; x++)
{
int yy = y / verticalFactor;
int xx = x / horizontalFactor;
float expected = block[xx, yy];
float actual = region[x, y];
Assert.Equal(expected, actual);
}
}
VerifyAllZeroOutsideSubArea(buffer, start.X, start.Y, horizontalFactor, verticalFactor);
}
}
/// <inheritdoc/>
public void AddPaletteColors(Buffer2DRegion <TPixel> pixelRegion)
{
Rectangle bounds = pixelRegion.Rectangle;
Buffer2D <TPixel> source = pixelRegion.Buffer;
this.Build3DHistogram(source, bounds);
this.Get3DMoments(this.memoryAllocator);
this.BuildCube();
// Slice again since maxColors has been updated since the buffer was created.
Span <TPixel> paletteSpan = this.paletteOwner.GetSpan().Slice(0, this.maxColors);
ReadOnlySpan <Moment> momentsSpan = this.momentsOwner.GetSpan();
for (int k = 0; k < paletteSpan.Length; k++)
{
this.Mark(ref this.colorCube[k], (byte)k);
Moment moment = Volume(ref this.colorCube[k], momentsSpan);
if (moment.Weight > 0)
{
ref TPixel color = ref paletteSpan[k];
color.FromScaledVector4(moment.Normalize());
}
}
public void GetReferenceToOrigin(int bufferCapacity)
{
this.memoryAllocator.BufferCapacityInBytes = sizeof(int) * bufferCapacity;
using Buffer2D <int> buffer = this.CreateTestBuffer(20, 30);
Buffer2DRegion <int> area0 = buffer.GetRegion(6, 8, 10, 10);
ref int r = ref area0.GetReferenceToOrigin();
public void Construct()
{
using Buffer2D <int> buffer = this.memoryAllocator.Allocate2D <int>(10, 20);
var rectangle = new Rectangle(3, 2, 5, 6);
var area = new Buffer2DRegion <int>(buffer, rectangle);
Assert.Equal(buffer, area.Buffer);
Assert.Equal(rectangle, area.Rectangle);
}
private static void PaintWhite(Buffer2DRegion <L8> region)
{
var white = new L8(255);
for (int y = 0; y < region.Height; y++)
{
region.GetRowSpan(y).Fill(white);
}
}
/// <inheritdoc/>
public void AddPaletteColors(Buffer2DRegion <TPixel> pixelRegion)
{
Rectangle bounds = pixelRegion.Rectangle;
Buffer2D <TPixel> source = pixelRegion.Buffer;
using (IMemoryOwner <Rgba32> buffer = this.Configuration.MemoryAllocator.Allocate <Rgba32>(bounds.Width))
{
Span <Rgba32> bufferSpan = buffer.GetSpan();
// Loop through each row
for (int y = bounds.Top; y < bounds.Bottom; y++)
{
Span <TPixel> row = source.DangerousGetRowSpan(y).Slice(bounds.Left, bounds.Width);
PixelOperations <TPixel> .Instance.ToRgba32(this.Configuration, row, bufferSpan);
for (int x = 0; x < bufferSpan.Length; x++)
{
Rgba32 rgba = bufferSpan[x];
// Add the color to the Octree
this.octree.AddColor(rgba);
}
}
}
int paletteIndex = 0;
Span <TPixel> paletteSpan = this.paletteOwner.GetSpan();
// On very rare occasions, (blur.png), the quantizer does not preserve a
// transparent entry when palletizing the captured colors.
// To workaround this we ensure the palette ends with the default color
// for higher bit depths. Lower bit depths will correctly reduce the palette.
// TODO: Investigate more evenly reduced palette reduction.
int max = this.maxColors;
if (this.bitDepth == 8)
{
max--;
}
this.octree.Palletize(paletteSpan, max, ref paletteIndex);
ReadOnlyMemory <TPixel> result = this.paletteOwner.Memory.Slice(0, paletteSpan.Length);
// When called multiple times by QuantizerUtilities.BuildPalette
// this prevents memory churn caused by reallocation.
if (this.pixelMap is null)
{
this.pixelMap = new EuclideanPixelMap <TPixel>(this.Configuration, result);
}
else
{
this.pixelMap.Clear(result);
}
this.palette = result;
}
public void Indexer(int bufferCapacity, int rx, int ry, int x, int y)
{
this.memoryAllocator.BufferCapacityInBytes = sizeof(int) * bufferCapacity;
using Buffer2D <int> buffer = this.CreateTestBuffer(20, 30);
var r = new Rectangle(rx, ry, 5, 6);
Buffer2DRegion <int> region = buffer.GetRegion(r);
int value = region[x, y];
int expected = ((ry + y) * 100) + rx + x;
Assert.Equal(expected, value);
}
public void GetSubArea()
{
using Buffer2D <int> buffer = this.CreateTestBuffer(20, 30);
Buffer2DRegion <int> area0 = buffer.GetRegion(6, 8, 10, 10);
Buffer2DRegion <int> area1 = area0.GetSubRegion(4, 4, 5, 5);
var expectedRect = new Rectangle(10, 12, 5, 5);
Assert.Equal(buffer, area1.Buffer);
Assert.Equal(expectedRect, area1.Rectangle);
int value00 = (12 * 100) + 10;
Assert.Equal(value00, area1[0, 0]);
}
public ResizeWorker(
Configuration configuration,
Buffer2DRegion <TPixel> source,
PixelConversionModifiers conversionModifiers,
ResizeKernelMap horizontalKernelMap,
ResizeKernelMap verticalKernelMap,
int destWidth,
Rectangle targetWorkingRect,
Point targetOrigin)
{
this.configuration = configuration;
this.source = source;
this.sourceRectangle = source.Rectangle;
this.conversionModifiers = conversionModifiers;
this.horizontalKernelMap = horizontalKernelMap;
this.verticalKernelMap = verticalKernelMap;
this.destWidth = destWidth;
this.targetWorkingRect = targetWorkingRect;
this.targetOrigin = targetOrigin;
this.windowBandHeight = verticalKernelMap.MaxDiameter;
// We need to make sure the working buffer is contiguous:
int workingBufferLimitHintInBytes = Math.Min(
configuration.WorkingBufferSizeHintInBytes,
configuration.MemoryAllocator.GetBufferCapacityInBytes());
int numberOfWindowBands = ResizeHelper.CalculateResizeWorkerHeightInWindowBands(
this.windowBandHeight,
destWidth,
workingBufferLimitHintInBytes);
this.workerHeight = Math.Min(this.sourceRectangle.Height, numberOfWindowBands * this.windowBandHeight);
this.transposedFirstPassBuffer = configuration.MemoryAllocator.Allocate2D <Vector4>(
this.workerHeight,
destWidth,
preferContiguosImageBuffers: true,
options: AllocationOptions.Clean);
this.tempRowBuffer = configuration.MemoryAllocator.Allocate <Vector4>(this.sourceRectangle.Width);
this.tempColumnBuffer = configuration.MemoryAllocator.Allocate <Vector4>(destWidth);
this.currentWindow = new RowInterval(0, this.workerHeight);
}
public void Copy1x1Scale()
{
Block8x8F block = CreateRandomFloatBlock(0, 100);
using (Buffer2D <float> buffer = Configuration.Default.MemoryAllocator.Allocate2D <float>(20, 20, AllocationOptions.Clean))
{
Buffer2DRegion <float> region = buffer.GetRegion(5, 10, 8, 8);
block.Copy1x1Scale(ref region.GetReferenceToOrigin(), region.Stride);
Assert.Equal(block[0, 0], buffer[5, 10]);
Assert.Equal(block[1, 0], buffer[6, 10]);
Assert.Equal(block[0, 1], buffer[5, 11]);
Assert.Equal(block[0, 7], buffer[5, 17]);
Assert.Equal(block[63], buffer[12, 17]);
VerifyAllZeroOutsideSubArea(buffer, 5, 10);
}
}
public void GetRowSpan(int bufferCapacity, int rx, int ry, int y, int w, int h)
{
this.memoryAllocator.BufferCapacityInBytes = sizeof(int) * bufferCapacity;
using Buffer2D <int> buffer = this.CreateTestBuffer(20, 30);
var r = new Rectangle(rx, ry, w, h);
Buffer2DRegion <int> region = buffer.GetRegion(r);
Span <int> span = region.GetRowSpan(y);
Assert.Equal(w, span.Length);
for (int i = 0; i < w; i++)
{
int expected = ((ry + y) * 100) + rx + i;
int value = span[i];
Assert.Equal(expected, value);
}
}
public void Setup()
{
this.buffer = Configuration.Default.MemoryAllocator.Allocate2D <float>(1000, 500);
this.destRegion = this.buffer.GetRegion(200, 100, 128, 128);
}
public void AddPaletteColors(Buffer2DRegion <TPixel> pixelRegion)
{
}
