/// <summary>
/// Initializes a new instance of the <see cref="ImageFrameMetaData"/> class
/// by making a copy from other metadata.
/// </summary>
/// <param name="other">
/// The other <see cref="ImageFrameMetaData"/> to create this instance from.
/// </param>
internal ImageFrameMetaData(ImageFrameMetaData other)
{
DebugGuard.NotNull(other, nameof(other));
this.FrameDelay = other.FrameDelay;
this.DisposalMethod = other.DisposalMethod;
}
public UnmanagedBuffer(int lengthInElements, UnmanagedBufferLifetimeGuard lifetimeGuard)
{
DebugGuard.NotNull(lifetimeGuard, nameof(lifetimeGuard));
this.lengthInElements = lengthInElements;
this.lifetimeGuard = lifetimeGuard;
}
internal bool TryGetPaddedRowSpan(int y, int padding, out Span <T> paddedSpan)
{
DebugGuard.MustBeGreaterThanOrEqualTo(y, 0, nameof(y));
DebugGuard.MustBeLessThan(y, this.Height, nameof(y));
int stride = this.Width + padding;
if (this.cachedMemory.Length > 0)
{
paddedSpan = this.cachedMemory.Span.Slice(y * this.Width);
if (paddedSpan.Length < stride)
{
return(false);
}
paddedSpan = paddedSpan.Slice(0, stride);
return(true);
}
Memory <T> memory = this.FastMemoryGroup.GetRemainingSliceOfBuffer(y * (long)this.Width);
if (memory.Length < stride)
{
paddedSpan = default;
return(false);
}
paddedSpan = memory.Span.Slice(0, stride);
return(true);
}
/// <summary>
/// Initializes a new instance of the <see cref="TiffCcittCompressor" /> class.
/// </summary>
/// <param name="output">The output.</param>
/// <param name="allocator">The allocator.</param>
/// <param name="width">The width.</param>
/// <param name="bitsPerPixel">The bits per pixel.</param>
protected TiffCcittCompressor(Stream output, MemoryAllocator allocator, int width, int bitsPerPixel)
: base(output, allocator, width, bitsPerPixel)
{
DebugGuard.IsTrue(bitsPerPixel == 1, nameof(bitsPerPixel), "CCITT compression requires one bit per pixel");
this.bytePosition = 0;
this.bitPosition = 0;
}
public static unsafe void Copy <T>(Span <T> source, Span <T> destination, int count)
where T : struct
{
DebugGuard.MustBeLessThanOrEqualTo(count, source.Length, nameof(count));
DebugGuard.MustBeLessThanOrEqualTo(count, destination.Length, nameof(count));
ref byte srcRef = ref Unsafe.As <T, byte>(ref MemoryMarshal.GetReference(source));
/// <summary>
/// Initializes a new instance of the <see cref="RowInterval"/> struct.
/// </summary>
public RowInterval(int min, int max)
{
DebugGuard.MustBeLessThan(min, max, nameof(min));
this.Min = min;
this.Max = max;
}
public T ParseValue <T>(string value, CultureInfo culture)
{
DebugGuard.NotNull(culture, nameof(culture));
Type type = typeof(T);
ICommandConverter converter = Array.Find(this.converters, x => x.Type.Equals(type));
if (converter != null)
{
return(((ICommandConverter <T>)converter).ConvertFrom(
this,
culture,
WebUtility.UrlDecode(value),
type));
}
// This special case allows us to reuse the same converter for infinite enum types
// if one has not already been configured.
if (type.IsEnum)
{
converter = Array.Find(this.converters, x => x.Type.Equals(typeof(Enum)));
if (converter != null)
{
return((T)((ICommandConverter <object>)converter).ConvertFrom(
this,
culture,
WebUtility.UrlDecode(value),
type));
}
}
// We don't actually return here.
// The compiler just cannot see our exception.
ThrowNotSupported(type);
return(default);
public void NotNull_TargetNull_ThrowsException()
{
Assert.Throws <ArgumentNullException>(() =>
{
DebugGuard.NotNull((object)null, "myParamName");
});
}
public virtual void Write(TiffBaseCompressor compressor, int rowsPerStrip)
{
DebugGuard.IsTrue(this.BytesPerRow == compressor.BytesPerRow, "bytes per row of the compressor does not match tiff color writer");
int stripsCount = (this.Image.Height + rowsPerStrip - 1) / rowsPerStrip;
uint[] stripOffsets = new uint[stripsCount];
uint[] stripByteCounts = new uint[stripsCount];
int stripIndex = 0;
compressor.Initialize(rowsPerStrip);
for (int y = 0; y < this.Image.Height; y += rowsPerStrip)
{
long offset = compressor.Output.Position;
int height = Math.Min(rowsPerStrip, this.Image.Height - y);
this.EncodeStrip(y, height, compressor);
long endOffset = compressor.Output.Position;
stripOffsets[stripIndex] = (uint)offset;
stripByteCounts[stripIndex] = (uint)(endOffset - offset);
stripIndex++;
}
DebugGuard.IsTrue(stripIndex == stripsCount, "stripIndex and stripsCount should match");
this.AddStripTags(rowsPerStrip, stripOffsets, stripByteCounts);
}
public CieLuv Convert(CieXyz input)
{
DebugGuard.NotNull(input, nameof(input));
// Conversion algorithm described here: http://www.brucelindbloom.com/index.html?Eqn_XYZ_to_Luv.html
float yr = input.Y / this.LuvWhitePoint.Y;
float up = ComputeUp(input);
float vp = ComputeVp(input);
float upr = ComputeUp(this.LuvWhitePoint);
float vpr = ComputeVp(this.LuvWhitePoint);
float l = yr > CieConstants.Epsilon ? ((116 * MathF.Pow(yr, 0.3333333F)) - 16F) : (CieConstants.Kappa * yr);
if (float.IsNaN(l) || l < 0)
{
l = 0;
}
float u = 13 * l * (up - upr);
float v = 13 * l * (vp - vpr);
if (float.IsNaN(u))
{
u = 0;
}
if (float.IsNaN(v))
{
v = 0;
}
return(new CieLuv(l, u, v, this.LuvWhitePoint));
}
/// <summary>
/// TODO: Does not work with multi-buffer groups, should be specific to Resize.
/// Copy <paramref name="columnCount"/> columns of <paramref name="buffer"/> inplace,
/// from positions starting at <paramref name="sourceIndex"/> to positions at <paramref name="destIndex"/>.
/// </summary>
internal static unsafe void CopyColumns <T>(
this Buffer2D <T> buffer,
int sourceIndex,
int destIndex,
int columnCount)
where T : struct
{
DebugGuard.NotNull(buffer, nameof(buffer));
DebugGuard.MustBeGreaterThanOrEqualTo(sourceIndex, 0, nameof(sourceIndex));
DebugGuard.MustBeGreaterThanOrEqualTo(destIndex, 0, nameof(sourceIndex));
CheckColumnRegionsDoNotOverlap(buffer, sourceIndex, destIndex, columnCount);
int elementSize = Unsafe.SizeOf <T>();
int width = buffer.Width * elementSize;
int sOffset = sourceIndex * elementSize;
int dOffset = destIndex * elementSize;
long count = columnCount * elementSize;
Span <byte> span = MemoryMarshal.AsBytes(buffer.GetSingleMemory().Span);
fixed(byte *ptr = span)
{
byte *basePtr = ptr;
for (int y = 0; y < buffer.Height; y++)
{
byte *sPtr = basePtr + sOffset;
byte *dPtr = basePtr + dOffset;
Buffer.MemoryCopy(sPtr, dPtr, count, count);
basePtr += width;
}
}
}
public HunterLab Convert(CieXyz input)
{
DebugGuard.NotNull(input, nameof(input));
// Conversion algorithm described here: http://en.wikipedia.org/wiki/Lab_color_space#Hunter_Lab
float x = input.X, y = input.Y, z = input.Z;
float xn = this.HunterLabWhitePoint.X, yn = this.HunterLabWhitePoint.Y, zn = this.HunterLabWhitePoint.Z;
float ka = ComputeKa(this.HunterLabWhitePoint);
float kb = ComputeKb(this.HunterLabWhitePoint);
float l = 100 * MathF.Sqrt(y / yn);
float a = ka * (((x / xn) - (y / yn)) / MathF.Sqrt(y / yn));
float b = kb * (((y / yn) - (z / zn)) / MathF.Sqrt(y / yn));
if (float.IsNaN(a))
{
a = 0;
}
if (float.IsNaN(b))
{
b = 0;
}
return(new HunterLab(l, a, b, this.HunterLabWhitePoint));
}
#pragma warning restore SA1600 // ElementsMustBeDocumented
/// <summary>
/// Get/Set scalar elements at a given index
/// </summary>
/// <param name="idx">The index</param>
/// <returns>The float value at the specified index</returns>
public float this[int idx]
{
[MethodImpl(MethodImplOptions.AggressiveInlining)]
get
{
DebugGuard.MustBeBetweenOrEqualTo(idx, 0, Size - 1, nameof(idx));
ref float selfRef = ref Unsafe.As <Block8x8F, float>(ref this);
public Rgb Convert(Hsl input)
{
DebugGuard.NotNull(input, nameof(input));
float rangedH = input.H / 360F;
float r = 0;
float g = 0;
float b = 0;
float s = input.S;
float l = input.L;
if (MathF.Abs(l) > Constants.Epsilon)
{
if (MathF.Abs(s) < Constants.Epsilon)
{
r = g = b = l;
}
else
{
float temp2 = (l < .5F) ? l * (1F + s) : l + s - (l * s);
float temp1 = (2F * l) - temp2;
r = GetColorComponent(temp1, temp2, rangedH + 0.3333333F);
g = GetColorComponent(temp1, temp2, rangedH);
b = GetColorComponent(temp1, temp2, rangedH - 0.3333333F);
}
}
return(new Rgb(r, g, b));
}
public BasicArrayBuffer(T[] array, int length, TestMemoryAllocator allocator)
{
this.allocator = allocator;
DebugGuard.MustBeLessThanOrEqualTo(length, array.Length, nameof(length));
this.Array = array;
this.Length = length;
}
public static unsafe void Copy <T>(Span <T> source, Span <T> destination, int count)
where T : struct
{
DebugGuard.MustBeLessThanOrEqualTo(count, source.Length, nameof(count));
DebugGuard.MustBeLessThanOrEqualTo(count, destination.Length, nameof(count));
ref byte srcRef = ref Unsafe.As <T, byte>(ref source.DangerousGetPinnableReference());
/// <summary>
/// Applies the opactiy weighting for each pixel in a scanline to the target based on the pattern contained in the brush.
/// </summary>
/// <param name="scanlineBuffer">The a collection of opacity values between 0 and 1 to be merged with the brushed color value before being applied to the target.</param>
/// <param name="scanlineWidth">The number of pixels effected by this scanline.</param>
/// <param name="offset">The offset fromthe begining of <paramref name="scanlineBuffer" /> the opacity data starts.</param>
/// <param name="x">The x position in the target pixel space that the start of the scanline data corresponds to.</param>
/// <param name="y">The y position in the target pixel space that whole scanline corresponds to.</param>
/// <remarks>scanlineBuffer will be > scanlineWidth but provide and offset in case we want to share a larger buffer across runs.</remarks>
internal virtual void Apply(float[] scanlineBuffer, int scanlineWidth, int offset, int x, int y)
{
DebugGuard.MustBeGreaterThanOrEqualTo(scanlineBuffer.Length, offset + scanlineWidth, nameof(scanlineWidth));
using (Buffer <float> buffer = new Buffer <float>(scanlineBuffer))
{
BufferSpan <float> slice = buffer.Slice(offset);
for (int xPos = 0; xPos < scanlineWidth; xPos++)
{
int targetX = xPos + x;
int targetY = y;
float opacity = slice[xPos];
if (opacity > Constants.Epsilon)
{
Vector4 backgroundVector = this.Target[targetX, targetY].ToVector4();
Vector4 sourceVector = this[targetX, targetY].ToVector4();
Vector4 finalColor = Vector4BlendTransforms.PremultipliedLerp(backgroundVector, sourceVector, opacity);
TPixel packed = default(TPixel);
packed.PackFromVector4(finalColor);
this.Target[targetX, targetY] = packed;
}
}
}
}
/// <summary>
/// Initializes a new instance of the <see cref="ImageProperty"/> class
/// by making a copy from another property.
/// </summary>
/// <param name="other">
/// The other <see cref="ImageProperty"/> to create this instance from.
/// </param>
internal ImageProperty(ImageProperty other)
{
DebugGuard.NotNull(other, nameof(other));
this.Name = other.Name;
this.Value = other.Value;
}
public TiffPaletteWriter(
ImageFrame <TPixel> image,
IQuantizer quantizer,
MemoryAllocator memoryAllocator,
Configuration configuration,
TiffEncoderEntriesCollector entriesCollector,
int bitsPerPixel)
: base(image, memoryAllocator, configuration, entriesCollector)
{
DebugGuard.NotNull(quantizer, nameof(quantizer));
DebugGuard.NotNull(configuration, nameof(configuration));
DebugGuard.NotNull(entriesCollector, nameof(entriesCollector));
DebugGuard.MustBeBetweenOrEqualTo(bitsPerPixel, 4, 8, nameof(bitsPerPixel));
this.BitsPerPixel = bitsPerPixel;
this.maxColors = this.BitsPerPixel == 4 ? 16 : 256;
this.colorPaletteSize = this.maxColors * 3;
this.colorPaletteBytes = this.colorPaletteSize * 2;
using IQuantizer <TPixel> frameQuantizer = quantizer.CreatePixelSpecificQuantizer <TPixel>(this.Configuration, new QuantizerOptions()
{
MaxColors = this.maxColors
});
this.quantizedImage = frameQuantizer.BuildPaletteAndQuantizeFrame(image, image.Bounds());
this.AddColorMapTag();
}
public static TiffBasePlanarColorDecoder <TPixel> CreatePlanar(
TiffColorType colorType,
TiffBitsPerSample bitsPerSample,
ushort[] colorMap,
Rational[] referenceBlackAndWhite,
Rational[] ycbcrCoefficients,
ushort[] ycbcrSubSampling,
ByteOrder byteOrder)
{
switch (colorType)
{
case TiffColorType.Rgb888Planar:
DebugGuard.IsTrue(colorMap == null, "colorMap");
return(new RgbPlanarTiffColor <TPixel>(bitsPerSample));
case TiffColorType.YCbCrPlanar:
return(new YCbCrPlanarTiffColor <TPixel>(referenceBlackAndWhite, ycbcrCoefficients, ycbcrSubSampling));
case TiffColorType.Rgb161616Planar:
DebugGuard.IsTrue(colorMap == null, "colorMap");
return(new Rgb16PlanarTiffColor <TPixel>(byteOrder == ByteOrder.BigEndian));
case TiffColorType.Rgb242424Planar:
DebugGuard.IsTrue(colorMap == null, "colorMap");
return(new Rgb24PlanarTiffColor <TPixel>(byteOrder == ByteOrder.BigEndian));
case TiffColorType.Rgb323232Planar:
DebugGuard.IsTrue(colorMap == null, "colorMap");
return(new Rgb32PlanarTiffColor <TPixel>(byteOrder == ByteOrder.BigEndian));
default:
throw TiffThrowHelper.InvalidColorType(colorType.ToString());
}
}
public static void InterpolateA(LdrColorA c0, LdrColorA c1, int wa, int waprec, LdrColorA outt)
{
DebugGuard.MustBeBetweenOrEqualTo(waprec, 2, 4, nameof(waprec));
int[] aWeights;
switch (waprec)
{
case 2:
{
aWeights = Constants.Weights2;
Debug.Assert(wa < 4, "wc is expected to be smaller then 4");
break;
}
case 3:
{
aWeights = Constants.Weights3;
Debug.Assert(wa < 8, "wc is expected to be smaller then 8");
break;
}
case 4:
{
aWeights = Constants.Weights4;
Debug.Assert(wa < 16, "wc is expected to be smaller then 16");
break;
}
default:
outt.A = 0;
return;
}
outt.A = (byte)(((c0.A * (uint)(Constants.BC67_WEIGHT_MAX - aWeights[wa])) + (c1.A * (uint)aWeights[wa]) + Constants.BC67_WEIGHT_ROUND) >> Constants.BC67_WEIGHT_SHIFT);
}
public CieXyz Convert(CieLab input)
{
DebugGuard.NotNull(input, nameof(input));
// Conversion algorithm described here: http://www.brucelindbloom.com/index.html?Eqn_Lab_to_XYZ.html
float l = input.L, a = input.A, b = input.B;
float fy = (l + 16) / 116F;
float fx = (a / 500F) + fy;
float fz = fy - (b / 200F);
float fx3 = MathF.Pow(fx, 3F);
float fz3 = MathF.Pow(fz, 3F);
float xr = fx3 > CieConstants.Epsilon ? fx3 : ((116F * fx) - 16F) / CieConstants.Kappa;
float yr = l > CieConstants.Kappa * CieConstants.Epsilon ? MathF.Pow((l + 16F) / 116F, 3F) : l / CieConstants.Kappa;
float zr = fz3 > CieConstants.Epsilon ? fz3 : ((116F * fz) - 16F) / CieConstants.Kappa;
float wx = input.WhitePoint.X, wy = input.WhitePoint.Y, wz = input.WhitePoint.Z;
// Avoids XYZ coordinates out range (restricted by 0 and XYZ reference white)
xr = xr.Clamp(0, 1F);
yr = yr.Clamp(0, 1F);
zr = zr.Clamp(0, 1F);
float x = xr * wx;
float y = yr * wy;
float z = zr * wz;
return(new CieXyz(x, y, z));
}
private static void RunApplication([NotNull] Container container)
{
DebugGuard.NotNull(container, nameof(container));
try
{
using (AsyncScopedLifestyle.BeginScope(container))
{
var app = container.GetInstance <Application>();
var mainWindow = container.GetInstance <MainWindow>();
void MainWindowOnClosed(object sender, EventArgs e)
{
mainWindow.Closed -= MainWindowOnClosed;
app.Shutdown(0);
}
// not sure if this is the way to do this.
mainWindow.Closed += MainWindowOnClosed;
app.Run(mainWindow);
}
}
// ReSharper disable once RedundantCatchClause
catch
{
// Log the exception and exit
#if DEBUG
throw;
#endif
}
}
public DataCapturedArgs([NotNull] string key, [NotNull] string data)
{
DebugGuard.NotNullOrWhiteSpace(key, nameof(key));
DebugGuard.NotNull(data, nameof(data)); // can be empty
Key = key;
Data = data;
}
/// <inheritdoc/>
public CieXyz Convert(LinearRgb input)
{
DebugGuard.IsTrue(input.WorkingSpace.Equals(this.SourceWorkingSpace), nameof(input.WorkingSpace), "Input and source working spaces must be equal.");
Vector3 vector = Vector3.Transform(input.Vector, this.conversionMatrix);
return(new CieXyz(vector));
}
private static void RegisterPlugins([NotNull] Container container)
{
DebugGuard.NotNull(container, nameof(container));
var pluginAssemblies = PluginFinder.FindPluginAssemblies(Path.Combine(AppDomain.CurrentDomain.BaseDirectory));
container.RegisterPackages(pluginAssemblies);
}
public void MustBeGreaterThanOrEqualTo_IsLess_ThrowsNoException()
{
ArgumentOutOfRangeException exception = Assert.Throws <ArgumentOutOfRangeException>(
() => DebugGuard.MustBeGreaterThanOrEqualTo(1, 2, "myParamName"));
Assert.Equal("myParamName", exception.ParamName);
Assert.Contains($"Value 1 must be greater than or equal to 2.", exception.Message);
}
public void MustBeSizedAtLeast_Array_LengthIsLess_ThrowsException()
{
ArgumentException exception = Assert.Throws <ArgumentException>(
() => DebugGuard.MustBeSizedAtLeast <int>(new int[] { 1, 2 }, 3, "myParamName"));
Assert.Equal("myParamName", exception.ParamName);
Assert.Contains($"The size must be at least 3.", exception.Message);
}
protected override void CheckPreconditions()
{
DebugGuard.Requires(this.Model.Schema.Title == "Article");
DebugGuard.Requires(this.OutputType == ViewOutputType.Html);
DebugGuard.Requires(this.EnableOutputDecoration);
DebugGuard.Requires(this.EnableOutputValidation);
DebugGuard.Requires(this.Parent == null);
}
public void MustBeGreaterThan_IsLessOrEqual_ThrowsNoException(int value, int min)
{
ArgumentOutOfRangeException exception = Assert.Throws <ArgumentOutOfRangeException>(
() => DebugGuard.MustBeGreaterThan(value, min, "myParamName"));
Assert.Equal("myParamName", exception.ParamName);
Assert.Contains($"Value {value} must be greater than {min}.", exception.Message);
}
